由于微博更新了sdk，关闭了网络请求的接口，后来微博登录的时候一直显示系统错误，微博更新sdk以后不再是jar提供使用，改成了aar提供使用，区别不是很大，修改一下你的gradle，在dependices里面加上
compile(name: 'openDefault-2.0.3', ext: 'aar')，上面还要加一个repositories。
然后应用一下，吧这个aar的包拷到你的libs目录下就可以了。
1. repositories{
2. flatDir {
3. dirs 'libs'
4. }
5. }
6. dependencies {
7. compile fileTree(include: ['*.jar'], dir: 'libs')
8. androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
9. exclude group: 'com.android.support', module: 'support-annotations'
10. })
11. compile 'com.android.support:appcompat-v7:25.0.1'
12. compile 'com.android.support:support-v4:25.3.1'
13. testCompile 'junit:junit:4.12'
14. compile files('libs/libammsdk.jar')
15. compile files('libs/classes.jar')
16. // compile files('libs/weiboSDKCore_3.1.4.jar')
17. compile files('libs/mta-sdk-1.6.2.jar')
18. compile files('libs/open_sdk_r5756.jar')
19. compile files('libs/Sunflower.jar')
20. compile files('libs/okhttputils-2_6_2.jar')
21. compile files('libs/okhttp-3.3.1.jar')
22. compile files('libs/okio-1.8.0.jar')
23. compile files('libs/commons-beanutils-1.8.0.jar')
24. compile files('libs/fastjson-1.1.41.jar')
25. compile files('libs/unitynotification.jar')
26. compile files('libs/gson-2.8.0.jar')
27. compile files('libs/unityutil.jar')
28. compile(name: 'openDefault-2.0.3', ext: 'aar')
29. // compile(name: 'PushSDK-debug', ext: 'aar')
30.
31. }
然后在你的mainactivity里的oncreate函数里注册一下微博：
WbSdk.install(this,new AuthInfo(this, Constants.APP_KEY, Constants.REDIRECT_URL, Constants.SCOPE));
把之前的WBTools这个脚本删掉，新建一个WBAuthActivity脚本，或者把新下载的微博sdk Demo里的这个脚本拷过来。
android供unity调用的微博登录函数
1. //微博登录
2. public void WBLogin()
3. {
4. // wbTools.WBLogin();
5. "微博","点到微博登录了");
6. new Intent(this, WBAuthActivity.class));
7.
8. }
WBAuthActivity脚本代码：
1. public class WBAuthActivity extends Activity {
2.
3. private static final String TAG = "weibosdk";
4. /** 显示认证后的信息，如 AccessToken */
5. private TextView mTokenText;
6. /** 封装了 "access_token"，"expires_in"，"refresh_token"，并提供了他们的管理功能 */
7. private Oauth2AccessToken mAccessToken;
8. /** 注意：SsoHandler 仅当 SDK 支持 SSO 时有效 */
9. private SsoHandler mSsoHandler;
10. /**
11. * @see {@link Activity#onCreate}
12. */
13. @Override
14. public void onCreate(Bundle savedInstanceState) {
15. super.onCreate(savedInstanceState);
16. // 创建微博实例
17. new SsoHandler(WBAuthActivity.this);
18.
19.
20. // SSO 授权, 仅客户端
21.
22. new SelfWbAuthListener());
23.
24. "发起授权成功","授权成功");
25. // 从 SharedPreferences 中读取上次已保存好 AccessToken 等信息，
26. // 第一次启动本应用，AccessToken 不可用
27. this);
28. "发起授权成功11111111","授权成功");
29. }
30.
31. /**
32. * 当 SSO 授权 Activity 退出时，该函数被调用。
33. *
34. * @see {@link Activity#onActivityResult}
35. */
36. @Override
37. protected void onActivityResult(int requestCode, int resultCode, Intent data) {
38. super.onActivityResult(requestCode, resultCode, data);
39. "data1111",Integer.toString(requestCode));
40. if(resultCode== Activity.RESULT_CANCELED)
41. {
42. "用户取消了33333");
43. finish();
44. }
45. // SSO 授权回调
46. // 重要：发起 SSO 登陆的 Activity 必须重写 onActivityResults
47. if (mSsoHandler != null) {
48. "sso回调","毁掉成功");
49. mSsoHandler.authorizeCallBack(requestCode, resultCode, data);
50. }
51.
52. }
53.
54.
55. private class SelfWbAuthListener implements com.sina.weibo.sdk.auth.WbAuthListener{
56. @Override
57. public void onSuccess(final Oauth2AccessToken token) {
58. this.runOnUiThread(new Runnable() {
59. @Override
60. public void run() {
61. mAccessToken = token;
62. if (mAccessToken.isSessionValid()) {
63. // 显示 Token
64. // updateTokenView(false);
65. // 保存 Token 到 SharedPreferences
66. new HashMap();
67. "access_token",mAccessToken.getToken());
68. "uid",mAccessToken.getUid());
69. this, mAccessToken);
70. "ThirdLoginGameobject","WeiboCallBack", JSON.toJSONString(m));
71. "accesstoken",JSON.toJSONString(m));
72. finish();
73. }
74. }
75. });
76. }
77.
78. @Override
79. public void cancel() {
80. "取消授权","取消授权成功");
81. }
82.
83. @Override
84. public void onFailure(WbConnectErrorMessage errorMessage) {
85. this, errorMessage.getErrorMessage(), Toast.LENGTH_LONG).show();
86. }
87. }
88. }
最后改一下你的Mainfest文件，之前关于微博的权限全部删掉，加上
1. <!-- 授权认证 -->
2. <activity android:name=".WBAuthActivity" />
3. <!--<activity android:name=".WBAuthCodeActivity" />-->
4. <!--<activity android:name=".WBShareMainActivity" />-->
5. <meta-data
6. android:name="WEIBO_APPKEY"
7. android:value="你申请的微博的APPKEY" />
8. <meta-data
9. android:name="WEIBO_CHANNEL"
10. android:value="weibo" />
---------------------------------------------------------微博登录更新结束------------------------------------------------------------------------------------------------------------------------------------------------------
对于一个不懂安卓不会java的新手程序，实现安卓三方登录开始是 一头雾水，不知道从哪下手，通过自己摸索加上多方求助终于完成了。为了自己巩固一下以及一些像我一样的新手走弯路，把详细过程记录下来。
第一次写文章，写的有点乱，希望能帮助到大家。
我使用的是android studio2.2.2版本开发。
一、新建安卓工程并导入jar文件
注意写好自己的包名，微信登录和微博登录都要用到包名获取签名，把获取到的签名上传到开放平台。
填好包名后一直点next就可以了，点击finish完成创建。
创建完成后，新建一个module类，同样写好自己的包名。
到这里准备工作就做好了。
二、QQ登录
QQ登录时最简单的一个，因为不需要签名。在qq开放平台下载好sdk，然后copy到libs文件夹下。
点击Add as Library就可以了，微信和微博的jar包导入也是一样，Unity的classes.jar也需要导入，后面就不赘述了。
通过调用Tencent类的login函数发起登录/校验登录态。
该API具有两个作用：
（1）如果开发者没有调用mTencent实例的setOpenId、setAccessToken API，则该API执行正常的登录操作；
（2）如果开发者先调用mTencent实例的setOpenId、setAccessToken API，则该API执行校验登录态的操作。如果登录态有效，则返回成功给应用，如果登录态失效，则会自动进入登录流程，将最新的登录态数据返回给应用。
建议开发者在每次应用启动时调用一次该API(先调用setOpenId、setAccessToken)，以确保每次打开应用时用户都是有登录态的。
1. public class MainActivity extends UnityPlayerActivity {
2. private Tencent mTencent;
3. private BaseUiListener mBaseUiListener=new BaseUiListener();
4.
5. @Override
6. protected void onCreate(Bundle savedInstanceState) {
7. super.onCreate(savedInstanceState);
8. "你的APPID", this.getApplicationContext());
9. }
10.
11. /**
12. * qq登录代码 Unity里调用
13. */
14. public void QQlogin() {
15. //登录代码。。。
16. if (!mTencent.isSessionValid())
17. {
18. this, "", mBaseUiListener);
19. }
20.
21. }
22.
23. /**
24. * qq请求回调
25. */
26. private class BaseUiListener implements IUiListener {
27.
28. @Override
29. public void onComplete(Object o) {
30. JSONObject response=(JSONObject)o;
1. //把请求到的参数传给unity
2. "ThirdLoginGameobject","QQCallBack",o.toString());
3. }
4.
5. @Override
6. public void onError(UiError uiError) {
7. }
8.
9. @Override
10. public void onCancel() {
11.
12. }
13. }
14.
15. /**
16. * qq登录页面返回处理
17. * @param requestCode
18. * @param resultCode
19. * @param data
20. */
21. @Override
22. protected void onActivityResult(int requestCode, int resultCode, Intent data) {
23. Tencent.onActivityResultData(requestCode,resultCode,data,mBaseUiListener);
24. }
然后再mainfest里配置权限。
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<application>
<activity
android:name="com.tencent.tauth.AuthActivity"
android:noHistory="true"
android:launchMode="singleTask" >
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="tencent你的AppId" />
</intent-filter>
</activity>
<application>
SDK_V2.0引入了AssistActivity，开发者需在androidManifest.xml中注册。代码如下：
<activity android:name="com.tencent.connect.common.AssistActivity"
android:theme="@android:style/Theme.Translucent.NoTitleBar"
android:configChanges="orientation|keyboardHidden|screenSize"
/>
现在就可以成功拉起QQ授权页面并登陆了。
三、微信登录
新建一个名为wxapi的包和WXEntryActivity的类。
WXEntryActivity的代码如下：
1. public class WXEntryActivity extends Activity implements IWXAPIEventHandler {
2. private static final String WEIXIN_ACCESS_TOKEN_KEY = "wx_access_token_key";
3. private static final String WEIXIN_OPENID_KEY = "wx_openid_key";
4. private static final String WEIXIN_REFRESH_TOKEN_KEY = "wx_refresh_token_key";
5. public static WeChatCode mWeChatCode;
6.
7. public WeChatCode getWeChatCode() {
8. return mWeChatCode;
9. }
10.
11. public void setWeChatCode(WeChatCode weChatCode) {
12. mWeChatCode = weChatCode;
13. }
14.
15. @Override
16. public void onCreate(Bundle savedInstanceState) {
17. super.onCreate(savedInstanceState);
18. // 微信事件回调接口注册
19. this);
20. }
21.
22. //微信组件注册初始化
23.
24. public static IWXAPI initWeiXin(Context context, @NonNull String weixin_app_id) {
25. if (TextUtils.isEmpty(weixin_app_id)) {
26. "app_id 不能为空", Toast.LENGTH_SHORT).show();
27. }
28. true);
29. api.registerApp(weixin_app_id);
30. return api;
31. }
32.
33. /**
34. * 登录微信
35. */
36. public static void loginWeixin(Context context, IWXAPI api, WeChatCode wechatCode) {
37. // 判断是否安装了微信客户端
38. // if (!api.isWXAppInstalled()) {
39. // Toast.makeText(context.getApplicationContext(), "您还未安装微信客户端！", Toast.LENGTH_SHORT)
40. // .show();
41. // return;
42. // }
43. mWeChatCode=wechatCode;
44. // 发送授权登录信息，来获取code
45. new SendAuth.Req();
46. // 应用的作用域，获取个人信息
47. "snsapi_userinfo";
48. /**
49. * 用于保持请求和回调的状态，授权请求后原样带回给第三方
50. * 为了防止csrf攻击（跨站请求伪造攻击），后期改为随机数加session来校验
51. */
52. "app_wechat";
53. api.sendReq(req);
54. }
55.
56. // 微信发送请求到第三方应用时，会回调到该方法
57. @Override
58. public void onReq(BaseReq req) {
59. switch (req.getType()) {
60. case ConstantsAPI.COMMAND_GETMESSAGE_FROM_WX:
61. break;
62. case ConstantsAPI.COMMAND_SHOWMESSAGE_FROM_WX:
63. break;
64. default:
65. break;
66. }
67. }
68.
69. // 第三方应用发送到微信的请求处理后的响应结果，会回调到该方法
70. @Override
71. public void onResp(BaseResp resp) {
72. switch (resp.errCode) {
73. // 发送成功
74. case BaseResp.ErrCode.ERR_OK:
75. // 获取code
76. String code = ((SendAuth.Resp) resp).code;
77. mWeChatCode.getResponse(code);
78. break;
79. }
80. }
81.
82. /**
83. * 返回code的回调接口
84. */
85. public interface WeChatCode {
86. void getResponse(String code);
87. }
88. }
MainActivity中添加如下代码：
1. private static final String WEIXIN_ACCESS_TOKEN_KEY = "wx_access_token_key";
2. private static final String WEIXIN_OPENID_KEY = "wx_openid_key";
3. private static final String WEIXIN_REFRESH_TOKEN_KEY = "wx_refresh_token_key";
4.
5. 微信登录 unity中调用该方法
6. public void weiLogin() {
7. this, MyApplication.sApi, new WXEntryActivity.WeChatCode() {
8. @Override
9. public void getResponse(String code) {
10. // 通过code获取授权口令access_token
11. getAccessToken(code);
12. "获取token成功",code.toString());
13. // 从手机本地获取存储的授权口令信息，判断是否存在access_token，不存在请求获取，存在就判断是否过期
14. this, WEIXIN_ACCESS_TOKEN_KEY,
15. "none");
16. this, WEIXIN_OPENID_KEY, "");
17. if (!"none".equals(accessToken)) {
18. // 有access_token，判断是否过期有效
19. isExpireAccessToken(accessToken, openid);
20. else {
21. // 没有access_token
22. getAccessToken(code);
23. "获取token成功",code.toString());
24. }
25. }
26. });
27. "登录成功","aaaaaaaaaaaaaaaaaaaaaaaaaa");
28.
29. }
30.
31. /**
32. * 微信登录获取授权口令
33. */
34. private void getAccessToken(String code) {
35. "https://api.weixin.qq.com/sns/oauth2/access_token?" +
36. "appid=" + AppConst.WEIXIN_APP_ID +
37. "&secret=" + AppConst.WEIXIN_APP_SECRET +
38. "&code=" + code +
39. "&grant_type=authorization_code";
40. // 网络请求获取access_token
41. get().url(url).build().execute(new StringCallback() {
42. @Override
43. public void onError(Call call, Exception e, int id) {
44. e.printStackTrace();
45. }
46.
47. @Override
48. public void onResponse(String response, int id) {
49. // 判断是否获取成功，成功则去获取用户信息，否则提示失败
50. processGetAccessTokenResult(response);
51. }
52. });
53.
54. }
55.
56. /**
57. * 微信登录处理获取的授权信息结果
58. *
59. * @param response 授权信息结果
60. */
61. public void processGetAccessTokenResult(String response) {
62. // 验证获取授权口令返回的信息是否成功
63. if (validateSuccess(response)) {
64. // 使用Gson解析返回的授权口令信息
65. // WXAccessTokenInfo tokenInfo = mGson.fromJson(response, WXAccessTokenInfo.class);
66. // 保存信息到手机本地
67. // saveAccessInfotoLocation(tokenInfo);
68. // 获取用户信息
69. // getUserInfo(tokenInfo.getAccess_token(), tokenInfo.getOpenid());
70. else {
71. // 授权口令获取失败，解析返回错误信息
72. // WXErrorInfo wxErrorInfo = mGson.fromJson(response, WXErrorInfo.class);
73.
74. }
75. }
76.
77. /**
78. *微信登录获取tokenInfo的WEIXIN_OPENID_KEY，WEIXIN_ACCESS_TOKEN_KEY，WEIXIN_REFRESH_TOKEN_KEY保存到shareprephence中
79. * @param tokenInfo
80. */
81. private void saveAccessInfotoLocation(WXAccessTokenInfo tokenInfo) {
82. ShareUtils.saveValue(MyApplication.mContext,WEIXIN_OPENID_KEY,tokenInfo.getOpenid());
83. ShareUtils.saveValue(MyApplication.mContext,WEIXIN_ACCESS_TOKEN_KEY,tokenInfo.getAccess_token());
84. ShareUtils.saveValue(MyApplication.mContext,WEIXIN_REFRESH_TOKEN_KEY,tokenInfo.getRefresh_token());
85. }
86.
87. /**
88. * 验证是否成功
89. *
90. * @param response 返回消息
91. * @return 是否成功
92. */
93. private boolean validateSuccess(String response) {
94. "errmsg";
95. return (errFlag.contains(response) && !"ok".equals(response))
96. "errcode".contains(response) && !errFlag.contains(response));
97. }
98.
99.
100. /**
101. * 微信登录判断accesstoken是过期
102. *
103. * @param accessToken token
104. * @param openid 授权用户唯一标识
105. */
106. private void isExpireAccessToken(final String accessToken, final String openid) {
107. "https://api.weixin.qq.com/sns/auth?" +
108. "access_token=" + accessToken +
109. "&openid=" + openid;
110. get().url(url).build().execute(new StringCallback() {
111. @Override
112. public void onError(Call call, Exception e, int id) {
113.
114. }
115.
116. @Override
117. public void onResponse(String response, int id) {
118. if (validateSuccess(response)) {
119. // accessToken没有过期，获取用户信息
120. getUserInfo(accessToken, openid);
1. //把请求到的数据传递到unity
2. "与安卓交互的C#脚本挂载的物体名","函数名",response.toString());
3. Toast.makeText(getApplicationContext(),response.toString(),Toast.LENGTH_LONG).show();
4.
5. else {
6. // 过期了，使用refresh_token来刷新accesstoken
7. refreshAccessToken();
8. }
9. }
10. });
11.
12. }
13. /**
14. * 微信登录刷新获取新的access_token
15. */
16. private void refreshAccessToken() {
17. // 从本地获取以存储的refresh_token
18. this, WEIXIN_REFRESH_TOKEN_KEY,
19. "");
20. if (TextUtils.isEmpty(refreshToken)) {
21. return;
22. }
23. // 拼装刷新access_token的url请求地址
24. "https://api.weixin.qq.com/sns/oauth2/refresh_token?" +
25. "appid=" + AppConst.WEIXIN_APP_ID +
26. "&grant_type=refresh_token" +
27. "&refresh_token=" + refreshToken;
28. // 请求执行
29. get().url(url).build().execute(new StringCallback() {
30. @Override
31. public void onError(Call call, Exception e, int id) {
32. out.println("刷新获取新的access_token信息失败！！！");
33. // 重新请求授权
34. weiLogin();
35. }
36.
37. @Override
38. public void onResponse(String response, int id) {
39. // 判断是否获取成功，成功则去获取用户信息，否则提示失败
40. processGetAccessTokenResult(response);
41. }
42. });
43.
44. }
45. /**
46. * 微信token验证成功后，联网获取用户信息
47. * @param access_token
48. * @param openid
49. */
50. private void getUserInfo(String access_token, String openid) {
51. "https://api.weixin.qq.com/sns/userinfo?" +
52. "access_token=" + access_token +
53. "&openid=" + openid;
54. get().url(url).build().execute(new StringCallback() {
55. @Override
56. public void onError(Call call, Exception e, int id) {
57. out.println("联网获取用户信息失败！！！");
58. }
59.
60. @Override
61. public void onResponse(String response, int id) {
62. // 解析获取的用户信息
63. // WXUserInfo userInfo = mGson.fromJson(response, WXUserInfo.class);
64. out.println("获取用户信息String是：：：：：："+response);
65.
66. }
67. });
68. }
我写了一个类来存APPID和SECRET
MyApplication类来初始化微信登录和网络请求
1. public class MyApplication extends Application {
2. public static IWXAPI sApi;
3. public static Context mContext;
4. @Override
5. public void onCreate() {
6. super.onCreate();
7. this;
8. //初始化微信
9. this, AppConst.WEIXIN_APP_ID);
10. initOkHttp();
11. }
12. //封装okhttp框架的初始化配置
13. private void initOkHttp() {
14. null, null, null);
15. new CookieJarImpl(new PersistentCookieStore(getApplicationContext()));
16. new OkHttpClient.Builder()
17. new LoggerInterceptor("TAG"))
18. .cookieJar(cookieJar)
19. .connectTimeout(20000L, TimeUnit.MILLISECONDS)
20. .readTimeout(20000L,TimeUnit.MILLISECONDS)
21. .writeTimeout(20000L,TimeUnit.MILLISECONDS)
22. .sslSocketFactory(sslParams.sSLSocketFactory, sslParams.trustManager)
23. //其他配置
24. .build();
25. OkHttpUtils.initClient(okHttpClient);
26. }
27. }
mainfest里初始化MyApplication
只要填写正确的APPID以及签名正确，就可以拉起微信登录页面了。
四、微博登录
微博登录不光要导入jar包，libs里面的.so文件也要导入
这里只讲客户端授权。
AccessTokenKeeper这个类到你的工程中。写一个Constance类来存APPKEY
把这三个类也从官方的demo中复制过来，下面我贴上我删减后的代码
1. public class WBAuthActivity extends Activity {
2.
3. private static final String TAG = "weibosdk";
4.
5. private AuthInfo mAuthInfo;
6.
7. /** 封装了 "access_token"，"expires_in"，"refresh_token"，并提供了他们的管理功能 */
8. private Oauth2AccessToken mAccessToken;
9.
10. /** 注意：SsoHandler 仅当 SDK 支持 SSO 时有效 */
11. private SsoHandler mSsoHandler;
12.
13. /**
14. * @see {@link Activity#onCreate}
15. */
16. @Override
17. public void onCreate(Bundle savedInstanceState) {
18. super.onCreate(savedInstanceState);
19. new AuthInfo(this, Constants.APP_KEY, Constants.REDIRECT_URL, Constants.SCOPE);
20. new SsoHandler(WBAuthActivity.this, mAuthInfo);
21. // SSO 授权, 仅客户端
22. WBLogin();
23. // 从 SharedPreferences 中读取上次已保存好 AccessToken 等信息，
24. // 第一次启动本应用，AccessToken 不可用
25. this);
26. if (mAccessToken.isSessionValid()) {
27. true);
28. }
29. }
30.
31. /**
32. * 当 SSO 授权 Activity 退出时，该函数被调用。
33. *
34. * @see {@link Activity#onActivityResult}
35. */
36. @Override
37. protected void onActivityResult(int requestCode, int resultCode, Intent data) {
38. super.onActivityResult(requestCode, resultCode, data);
39.
40. // SSO 授权回调
41. // 重要：发起 SSO 登陆的 Activity 必须重写 onActivityResults
42. // ++++++++++++++++++
43. //如果是sso授权登陆，必须先执行下面的回调，然后才会执行监听器里的 回调
44. if (mSsoHandler != null) {
45. mSsoHandler.authorizeCallBack(requestCode, resultCode, data);
46. }
47.
48. }
49. private void WBLogin()
50. {
51. new AuthListener());
52. }
53. /**
54. * 微博认证授权回调类。
55. * 1. SSO 授权时，需要在 {@link #onActivityResult} 中调用 {@link SsoHandler#authorizeCallBack} 后，
56. * 该回调才会被执行。
57. * 2. 非 SSO 授权时，当授权结束后，该回调就会被执行。
58. * 当授权成功后，请保存该 access_token、expires_in、uid 等信息到 SharedPreferences 中。
59. */
60. class AuthListener implements WeiboAuthListener {
61.
62. @Override
63. public void onComplete(Bundle values) {
64. // 从 Bundle 中解析 Token
65. mAccessToken = Oauth2AccessToken.parseAccessToken(values);
66. "ThirdLoginGameobject","WeiboCallBack",values.toString());
67. //从这里获取用户输入的 电话号码信息
68. // String phoneNum = mAccessToken.getUid();
69. if (mAccessToken.isSessionValid()) {
70. // 显示 Token
71. false);
72.
73. else {
74. // 以下几种情况，您不会收到 Code：
75. // 1. 当您未在平台上注册的应用程序的包名与签名时；
76. // 2. 当您注册的应用程序包名与签名不正确时；
77. // 3. 当您在平台上注册的包名和签名与您当前测试的应用的包名和签名不匹配时。
78. }
79. }
80.
81. @Override
82. public void onCancel() {
83.
84. }
85.
86. @Override
87. public void onWeiboException(WeiboException e) {
88.
89. }
90. }
91.
92. /**
93. * 显示当前 Token 信息。
94. *
95. * @param hasExisted 配置文件中是否已存在 token 信息并且合法
96. */
97. private void updateTokenView(boolean hasExisted) {
98.
99. }
100. }
1. public class WBAuthCodeActivity extends Activity {
2.
3. private static final String TAG = "WBAuthCodeActivity";
4.
5. /**
6. * WeiboSDKDemo 程序的 APP_SECRET。
7. * 请注意：请务必妥善保管好自己的 APP_SECRET，不要直接暴露在程序中，此处仅作为一个DEMO来演示。
8. */
9.
10. /** 通过 code 获取 Token 的 URL */
11. private static final String OAUTH2_ACCESS_TOKEN_URL = "https://open.weibo.cn/oauth2/access_token";
12.
13. /** 微博 Web 授权接口类，提供登陆等功能 */
14. private AuthInfo mAuthInfo;
15. /** 获取到的 Code */
16. private String mCode;
17. /** 获取到的 Token */
18. private Oauth2AccessToken mAccessToken;
19.
20. /**
21. * @see {@link Activity#onCreate}
22. */
23. @Override
24. public void onCreate(Bundle savedInstanceState) {
25. super.onCreate(savedInstanceState);
26. // setContentView(R.layout.activity_auth_code);
27.
28. // 初始化微博对象
29. new AuthInfo(this, Constants.APP_KEY, Constants.REDIRECT_URL, Constants.SCOPE);
30. }
31.
32. /**
33. * 微博认证授权回调类。
34. */
35. class AuthListener implements WeiboAuthListener {
36.
37. @Override
38. public void onComplete(Bundle values) {
39. if (null == values) {
40. return;
41. }
42. "code");
43. if (TextUtils.isEmpty(code)) {
44. return;
45. }
46. mCode = code;
47. }
48.
49. @Override
50. public void onCancel() {
51.
52. }
53.
54. @Override
55. public void onWeiboException(WeiboException e) {
56.
57. }
58. }
59.
60. /**
61. * 异步获取 Token。
62. *
63. * @param authCode 授权 Code，该 Code 是一次性的，只能被获取一次 Token
64. * @param appSecret 应用程序的 APP_SECRET，请务必妥善保管好自己的 APP_SECRET，
65. * 不要直接暴露在程序中，此处仅作为一个DEMO来演示。
66. */
67. public void fetchTokenAsync(String authCode, String appSecret) {
68.
69. new WeiboParameters(Constants.APP_KEY);
70. requestParams.put(WBConstants.AUTH_PARAMS_CLIENT_ID, Constants.APP_KEY);
71. requestParams.put(WBConstants.AUTH_PARAMS_CLIENT_SECRET, appSecret);
72. "authorization_code");
73. requestParams.put(WBConstants.AUTH_PARAMS_CODE, authCode);
74. requestParams.put(WBConstants.AUTH_PARAMS_REDIRECT_URL, Constants.REDIRECT_URL);
75.
76. // 异步请求，获取 Token
77. new AsyncWeiboRunner(getApplicationContext()).requestAsync(OAUTH2_ACCESS_TOKEN_URL, requestParams, "POST", new RequestListener() {
78. @Override
79. public void onComplete(String response) {
80.
81. // 获取 Token 成功
82. Oauth2AccessToken token = Oauth2AccessToken.parseAccessToken(response);
83. if (token != null && token.isSessionValid()) {
84.
85. mAccessToken = token;
86. new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(
87. new java.util.Date(mAccessToken.getExpiresTime()));
88. String format = token.toString();
89. else {
90.
91. }
92. }
93.
94. @Override
95. public void onWeiboException(WeiboException e) {
96.
97. }
98. });
99. }
100. }
WBShareMainActivity继承Activity为空即可。在MainActivity的onCreate里写上LogUtil.sIsLogEnable = true;
MainActivity里加上微博登录代码
1. //微博登录 Unity里调用
2. public void WBLogin()
3. {
4. new Intent(MainActivity.this, WBAuthActivity.class));
5. }
mainfest里加上
即可。
把MainActivity里的代码整合到一起后，build
把libs里的classes.jar删掉，把红框圈起来的classes.jar拖到libs文件夹里，然后把libs，res和AndroidMainfest这三个文件拖到Unity工程的Plugins/Android文件夹下。
然后在unity创建三个按钮并添加点击事件
1. public void OnQQBtnClick(ButtonScript obj, object args, object param1, object param2)
2. {
3. #if UNITY_IPHONE
4. c_thirdQQLogin();
5. #elif UNITY_ANDROID
6. new AndroidJavaClass("com.unity3d.player.UnityPlayer");
7. "currentActivity");
8. "QQlogin");
9. #endif
10. }
11.
12. public void OnWeChatBtnClick(ButtonScript obj, object args, object param1, object param2)
13. {
14. #if UNITY_IPHONE
15. c_thirdLogin();
16. #elif UNITY_ANDROID
17. new AndroidJavaClass("com.unity3d.player.UnityPlayer");
18. "currentActivity");
19. "weiLogin");
20. #endif
21. }
22.
23. public void OnWeiboBtnClick(ButtonScript obj, object args, object param1, object param2)
24. {
25. #if UNITY_IPHONE
26. c_thirdWeiboLogin();
27. #elif UNITY_ANDROID
28. new AndroidJavaClass("com.unity3d.player.UnityPlayer");
29. "currentActivity");
30. "WBLogin");
31. #endif
32.
33. }
发布安卓应用的时候记得签名，不然微信和微博登录会报错。
demo脚本和jar包下载地址点击打开链接
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
