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

可参考本文。

http://masl.cis.gvsu.edu/2010/04/05/android-code-sample-asynchronous-http-connections/