Android Http異步請求 Callback

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

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

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

1. package com.juupoo.common;
3. import java.util.ArrayList;
4. import java.util.List;
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;
19. import android.os.Bundle;
20. import android.os.Handler;
21. import android.os.Message;
23. /**
24. * Asynchronous HTTP connections
25. *
26. * @author Greg Zavitz & Joseph Roth
27. */
28. public class HttpConnection implements Runnable {
30. public static final int DID_START = 0;
31. public static final int DID_ERROR = 1;
32. public static final int DID_SUCCEED = 2;
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;
40. private String url;
41. private int method;
42. private String data;
43. private CallbackListener listener;
45. private HttpClient httpClient;
47. // public HttpConnection() {
48. // this(new Handler());
49. // }
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. }
59. public void get(String url) {
60. create(GET, url, null, listener);
61. }
63. public void post(String url, String data, CallbackListener listener) {
64. create(POST, url, data, listener);
65. }
67. public void put(String url, String data) {
68. create(PUT, url, data, listener);
69. }
71. public void delete(String url) {
72. create(DELETE, url, null, listener);
73. }
75. public void bitmap(String url) {
76. create(BITMAP, url, null, listener);
77. }
79. public interface CallbackListener {
80. public void callBack(String result);
81. }
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. };
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. }
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. // }
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);
157. }
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);
165. DefaultHttpClient httpClient = new DefaultHttpClient(httpParams);
166. return httpClient;
167. }
169. public static boolean isHttpSuccessExecuted(HttpResponse response) {
170. int statusCode = response.getStatusLine().getStatusCode();
171. return (statusCode > 199) && (statusCode < 400);
172. }
174. }

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

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

1. new HttpConnection().post("user.login", args, callbackListener);
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. };