第三方登录分享

效果图

1、登录

2、分享

微博

新浪微博Android SDK为开发者提供了Oauth 2.0授权认证，并集成SSO登录功能，使第三方应用无需了解复杂的验证机制即可进行授权登录操作，同时也提供了微博分享功能，第三方应用可直接通过微博客户端进行分享操作。

集成准备

1、申请APP_KEY

第三方应用如果需要接入微博SDK就必须在微博开放平台上对应用进行注册，并获取APP_KEY，同时添加应用的授权回调页REDIRECT_URL。

2、注册应用包名和签名

集成SDK之前需要在微博开放平台上注册应用的包名和签名。

注意：包名和签名未注册或者编译运行时的签名和注册签名不一致都可能导致无法授权(debug运行apk和发布时的apk)。

集成方式

在项目根目录的build.gradle中设置中央仓库。

buildscript {
    repositories {
        jcenter()
        maven { url "https://dl.bintray.com/thelasterstar/maven/" }
    }
}

allprojects {
    repositories {
        jcenter()
        maven { url "https://dl.bintray.com/thelasterstar/maven/" }
    }
}

在项目module目录的build.gradle中引入sdk-core依赖。

dependencies {
    compile 'com.sina.weibo.sdk:core:2.0.3:openDefaultRelease@aar'
}

授权

1、初始化WbSdk对象（在应用的Application中或者调用SDK功能代码前）

WbSdk.install(this, new AuthInfo(this, Constants.APP_KEY, Constants.REDIRECT_URL, Constants.SCOPE));

AuthInfo维护了授权需要的基本信息，APP_KEY（开发平台生成的唯一key）、REDIRECT_URL（授权回调）、SCOPE（需要请求的权限功能）。

2、初始化SsoHandler对象

mSsoHandler = new SsoHandler(this);

SsoHandler是发起授权的核心类。

3、调用授权

SDK中有三种模式的授权方案：

模式一：AuthorizeClientSso：仅客户端，通过微博客户端进行授权。

模式二：AuthorizeWeb：仅Web，通过SDK自带的WebView打开H5页面进行授权。

模式三：Authorize：ALL IN ONE，如果手机安装了微博客户端则通过客户端授权，反之则通过Web网页方式授权。

// SSO 授权, 仅客户端
mSsoHandler.authorizeClientSso(new SelfWbAuthListener());

// SSO 授权, 仅Web
mSsoHandler.authorizeWeb(new SelfWbAuthListener());

// SSO 授权, ALL IN ONE, 如果手机安装了微博客户端则使用客户端授权，没有则进行网页授权
mSsoHandler.authorize(new SelfWbAuthListener());

4、调用授权回调

SelfWbAuthListener：授权结果回调，实现WbAuthListener接口。

public interface WbAuthListener {
    void onSuccess(Oauth2AccessToken var1);

    void cancel();

    void onFailure(WbConnectErrorMessage var1);
}

onSuccess：授权成功回调，返回Oauth2AccessToken对象，封装了登录相关信息。

onFailure：授权失败回调。

cancel：授权取消回调。

注意：要接收到授权的相关数据，必须在当前页面Activity或者Fragment的onActivityResult方法中添加SSOHandler的调用。

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    // 发起SSO登录的Activity必须重写onActivityResult
    if (mSsoHandler != null) {
        mSsoHandler.authorizeCallBack(requestCode, resultCode, data);
    }
}

5、获取用户信息

/**
 * 获取用户信息
 */
