Unity使用官方sdk实现微信、QQ、微博三方登录（Android）

https://i-blog.csdnimg.cn/blog_migrate/d6a671a27a737e8283e3ca0504412251.png

由于微博更新了sdk，关闭了网络请求的接口，后来微博登录的时候一直显示系统错误，微博更新sdk以后不再是jar提供使用，改成了aar提供使用，区别不是很大，修改一下你的gradle，在dependices里面加上

compile(name: 'openDefault-2.0.3', ext: 'aar')，上面还要加一个repositories。

然后应用一下，吧这个aar的包拷到你的libs目录下就可以了。

[plain]  view plain  copy

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调用的微博登录函数

[java]  view plain  copy

1. //微博登录  
2.    public void WBLogin()  
3.    {  
4.      // wbTools.WBLogin();  
5.        Log.i("微博","点到微博登录了");  
6.        startActivity(new Intent(this, WBAuthActivity.class));  
7.   
8.    }  

WBAuthActivity脚本代码：

[java]  view plain  copy

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.         mSsoHandler = new SsoHandler(WBAuthActivity.this);  
18.   
19.   
20.         // SSO 授权, 仅客户端  
21.   
22.         mSsoHandler.authorizeClientSso(new SelfWbAuthListener());  
23.   
24.         Log.i("发起授权成功","授权成功");  
25.         // 从 SharedPreferences 中读取上次已保存好 AccessToken 等信息，  
26.         // 第一次启动本应用，AccessToken 不可用  
27.         mAccessToken = com.sina.weibo.sdk.auth.AccessTokenKeeper.readAccessToken(this);  
28.         Log.i("发起授权成功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.         Log.i("data1111",Integer.toString(requestCode));  
40.         if(resultCode== Activity.RESULT_CANCELED)  
41.         {  
42.             System.out.println("用户取消了33333");  
43.            finish();  
44.         }  
45.         // SSO 授权回调  
46.         // 重要：发起 SSO 登陆的 Activity 必须重写 onActivityResults  
47.         if (mSsoHandler != null) {  
48.             Log.i("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.             WBAuthActivity.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.                         Map m=new HashMap();  
67.                         m.put("access_token",mAccessToken.getToken());  
68.                         m.put("uid",mAccessToken.getUid());  
69.                         com.sina.weibo.sdk.auth.AccessTokenKeeper.writeAccessToken(WBAuthActivity.this, mAccessToken);  
70.                         UnityPlayer.UnitySendMessage("ThirdLoginGameobject","WeiboCallBack", JSON.toJSONString(m));  
71.                         Log.i("accesstoken",JSON.toJSONString(m));  
72.                         finish();  
73.                     }  
74.                 }  
75.             });  
76.         }  
77.   
78.         @Override  
79.         public void cancel() {  
80.             Log.i("取消授权","取消授权成功");  
81.         }  
82.   
83.         @Override  
84.         public void onFailure(WbConnectErrorMessage errorMessage) {  
85.             Toast.makeText(WBAuthActivity.this, errorMessage.getErrorMessage(), Toast.LENGTH_LONG).show();  
86.         }  
87.     }  
88. }  

最后改一下你的Mainfest文件，之前关于微博的权限全部删掉，加上

[html]  view plain  copy

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)，以确保每次打开应用时用户都是有登录态的。

