com.sina.weibo.sdk.net.RequestListener Java Examples

/**
 * 添加地点
 * 
 * @param title     POI点的名称，不超过30个字符，必须进行URLencode
 * @param address   POI点的地址，不超过60个字符，必须进行URLencode
 * @param category  POI的类型分类代码，取值范围见：分类代码对应表，默认为500
 * @param lat       纬度，有效范围：-90.0到+90.0，+表示北纬
 * @param lon       经度，有效范围：-180.0到+180.0，+表示东经
 * @param city      城市代码
 * @param province  省份代码
 * @param country   国家代码
 * @param phone     POI点的电话，不超过14个字符
 * @param postCode  POI点的邮编
 * @param extra     其他，必须进行URLencode
 * @param listener  异步请求回调接口
 */
public void poisCreate(String title, String address, String category, String lat, String lon, String city,
        String province, String country, String phone, String postCode, String extra, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("title", title);
    params.put("address", address);
    params.put("category", category);
    params.put("lat", lat);
    params.put("long", lon);
    params.put("city", city);
    params.put("province", province);
    params.put("country", country);
    params.put("phone", phone);
    params.put("postcode", postCode);
    params.put("extra", extra);
    requestAsync(SERVER_URL_PRIX + "/pois/create.json", params, HTTPMETHOD_POST, listener);
}
 

/**
 * 加载分组微博
 *
 * @param groupId
 * @param maxId
 * @param refresh
 */
public void loadGroupStatuses(long groupId, long maxId, final boolean refresh) {
    if (mGroupAPI == null) {
        mGroupAPI = new GroupAPI(MainActivity.this, SinaConsts.APP_KEY, BaseConfig.sAccessToken);
    }
    mGroupAPI.timeline(groupId, 0, maxId, mRefreshCount, 1, false, 0, new RequestListener() {
        @Override
        public void onComplete(String s) {
            if (!TextUtils.isEmpty(s)) {
                formatStatusStr(s, refresh);
            }
        }

        @Override
        public void onWeiboException(WeiboException e) {
            AppToast.showToast(R.string.loading_statuses_failed);
            e.printStackTrace();
        }
    });
}
 

/**
 * 添加地点
 * 
 * @param title     POI点的名称，不超过30个字符，必须进行URLencode
 * @param address   POI点的地址，不超过60个字符，必须进行URLencode
 * @param category  POI的类型分类代码，取值范围见：分类代码对应表，默认为500
 * @param lat       纬度，有效范围：-90.0到+90.0，+表示北纬
 * @param lon       经度，有效范围：-180.0到+180.0，+表示东经
 * @param city      城市代码
 * @param province  省份代码
 * @param country   国家代码
 * @param phone     POI点的电话，不超过14个字符
 * @param postCode  POI点的邮编
 * @param extra     其他，必须进行URLencode
 * @param listener  异步请求回调接口
 */
public void poisCreate(String title, String address, String category, String lat, String lon, String city,
        String province, String country, String phone, String postCode, String extra, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("title", title);
    params.put("address", address);
    params.put("category", category);
    params.put("lat", lat);
    params.put("long", lon);
    params.put("city", city);
    params.put("province", province);
    params.put("country", country);
    params.put("phone", phone);
    params.put("postcode", postCode);
    params.put("extra", extra);
    requestAsync(SERVER_URL_PRIX + "/pois/create.json", params, HTTPMETHOD_POST, listener);
}
 

/**
 * 批量删除一组标签。
 * 
 * @param ids       要删除的一组标签ID，一次最多提交10个ID
 * @param listener  异步请求回调接口
 */
public void destroyBatch(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 + "/destroy_batch.json", params, HTTPMETHOD_POST, listener);
}
 

/**
 * HTTP 异步请求。
 * 
 * @param url        请求的地址
 * @param params     请求的参数
 * @param httpMethod 请求方法
 * @param listener   请求后的回调接口
 */
