转载请注明出处： http://blog.csdn.net/iwanghang/article/details/65633129
觉得博文有用，请点赞，请评论，请关注，谢谢！~

老规矩，先上GIF动态图，看个效果，如果符合你的项目或者确定你要了解的内容，再往下看吧：

完整项目下载地址：http://download.csdn.net/detail/iwanghang/9792768

贴代码：

1.PHP：

<?phpnamespace app\index\controller;class Uploadimg2
{public function index(){$param = file_get_contents("php://input");// 1// base64// 过来的字符串是“photo:xxxxx”,xxxxx就是base64的图片，下面这一行去掉了“photo:”$param1 = substr($param, 6);// 这里是转码 Unicode转Native$param2 = str_replace(" ","+",$param1);$param2 = str_replace("%2F","/",$param2);$param2 = str_replace("%2B","+",$param2);$param2 = str_replace("%0A","",$param2);// 这里是 base64_decode$image_content = base64_decode($param2);// 保存图片file_put_contents(ROOT_PATH . 'public' . DS . 'uploads/0/1.jpg', $image_content);//file_put_contents(ROOT_PATH . 'public' . DS . 'uploads/0/1.txt', $param);// 2// 16进制$binary_string = pack("H*" , $param1);file_put_contents(ROOT_PATH . 'public' . DS . 'uploads/0/2.jpg', $binary_string);//file_put_contents(ROOT_PATH . 'public' . DS . 'uploads/0/2.txt', $binary_string);// 3// 2进制file_put_contents(ROOT_PATH . 'public' . DS . 'uploads/0/3.jpg', $param);//file_put_contents(ROOT_PATH . 'public' . DS . 'uploads/0/3.txt', $param);return 111;}
}

2.Android：

uploadimg:

package com.jerry.uploadimg;import java.io.ByteArrayOutputStream;
import java.io.File;import org.apache.http.Header;import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.os.Environment;
import android.provider.MediaStore;
import android.util.Base64;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;import com.loopj.android.http.AsyncHttpClient;
import com.loopj.android.http.AsyncHttpResponseHandler;
import com.loopj.android.http.RequestParams;public class MainActivity extends Activity {private static final int PHOTO_REQUEST_CAMERA = 1;// 拍照private static final int PHOTO_REQUEST_GALLERY = 2;// 从相册中选择private static final int PHOTO_REQUEST_CUT = 3;// 结果private ImageView mFace;private Bitmap bitmap;private TextView tvv;//private String url = "http://192.168.1.106:80/index.php/index/Upload";private String url = "http://192.168.1.111/index.php/index/Uploadimg2";
//  private String url = "http://192.168.1.113/tugua/api/";
//  private String url = "http://192.168.1.126/tx_api/Test/index";
//  private String url = "192.168.1.103/mibileup/iosphp.php";private char[] slslsl;/* 头像名称 */private static final String PHOTO_FILE_NAME = "temp_photo.jpg";private File tempFile;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);this.mFace = (ImageView) this.findViewById(R.id.iv_image);this.tvv = (TextView) findViewById(R.id.tv);tvv.setText(url);}/** 上传图片*/public void upload(View view) {try {ByteArrayOutputStream out = new ByteArrayOutputStream();bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);out.flush();out.close();byte[] buffer = out.toByteArray();// 1// 转换为Base64，然后没转换为字符串byte[] encode = Base64.encode(buffer, Base64.DEFAULT);String photo = new String(encode);// 2// 转换为16进制，然后没转换为字符串char[] ssssss =  Hex.encodeHex(buffer);photo = new String(ssssss);// 3// byte[] 直接转为字符串// String photo = new String(buffer);RequestParams params = new RequestParams();params.put("photo", photo);//String url = "http://192.168.1.106:80/index.php/index/Uploadimg2";//tvv.setText(url);AsyncHttpClient client = new AsyncHttpClient();client.post(url, params, new AsyncHttpResponseHandler() {@Overridepublic void onSuccess(int statusCode, Header[] headers,byte[] responseBody) {try {if (statusCode == 200) {Toast.makeText(MainActivity.this, "头像上传成功!", 0).show();} else {Toast.makeText(MainActivity.this,"网络访问异常，错误码：" + statusCode, 0).show();}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}@Overridepublic void onFailure(int statusCode, Header[] headers,byte[] responseBody, Throwable error) {Toast.makeText(MainActivity.this,"网络访问异常，错误码  > " + statusCode, 0).show();}});} catch (Exception e) {e.printStackTrace();}}/** 从相册获取*/public void gallery(View view) {// 激活系统图库，选择一张图片Intent intent = new Intent(Intent.ACTION_PICK);intent.setType("image/*");startActivityForResult(intent, PHOTO_REQUEST_GALLERY);}/** 从相机获取*/public void camera(View view) {Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");// 判断存储卡是否可以用，可用进行存储if (hasSdcard()) {intent.putExtra(MediaStore.EXTRA_OUTPUT,Uri.fromFile(new File(Environment.getExternalStorageDirectory(), PHOTO_FILE_NAME)));}startActivityForResult(intent, PHOTO_REQUEST_CAMERA);}@Overrideprotected void onActivityResult(int requestCode, int resultCode, Intent data) {if (requestCode == PHOTO_REQUEST_GALLERY) {if (data != null) {// 得到图片的全路径Uri uri = data.getData();crop(uri);}} else if (requestCode == PHOTO_REQUEST_CAMERA) {if (hasSdcard()) {tempFile = new File(Environment.getExternalStorageDirectory(),PHOTO_FILE_NAME);crop(Uri.fromFile(tempFile));} else {Toast.makeText(MainActivity.this, "未找到存储卡，无法存储照片！", 0).show();}} else if (requestCode == PHOTO_REQUEST_CUT) {try {bitmap = data.getParcelableExtra("data");this.mFace.setImageBitmap(bitmap);boolean delete = tempFile.delete();System.out.println("delete = " + delete);} catch (Exception e) {e.printStackTrace();}}super.onActivityResult(requestCode, resultCode, data);}/*** 剪切图片** @function:* @author:Jerry* @date:2013-12-30* @param uri*/private void crop(Uri uri) {// 裁剪图片意图Intent intent = new Intent("com.android.camera.action.CROP");intent.setDataAndType(uri, "image/*");intent.putExtra("crop", "true");// 裁剪框的比例，1：1intent.putExtra("aspectX", 1);intent.putExtra("aspectY", 1);// 裁剪后输出图片的尺寸大小intent.putExtra("outputX", 250);intent.putExtra("outputY", 250);// 图片格式intent.putExtra("outputFormat", "JPEG");intent.putExtra("noFaceDetection", true);// 取消人脸识别intent.putExtra("return-data", true);// true:不返回uri，false：返回uristartActivityForResult(intent, PHOTO_REQUEST_CUT);}private boolean hasSdcard() {if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {return true;} else {return false;}}
}

package com.jerry.uploadimg;/*** reference apache commons <a* href="http://commons.apache.org/codec/">http://commons.apache.org/codec/</a>** @author Aub**/
public class Hex {/*** 用于建立十六进制字符的输出的小写字符数组*/private static final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5','6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };/*** 用于建立十六进制字符的输出的大写字符数组*/private static final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5','6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };/*** 将字节数组转换为十六进制字符数组** @param data*            byte[]* @return 十六进制char[]*/public static char[] encodeHex(byte[] data) {return encodeHex(data, true);}/*** 将字节数组转换为十六进制字符数组** @param data*            byte[]* @param toLowerCase*            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式* @return 十六进制char[]*/public static char[] encodeHex(byte[] data, boolean toLowerCase) {return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);}/*** 将字节数组转换为十六进制字符数组** @param data*            byte[]* @param toDigits*            用于控制输出的char[]* @return 十六进制char[]*/protected static char[] encodeHex(byte[] data, char[] toDigits) {int l = data.length;char[] out = new char[l << 1];// two characters form the hex value.for (int i = 0, j = 0; i < l; i++) {out[j++] = toDigits[(0xF0 & data[i]) >>> 4];out[j++] = toDigits[0x0F & data[i]];}return out;}/*** 将字节数组转换为十六进制字符串** @param data*            byte[]* @return 十六进制String*/public static String encodeHexStr(byte[] data) {return encodeHexStr(data, true);}/*** 将字节数组转换为十六进制字符串** @param data*            byte[]* @param toLowerCase*            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式* @return 十六进制String*/public static String encodeHexStr(byte[] data, boolean toLowerCase) {return encodeHexStr(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);}/*** 将字节数组转换为十六进制字符串** @param data*            byte[]* @param toDigits*            用于控制输出的char[]* @return 十六进制String*/protected static String encodeHexStr(byte[] data, char[] toDigits) {return new String(encodeHex(data, toDigits));}/*** 将十六进制字符数组转换为字节数组** @param data*            十六进制char[]* @return byte[]* @throws RuntimeException*             如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常*/public static byte[] decodeHex(char[] data) {int len = data.length;if ((len & 0x01) != 0) {throw new RuntimeException("Odd number of characters.");}byte[] out = new byte[len >> 1];// two characters form the hex value.for (int i = 0, j = 0; j < len; i++) {int f = toDigit(data[j], j) << 4;j++;f = f | toDigit(data[j], j);j++;out[i] = (byte) (f & 0xFF);}return out;}/*** 将十六进制字符转换成一个整数** @param ch*            十六进制char* @param index*            十六进制字符在字符数组中的位置* @return 一个整数* @throws RuntimeException*             当ch不是一个合法的十六进制字符时，抛出运行时异常*/protected static int toDigit(char ch, int index) {int digit = Character.digit(ch, 16);if (digit == -1) {throw new RuntimeException("Illegal hexadecimal character " + ch+ " at index " + index);}return digit;}public static void main(String[] args) {String srcStr = "待转换字符串";String encodeStr = encodeHexStr(srcStr.getBytes());String decodeStr = new String(decodeHex(encodeStr.toCharArray()));System.out.println("转换前：" + srcStr);System.out.println("转换后：" + encodeStr);System.out.println("还原后：" + decodeStr);}}

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:tools="http://schemas.android.com/tools"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"tools:context=".MainActivity" ><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:onClick="gallery"android:text="获取图库图片" /><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:onClick="camera"android:text="拍照获取图片" /><ImageViewandroid:id="@+id/iv_image"android:layout_width="wrap_content"android:layout_height="wrap_content" /><Buttonandroid:onClick="upload"        android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="上传" /><TextViewandroid:id="@+id/tv"android:text="URL"android:layout_width="match_parent"android:layout_height="match_parent" /></LinearLayout>

loopj\android\http\AsyncHttpClient.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*/package com.loopj.android.http;import android.content.Context;
import android.util.Log;import org.apache.http.Header;
import org.apache.http.HeaderElement;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpRequestInterceptor;
import org.apache.http.HttpResponse;
import org.apache.http.HttpResponseInterceptor;
import org.apache.http.HttpVersion;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpHead;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.protocol.ClientContext;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.params.ConnPerRouteBean;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.HttpEntityWrapper;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.DefaultRedirectHandler;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.protocol.SyncBasicHttpContext;import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.zip.GZIPInputStream;/*** The AsyncHttpClient can be used to make asynchronous GET, POST, PUT and* DELETE HTTP requests in your Android applications. Requests can be made* with additional parameters by passing a {@link RequestParams} instance,* and responses can be handled by passing an anonymously overridden* {@link AsyncHttpResponseHandler} instance.* <p> </p>* For example:* <p> </p>* <pre>* AsyncHttpClient client = new AsyncHttpClient();* client.get("http://www.google.com", new AsyncHttpResponseHandler() {*     @Override*     public void onSuccess(String response) {*         System.out.println(response);*     }* });* </pre>*/
public class AsyncHttpClient {private static final String VERSION = "1.4.4";private static final int DEFAULT_MAX_CONNECTIONS = 10;private static final int DEFAULT_SOCKET_TIMEOUT = 10 * 1000;private static final int DEFAULT_MAX_RETRIES = 5;private static final int DEFAULT_RETRY_SLEEP_TIME_MILLIS = 1500;private static final int DEFAULT_SOCKET_BUFFER_SIZE = 8192;private static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding";private static final String ENCODING_GZIP = "gzip";private static final String LOG_TAG = "AsyncHttpClient";private int maxConnections = DEFAULT_MAX_CONNECTIONS;private int timeout = DEFAULT_SOCKET_TIMEOUT;private final DefaultHttpClient httpClient;private final HttpContext httpContext;private ThreadPoolExecutor threadPool;private final Map<Context, List<WeakReference<Future<?>>>> requestMap;private final Map<String, String> clientHeaderMap;private boolean isUrlEncodingEnabled = true;/*** Creates a new AsyncHttpClient with default constructor arguments values*/public AsyncHttpClient() {this(false, 80, 443);}/*** Creates a new AsyncHttpClient.** @param httpPort non-standard HTTP-only port*/public AsyncHttpClient(int httpPort) {this(false, httpPort, 443);}/*** Creates a new AsyncHttpClient.** @param httpPort  non-standard HTTP-only port* @param httpsPort non-standard HTTPS-only port*/public AsyncHttpClient(int httpPort, int httpsPort) {this(false, httpPort, httpsPort);}/*** Creates new AsyncHttpClient using given params** @param fixNoHttpResponseException Whether to fix or not issue, by ommiting SSL verification* @param httpPort                   HTTP port to be used, must be greater than 0* @param httpsPort                  HTTPS port to be used, must be greater than 0*/public AsyncHttpClient(boolean fixNoHttpResponseException, int httpPort, int httpsPort) {this(getDefaultSchemeRegistry(fixNoHttpResponseException, httpPort, httpsPort));}/*** Returns default instance of SchemeRegistry** @param fixNoHttpResponseException Whether to fix or not issue, by ommiting SSL verification* @param httpPort                   HTTP port to be used, must be greater than 0* @param httpsPort                  HTTPS port to be used, must be greater than 0*/private static SchemeRegistry getDefaultSchemeRegistry(boolean fixNoHttpResponseException, int httpPort, int httpsPort) {if (fixNoHttpResponseException) {Log.d(LOG_TAG, "Beware! Using the fix is insecure, as it doesn't verify SSL certificates.");}if (httpPort < 1) {httpPort = 80;Log.d(LOG_TAG, "Invalid HTTP port number specified, defaulting to 80");}if (httpsPort < 1) {httpsPort = 443;Log.d(LOG_TAG, "Invalid HTTPS port number specified, defaulting to 443");}// Fix to SSL flaw in API < ICS// See https://code.google.com/p/android/issues/detail?id=13117SSLSocketFactory sslSocketFactory;if (fixNoHttpResponseException)sslSocketFactory = MySSLSocketFactory.getFixedSocketFactory();elsesslSocketFactory = SSLSocketFactory.getSocketFactory();SchemeRegistry schemeRegistry = new SchemeRegistry();schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), httpPort));schemeRegistry.register(new Scheme("https", sslSocketFactory, httpsPort));return schemeRegistry;}/*** Creates a new AsyncHttpClient.** @param schemeRegistry SchemeRegistry to be used*/public AsyncHttpClient(SchemeRegistry schemeRegistry) {BasicHttpParams httpParams = new BasicHttpParams();ConnManagerParams.setTimeout(httpParams, timeout);ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(maxConnections));ConnManagerParams.setMaxTotalConnections(httpParams, DEFAULT_MAX_CONNECTIONS);HttpConnectionParams.setSoTimeout(httpParams, timeout);HttpConnectionParams.setConnectionTimeout(httpParams, timeout);HttpConnectionParams.setTcpNoDelay(httpParams, true);HttpConnectionParams.setSocketBufferSize(httpParams, DEFAULT_SOCKET_BUFFER_SIZE);HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);HttpProtocolParams.setUserAgent(httpParams, String.format("android-async-http/%s (http://loopj.com/android-async-http)", VERSION));ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry);threadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool();requestMap = new WeakHashMap<Context, List<WeakReference<Future<?>>>>();clientHeaderMap = new HashMap<String, String>();httpContext = new SyncBasicHttpContext(new BasicHttpContext());httpClient = new DefaultHttpClient(cm, httpParams);httpClient.addRequestInterceptor(new HttpRequestInterceptor() {@Overridepublic void process(HttpRequest request, HttpContext context) {if (!request.containsHeader(HEADER_ACCEPT_ENCODING)) {request.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP);}for (String header : clientHeaderMap.keySet()) {request.addHeader(header, clientHeaderMap.get(header));}}});httpClient.addResponseInterceptor(new HttpResponseInterceptor() {@Overridepublic void process(HttpResponse response, HttpContext context) {final HttpEntity entity = response.getEntity();if (entity == null) {return;}final Header encoding = entity.getContentEncoding();if (encoding != null) {for (HeaderElement element : encoding.getElements()) {if (element.getName().equalsIgnoreCase(ENCODING_GZIP)) {response.setEntity(new InflatingEntity(entity));break;}}}}});httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_MAX_RETRIES, DEFAULT_RETRY_SLEEP_TIME_MILLIS));}/*** Get the underlying HttpClient instance. This is useful for setting* additional fine-grained settings for requests by accessing the* client's ConnectionManager, HttpParams and SchemeRegistry.** @return underlying HttpClient instance*/public HttpClient getHttpClient() {return this.httpClient;}/*** Get the underlying HttpContext instance. This is useful for getting* and setting fine-grained settings for requests by accessing the* context's attributes such as the CookieStore.** @return underlying HttpContext instance*/public HttpContext getHttpContext() {return this.httpContext;}/*** Sets an optional CookieStore to use when making requests** @param cookieStore The CookieStore implementation to use, usually an instance of {@link PersistentCookieStore}*/public void setCookieStore(CookieStore cookieStore) {httpContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);}/*** Overrides the threadpool implementation used when queuing/pooling* requests. By default, Executors.newCachedThreadPool() is used.** @param threadPool an instance of {@link ThreadPoolExecutor} to use for queuing/pooling requests.*/public void setThreadPool(ThreadPoolExecutor threadPool) {this.threadPool = threadPool;}/*** Simple interface method, to enable or disable redirects.* If you set manually RedirectHandler on underlying HttpClient, effects of this method will be canceled.** @param enableRedirects boolean*/public void setEnableRedirects(final boolean enableRedirects) {httpClient.setRedirectHandler(new DefaultRedirectHandler() {@Overridepublic boolean isRedirectRequested(HttpResponse response, HttpContext context) {return enableRedirects;}});}/*** Sets the User-Agent header to be sent with each request. By default,* "Android Asynchronous Http Client/VERSION (http://loopj.com/android-async-http/)" is used.** @param userAgent the string to use in the User-Agent header.*/public void setUserAgent(String userAgent) {HttpProtocolParams.setUserAgent(this.httpClient.getParams(), userAgent);}/*** Returns current limit of parallel connections** @return maximum limit of parallel connections, default is 10*/public int getMaxConnections() {return maxConnections;}/*** Sets maximum limit of parallel connections** @param maxConnections maximum parallel connections, must be at least 1*/public void setMaxConnections(int maxConnections) {if (maxConnections < 1)maxConnections = DEFAULT_MAX_CONNECTIONS;this.maxConnections = maxConnections;final HttpParams httpParams = this.httpClient.getParams();ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(this.maxConnections));}/*** Returns current socket timeout limit (milliseconds), default is 10000 (10sec)** @return Socket Timeout limit in milliseconds*/public int getTimeout() {return timeout;}/*** Set the connection and socket timeout. By default, 10 seconds.** @param timeout the connect/socket timeout in milliseconds, at least 1 second*/public void setTimeout(int timeout) {if (timeout < 1000)timeout = DEFAULT_SOCKET_TIMEOUT;this.timeout = timeout;final HttpParams httpParams = this.httpClient.getParams();ConnManagerParams.setTimeout(httpParams, this.timeout);HttpConnectionParams.setSoTimeout(httpParams, this.timeout);HttpConnectionParams.setConnectionTimeout(httpParams, this.timeout);}/*** Sets the Proxy by it's hostname and port** @param hostname the hostname (IP or DNS name)* @param port     the port number. -1 indicates the scheme default port.*/public void setProxy(String hostname, int port) {final HttpHost proxy = new HttpHost(hostname, port);final HttpParams httpParams = this.httpClient.getParams();httpParams.setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);}/*** Sets the Proxy by it's hostname,port,username and password** @param hostname the hostname (IP or DNS name)* @param port     the port number. -1 indicates the scheme default port.* @param username the username* @param password the password*/public void setProxy(String hostname, int port, String username, String password) {httpClient.getCredentialsProvider().setCredentials(new AuthScope(hostname, port),new UsernamePasswordCredentials(username, password));final HttpHost proxy = new HttpHost(hostname, port);final HttpParams httpParams = this.httpClient.getParams();httpParams.setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);}/*** Sets the SSLSocketFactory to user when making requests. By default,* a new, default SSLSocketFactory is used.** @param sslSocketFactory the socket factory to use for https requests.*/public void setSSLSocketFactory(SSLSocketFactory sslSocketFactory) {this.httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", sslSocketFactory, 443));}/*** Sets the maximum number of retries and timeout for a particular Request.** @param retries maximum number of retries per request*/public void setMaxRetriesAndTimeout(int retries, int timeout) {this.httpClient.setHttpRequestRetryHandler(new RetryHandler(retries, timeout));}/*** Sets headers that will be added to all requests this client makes (before sending).** @param header the name of the header* @param value  the contents of the header*/public void addHeader(String header, String value) {clientHeaderMap.put(header, value);}/*** Remove header from all requests this client makes (before sending).** @param header the name of the header*/public void removeHeader(String header) {clientHeaderMap.remove(header);}/*** Sets basic authentication for the request. Uses AuthScope.ANY. This is the same as* setBasicAuth('username','password',AuthScope.ANY)** @param username Basic Auth username* @param password Basic Auth password*/public void setBasicAuth(String username, String password) {AuthScope scope = AuthScope.ANY;setBasicAuth(username, password, scope);}/*** Sets basic authentication for the request. You should pass in your AuthScope for security. It should be like this* setBasicAuth("username","password", new AuthScope("host",port,AuthScope.ANY_REALM))** @param username Basic Auth username* @param password Basic Auth password* @param scope    - an AuthScope object*/public void setBasicAuth(String username, String password, AuthScope scope) {UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(username, password);this.httpClient.getCredentialsProvider().setCredentials(scope, credentials);}/*** Removes set basic auth credentials*/public void clearBasicAuth() {this.httpClient.getCredentialsProvider().clear();}/*** Cancels any pending (or potentially active) requests associated with the* passed Context.* <p> </p>* <b>Note:</b> This will only affect requests which were created with a non-null* android Context. This method is intended to be used in the onDestroy* method of your android activities to destroy all requests which are no* longer required.** @param context               the android Context instance associated to the request.* @param mayInterruptIfRunning specifies if active requests should be cancelled along with pending requests.*/public void cancelRequests(Context context, boolean mayInterruptIfRunning) {List<WeakReference<Future<?>>> requestList = requestMap.get(context);if (requestList != null) {for (WeakReference<Future<?>> requestRef : requestList) {Future<?> request = requestRef.get();if (request != null) {request.cancel(mayInterruptIfRunning);}}}requestMap.remove(context);}//// HTTP HEAD Requests///*** Perform a HTTP HEAD request, without any parameters.** @param url             the URL to send the request to.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle head(String url, AsyncHttpResponseHandler responseHandler) {return head(null, url, null, responseHandler);}/*** Perform a HTTP HEAD request with parameters.** @param url             the URL to send the request to.* @param params          additional HEAD parameters to send with the request.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle head(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {return head(null, url, params, responseHandler);}/*** Perform a HTTP HEAD request without any parameters and track the Android Context which initiated the request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle head(Context context, String url, AsyncHttpResponseHandler responseHandler) {return head(context, url, null, responseHandler);}/*** Perform a HTTP HEAD request and track the Android Context which initiated the request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param params          additional HEAD parameters to send with the request.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle head(Context context, String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {return sendRequest(httpClient, httpContext, new HttpHead(getUrlWithQueryString(isUrlEncodingEnabled, url, params)), null, responseHandler, context);}/*** Perform a HTTP HEAD request and track the Android Context which initiated* the request with customized headers** @param context         Context to execute request against* @param url             the URL to send the request to.* @param headers         set headers only for this request* @param params          additional HEAD parameters to send with the request.* @param responseHandler the response handler instance that should handle*                        the response.*/public RequestHandle head(Context context, String url, Header[] headers, RequestParams params, AsyncHttpResponseHandler responseHandler) {HttpUriRequest request = new HttpHead(getUrlWithQueryString(isUrlEncodingEnabled, url, params));if (headers != null) request.setHeaders(headers);return sendRequest(httpClient, httpContext, request, null, responseHandler,context);}//// HTTP GET Requests///*** Perform a HTTP GET request, without any parameters.** @param url             the URL to send the request to.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle get(String url, AsyncHttpResponseHandler responseHandler) {return get(null, url, null, responseHandler);}/*** Perform a HTTP GET request with parameters.** @param url             the URL to send the request to.* @param params          additional GET parameters to send with the request.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle get(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {return get(null, url, params, responseHandler);}/*** Perform a HTTP GET request without any parameters and track the Android Context which initiated the request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle get(Context context, String url, AsyncHttpResponseHandler responseHandler) {return get(context, url, null, responseHandler);}/*** Perform a HTTP GET request and track the Android Context which initiated the request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param params          additional GET parameters to send with the request.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle get(Context context, String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {return sendRequest(httpClient, httpContext, new HttpGet(getUrlWithQueryString(isUrlEncodingEnabled, url, params)), null, responseHandler, context);}/*** Perform a HTTP GET request and track the Android Context which initiated* the request with customized headers** @param context         Context to execute request against* @param url             the URL to send the request to.* @param headers         set headers only for this request* @param params          additional GET parameters to send with the request.* @param responseHandler the response handler instance that should handle*                        the response.*/public RequestHandle get(Context context, String url, Header[] headers, RequestParams params, AsyncHttpResponseHandler responseHandler) {HttpUriRequest request = new HttpGet(getUrlWithQueryString(isUrlEncodingEnabled, url, params));if (headers != null) request.setHeaders(headers);return sendRequest(httpClient, httpContext, request, null, responseHandler,context);}//// HTTP POST Requests///*** Perform a HTTP POST request, without any parameters.** @param url             the URL to send the request to.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle post(String url, AsyncHttpResponseHandler responseHandler) {return post(null, url, null, responseHandler);}/*** Perform a HTTP POST request with parameters.** @param url             the URL to send the request to.* @param params          additional POST parameters or files to send with the request.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle post(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {return post(null, url, params, responseHandler);}/*** Perform a HTTP POST request and track the Android Context which initiated the request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param params          additional POST parameters or files to send with the request.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle post(Context context, String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {return post(context, url, paramsToEntity(params, responseHandler), null, responseHandler);}/*** Perform a HTTP POST request and track the Android Context which initiated the request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param entity          a raw {@link org.apache.http.HttpEntity} to send with the request, for example, use this to send string/json/xml payloads to a server by passing a {@link org.apache.http.entity.StringEntity}.* @param contentType     the content type of the payload you are sending, for example application/json if sending a json payload.* @param responseHandler the response ha   ndler instance that should handle the response.*/public RequestHandle post(Context context, String url, HttpEntity entity, String contentType, AsyncHttpResponseHandler responseHandler) {return sendRequest(httpClient, httpContext, addEntityToRequestBase(new HttpPost(url), entity), contentType, responseHandler, context);}/*** Perform a HTTP POST request and track the Android Context which initiated* the request. Set headers only for this request** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param headers         set headers only for this request* @param params          additional POST parameters to send with the request.* @param contentType     the content type of the payload you are sending, for*                        example application/json if sending a json payload.* @param responseHandler the response handler instance that should handle*                        the response.*/public RequestHandle post(Context context, String url, Header[] headers, RequestParams params, String contentType,AsyncHttpResponseHandler responseHandler) {HttpEntityEnclosingRequestBase request = new HttpPost(url);if (params != null) request.setEntity(paramsToEntity(params, responseHandler));if (headers != null) request.setHeaders(headers);return sendRequest(httpClient, httpContext, request, contentType,responseHandler, context);}/*** Perform a HTTP POST request and track the Android Context which initiated* the request. Set headers only for this request** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param headers         set headers only for this request* @param entity          a raw {@link HttpEntity} to send with the request, for*                        example, use this to send string/json/xml payloads to a server by*                        passing a {@link org.apache.http.entity.StringEntity}.* @param contentType     the content type of the payload you are sending, for*                        example application/json if sending a json payload.* @param responseHandler the response handler instance that should handle*                        the response.*/public RequestHandle post(Context context, String url, Header[] headers, HttpEntity entity, String contentType,AsyncHttpResponseHandler responseHandler) {HttpEntityEnclosingRequestBase request = addEntityToRequestBase(new HttpPost(url), entity);if (headers != null) request.setHeaders(headers);return sendRequest(httpClient, httpContext, request, contentType, responseHandler, context);}//// HTTP PUT Requests///*** Perform a HTTP PUT request, without any parameters.** @param url             the URL to send the request to.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle put(String url, AsyncHttpResponseHandler responseHandler) {return put(null, url, null, responseHandler);}/*** Perform a HTTP PUT request with parameters.** @param url             the URL to send the request to.* @param params          additional PUT parameters or files to send with the request.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle put(String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {return put(null, url, params, responseHandler);}/*** Perform a HTTP PUT request and track the Android Context which initiated the request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param params          additional PUT parameters or files to send with the request.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle put(Context context, String url, RequestParams params, AsyncHttpResponseHandler responseHandler) {return put(context, url, paramsToEntity(params, responseHandler), null, responseHandler);}/*** Perform a HTTP PUT request and track the Android Context which initiated the request.* And set one-time headers for the request** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param entity          a raw {@link HttpEntity} to send with the request, for example, use this to send string/json/xml payloads to a server by passing a {@link org.apache.http.entity.StringEntity}.* @param contentType     the content type of the payload you are sending, for example application/json if sending a json payload.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle put(Context context, String url, HttpEntity entity, String contentType, AsyncHttpResponseHandler responseHandler) {return sendRequest(httpClient, httpContext, addEntityToRequestBase(new HttpPut(url), entity), contentType, responseHandler, context);}/*** Perform a HTTP PUT request and track the Android Context which initiated the request.* And set one-time headers for the request** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param headers         set one-time headers for this request* @param entity          a raw {@link HttpEntity} to send with the request, for example, use this to send string/json/xml payloads to a server by passing a {@link org.apache.http.entity.StringEntity}.* @param contentType     the content type of the payload you are sending, for example application/json if sending a json payload.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle put(Context context, String url, Header[] headers, HttpEntity entity, String contentType, AsyncHttpResponseHandler responseHandler) {HttpEntityEnclosingRequestBase request = addEntityToRequestBase(new HttpPut(url), entity);if (headers != null) request.setHeaders(headers);return sendRequest(httpClient, httpContext, request, contentType, responseHandler, context);}//// HTTP DELETE Requests///*** Perform a HTTP DELETE request.** @param url             the URL to send the request to.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle delete(String url, AsyncHttpResponseHandler responseHandler) {return delete(null, url, responseHandler);}/*** Perform a HTTP DELETE request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle delete(Context context, String url, AsyncHttpResponseHandler responseHandler) {final HttpDelete delete = new HttpDelete(url);return sendRequest(httpClient, httpContext, delete, null, responseHandler, context);}/*** Perform a HTTP DELETE request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param headers         set one-time headers for this request* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle delete(Context context, String url, Header[] headers, AsyncHttpResponseHandler responseHandler) {final HttpDelete delete = new HttpDelete(url);if (headers != null) delete.setHeaders(headers);return sendRequest(httpClient, httpContext, delete, null, responseHandler, context);}/*** Perform a HTTP DELETE request.** @param context         the Android Context which initiated the request.* @param url             the URL to send the request to.* @param headers         set one-time headers for this request* @param params          additional DELETE parameters or files to send along with request* @param responseHandler the response handler instance that should handle the response.*/public RequestHandle delete(Context context, String url, Header[] headers, RequestParams params, AsyncHttpResponseHandler responseHandler) {HttpDelete httpDelete = new HttpDelete(getUrlWithQueryString(isUrlEncodingEnabled, url, params));if (headers != null) httpDelete.setHeaders(headers);return sendRequest(httpClient, httpContext, httpDelete, null, responseHandler, context);}/*** Puts a new request in queue as a new thread in pool to be executed** @param client          HttpClient to be used for request, can differ in single requests* @param contentType     MIME body type, for POST and PUT requests, may be null* @param context         Context of Android application, to hold the reference of request* @param httpContext     HttpContext in which the request will be executed* @param responseHandler ResponseHandler or its subclass to put the response into* @param uriRequest      instance of HttpUriRequest, which means it must be of HttpDelete, HttpPost, HttpGet, HttpPut, etc.*/protected RequestHandle sendRequest(DefaultHttpClient client, HttpContext httpContext, HttpUriRequest uriRequest, String contentType, AsyncHttpResponseHandler responseHandler, Context context) {if (contentType != null) {uriRequest.addHeader("Content-Type", contentType);}Future<?> request = threadPool.submit(new AsyncHttpRequest(client, httpContext, uriRequest, responseHandler));if (context != null) {// Add request to request mapList<WeakReference<Future<?>>> requestList = requestMap.get(context);if (requestList == null) {requestList = new LinkedList<WeakReference<Future<?>>>();requestMap.put(context, requestList);}requestList.add(new WeakReference<Future<?>>(request));// TODO: Remove dead weakrefs from requestLists?}return new RequestHandle(request);}/*** Sets state of URL encoding feature, see bug #227, this method* allows you to turn off and on this auto-magic feature on-demand.** @param enabled desired state of feature*/public void setURLEncodingEnabled(boolean enabled) {this.isUrlEncodingEnabled = enabled;}/*** Will encode url, if not disabled, and adds params on the end of it** @param url    String with URL, should be valid URL without params* @param params RequestParams to be appended on the end of URL*/public static String getUrlWithQueryString(boolean isUrlEncodingEnabled, String url, RequestParams params) {if (isUrlEncodingEnabled)url = url.replace(" ", "%20");if (params != null) {String paramString = params.getParamString();if (!url.contains("?")) {url += "?" + paramString;} else {url += "&" + paramString;}}return url;}/*** Returns HttpEntity containing data from RequestParams included with request declaration.* Allows also passing progress from upload via provided ResponseHandler** @param params          additional request params* @param responseHandler AsyncHttpResponseHandler or its subclass to be notified on progress*/private HttpEntity paramsToEntity(RequestParams params, AsyncHttpResponseHandler responseHandler) {HttpEntity entity = null;try {if (params != null) {entity = params.getEntity(responseHandler);}} catch (Throwable t) {if (responseHandler != null)responseHandler.sendFailureMessage(0, null, null, t);elset.printStackTrace();}return entity;}public boolean isUrlEncodingEnabled() {return isUrlEncodingEnabled;}/*** Applicable only to HttpRequest methods extending HttpEntityEnclosingRequestBase, which is for example not DELETE** @param entity      entity to be included within the request* @param requestBase HttpRequest instance, must not be null*/private HttpEntityEnclosingRequestBase addEntityToRequestBase(HttpEntityEnclosingRequestBase requestBase, HttpEntity entity) {if (entity != null) {requestBase.setEntity(entity);}return requestBase;}/*** Enclosing entity to hold stream of gzip decoded data for accessing HttpEntity contents*/private static class InflatingEntity extends HttpEntityWrapper {public InflatingEntity(HttpEntity wrapped) {super(wrapped);}@Overridepublic InputStream getContent() throws IOException {return new GZIPInputStream(wrappedEntity.getContent());}@Overridepublic long getContentLength() {return -1;}}
}

