Android Http異步請求 Callback

之前一直在用HTML5開發移動本地應用，後來發現，實際上HTML5開發的本地應用，開發效率高，而且跨平台，但是體驗，相應無法和原生應用，還有一定差距。

開發HTML5和遠程交互，采用JSONP，是異步方式。Android的異步方式不太一樣，采用的是多線程和Handler的方式處理。

1 首先是HttpConnection，方法包括HttPost, HttpGet

1. package com.juupoo.common;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. import org.apache.http.HttpResponse;  
7. import org.apache.http.NameValuePair;  
8. import org.apache.http.client.HttpClient;  
9. import org.apache.http.client.entity.UrlEncodedFormEntity;  
10. import org.apache.http.client.methods.HttpGet;  
11. import org.apache.http.client.methods.HttpPost;  
12. import org.apache.http.impl.client.DefaultHttpClient;  
13. import org.apache.http.message.BasicNameValuePair;  
14. import org.apache.http.params.BasicHttpParams;  
15. import org.apache.http.params.HttpConnectionParams;  
16. import org.apache.http.params.HttpParams;  
17. import org.apache.http.util.EntityUtils;  
18.   
19. import android.os.Bundle;  
20. import android.os.Handler;  
21. import android.os.Message;  
22.   
23. /** 
24.  * Asynchronous HTTP connections 
25.  *  
26.  * @author Greg Zavitz & Joseph Roth 
27.  */  
28. public class HttpConnection implements Runnable {  
29.   
30.     public static final int DID_START = 0;  
31.     public static final int DID_ERROR = 1;  
32.     public static final int DID_SUCCEED = 2;  
33.   
34.     private static final int GET = 0;  
35.     private static final int POST = 1;  
36.     private static final int PUT = 2;  
37.     private static final int DELETE = 3;  
38.     private static final int BITMAP = 4;  
39.   
40.     private String url;  
41.     private int method;  
42.     private String data;  
43.     private CallbackListener listener;  
44.   
45.     private HttpClient httpClient;  
46.   
47.     // public HttpConnection() {   
48.     // this(new Handler());   
49.     // }   
50.   
51.     public void create(int method, String url, String data, CallbackListener listener) {  
52.         this.method = method;  
53.         this.url = url;  
54.         this.data = data;  
55.         this.listener = listener;  
56.         ConnectionManager.getInstance().push(this);  
57.     }  
58.   
59.     public void get(String url) {  
60.         create(GET, url, null, listener);  
61.     }  
62.   
63.     public void post(String url, String data, CallbackListener listener) {  
64.         create(POST, url, data, listener);  
65.     }  
66.   
67.     public void put(String url, String data) {  
68.         create(PUT, url, data, listener);  
69.     }  
70.   
71.     public void delete(String url) {  
72.         create(DELETE, url, null, listener);  
73.     }  
74.   
75.     public void bitmap(String url) {  
76.         create(BITMAP, url, null, listener);  
77.     }  
78.   
79.     public interface CallbackListener {  
80.         public void callBack(String result);  
81.     }  
82.   
83.     private static final Handler handler = new Handler() {  
84.         @Override  
85.         public void handleMessage(Message message) {  
86.             switch (message.what) {  
87.                 case HttpConnection.DID_START: {  
88.                     break;  
89.                 }  
90.                 case HttpConnection.DID_SUCCEED: {  
91.                     CallbackListener listener = (CallbackListener) message.obj;  
92.                     Object data = message.getData();  
93.                     if (listener != null) {  
94.                         if(data != null) {  
95.                             Bundle bundle = (Bundle)data;  
96.                             String result = bundle.getString("callbackkey");  
97.                             listener.callBack(result);  
98.                         }  
99.                     }  
100.                     break;  
101.                 }  
102.                 case HttpConnection.DID_ERROR: {  
103.                     break;  
104.                 }  
105.             }  
106.         }  
107.     };  
108.   
109.     public void run() {  
110. //      handler.sendMessage(Message.obtain(handler, HttpConnection.DID_START));   
111.         httpClient = getHttpClient();  
112.         try {  
113.             HttpResponse httpResponse = null;  
114.             switch (method) {  
115.             case GET:  
116.                 httpResponse = httpClient.execute(new HttpGet(  
117.                         StaticInfos.Server_URL + url));  
118.                 break;  
119.             case POST:  
120.                 HttpPost httpPost = new HttpPost(StaticInfos.Server_URL  
121.                         + url);  
122.                 List<NameValuePair> params = new ArrayList<NameValuePair>();  
123.                 BasicNameValuePair valuesPair = new BasicNameValuePair("args",  
124.                         data);  
125.                 params.add(valuesPair);  
126.                 httpPost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));  
127.                 httpResponse = httpClient.execute(httpPost);  
128.                 if (isHttpSuccessExecuted(httpResponse)) {  
129.                     String result = EntityUtils.toString(httpResponse  
130.                             .getEntity());  
131.                     this.sendMessage(result);  
132.                 } else {  
133.                     this.sendMessage("fail");  
134.                 }  
135.                 break;  
136.             }  
137.         } catch (Exception e) {  
138.             this.sendMessage("fail");  
139.         }  
140.         ConnectionManager.getInstance().didComplete(this);  
141.     }  
142.   
143.     // private void processBitmapEntity(HttpEntity entity) throws IOException {   
144.     // BufferedHttpEntity bufHttpEntity = new BufferedHttpEntity(entity);   
145.     // Bitmap bm = BitmapFactory.decodeStream(bufHttpEntity.getContent());   
146.     // handler.sendMessage(Message.obtain(handler, DID_SUCCEED, bm));   
147.     // }   
148.   
149.     private void sendMessage(String result) {  
150.         Message message = Message.obtain(handler, DID_SUCCEED,  
151.                 listener);  
152.         Bundle data = new Bundle();  
153.         data.putString("callbackkey", result);  
154.         message.setData(data);  
155.         handler.sendMessage(message);  
156.           
157.     }  
158.   
159.     public static DefaultHttpClient getHttpClient() {  
160.         HttpParams httpParams = new BasicHttpParams();  
161.         HttpConnectionParams.setConnectionTimeout(httpParams, 20000);  
162.         HttpConnectionParams.setSoTimeout(httpParams, 20000);  
163.         // HttpConnectionParams.setSocketBufferSize(httpParams, 8192);   
164.   
165.         DefaultHttpClient httpClient = new DefaultHttpClient(httpParams);  
166.         return httpClient;  
167.     }  
168.   
169.     public static boolean isHttpSuccessExecuted(HttpResponse response) {  
170.         int statusCode = response.getStatusLine().getStatusCode();  
171.         return (statusCode > 199) && (statusCode < 400);  
172.     }  
173.   
174. }  