public void getUserInfo(String access_token, String uid) {
    String url = "https://api.weibo.com/2/users/show.json?"
            + "access_token="
            + access_token
            + "&uid="
            + uid;

    new RxVolley.Builder()
            .url(url)
            .httpMethod(RxVolley.Method.GET)
            .callback(new HttpCallback() {
                @Override
                public void onSuccess(String t) {
                    super.onSuccess(t);
                    JSONObject jsonObject;
                    try {
                        stringBuilder = new StringBuilder();
                        jsonObject = new JSONObject(t);
                        String screen_name = jsonObject.getString("screen_name");
                        String gender = jsonObject.getString("gender");
                        String avatar_large = jsonObject.getString("avatar_large");
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onFailure(int errorNo, String strMsg) {
                    super.onFailure(errorNo, strMsg);
                }
            })
            .doTask();
}

分享

1、在分享当前页的Activity中实现WbShareCallback接口

private class SelfWbShareCallback implements WbShareCallback {

    @Override
    public void onWbShareSuccess() {
        ToastUtil.showText(R.string.toast_share_success);
    }

    @Override
    public void onWbShareCancel() {
        ToastUtil.showText(R.string.toast_share_canceled);
    }

    @Override
    public void onWbShareFail() {
        ToastUtil.showText(R.string.toast_share_failed);
    }
}

WbShareCallback接口实现了分享结果的各种回调。

2、初始化WbShareHandler并注册应用

shareHandler = new WbShareHandler(this);
shareHandler.registerApp();

3、分享微博

public void sendMultiMessage(boolean hasText, boolean hasImage, int mShareType) {
    WeiboMultiMessage weiboMessage = new WeiboMultiMessage();
    if (hasText) {
        weiboMessage.textObject = getTextObj();
    }
    if (hasImage) {
        weiboMessage.imageObject = getImageObj();
    }
    weiboMessage.mediaObject = getWebpageObj();
    shareHandler.shareMessage(weiboMessage, mShareType == SHARE_CLIENT);
}

4、处理分享回调：重写onNewIntent方法

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    shareHandler.doResultIntent(intent,this);
}

微信

移动应用微信登录是基于OAuth 2.0协议标准构建的微信OAuth 2.0授权登录系统。在进行微信OAuth 2.0授权登录接入之前，需要在微信开放平台注册开发者帐号，并拥有一个已审核通过的移动应用，并获得相应的AppID和AppSecret，申请微信登录且通过审核后即可开始接入流程。

微信分享及收藏是指第三方App通过接入该功能，让用户可以从App分享文字、图片、音乐、视频、网页至微信好友会话、朋友圈或添加到微信收藏。

集成准备

1、申请AppID

登录开发者账号，在管理中心创建移动应用，填写相关信息后提交审核，只有审核通过的应用才能进行开发。

2、在应用build.gradle文件中添加依赖

dependencies {
    compile 'com.tencent.mm.opensdk:wechat-sdk-android-with-mta:+'
}

或者

dependencies {
    compile 'com.tencent.mm.opensdk:wechat-sdk-android-without-mta:+'
}

其中：前者包含统计功能。

3、添加必要的权限支持

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />

4、添加混淆配置

-keep class com.tencent.mm.opensdk.** {
   *;
}

-keep class com.tencent.wxop.** {
   *;
}

-keep class com.tencent.mm.sdk.** {
   *;
}

分享

1、初始化数据

/**
 * 初始化数据
 */
private void initWechatShare(Context context) {
    if (mWXApi == null) {
        // 通过WXAPIFactory工厂获取IWXAPI的实例
        mWXApi = WXAPIFactory.createWXAPI(context, WechatConstants.APP_ID);
    }
    // 将应用的appid注册到微信
    mWXApi.registerApp(WechatConstants.APP_ID);
}

2、通过微信分享

/**
 * 通过微信分享
 *
 * @param shareContent 分享的方式（文本、图片、链接）
 * @param shareType    分享的类型（朋友圈，会话）
 */
public void shareByWebchat(ShareContent shareContent, int shareType) {
    if (!isWebchatAvaliable()) {
        ToastUtil.showText(UIUtils.getString(R.string.please_install_wechat_client));
        return;
    }
    switch (shareContent.getShareWay()) {
        case WECHAT_SHARE_WAY_TEXT:
            shareText(shareContent, shareType);
            break;
        case WECHAT_SHARE_WAY_PICTURE:
            sharePicture(shareContent, shareType);
            break;
        case WECHAT_SHARE_WAY_WEBPAGE:
            shareWebPage(shareContent, shareType);
            break;
        case WECHAT_SHARE_WAY_VIDEO:
            shareVideo(shareContent, shareType);
            break;
    }
}

3、分享文字

/**
 * 分享文字
 */
private void shareText(ShareContent shareContent, int shareType) {
    String text = shareContent.getContent();

    // 初始化一个WXTextObject对象
    WXTextObject textObj = new WXTextObject();
    textObj.text = text;

    // 用WXTextObject对象初始化一个WXMediaMessage对象
    WXMediaMessage msg = new WXMediaMessage();
    msg.mediaObject = textObj;
    msg.description = text;

    // 构造一个Req
    SendMessageToWX.Req req = new SendMessageToWX.Req();
    // transaction字段用于唯一标识一个请求
    req.transaction = buildTransaction("text");
    req.message = msg;
    req.scene = shareType;

    // 发送数据到微信
    mWXApi.sendReq(req);
}

4、分享图片

/**
 * 分享图片
 */
private void sharePicture(ShareContent shareContent, int shareType) {
    Bitmap bmp = BitmapFactory.decodeResource(mContext.getResources(), shareContent.getPictureResource());

    // 初始化WXImageObject和WXMediaMessage对象
    WXImageObject imgObj = new WXImageObject(bmp);
    WXMediaMessage msg = new WXMediaMessage();
    msg.mediaObject = imgObj;

    // 设置缩略图
    Bitmap thumbBmp = Bitmap.createScaledBitmap(bmp, THUMB_SIZE, THUMB_SIZE, true);
    bmp.recycle();
    msg.thumbData = Util.bmpToByteArray(thumbBmp, true);

    // 构造一个Req
    SendMessageToWX.Req req = new SendMessageToWX.Req();
    req.transaction = buildTransaction("img");
    req.message = msg;
    req.scene = shareType;

    mWXApi.sendReq(req);
}

5、分享链接

/**
 * 分享链接
 */
private void shareWebPage(ShareContent shareContent, int shareType) {
    // 初始化一个WXWebpageObject对象
    WXWebpageObject webpage = new WXWebpageObject();
    webpage.webpageUrl = shareContent.getURL();

    // 用WXWebpageObject对象初始化一个WXMediaMessage对象
    WXMediaMessage msg = new WXMediaMessage(webpage);
    msg.title = shareContent.getTitle();
    msg.description = shareContent.getContent();

    Bitmap bmp = BitmapFactory.decodeResource(mContext.getResources(), shareContent.getPictureResource());
    Bitmap thumbBmp = Bitmap.createScaledBitmap(bmp, THUMB_SIZE, THUMB_SIZE, true);
    bmp.recycle();
    msg.thumbData = Util.bmpToByteArray(thumbBmp, true);

    // 打造一个Req
    SendMessageToWX.Req req = new SendMessageToWX.Req();
    req.transaction = buildTransaction("webpage");
    req.message = msg;
    req.scene = shareType;

    mWXApi.sendReq(req);
}

6、分享视频

/**
 * 分享视频
 */
private void shareVideo(ShareContent shareContent, int shareType) {
    // 初始化一个WXVideoObject对象
    WXVideoObject video = new WXVideoObject();
    video.videoUrl = shareContent.getURL();

    // 用WXVideoObject对象初始化一个WXMediaMessage对象
    WXMediaMessage msg = new WXMediaMessage(video);
    msg.title = shareContent.getTitle();
    msg.description = shareContent.getContent();
    Bitmap thumb = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.image_default);
    Bitmap thumbBitmap = Bitmap.createScaledBitmap(thumb, THUMB_SIZE, THUMB_SIZE, true);
    thumb.recycle();
    msg.thumbData = Util.bmpToByteArray(thumbBitmap, true);

    SendMessageToWX.Req req = new SendMessageToWX.Req();
    req.transaction = buildTransaction("video");
    req.message = msg;
    req.scene = shareType;

    mWXApi.sendReq(req);
}