loopj\android\http\AsyncHttpRequest.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*/package com.loopj.android.http;import org.apache.http.HttpResponse;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.AbstractHttpClient;
import org.apache.http.protocol.HttpContext;import java.io.IOException;
import java.net.MalformedURLException;
import java.net.UnknownHostException;class AsyncHttpRequest implements Runnable {private final AbstractHttpClient client;private final HttpContext context;private final HttpUriRequest request;private final AsyncHttpResponseHandler responseHandler;private int executionCount;public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, AsyncHttpResponseHandler responseHandler) {this.client = client;this.context = context;this.request = request;this.responseHandler = responseHandler;}@Overridepublic void run() {if (responseHandler != null) {responseHandler.sendStartMessage();}try {makeRequestWithRetries();} catch (IOException e) {if (responseHandler != null) {responseHandler.sendFailureMessage(0, null, null, e);}}if (responseHandler != null) {responseHandler.sendFinishMessage();}}private void makeRequest() throws IOException {if (!Thread.currentThread().isInterrupted()) {// Fixes #115if (request.getURI().getScheme() == null) {// subclass of IOException so processed in the callerthrow new MalformedURLException("No valid URI scheme was provided");}HttpResponse response = client.execute(request, context);if (!Thread.currentThread().isInterrupted()) {if (responseHandler != null) {responseHandler.sendResponseMessage(response);}}}}private void makeRequestWithRetries() throws IOException {boolean retry = true;IOException cause = null;HttpRequestRetryHandler retryHandler = client.getHttpRequestRetryHandler();try{while (retry) {try {makeRequest();return;} catch (UnknownHostException e) {// switching between WI-FI and mobile data networks can cause a retry which then results in an UnknownHostException// while the WI-FI is initialising. The retry logic will be invoked here, if this is NOT the first retry// (to assist in genuine cases of unknown host) which seems better than outright failurecause = new IOException("UnknownHostException exception: " + e.getMessage());retry = (executionCount > 0) && retryHandler.retryRequest(cause, ++executionCount, context);} catch (NullPointerException e) {// there's a bug in HttpClient 4.0.x that on some occasions causes// DefaultRequestExecutor to throw an NPE, see// http://code.google.com/p/android/issues/detail?id=5255cause = new IOException("NPE in HttpClient: " + e.getMessage());retry = retryHandler.retryRequest(cause, ++executionCount, context);} catch (IOException e) {cause = e;retry = retryHandler.retryRequest(cause, ++executionCount, context);}if(retry && (responseHandler != null)) {responseHandler.sendRetryMessage();}}} catch (Exception e) {// catch anything else to ensure failure message is propagatedcause = new IOException("Unhandled exception: " + e.getMessage());}// cleaned up to throw IOExceptionthrow(cause);}
}

loopj\android\http\AsyncHttpResponseHandler.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*/package com.loopj.android.http;import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpResponseException;
import org.apache.http.util.ByteArrayBuffer;import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.ref.WeakReference;/*** Used to intercept and handle the responses from requests made using* {@link AsyncHttpClient}. The {@link #onSuccess(int, org.apache.http.Header[], byte[])} method is* designed to be anonymously overridden with your own response handling code.* <p> </p>* Additionally, you can override the {@link #onFailure(int, org.apache.http.Header[], byte[], Throwable)},* {@link #onStart()}, {@link #onFinish()}, {@link #onRetry()} and {@link #onProgress(int, int)} methods as required.* <p> </p>* For example:* <p> </p>* <pre>* AsyncHttpClient client = new AsyncHttpClient();* client.get("http://www.google.com", new AsyncHttpResponseHandler() {*     @Override*     public void onStart() {*         // Initiated the request*     }**     @Override*     public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {*         // Successfully got a response*     }**     @Override*     public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {*         // Response failed :(*     }**     @Override*     public void onRetry() {*         // Request was retried*     }**     @Override*     public void onProgress(int bytesWritten, int totalSize) {*         // Progress notification*     }**     @Override*     public void onFinish() {*         // Completed the request (either success or failure)*     }* });* </pre>*/
public class AsyncHttpResponseHandler {private static final String LOG_TAG = "AsyncHttpResponseHandler";protected static final int SUCCESS_MESSAGE = 0;protected static final int FAILURE_MESSAGE = 1;protected static final int START_MESSAGE = 2;protected static final int FINISH_MESSAGE = 3;protected static final int PROGRESS_MESSAGE = 4;protected static final int RETRY_MESSAGE = 5;protected static final int BUFFER_SIZE = 4096;private Handler handler;public static final String DEFAULT_CHARSET = "UTF-8";private String responseCharset = DEFAULT_CHARSET;private Boolean useSynchronousMode = false;// avoid leaks by using a non-anonymous handler class// with a weak referencestatic class ResponderHandler extends Handler {private final WeakReference<AsyncHttpResponseHandler> mResponder;ResponderHandler(AsyncHttpResponseHandler service) {mResponder = new WeakReference<AsyncHttpResponseHandler>(service);}@Overridepublic void handleMessage(Message msg) {AsyncHttpResponseHandler service = mResponder.get();if (service != null) {service.handleMessage(msg);}}}public boolean getUseSynchronousMode() {return (useSynchronousMode);}/*** Set the response handler to use synchronous mode or not** @param value true indicates that synchronous mode should be used*/public void setUseSynchronousMode(Boolean value) {useSynchronousMode = value;}/*** Sets the charset for the response string. If not set, the default is UTF-8.** @param charset to be used for the response string.* @see <a href="http://docs.oracle.com/javase/7/docs/api/java/nio/charset/Charset.html">Charset</a>*/public void setCharset(final String charset) {this.responseCharset = charset;}public String getCharset() {return this.responseCharset;}/*** Creates a new AsyncHttpResponseHandler*/public AsyncHttpResponseHandler() {// Set up a handler to post events back to the correct thread if possibleif (Looper.myLooper() != null) {handler = new ResponderHandler(this);}}//// Callbacks to be overridden, typically anonymously///*** Fired when the request progress, override to handle in your own code** @param bytesWritten offset from start of file* @param totalSize    total size of file*/public void onProgress(int bytesWritten, int totalSize) {}/*** Fired when the request is started, override to handle in your own code*/public void onStart() {}/*** Fired in all cases when the request is finished, after both success and failure, override to handle in your own code*/public void onFinish() {}/*** Fired when a request returns successfully, override to handle in your own code** @param content the body of the HTTP response from the server* @deprecated use {@link #onSuccess(int, Header[], byte[])}*/@Deprecatedpublic void onSuccess(String content) {}/*** Fired when a request returns successfully, override to handle in your own code** @param statusCode the status code of the response* @param headers    the headers of the HTTP response* @param content    the body of the HTTP response from the server* @deprecated use {@link #onSuccess(int, Header[], byte[])}*/@Deprecatedpublic void onSuccess(int statusCode, Header[] headers, String content) {onSuccess(statusCode, content);}/*** Fired when a request returns successfully, override to handle in your own code** @param statusCode the status code of the response* @param content    the body of the HTTP response from the server* @deprecated use {@link #onSuccess(int, Header[], byte[])}*/@Deprecatedpublic void onSuccess(int statusCode, String content) {onSuccess(content);}/*** Fired when a request returns successfully, override to handle in your own code** @param statusCode   the status code of the response* @param headers      return headers, if any* @param responseBody the body of the HTTP response from the server*/public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {try {String response = new String(responseBody, getCharset());onSuccess(statusCode, headers, response);} catch (UnsupportedEncodingException e) {Log.e(LOG_TAG, e.toString());onFailure(statusCode, headers, e, null);}}/*** Fired when a request fails to complete, override to handle in your own code** @param error the underlying cause of the failure* @deprecated use {@link #onFailure(Throwable, String)}*/@Deprecatedpublic void onFailure(Throwable error) {}/*** Fired when a request fails to complete, override to handle in your own code** @param error   the underlying cause of the failure* @param content the response body, if any* @deprecated use {@link #onFailure(int, Header[], byte[], Throwable)}*/@Deprecatedpublic void onFailure(Throwable error, String content) {// By default, call the deprecated onFailure(Throwable) for compatibilityonFailure(error);}/*** Fired when a request fails to complete, override to handle in your own code** @param statusCode return HTTP status code* @param error      the underlying cause of the failure* @param content    the response body, if any* @deprecated use {@link #onFailure(int, Header[], byte[], Throwable)}*/@Deprecatedpublic void onFailure(int statusCode, Throwable error, String content) {// By default, call the chain method onFailure(Throwable,String)onFailure(error, content);}/*** Fired when a request fails to complete, override to handle in your own code** @param statusCode return HTTP status code* @param headers    return headers, if any* @param error      the underlying cause of the failure* @param content    the response body, if any* @deprecated use {@link #onFailure(int, Header[], byte[], Throwable)}*/@Deprecatedpublic void onFailure(int statusCode, Header[] headers, Throwable error, String content) {// By default, call the chain method onFailure(int,Throwable,String)onFailure(statusCode, error, content);}/*** Fired when a request fails to complete, override to handle in your own code** @param statusCode   return HTTP status code* @param headers      return headers, if any* @param responseBody the response body, if any* @param error        the underlying cause of the failure*/public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {String response;try {response = new String(responseBody, getCharset());onFailure(statusCode, headers, error, response);} catch (UnsupportedEncodingException e) {Log.e(LOG_TAG, e.toString());onFailure(statusCode, headers, e, null);}}/*** Fired when a retry occurs, override to handle in your own code*/public void onRetry() {}//// Pre-processing of messages (executes in background threadpool thread)//protected void sendProgressMessage(int bytesWritten, int totalSize) {sendMessage(obtainMessage(PROGRESS_MESSAGE, new Object[]{bytesWritten, totalSize}));}protected void sendSuccessMessage(int statusCode, Header[] headers, byte[] responseBody) {sendMessage(obtainMessage(SUCCESS_MESSAGE, new Object[]{statusCode, headers, responseBody}));}protected void sendFailureMessage(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {sendMessage(obtainMessage(FAILURE_MESSAGE, new Object[]{statusCode, headers, responseBody, error}));}protected void sendStartMessage() {sendMessage(obtainMessage(START_MESSAGE, null));}protected void sendFinishMessage() {sendMessage(obtainMessage(FINISH_MESSAGE, null));}protected void sendRetryMessage() {sendMessage(obtainMessage(RETRY_MESSAGE, null));}// Methods which emulate android's Handler and Message methodsprotected void handleMessage(Message msg) {Object[] response;switch (msg.what) {case SUCCESS_MESSAGE:response = (Object[]) msg.obj;if (response != null && response.length >= 3)onSuccess((Integer) response[0], (Header[]) response[1], (byte[]) response[2]);elseLog.e(LOG_TAG, "SUCCESS_MESSAGE didn't got enough params");break;case FAILURE_MESSAGE:response = (Object[]) msg.obj;if (response != null && response.length >= 4)onFailure((Integer) response[0], (Header[]) response[1], (byte[]) response[2], (Throwable) response[3]);elseLog.e(LOG_TAG, "FAILURE_MESSAGE didn't got enough params");break;case START_MESSAGE:onStart();break;case FINISH_MESSAGE:onFinish();break;case PROGRESS_MESSAGE:response = (Object[]) msg.obj;if (response != null && response.length >= 2)onProgress((Integer) response[0], (Integer) response[1]);elseLog.e(LOG_TAG, "PROGRESS_MESSAGE didn't got enough params");break;case RETRY_MESSAGE:onRetry();break;}}protected void sendMessage(Message msg) {if (getUseSynchronousMode() || handler == null) {handleMessage(msg);} else if (!Thread.currentThread().isInterrupted()) { // do not send messages if request has been cancelledhandler.sendMessage(msg);}}protected void postRunnable(Runnable r) {if (r != null) {handler.post(r);}}protected Message obtainMessage(int responseMessage, Object response) {Message msg;if (handler != null) {msg = handler.obtainMessage(responseMessage, response);} else {msg = Message.obtain();if (msg != null) {msg.what = responseMessage;msg.obj = response;}}return msg;}// Interface to AsyncHttpRequestvoid sendResponseMessage(HttpResponse response) throws IOException {// do not process if request has been cancelledif (!Thread.currentThread().isInterrupted()) {StatusLine status = response.getStatusLine();byte[] responseBody;responseBody = getResponseData(response.getEntity());// additional cancellation check as getResponseData() can take non-zero time to processif (!Thread.currentThread().isInterrupted()) {if (status.getStatusCode() >= 300) {sendFailureMessage(status.getStatusCode(), response.getAllHeaders(), responseBody, new HttpResponseException(status.getStatusCode(), status.getReasonPhrase()));} else {sendSuccessMessage(status.getStatusCode(), response.getAllHeaders(), responseBody);}}}}byte[] getResponseData(HttpEntity entity) throws IOException {byte[] responseBody = null;if (entity != null) {InputStream instream = entity.getContent();if (instream != null) {long contentLength = entity.getContentLength();if (contentLength > Integer.MAX_VALUE) {throw new IllegalArgumentException("HTTP entity too large to be buffered in memory");}if (contentLength < 0) {contentLength = BUFFER_SIZE;}try {ByteArrayBuffer buffer = new ByteArrayBuffer((int) contentLength);try {byte[] tmp = new byte[BUFFER_SIZE];int l, count = 0;// do not send messages if request has been cancelledwhile ((l = instream.read(tmp)) != -1 && !Thread.currentThread().isInterrupted()) {count += l;buffer.append(tmp, 0, l);sendProgressMessage(count, (int) contentLength);}} finally {instream.close();}responseBody = buffer.buffer();} catch (OutOfMemoryError e) {System.gc();throw new IOException("File too large to fit into available memory");}}}return responseBody;}
}

\loopj\android\http\BinaryHttpResponseHandler.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*/package com.loopj.android.http;import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpResponseException;import java.io.IOException;
import java.util.regex.Pattern;/*** Used to intercept and handle the responses from requests made using* {@link AsyncHttpClient}. Receives response body as byte array with a* content-type whitelist. (e.g. checks Content-Type against allowed list,* Content-length).* <p> </p>* For example:* <p> </p>* <pre>* AsyncHttpClient client = new AsyncHttpClient();* String[] allowedTypes = new String[] { "image/png" };* client.get("http://www.example.com/image.png", new BinaryHttpResponseHandler(allowedTypes) {*     @Override*     public void onSuccess(byte[] imageData) {*         // Successfully got a response*     }**     @Override*     public void onFailure(Throwable e, byte[] imageData) {*         // Response failed :(*     }* });* </pre>*/
public class BinaryHttpResponseHandler extends AsyncHttpResponseHandler {// Allow images by defaultprivate String[] mAllowedContentTypes = new String[]{"image/jpeg","image/png"};/*** Creates a new BinaryHttpResponseHandler*/public BinaryHttpResponseHandler() {super();}/*** Creates a new BinaryHttpResponseHandler, and overrides the default allowed* content types with passed String array (hopefully) of content types.** @param allowedContentTypes content types array, eg. 'image/jpeg'*/public BinaryHttpResponseHandler(String[] allowedContentTypes) {this();mAllowedContentTypes = allowedContentTypes;}//// Callbacks to be overridden, typically anonymously///*** Fired when a request returns successfully, override to handle in your own code** @param binaryData the body of the HTTP response from the server*/public void onSuccess(byte[] binaryData) {}/*** Fired when a request returns successfully, override to handle in your own code** @param statusCode the status code of the response* @param binaryData the body of the HTTP response from the server*/public void onSuccess(int statusCode, byte[] binaryData) {onSuccess(binaryData);}/*** Fired when a request returns successfully, override to handle in your own code** @param statusCode    response HTTP statuse code* @param headers       response headers, if any* @param responseData  the response body, if any*/@Overridepublic void onSuccess(int statusCode, Header[] headers, byte[] responseData) {onSuccess(statusCode, responseData);}/*** Fired when a request fails to complete, override to handle in your own code** @param statusCode    response HTTP statuse code* @param headers       response headers, if any* @param responseData  the response body, if any* @param error         the underlying cause of the failure*/@Overridepublic void onFailure(int statusCode, Header[] headers, byte[] responseData, Throwable error) {onFailure(statusCode, error, null);}//// Pre-processing of messages (in original calling thread, typically the UI thread)//// Interface to AsyncHttpRequest@Overrideprotected void sendResponseMessage(HttpResponse response) throws IOException {StatusLine status = response.getStatusLine();Header[] contentTypeHeaders = response.getHeaders("Content-Type");if (contentTypeHeaders.length != 1) {//malformed/ambiguous HTTP Header, ABORT!sendFailureMessage(status.getStatusCode(), response.getAllHeaders(), null, new HttpResponseException(status.getStatusCode(), "None, or more than one, Content-Type Header found!"));return;}Header contentTypeHeader = contentTypeHeaders[0];boolean foundAllowedContentType = false;for (String anAllowedContentType : mAllowedContentTypes) {if (Pattern.matches(anAllowedContentType, contentTypeHeader.getValue())) {foundAllowedContentType = true;}}if (!foundAllowedContentType) {//Content-Type not in allowed list, ABORT!sendFailureMessage(status.getStatusCode(), response.getAllHeaders(), null, new HttpResponseException(status.getStatusCode(), "Content-Type not allowed!"));return;}super.sendResponseMessage( response );}
}

\loopj\android\http\FileAsyncHttpResponseHandler.java

package com.loopj.android.http;import org.apache.http.Header;
import org.apache.http.HttpEntity;import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;public class FileAsyncHttpResponseHandler extends AsyncHttpResponseHandler {private File mFile;public FileAsyncHttpResponseHandler(File file) {super();this.mFile = file;}public void onSuccess(File file) {}public void onSuccess(int statusCode, File file) {onSuccess(file);}public void onFailure(Throwable e, File response) {// By default call lower chain methodonFailure(e);}public void onFailure(int statusCode, Throwable e, File response) {// By default call lower chain methodonFailure(e, response);}public void onFailure(int statusCode, Header[] headers, Throwable e, File response) {// By default call lower chain methodonFailure(statusCode, e, response);}@Overridepublic void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {onFailure(statusCode, headers, error, mFile);}@Overridepublic void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {onSuccess(statusCode, mFile);}@Overridebyte[] getResponseData(HttpEntity entity) throws IOException {if (entity != null) {InputStream instream = entity.getContent();long contentLength = entity.getContentLength();FileOutputStream buffer = new FileOutputStream(this.mFile);if (instream != null) {try {byte[] tmp = new byte[BUFFER_SIZE];int l, count = 0;// do not send messages if request has been cancelledwhile ((l = instream.read(tmp)) != -1 && !Thread.currentThread().isInterrupted()) {count += l;buffer.write(tmp, 0, l);sendProgressMessage(count, (int) contentLength);}} finally {instream.close();buffer.flush();buffer.close();}}}return null;}}

loopj\android\http\FileAsyncHttpResponseHandler.java

package com.loopj.android.http;import org.apache.http.Header;
import org.apache.http.HttpEntity;import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;public class FileAsyncHttpResponseHandler extends AsyncHttpResponseHandler {private File mFile;public FileAsyncHttpResponseHandler(File file) {super();this.mFile = file;}public void onSuccess(File file) {}public void onSuccess(int statusCode, File file) {onSuccess(file);}public void onFailure(Throwable e, File response) {// By default call lower chain methodonFailure(e);}public void onFailure(int statusCode, Throwable e, File response) {// By default call lower chain methodonFailure(e, response);}public void onFailure(int statusCode, Header[] headers, Throwable e, File response) {// By default call lower chain methodonFailure(statusCode, e, response);}@Overridepublic void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {onFailure(statusCode, headers, error, mFile);}@Overridepublic void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {onSuccess(statusCode, mFile);}@Overridebyte[] getResponseData(HttpEntity entity) throws IOException {if (entity != null) {InputStream instream = entity.getContent();long contentLength = entity.getContentLength();FileOutputStream buffer = new FileOutputStream(this.mFile);if (instream != null) {try {byte[] tmp = new byte[BUFFER_SIZE];int l, count = 0;// do not send messages if request has been cancelledwhile ((l = instream.read(tmp)) != -1 && !Thread.currentThread().isInterrupted()) {count += l;buffer.write(tmp, 0, l);sendProgressMessage(count, (int) contentLength);}} finally {instream.close();buffer.flush();buffer.close();}}}return null;}}

loopj\android\http\JsonHttpResponseHandler.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*/package com.loopj.android.http;import android.util.Log;import org.apache.http.Header;
import org.apache.http.HttpStatus;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;import java.io.UnsupportedEncodingException;/*** Used to intercept and handle the responses from requests made using* {@link AsyncHttpClient}, with automatic parsing into a {@link JSONObject}* or {@link JSONArray}.* <p> </p>* This class is designed to be passed to get, post, put and delete requests* with the {@link #onSuccess(JSONObject)} or {@link #onSuccess(JSONArray)}* methods anonymously overridden.* <p> </p>* Additionally, you can override the other event methods from the* parent class.*/
public class JsonHttpResponseHandler extends TextHttpResponseHandler {private static final String LOG_TAG = "JsonHttpResponseHandler";/*** Creates a new JsonHttpResponseHandler*/public JsonHttpResponseHandler() {super(DEFAULT_CHARSET);}public JsonHttpResponseHandler(String encoding) {super(encoding);}//// Callbacks to be overridden, typically anonymously///*** Fired when a request returns successfully and contains a json object* at the base of the response string. Override to handle in your* own code.** @param response the parsed json object found in the server response (if any)*/public void onSuccess(JSONObject response) {}/*** Fired when a request returns successfully and contains a json array* at the base of the response string. Override to handle in your* own code.** @param response the parsed json array found in the server response (if any)*/public void onSuccess(JSONArray response) {}/*** Fired when a request returns successfully and contains a json object* at the base of the response string. Override to handle in your* own code.** @param statusCode the status code of the response* @param headers    the headers of the HTTP response* @param response   the parsed json object found in the server response (if any)*/public void onSuccess(int statusCode, Header[] headers, JSONObject response) {onSuccess(statusCode, response);}/*** Fired when a request returns successfully and contains a json object* at the base of the response string. Override to handle in your* own code.** @param statusCode the status code of the response* @param response   the parsed json object found in the server response (if any)*/public void onSuccess(int statusCode, JSONObject response) {onSuccess(response);}/*** Fired when a request returns successfully and contains a json array* at the base of the response string. Override to handle in your* own code.** @param statusCode the status code of the response* @param headers    the headers of the HTTP response* @param response   the parsed json array found in the server response (if any)*/public void onSuccess(int statusCode, Header[] headers, JSONArray response) {onSuccess(statusCode, response);}/*** Fired when a request returns successfully and contains a json array* at the base of the response string. Override to handle in your* own code.** @param statusCode the status code of the response* @param response   the parsed json array found in the server response (if any)*/public void onSuccess(int statusCode, JSONArray response) {onSuccess(response);}public void onFailure(Throwable e, JSONObject errorResponse) {onFailure(e);}public void onFailure(int statusCode, Throwable e, JSONObject errorResponse) {onFailure(e, errorResponse);}public void onFailure(int statusCode, Header[] headers, Throwable e, JSONObject errorResponse) {onFailure(statusCode, e, errorResponse);}public void onFailure(Throwable e, JSONArray errorResponse) {onFailure(e);}public void onFailure(int statusCode, Throwable e, JSONArray errorResponse) {onFailure(e, errorResponse);}public void onFailure(int statusCode, Header[] headers, Throwable e, JSONArray errorResponse) {onFailure(statusCode, e, errorResponse);}@Overridepublic void onSuccess(final int statusCode, final Header[] headers, final String responseBody) {if (statusCode != HttpStatus.SC_NO_CONTENT) {new Thread(new Runnable() {@Overridepublic void run() {try {final Object jsonResponse = parseResponse(responseBody);postRunnable(new Runnable() {@Overridepublic void run() {if (jsonResponse instanceof JSONObject) {onSuccess(statusCode, headers, (JSONObject) jsonResponse);} else if (jsonResponse instanceof JSONArray) {onSuccess(statusCode, headers, (JSONArray) jsonResponse);} else if (jsonResponse instanceof String) {onSuccess(statusCode, headers, (String) jsonResponse);} else {onFailure(new JSONException("Unexpected type " + jsonResponse.getClass().getName()), (JSONObject) null);}}});} catch (final JSONException ex) {postRunnable(new Runnable() {@Overridepublic void run() {onFailure(ex, (JSONObject) null);}});}}}).start();} else {onSuccess(statusCode, headers, new JSONObject());}}@Overridepublic void onFailure(final int statusCode, final Header[] headers, final String responseBody, final Throwable e) {if (responseBody != null) {new Thread(new Runnable() {@Overridepublic void run() {try {final Object jsonResponse = parseResponse(responseBody);postRunnable(new Runnable() {@Overridepublic void run() {if (jsonResponse instanceof JSONObject) {onFailure(statusCode, headers, e, (JSONObject) jsonResponse);} else if (jsonResponse instanceof JSONArray) {onFailure(statusCode, headers, e, (JSONArray) jsonResponse);} else if (jsonResponse instanceof String) {onFailure(statusCode, headers, e, (String) jsonResponse);} else {onFailure(new JSONException("Unexpected type " + jsonResponse.getClass().getName()), (JSONObject) null);}}});} catch (final JSONException ex) {postRunnable(new Runnable() {@Overridepublic void run() {onFailure(ex, (JSONObject) null);}});}}}).start();} else {Log.v(LOG_TAG, "response body is null, calling onFailure(Throwable, JSONObject)");onFailure(e, (JSONObject) null);}}protected Object parseResponse(String responseBody) throws JSONException {if (null == responseBody)return null;Object result = null;//trim the string to prevent start with blank, and test if the string is valid JSON, because the parser don't do this :(. If Json is not valid this will return nullString jsonString = responseBody.trim();if (jsonString.startsWith("{") || jsonString.startsWith("[")) {result = new JSONTokener(jsonString).nextValue();}if (result == null) {result = jsonString;}return result;}
}

loopj\android\http\MySSLSocketFactory.java

package com.loopj.android.http;import org.apache.http.conn.ssl.SSLSocketFactory;import java.io.IOException;
import java.net.Socket;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;/*** This file is introduced to fix HTTPS Post bug on API < ICS* see http://code.google.com/p/android/issues/detail?id=13117#c14*/
public class MySSLSocketFactory extends SSLSocketFactory {SSLContext sslContext = SSLContext.getInstance("TLS");public MySSLSocketFactory(KeyStore truststore)throws NoSuchAlgorithmException, KeyManagementException,KeyStoreException, UnrecoverableKeyException {super(truststore);TrustManager tm = new X509TrustManager() {public java.security.cert.X509Certificate[] getAcceptedIssuers() {return null;}@Overridepublic void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType)throws java.security.cert.CertificateException {}@Overridepublic void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType)throws java.security.cert.CertificateException {}};sslContext.init(null, new TrustManager[]{tm}, null);}@Overridepublic Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException {return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);}@Overridepublic Socket createSocket() throws IOException {return sslContext.getSocketFactory().createSocket();}public static KeyStore getKeystore() {KeyStore trustStore = null;try {trustStore = KeyStore.getInstance(KeyStore.getDefaultType());trustStore.load(null, null);} catch (Throwable t) {t.printStackTrace();}return trustStore;}public static SSLSocketFactory getFixedSocketFactory() {SSLSocketFactory socketFactory;try {socketFactory = new MySSLSocketFactory(getKeystore());socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);} catch (Throwable t) {t.printStackTrace();socketFactory = SSLSocketFactory.getSocketFactory();}return socketFactory;}}

loopj\android\http\PersistentCookieStore.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*/package com.loopj.android.http;import android.content.Context;
import android.content.SharedPreferences;
import android.text.TextUtils;import org.apache.http.client.CookieStore;
import org.apache.http.cookie.Cookie;import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;/*** A persistent cookie store which implements the Apache HttpClient* {@link CookieStore} interface. Cookies are stored and will persist on the* user's device between application sessions since they are serialized and* stored in {@link SharedPreferences}.* <p> </p>* Instances of this class are designed to be used with* {@link AsyncHttpClient#setCookieStore}, but can also be used with a* regular old apache HttpClient/HttpContext if you prefer.*/
public class PersistentCookieStore implements CookieStore {private static final String COOKIE_PREFS = "CookiePrefsFile";private static final String COOKIE_NAME_STORE = "names";private static final String COOKIE_NAME_PREFIX = "cookie_";private final ConcurrentHashMap<String, Cookie> cookies;private final SharedPreferences cookiePrefs;/*** Construct a persistent cookie store.** @param context Context to attach cookie store to*/public PersistentCookieStore(Context context) {cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0);cookies = new ConcurrentHashMap<String, Cookie>();// Load any previously stored cookies into the storeString storedCookieNames = cookiePrefs.getString(COOKIE_NAME_STORE, null);if (storedCookieNames != null) {String[] cookieNames = TextUtils.split(storedCookieNames, ",");for (String name : cookieNames) {String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + name, null);if (encodedCookie != null) {Cookie decodedCookie = decodeCookie(encodedCookie);if (decodedCookie != null) {cookies.put(name, decodedCookie);}}}// Clear out expired cookiesclearExpired(new Date());}}@Overridepublic void addCookie(Cookie cookie) {String name = cookie.getName() + cookie.getDomain();// Save cookie into local store, or remove if expiredif (!cookie.isExpired(new Date())) {cookies.put(name, cookie);} else {cookies.remove(name);}// Save cookie into persistent storeSharedPreferences.Editor prefsWriter = cookiePrefs.edit();prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));prefsWriter.putString(COOKIE_NAME_PREFIX + name, encodeCookie(new SerializableCookie(cookie)));prefsWriter.commit();}@Overridepublic void clear() {// Clear cookies from persistent storeSharedPreferences.Editor prefsWriter = cookiePrefs.edit();for (String name : cookies.keySet()) {prefsWriter.remove(COOKIE_NAME_PREFIX + name);}prefsWriter.remove(COOKIE_NAME_STORE);prefsWriter.commit();// Clear cookies from local storecookies.clear();}@Overridepublic boolean clearExpired(Date date) {boolean clearedAny = false;SharedPreferences.Editor prefsWriter = cookiePrefs.edit();for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) {String name = entry.getKey();Cookie cookie = entry.getValue();if (cookie.isExpired(date)) {// Clear cookies from local storecookies.remove(name);// Clear cookies from persistent storeprefsWriter.remove(COOKIE_NAME_PREFIX + name);// We've cleared at least oneclearedAny = true;}}// Update names in persistent storeif (clearedAny) {prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet()));}prefsWriter.commit();return clearedAny;}@Overridepublic List<Cookie> getCookies() {return new ArrayList<Cookie>(cookies.values());}//// Cookie serialization/deserialization//protected String encodeCookie(SerializableCookie cookie) {ByteArrayOutputStream os = new ByteArrayOutputStream();try {ObjectOutputStream outputStream = new ObjectOutputStream(os);outputStream.writeObject(cookie);} catch (Exception e) {return null;}return byteArrayToHexString(os.toByteArray());}protected Cookie decodeCookie(String cookieStr) {byte[] bytes = hexStringToByteArray(cookieStr);ByteArrayInputStream is = new ByteArrayInputStream(bytes);Cookie cookie = null;try {ObjectInputStream ois = new ObjectInputStream(is);cookie = ((SerializableCookie) ois.readObject()).getCookie();} catch (Exception e) {e.printStackTrace();}return cookie;}// Using some super basic byte array <-> hex conversions so we don't have// to rely on any large Base64 libraries. Can be overridden if you like!protected String byteArrayToHexString(byte[] b) {StringBuilder sb = new StringBuilder(b.length * 2);for (byte element : b) {int v = element & 0xff;if (v < 16) {sb.append('0');}sb.append(Integer.toHexString(v));}return sb.toString().toUpperCase();}protected byte[] hexStringToByteArray(String s) {int len = s.length();byte[] data = new byte[len / 2];for (int i = 0; i < len; i += 2) {data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));}return data;}
}

\loopj\android\http\RequestHandle.java

package com.loopj.android.http;import java.util.concurrent.Future;/*** A Handle to an AsyncRequest which can be used to cancel a running request.* */
public class RequestHandle {private final Future<?> request;public RequestHandle(Future<?> request) {this.request = request;}/*** Attempts to cancel this request. This attempt will fail if the request has* already completed, has already been cancelled, or could not be cancelled* for some other reason. If successful, and this request has not started* when cancel is called, this request should never run. If the request has* already started, then the mayInterruptIfRunning parameter determines* whether the thread executing this request should be interrupted in an* attempt to stop the request.* * After this method returns, subsequent calls to isDone() will always* return true. Subsequent calls to isCancelled() will always return true* if this method returned true.* * @param mayInterruptIfRunning true if the thread executing this request should be interrupted; otherwise, in-progress requests are allowed to complete* @return false if the request could not be cancelled, typically because it has already completed normally; true otherwise*/public boolean cancel(boolean mayInterruptIfRunning) {if (this.request == null) {return false;}return request.cancel(mayInterruptIfRunning);}/*** Returns true if this task completed. Completion may be due to normal termination, an exception, or cancellation -- in all of these cases, this method will return true.* @return true if this task completed*/public boolean isFinished() {if (this.request == null) {return true;}return request.isDone();}/*** Returns true if this task was cancelled before it completed normally.* @return true if this task was cancelled before it completed*/public boolean isCancelled() {if (this.request == null) {return false;}return request.isCancelled();}
}

\loopj\android\http\RequestParams.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*/package com.loopj.android.http;import org.apache.http.HttpEntity;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;/*** A collection of string request parameters or files to send along with* requests made from an {@link AsyncHttpClient} instance.* <p> </p>* For example:* <p> </p>* <pre>* RequestParams params = new RequestParams();* params.put("username", "james");* params.put("password", "123456");* params.put("email", "my@email.com");* params.put("profile_picture", new File("pic.jpg")); // Upload a File* params.put("profile_picture2", someInputStream); // Upload an InputStream* params.put("profile_picture3", new ByteArrayInputStream(someBytes)); // Upload some bytes* * Map<String, String> map = new HashMap<String, String>();* map.put("first_name", "James");* map.put("last_name", "Smith");* params.put("user", map); // url params: "user[first_name]=James&user[last_name]=Smith"** Set<String> set = new HashSet<String>(); // unordered collection* set.add("music");* set.add("art");* params.put("like", set); // url params: "like=music&like=art"* * List<String> list = new ArrayList<String>(); // Ordered collection* list.add("Java");* list.add("C");* params.put("languages", list); // url params: "languages[]=Java&languages[]=C"* * String[] colors = { "blue", "yellow" }; // Ordered collection* params.put("colors", colors); // url params: "colors[]=blue&colors[]=yellow"* * List<Map<String, String>> listOfMaps = new ArrayList<Map<String, String>>();* Map<String, String> user1 = new HashMap<String, String>();* user1.put("age", "30");* user1.put("gender", "male");* Map<String, String> user2 = new HashMap<String, String>();* user2.put("age", "25");* user2.put("gender", "female");* listOfMaps.add(user1);* listOfMaps.add(user2);* params.put("users", listOfMaps); // url params: "users[][age]=30&users[][gender]=male&users[][age]=25&users[][gender]=female"** AsyncHttpClient client = new AsyncHttpClient();* client.post("http://myendpoint.com", params, responseHandler);* </pre>*/
public class RequestParams {private static final String LOG_TAG = "RequestParams";protected ConcurrentHashMap<String, String> urlParams;protected ConcurrentHashMap<String, StreamWrapper> streamParams;protected ConcurrentHashMap<String, FileWrapper> fileParams;protected ConcurrentHashMap<String, Object> urlParamsWithObjects;/*** Constructs a new empty <code>RequestParams</code> instance.*/public RequestParams() {init();}/*** Constructs a new RequestParams instance containing the key/value* string params from the specified map.** @param source the source key/value string map to add.*/public RequestParams(Map<String, String> source) {init();for (Map.Entry<String, String> entry : source.entrySet()) {put(entry.getKey(), entry.getValue());}}/*** Constructs a new RequestParams instance and populate it with a single* initial key/value string param.** @param key   the key name for the intial param.* @param value the value string for the initial param.*/public RequestParams(String key, String value) {init();put(key, value);}/*** Constructs a new RequestParams instance and populate it with multiple* initial key/value string param.** @param keysAndValues a sequence of keys and values. Objects are*                      automatically converted to Strings (including the value {@code null}).* @throws IllegalArgumentException if the number of arguments isn't even.*/public RequestParams(Object... keysAndValues) {init();int len = keysAndValues.length;if (len % 2 != 0)throw new IllegalArgumentException("Supplied arguments must be even");for (int i = 0; i < len; i += 2) {String key = String.valueOf(keysAndValues[i]);String val = String.valueOf(keysAndValues[i + 1]);put(key, val);}}/*** Adds a key/value string pair to the request.** @param key   the key name for the new param.* @param value the value string for the new param.*/public void put(String key, String value) {if (key != null && value != null) {urlParams.put(key, value);}}/*** Adds a file to the request.** @param key  the key name for the new param.* @param file the file to add.* @throws java.io.FileNotFoundException throws if wrong File argument was passed*/public void put(String key, File file) throws FileNotFoundException {put(key, file, null);}/*** Adds a file to the request.** @param key         the key name for the new param.* @param file        the file to add.* @param contentType the content type of the file, eg. application/json* @throws java.io.FileNotFoundException throws if wrong File argument was passed*/public void put(String key, File file, String contentType) throws FileNotFoundException {if (key != null && file != null) {fileParams.put(key, new FileWrapper(file, contentType));}}/*** Adds an input stream to the request.** @param key    the key name for the new param.* @param stream the input stream to add.*/public void put(String key, InputStream stream) {put(key, stream, null);}/*** Adds an input stream to the request.** @param key    the key name for the new param.* @param stream the input stream to add.* @param name   the name of the stream.*/public void put(String key, InputStream stream, String name) {put(key, stream, name, null);}/*** Adds an input stream to the request.** @param key         the key name for the new param.* @param stream      the input stream to add.* @param name        the name of the stream.* @param contentType the content type of the file, eg. application/json*/public void put(String key, InputStream stream, String name, String contentType) {if (key != null && stream != null) {streamParams.put(key, new StreamWrapper(stream, name, contentType));}}/*** Adds param with non-string value (e.g. Map, List, Set).* @param key   the key name for the new param.* @param value the non-string value object for the new param.*/public void put(String key, Object value)  {if (key != null && value != null) {urlParamsWithObjects.put(key, value);}}/*** Adds string value to param which can have more than one value.* @param key   the key name for the param, either existing or new.* @param value the value string for the new param.*/public void add(String key, String value) {if (key != null && value != null) {Object params = urlParamsWithObjects.get(key);if (params == null) {// Backward compatible, which will result in "k=v1&k=v2&k=v3"params = new HashSet<String>();this.put(key, params);}if (params instanceof List) {((List<Object>) params).add(value);} else if (params instanceof Set) {((Set<Object>) params).add(value);}}}/*** Removes a parameter from the request.** @param key the key name for the parameter to remove.*/public void remove(String key) {urlParams.remove(key);streamParams.remove(key);fileParams.remove(key);urlParamsWithObjects.remove(key);}@Overridepublic String toString() {StringBuilder result = new StringBuilder();for (ConcurrentHashMap.Entry<String, String> entry : urlParams.entrySet()) {if (result.length() > 0)result.append("&");result.append(entry.getKey());result.append("=");result.append(entry.getValue());}for (ConcurrentHashMap.Entry<String, StreamWrapper> entry : streamParams.entrySet()) {if (result.length() > 0)result.append("&");result.append(entry.getKey());result.append("=");result.append("STREAM");}for (ConcurrentHashMap.Entry<String, FileWrapper> entry : fileParams.entrySet()) {if (result.length() > 0)result.append("&");result.append(entry.getKey());result.append("=");result.append("FILE");}List<BasicNameValuePair> params = getParamsList(null, urlParamsWithObjects);for (BasicNameValuePair kv : params) {if (result.length() > 0)result.append("&");result.append(kv.getName());result.append("=");result.append(kv.getValue());}return result.toString();}/*** Returns an HttpEntity containing all request parameters** @param progressHandler HttpResponseHandler for reporting progress on entity submit* @return HttpEntity resulting HttpEntity to be included along with {@link org.apache.http.client.methods.HttpEntityEnclosingRequestBase}* @throws IOException if one of the streams cannot be read*/public HttpEntity getEntity(AsyncHttpResponseHandler progressHandler) throws IOException {if (streamParams.isEmpty() && fileParams.isEmpty()) {return createFormEntity();} else {return createMultipartEntity(progressHandler);}}private HttpEntity createFormEntity() {try {return new UrlEncodedFormEntity(getParamsList(), HTTP.UTF_8);} catch (UnsupportedEncodingException e) {return null; // Actually cannot happen when using utf-8}}private HttpEntity createMultipartEntity(AsyncHttpResponseHandler progressHandler) throws IOException {SimpleMultipartEntity entity = new SimpleMultipartEntity(progressHandler);// Add string paramsfor (ConcurrentHashMap.Entry<String, String> entry : urlParams.entrySet()) {entity.addPart(entry.getKey(), entry.getValue());}// Add non-string paramsList<BasicNameValuePair> params = getParamsList(null, urlParamsWithObjects);for (BasicNameValuePair kv : params) {entity.addPart(kv.getName(), kv.getValue());}// Add stream paramsfor (ConcurrentHashMap.Entry<String, StreamWrapper> entry : streamParams.entrySet()) {StreamWrapper stream = entry.getValue();if (stream.inputStream != null) {entity.addPart(entry.getKey(), stream.name, stream.inputStream,stream.contentType);}}// Add file paramsfor (ConcurrentHashMap.Entry<String, FileWrapper> entry : fileParams.entrySet()) {FileWrapper fileWrapper = entry.getValue();entity.addPart(entry.getKey(), fileWrapper.file, fileWrapper.contentType);}return entity;}private void init() {urlParams = new ConcurrentHashMap<String, String>();streamParams = new ConcurrentHashMap<String, StreamWrapper>();fileParams = new ConcurrentHashMap<String, FileWrapper>();urlParamsWithObjects = new ConcurrentHashMap<String, Object>();}protected List<BasicNameValuePair> getParamsList() {List<BasicNameValuePair> lparams = new LinkedList<BasicNameValuePair>();for (ConcurrentHashMap.Entry<String, String> entry : urlParams.entrySet()) {lparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));}lparams.addAll(getParamsList(null, urlParamsWithObjects));return lparams;}private List<BasicNameValuePair> getParamsList(String key, Object value) {List<BasicNameValuePair> params = new LinkedList<BasicNameValuePair>();if (value instanceof Map) {Map<String, Object> map = (Map<String, Object>) value;List<String> list = new ArrayList<String>(map.keySet());// Ensure consistent ordering in query stringCollections.sort(list);for (String nestedKey : list) {Object nestedValue = map.get(nestedKey);if (nestedValue != null) {params.addAll(getParamsList(key == null ? nestedKey : String.format("%s[%s]", key, nestedKey),nestedValue));}}} else if (value instanceof List) {List<Object> list = (List<Object>) value;for (Object nestedValue : list) {params.addAll(getParamsList(String.format("%s[]", key), nestedValue));}} else if (value instanceof Object[]) {Object[] array = (Object[]) value;for (Object nestedValue : array) {params.addAll(getParamsList(String.format("%s[]", key), nestedValue));}} else if (value instanceof Set) {Set<Object> set = (Set<Object>) value;for (Object nestedValue : set) {params.addAll(getParamsList(key, nestedValue));}} else if (value instanceof String) {params.add(new BasicNameValuePair(key, (String) value));}return params;}protected String getParamString() {return URLEncodedUtils.format(getParamsList(), HTTP.UTF_8);}private static class FileWrapper {public File file;public String contentType;public FileWrapper(File file, String contentType) {this.file = file;this.contentType = contentType;}}private static class StreamWrapper {public InputStream inputStream;public String name;public String contentType;public StreamWrapper(InputStream inputStream, String name, String contentType) {this.inputStream = inputStream;this.name = name;this.contentType = contentType;}}
}

\loopj\android\http\RetryHandler.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*//*Some of the retry logic in this class is heavily borrowed from thefantastic droid-fu project: https://github.com/donnfelker/droid-fu
*/package com.loopj.android.http;import android.os.SystemClock;import org.apache.http.NoHttpResponseException;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.protocol.ExecutionContext;
import org.apache.http.protocol.HttpContext;import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.HashSet;import javax.net.ssl.SSLException;class RetryHandler implements HttpRequestRetryHandler {private static HashSet<Class<?>> exceptionWhitelist = new HashSet<Class<?>>();private static HashSet<Class<?>> exceptionBlacklist = new HashSet<Class<?>>();static {// Retry if the server dropped connection on usexceptionWhitelist.add(NoHttpResponseException.class);// retry-this, since it may happens as part of a Wi-Fi to 3G failoverexceptionWhitelist.add(UnknownHostException.class);// retry-this, since it may happens as part of a Wi-Fi to 3G failoverexceptionWhitelist.add(SocketException.class);// never retry timeoutsexceptionBlacklist.add(InterruptedIOException.class);// never retry SSL handshake failuresexceptionBlacklist.add(SSLException.class);}private final int maxRetries;private final int retrySleepTimeMS;public RetryHandler(int maxRetries, int retrySleepTimeMS) {this.maxRetries = maxRetries;this.retrySleepTimeMS = retrySleepTimeMS;}@Overridepublic boolean retryRequest(IOException exception, int executionCount, HttpContext context) {boolean retry = true;Boolean b = (Boolean) context.getAttribute(ExecutionContext.HTTP_REQ_SENT);boolean sent = (b != null && b);if (executionCount > maxRetries) {// Do not retry if over max retry countretry = false;} else if (isInList(exceptionBlacklist, exception)) {// immediately cancel retry if the error is blacklistedretry = false;} else if (isInList(exceptionWhitelist, exception)) {// immediately retry if error is whitelistedretry = true;} else if (!sent) {// for most other errors, retry only if request hasn't been fully sent yetretry = true;}if (retry) {// resend all idempotent requestsHttpUriRequest currentReq = (HttpUriRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST);if (currentReq == null) {return false;}String requestType = currentReq.getMethod();retry = !requestType.equals("POST");}if (retry) {SystemClock.sleep(retrySleepTimeMS);} else {exception.printStackTrace();}return retry;}protected boolean isInList(HashSet<Class<?>> list, Throwable error) {for (Class<?> aList : list) {if (aList.isInstance(error)) {return true;}}return false;}
}

\loopj\android\http\SerializableCookie.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*/package com.loopj.android.http;import org.apache.http.cookie.Cookie;
import org.apache.http.impl.cookie.BasicClientCookie;import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;/*** A wrapper class around {@link Cookie} and/or {@link BasicClientCookie}* designed for use in {@link PersistentCookieStore}.*/
public class SerializableCookie implements Serializable {private static final long serialVersionUID = 6374381828722046732L;private transient final Cookie cookie;private transient BasicClientCookie clientCookie;public SerializableCookie(Cookie cookie) {this.cookie = cookie;}public Cookie getCookie() {Cookie bestCookie = cookie;if (clientCookie != null) {bestCookie = clientCookie;}return bestCookie;}private void writeObject(ObjectOutputStream out) throws IOException {out.writeObject(cookie.getName());out.writeObject(cookie.getValue());out.writeObject(cookie.getComment());out.writeObject(cookie.getDomain());out.writeObject(cookie.getExpiryDate());out.writeObject(cookie.getPath());out.writeInt(cookie.getVersion());out.writeBoolean(cookie.isSecure());}private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {String name = (String) in.readObject();String value = (String) in.readObject();clientCookie = new BasicClientCookie(name, value);clientCookie.setComment((String) in.readObject());clientCookie.setDomain((String) in.readObject());clientCookie.setExpiryDate((Date) in.readObject());clientCookie.setPath((String) in.readObject());clientCookie.setVersion(in.readInt());clientCookie.setSecure(in.readBoolean());}
}

\loopj\android\http\SimpleMultipartEntity.java

/*Android Asynchronous Http ClientCopyright (c) 2011 James Smith <james@loopj.com>http://loopj.comLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.
*//*This code is taken from Rafael Sanches' blog.http://blog.rafaelsanches.com/2011/01/29/upload-using-multipart-post-using-httpclient-in-android/
*/package com.loopj.android.http;import android.util.Log;import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.message.BasicHeader;import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;/*** Simplified multipart entity mainly used for sending one or more files.*/
class SimpleMultipartEntity implements HttpEntity {private static final String LOG_TAG = "SimpleMultipartEntity";private static final String APPLICATION_OCTET_STREAM = "application/octet-stream";private static final byte[] CR_LF = ("\r\n").getBytes();private static final byte[] TRANSFER_ENCODING_BINARY = "Content-Transfer-Encoding: binary\r\n".getBytes();private final static char[] MULTIPART_CHARS = "-_1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();private String boundary;private byte[] boundaryLine;private byte[] boundaryEnd;private List<FilePart> fileParts = new ArrayList<FilePart>();// The buffer we use for building the message excluding files and the last// boundaryprivate ByteArrayOutputStream out = new ByteArrayOutputStream();private AsyncHttpResponseHandler progressHandler;private int bytesWritten;private int totalSize;public SimpleMultipartEntity(AsyncHttpResponseHandler progressHandler) {final StringBuilder buf = new StringBuilder();final Random rand = new Random();for (int i = 0; i < 30; i++) {buf.append(MULTIPART_CHARS[rand.nextInt(MULTIPART_CHARS.length)]);}boundary = buf.toString();boundaryLine = ("--" + boundary + "\r\n").getBytes();boundaryEnd = ("--" + boundary + "--\r\n").getBytes();this.progressHandler = progressHandler;}public void addPart(final String key, final String value, final String contentType) {try {out.write(boundaryLine);out.write(createContentDisposition(key));out.write(createContentType(contentType));out.write(CR_LF);out.write(value.getBytes());out.write(CR_LF);} catch (final IOException e) {// Can't happen on ByteArrayOutputStreamLog.e(LOG_TAG, "addPart ByteArrayOutputStream exception", e);}}public void addPart(final String key, final String value) {addPart(key, value, "text/plain; charset=UTF-8");}public void addPart(String key, File file) {addPart(key, file, null);}public void addPart(final String key, File file, String type) {if (type == null) {type = APPLICATION_OCTET_STREAM;}fileParts.add(new FilePart(key, file, type));}public void addPart(String key, String streamName, InputStream inputStream, String type)throws IOException {if (type == null) {type = APPLICATION_OCTET_STREAM;}out.write(boundaryLine);// Headersout.write(createContentDisposition(key, streamName));out.write(createContentType(type));out.write(TRANSFER_ENCODING_BINARY);out.write(CR_LF);// Stream (file)final byte[] tmp = new byte[4096];int l;while ((l = inputStream.read(tmp)) != -1) {out.write(tmp, 0, l);}out.write(CR_LF);out.flush();try {inputStream.close();} catch (final IOException e) {// Not important, just log itLog.w(LOG_TAG, "Cannot close input stream", e);}}private byte[] createContentType(String type) {String result = "Content-Type: " + type + "\r\n";return result.getBytes();}private byte[] createContentDisposition(final String key) {return ("Content-Disposition: form-data; name=\"" + key + "\"\r\n").getBytes();}private byte[] createContentDisposition(final String key, final String fileName) {return ("Content-Disposition: form-data; name=\"" + key + "\"; filename=\"" + fileName + "\"\r\n").getBytes();}private void updateProgress(int count) {bytesWritten += count;progressHandler.sendProgressMessage(bytesWritten, totalSize);}private class FilePart {public File file;public byte[] header;public FilePart(String key, File file, String type) {header = createHeader(key, file.getName(), type);this.file = file;}private byte[] createHeader(String key, String filename, String type) {ByteArrayOutputStream headerStream = new ByteArrayOutputStream();try {headerStream.write(boundaryLine);// HeadersheaderStream.write(createContentDisposition(key, filename));headerStream.write(createContentType(type));headerStream.write(TRANSFER_ENCODING_BINARY);headerStream.write(CR_LF);} catch (IOException e) {// Can't happen on ByteArrayOutputStreamLog.e(LOG_TAG, "createHeader ByteArrayOutputStream exception", e);}return headerStream.toByteArray();}public long getTotalLength() {long streamLength = file.length();return header.length + streamLength;}public void writeTo(OutputStream out) throws IOException {out.write(header);updateProgress(header.length);FileInputStream inputStream = new FileInputStream(file);final byte[] tmp = new byte[4096];int l;while ((l = inputStream.read(tmp)) != -1) {out.write(tmp, 0, l);updateProgress(l);}out.write(CR_LF);updateProgress(CR_LF.length);out.flush();try {inputStream.close();} catch (final IOException e) {// Not important, just log itLog.w(LOG_TAG, "Cannot close input stream", e);}}}// The following methods are from the HttpEntity interface@Overridepublic long getContentLength() {long contentLen = out.size();for (FilePart filePart : fileParts) {long len = filePart.getTotalLength();if (len < 0) {return -1; // Should normally not happen}contentLen += len;}contentLen += boundaryEnd.length;return contentLen;}@Overridepublic Header getContentType() {return new BasicHeader("Content-Type", "multipart/form-data; boundary=" + boundary);}@Overridepublic boolean isChunked() {return false;}@Overridepublic boolean isRepeatable() {return false;}@Overridepublic boolean isStreaming() {return false;}@Overridepublic void writeTo(final OutputStream outstream) throws IOException {bytesWritten = 0;totalSize = (int) getContentLength();out.writeTo(outstream);updateProgress(out.size());for (FilePart filePart : fileParts) {filePart.writeTo(outstream);}outstream.write(boundaryEnd);updateProgress(boundaryEnd.length);}@Overridepublic Header getContentEncoding() {return null;}@Overridepublic void consumeContent() throws IOException, UnsupportedOperationException {if (isStreaming()) {throw new UnsupportedOperationException("Streaming entity does not implement #consumeContent()");}}@Overridepublic InputStream getContent() throws IOException, UnsupportedOperationException {throw new UnsupportedOperationException("getContent() is not supported. Use writeTo() instead.");}
}

\loopj\android\http\SyncHttpClient.java

package com.loopj.android.http;import android.content.Context;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.protocol.HttpContext;public class SyncHttpClient extends AsyncHttpClient {/*** Creates a new SyncHttpClient with default constructor arguments values*/public SyncHttpClient() {super(false, 80, 443);}/*** Creates a new SyncHttpClient.** @param httpPort non-standard HTTP-only port*/public SyncHttpClient(int httpPort) {super(false, httpPort, 443);}/*** Creates a new SyncHttpClient.** @param httpPort  non-standard HTTP-only port* @param httpsPort non-standard HTTPS-only port*/public SyncHttpClient(int httpPort, int httpsPort) {super(false, httpPort, httpsPort);}/*** Creates new SyncHttpClient using given params** @param fixNoHttpResponseException Whether to fix or not issue, by ommiting SSL verification* @param httpPort                   HTTP port to be used, must be greater than 0* @param httpsPort                  HTTPS port to be used, must be greater than 0*/public SyncHttpClient(boolean fixNoHttpResponseException, int httpPort, int httpsPort) {super(fixNoHttpResponseException, httpPort, httpsPort);}/*** Creates a new SyncHttpClient.** @param schemeRegistry SchemeRegistry to be used*/public SyncHttpClient(SchemeRegistry schemeRegistry) {super(schemeRegistry);}@Overrideprotected RequestHandle sendRequest(DefaultHttpClient client,HttpContext httpContext, HttpUriRequest uriRequest,String contentType, AsyncHttpResponseHandler responseHandler,Context context) {if (contentType != null) {uriRequest.addHeader("Content-Type", contentType);}responseHandler.setUseSynchronousMode(true);/** will execute the request directly*/new AsyncHttpRequest(client, httpContext, uriRequest, responseHandler).run();// Return a Request Handle that cannot be used to cancel the request// because it is already complete by the time this returnsreturn new RequestHandle(null);}
}

\loopj\android\http\TextHttpResponseHandler.java

package com.loopj.android.http;import android.util.Log;import org.apache.http.Header;import java.io.UnsupportedEncodingException;/*** Used to intercept and handle the responses from requests made using* {@link AsyncHttpClient}. The {@link #onSuccess(String)} method is* designed to be anonymously overridden with your own response handling code.* <p/>* Additionally, you can override the {@link #onFailure(String, Throwable)},* {@link #onStart()}, and {@link #onFinish()} methods as required.* <p/>* For example:* <p/>* <pre>* AsyncHttpClient client = new AsyncHttpClient();* client.get("http://www.google.com", new TextHttpResponseHandler() {*     @Override*     public void onStart() {*         // Initiated the request*     }**     @Override*     public void onSuccess(String responseBody) {*         // Successfully got a response*     }**     @Override*     public void onFailure(String responseBody, Throwable e) {*         // Response failed :(*     }**     @Override*     public void onFinish() {*         // Completed the request (either success or failure)*     }* });* </pre>*/
public class TextHttpResponseHandler extends AsyncHttpResponseHandler {private static final String LOG_TAG = "TextHttpResponseHandler";/*** Creates a new TextHttpResponseHandler*/public TextHttpResponseHandler() {this(DEFAULT_CHARSET);}public TextHttpResponseHandler(String encoding) {super();setCharset(encoding);}//// Callbacks to be overridden, typically anonymously///*** Fired when a request fails to complete, override to handle in your own* code** @param responseBody the response body, if any* @param error        the underlying cause of the failure*/public void onFailure(String responseBody, Throwable error) {}/*** Fired when a request fails to complete, override to handle in your own* code** @param statusCode   the status code of the response* @param headers      HTTP response headers* @param responseBody the response body, if any* @param error        the underlying cause of the failure*/public void onFailure(int statusCode, Header[] headers, String responseBody, Throwable error) {onFailure(responseBody, error);}/*** Fired when a request returns successfully, override to handle in your own* code** @param statusCode the status code of the response* @param headers HTTP response headers* @param responseBody the body of the HTTP response from the server*/@Overridepublic void onSuccess(int statusCode, Header[] headers, String responseBody) {onSuccess( statusCode, responseBody );}@Overridepublic void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {try {onSuccess(statusCode, headers, new String(responseBody, getCharset()));} catch (UnsupportedEncodingException e) {Log.v(LOG_TAG, "String encoding failed, calling onFailure(int, Header[], String, Throwable)");onFailure(0, headers, (String) null, e);}}@Overridepublic void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {try {onFailure(statusCode, headers, new String(responseBody, getCharset()), error);} catch (UnsupportedEncodingException e) {Log.v(LOG_TAG, "String encoding failed, calling onFailure(int, Header[], String, Throwable)");onFailure(0, headers, (String) null, e);}}}

完整项目下载地址： http://download.csdn.net/detail/iwanghang/9792768

转载请注明出处： http://blog.csdn.net/iwanghang/article/details/65633129

欢迎移动开发爱好者交流
沈阳或周边城市公司有意开发Android，请与我联系
联系方式

微信：iwanghang
QQ：413711276
邮箱：iwanghang@qq.com

觉得博文有用，请点赞，请评论，请关注，谢谢！~

Android选择/拍照 剪裁 base64/16进制/byte上传图片+PHP接收图片相关推荐

1. Unity C# 将String字符串转换为16进制Byte数组

   今天开发过程中后台给了我一个已经转成string了的16进制字符串,我这边做了些处理,将str又转回16进制,并以16位16进制byte数组的形式存放了. void Start(){string st ...

2. java 16进制_JAVA十六进制数据接收与传输

   由于项目中经常遇到与设备进行交互获取数据,不仅有Python版本.还有Java版本,还可能会有C#版本,在此做个记录. 一.十六进制转换工具类 主要包含十六进制字符串转ASCII,ASCII转十六进制 ...

3. python将图片转十六进制_如何使用python将16进制字符串还原为PNG图片？

   各位,我这里有一个png图片的16进制的字符串,如何用python输出为png位图? thanks 89504e470d0a1a0a0000000d49484452000000320000007b08 ...

4. Java中bit操作常用技巧，16进制byte转bit

   概念速览 1. bit :位 一个 二进制 数据0或1,是1bit: 2. byte :字节 存储空间的基本计量单位,如:MySQL中定义 VARCHAR(45)  即是指 45个字节: 1 byte ...

5. java php des加密 byte数组16进制 DESTools

   大家好,我是烤鸭: 今天分享的是java 和 php des 加密. 因为接口对接,难免不同语言,加密又是必不可少的. 作为接口的提供方,必须把加密规则写好,最好有不同语言的加密demo. 1.    ...

6. java socket发送16进制_JavaSocket短连接实现分别接收字符串和16进制数据

   做个笔记,在接收16进制数据的时候乱码了.原因是Socket在接收数据的时候需要根据不同的数据定义不同的接收方式,也就是约定好传输协议(具体体现在后面服务端接收16进制那里). 字符串的发送接收 字符 ...

7. android 16进制 全透明_你有几种实现方案Android 设备唯一标识？

   前言 项目开发中,多少会遇到这种需求:获得设备唯一标识DeviceId,用于: 1.标识一个唯一的设备,做数据精准下发或者数据统计分析: 2.账号与设备绑定: 3..... 分析 这类文章,网上有许多 ...

8. 16进制转Base64的实现原理及代码

   随着计算机技术的发展,数据的存储和传输方式也在不断更新,其中十六进制字符串和Base64编码是两种常见的数据表示方式.本文将介绍16进制字符串和Base64编码的原理,并提供Java代码实现16进制字 ...

9. linux进程号转换成16进制,Shell脚本中不同进制数据转换的例子（二进制、八进制、十六进制、base64)...

   shell可以在不调用第3方命令,表示不同进制数据.这里总结以下表示方法.shell 脚本默认数值是由10 进制数处理,除非这个数字某种特殊的标记法或前缀开头. 才可以表示其它进制类型数值.如:以 0 ...

最新文章

1. J2EE学习中一些值得研究的开源项目（转载天极网）
2. UA MATH563 概率论的数学基础 中心极限定理14 Kolmogorov maximal inequality
3. 是什么影响了MySQL性能？
4. 部署Office Web Apps Server并配置其与SharePoint 2013的集成
5. 总线协议之I2C总线时序
6. 剑指offer 面试32题
7. linksys 打印软件_Linksys对FCC表示“不”，Mozilla扩大了开源资金，还有更多新闻
8. centos下svn和Apache的结合使用
9. 数据结构与算法小结——排序（八）
10. OpenSuSE 网络配置
11. 户籍管理员按1进入函数1c语言,户籍管理系统信息系统.doc
12. 服务器lsass状态代码c0000005,lsass.exe是什么进程？Win7系统提示Lsass.exe系统错误的原因及解决方法...
13. 图神经网络-图游走类模型-作业
14. java gc什么意思_Java的GC是什么？做了什么？
15. Excel VBA内部函数大全
16. 数学三次方的计算机符号,数学符号三次方
17. 使用计算机管理文件教后反思,《管理计算机中的文件》教学设计
18. 红米5双清_红米手机双清步骤
19. 微信摇一摇插件ios_iOS仿微信摇一摇功能
20. DC综合——学习笔记

热门文章

1. RStudio安装失败的解决办法
2. C++：图片数字水印-基于OpenCV+LSB
3. 混淆矩阵与miou代码
4. 医美his管理软件系统解说新开医美整形机构，90%都是这个流程
5. 大数据分析的思维方式有哪些
6. 【ACWing】1176. 消息的传递
7. 基于FPGA的数字电子琴——数电小系统设计【数字电子技术】(使用Vivado中的verilog语言）含piano代码文件（全）
8. Flutter 不一样的跨平台解决方案
9. Android studio创建第一个项目并运行
10. 大数据职业理解_3大数据职业职位描述及其职业要求