2  ConnectionManager類，將線程添加到隊列中

1. package com.juupoo.common;  
2.   
3.   
4. import java.util.ArrayList;  
5.   
6. /** 
7.  * Simple connection manager to throttle connections 
8.  *  
9.  * @author Greg Zavitz 
10.  */  
11. public class ConnectionManager {  
12.       
13.     public static final int MAX_CONNECTIONS = 5;  
14.   
15.     private ArrayList<Runnable> active = new ArrayList<Runnable>();  
16.     private ArrayList<Runnable> queue = new ArrayList<Runnable>();  
17.   
18.     private static ConnectionManager instance;  
19.   
20.     public static ConnectionManager getInstance() {  
21.         if (instance == null)  
22.             instance = new ConnectionManager();  
23.         return instance;  
24.     }  
25.   
26.     public void push(Runnable runnable) {  
27.         queue.add(runnable);  
28.         if (active.size() < MAX_CONNECTIONS)  
29.             startNext();  
30.     }  
31.   
32.     private void startNext() {  
33.         if (!queue.isEmpty()) {  
34.             Runnable next = queue.get(0);  
35.             queue.remove(0);  
36.             active.add(next);  
37.   
38.             Thread thread = new Thread(next);  
39.             thread.start();  
40.         }  
41.     }  
42.   
43.     public void didComplete(Runnable runnable) {  
44.         active.remove(runnable);  
45.         startNext();  
46.     }  
47.   
48. }  

1. new HttpConnection().post("user.login", args, callbackListener);  
2.   
3. private CallbackListener callbackListener = new HttpConnection.CallbackListener() {  
4.         @Override  
5.         public void callBack(String v) {  
6.             if(v != "fail") {  
7.                 if("false".equals(v)) {  
8.                     LoginActivity.this.showInfo(R.string.username_or_pass_error);  
9.                 } else {  
10.                     // 登錄   
11.                     Intent intent = new Intent();  
12.                     intent.setClass(LoginActivity.this, MainActivity.class);  
13.                     LoginActivity.this.startActivity(intent);  
14.                 }  
15.             } else {  
16.                 LoginActivity.this.showInfo(R.string.network_transfer_error);  
17.             }  
18.             progressDialog.dismiss();  
19.         }  
20.     };