protected void requestAsync(String url, WeiboParameters params, String httpMethod, RequestListener listener) {
    if (null == mAccessToken
            || TextUtils.isEmpty(url)
            || null == params
            || TextUtils.isEmpty(httpMethod)
            || null == listener) {
        LogUtil.e(TAG, "Argument error!");
        return;
    }
    
    params.put(KEY_ACCESS_TOKEN, mAccessToken.getToken());
    new AsyncWeiboRunner(mContext).requestAsync(url, params, httpMethod, listener);
}
 

/**
 * 取消关注一个用户。
 * 
 * @param screen_name 需要取消关注的用户昵称
 * @param listener    异步请求回调接口
 */
@Deprecated
public void destroy(String screen_name, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("screen_name", screen_name);
    requestAsync(SERVER_URL_PRIX + "/destroy.json", params, HTTPMETHOD_POST, listener);
}
 

private void loadUserInfo(UsersAPI usersAPI) {
    usersAPI.show(Long.parseLong(BaseConfig.sUid), new RequestListener() {
        @Override
        public void onComplete(String s) {
            if (!TextUtils.isEmpty(s)) {
                formatUserStr(s);      // 格式化用户信息字符串
                saveUserCache(s);    // 缓存当前用户信息
                UnreadService.startService();   // 开启未读服务
            } else {
                // 获取用户信息失败
                mOK = false;
                AppToast.showToast(R.string.failed_to_get_user_info);
            }
        }

        @Override
        public void onWeiboException(WeiboException e) {
            e.printStackTrace();
            try {
                JSONObject obj = new JSONObject(e.getMessage());
                int errorCode = obj.optInt("error_code");
                if (errorCode == 10006 || errorCode == 21332) {
                    // 授权过期
                    AppToast.showToast("应用授权过期，请重新授权");
                    if (!BaseConfig.sTokenExpired) {
                        BaseConfig.sTokenExpired = true;
                        App.getInstance().finishAllActivities();
                        startActivity(WBLoginActivity.newIntent(MainActivity.this));
                        return;
                    }
                }
            } catch (JSONException e1) {
                e1.printStackTrace();
            }
            mOK = false;
            AppToast.showToast(e.getMessage());
        }
    });
}
 

private void queryPhotos(long maxId, final boolean refresh) {
    if (mSApi == null) {
        mSApi = new StatusesAPI(this, SinaConsts.APP_KEY, BaseConfig.sAccessToken);
    }

    mSApi.userTimeline(mUid, 0, maxId, 20, 1, false, StatusesAPI.FEATURE_PICTURE, true, new RequestListener() {
        @Override
        public void onComplete(String s) {
            mSwipeRefresh.setRefreshing(false);
            StatusList statusList = StatusList.parse(s);
            if (statusList == null || statusList.statusList == null || statusList.statusList.isEmpty()) {
                mMaxId = 0;
                mAdapter.setFooterInfo(getString(R.string.no_more_data));
                return;
            }
            List<String> once = new ArrayList<>();
            for (int i = 0; i < statusList.statusList.size(); i++) {
                ArrayList<String> picUrls = statusList.statusList.get(i).pic_urls;
                if (picUrls != null && !picUrls.isEmpty()) {
                    once.addAll(picUrls);
                }
            }

            if (refresh) {
                mAdapter.setAlbums(once);
            } else {
                mAdapter.addAlbums(once);
            }
            mMaxId = statusList.statusList.get(statusList.statusList.size() - 1).id - 1;
            mAdapter.setFooterInfo(getString(R.string.pull_up_to_load_more));
        }

        @Override
        public void onWeiboException(WeiboException e) {
            mSwipeRefresh.setRefreshing(false);
            e.printStackTrace();
            AppToast.showToast("暂无法查看个人相册");
        }
    });
}
 