7、shareType分享类型

public static final int WECHAT_SHARE_TYPE_SESSION = SendMessageToWX.Req.WXSceneSession;//会话
public static final int WECHAT_SHARE_TYPE_FRIENDS = SendMessageToWX.Req.WXSceneTimeline;//朋友圈
public static final int WECHAT_SHARE_TYPE_FAVORITE = SendMessageToWX.Req.WXSceneFavorite;//收藏

8、唯一标识一个请求

/**
 * 唯一标识一个请求
 */
private String buildTransaction(final String type) {
    return (type == null) ? String.valueOf(System.currentTimeMillis()) : type + System.currentTimeMillis();
}

9、检测手机上是否安装了微信

/**
 * @Description 检测手机上是否安装了微信
 */
public boolean isWebchatAvaliable() {
    try {
        mWXApi.isWXAppInstalled();
        return true;
    } catch (Exception e) {
        return false;
    }
}

监听分享结果回调

1、在应用包名相应目录下新建一个wxapi目录，并在该wxapi目录下新增一个WXEntryActivity类，该类继承自Activity。

public class WXEntryActivity extends BaseActivity { }

并在AndroidManifest.xml文件里面加上exported属性，设置为true。

<activity
    android:name=".wxapi.WXEntryActivity"
    android:exported="true"
    android:theme="@android:style/Theme.Translucent" />

2、实现IWXAPIEventHandler接口，微信发送的请求将回调到onReq方法，发送到微信请求的响应结果将回调到onResp方法。

3、在WXEntryActivity中将接收到的intent及实现了IWXAPIEventHandler接口的对象传递给IWXAPI接口的handleIntent方法。

4、微信分享回调示例

public class WXEntryActivity extends BaseActivity implements IWXAPIEventHandler {

