1200字范文 > Android选择/拍照剪裁 base64/16进制/byte上传图片+PHP接收图片

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

时间：2019-07-16 18:54:01

转载请注明出处：/iwanghang/article/details/65633129

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

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

完整项目下载地址：/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:

\uploadimg\MainActivity.java

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 .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();press(pressFormat.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:-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;}}}

\uploadimg\Hex.java

package com.jerry.uploadimg;/*** reference apache commons <a* href="/codec/">/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);}}

activity_main.xml

loopj\android\http

loopj\android\http\AsyncHttpClient.java

/*Android Asynchronous Http ClientCopyright (c) James Smith <james@>Licensed 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 at/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.* * For example:* * <pre>* AsyncHttpClient client = new AsyncHttpClient();* client.get("", 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 /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 (/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 (/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 portthe 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 portthe 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.* * Note: 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 contextthe 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 paramsadditional 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 paramsadditional 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 paramsadditional 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 paramsadditional 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 paramsadditional 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 paramsadditional 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 paramsadditional 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 paramsadditional 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 entitya 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 contentTypethe 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 paramsadditional POST parameters to send with the request.* @param contentTypethe 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 entitya 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 contentTypethe 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 paramsadditional 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 paramsadditional 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 entitya 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 contentTypethe 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 entitya 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 contentTypethe 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 paramsadditional 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 clientHttpClient to be used for request, can differ in single requests* @param contentTypeMIME body type, for POST and PUT requests, may be null* @param context Context of Android application, to hold the reference of request* @param httpContextHttpContext in which the request will be executed* @param responseHandler ResponseHandler or its subclass to put the response into* @param uriRequestinstance 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 paramsadditional 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 entityentity 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

loopj\android\http\AsyncHttpResponseHandler.java

\loopj\android\http\BinaryHttpResponseHandler.java

\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

loopj\android\http\JsonHttpResponseHandler.java

loopj\android\http\MySSLSocketFactory.java

package com.loopj.android.http;import org.apache.http.conn.ssl.SSLSocketFactory;import java.io.IOException;import .Socket;import java.security.KeyManagementException;import java.security.KeyStore;import java.security.KeyStoreException;import java.security.NoSuchAlgorithmException;import java.security.UnrecoverableKeyException;import .ssl.SSLContext;import .ssl.TrustManager;import .ssl.X509TrustManager;/*** This file is introduced to fix HTTPS Post bug on API < ICS* see /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

\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

\loopj\android\http\RetryHandler.java

\loopj\android\http\SerializableCookie.java

\loopj\android\http\SimpleMultipartEntity.java

\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.* * Additionally, you can override the {@link #onFailure(String, Throwable)},* {@link #onStart()}, and {@link #onFinish()} methods as required.* * For example:* * <pre>* AsyncHttpClient client = new AsyncHttpClient();* client.get("", 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 headersHTTP 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);}}}

完整项目下载地址：/detail/iwanghang/9792768

转载请注明出处：/iwanghang/article/details/65633129

欢迎移动开发爱好者交流

沈阳或周边城市公司有意开发Android，请与我联系

联系方式

微信：iwanghang

QQ：413711276

邮箱：iwanghang@

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

本内容不代表本网观点和政治立场，如有侵犯你的权益请联系我们处理。

网友评论

网友评论仅供其表达个人看法，并不表明网站立场。