/**
     * 查询用户信息
     */
    private void queryUserInfo() {
        // 根据用户昵称，获取用户信息
        mUsersAPI.show(mScreenName, new RequestListener() {
            @Override
            public void onComplete(String s) {
                mSwipeRefresh.setRefreshing(false);
                if (!TextUtils.isEmpty(s)) {
//                    Log.d(TAG, s);
                    mUser = User.parse(s);
                    initUserInfo();
                }
            }

            @Override
            public void onWeiboException(WeiboException e) {
                mSwipeRefresh.setRefreshing(false);
                e.printStackTrace();
                try {
                    JSONObject obj = new JSONObject(e.getMessage());
                    if (obj.optInt("error_code") == 20003) {
                        AppToast.showToast(R.string.user_does_not_exists);
                        finish();
                        return;
                    }
                } catch (JSONException e1) {
                    e1.printStackTrace();
                }
                AppToast.showToast(R.string.failed_to_get_user_info);
            }
        });
    }
 

private void init() {
    UsersAPI usersAPI = new UsersAPI(this, SinaConsts.APP_KEY, BaseConfig.sAccessToken);
    usersAPI.show(AUTHOR_UID, new RequestListener() {
        @Override
        public void onComplete(String s) {
            if (!TextUtils.isEmpty(s)) {
                User author = User.parse(s);
                // 加载头像
                Glide.with(AboutMeActivity.this).load(author.avatar_large).into(mCivHead);
                UserVerify.verify(author, mIvAvatarVip, mTvDescription);
                mTvName.setText(author.name);
                mAuthorScreenName = author.screen_name;
                if (author.following) {
                    // 已关注
                    mTvRelation.setText(R.string.pay_attention_ok);
                    mTvRelation.setClickable(false);
                } else {
                    // 未关注
                    mTvRelation.setText(R.string.pay_attention_to_him);
                    mTvRelation.setClickable(true);
                }
                // 点击作者头像，进入作者主页
                mCivHead.setOnClickListener(new ViewUserOp(AboutMeActivity.this, author.screen_name));
            }
        }

        @Override
        public void onWeiboException(WeiboException e) {
            e.printStackTrace();
        }
    });
}
 

/**
 * 获取某个用户的各种消息未读数。
 *
 * @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);
}
 

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));
            }
        }
    });
}
 

/**
 * 获取某个用户的位置动态。
 * 
 * @param uid       需要查询的用户ID
 * @param since_id  若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0
 * @param max_id    若指定此参数，则返回ID小于或等于max_id的微博，默认为0
 * @param count     单页返回的记录条数，最大为50，默认为20
 * @param page      返回结果的页码，默认为1
 * @param base_app  是否只获取当前应用的数据。false为否（所有数据），true为是（仅当前应用），默认为false
 * @param listener  异步请求回调接口
 */