    // 第三方app和微信通信的接口
    private IWXAPI mWXApi;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 通过WXAPIFactory工厂获取IWXAPI的实例
        mWXApi = WXAPIFactory.createWXAPI(this, WechatConstants.APP_ID);
        // 将应用的appid注册到微信
        mWXApi.registerApp(WechatConstants.APP_ID);
        // 如果分享的时候，该界面没有开启，那么微信开始这个Activity时会调用onCreate，所以这里要处理微信的返回结果。
        // 注意：第三方开发者如果使用透明界面来实现WXEntryActivity，则需要判断handleIntent的返回值。
        // 如果返回值为false，则说明入参不合法未被SDK处理，应finish当前透明界面，避免外部通过传递非法参数的Intent导致停留在透明界面，引起用户的疑惑。
        mWXApi.handleIntent(getIntent(), this);
    }

    /**
     * @Description 如果分享的时候，该界面已经开启，那么微信开始这个Activity时会调用onNewIntent，所以这里要处理微信的返回结果
     */
    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        setIntent(intent);
        mWXApi.handleIntent(intent, this);
    }

    /**
     * 微信发送请求到第三方应用时，会回调到该方法
     */
    @Override
    public void onReq(BaseReq baseReq) {

    }

    /**
     * 第三方应用发送到微信的请求处理后的响应结果，会回调到该方法
     */
    @Override
    public void onResp(BaseResp baseResp) {
        String result;
        switch (baseResp.errCode) {
            case BaseResp.ErrCode.ERR_OK://发送成功
                result = UIUtils.getString(R.string.errcode_ok);
                break;
            case BaseResp.ErrCode.ERR_USER_CANCEL://发送取消
                result = UIUtils.getString(R.string.errcode_cancel);
                break;
            case BaseResp.ErrCode.ERR_SENT_FAILED://发送失败
                result = UIUtils.getString(R.string.errcode_failed);
                break;
            case BaseResp.ErrCode.ERR_AUTH_DENIED://发送被拒绝
                result = UIUtils.getString(R.string.errcode_denied);
                break;
            case BaseResp.ErrCode.ERR_UNSUPPORT://不支持错误
                result = UIUtils.getString(R.string.errcode_unsupport);
                break;
            case BaseResp.ErrCode.ERR_COMM://一般错误
                result = UIUtils.getString(R.string.errcode_comm);
                break;
            default:
                result = UIUtils.getString(R.string.errcode_unknown);
                break;
        }

        ToastUtil.showText(result);
        this.finish();
    }
}

授权登录

微信OAuth 2.0授权登录是让微信用户使用微信身份安全登录第三方应用或网站，在微信用户授权登录已接入微信OAuth 2.0的第三方应用后，第三方可以获取到用户的接口调用凭证（access_token），通过access_token可以进行微信开放平台授权关系接口调用，从而即可实现获取微信用户基本开放信息和帮助用户实现基础开放功能等。

微信OAuth 2.0授权登录目前支持authorization_code模式，适用于拥有server端的应用授权。该模式整体流程为：

1. 第三方发起微信授权登录请求，微信用户允许授权第三方应用后，微信会拉起应用或重定向到第三方网站，并且带上授权临时票据code参数；
2. 通过code参数加上AppID和AppSecret等，通过API获取access_token；
3. 通过access_token进行接口调用，获取用户基本数据资源或帮助用户实现基本操作。

1、授权登录，请求code

/**
 * 授权登录
 */
public void loginByWebchat() {
    if (mWXApi != null && mWXApi.isWXAppInstalled()) {
        SendAuth.Req req = new SendAuth.Req();
        req.scope = "snsapi_userinfo";
        req.state = "login_state";
        mWXApi.sendReq(req);
    }
}

参数说明：
scope：应用授权作用域，如获取用户个人信息则填写snsapi_userinfo。
state：用于保持请求和回调的状态，授权请求后原样带回给第三方。

2、通过code获取access_token、openid

/**
 * 获取openid、accessToken值用于后期操作
 *
 * @param code 请求码
 */
