Java tutorial
/* Android Asynchronous Http Client Copyright (c) 2011 James Smith <james@loopj.com> http://loopj.com 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 http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed 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 and limitations under the License. */ package com.loopj.android.http; import java.io.IOException; import java.io.InputStream; import java.util.HashMap; import java.util.Map; import java.util.zip.GZIPInputStream; import org.apache.http.Header; import org.apache.http.HeaderElement; import org.apache.http.HttpEntity; 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.HttpEntityEnclosingRequestBase; import org.apache.http.client.methods.HttpGet; import org.apache.http.client.methods.HttpPost; 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.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.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 android.util.Log; import com.llbt.myownmvc.MyOwnMVCApp; import com.llbt.myownmvc.R; import com.llbt.myownmvc.utils.Utils; import com.meepwn.utils.MyLog; /** * */ public class RdHttpClient { private static final String VERSION = "1.4.3"; 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_SOCKET_BUFFER_SIZE = 8192; private static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding"; private static final String ENCODING_GZIP = "gzip"; private static int maxConnections = DEFAULT_MAX_CONNECTIONS; private static int socketTimeout = DEFAULT_SOCKET_TIMEOUT; private final DefaultHttpClient httpClient; private final HttpContext httpContext; private final Map<String, String> clientHeaderMap; /** * Creates a new AsyncHttpClient. */ public RdHttpClient() { BasicHttpParams httpParams = new BasicHttpParams(); ConnManagerParams.setTimeout(httpParams, socketTimeout); ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(maxConnections)); ConnManagerParams.setMaxTotalConnections(httpParams, DEFAULT_MAX_CONNECTIONS); HttpConnectionParams.setSoTimeout(httpParams, socketTimeout); HttpConnectionParams.setConnectionTimeout(httpParams, socketTimeout); 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)); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry); httpContext = new SyncBasicHttpContext(new BasicHttpContext()); httpClient = new DefaultHttpClient(cm, httpParams); httpClient.addRequestInterceptor(new HttpRequestInterceptor() { @Override public 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.clearResponseInterceptors(); httpClient.addResponseInterceptor(new HttpResponseInterceptor() { @Override public 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(response.getEntity())); break; } } } } }); httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_MAX_RETRIES)); clientHeaderMap = new HashMap<String, String>(); } /** * 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. */ 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. */ 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); } /** * 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); } /** * Sets the connection time oout. By default, 10 seconds * * @param timeout * the connect/socket timeout in milliseconds */ public void setTimeout(int timeout) { final HttpParams httpParams = this.httpClient.getParams(); ConnManagerParams.setTimeout(httpParams, timeout); HttpConnectionParams.setSoTimeout(httpParams, timeout); HttpConnectionParams.setConnectionTimeout(httpParams, timeout); } /** * 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 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); } /** * Sets basic authentication for the request. Uses AuthScope.ANY. This is * the same as setBasicAuth('username','password',AuthScope.ANY) * * @param username * @param password */ public void setBasicAuth(String user, String pass) { AuthScope scope = AuthScope.ANY; setBasicAuth(user, pass, 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 * @param password * @param scope * - an AuthScope object * */ public void setBasicAuth(String user, String pass, AuthScope scope) { UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(user, pass); this.httpClient.getCredentialsProvider().setCredentials(scope, credentials); } public static String getUrlWithQueryString(String url, RequestParams params) { if (params != null) { String paramString = params.getParamString(); if (url.indexOf("?") == -1) { url += "?" + paramString; } else { url += "&" + paramString; } } return url; } private HttpEntity paramsToEntity(RequestParams params) { HttpEntity entity = null; if (params != null) { entity = params.getEntity(); } return entity; } private HttpEntityEnclosingRequestBase addEntityToRequestBase(HttpEntityEnclosingRequestBase requestBase, HttpEntity entity) { if (entity != null) { requestBase.setEntity(entity); } return requestBase; } private static class InflatingEntity extends HttpEntityWrapper { public InflatingEntity(HttpEntity wrapped) { super(wrapped); } @Override public InputStream getContent() throws IOException { return new GZIPInputStream(wrappedEntity.getContent()); } @Override public long getContentLength() { return -1; } } /** * * * @param url * @param params * @return * @throws Exception */ public String get(String url, RequestParams params) throws Exception { if (!Utils.checkNetworkAvailable(MyOwnMVCApp.app)) { throw new Exception(MyOwnMVCApp.app.getString(R.string.no_network)); } String furl = getUrlWithQueryString(url, params); MyLog.log(Log.DEBUG, getClass(), "block get:" + furl); RdHttpRequest request = new RdHttpRequest(httpClient, httpContext, new HttpGet(furl)); String res = request.run(); MyLog.log(Log.DEBUG, getClass(), "block get:" + furl + " res:" + res); return res; } public String post(String url, RequestParams params) throws Exception { if (!Utils.checkNetworkAvailable(MyOwnMVCApp.app)) { throw new Exception(MyOwnMVCApp.app.getString(R.string.no_network)); } MyLog.log(Log.DEBUG, getClass(), "block post:" + url + " ps:" + params.toString()); HttpEntity entity = paramsToEntity(params); HttpEntityEnclosingRequestBase base = addEntityToRequestBase(new HttpPost(url), entity); RdHttpRequest request = new RdHttpRequest(httpClient, httpContext, base); String res = request.run(); MyLog.log(Log.DEBUG, getClass(), "block post:" + url + " ps:" + params.toString() + " res:" + res); return res; } public String post(String url, HttpEntity entity) throws Exception { MyLog.log(Log.DEBUG, getClass(), "block post:" + url + " ps:" + entity.toString()); if (!Utils.checkNetworkAvailable(MyOwnMVCApp.app)) { throw new Exception(MyOwnMVCApp.app.getString(R.string.no_network)); } HttpEntityEnclosingRequestBase base = addEntityToRequestBase(new HttpPost(url), entity); RdHttpRequest request = new RdHttpRequest(httpClient, httpContext, base); String res = request.run(); MyLog.log(Log.DEBUG, getClass(), "block post:" + url + " ps:" + entity.toString() + " res:" + res); return res; } }