import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 通过微博（评论、私信）ID获取其MID。
 *
 * @param ids      需要查询的微博（评论、私信）ID，最多不超过20个。
 * @param type     获取类型，1：微博、2：评论、3：私信，默认为1。可为几下几种：
 *                 <li> {@link #TYPE_STATUSES}
 *                 <li> {@link #TYPE_COMMENTS}
 *                 <li> {@link #TYPE_MESSAGE}
 * @param listener 异步请求回调接口
 */
public void queryMID(long[] ids, int type, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    if (1 == ids.length) {
        params.put("id", ids[0]);
    } else {
        params.put("is_batch", 1);
        StringBuilder strb = new StringBuilder();
        for (long id : ids) {
            strb.append(id).append(",");
        }
        strb.deleteCharAt(strb.length() - 1);
        params.put("id", strb.toString());
    }
    params.put("type", type);
    requestAsync(SERVER_URL_PRIX + "/querymid.json", params, HTTPMETHOD_GET, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
     * 查询用户信息
     *
     * @param refreshAvatar 是否更新头像缓存
     */
    private void queryUserInfo(final boolean refreshAvatar) {
        // 根据用户Id，获取用户信息
        mUsersAPI.show(Long.parseLong(BaseConfig.sUid), new RequestListener() {
            @Override
            public void onComplete(String s) {
                mSwipeRefresh.setRefreshing(false);
                if (!TextUtils.isEmpty(s)) {
//                    Log.d(TAG, s);
                    mCurUser = User.parse(s);
                    // 更新用户信息
                    BaseConfig.sUser = mCurUser;
                    initUserInfo(refreshAvatar);
                }
            }

            @Override
            public void onWeiboException(WeiboException e) {
                mSwipeRefresh.setRefreshing(false);
                e.printStackTrace();
                AppToast.showToast("获取用户信息失败");
            }
        });
    }
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 批量获取指定微博的转发数评论数。
 * 
 * @param ids       需要获取数据的微博ID，最多不超过100个
 * @param listener  异步请求回调接口
 */
public void count(String[] ids, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    StringBuilder strb = new StringBuilder();
    for (String id : ids) {
        strb.append(id).append(",");
    }
    strb.deleteCharAt(strb.length() - 1);
    params.put("ids", strb.toString());
    requestAsync(SERVER_URL_PRIX + "/count.json", params, HTTPMETHOD_GET, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 更新好友分组。
 * 
 * @param list_id       需要更新的好友分组ID，建议使用返回值里的idstr，只能更新当前登录用户自己创建的分组
 * @param name          要创建的好友分组的名称，不超过10个汉字，20个半角字符
 * @param description   要创建的好友分组的描述，不超过70个汉字，140个半角字符
 * @param tags          要创建的好友分组的标签，多个之间用逗号分隔，最多不超过10个，每个不超过7个汉字，14个半角字符
 * @param listener      异步请求回调接口
 */
public void update(long list_id, String name, String description, String tags, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("list_id", list_id);
    if (TextUtils.isEmpty(name) == false) {
        params.put("name", name);
    }
    if (TextUtils.isEmpty(description) == false) {
        params.put("description", description);
    }
    if (TextUtils.isEmpty(tags) == false) {
        params.put("tags", tags);
    }
    requestAsync(SERVER_URL_PRIX + "/update.json", params, HTTPMETHOD_POST, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
public void upload(Bitmap bitmap) {
    if (mAApi == null) {
        mAApi = new AccountAPI(mContext, SinaConsts.APP_KEY, BaseConfig.sAccessToken);
    }
    mAApi.avatarUpload(bitmap, new RequestListener() {
        @Override
        public void onComplete(String s) {
            User user = User.parse(s);
            if (user != null && user.id > 0L) {
                // 头像上传成功
                if (mListener != null) {
                    mListener.onSuccess();
                }
            } else {
                if (mListener != null) {
                    mListener.onFailure(mContext.getString(R.string.avatar_upload_failure));
                }
            }
        }

        @Override
        public void onWeiboException(WeiboException e) {
            e.printStackTrace();
            if (mListener != null) {
                mListener.onFailure(mContext.getString(R.string.avatar_upload_failure));
            }
        }
    });
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 为当前登录用户添加新的用户标签(无论调用该接口次数多少，每个用户最多可以创建10个标签)。
 * 
 * @param tags      要创建的一组标签，每个标签的长度不可超过7个汉字，14个半角字符
 * @param listener  异步请求回调接口
 */
public void create(String[] tags, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    StringBuilder strb = new StringBuilder();
    for (String tag : tags) {
        strb.append(tag).append(",");
    }
    strb.deleteCharAt(strb.length() - 1);
    params.put("tags", strb.toString());
    requestAsync(SERVER_URL_PRIX + "/create.json", params, HTTPMETHOD_POST, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 获取某个用户的各种消息未读数。
 *
 * @param uid      需要查询的用户ID
 * @param listener 异步请求回调接口
 */
public void unreadCount(long uid, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("uid", uid);
    params.put("unread_message", 1);
    requestAsync(SERVER_URL_PRIX + "/unread_count.json", params, HTTPMETHOD_GET, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 关注一个用户
 * 
 * @param screen_name   需要关注的用户昵称
 * @param listener      异步请求回调接口
 */
@Deprecated
public void create(String screen_name, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("screen_name", screen_name);
    requestAsync(SERVER_URL_PRIX + "/create.json", params, HTTPMETHOD_POST, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 创建好友分组。
 * 
 * @param name          要创建的好友分组的名称，不超过10个汉字，20个半角字符
 * @param description   要创建的好友分组的描述，不超过70个汉字，140个半角字符
 * @param tags          要创建的好友分组的标签，多个之间用逗号分隔，最多不超过10个，每个不超过7个汉字，14个半角字符
 * @param listener      异步请求回调接口
 */
public void create(String name, String description, String tags, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("name", name);
    if (TextUtils.isEmpty(description) == false) {
        params.put("description", description);
    }
    if (TextUtils.isEmpty(tags) == false) {
        params.put("tags", tags);
    }
    requestAsync(SERVER_URL_PRIX + "/create.json", params, HTTPMETHOD_POST, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
private void queryGroups() {
    if (mGApi == null) {
        mGApi = new GroupAPI(this, SinaConsts.APP_KEY, BaseConfig.sAccessToken);
    }
    mGApi.groups(new RequestListener() {
        @Override
        public void onComplete(String s) {
            mSwipeRefresh.setRefreshing(false);
            // Log.d("Group", s);
            GroupList groupList = GroupList.parse(s);
            if (groupList != null && groupList.groupList != null) {
                BaseConfig.sGroups = groupList.groupList;
                mAdapter.setGroups(groupList.groupList);
                mAdapter.setFooterInfo(getString(R.string.loaded_all));
            } else {
                AppToast.showToast("获取分组失败");
            }
        }

        @Override
        public void onWeiboException(WeiboException e) {
            mSwipeRefresh.setRefreshing(false);
            e.printStackTrace();
            AppToast.showToast("获取分组失败");
        }
    });
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 更新好友分组。
 *
 * @param list_id     需要更新的好友分组ID，建议使用返回值里的idstr，只能更新当前登录用户自己创建的分组
 * @param name        要创建的好友分组的名称，不超过10个汉字，20个半角字符
 * @param description 要创建的好友分组的描述，不超过70个汉字，140个半角字符
 * @param tags        要创建的好友分组的标签，多个之间用逗号分隔，最多不超过10个，每个不超过7个汉字，14个半角字符
 * @param listener    异步请求回调接口
 */
public void update(long list_id, String name, String description, String tags, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("list_id", list_id);
    if (!TextUtils.isEmpty(name)) {
        params.put("name", name);
    }
    if (!TextUtils.isEmpty(description)) {
        params.put("description", description);
    }
    if (!TextUtils.isEmpty(tags)) {
        params.put("tags", tags);
    }
    requestAsync(SERVER_URL_PRIX + "/update.json", params, HTTPMETHOD_POST, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 查询分组成员
 *
 * @param gid     分组id
 * @param cursor  游标
 * @param refresh 是否刷新列表
 */
private void queryMembers(long gid, final int cursor, final boolean refresh) {
    if (mGApi == null) {
        mGApi = new GroupAPI(this, SinaConsts.APP_KEY, BaseConfig.sAccessToken);
    }
    mGApi.members(gid, 50, cursor, new RequestListener() {
        @Override
        public void onComplete(String s) {
            mSwipeRefresh.setRefreshing(false);
            UserList userList = UserList.parse(s);
            if (userList != null && userList.users != null) {
                if (refresh) {
                    mAdapter.setData(userList.users);
                } else {
                    mAdapter.addData(userList.users);
                }
                mCursor = userList.next_cursor;
                if (mCursor > 0) {
                    mAdapter.setFooterInfo(getString(R.string.pull_up_to_load_more));
                } else {
                    mAdapter.setFooterInfo(getString(R.string.no_more_data));
                }
            } else {
                AppToast.showToast("该分组下没有好友");
            }
        }

        @Override
        public void onWeiboException(WeiboException e) {
            mSwipeRefresh.setRefreshing(false);
            e.printStackTrace();
            AppToast.showToast("获取分组好友失败");
        }
    });
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
public void friendsTimeline(long since_id, long max_id, int count, int page, boolean base_app,
                            int featureType, boolean trim_user, RequestListener listener) {
    WeiboParameters params =
            buildTimeLineParamsBase(since_id, max_id, count, page, base_app, trim_user, featureType);
    requestAsync(sAPIList.get(READ_API_FRIENDS_TIMELINE), params, HTTPMETHOD_GET, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 获取LBS位置服务内的用户信息。
 * 
 * @param uid       需要查询的用户ID
 * @param base_app  是否只获取当前应用的数据。false为否（所有数据），true为是（仅当前应用），默认为false
 * @param listener  异步请求回调接口
 */
public void usersShow(long uid, boolean base_app, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("uid", uid);
    params.put("base_app", base_app ? 1 : 0);
    requestAsync(SERVER_URL_PRIX + "/users/show.json", params, HTTPMETHOD_GET, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 获取微博官方表情的详细信息。
 * 
 * @param type      表情类别，表情类别，face：普通表情、ani：魔法表情、cartoon：动漫表情，默认为face。可为以下几种： 
 *                  <li> {@link #EMOTION_TYPE_FACE}
 *                  <li> {@link #EMOTION_TYPE_ANI}
 *                  <li> {@link #EMOTION_TYPE_CARTOON}
 * @param language  语言类别，cnname：、twname：，默认为cnname。 
 *                  <li> {@link #LANGUAGE_CNNAME}
 *                  <li> {@link #LANGUAGE_TWNAME}
 * @param listener  异步请求回调接口
 */
public void emotions(String type, String language, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("type", type);
    params.put("language", language);
    requestAsync(API_SERVER + "/emotions.json", params, HTTPMETHOD_GET, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 获取两个用户之间的共同关注人列表。
 * 
 * @param uid       需要获取共同关注关系的用户UID
 * @param suid      需要获取共同关注关系的用户UID，默认为当前登录用户
 * @param count     单页返回的记录条数，默认为50
 * @param page      返回结果的页码，默认为1
 * @param trim_status 返回值中user字段中的status字段开关，false：返回完整status字段、true：status字段仅返回status_id，默认为true
 * @param listener  异步请求回调接口
 */
public void inCommon(long uid, long suid, int count, int page, boolean trim_status, RequestListener listener) {
    WeiboParameters params = buildFriendIDParam(uid, count);
    params.put("suid", suid);
    params.put("page", page);
    params.put("trim_status", trim_status ? 1: 0);
    requestAsync(SERVER_URL_PRIX + "/friends/in_common.json", params, HTTPMETHOD_GET, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 转发一条微博。
 *
 * @param id          要转发的微博ID
 * @param status      添加的转发文本，内容不超过140个汉字，不填则默认为“转发微博”
 * @param commentType 是否在转发的同时发表评论，0：否、1：评论给当前微博、2：评论给原微博、3：都评论，默认为0
 *                    <li> {@link #COMMENTS_NONE}
 *                    <li> {@link #COMMENTS_CUR_STATUSES}
 *                    <li> {@link #COMMENTS_RIGAL_STATUSES}
 *                    <li> {@link #COMMENTS_BOTH}
 * @param listener    异步请求回调接口
 */
public void repost(long id, String status, int commentType, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("id", id);
    params.put("status", status);
    params.put("is_comment", commentType);
    requestAsync(SERVER_URL_PRIX + "/repost.json", params, HTTPMETHOD_POST, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 获取当前登录用户及其所关注用户的最新微博。
 * 
 * @param since_id    若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0
 * @param max_id      若指定此参数，则返回ID小于或等于max_id的微博，默认为0。
 * @param count       单页返回的记录条数，默认为50。
 * @param page        返回结果的页码，默认为1。
 * @param base_app    是否只获取当前应用的数据。false为否（所有数据），true为是（仅当前应用），默认为false。
 * @param featureType 过滤类型ID，0：全部、1：原创、2：图片、3：视频、4：音乐，默认为0。
 *                    <li>{@link #FEATURE_ALL}
 *                    <li>{@link #FEATURE_ORIGINAL}
 *                    <li>{@link #FEATURE_PICTURE}
 *                    <li>{@link #FEATURE_VIDEO}
 *                    <li>{@link #FEATURE_MUSICE}
 * @param trim_user   返回值中user字段开关，false：返回完整user字段、true：user字段仅返回user_id，默认为false。
 * @param listener    异步请求回调接口
 */
public void friendsTimeline(long since_id, long max_id, int count, int page, boolean base_app,
        int featureType, boolean trim_user, RequestListener listener) {
    WeiboParameters params = 
            buildTimeLineParamsBase(since_id, max_id, count, page, base_app, trim_user, featureType);
    requestAsync(sAPIList.get(READ_API_FRIENDS_TIMELINE), params, HTTPMETHOD_GET, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 获取当前用户最新发表的微博列表
 * 
 * @param screen_name   需要查询的用户昵称
 * @param since_id      若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0
 * @param max_id        若指定此参数，则返回ID小于或等于max_id的微博，默认为0
 * @param count         单页返回的记录条数，默认为50
 * @param page          返回结果的页码，默认为1
 * @param base_app      是否只获取当前应用的数据。false为否（所有数据），true为是（仅当前应用），默认为false
 * @param featureType   过滤类型ID，0：全部、1：原创、2：图片、3：视频、4：音乐，默认为0
 *                      <li> {@link #FEATURE_ALL}
 *                      <li> {@link #FEATURE_ORIGINAL}
 *                      <li> {@link #FEATURE_PICTURE}
 *                      <li> {@link #FEATURE_VIDEO}
 *                      <li> {@link #FEATURE_MUSICE}
 * @param trim_user     返回值中user字段开关，false：返回完整user字段、true：user字段仅返回user_id，默认为false
 * @param listener      异步请求回调接口
 */
public void userTimeline(long since_id, long max_id, int count, int page, boolean base_app, int featureType,
        boolean trim_user, RequestListener listener) {
    WeiboParameters params = buildTimeLineWithAppTrim(since_id, max_id, count, page, base_app, trim_user,
            featureType);
    requestAsync(SERVER_URL_PRIX + "/user_timeline.json", params, HTTPMETHOD_GET, listener);
}
 

import com.sina.weibo.sdk.net.RequestListener; //导入依赖的package包/类
/**
 * 获取用户发布的微博的ID
 *
 * @param uid         需要查询的用户ID
 * @param since_id    若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0
 * @param max_id      若指定此参数，则返回ID小于或等于max_id的微博，默认为0
 * @param count       单页返回的记录条数，默认为50
 * @param page        返回结果的页码，默认为1
 * @param base_app    是否只获取当前应用的数据。false为否（所有数据），true为是（仅当前应用），默认为false
 * @param featureType 过滤类型ID，0：全部、1：原创、2：图片、3：视频、4：音乐，默认为0
 *                    <li> {@link #FEATURE_ALL}
 *                    <li> {@link #FEATURE_ORIGINAL}
 *                    <li> {@link #FEATURE_PICTURE}
 *                    <li> {@link #FEATURE_VIDEO}
 *                    <li> {@link #FEATURE_MUSICE}
 * @param listener    异步请求回调接口
 */
public void userTimelineIds(long uid, long since_id, long max_id, int count, int page, boolean base_app,
                            int featureType, RequestListener listener) {
    WeiboParameters params = buildTimeLineWithApp(since_id, max_id, count, page, base_app, featureType);
    params.put("uid", uid);
    requestAsync(SERVER_URL_PRIX + "/user_timeline/ids.json", params, HTTPMETHOD_GET, listener);
}