public void getAccessToken(String code) {
    String url = "https://api.weixin.qq.com/sns/oauth2/access_token?"
            + "appid="
            + WechatConstants.APP_ID
            + "&secret="
            + WechatConstants.APP_SECRET
            + "&code="
            + code
            + "&grant_type=authorization_code";

     //网络请求：根据自己的请求方式
    new RxVolley.Builder()
            .url(url)
            .httpMethod(RxVolley.Method.GET)
            .callback(new HttpCallback() {
                @Override
                public void onSuccess(String t) {
                    super.onSuccess(t);
                    JSONObject jsonObject;
                    try {
                        jsonObject = new JSONObject(t);
                        String access_token = jsonObject.getString("access_token");
                        String expires_in = jsonObject.getString("expires_in");
                        String refresh_token = jsonObject.getString("refresh_token");
                        String openid = jsonObject.getString("openid");
                        String scope = jsonObject.getString("scope");
                        isAccessTokenValid(access_token, openid);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onFailure(int errorNo, String strMsg) {
                    super.onFailure(errorNo, strMsg);
                }
            })
            .doTask();
}

参数说明：
grant_type：填authorization_code

3、检验授权凭证（access_token）是否有效

/**
* 检验授权凭证（access_token）是否有效
 *
 * @param access_token 接口调用凭
 * @param openid       授权用户唯一标识
 */
public void isAccessTokenValid(final String access_token, final String openid) {
    String url = "https://api.weixin.qq.com/sns/auth?"
            + "access_token="
            + access_token
            + "&openid="
            + openid;

    new RxVolley.Builder()
            .url(url)
            .httpMethod(RxVolley.Method.GET)
            .callback(new HttpCallback() {
                @Override
                public void onSuccess(String t) {
                    super.onSuccess(t);
                    JSONObject jsonObject;
                    try {
                        jsonObject = new JSONObject(t);
                        int errcode = jsonObject.getInt("errcode");
                        if (errcode == 0) {
                            getUserInfo(access_token, openid);
                        }
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onFailure(int errorNo, String strMsg) {
                    super.onFailure(errorNo, strMsg);
                }
            })
            .doTask();
}

4、获取用户个人信息

/**
 * 获取用户个人信息
 *
 * @param access_token 接口调用凭
 * @param openid       授权用户唯一标识
 */
public void getUserInfo(String access_token, String openid) {
    String url = "https://api.weixin.qq.com/sns/userinfo?"
            + "access_token="
            + access_token
            + "&openid="
            + openid;

    new RxVolley.Builder()
            .url(url)
            .httpMethod(RxVolley.Method.GET)
            .callback(new HttpCallback() {
                @Override
                public void onSuccess(String t) {
                    super.onSuccess(t);
                    JSONObject jsonObject;
                    try {
                        jsonObject = new JSONObject(t);
                        String nickname = jsonObject.getString("nickname");
                        int sex = Integer.parseInt(jsonObject.getString("sex"));
                        String headimgurl = jsonObject.getString("headimgurl");
                        String unionid = jsonObject.getString("unionid");
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onFailure(int errorNo, String strMsg) {
                    super.onFailure(errorNo, strMsg);
                }
            })
            .doTask();
}

QQ

登录授权可以让用户使用QQ帐号在第三方移动应用上进行登录，分享内容、同步信息，大大降低了用户注册的门槛。成功在腾讯开发者平台创建的应用会自动授予QQ登录的权限，开发者可接入QQ登陆SDK就可以进行开发。

使用QQ登录分享功能，可以实现定向分享给指定好友，实现与QQ好友的亲密互动。

集成准备

1、申请APP_ID和APP_KEY

在腾讯开发者平台上注册应用，在审核通过后可获得APP_ID和APP_KEY。

2、下载并导入SDK的jar文件

OpenSdk从2.4版本开始，在原有接口的基础之上，提炼重要及常用接口，生成基础包。

对应包名如下：
全量包：open_sdk_r****.jar
基础包：open_sdk_r****_lite.jar

3、添加权限

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

4、配置AndroidManifest.xml

<activity
    android:name="com.tencent.tauth.AuthActivity"
    android:launchMode="singleTask"
    android:noHistory="true">
    <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******" />
    </intent-filter>
</activity>

注意：上面<data android:scheme="tencent******" />中的******要替换成自己获取到的APP_ID（假设APP_ID是123456，则替换后为<data android:scheme="tencent123456" />）。

SDK_V 2.0引入了AssistActivity，开发者也需要进行注册。

<activity
    android:name="com.tencent.connect.common.AssistActivity"
    android:configChanges="orientation|keyboardHidden|screenSize"
    android:theme="@android:style/Theme.Translucent.NoTitleBar" />

登录

1、创建实例

Tencent是SDK的功能入口，所有的接口调用都得通过Tencent进行调用。因此调用SDK，首先需要创建一个Tencent实例。

/**
 * 初始化数据
 */
private void initTencent() {
    // Tencent类是SDK的主要实现类，开发者可通过Tencent类访问腾讯开放的OpenAPI。其中APP_ID是分配给第三方应用的app_id，类型为String。
    mTencent = Tencent.createInstance(QqConstants.APP_ID, mContext.getApplicationContext());
}

2、实现回调IUiListener

/**
 * 登录授权回调
 */
private class LogInListener implements IUiListener {

    @Override
    public void onComplete(Object o) {
        ToastUtil.showText(R.string.auth_success);
    }

    @Override
    public void onError(UiError uiError) {
        ToastUtil.showText(R.string.auth_failed);
    }

    @Override
    public void onCancel() {
        ToastUtil.showText(R.string.auth_canceled);
    }
}

其中：LogInListener是IUiListener的实现类，用来接收授权后的相关信息。

3、特别注意

应用调用Andriod_SDK接口时，如果要成功接收到回调，需要在调用接口的Activity中覆写onActivityResult方法，否则接收不到回调。

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    Tencent.onActivityResultData(requestCode, resultCode, data, mListener);
}

其中：onActivityResultData接口中的mListener为当前调用的Activity所实现的相应回调IUiListener。

4、登录

/**
 * 授权登录
 */
public void login() {
    if (!mTencent.isSessionValid()) {
        mTencent.login(mActivity, "all", mListener);
    }
}

5、设置AccessToken和OpenId

@Override
public void onComplete(Object o) {
    if (null == o) {
        ToastUtil.showText(R.string.auth_failed);
        return;
    }
    JSONObject jsonObject = (JSONObject) o;
    if (jsonObject.length() == 0) {
        ToastUtil.showText(R.string.auth_failed);
        return;
    }
    // 设置AccessToken和OpenId
    initOpenidAndToken(jsonObject);
    // 获取QQ用户信息  
    getUserInfo();
    ToastUtil.showText(R.string.auth_success);
}

/**
 * 设置AccessToken和OpenId
 */
private void initOpenidAndToken(JSONObject jsonObject) {
    try {
        String access_token = jsonObject.getString(Constants.PARAM_ACCESS_TOKEN);
        String expires_in = jsonObject.getString(Constants.PARAM_EXPIRES_IN);
        String openid = jsonObject.getString(Constants.PARAM_OPEN_ID);

        if (!StringUtil.isEmpty(access_token) && !StringUtil.isEmpty(openid)) {
            mTencent.setAccessToken(access_token, expires_in);
            mTencent.setOpenId(openid);
        }
    } catch (JSONException e) {
        e.printStackTrace();
    }
}

6、获取用户信息

/**
 * 获取用户信息
 */
private void getUserInfo() {
    QQToken mQQToken = mTencent.getQQToken();
    UserInfo userInfo = new UserInfo(mActivity, mQQToken);
    userInfo.getUserInfo(new IUiListener() {
        @Override
        public void onComplete(Object o) {
            if (null == o) {
                ToastUtil.showText(R.string.get_user_info_failed);
                return;
            }
            JSONObject jsonObject = (JSONObject) o;
            if (jsonObject.length() == 0) {
                ToastUtil.showText(R.string.get_user_info_failed);
                return;
            }
            try {
                String gender = jsonObject.getString("gender");
                String nickname = jsonObject.getString("nickname");
                String figureurl = jsonObject.getString("figureurl");
                LogUtil.e("gender-->" + gender + "  nickname-->" + nickname + "  figureurl-->" + figureurl);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onError(UiError uiError) {
            ToastUtil.showText(R.string.get_user_info_failed);
        }

        @Override
        public void onCancel() {
            ToastUtil.showText(R.string.get_user_info_canceled);
        }
    });
}

7、注销

/**
 * 注销
 */
public void logout() {
    mTencent.logout(mActivity);
}

分享

1、在分享当前页的Activity中实现IUiListener接口

private class ShareListener implements IUiListener {

    @Override
    public void onComplete(Object o) {
        if (null == o) {
            ToastUtil.showText(R.string.share_failed);
            return;
        }
        JSONObject jsonObject = (JSONObject) o;
        if (jsonObject.length() == 0) {
            ToastUtil.showText(R.string.share_failed);
            return;
        }
        ToastUtil.showText(R.string.share_success);
    }

    @Override
    public void onError(UiError uiError) {
        ToastUtil.showText(R.string.share_failed);
    }

    @Override
    public void onCancel() {
        ToastUtil.showText(R.string.share_canceled);
    }
}

IUiListener接口实现了分享结果的各种回调。

2、初始化Tencent

private void initQqShare() {
    // Tencent类是SDK的主要实现类，开发者可通过Tencent类访问腾讯开放的OpenAPI。其中APP_ID是分配给第三方应用的app_id，类型为String。
    mTencent = Tencent.createInstance(QqConstants.APP_ID, mActivity);
    mListener = new ShareListener();
}

3、重写onActivityResult方法，确保能接收到回调信息

public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == Constants.REQUEST_QZONE_SHARE || requestCode == Constants.REQUEST_QQ_SHARE) {
        Tencent.onActivityResultData(requestCode, resultCode, data, mListener);
    }
}

4、分享图文消息（QQ）

public void shareToQqImageText(String title, String targetUrl, String summary, String imageUrl, String appName, int extInt) {
    final Bundle params = new Bundle();
    // 必填：分享的类型
    params.putInt(QQShare.SHARE_TO_QQ_KEY_TYPE, QQShare.SHARE_TO_QQ_TYPE_DEFAULT);
    // 必填：分享的标题，最长30个字符
    params.putString(QQShare.SHARE_TO_QQ_TITLE, title);
    // 必填：分享消息被好友点击后的跳转URL
    params.putString(QQShare.SHARE_TO_QQ_TARGET_URL, targetUrl);
    // 可选：分享的消息摘要，最长40个字
    params.putString(QQShare.SHARE_TO_QQ_SUMMARY, summary);
    // 可选：分享图片的URL或者本地路径
    params.putString(QQShare.SHARE_TO_QQ_IMAGE_URL, imageUrl);
    // 可选：手Q客户端顶部替换“返回”按钮文字，如果为空则用“返回”代替
    params.putString(QQShare.SHARE_TO_QQ_APP_NAME, appName);
    // 可选：分享额外选项，有两种类型可选（默认是不隐藏分享到QZone按钮且不自动打开分享到QZone的对话框）。
    // QQShare.SHARE_TO_QQ_FLAG_QZONE_AUTO_OPEN，分享时自动打开分享到QZone的对话框。
    // QQShare.SHARE_TO_QQ_FLAG_QZONE_ITEM_HIDE，分享时隐藏分享到QZone按钮。
    params.putInt(QQShare.SHARE_TO_QQ_EXT_INT, extInt);
    mTencent.shareToQQ(mActivity, params, mListener);
}

5、分享纯图片（QQ）

public void shareToQqImage(String imageLocalUrl, String appName, int extInt) {
    Bundle params = new Bundle();
    // 必填：分享的类型
    params.putInt(QQShare.SHARE_TO_QQ_KEY_TYPE, QQShare.SHARE_TO_QQ_TYPE_IMAGE);
    // 必填：分享的本地图片路径
    params.putString(QQShare.SHARE_TO_QQ_IMAGE_LOCAL_URL, imageLocalUrl);
    // 可选：手Q客户端顶部替换“返回”按钮文字，如果为空则用“返回”代替
    params.putString(QQShare.SHARE_TO_QQ_APP_NAME, appName);
    // 可选：分享额外选项，有两种类型可选（默认是不隐藏分享到QZone按钮且不自动打开分享到QZone的对话框）。
    // QQShare.SHARE_TO_QQ_FLAG_QZONE_AUTO_OPEN，分享时自动打开分享到QZone的对话框。
    // QQShare.SHARE_TO_QQ_FLAG_QZONE_ITEM_HIDE，分享时隐藏分享到QZone按钮。
    params.putInt(QQShare.SHARE_TO_QQ_EXT_INT, extInt);
    mTencent.shareToQQ(mActivity, params, mListener);
}

6、分享音乐（QQ）

public void shareToQqAudio(String title, String targetUrl, String summary, String imageUrl, String audioUrl, String appName, int extInt) {
    final Bundle params = new Bundle();
    // 必填：分享的类型
    params.putInt(QQShare.SHARE_TO_QQ_KEY_TYPE, QQShare.SHARE_TO_QQ_TYPE_AUDIO);
    // 必填：分享消息被好友点击后的跳转URL
    params.putString(QQShare.SHARE_TO_QQ_TARGET_URL, targetUrl);
    // 必填：音乐文件的远程链接, 以URL的形式传入, 不支持本地音乐
    params.putString(QQShare.SHARE_TO_QQ_AUDIO_URL, audioUrl);
    // 可选：分享的标题, 最长30个字符
    params.putString(QQShare.SHARE_TO_QQ_TITLE, title);
    // 可选：分享的消息摘要，最长40个字符
    params.putString(QQShare.SHARE_TO_QQ_SUMMARY, summary);
    // 可选：分享图片的URL或者本地路径
    params.putString(QQShare.SHARE_TO_QQ_IMAGE_URL, imageUrl);
    // 可选：手Q客户端顶部替换“返回”按钮文字，如果为空则用“返回”代替
    params.putString(QQShare.SHARE_TO_QQ_APP_NAME, appName);
    // 可选：分享额外选项，有两种类型可选（默认是不隐藏分享到QZone按钮且不自动打开分享到QZone的对话框）。
    // QQShare.SHARE_TO_QQ_FLAG_QZONE_AUTO_OPEN，分享时自动打开分享到QZone的对话框。
    // QQShare.SHARE_TO_QQ_FLAG_QZONE_ITEM_HIDE，分享时隐藏分享到QZone按钮。
    params.putInt(QQShare.SHARE_TO_QQ_EXT_INT, extInt);
    mTencent.shareToQQ(mActivity, params, mListener);
}

7、分享应用（QQ）

public void shareToQqApp(String title, String summary, String imageUrl, String appName, int extInt) {
    final Bundle params = new Bundle();
    // 必填：分享的类型
    params.putInt(QQShare.SHARE_TO_QQ_KEY_TYPE, QQShare.SHARE_TO_QQ_TYPE_APP);
    // 可选：分享的标题, 最长30个字符
    params.putString(QQShare.SHARE_TO_QQ_TITLE, title);
    // 可选：分享的消息摘要，最长40个字符
    params.putString(QQShare.SHARE_TO_QQ_SUMMARY, summary);
    // 可选：分享图片的URL或者本地路径
    params.putString(QQShare.SHARE_TO_QQ_IMAGE_URL, imageUrl);
    // 可选：手Q客户端顶部替换“返回”按钮文字，如果为空则用“返回”代替
    params.putString(QQShare.SHARE_TO_QQ_APP_NAME, appName);
    // 可选：分享额外选项，有两种类型可选（默认是不隐藏分享到QZone按钮且不自动打开分享到QZone的对话框）。
    // QQShare.SHARE_TO_QQ_FLAG_QZONE_AUTO_OPEN，分享时自动打开分享到QZone的对话框。
    // QQShare.SHARE_TO_QQ_FLAG_QZONE_ITEM_HIDE，分享时隐藏分享到QZone按钮。
    params.putInt(QQShare.SHARE_TO_QQ_EXT_INT, extInt);
    mTencent.shareToQQ(mActivity, params, mListener);
}

8、分享图文消息（QQ空间）

public void shareToQzone(String title, String targetUrl, String summary, ArrayList<String> imageUrlList) {
    final Bundle params = new Bundle();
    // 可选：分享的类型
    params.putInt(QzoneShare.SHARE_TO_QZONE_KEY_TYPE, QzoneShare.SHARE_TO_QZONE_TYPE_IMAGE_TEXT);
    // 必填：分享的标题，最多200个字符
    params.putString(QzoneShare.SHARE_TO_QQ_TITLE, title);
    // 必填：需要跳转的链接，URL字符串
    params.putString(QzoneShare.SHARE_TO_QQ_TARGET_URL, targetUrl);
    // 可选：分享的摘要，最多600字符
    params.putString(QzoneShare.SHARE_TO_QQ_SUMMARY, summary);
    // 可选：分享的图片, 以ArrayList<String>的类型传入，以便支持多张图片（注：图片最多支持9张图片，多余的图片会被丢弃）
    params.putStringArrayList(QzoneShare.SHARE_TO_QQ_IMAGE_URL, imageUrlList);
    mTencent.shareToQzone(mActivity, params, mListener);
}

9、写说说

public void writeToQqTalk(String summary, ArrayList<String> imageUrlList) {
    final Bundle params = new Bundle();
    // 可选：分享的类型
    params.putInt(QzoneShare.SHARE_TO_QZONE_KEY_TYPE, QzonePublish.PUBLISH_TO_QZONE_TYPE_PUBLISHMOOD);
    // 可选：分享的摘要，最多600字符
    params.putString(QzoneShare.SHARE_TO_QQ_SUMMARY, summary);
    // 可选：分享的图片, 以ArrayList<String>的类型传入，以便支持多张图片（注：图片最多支持9张图片，多余的图片会被丢弃）
    params.putStringArrayList(QzoneShare.SHARE_TO_QQ_IMAGE_URL, imageUrlList);
    mTencent.publishToQzone(mActivity, params, mListener);
}

10、短视频

public void shortToQqVideo(String summary, String videoPath) {
    final Bundle params = new Bundle();
    // 可选：分享的类型
    params.putInt(QzoneShare.SHARE_TO_QZONE_KEY_TYPE, QzonePublish.PUBLISH_TO_QZONE_TYPE_PUBLISHVIDEO);
    // 可选：分享的摘要，最多600字符
    params.putString(QzoneShare.SHARE_TO_QQ_SUMMARY, summary);
    // 必填：分享的视频地址
    params.putString(QzonePublish.PUBLISH_TO_QZONE_VIDEO_PATH, videoPath);
    mTencent.publishToQzone(mActivity, params, mListener);
}

项目地址 ☞ 传送门