public void userTimeline(long uid, long since_id, long max_id, int count, int page, boolean base_app,
        RequestListener listener) {
    WeiboParameters params = buildTimeLineParamsBase(since_id, max_id, count, page);
    params.put("uid", uid);
    params.put("base_app", base_app ? 1 : 0);
    requestAsync(SERVER_URL_PRIX + "/user_timeline.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取地点详情。
 * 
 * @param poiid     需要查询的POI地点ID
 * @param base_app  是否只获取当前应用的数据。false为否（所有数据），true为是（仅当前应用），默认为false
 * @param listener  异步请求回调接口
 */
public void poisShow(String poiid, boolean base_app, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("poiid", poiid);
    params.put("base_app", base_app ? 1 : 0);
    requestAsync(SERVER_URL_PRIX + "/pois/show.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取某个位置周边的动态。
 * 
 * @param lat       纬度。有效范围：-90.0到+90.0，+表示北纬
 * @param lon       经度。有效范围：-180.0到+180.0，+表示东经
 * @param range     搜索范围，单位米，默认2000米，最大11132米
 * @param starttime 开始时间，Unix时间戳
 * @param endtime   结束时间，Unix时间戳
 * @param sortType  排序方式。0：按时间排序， 1：按与中心点距离进行排序
 *                  <li>{@link #SORT_BY_TIME}
 *                  <li>{@link #SORT_BY_DISTENCE}
 * @param count     单页返回的记录条数，最大为50，默认为20
 * @param page      返回结果的页码，默认为1
 * @param base_app  是否只获取当前应用的数据。false为否（所有数据），true为是（仅当前应用），默认为false
 * @param offset    传入的经纬度是否是纠偏过，false：没纠偏、true：纠偏过，默认为false
 * @param listener  异步请求回调接口
 */
public void nearbyTimeline(String lat, String lon, int range, long starttime, long endtime, int sortType,
        int count, int page, boolean base_app, boolean offset, RequestListener listener) {
    WeiboParameters params = buildNearbyParams(lat, lon, range, count, page, sortType, offset);
    params.put("starttime", starttime);
    params.put("endtime", endtime);
    params.put("base_app", base_app ? 1 : 0);
    requestAsync(SERVER_URL_PRIX + "/nearby_timeline.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取@当前用户的最新微博的ID。
 * 
 * @param since_id      若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0
 * @param max_id        若指定此参数，则返回ID小于或等于max_id的微博，默认为0
 * @param count         单页返回的记录条数，默认为50
 * @param page          返回结果的页码，默认为1
 * @param authorType    作者筛选类型，0：全部、1：我关注的人、2：陌生人，默认为0。可为以下几种：
 *                      <li> {@link #AUTHOR_FILTER_ALL}
 *                      <li> {@link #AUTHOR_FILTER_ATTENTIONS}
 *                      <li> {@link #AUTHOR_FILTER_STRANGER}
 * @param sourceType    来源筛选类型，0：全部、1：来自微博的评论、2：来自微群的评论。可分为以下几种：
 *                      <li> {@link #SRC_FILTER_ALL}
 *                      <li> {@link #SRC_FILTER_WEIBO}
 *                      <li> {@link #SRC_FILTER_WEIQUN}
 * @param filterType    原创筛选类型，0：全部微博、1：原创的微博，默认为0。可分为以下几种：
 *                      <li> {@link #TYPE_FILTER_ALL}
 *                      <li> {@link #TYPE_FILTER_ORIGAL}
 * @param listener      异步请求回调接口
 */
public void mentionsIds(long since_id, long max_id, int count, int page, int authorType, int sourceType,
        int filterType, RequestListener listener) {
    WeiboParameters params = buildTimeLineBase(since_id, max_id, count, page);
    params.put("filter_by_author", authorType);
    params.put("filter_by_source", sourceType);
    params.put("filter_by_type", filterType);
    requestAsync(SERVER_URL_PRIX + "/mentions/ids.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取用户粉丝的用户UID列表。
 * 
 * @param screen_name   需要查询的用户昵称
 * @param count         单页返回的记录条数，默认为500，最大不超过5000
 * @param cursor        返回结果的游标，下一页用返回值里的next_cursor，上一页用previous_cursor，默认为0
 * @param listener      异步请求回调接口
 */
public void followersIds(String screen_name, int count, int cursor, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("screen_name", screen_name);
    params.put("count", count);
    params.put("cursor", cursor);
    requestAsync(SERVER_URL_PRIX + "/followers/ids.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取当前登录用户与其好友的位置动态。
 * 
 * @param since_id  若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0
 * @param max_id    若指定此参数，则返回ID小于或等于max_id的微博，默认为0
 * @param count     单页返回的记录条数，最大为50，默认为20
 * @param page      返回结果的页码，默认为1
 * @param only_attentions true：仅返回关注的，false：返回好友的，默认为true
 * @param listener  异步请求回调接口
 */
public void friendsTimeline(long since_id, long max_id, int count, int page, boolean only_attentions,
        RequestListener listener) {
    WeiboParameters params = buildTimeLineParamsBase(since_id, max_id, count, page);
    params.put("type", only_attentions ? 1 : 0);
    requestAsync(SERVER_URL_PRIX + "/friends_timeline.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取某个位置地点的动态。
 * 
 * @param poiid     需要查询的POI点ID
 * @param since_id  若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0
 * @param max_id    若指定此参数，则返回ID小于或等于max_id的微博，默认为0
 * @param count     单页返回的记录条数，最大为50，默认为20
 * @param page      返回结果的页码，默认为1
 * @param base_app  是否只获取当前应用的数据。false为否（所有数据），true为是（仅当前应用），默认为false
 * @param listener  异步请求回调接口
 */
public void poiTimeline(String poiid, long since_id, long max_id, int count, int page, boolean base_app,
        RequestListener listener) {
    WeiboParameters params = buildTimeLineParamsBase(since_id, max_id, count, page);
    params.put("poiid", poiid);
    params.put("base_app", base_app ? 1 : 0);
    requestAsync(SERVER_URL_PRIX + "/poi_timeline.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取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);
}
 

/**
 * 获取当前登录用户所接收到的评论列表。
 * 
 * @param since_id   若指定此参数，则返回ID比since_id大的评论（即比since_id时间晚的评论），默认为0。
 * @param max_id     若指定此参数，则返回ID小于或等于max_id的评论，默认为0。
 * @param count      单页返回的记录条数，默认为50。
 * @param page       返回结果的页码，默认为1。
 * @param authorType 作者筛选类型，0：全部、1：我关注的人、2：陌生人 ,默认为0。可为以下几种 :
 *                   <li>{@link #AUTHOR_FILTER_ALL}
 *                   <li>{@link #AUTHOR_FILTER_ATTENTIONS}
 *                   <li>{@link #AUTHOR_FILTER_STRANGER}
 * @param sourceType 来源筛选类型，0：全部、1：来自微博的评论、2：来自微群的评论，默认为0。
 *                   <li>{@link #SRC_FILTER_ALL}
 *                   <li>{@link #SRC_FILTER_WEIBO}
 *                   <li>{@link #SRC_FILTER_WEIQUN}
 * @param listener   异步请求回调接口
 */
public void toME(long since_id, long max_id, int count, int page, int authorType, int sourceType,
        RequestListener listener) {
    WeiboParameters params = buildTimeLineParamsBase(since_id, max_id, count, page);
    params.put("filter_by_author", authorType);
    params.put("filter_by_source", sourceType);
    requestAsync(sAPIList.get(READ_API_TO_ME), params, HTTPMETHOD_GET, listener);
}
 

/**
 * 根据微博ID返回某条微博的评论列表。
 * 
 * @param id         需要查询的微博ID。
 * @param since_id   若指定此参数，则返回ID比since_id大的评论（即比since_id时间晚的评论），默认为0。
 * @param max_id     若指定此参数，则返回ID小于或等于max_id的评论，默认为0。
 * @param count      单页返回的记录条数，默认为50
 * @param page       返回结果的页码，默认为1。
 * @param authorType 作者筛选类型，0：全部、1：我关注的人、2：陌生人 ,默认为0。可为以下几种 :
 *                   <li>{@link #AUTHOR_FILTER_ALL}
 *                   <li>{@link #AUTHOR_FILTER_ATTENTIONS}
 *                   <li>{@link #AUTHOR_FILTER_STRANGER}
 * @param listener   异步请求回调接口
 */
public void show(long id, long since_id, long max_id, int count, int page, int authorType, RequestListener listener) {
    WeiboParameters params = buildTimeLineParamsBase(since_id, max_id, count, page);
    params.put("id", id);
    params.put("filter_by_author", authorType);
    requestAsync(sAPIList.get(READ_API_SHOW), params, HTTPMETHOD_GET, listener);
}
 

/**
 * 按省市查询地点。
 * 
 * @param keyword   查询的关键词
 * @param city      城市代码，默认为全国搜索
 * @param category  查询的分类代码，取值范围见：分类代码对应表
 * @param count     单页返回的记录条数，默认为20，最大为50
 * @param page      返回结果的页码，默认为1。
 * @param listener  异步请求回调接口
 */
public void poisSearch(String keyword, String city, String category, int count, int page, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("keyword", keyword);
    params.put("city", city);
    params.put("category", category);
    params.put("count", count);
    params.put("page", page);
    requestAsync(SERVER_URL_PRIX + "/pois/search.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取附近的人
 * 
 * @param lat       纬度，有效范围：-90.0到+90.0，+表示北纬
 * @param lon       经度，有效范围：-180.0到+180.0，+表示东经
 * @param count     单页返回的记录条数，默认为20，最大为50
 * @param page      返回结果的页码，默认为1
 * @param range     查询范围半径，默认为2000，最大为11132
 * @param sortType  排序方式，0：按时间、1：按距离、2：按社会化关系，默认为2。
 *                  <li>{@link #NEARBY_USER_SORT_BY_TIME}
 *                  <li>{@link #NEARBY_POIS_SORT_BY_DISTENCE}
 *                  <li>{@link #NEARBY_USER_SORT_BY_SOCIAL_SHIP}
 * @param filterType（暂未启用）用户关系过滤，0：全部、1：只返回陌生人、2：只返回关注人，默认为0
 *                  <li>{@link #RELATIONSHIP_FILTER_ALL}
 *                  <li>{@link #RELATIONSHIP_FILTER_STRANGER}
 *                  <li>{@link #RELATIONSHIP_FILTER_FOLLOW}
 * @param genderType性别过滤，0：全部、1：男、2：女，默认为0
 *                  <li>{@link #GENDER_ALL}
 *                  <li>{@link #GENDER_MAN}
 *                  <li>{@link #GENDER_WOMAM}
 * @param levelType 用户级别过滤，0：全部、1：普通用户、2：VIP用户、7：达人，默认为0
 *                  <li>{@link #USER_LEVEL_ALL}
 *                  <li>{@link #USER_LEVEL_NORMAL}
 *                  <li>{@link #USER_LEVEL_VIP}
 *                  <li>{@link #USER_LEVEL_STAR}
 * @param start_birth 与参数endbirth一起定义过滤年龄段，数值为年龄大小，默认为空
 * @param end_birth 与参数startbirth一起定义过滤年龄段，数值为年龄大小，默认为空
 * @param offset    传入的经纬度是否是纠偏过，0：没纠偏、1：纠偏过，默认为0
 * @param listener  异步请求回调接口
 */
public void nearbyUserList(String lat, String lon, int count, int page, int range, int sortType, int filterType,
        int genderType, int levelType, int start_birth, int end_birth, boolean offset, RequestListener listener) {
    WeiboParameters params = buildNearbyParams(lat, lon, range, count, page, sortType, offset);
    params.put("filter", filterType);
    params.put("gender", genderType);
    params.put("level", levelType);
    params.put("startbirth", start_birth);
    params.put("endbirth", end_birth);
    requestAsync(SERVER_URL_PRIX + "/nearby_users/list.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 调整当前登录用户的好友分组顺序。
 * 
 * @param list_ids  调整好顺序后的分组ID列表，以逗号分隔，例：57,38，表示57排第一、38排第二，以此类推
 * @param count     好友分组数量，必须与用户所有的分组数一致、与分组ID的list_id个数一致
 * @param listener  异步请求回调接口
 */
public void order(String list_ids, int count, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("list_id", list_ids);
    params.put("count", count);
    requestAsync(SERVER_URL_PRIX + "/order.json", params, HTTPMETHOD_POST, listener);
}
 

/**
 * 返回最新的公共微博。
 *
 * @param count    单页返回的记录条数，默认为50
 * @param page     返回结果的页码，默认为1
 * @param base_app 是否只获取当前应用的数据。false为否（所有数据），true为是（仅当前应用），默认为false
 * @param listener 异步请求回调接口
 */
public void publicTimeline(int count, int page, boolean base_app, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("count", count);
    params.put("page", page);
    params.put("base_app", base_app ? 1 : 0);
    requestAsync(SERVER_URL_PRIX + "/public_timeline.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取两个用户之间的详细关注关系情况。
 *
 * @param source_id          源用户的UID
 * @param target_screen_name 目标用户的微博昵称
 * @param listener           异步请求回调接口
 */
public void show(long source_id, String target_screen_name, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("source_id", source_id);
    params.put("target_screen_name", target_screen_name);
    requestAsync(SERVER_URL_PRIX + "/show.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取当前登录用户某一好友分组的微博列表。
 *
 * @param list_id     需要查询的好友分组ID，建议使用返回值里的idstr，当查询的为私有分组时，则当前登录用户必须为其所有者
 * @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：音乐
 *                    {@link #FEATURE_ALL}
 *                    {@link #FEATURE_ORIGINAL}
 *                    {@link #FEATURE_PICTURE}
 *                    {@link #FEATURE_VIDEO}
 *                    {@link #FEATURE_MUSICE}
 * @param listener    异步请求回调接口
 */
public void timeline(long list_id, long since_id, long max_id, int count, int page, boolean base_app,
                     int featureType, RequestListener listener) {
    WeiboParameters params = new WeiboParameters(mAppKey);
    params.put("list_id", list_id);
    params.put("since_id", since_id);
    params.put("max_id", max_id);
    params.put("count", count);
    params.put("page", page);
    params.put("base_app", base_app ? 1 : 0);
    params.put("feature", featureType);
    requestAsync(SERVER_URL_PRIX + "/timeline.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取@当前用户的最新微博的ID。
 *
 * @param since_id   若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0
 * @param max_id     若指定此参数，则返回ID小于或等于max_id的微博，默认为0
 * @param count      单页返回的记录条数，默认为50
 * @param page       返回结果的页码，默认为1
 * @param authorType 作者筛选类型，0：全部、1：我关注的人、2：陌生人，默认为0。可为以下几种：
 *                   <li> {@link #AUTHOR_FILTER_ALL}
 *                   <li> {@link #AUTHOR_FILTER_ATTENTIONS}
 *                   <li> {@link #AUTHOR_FILTER_STRANGER}
 * @param sourceType 来源筛选类型，0：全部、1：来自微博的评论、2：来自微群的评论。可分为以下几种：
 *                   <li> {@link #SRC_FILTER_ALL}
 *                   <li> {@link #SRC_FILTER_WEIBO}
 *                   <li> {@link #SRC_FILTER_WEIQUN}
 * @param filterType 原创筛选类型，0：全部微博、1：原创的微博，默认为0。可分为以下几种：
 *                   <li> {@link #TYPE_FILTER_ALL}
 *                   <li> {@link #TYPE_FILTER_ORIGAL}
 * @param listener   异步请求回调接口
 */
public void mentionsIds(long since_id, long max_id, int count, int page, int authorType, int sourceType,
                        int filterType, RequestListener listener) {
    WeiboParameters params = buildTimeLineBase(since_id, max_id, count, page);
    params.put("filter_by_author", authorType);
    params.put("filter_by_source", sourceType);
    params.put("filter_by_type", filterType);
    requestAsync(SERVER_URL_PRIX + "/mentions/ids.json", params, HTTPMETHOD_GET, listener);
}
 

/**
 * 获取某个用户最新发表的微博列表。
 * 
 * @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(String screen_name, 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);
    params.put("screen_name", screen_name);
    requestAsync(SERVER_URL_PRIX + "/user_timeline.json", params, HTTPMETHOD_GET, listener);
}