Android Http异步请求，Callback

之前一直在用HTML5开发移动本地应用，后来发现，实际上HTML5开发的本地应用，开发效率高，而且跨平台，但是体验，相应无法和原生应用，还有一定差距。

开发HTML5和远程交互，采用JSONP，是异步方式。Android的异步方式不太一样，采用的是多线程和Handler的方式处理。

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

package com.juupoo.common;



import java.util.ArrayList;

import java.util.List;



import org.apache.http.HttpResponse;

import org.apache.http.NameValuePair;

import org.apache.http.client.HttpClient;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.message.BasicNameValuePair;

import org.apache.http.params.BasicHttpParams;

import org.apache.http.params.HttpConnectionParams;

import org.apache.http.params.HttpParams;

import org.apache.http.util.EntityUtils;



import android.os.Bundle;

import android.os.Handler;

import android.os.Message;



/**

 * Asynchronous HTTP connections

 * 

 * @author Greg Zavitz & Joseph Roth

 */

public class HttpConnection implements Runnable {



	public static final int DID_START = 0;

	public static final int DID_ERROR = 1;

	public static final int DID_SUCCEED = 2;



	private static final int GET = 0;

	private static final int POST = 1;

	private static final int PUT = 2;

	private static final int DELETE = 3;

	private static final int BITMAP = 4;



	private String url;

	private int method;

	private String data;

	private CallbackListener listener;



	private HttpClient httpClient;



	// public HttpConnection() {

	// this(new Handler());

	// }



	public void create(int method, String url, String data, CallbackListener listener) {

		this.method = method;

		this.url = url;

		this.data = data;

		this.listener = listener;

		ConnectionManager.getInstance().push(this);

	}



	public void get(String url) {

		create(GET, url, null, listener);

	}



	public void post(String url, String data, CallbackListener listener) {

		create(POST, url, data, listener);

	}



	public void put(String url, String data) {

		create(PUT, url, data, listener);

	}



	public void delete(String url) {

		create(DELETE, url, null, listener);

	}



	public void bitmap(String url) {

		create(BITMAP, url, null, listener);

	}



	public interface CallbackListener {

		public void callBack(String result);

	}



	private static final Handler handler = new Handler() {

		@Override

		public void handleMessage(Message message) {

			switch (message.what) {

				case HttpConnection.DID_START: {

					break;

				}

				case HttpConnection.DID_SUCCEED: {

					CallbackListener listener = (CallbackListener) message.obj;

					Object data = message.getData();

					if (listener != null) {

						if(data != null) {

							Bundle bundle = (Bundle)data;

							String result = bundle.getString("callbackkey");

							listener.callBack(result);

						}

					}

					break;

				}

				case HttpConnection.DID_ERROR: {

					break;

				}

			}

		}

	};



	public void run() {

//		handler.sendMessage(Message.obtain(handler, HttpConnection.DID_START));

		httpClient = getHttpClient();

		try {

			HttpResponse httpResponse = null;

			switch (method) {

			case GET:

				httpResponse = httpClient.execute(new HttpGet(

						StaticInfos.Server_URL + url));

				break;

			case POST:

				HttpPost httpPost = new HttpPost(StaticInfos.Server_URL

						+ url);

				List<NameValuePair> params = new ArrayList<NameValuePair>();

				BasicNameValuePair valuesPair = new BasicNameValuePair("args",

						data);

				params.add(valuesPair);

				httpPost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));

				httpResponse = httpClient.execute(httpPost);

				if (isHttpSuccessExecuted(httpResponse)) {

					String result = EntityUtils.toString(httpResponse

							.getEntity());

					this.sendMessage(result);

				} else {

					this.sendMessage("fail");

				}

				break;

			}

		} catch (Exception e) {

			this.sendMessage("fail");

		}

		ConnectionManager.getInstance().didComplete(this);

	}



	// private void processBitmapEntity(HttpEntity entity) throws IOException {

	// BufferedHttpEntity bufHttpEntity = new BufferedHttpEntity(entity);

	// Bitmap bm = BitmapFactory.decodeStream(bufHttpEntity.getContent());

	// handler.sendMessage(Message.obtain(handler, DID_SUCCEED, bm));

	// }



	private void sendMessage(String result) {

		Message message = Message.obtain(handler, DID_SUCCEED,

				listener);

		Bundle data = new Bundle();

		data.putString("callbackkey", result);

		message.setData(data);

		handler.sendMessage(message);

		

	}



	public static DefaultHttpClient getHttpClient() {

		HttpParams httpParams = new BasicHttpParams();

		HttpConnectionParams.setConnectionTimeout(httpParams, 20000);

		HttpConnectionParams.setSoTimeout(httpParams, 20000);

		// HttpConnectionParams.setSocketBufferSize(httpParams, 8192);



		DefaultHttpClient httpClient = new DefaultHttpClient(httpParams);

		return httpClient;

	}



	public static boolean isHttpSuccessExecuted(HttpResponse response) {

		int statusCode = response.getStatusLine().getStatusCode();

		return (statusCode > 199) && (statusCode < 400);

	}



}

　　2  ConnectionManager类，将线程添加到队列中

package com.juupoo.common;





import java.util.ArrayList;



/**

 * Simple connection manager to throttle connections

 * 

 * @author Greg Zavitz

 */

public class ConnectionManager {

	

	public static final int MAX_CONNECTIONS = 5;



	private ArrayList<Runnable> active = new ArrayList<Runnable>();

	private ArrayList<Runnable> queue = new ArrayList<Runnable>();



	private static ConnectionManager instance;



	public static ConnectionManager getInstance() {

		if (instance == null)

			instance = new ConnectionManager();

		return instance;

	}



	public void push(Runnable runnable) {

		queue.add(runnable);

		if (active.size() < MAX_CONNECTIONS)

			startNext();

	}



	private void startNext() {

		if (!queue.isEmpty()) {

			Runnable next = queue.get(0);

			queue.remove(0);

			active.add(next);



			Thread thread = new Thread(next);

			thread.start();

		}

	}



	public void didComplete(Runnable runnable) {

		active.remove(runnable);

		startNext();

	}



}

　　3 调用：

new HttpConnection().post("user.login", args, callbackListener);



private CallbackListener callbackListener = new HttpConnection.CallbackListener() {

		@Override

		public void callBack(String v) {

			if(v != "fail") {

				if("false".equals(v)) {

					LoginActivity.this.showInfo(R.string.username_or_pass_error);

    			} else {

    				// 登录

					Intent intent = new Intent();

					intent.setClass(LoginActivity.this, MainActivity.class);

					LoginActivity.this.startActivity(intent);

    			}

			} else {

				LoginActivity.this.showInfo(R.string.network_transfer_error);

			}

			progressDialog.dismiss();

		}

	};