else
sb.append(“”
- s.charAt(i) + “”);
}
break;
case 2: // 处理遇到@的情况
// 处理@后面的普通字符
if (Character.isJavaIdentifierPart(s.charAt(i))) {
str += s.charAt(i);
}
else {
// 如果只有一个@，作为普通字符处理
if (“@”.equals(str)) {
sb.append(str);
}
// 将@及后面的普通字符变成蓝色
else {
sb.append(setTextColor(str, String.valueOf(signColor)));
}
// @后面有#的情况，首先应将#添加到str里，这个值可能会变成蓝色，也可以作为普通字符，要看后面还有没有#了
if (s.charAt(i) == ‘#’) {
str = String.valueOf(s.charAt(i));
state = 3;
}
// @后面还有个@的情况，和#类似
else if (s.charAt(i) == ‘@’) {
str = String.valueOf(s.charAt(i));
state = 2;
}
// @后面有除了@、#的其他特殊字符。需要将这个字符作为普通字符处理
else {
if (commonTextColor == Color.BLACK)
sb.append(s.charAt(i));
else
sb.append(“”
- s.charAt(i) + “”);
state = 1;
str = “”;
}
}
break;
case 3: // 处理遇到#的情况
// 前面已经遇到一个#了，这里处理结束的#
if (s.charAt(i) == ‘#’) {
str += s.charAt(i);
sb.append(setTextColor(str, String.valueOf(signColor)));
str = “”;
state = 1;
}
// 如果#后面有@，那么看一下后面是否还有#，如果没有#，前面的#作废，按遇到@处理
else if (s.charAt(i) == ‘@’) {
if (s.substring(i).indexOf(“#”) < 0) {
sb.append(str);
str = String.valueOf(s.charAt(i));
state = 2;
} else {
str += s.charAt(i);
}
}
// 处理#…#之间的普通字符
else {
str += s.charAt(i);
}
break;
}
}
if (state == 1 || state == 3) {
sb.append(str);
} else if (state == 2) {
if (“@”.equals(str)) {
sb.append(str);
} else {
sb.append(setTextColor(str, String.valueOf(signColor)));
}
}
return sb.toString();
}
public static String setTextColor(String s, String color) {
String result = “” + s + “”;
return result;
}
public static String getTimeStr(Date oldTime, Date currentDate) {
long time1 = currentDate.getTime();
long time2 = oldTime.getTime();
long time = (time1 - time2) / 1000;
if (time >= 0 && time < 60) {
return “刚才”;
} else if (time >= 60 && time < 3600) {
return time / 60 + “分钟前”;
} else if (time >= 3600 && time < 3600 * 24) {
return time / 3600 + “小时前”;
} else {
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm”);
return sdf.format(oldTime);
}
}
}
上面定义了一个getWeibo()的方法，可以看到它是通过GlobalObject来获取微博对象的，那在看看这个类
/Wwj_sina_weibo/src/com/wwj/sina/weibo/GlobalObject.java
package com.wwj.sina.weibo;
import android.app.Activity;
import android.app.Application;
import com.weibo.net.Weibo;
import com.wwj.sina.weibo.interfaces.Const;
import com.wwj.sina.weibo.listener.AuthDialogListener;
import com.wwj.sina.weibo.net.PullFile;
import com.wwj.sina.weibo.object.Consumer;
import com.wwj.sina.weibo.workqueue.WorkQueueMonitor;
import com.wwj.sina.weibo.workqueue.WorkQueueStorage;
public class GlobalObject extends Application implements Const{
private Weibo weibo;
private WorkQueueStorage workQueueStorage;
private WorkQueueMonitor imageWorkQueueMonitor;
private WorkQueueMonitor taskWorkQueueMonitor;
public Weibo getWeibo(Activity activity) {
if (weibo == null || !weibo.isSessionValid()) {
weibo = Weibo.getInstance(); // 获取Weibo对象
weibo.setupConsumerConfig(Consumer.consumerKey, Consumer.consumerSecret);
weibo.setRedirectUrl(Consumer.redirectUrl);
weibo.authorize(activity, new AuthDialogListener(activity));
}
return weibo;
}
public Weibo getWeibo() {
return weibo;
}
public WorkQueueStorage getWorkQueueStorage() {
if (workQueueStorage == null){
workQueueStorage = new WorkQueueStorage();
}
return workQueueStorage;
}
public WorkQueueMonitor getWorkQueueMonitor(Activity activity) {
if (imageWorkQueueMonitor == null) {
imageWorkQueueMonitor = new WorkQueueMonitor(activity, getWorkQueueStorage(), new PullFile(), MONITOR_TYPE_IMAGE);
imageWorkQueueMonitor.start();
}
return imageWorkQueueMonitor;
}
}
可以看到这个类是Application级别的，说明最先加载的是这个类，来看这个类定义的getWeibo()方法，现在很直观啦，这里就是获取授权认证的地方。设置好consumerKey和consumerSecret后，就可以调用authorize()方法进行授权了。这个方法在Weibo这个类当中，这个类很重要，能不能使用微博功能就看它了。
/Wwj_sina_weibo/src/com/weibo/net/Weibo.java
/*
-
Copyright 2011 Sina.
-
Licensed under the Apache License and Weibo License, Version 2.0 (the “License”);
-
you may not use this file except in compliance with the License.
-
You may obtain a copy of the License at
-
http://www.open.weibo.com
-
http://www.apache.org/licenses/LICENSE-2.0
-
Unless required by applicable law or agreed to in writing, software
-
distributed under the License is distributed on an “AS IS” BASIS,
-
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
See the License for the specific language governing permissions and
-
limitations under the License.
*/
package com.weibo.net;
import java.io.IOException;
import java.net.MalformedURLException;
import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.webkit.CookieSyncManager;
/**
-
Encapsulation main Weibo APIs, Include: 1. getRquestToken , 2.
-
getAccessToken, 3. url request. Used as a single instance class. Implements a
-
weibo api as a synchronized way.
-
@author ZhangJie (zhangjie2@staff.sina.com.cn)
*/
public class Weibo {
// public static String SERVER = “http://api.t.sina.com.cn/”;
public static String SERVER = “https://api.weibo.com/2/”;
public static String URL_OAUTH_TOKEN = “http://api.t.sina.com.cn/oauth/request_token”;
public static String URL_AUTHORIZE = “http://api.t.sina.com.cn/oauth/authorize”;
public static String URL_ACCESS_TOKEN = “http://api.t.sina.com.cn/oauth/access_token”;
public static String URL_AUTHENTICATION = “http://api.t.sina.com.cn/oauth/authenticate”;
public static String URL_OAUTH2_ACCESS_TOKEN = “https://api.weibo.com/oauth2/access_token”;
// public static String URL_OAUTH2_ACCESS_AUTHORIZE =
// “http://t.weibo.com:8093/oauth2/authorize”;
public static String URL_OAUTH2_ACCESS_AUTHORIZE = “https://api.weibo.com/oauth2/authorize”;
private static String APP_KEY = “”;
private static String APP_SECRET = “”;
private static Weibo mWeiboInstance = null;
private Token mAccessToken = null;
private RequestToken mRequestToken = null;
private WeiboDialogListener mAuthDialogListener;
private static final int DEFAULT_AUTH_ACTIVITY_CODE = 32973;
public static final String TOKEN = “access_token”;
public static final String EXPIRES = “expires_in”;
public static final String DEFAULT_REDIRECT_URI = “wbconnect://success”;// 暂不支持
public static final String DEFAULT_CANCEL_URI = “wbconnect://cancel”;// 暂不支持
private String mRedirectUrl;
private Weibo() {
Utility.setRequestHeader(“Accept-Encoding”, “gzip”);
Utility.setTokenObject(this.mRequestToken);
mRedirectUrl = DEFAULT_REDIRECT_URI;
}
/**
-
获取单例
-
@return
*/
public synchronized static Weibo getInstance() {
if (mWeiboInstance == null) {
mWeiboInstance = new Weibo();
}
return mWeiboInstance;
}
// 设置accessToken
public void setAccessToken(AccessToken token) {
mAccessToken = token;
}
public Token getAccessToken() {
return this.mAccessToken;
}
/**
-
设置第三方key和secret
-
@param consumer_key
-
@param consumer_secret
*/
public void setupConsumerConfig(String consumer_key, String consumer_secret) {
Weibo.APP_KEY = consumer_key;
Weibo.APP_SECRET = consumer_secret;
}
public static String getAppKey() {
return Weibo.APP_KEY;
}
public static String getAppSecret() {
return Weibo.APP_SECRET;
}
public void setRequestToken(RequestToken token) {
this.mRequestToken = token;
}
public static String getSERVER() {
return SERVER;
}
public static void setSERVER(String sERVER) {
SERVER = sERVER;
}
// 设置oauth_verifier
public void addOauthverifier(String verifier) {
mRequestToken.setVerifier(verifier);
}
public String getRedirectUrl() {
return mRedirectUrl;
}
/**
-
设置第三方回调页
-
@param mRedirectUrl
*/
public void setRedirectUrl(String mRedirectUrl) {
this.mRedirectUrl = mRedirectUrl;
}
/**
-
Requst sina weibo open api by get or post
-
@param url
-
Openapi request URL. -
@param params
-
http get or post parameters . e.g. -
gettimeling?max=max_id&min=min_id max and max_id is a pair of -
key and value for params, also the min and min_id -
@param httpMethod
-
http verb: e.g. "GET", "POST", "DELETE" -
@throws IOException
-
@throws MalformedURLException
-
@throws WeiboException
*/
public String request(Context context, String url, WeiboParameters params, String httpMethod,
Token token) throws WeiboException {
String rlt = Utility.openUrl(context, url, httpMethod, params, this.mAccessToken);
return rlt;
}
/**/
public RequestToken getRequestToken(Context context, String key, String secret,
String callback_url) throws WeiboException {
Utility.setAuthorization(new RequestTokenHeader());
WeiboParameters postParams = new WeiboParameters();
postParams.add(“oauth_callback”, callback_url);
String rlt;
rlt = Utility.openUrl(context, Weibo.URL_OAUTH_TOKEN, “POST”, postParams, null);
RequestToken request = new RequestToken(rlt);
this.mRequestToken = request;
return request;
}
public AccessToken generateAccessToken(Context context, RequestToken requestToken)
throws WeiboException {
Utility.setAuthorization(new AccessTokenHeader());
WeiboParameters authParam = new WeiboParameters();
authParam.add(“oauth_verifier”, this.mRequestToken.getVerifier()/* “605835” */);
authParam.add(“source”, APP_KEY);
String rlt = Utility.openUrl(context, Weibo.URL_ACCESS_TOKEN, “POST”, authParam,
this.mRequestToken);
AccessToken accessToken = new AccessToken(rlt);
this.mAccessToken = accessToken;
return accessToken;
}
public AccessToken getXauthAccessToken(Context context, String app_key, String app_secret,
String usrname, String password) throws WeiboException {
Utility.setAuthorization(new XAuthHeader());
WeiboParameters postParams = new WeiboParameters();
postParams.add(“x_auth_username”, usrname);
postParams.add(“x_auth_password”, password);
postParams.add(“oauth_consumer_key”, APP_KEY);
String rlt = Utility.openUrl(context, Weibo.URL_ACCESS_TOKEN, “POST”, postParams, null);
AccessToken accessToken = new AccessToken(rlt);
this.mAccessToken = accessToken;
return accessToken;
}
/**
-
获取Oauth2.0的accesstoken
-
https://api.weibo.com/oauth2/access_token?client_id=YOUR_CLIENT_ID&
-
client_secret=YOUR_CLIENT_SECRET&grant_type=password&redirect_uri=
-
YOUR_REGISTERED_REDIRECT_URI&username=USER_NAME&pasword=PASSWORD
-
@param context
-
@param app_key
-
@param app_secret
-
@param usrname
-
@param password
-
@return
-
@throws WeiboException
*/
public Oauth2AccessToken getOauth2AccessToken(Context context, String app_key,
String app_secret, String usrname, String password) throws WeiboException {
Utility.setAuthorization(new Oauth2AccessTokenHeader());
WeiboParameters postParams = new WeiboParameters();
postParams.add(“username”, usrname);
postParams.add(“password”, password);
postParams.add(“client_id”, app_key);
postParams.add(“client_secret”, app_secret);
postParams.add(“grant_type”, “password”);
String rlt = Utility.openUrl(context, Weibo.URL_OAUTH2_ACCESS_TOKEN, “POST”, postParams,
null);
Oauth2AccessToken accessToken = new Oauth2AccessToken(rlt);
this.mAccessToken = accessToken;
return accessToken;
}
/**
-
Share text content or image to weibo .
*/
public boolean share2weibo(Activity activity, String accessToken, String tokenSecret,
String content, String picPath) throws WeiboException {
if (TextUtils.isEmpty(accessToken)) {
throw new WeiboException(“token can not be null!”);
}
// else if (TextUtils.isEmpty(tokenSecret)) {
// throw new WeiboException(“secret can not be null!”);
// }
if (TextUtils.isEmpty(content) && TextUtils.isEmpty(picPath)) {
throw new WeiboException(“weibo content can not be null!”);
}
Intent i = new Intent(activity, ShareActivity.class);
i.putExtra(ShareActivity.EXTRA_ACCESS_TOKEN, accessToken);
i.putExtra(ShareActivity.EXTRA_TOKEN_SECRET, tokenSecret);
i.putExtra(ShareActivity.EXTRA_WEIBO_CONTENT, content);
i.putExtra(ShareActivity.EXTRA_PIC_URI, picPath);
activity.startActivity(i);
return true;
}
private boolean startSingleSignOn(Activity activity, String applicationId,
String[] permissions, int activityCode) {
return false;
}
public static boolean flag = false;
private void startDialogAuth(Activity activity, String[] permissions) {
if(flag == true) return;
WeiboParameters params = new WeiboParameters();
if (permissions.length > 0) {
params.add(“scope”, TextUtils.join(“,”, permissions));
}
CookieSyncManager.createInstance(activity);
dialog(activity, params, new WeiboDialogListener() {
public void onComplete(Bundle values) {
flag = false;
// ensure any cookies set by the dialog are saved
CookieSyncManager.getInstance().sync();
if (null == mAccessToken) {
mAccessToken = new Token();
}
mAccessToken.setToken(values.getString(TOKEN));
mAccessToken.setExpiresIn(values.getString(EXPIRES));
if (isSessionValid()) {
Log.d(“Weibo-authorize”,
“Login Success! access_token=” + mAccessToken.getToken() + " expires="
- mAccessToken.getExpiresIn());
mAuthDialogListener.onComplete(values);
} else {
Log.d(“Weibo-authorize”, “Failed to receive access token”);
mAuthDialogListener.onWeiboException(new WeiboException(
“Failed to receive access token.”));
}
}
public void onError(DialogError error) {
flag = false;
Log.d(“Weibo-authorize”, "Login failed: " + error);
mAuthDialogListener.onError(error);
}
public void onWeiboException(WeiboException error) {
flag = false;
Log.d(“Weibo-authorize”, "Login failed: " + error);
mAuthDialogListener.onWeiboException(error);
}
public void onCancel() {
flag = false;
Log.d(“Weibo-authorize”, “Login canceled”);
mAuthDialogListener.onCancel();
}
});
flag = true;
}
/**
-
User-Agent Flow
-
@param activity
-
@param listener
-
授权结果监听器
*/
public void authorize(Activity activity, final WeiboDialogListener listener) {
authorize(activity, new String[] {}, DEFAULT_AUTH_ACTIVITY_CODE, listener);
}
@SuppressWarnings(“unused”)
private void authorize(Activity activity, String[] permissions,
final WeiboDialogListener listener) {
authorize(activity, permissions, DEFAULT_AUTH_ACTIVITY_CODE, listener);
}
private void authorize(Activity activity, String[] permissions, int activityCode,
final WeiboDialogListener listener) {
Utility.setAuthorization(new Oauth2AccessTokenHeader());
boolean singleSignOnStarted = false;
mAuthDialogListener = listener;
// Prefer single sign-on, where available.
if (activityCode >= 0) {
singleSignOnStarted = startSingleSignOn(activity, APP_KEY, permissions, activityCode);
}
// Otherwise fall back to traditional dialog.
if (!singleSignOnStarted) {
startDialogAuth(activity, permissions);
}
}
@SuppressWarnings(“unused”)
private void authorizeCallBack(int requestCode, int resultCode, Intent data) {
}
public void dialog(Context context, WeiboParameters parameters,
final WeiboDialogListener listener) {
parameters.add(“client_id”, APP_KEY);
parameters.add(“response_type”, “token”);
parameters.add(“redirect_uri”, mRedirectUrl);
parameters.add(“display”, “mobile”);
if (isSessionValid()) {
parameters.add(TOKEN, mAccessToken.getToken());
}
String url = URL_OAUTH2_ACCESS_AUTHORIZE + “?” + Utility.encodeUrl(parameters);
if (context.checkCallingOrSelfPermission(Manifest.permission.INTERNET) != PackageManager.PERMISSION_GRANTED) {
Utility.showAlert(context, “Error”,
“Application requires permission to access the Internet”);
} else {
new WeiboDialog(this, context, url, listener).show();
}
}
public boolean isSessionValid() {
if (mAccessToken != null) {
return (!TextUtils.isEmpty(mAccessToken.getToken()) && (mAccessToken.getExpiresIn() == 0 || (System
.currentTimeMillis() < mAccessToken.getExpiresIn())));
}
return false;
}
}
你们自己找到authorize()看看呗，怎么弹出那个登录界面的自己研究去，这个方法需要传入一个listener，
就是这个类了AuthDialogListener
/Wwj_sina_weibo/src/com/wwj/sina/weibo/listener/AuthDialogListener.java
授权完成后，回调这个类的onComplete方法，然后就可以获取微博数据了。
package com.wwj.sina.weibo.listener;
import android.app.Activity;
import android.os.Bundle;
import android.widget.Toast;
import com.weibo.net.DialogError;
import com.weibo.net.WeiboDialogListener;
import com.weibo.net.WeiboException;
import com.wwj.sina.weibo.HomeActivity;
import com.wwj.sina.weibo.adapter.WeiboListAdapter;
import com.wwj.sina.weibo.interfaces.Const;
import com.wwj.sina.weibo.library.StorageManager;
import com.wwj.sina.weibo.library.WeiboData;
import com.wwj.sina.weibo.library.WeiboManager;
import com.wwj.sina.weibo.object.User;
import com.wwj.sina.weibo.util.SettingUtil;
public class AuthDialogListener implements WeiboDialogListener {
private Activity activity;
public AuthDialogListener(Activity activity) {
super();
this.activity = activity;
}
public void onComplete(Bundle values) {
// 保存access_token 和 expires_in
String token = values.getString(“access_token”);
String expires_in = values.getString(“expires_in”);
SettingUtil.set(activity, SettingUtil.ACCESS_TOKEN, token);
SettingUtil.set(activity, SettingUtil.EXPIRES_IN, expires_in);
Toast.makeText(activity, “认证成功”, Toast.LENGTH_SHORT).show();
HomeActivity homeActivity = (HomeActivity) activity;
WeiboListAdapter weiboListAdapter = null;
long uid = Long.parseLong(values.getString(“uid”));
User user = WeiboManager.getUser(activity, uid);
if (user != null) {
homeActivity.username.setText(user.name);
StorageManager.setValue(activity, “uid”, uid); // 保存用户UID
}
weiboListAdapter = WeiboData.loadWeiboListData(activity, Const.HOME,
homeActivity.weiboListView);
homeActivity.homeData.weiboListAdapter = weiboListAdapter;
}
public void onWeiboException(WeiboException e) {
// 当认证过程中捕获到WeiboException时调用
Toast.makeText(activity, “Auth exception:” + e.getMessage(),
Toast.LENGTH_LONG).show();
}
public void onError(DialogError e) {
// Oauth2.0认证过程中，当认证对话框中的webView接收数据出现错误时调用此方法
Toast.makeText(activity, “Auth error:” + e.getMessage(),
Toast.LENGTH_LONG).show();
}
public void onCancel() {
// Oauth2.0认证过程中，如果认证窗口被关闭或认证取消时调用
Toast.makeText(activity, “Auth cancel”, Toast.LENGTH_LONG).show();
}
}
执行完这个就已经把数据显示出来了
WeiboData.loadWeiboListData(activity, Const.HOME,homeActivity.weiboListView);
这里又有一个WeiboData这个类，看看就明白了
package com.wwj.sina.weibo.library;
import java.util.List;
import android.app.Activity;
import android.widget.ListView;
import com.wwj.sina.weibo.adapter.WeiboListAdapter;
import com.wwj.sina.weibo.interfaces.Const;
import com.wwj.sina.weibo.object.Status;
import com.wwj.sina.weibo.util.Tools;
public class WeiboData implements Const {
public static WeiboListAdapter loadWeiboListData(Activity activity,
int type, ListView listView) {
return loadWeiboListData(activity, type, listView, null);
}
public static WeiboListAdapter loadWeiboListData(Activity activity,
int type, ListView listView, List statuses) {
WeiboListAdapter adapter = null;
if (Tools.hasWeibo(activity)) {
switch (type) {
case HOME:
if (statuses == null)
statuses = WeiboManager.getHomeTimeline(activity);
adapter = new WeiboListAdapter(activity, statuses, type);
break;
default:
break;
}
listView.setAdapter(adapter);
}
return adapter;
}
}
可以看到，这里ListView就直接setAdapter了。来看到第二个loadWeiboListData方法，有一个List statuses参数，这个就是保存微博数据的参数了，是怎么得到的？我们又可以看到一个类WeiboManager里有一个getHomeTimeline的方法，这个就是返回微博数据的方法。
等不及了，进去看看。
/Wwj_sina_weibo/src/com/wwj/sina/weibo/library/WeiboManager.java
package com.wwj.sina.weibo.library;
import java.io.File;
import java.util.List;
import android.app.Activity;
import com.weibo.net.AsyncWeiboRunner;
import com.weibo.net.AsyncWeiboRunner.RequestListener;
import com.weibo.net.Weibo;
import com.weibo.net.WeiboParameters;
import com.wwj.sina.weibo.interfaces.Const;
import com.wwj.sina.weibo.object.Consumer;
import com.wwj.sina.weibo.object.Status;
import com.wwj.sina.weibo.object.User;
import com.wwj.sina.weibo.util.Tools;
import com.wwj.sina.weibo.workqueue.DoneAndProcess;
import com.wwj.sina.weibo.workqueue.WorkQueueStorage;
import com.wwj.sina.weibo.workqueue.task.PullFileTask;
/**
-
微博管理类，提供方法获取微博数据
-
@author Administrator
*/
public class WeiboManager implements Const {
public static List getHomeTimeline(Activity activity) {
return getHomeTimeline(activity, 0, 0, DEFAULT_STATUS_COUNT);
}
private static List getHomeTimeline(Activity activity,
long sinceId, long maxId, int count) {
return getHomeTimeline(activity, sinceId, maxId, count, false, null);
}
/**
-
获取当前登录用户及其所关注用户的最新微博
-
@param activity
-
@param sinceId
-
@param maxId
-
@param count
-
@param async
-
是否同步 -
@param listener
-
@return
*/
@SuppressWarnings(“unchecked”)
public static List getHomeTimeline(Activity activity,
long sinceId, long maxId, int count, boolean async,
RequestListener listener) {
// 访问接口url
String url = Weibo.SERVER + “statuses/home_timeline.json”;
// 获取微博对象
Weibo weibo = Tools.getWeibo(activity);
if (weibo == null || !weibo.isSessionValid()) {
return null;
}
WeiboParameters bundle = new WeiboParameters();
bundle.add(“source”, Consumer.consumerKey);
if (sinceId != 0)
bundle.add(“since_id”, String.valueOf(sinceId));
if (maxId != 0)
bundle.add(“max_id”, String.valueOf(maxId));
if (count != 0)
bundle.add(“count”, String.valueOf(count));
List statuses = null;
try {
if (!async) {
// 请求获取JSON数据
String json = weibo.request(activity, url, bundle, “GET”,
weibo.getAccessToken());
statuses = JSONAndObject
.convert(Status.class, json, “statuses”);
} else {
AsyncWeiboRunner asyncWeiboRunner = new AsyncWeiboRunner(weibo);
asyncWeiboRunner
.request(activity, url, bundle, “GET”, listener);
}
} catch (Exception e) {
}
return statuses;
}
public static String getImageurl(Activity activity, String url) {
return getImageurl(activity, url, null);
}
public static String getImageurl(Activity activity, String url,
DoneAndProcess doneAndProcess) {
String result = null;
if (url == null || “”.equals(url))
return result;
result = PATH_FILE_CACHE + “/” + url.hashCode();
File file = new File(PATH_FILE_CACHE + “/” + url.hashCode());
if (file.exists()) {
return result;
} else {
WorkQueueStorage workQueueStorage = Tools.getGlobalObject(activity)
.getWorkQueueStorage();
if (workQueueStorage != null) {
if (doneAndProcess == null) {
workQueueStorage.addDoneWebFileUrl(url);
} else {
PullFileTask pullFileTask = new PullFileTask();
pullFileTask.doneAndProcess = doneAndProcess;
pullFileTask.fileUrl = url;
workQueueStorage.addTask(pullFileTask);
}
}
result = null;
}
return result;
}
public static boolean hasPicture(Status status) {
if (status.thumbnail_pic != null && !“”.equals(status.thumbnail_pic))
return true;
if (status.retweeted_status != null) {
if (status.retweeted_status.thumbnail_pic != null
&& !“”.equals(status.retweeted_status.thumbnail_pic)) {
return true;
}
}
return false;
}
public static User getUser(Activity activity, long uid) {
return getUser(activity, uid, null, false, null);
}
public static User getUser(Activity activity, String screen_name) {
return getUser(activity, 0, screen_name, false, null);
}
public static User getUser(Activity activity, long uid, String screen_name,
boolean async, RequestListener listener) {
String url = Weibo.SERVER + “users/show.json”;
Weibo weibo = Tools.getWeibo(activity);
if (weibo == null || !weibo.isSessionValid()) {
return null;
}
User user = null;
WeiboParameters bundle = new WeiboParameters();
bundle.add(“source”, Consumer.consumerKey);
if (uid > 0) {
bundle.add(“uid”, String.valueOf(uid));
} else if (screen_name != null) {
bundle.add(“screen_name”, screen_name);
} else {
return user;
}
try {
if (!async) {
String json = weibo.request(activity, url, bundle, “GET”,
weibo.getAccessToken());
user = new User();
JSONAndObject.convertSingleObject((Object) user, json);
} else {
AsyncWeiboRunner asyncWeiboRunner = new AsyncWeiboRunner(weibo);
asyncWeiboRunner
.request(activity, url, bundle, “GET”, listener);
}
} catch (Exception e) {
}
return user;
}
}
只看 getHomeTimeline()这个方法，一直追踪，很快就可以知道这个微博数据是怎么得到的了。
public static List getHomeTimeline(Activity activity,
long sinceId, long maxId, int count, boolean async,
RequestListener listener) {
// 访问接口url
String url = Weibo.SERVER + “statuses/home_timeline.json”;
// 获取微博对象
Weibo weibo = Tools.getWeibo(activity);
if (weibo == null || !weibo.isSessionValid()) {
return null;
}
WeiboParameters bundle = new WeiboParameters();
bundle.add(“source”, Consumer.consumerKey);
if (sinceId != 0)
bundle.add(“since_id”, String.valueOf(sinceId));
if (maxId != 0)
bundle.add(“max_id”, String.valueOf(maxId));
if (count != 0)
bundle.add(“count”, String.valueOf(count));
List statuses = null;
try {
if (!async) {
// 请求获取JSON数据
String json = weibo.request(activity, url, bundle, “GET”,
weibo.getAccessToken());
statuses = JSONAndObject
.convert(Status.class, json, “statuses”);
} else {
AsyncWeiboRunner asyncWeiboRunner = new AsyncWeiboRunner(weibo);
asyncWeiboRunner
.request(activity, url, bundle, “GET”, listener);
}
} catch (Exception e) {
}
return statuses;
}
就是这个方法了，通过调用weibo对象的request()方法，返回Json字符串，通过解析得到的JSON字符串得到statuses数组。这里需要进行的转换，全靠JSONAndObject这个类
package com.wwj.sina.weibo.library;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import org.json.JSONArray;
import org.json.JSONObject;
import android.util.Log;
import com.wwj.sina.weibo.interfaces.WeiboObject;
public class JSONAndObject {
/**
-
将一个对象转换为JSON格式的字符串，只转换public类型的变量
-
@param obj
-
@return
*/
public static String convertSingleObjectToJson(Object obj) {
String json = null;
if (obj == null) {
return json;
}
Field[] fields = obj.getClass().getFields();
json = “{”;
// 开始转换每一个public类型的变量
for (int i = 0; i < fields.length; i++) {
try {
Field field = fields[i];
if (field.getType() == String.class) {
// 属性值为null, 用空字符串取代
String temp = ((field.get(obj) == null) ? “” : String
.valueOf(field.get(obj)));
// 处理字符串中的双引号
// JSON字符串中不能直接使用双引号
temp = temp.replaceAll(“”“, “\\””);
json += “”" + field.getName() + “”:“” + temp + “”";
}
// long类型
else if (field.getType() == long.class) {
json += “”" + field.getName() + “”:" + field.getLong(obj);
}
// int类型
else if (field.getType() == int.class) {
json += “”" + field.getName() + “”:" + field.getInt(obj);
}
// boolean类型
else if (field.getType() == boolean.class) {
json += “”" + field.getName() + “”:"
- field.getBoolean(obj);
}
// Object类型（WeiboObject类型)
else {
Object fieldObject = field.get(obj);
if (fieldObject instanceof WeiboObject) {
// 如果对象中含有对象类型的变量
// 递归生成JSON字符串
json += “”" + field.getName() + “”:"
- convertSingleObjectToJson(fieldObject);
} else {
continue;
}
}
if (i < fields.length - 1) {
json += “,”;
}
} catch (Exception e) {
}
}
json += “}”;
return json;
}
/**
-
将obj转换为JSON字符串，该字符串必须是一个对象 其中obj必须是一个List，而且JSON字符串必须包含一个propertyName
-
制定的属性，属性值是JSON数组，该数组与obj指定的List对应 类似于hometimeline.json返回的JSON字符串的逆过程
-
@param obj
-
@param propertyName
-
@return
*/
public static String covertObjectToJson(Object obj, String propertyName) {
String json = null;
if (obj == null) {
return json;
}
if (obj instanceof List) {
List list = (List) obj;
if (propertyName != null) {
// 包含一个属性的对象，这个属性是对象数组
json = “{”" + propertyName + “”:[";
} else {
// 对象数组
json = “[”;
}
for (int i = 0; i < list.size(); i++) {
Object item = list.get(i);
json += convertSingleObjectToJson(item);
if (i < list.size() - 1)
json += “,”;
}
if (propertyName != null) {
json += “]}”;
} else {
json = “]”;
}
}
return json;
}
/**
-
将json字符串转换为List
-
@param c
-
@param json
-
@param propertyName
-
这个参数用来制定属性的对象，而且这个属性值必须是一个数组 -
@return
*/
public static List convert(Class c, String json, String propertyName) {
List objs = null;
if (c == null || json == null)
return objs;
try {
// 只使用public类型字段
Field[] fields = c.getFields();
if (fields != null) {
String jsonStr = json;
if (propertyName != null) {
JSONObject jsonObject = new JSONObject(json);
jsonStr = jsonObject.get(propertyName).toString();
}
JSONArray jsonArray = new JSONArray(jsonStr);
objs = new ArrayList();
for (int i = 0; i < jsonArray.length(); i++) {
Object obj = c.newInstance();
objs.add(obj);
convertSingleObject(obj, jsonArray.getString(i));
}
}
} catch (Exception e) {
Log.d(“convert”, e.getMessage());
}
return objs;
}
/**
-
使用该方法需要先创建一个object,传入第一个参数 将JSON格式的数据转换为一个对象 json参数的值必须是一个JSON格式的对象，不能是数组
-
@param obj
-
@param json
-
@return
*/
public static Object convertSingleObject(Object obj, String json) {
if (obj == null || json == null)
return obj;
try {
// 只使用public类型字段
Field[] fields = obj.getClass().getFields();
if (fields != null) {
JSONObject jsonObject = new JSONObject(json);
for (Field field : fields) {
try {
Object objValue = jsonObject.get(field.getName());
// 字符串类型
if (field.getType() == String.class) {
field.set(obj, String.valueOf(objValue));
}
// long类型
else if (field.getType() == long.class) {
field.set(obj,
Long.valueOf(String.valueOf(objValue)));
} // int类型
else if (field.getType() == int.class) {
field.set(obj,
Integer.valueOf(String.valueOf(objValue)));
}
// boolean类型
else if (field.getType() == boolean.class) {
field.set(obj, Boolean.getBoolean(String
.valueOf(objValue)));
}
// Object类型(WeiboObject类型）
else {
Object fieldObject = field.getType().newInstance();
if (fieldObject instanceof WeiboObject) {
convertSingleObject(fieldObject,
String.valueOf(objValue));
field.set(obj, fieldObject);
最后
分享一份工作1到5年以上的Android程序员架构进阶学习路线体系，希望能对那些还在从事Android开发却还不知道如何去提升自己的，还处于迷茫的朋友！
-
阿里P7级Android架构师技术脑图；查漏补缺，体系化深入学习提升
-
**全套体系化高级架构视频；**七大主流技术模块，视频+源码+笔记
有任何问题，欢迎广大网友一起来交流
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！
ull;
if (c == null || json == null)
return objs;
try {
// 只使用public类型字段
Field[] fields = c.getFields();
if (fields != null) {
String jsonStr = json;
if (propertyName != null) {
JSONObject jsonObject = new JSONObject(json);
jsonStr = jsonObject.get(propertyName).toString();
}
JSONArray jsonArray = new JSONArray(jsonStr);
objs = new ArrayList();
for (int i = 0; i < jsonArray.length(); i++) {
Object obj = c.newInstance();
objs.add(obj);
convertSingleObject(obj, jsonArray.getString(i));
}
}
} catch (Exception e) {
Log.d(“convert”, e.getMessage());
}
return objs;
}
/**
-
使用该方法需要先创建一个object,传入第一个参数 将JSON格式的数据转换为一个对象 json参数的值必须是一个JSON格式的对象，不能是数组
-
@param obj
-
@param json
-
@return
*/
public static Object convertSingleObject(Object obj, String json) {
if (obj == null || json == null)
return obj;
try {
// 只使用public类型字段
Field[] fields = obj.getClass().getFields();
if (fields != null) {
JSONObject jsonObject = new JSONObject(json);
for (Field field : fields) {
try {
Object objValue = jsonObject.get(field.getName());
// 字符串类型
if (field.getType() == String.class) {
field.set(obj, String.valueOf(objValue));
}
// long类型
else if (field.getType() == long.class) {
field.set(obj,
Long.valueOf(String.valueOf(objValue)));
} // int类型
else if (field.getType() == int.class) {
field.set(obj,
Integer.valueOf(String.valueOf(objValue)));
}
// boolean类型
else if (field.getType() == boolean.class) {
field.set(obj, Boolean.getBoolean(String
.valueOf(objValue)));
}
// Object类型(WeiboObject类型）
else {
Object fieldObject = field.getType().newInstance();
if (fieldObject instanceof WeiboObject) {
convertSingleObject(fieldObject,
String.valueOf(objValue));
field.set(obj, fieldObject);
最后
分享一份工作1到5年以上的Android程序员架构进阶学习路线体系，希望能对那些还在从事Android开发却还不知道如何去提升自己的，还处于迷茫的朋友！
-
阿里P7级Android架构师技术脑图；查漏补缺，体系化深入学习提升
[外链图片转存中…(img-pmqakA15-1715097657666)]
-
**全套体系化高级架构视频；**七大主流技术模块，视频+源码+笔记
[外链图片转存中…(img-6muTL2EU-1715097657668)]
有任何问题，欢迎广大网友一起来交流
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！
扫一扫
400
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