[csharp]  view plain  copy

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.         mTencent = Tencent.createInstance("你的APPID", this.getApplicationContext());  
9.     }  
10.     
11.     /** 
12.      * qq登录代码  Unity里调用 
13.      */  
14.     public void QQlogin() {  
15.         //登录代码。。。  
16.             if (!mTencent.isSessionValid())  
17.             {  
18.                 mTencent.login(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;  

[csharp]  view plain  copy

1. //把请求到的参数传给unity  
2.             UnityPlayer.UnitySendMessage("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的代码如下：

[csharp]  view plain  copy

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.         MyApplication.sApi.handleIntent(getIntent(), 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.      Toast.makeText(context.getApplicationContext(), "app_id 不能为空", Toast.LENGTH_SHORT).show();  
27.      }  
28.      IWXAPI api = WXAPIFactory.createWXAPI(context, weixin_app_id, 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.         SendAuth.Req req = new SendAuth.Req();  
46.         // 应用的作用域，获取个人信息  
47.         req.scope = "snsapi_userinfo";  
48.         /** 
49.          * 用于保持请求和回调的状态，授权请求后原样带回给第三方 
50.          * 为了防止csrf攻击（跨站请求伪造攻击），后期改为随机数加session来校验 
51.          */  
52.         req.state = "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中添加如下代码：

[csharp]  view plain  copy

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.       WXEntryActivity.loginWeixin(MainActivity.this, MyApplication.sApi, new WXEntryActivity.WeChatCode() {  
8.           @Override  
9.           public void getResponse(String code) {  
10.               // 通过code获取授权口令access_token  
11.               getAccessToken(code);  
12.               Log.i("获取token成功",code.toString());  
13.               // 从手机本地获取存储的授权口令信息，判断是否存在access_token，不存在请求获取，存在就判断是否过期  
14.               String accessToken = (String) ShareUtils.getValue(MainActivity.this, WEIXIN_ACCESS_TOKEN_KEY,  
15.                       "none");  
16.               String openid = (String) ShareUtils.getValue(MainActivity.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.                   Log.i("获取token成功",code.toString());  
24.               }  
25.           }  
26.       });  
27.       Log.i("登录成功","aaaaaaaaaaaaaaaaaaaaaaaaaa");  
28.   
29.   }  
30.   
31. /** 
32.    * 微信登录获取授权口令 
33.    */  
34.   private void getAccessToken(String code) {  
35.       String url = "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.       OkHttpUtils.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.       String errFlag = "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.       String url = "https://api.weixin.qq.com/sns/auth?" +  
108.               "access_token=" + accessToken +  
109.               "&openid=" + openid;  
110.       OkHttpUtils.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);  

[csharp]  view plain  copy

1.                //把请求到的数据传递到unity  
2.                 UnityPlayer.UnitySendMessage("与安卓交互的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.     final String refreshToken = (String) ShareUtils.getValue(this, WEIXIN_REFRESH_TOKEN_KEY,  
19.             "");  
20.     if (TextUtils.isEmpty(refreshToken)) {  
21.         return;  
22.     }  
23.     // 拼装刷新access_token的url请求地址  
24.     String url = "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.     OkHttpUtils.get().url(url).build().execute(new StringCallback() {  
30.         @Override  
31.         public void onError(Call call, Exception e, int id) {  
32.             System.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.     String url = "https://api.weixin.qq.com/sns/userinfo?" +  
52.             "access_token=" + access_token +  
53.             "&openid=" + openid;  
54.     OkHttpUtils.get().url(url).build().execute(new StringCallback() {  
55.         @Override  
56.         public void onError(Call call, Exception e, int id) {  
57.             System.out.println("联网获取用户信息失败！！！");  
58.         }  
59.   
60.         @Override  
61.         public void onResponse(String response, int id) {  
62.             // 解析获取的用户信息  
63.            // WXUserInfo userInfo = mGson.fromJson(response, WXUserInfo.class);  
64.             System.out.println("获取用户信息String是：：：：：："+response);  
65.   
66.         }  
67.     });  
68. }  

我写了一个类来存APPID和SECRET

新建一个MyApplication类来初始化微信登录和网络请求

[csharp]  view plain  copy

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.         mContext=this;  
8.         //初始化微信  
9.         sApi = WXEntryActivity.initWeiXin(this, AppConst.WEIXIN_APP_ID);  
10.         initOkHttp();  
11.     }  
12.     //封装okhttp框架的初始化配置  
13.     private void initOkHttp() {  
14.         HttpsUtils.SSLParams sslParams = HttpsUtils.getSslSocketFactory(null, null, null);  
15.         CookieJarImpl cookieJar = new CookieJarImpl(new PersistentCookieStore(getApplicationContext()));  
16.         OkHttpClient okHttpClient = new OkHttpClient.Builder()  
17.                 .addInterceptor(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文件也要导入

这里只讲客户端授权。

从官方demo中复制AccessTokenKeeper这个类到你的工程中。写一个Constance类来存APPKEY

把这三个类也从官方的demo中复制过来，下面我贴上我删减后的代码

[csharp]  view plain  copy

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.         mAuthInfo = new AuthInfo(this, Constants.APP_KEY, Constants.REDIRECT_URL, Constants.SCOPE);  
20.         mSsoHandler = new SsoHandler(WBAuthActivity.this, mAuthInfo);  
21.         // SSO 授权, 仅客户端  
22.         WBLogin();  
23.         // 从 SharedPreferences 中读取上次已保存好 AccessToken 等信息，  
24.         // 第一次启动本应用，AccessToken 不可用  
25.         mAccessToken = AccessTokenKeeper.readAccessToken(this);  
26.         if (mAccessToken.isSessionValid()) {  
27.             updateTokenView(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.     mSsoHandler.authorizeClientSso(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.             UnityPlayer.UnitySendMessage("ThirdLoginGameobject","WeiboCallBack",values.toString());  
67.             //从这里获取用户输入的 电话号码信息   
68.           //  String phoneNum =  mAccessToken.getUid();  
69.             if (mAccessToken.isSessionValid()) {  
70.                 // 显示 Token  
71.                 updateTokenView(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. }  

[csharp]  view plain  copy

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.         mAuthInfo = 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.             String code = values.getString("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.         WeiboParameters requestParams = 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.         requestParams.put(WBConstants.AUTH_PARAMS_GRANT_TYPE,    "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.                     String date = 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里加上微博登录代码

[csharp]  view plain  copy

1. //微博登录  Unity里调用  
2.     public void WBLogin()  
3.     {  
4.         startActivity(new Intent(MainActivity.this, WBAuthActivity.class));  
5.     }  

mainfest里加上

即可。

把MainActivity里的代码整合到一起后，build

把libs里的classes.jar删掉，把红框圈起来的classes.jar拖到libs文件夹里，然后把libs，res和AndroidMainfest这三个文件拖到Unity工程的Plugins/Android文件夹下。

然后在unity创建三个按钮并添加点击事件

[csharp]  view plain  copy

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.     AndroidJavaClass jc = new AndroidJavaClass("com.unity3d.player.UnityPlayer");  
7.     AndroidJavaObject jo = jc.GetStatic<AndroidJavaObject>("currentActivity");  
8.     jo.Call("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.     AndroidJavaClass jc = new AndroidJavaClass("com.unity3d.player.UnityPlayer");  
18.     AndroidJavaObject jo = jc.GetStatic<AndroidJavaObject>("currentActivity");  
19.     jo.Call("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.     AndroidJavaClass jc = new AndroidJavaClass("com.unity3d.player.UnityPlayer");  
29.     AndroidJavaObject jo = jc.GetStatic<AndroidJavaObject>("currentActivity");  
30.     jo.Call("WBLogin");  
31.     #endif  
32.          
33.    }  

发布安卓应用的时候记得签名，不然微信和微博登录会报错。

demo脚本和jar包下载地址点击打开链接