WSHelper.java

package com.bigdo.util;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.SocketException;
import java.net.UnknownHostException;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.HttpHostConnectException;
import org.apache.http.entity.FileEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import com.bigdo.common.RConfig;
import com.bigdo.common.RState;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

public class WSHelper {
	public static final int GET = 1;
	public static final int POST = 2;
	Handler handler;
	String RequestUrl, ContentType = "application/json", desc;
	HttpEntity RequestParams;
	int RequestCode, RequestCode2, RequestCode3, RequestCode4, RequestType;
	Context context;
	boolean offUpdate = false;

	/**
	 * 调用服务辅助类
	 * 
	 * @param context
	 *            页面上下文，值可以是： this 或 getApplicationContext()
	 * @param desc
	 *            当前请求描述,用于请求失败时离线同步描述.
	 * @param offUpdate
	 *            是否请求失败时离线同步.
	 * @param handler
	 *            请求完成后通知对象
	 * @param url
	 *            请求网址
	 * @param contentType
	 *            请求内容类别. 默认值:application/json
	 * @param params
	 *            请求参数
	 * @param requestCode
	 *            请求代码,用于区分请求的标识
	 * @param requestCode2
	 *            请求代码,用于区分请求的标识
	 * @param requestCode3
	 *            请求代码,用于区分请求的标识
	 * @param requestCode4
	 *            请求代码,用于区分请求的标识
	 * @param requestType
	 *            请求类别，可以选值为:WSHelper.GET 或 WSHelper.POST *
	 * 
	 */
	public WSHelper(Context context, String desc, boolean offUpdate,
			Handler handler, String url, String contentType, HttpEntity params,
			int requestCode, int requestCode2, int requestCode3,
			int requestCode4, int requestType) {
		this.context = context;
		this.desc = desc;
		this.offUpdate = offUpdate;
		this.handler = handler;
		this.RequestUrl = url;
		if (ContentType == null) {
			this.ContentType = null;
		} else {
			if (ContentType.equals("")) {
				this.ContentType = "application/json";
			} else {
				this.ContentType = contentType;
			}
		}
		this.RequestParams = params;
		this.RequestCode = requestCode;
		this.RequestCode2 = requestCode2;
		this.RequestCode3 = requestCode3;
		this.RequestCode4 = requestCode4;
		this.RequestType = requestType;
	}

	/**
	 * 开始请求
	 * 
	 * @return
	 */
	public WSResult start() {
		if (handler != null) {
			WSHelperThread wSThreadObj = new WSHelperThread();
			wSThreadObj.start();
			return null;
		} else {
			return request();
		}
	}

	public static StringEntity getStringEntity(String Params) {
		try {
			return new StringEntity(Params, HTTP.UTF_8);
		} catch (UnsupportedEncodingException e) {
		}
		return null;
	}

	public static FileEntity getFileEntity(String filePath) {
		File file = new File(filePath);
		FileEntity fEntity = new FileEntity(file, "binary/octet-stream");
		return fEntity;
	}

	private WSResult request() {
		WSResult result = new WSResult();
		if (isNetConnecting(context)) {
			switch (RequestType) {
			case GET:
				result = Get();
				break;
			case POST:
				result = Post();
				break;
			default:
				result.Result = "无效请求.[C]";
				result.State = WSResult.Error;
				result.RequestCode = RequestCode;
				result.RequestCode2 = RequestCode2;
				result.RequestCode3 = RequestCode3;
				result.RequestCode4 = RequestCode4;
				if (handler != null) {
					Bundle b = new Bundle();
					b.putParcelable(WSResult.ResultKey, result);
					Message msg = new Message();
					msg.arg1 = RState.WSCall;
					msg.setData(b);
					handler.sendMessage(msg);
				}
				break;
			}
		} else {
			result.Result = "无法连接到服务器,请您先检查网络.[C]";
			result.State = WSResult.NetError;
			result.RequestCode = RequestCode;
			result.RequestCode2 = RequestCode2;
			result.RequestCode3 = RequestCode3;
			result.RequestCode4 = RequestCode4;
			if (handler != null) {
				Bundle b = new Bundle();
				b.putParcelable(WSResult.ResultKey, result);
				Message msg = new Message();
				msg.arg1 = RState.WSCall;
				msg.setData(b);
				handler.sendMessage(msg);
			}
		}
		return result;
	}

	private WSResult Post() {
		WSResult result = new WSResult();
		int code = 0;
		String Error = "";
		HttpClient client = new DefaultHttpClient();
		HttpPost request = new HttpPost(RequestUrl);
		request.setHeader("Accept", "application/json");
		if (ContentType != null) {
			request.setHeader("Content-Type", ContentType);
		}
		request.addHeader("charset", HTTP.UTF_8);
		if (RequestParams != null) {
			request.setEntity(RequestParams);
		}
		HttpResponse response = null;
		int errorCode = 0;
		try {
			response = client.execute(request);
			code = response.getStatusLine().getStatusCode();
			if (code == 200) {
				result.Result = EntityUtils.toString(response.getEntity(),
						HTTP.UTF_8);
				result.State = WSResult.OK;
				result.RequestCode = RequestCode;
				result.RequestCode2 = RequestCode2;
				result.RequestCode3 = RequestCode3;
				result.RequestCode4 = RequestCode4;
				if (handler != null) {
					Bundle b = new Bundle();
					b.putParcelable(WSResult.ResultKey, result);
					Message msg = new Message();
					msg.arg1 = RState.WSCall;
					msg.setData(b);
					handler.sendMessage(msg);
				}
				return result;
			} else if (code == 404) {
				Error = "抱歉！服务器不存在该服务.[C]";
				errorCode = WSResult.SError404;
			} else {
				Error = "抱歉！调用服务期间发生了错误.[C]";
				errorCode = WSResult.SError;
			}
		} catch (UnknownHostException e) {
			Error = "无法连接到服务器,请您先检查网络.[C]";
			errorCode = WSResult.UnknownHost;
		} catch (HttpHostConnectException e) {
			Error = "无法连接到服务器,请您先检查网络.[C]";
			errorCode = WSResult.ServiceBreak;
		} catch (SocketException e) {
			Error = "服务中断,请您先检查网络.[C]";
			errorCode = WSResult.ServiceBreak;
		} catch (ConnectTimeoutException ex) {
			Error = "连接超时.[C]";
			errorCode = WSResult.NetTimeout;

		} catch (Exception ex) {
			Error = "抱歉！调用服务期间发生了错误.[C]";
			errorCode = WSResult.Error;
		}
		result.Result = Error;
		result.State = errorCode;
		result.RequestCode = RequestCode;
		result.RequestCode2 = RequestCode2;
		result.RequestCode3 = RequestCode3;
		result.RequestCode4 = RequestCode4;
		if (handler != null) {
			Bundle b = new Bundle();
			b.putParcelable(WSResult.ResultKey, result);
			Message msg = new Message();
			msg.arg1 = RState.WSCall;
			msg.setData(b);
			handler.sendMessage(msg);
		}
		return result;
	}

	private WSResult Get() {
		WSResult result = new WSResult();
		int code = 0;
		String Error = "";
		int errorCode = 0;
		try {
			HttpClient client = new DefaultHttpClient();
			if (RequestParams != null) {
				int s = RequestUrl.indexOf("?");
				if (s > 0) {
					RequestUrl += "&";
				} else {
					RequestUrl += "?";
				}
				RequestUrl += RequestParams.toString();
			}
			HttpGet request = new HttpGet(RequestUrl);
			request.setHeader("Accept", "application/json");
			if (ContentType != null) {
				request.setHeader("Content-Type", ContentType);
			}
			request.addHeader("charset", HTTP.UTF_8);
			HttpResponse response = client.execute(request);
			code = response.getStatusLine().getStatusCode();
			if (code == 200) {
				result.Result = EntityUtils.toString(response.getEntity(),
						HTTP.UTF_8);
				result.State = WSResult.OK;
				result.RequestCode = RequestCode;
				result.RequestCode2 = RequestCode2;
				result.RequestCode3 = RequestCode3;
				result.RequestCode4 = RequestCode4;
				if (handler != null) {
					Bundle b = new Bundle();
					b.putParcelable(WSResult.ResultKey, result);
					Message msg = new Message();
					msg.arg1 = RState.WSCall;
					msg.setData(b);
					handler.sendMessage(msg);
				}
				return result;
			} else if (code == 404) {
				Error = "抱歉！服务器不存在该服务.[C]";
				errorCode = WSResult.SError404;
			} else {
				Error = "抱歉！调用服务期间发生了错误.[C]";
				errorCode = WSResult.SError;
			}
		} catch (UnknownHostException e) {
			Error = "无法连接到服务器,请您先检查网络.[C]";
			errorCode = WSResult.UnknownHost;
		} catch (HttpHostConnectException e) {
			Error = "无法连接到服务器,请您先检查网络.[C]";
			errorCode = WSResult.UnknownHost;
		} catch (SocketException e) {
			Error = "服务中断,请您先检查网络.[C]";
			errorCode = WSResult.ServiceBreak;
		} catch (ConnectTimeoutException ex) {
			Error = "连接超时.[C]";
			errorCode = WSResult.NetTimeout;

		} catch (Exception ex) {
			Error = "抱歉！调用服务期间发生了错误.[C]";
			errorCode = WSResult.Error;
		}
		result.Result = Error;
		result.State = errorCode;
		result.RequestCode = RequestCode;
		result.RequestCode2 = RequestCode2;
		result.RequestCode3 = RequestCode3;
		result.RequestCode4 = RequestCode4;
		if (handler != null) {
			Bundle b = new Bundle();
			b.putParcelable(WSResult.ResultKey, result);
			Message msg = new Message();
			msg.arg1 = RState.WSCall;
			msg.setData(b);
			handler.sendMessage(msg);
		}
		return result;
	}

	public static boolean isNetConnecting(Context context) {
		if (context != null) {
			return isWifiConnected(context);
		}
		return false;
	}

	public static boolean isWifiConnected(Context context) {
		if (context != null) {
			ConnectivityManager mConnectivityManager = (ConnectivityManager) context
					.getSystemService(Context.CONNECTIVITY_SERVICE);
			NetworkInfo mWiFiNetworkInfo = mConnectivityManager
					.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
			if (mWiFiNetworkInfo != null) {
				if (!mWiFiNetworkInfo.isAvailable()) {
					NetworkInfo mMobileNetworkInfo = mConnectivityManager
							.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
					if (mWiFiNetworkInfo != null) {
						return mMobileNetworkInfo.isAvailable()
								&& mMobileNetworkInfo.isConnected();
					}
				} else {
					return true;
				}

			}

		}
		return false;
	}

	private class WSHelperThread extends Thread {
		@Override
		public void run() {
			super.run();
			request();
		}
	}
}