public HttpUtils(int connTimeout, String userAgent) {
HttpParams params = new BasicHttpParams();
ConnManagerParams.setTimeout(params, connTimeout);
HttpConnectionParams.setSoTimeout(params, connTimeout);
HttpConnectionParams.setConnectionTimeout(params, connTimeout);
if (TextUtils.isEmpty(userAgent)) {
userAgent = OtherUtils.getUserAgent(null);
}
HttpProtocolParams.setUserAgent(params, userAgent);
ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(10));
ConnManagerParams.setMaxTotalConnections(params, 10);
HttpConnectionParams.setTcpNoDelay(params, true);
HttpConnectionParams.setSocketBufferSize(params, 1024 * 8);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", DefaultSSLSocketFactory.getSocketFactory(), 443));
httpClient =
new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params);
httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_RETRY_TIMES));
httpClient.addRequestInterceptor(
new HttpRequestInterceptor() {
@Override
public void process(org.apache.http.HttpRequest httpRequest, HttpContext httpContext)
throws org.apache.http.HttpException, IOException {
if (!httpRequest.containsHeader(HEADER_ACCEPT_ENCODING)) {
httpRequest.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
}
}
});
httpClient.addResponseInterceptor(
new HttpResponseInterceptor() {
@Override
public void process(HttpResponse response, HttpContext httpContext)
throws org.apache.http.HttpException, IOException {
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("gzip")) {
response.setEntity(new GZipDecompressingEntity(response.getEntity()));
return;
}
}
}
}
});
}
private HttpClient getHttpClient() {
if (null == customerHttpClient) {
HttpParams params = new BasicHttpParams();
// 设置一些基本参数
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
HttpProtocolParams.setUseExpectContinue(params, true);
HttpProtocolParams.setUserAgent(params, "Linux; Android 2.2.1;zh-CN; itkt_Android");
// HttpClientParams.setRedirecting(params, true);
// HttpClientParams.setCookiePolicy(params, CookiePolicy.BROWSER_COMPATIBILITY);
// 设置最大连接数
ConnManagerParams.setMaxTotalConnections(params, MAX_TOTAL_CONNECTIONS);
// 设置获取连接的最大等待时间
ConnManagerParams.setTimeout(params, WAIT_TIMEOUT);
// 设置每个路由最大连接数
ConnPerRouteBean connPerRoute = new ConnPerRouteBean(MAX_ROUTE_CONNECTIONS);
ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);
// 设置连接超时时间
HttpConnectionParams.setConnectionTimeout(params, CONNECT_TIMEOUT);
// 设置读取超时时间
HttpConnectionParams.setSoTimeout(params, READ_TIMEOUT);
try {
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
SchemeRegistry schReg = new SchemeRegistry();
schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
// 使用线程安全的连接管理来创建HttpClient
ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, schReg);
customerHttpClient = new DefaultHttpClient(conMgr, params);
customerHttpClient.getParams().setParameter("http.protocol.content-charset", HTTP.UTF_8);
} catch (Exception e) {
e.printStackTrace();
}
}
return customerHttpClient;
}
public void testCloseExpiredConnections() throws Exception {
HttpParams mgrpar = defaultParams.copy();
ConnManagerParams.setMaxTotalConnections(mgrpar, 1);
SingleClientConnManager mgr = createSCCM(mgrpar, null);
final HttpHost target = getServerHttp();
final HttpRoute route = new HttpRoute(target, null, false);
ManagedClientConnection conn = mgr.getConnection(route, null);
conn.open(route, httpContext, defaultParams);
mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS);
mgr.closeExpiredConnections();
conn = mgr.getConnection(route, null);
assertTrue(conn.isOpen());
mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS);
Thread.sleep(150);
mgr.closeExpiredConnections();
conn = mgr.getConnection(route, null);
assertFalse(conn.isOpen());
mgr.shutdown();
}
protected DefaultHttpClient getHttpClient() {
if (httpClient == null) {
HttpParams httpParams = new BasicHttpParams();
HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(httpParams, HTTP.UTF_8);
HttpProtocolParams.setUseExpectContinue(
httpParams, false); // some webservers have problems if this is set to true
ConnManagerParams.setMaxTotalConnections(httpParams, MAX_TOTAL_CONNECTIONS);
HttpConnectionParams.setConnectionTimeout(httpParams, CONNECTION_TIMEOUT);
HttpConnectionParams.setSoTimeout(httpParams, SOCKET_TIMEOUT);
// httpParams.setParameter(ConnRoutePNames.DEFAULT_PROXY, new
// HttpHost("192.168.16.180", 8888, "http"));
httpParams.setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.RFC_2109);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
ClientConnectionManager connectionManager =
new ThreadSafeClientConnManager(httpParams, schemeRegistry);
httpClient = new DefaultHttpClient(connectionManager, httpParams);
}
return httpClient;
}
private DefaultHttpClient getNewHttpClient() {
DefaultHttpClient client = null;
try {
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
trustStore.load(null, null);
SSLSocketFactory sf = new TrustedSSLSocketFactory(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
HttpParams params = new BasicHttpParams();
ConnManagerParams.setMaxTotalConnections(params, 100);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
registry.register(new Scheme("https", sf, 443));
ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);
client = new DefaultHttpClient(ccm, params);
} catch (Exception e) {
client = new DefaultHttpClient();
}
client = applyTimeout(client);
return client;
}
/** Creates a new AsyncHttpClient. */
public AsyncHttpClient() {
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.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() {
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.addResponseInterceptor(
new HttpResponseInterceptor() {
public void process(HttpResponse response, HttpContext context) {
final HttpEntity entity = response.getEntity();
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));
threadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool();
requestMap = new WeakHashMap<Context, List<WeakReference<Future<?>>>>();
clientHeaderMap = new HashMap<String, String>();
}
public Http(Context context) {
BasicHttpParams httpParams = new BasicHttpParams();
ConnManagerParams.setTimeout(httpParams, socketTimeout);
ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(maxConnections));
ConnManagerParams.setMaxTotalConnections(httpParams, 10);
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);
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() {
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.addResponseInterceptor(
new HttpResponseInterceptor() {
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;
}
}
}
}
});
clientHeaderMap = new HashMap<String, String>();
}
private static DefaultHttpClient clientFactory() {
SchemeRegistry sr = new SchemeRegistry();
sr.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
BasicHttpParams params = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params, CONN_TIMEOUT);
HttpConnectionParams.setSoTimeout(params, CONN_TIMEOUT);
ConnManagerParams.setMaxTotalConnections(params, MAX_TOTAL_CONN);
ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(MAX_CONN_PER_ROUTE));
ThreadSafeClientConnManager mgr = new ThreadSafeClientConnManager(params, sr);
DefaultHttpClient client = new DefaultHttpClient(mgr, params);
return client;
}
private static void setupHttpClient() {
BasicHttpParams httpParams = new BasicHttpParams();
ConnManagerParams.setTimeout(httpParams, CONNECTION_TIMEOUT);
ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(MAX_CONNECTIONS));
ConnManagerParams.setMaxTotalConnections(httpParams, MAX_CONNECTIONS);
HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
HttpProtocolParams.setUserAgent(httpParams, HTTP_USER_AGENT);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
// schemeRegistry.register(new Scheme("https", new
// EasySSLProtocolSocketFactory(), 443));
ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry);
HttpProtocolParams.setContentCharset(httpParams, HTTP.UTF_8);
httpClient = new DefaultHttpClient(cm, httpParams);
}
/** initialize HttpParams , initialize settings such as total connextions,timeout ... */
private BasicHttpParams createHttpParams() {
BasicHttpParams params = new BasicHttpParams();
ConnManagerParams.setTimeout(params, config.getConnectTimeout());
ConnManagerParams.setMaxConnectionsPerRoute(
params, new ConnPerRouteBean(DEFAULT_MAX_CONN_PER_ROUT));
ConnManagerParams.setMaxTotalConnections(params, DEFAULT_MAX_CONN_TOTAL);
HttpConnectionParams.setTcpNoDelay(params, TCP_NO_DELAY);
HttpConnectionParams.setConnectionTimeout(params, config.getConnectTimeout());
HttpConnectionParams.setSoTimeout(params, config.getSocketTimeout());
HttpConnectionParams.setSocketBufferSize(params, config.getSocketBufferSize());
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setUserAgent(params, config.getUserAgent());
// settingOthers(params);
return params;
}
public static HttpClient getThreadSafeClient() {
HttpParams params = new BasicHttpParams();
ConnManagerParams.setMaxTotalConnections(params, 100);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpConnectionParams.setConnectionTimeout(params, REGISTRATION_TIMEOUT);
HttpConnectionParams.setSoTimeout(params, REGISTRATION_TIMEOUT);
ConnManagerParams.setTimeout(params, REGISTRATION_TIMEOUT);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
ClientConnectionManager mgr = new ThreadSafeClientConnManager(params, schemeRegistry);
HttpClient client = new DefaultHttpClient(mgr, params);
return client;
}
/** Tests that SCM can still connect to the same host after a connection was aborted. */
public void testOpenAfterAbort() throws Exception {
HttpParams mgrpar = defaultParams.copy();
ConnManagerParams.setMaxTotalConnections(mgrpar, 1);
SingleClientConnManager mgr = createSCCM(mgrpar, null);
final HttpHost target = getServerHttp();
final HttpRoute route = new HttpRoute(target, null, false);
ManagedClientConnection conn = mgr.getConnection(route, null);
assertTrue(conn instanceof AbstractClientConnAdapter);
((AbstractClientConnAdapter) conn).abortConnection();
conn = mgr.getConnection(route, null);
assertFalse("connection should have been closed", conn.isOpen());
conn.open(route, httpContext, defaultParams);
mgr.releaseConnection(conn, -1, null);
mgr.shutdown();
}
public void testAlreadyLeased() throws Exception {
HttpParams mgrpar = defaultParams.copy();
ConnManagerParams.setMaxTotalConnections(mgrpar, 1);
SingleClientConnManager mgr = createSCCM(mgrpar, null);
final HttpHost target = getServerHttp();
final HttpRoute route = new HttpRoute(target, null, false);
ManagedClientConnection conn = mgr.getConnection(route, null);
mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS);
mgr.getConnection(route, null);
try {
mgr.getConnection(route, null);
fail("IllegalStateException should have been thrown");
} catch (IllegalStateException ex) {
mgr.shutdown();
}
}
public static HttpClient newInstance() {
HttpParams params = new BasicHttpParams();
// 不自动处理重定向请求
params.setParameter(ClientPNames.HANDLE_REDIRECTS, false);
HttpConnectionParams.setStaleCheckingEnabled(params, true);
HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
HttpConnectionParams.setSoTimeout(params, SOCKET_OPERATION_TIMEOUT);
HttpConnectionParams.setSocketBufferSize(params, SOCKET_BUFFER_SIZE);
HttpConnectionParams.setTcpNoDelay(params, true);
ConnManagerParams.setMaxTotalConnections(params, 50);
ConnPerRouteBean connPerRoute = new ConnPerRouteBean();
connPerRoute.setDefaultMaxPerRoute(4);
ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
SSLSocketFactory socketFactory = SSLSocketFactory.getSocketFactory();
socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
schemeRegistry.register(new Scheme("https", socketFactory, 443));
ClientConnectionManager manager = new ThreadSafeClientConnManager(params, schemeRegistry);
return new DefaultHttpClient(manager, params);
}
protected void setupHttpClient() {
LOG.info("setting up http client");
BasicHttpParams httpParams = new BasicHttpParams();
HttpConnectionParams.setSoTimeout(httpParams, 70 * 1000);
HttpConnectionParams.setConnectionTimeout(httpParams, 10 * 1000);
ConnManagerParams.setMaxTotalConnections(httpParams, 200);
ConnPerRoute connPerRoute = new ConnPerRouteBean(400);
ConnManagerParams.setMaxConnectionsPerRoute(httpParams, connPerRoute);
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);
// ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams,
// HttpClientWithKeystore.getSchemeRegistry());
HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(httpParams, "utf-8");
mHttpClient = new HttpClientWithKeystore(cm, httpParams);
mHttpClient.getParams().setParameter("http.useragent", mConfig.getApplicationName());
mHttpClient.getParams().setBooleanParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, false);
mHttpClient.setReuseStrategy(new NoConnectionReuseStrategy());
}
public void init() {
if (inited) {
return;
}
// init thread pool
executor =
new NimTaskExecutor(
"NIM_HTTP_TASK_EXECUTOR", new NimTaskExecutor.Config(1, 3, 10 * 1000, true));
// init HttpClient supporting multi thread access
HttpParams httpParams = new BasicHttpParams();
// 设置最大连接数
ConnManagerParams.setMaxTotalConnections(httpParams, MAX_CONNECTIONS);
// 设置获取连接的最大等待时间
ConnManagerParams.setTimeout(httpParams, WAIT_TIMEOUT);
// 设置每个路由最大连接数
ConnManagerParams.setMaxConnectionsPerRoute(
httpParams, new ConnPerRouteBean(MAX_ROUTE_CONNECTIONS));
// 设置连接超时时间
HttpConnectionParams.setConnectionTimeout(httpParams, CONNECT_TIMEOUT);
// 设置读取超时时间
HttpConnectionParams.setSoTimeout(httpParams, READ_TIMEOUT);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
registry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
SSLSocketFactory.getSocketFactory().setHostnameVerifier(new AllowAllHostnameVerifier());
connManager = new ThreadSafeClientConnManager(httpParams, registry);
client = new DefaultHttpClient(connManager, httpParams);
uiHandler = new Handler(DemoCache.getContext().getMainLooper());
inited = true;
}
public Publisher() {
HttpParams params = new BasicHttpParams();
ConnManagerParams.setMaxTotalConnections(params, 200);
ConnPerRouteBean connPerRoute = new ConnPerRouteBean(20);
connPerRoute.setDefaultMaxPerRoute(50);
ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
httpClient = new DefaultHttpClient(cm, params);
httpClient.setKeepAliveStrategy(
new ConnectionKeepAliveStrategy() {
public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
HeaderElementIterator it =
new BasicHeaderElementIterator(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
while (it.hasNext()) {
HeaderElement he = it.nextElement();
String param = he.getName();
String value = he.getValue();
if (value != null && param.equalsIgnoreCase("timeout")) {
try {
return Long.parseLong(value) * 1000;
} catch (NumberFormatException ignore) {
}
}
}
// default keepalive is 60 seconds. This is higher than usual
// since the number of hubs it should be talking to should be
// small
return 30 * 1000;
}
});
}
private void initHttpClient() {
try {
// Create and initialize HTTP parameters
HttpParams params = new BasicHttpParams();
ConnManagerParams.setMaxTotalConnections(params, 10);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
// Create and initialize scheme registry
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
trustStore.load(null, null);
SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
schemeRegistry.register(new Scheme("https", sf, 443));
// Create an HttpClient with the ThreadSafeClientConnManager.
ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
mClient = new DefaultHttpClient(cm, params);
} catch (Exception e) {
mClient = new DefaultHttpClient();
}
}
private synchronized HttpClient initHttpClient(final BOSHClientConfig config) {
// Create and initialize HTTP parameters
HttpParams params = new BasicHttpParams();
ConnManagerParams.setMaxTotalConnections(params, 100);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setUseExpectContinue(params, false);
if (config != null && config.getProxyHost() != null && config.getProxyPort() != 0) {
HttpHost proxy = new HttpHost(config.getProxyHost(), config.getProxyPort());
params.setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
}
// Create and initialize scheme registry
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
SSLSocketFactory sslFactory = SSLSocketFactory.getSocketFactory();
sslFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
schemeRegistry.register(new Scheme("https", sslFactory, 443));
// Create an HttpClient with the ThreadSafeClientConnManager.
// This connection manager must be used if more than one thread will
// be using the HttpClient.
ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
return new DefaultHttpClient(cm, params);
}
/**
* Geeft een (Thread-safe) instantie van de httpclient
*
* @return instantie van httpclient
*/
public static HttpClient getClient() {
// Er mag maar ייn instantie van de thread-safe httpclient zijn, dus we maken er ook maar ייn
if (SyncClient.httpclient == null) {
// Bron van onderstaande:
// http://svn.apache.org/repos/asf/httpcomponents/httpclient/branches/4.0.x/httpclient/src/examples/org/apache/http/examples/client/ClientMultiThreadedExecution.java
// Create and initialize HTTP parameters
HttpParams params = new BasicHttpParams();
ConnManagerParams.setMaxTotalConnections(params, 100);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
// Create and initialize scheme registry
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
// Create an HttpClient with the ThreadSafeClientConnManager.
// This connection manager must be used if more than one thread will
// be using the HttpClient.
ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
SyncClient.httpclient = new DefaultHttpClient(cm, params);
}
return SyncClient.httpclient;
}
/** Tests releasing with time limits. */
public void testReleaseConnectionWithTimeLimits() throws Exception {
HttpParams mgrpar = defaultParams.copy();
ConnManagerParams.setMaxTotalConnections(mgrpar, 1);
SingleClientConnManager mgr = createSCCM(mgrpar, null);
final HttpHost target = getServerHttp();
final HttpRoute route = new HttpRoute(target, null, false);
final int rsplen = 8;
final String uri = "/random/" + rsplen;
HttpRequest request = new BasicHttpRequest("GET", uri, HttpVersion.HTTP_1_1);
ManagedClientConnection conn = mgr.getConnection(route, null);
conn.open(route, httpContext, defaultParams);
// a new context is created for each testcase, no need to reset
HttpResponse response =
Helper.execute(
request, conn, target, httpExecutor, httpProcessor, defaultParams, httpContext);
assertEquals(
"wrong status in first response",
HttpStatus.SC_OK,
response.getStatusLine().getStatusCode());
byte[] data = EntityUtils.toByteArray(response.getEntity());
assertEquals("wrong length of first response entity", rsplen, data.length);
// ignore data, but it must be read
// release connection without marking for re-use
// expect the next connection obtained to be closed
mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS);
conn = mgr.getConnection(route, null);
assertFalse("connection should have been closed", conn.isOpen());
// repeat the communication, no need to prepare the request again
conn.open(route, httpContext, defaultParams);
httpContext.setAttribute(ExecutionContext.HTTP_CONNECTION, conn);
response = httpExecutor.execute(request, conn, httpContext);
httpExecutor.postProcess(response, httpProcessor, httpContext);
assertEquals(
"wrong status in second response",
HttpStatus.SC_OK,
response.getStatusLine().getStatusCode());
data = EntityUtils.toByteArray(response.getEntity());
assertEquals("wrong length of second response entity", rsplen, data.length);
// ignore data, but it must be read
// release connection after marking it for re-use
// expect the next connection obtained to be open
conn.markReusable();
mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS);
conn = mgr.getConnection(route, null);
assertTrue("connection should have been open", conn.isOpen());
// repeat the communication, no need to prepare the request again
httpContext.setAttribute(ExecutionContext.HTTP_CONNECTION, conn);
response = httpExecutor.execute(request, conn, httpContext);
httpExecutor.postProcess(response, httpProcessor, httpContext);
assertEquals(
"wrong status in third response",
HttpStatus.SC_OK,
response.getStatusLine().getStatusCode());
data = EntityUtils.toByteArray(response.getEntity());
assertEquals("wrong length of third response entity", rsplen, data.length);
// ignore data, but it must be read
conn.markReusable();
mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS);
Thread.sleep(150);
conn = mgr.getConnection(route, null);
assertTrue("connection should have been closed", !conn.isOpen());
// repeat the communication, no need to prepare the request again
conn.open(route, httpContext, defaultParams);
httpContext.setAttribute(ExecutionContext.HTTP_CONNECTION, conn);
response = httpExecutor.execute(request, conn, httpContext);
httpExecutor.postProcess(response, httpProcessor, httpContext);
assertEquals(
"wrong status in third response",
HttpStatus.SC_OK,
response.getStatusLine().getStatusCode());
data = EntityUtils.toByteArray(response.getEntity());
assertEquals("wrong length of fourth response entity", rsplen, data.length);
// ignore data, but it must be read
mgr.shutdown();
}
/**
* Creates a handler with the specified input URL, max thread count, and message backlog support.
*
* @param inputUrl - the URL provided by Loggly for sending log messages to
* @param maxThreads - the max number of concurrent background threads that are allowed to send
* data to Loggly
* @param backlog - the max number of log messages that can be queued up (anything beyond will be
* thrown away)
*/
public LogglyHandler(String inputUrl, int maxThreads, int backlog) {
this.inputUrl = inputUrl;
pool =
new ThreadPoolExecutor(
maxThreads,
maxThreads,
60L,
TimeUnit.SECONDS,
new LinkedBlockingDeque<Runnable>(backlog),
new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, "Loggly Thread");
thread.setDaemon(true);
return thread;
}
},
new ThreadPoolExecutor.DiscardOldestPolicy());
pool.allowCoreThreadTimeOut(true);
retryQueue = new LinkedBlockingQueue<LogglySample>(backlog);
Thread retryThread =
new Thread(
new Runnable() {
@Override
public void run() {
while (allowRetry) {
// drain the retry requests
LogglySample sample = null;
while ((sample = retryQueue.poll()) != null) {
if (sample.retryCount > 10) {
// todo: capture statistics about the failure (exception and/or status code)
// and then report on it in some sort of thoughtful way to standard err
} else {
pool.submit(sample);
}
}
// retry every 10 seconds
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
System.err.println("Retry sleep was interrupted, giving up on retry thread");
return;
}
}
}
},
"Loggly Retry Thread");
retryThread.setDaemon(true);
retryThread.start();
HttpParams params = new BasicHttpParams();
ConnManagerParams.setMaxTotalConnections(params, maxThreads);
ConnPerRouteBean connPerRoute = new ConnPerRouteBean(maxThreads);
ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);
// set 15 second timeouts, since Loggly should return quickly
params.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, 15000);
params.setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 15000);
SchemeRegistry registry = new SchemeRegistry();
try {
registry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
} catch (Exception e) {
throw new RuntimeException("Could not register SSL socket factor for Loggly", e);
}
ThreadSafeClientConnManager connManager = new ThreadSafeClientConnManager(params, registry);
httpClient = new DefaultHttpClient(connManager, params);
// because the threads a daemon threads, we want to give them a chance
// to finish up before we totally shut down
Runtime.getRuntime()
.addShutdownHook(
new Thread(
new Runnable() {
@Override
public void run() {
close();
}
}));
}
private static void httpInit() {
try {
HttpParams params = new BasicHttpParams();
params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, Integer.valueOf(30000));
params.setParameter(CoreConnectionPNames.SO_TIMEOUT, Integer.valueOf(50000)); // 设置20秒socket超时
params.setLongParameter(ConnManagerPNames.TIMEOUT, 30000);
params.setBooleanParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, false);
params.setParameter(
CoreConnectionPNames.SOCKET_BUFFER_SIZE,
Integer.valueOf(8192 * 3)); // 默认是8192 byte socket buffers
ConnManagerParams.setMaxTotalConnections(params, 200);
ConnPerRouteBean connPerRoute = new ConnPerRouteBean(20);
HttpHost localhost = new HttpHost(INFO.HOST_IP, INFO.HOST_PORT);
connPerRoute.setMaxForRoute(new HttpRoute(localhost), 50);
ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);
////////////////////
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
trustStore.load(null, null);
SSLSocketFactory sf = new SSLSocketFactoryEx(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
////////////////////////////////////
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", sf, 443));
ClientConnectionManager clientManager =
new ThreadSafeClientConnManager(params, schemeRegistry);
defaultHttpClient = new DefaultHttpClient(clientManager, params);
defaultHttpClient.setKeepAliveStrategy(
new DefaultConnectionKeepAliveStrategy() {
public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
long keepAlive = super.getKeepAliveDuration(response, context);
if (keepAlive == -1) {
keepAlive = 5000;
}
return keepAlive;
}
});
defaultHttpClient.addRequestInterceptor(preemptiveAuth, 0);
defaultHttpClient.setHttpRequestRetryHandler(
new HttpRequestRetryHandler() {
public boolean retryRequest(
IOException exception, int executionCount, HttpContext context) {
// INFO.Log("NETWORKTEST>><<",exception.toString()+"##"+executionCount);
if (executionCount >= 2) {
return false;
}
if (exception instanceof NoHttpResponseException) {
// 服务停掉则重新尝试连接
// INFO.Log("NETWORKTEST>><<","port:"+INFO.HOST_PORT);
return true;
}
if (exception instanceof UnknownHostException) {
INFO.HOST_PORT = 8080;
// INFO.Log("NETWORKTEST>><<","port:"+INFO.HOST_PORT);
return true;
}
if (exception instanceof UnknownServiceException) {
INFO.HOST_PORT = 8080;
// INFO.Log("NETWORKTEST>><<","Service:"+INFO.HOST_PORT);
return true;
}
if (exception instanceof SocketException) {
// INFO.Log("NETWORKTEST>><<","SocketException");
return true;
}
if (exception instanceof SSLHandshakeException) {
return false;
}
HttpRequest request =
(HttpRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST);
boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
if (idempotent) {
return true;
}
return false;
}
});
} catch (Exception ex) {
ex.printStackTrace();
}
// ssl
// FileInputStream instream = new FileInputStream(new File("my.keystore"));
// InputStream instream = appContext.getResources().openRawResource(R.drawable.adcd); //读证书
// try {
// KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
// //KeyStore.getDefaultType() android为 BKS
// trustStore.load(instream, "nopassword".toCharArray());
// SSLSocketFactory socketFactory = new SSLSocketFactory(trustStore);
// Scheme sch = new Scheme("https", socketFactory, 443); //443端口
// defaultHttpClient.getConnectionManager().getSchemeRegistry().register(sch);
// }catch(Exception e){
// e.printStackTrace();
// }finally {
// try {
// instream.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
}
/**
* Creates a new fetcher for fetching HTTP objects. Not really suitable for production use. Use of
* an HTTP proxy for security is also necessary for production deployment.
*
* @param maxObjSize Maximum size, in bytes, of the object we will fetch, 0 if no limit..
* @param connectionTimeoutMs timeout, in milliseconds, for connecting to hosts.
* @param readTimeoutMs timeout, in millseconds, for unresponsive connections
* @param basicHttpFetcherProxy The http proxy to use.
*/
public BasicHttpFetcher(
int maxObjSize, int connectionTimeoutMs, int readTimeoutMs, String basicHttpFetcherProxy) {
// Create and initialize HTTP parameters
setMaxObjectSizeBytes(maxObjSize);
setSlowResponseWarning(DEFAULT_SLOW_RESPONSE_WARNING);
HttpParams params = new BasicHttpParams();
ConnManagerParams.setTimeout(params, connectionTimeoutMs);
// These are probably overkill for most sites.
ConnManagerParams.setMaxTotalConnections(params, 1152);
ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(256));
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setUserAgent(params, "Apache Shindig");
HttpProtocolParams.setContentCharset(params, "UTF-8");
HttpConnectionParams.setConnectionTimeout(params, connectionTimeoutMs);
HttpConnectionParams.setSoTimeout(params, readTimeoutMs);
HttpConnectionParams.setStaleCheckingEnabled(params, true);
HttpClientParams.setRedirecting(params, true);
HttpClientParams.setAuthenticating(params, false);
// Create and initialize scheme registry
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
// UCSF. Change to allow self signed registered certs
/**
* try { SSLContext sslContext = SSLContext.getInstance("SSL"); // set up a TrustManager that
* trusts everything sslContext.init(null, new TrustManager[] { new X509TrustManager() { public
* X509Certificate[] getAcceptedIssuers() { System.out.println("getAcceptedIssuers
* ============="); return null; }
*
* <p>public void checkClientTrusted(X509Certificate[] certs, String authType) {
* System.out.println("checkClientTrusted ============="); }
*
* <p>public void checkServerTrusted(X509Certificate[] certs, String authType) {
* System.out.println("checkServerTrusted ============="); } } }, new SecureRandom());
* SSLSocketFactory sf = new SSLSocketFactory(sslContext);
* sf.setHostnameVerifier((X509HostnameVerifier)org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
* schemeRegistry.register(new Scheme("https", sf, 443)); } catch (Exception e) { throw new
* RuntimeException(e); }
*/
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
// end UCSF
ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
DefaultHttpClient client = new DefaultHttpClient(cm, params);
// Set proxy if set via guice.
if (!StringUtils.isEmpty(basicHttpFetcherProxy)) {
String[] splits = basicHttpFetcherProxy.split(":");
ConnRouteParams.setDefaultProxy(
client.getParams(), new HttpHost(splits[0], Integer.parseInt(splits[1]), "http"));
}
// try resending the request once
client.setHttpRequestRetryHandler(new DefaultHttpRequestRetryHandler(1, true));
// Add hooks for gzip/deflate
client.addRequestInterceptor(
new HttpRequestInterceptor() {
public void process(final org.apache.http.HttpRequest request, final HttpContext context)
throws HttpException, IOException {
if (!request.containsHeader("Accept-Encoding")) {
request.addHeader("Accept-Encoding", "gzip, deflate");
}
}
});
client.addResponseInterceptor(
new HttpResponseInterceptor() {
public void process(
final org.apache.http.HttpResponse response, final HttpContext context)
throws HttpException, IOException {
HttpEntity entity = response.getEntity();
if (entity != null) {
Header ceheader = entity.getContentEncoding();
if (ceheader != null) {
for (HeaderElement codec : ceheader.getElements()) {
String codecname = codec.getName();
if ("gzip".equalsIgnoreCase(codecname)) {
response.setEntity(new GzipDecompressingEntity(response.getEntity()));
return;
} else if ("deflate".equals(codecname)) {
response.setEntity(new DeflateDecompressingEntity(response.getEntity()));
return;
}
}
}
}
}
});
client.setHttpRequestRetryHandler(new DefaultHttpRequestRetryHandler());
// Disable automatic storage and sending of cookies (see SHINDIG-1382)
client.removeRequestInterceptorByClass(RequestAddCookies.class);
client.removeResponseInterceptorByClass(ResponseProcessCookies.class);
// Use Java's built-in proxy logic in case no proxy set via guice.
if (StringUtils.isEmpty(basicHttpFetcherProxy)) {
ProxySelectorRoutePlanner routePlanner =
new ProxySelectorRoutePlanner(
client.getConnectionManager().getSchemeRegistry(), ProxySelector.getDefault());
client.setRoutePlanner(routePlanner);
}
FETCHER = client;
}
/**
* {@inheritDoc} <br>
* <br>
* The default implementation does all of this and more, including using a connection pool and
* killing connections after a timeout to use less battery power on mobile devices. It's unlikely
* that you'll want to change this behavior.
*/
@Override
public synchronized HttpClient getHttpClient() {
if (client == null) {
// Set up default connection params. There are two routes to
// Dropbox - api server and content server.
HttpParams connParams = new BasicHttpParams();
ConnManagerParams.setMaxConnectionsPerRoute(
connParams,
new ConnPerRoute() {
@Override
public int getMaxForRoute(HttpRoute route) {
return 10;
}
});
ConnManagerParams.setMaxTotalConnections(connParams, 20);
// Set up scheme registry.
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
DBClientConnManager cm = new DBClientConnManager(connParams, schemeRegistry);
try {
SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(
null,
new TrustManager[] {
new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
System.out.println("getAcceptedIssuers =============");
return null;
}
public void checkClientTrusted(X509Certificate[] certs, String authType) {
System.out.println("checkClientTrusted =============");
}
public void checkServerTrusted(X509Certificate[] certs, String authType) {
System.out.println("checkServerTrusted =============");
}
}
},
new SecureRandom());
SSLSocketFactory sf = new SSLSocketFactory(sslContext);
Scheme httpsScheme = new Scheme("https", 443, sf);
schemeRegistry.register(httpsScheme);
} catch (Exception e) {
e.printStackTrace();
}
schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
// Set up client params.
HttpParams httpParams = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(httpParams, DEFAULT_TIMEOUT_MILLIS);
HttpConnectionParams.setSoTimeout(httpParams, DEFAULT_TIMEOUT_MILLIS);
HttpConnectionParams.setSocketBufferSize(httpParams, 8192);
HttpProtocolParams.setUserAgent(
httpParams, "OfficialDropboxJavaSDK/" + DropboxAPI.SDK_VERSION);
DefaultHttpClient c =
new DefaultHttpClient(cm, httpParams) {
@Override
protected ConnectionKeepAliveStrategy createConnectionKeepAliveStrategy() {
return new DBKeepAliveStrategy();
}
@Override
protected ConnectionReuseStrategy createConnectionReuseStrategy() {
return new DBConnectionReuseStrategy();
}
};
c.addRequestInterceptor(
new HttpRequestInterceptor() {
@Override
public void process(final HttpRequest request, final HttpContext context)
throws HttpException, IOException {
if (!request.containsHeader("Accept-Encoding")) {
request.addHeader("Accept-Encoding", "gzip");
}
}
});
c.addResponseInterceptor(
new HttpResponseInterceptor() {
@Override
public void process(final HttpResponse response, final HttpContext context)
throws HttpException, IOException {
HttpEntity entity = response.getEntity();
if (entity != null) {
Header ceheader = entity.getContentEncoding();
if (ceheader != null) {
HeaderElement[] codecs = ceheader.getElements();
for (HeaderElement codec : codecs) {
if (codec.getName().equalsIgnoreCase("gzip")) {
response.setEntity(new GzipDecompressingEntity(response.getEntity()));
return;
}
}
}
}
}
});
client = c;
}
return client;
}
/**
* Creates a new AsyncHttpClient and set timeout.
*
* @param timeout 超时时间
*/
public AsyncHttpClient(int timeout) {
this.socketTimeout = timeout;
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.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();
SSLSocketFactory sf = null;
try {
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
trustStore.load(null, null);
sf = new MySSLSocketFactory(trustStore);
} catch (Exception e) {
e.printStackTrace();
}
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", sf, 443));
ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry);
httpContext = new SyncBasicHttpContext(new BasicHttpContext());
httpClient = new DefaultHttpClient(cm, httpParams);
httpClient.addRequestInterceptor(
new HttpRequestInterceptor() {
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.addResponseInterceptor(
new HttpResponseInterceptor() {
public void process(HttpResponse response, HttpContext context) {
final HttpEntity entity = response.getEntity();
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));
/* HttpHost proxy = NetworkUtils.getHttpHostProxy();
if (proxy!=null) { // set proxy
httpClient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
}
*/ threadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool();
requestMap = new WeakHashMap<Context, List<WeakReference<Future<?>>>>();
clientHeaderMap = new HashMap<String, String>();
}
public AsyncHttpClient() {
HttpParams basicHttpParams = new BasicHttpParams();
ConnManagerParams.setTimeout(basicHttpParams, (long) socketTimeout);
ConnManagerParams.setMaxConnectionsPerRoute(
basicHttpParams, new ConnPerRouteBean(maxConnections));
ConnManagerParams.setMaxTotalConnections(basicHttpParams, DEFAULT_MAX_CONNECTIONS);
HttpConnectionParams.setSoTimeout(basicHttpParams, socketTimeout);
HttpConnectionParams.setConnectionTimeout(basicHttpParams, socketTimeout);
HttpConnectionParams.setTcpNoDelay(basicHttpParams, true);
HttpConnectionParams.setSocketBufferSize(basicHttpParams, DEFAULT_SOCKET_BUFFER_SIZE);
HttpProtocolParams.setVersion(basicHttpParams, HttpVersion.HTTP_1_1);
HttpProtocolParams.setUserAgent(
basicHttpParams,
String.format(
"android-async-http/%s (http://loopj.com/android-async-http)", new Object[] {VERSION}));
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(
new Scheme(MediaService.DEFAULT_MEDIA_DELIVERY, PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
ClientConnectionManager threadSafeClientConnManager =
new ThreadSafeClientConnManager(basicHttpParams, schemeRegistry);
this.httpContext = new SyncBasicHttpContext(new BasicHttpContext());
this.httpClient = new DefaultHttpClient(threadSafeClientConnManager, basicHttpParams);
this.httpClient.addRequestInterceptor(
new HttpRequestInterceptor() {
public void process(HttpRequest httpRequest, HttpContext httpContext) {
if (!httpRequest.containsHeader(HEADER_ACCEPT_ENCODING)) {
httpRequest.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
}
Iterator it = AsyncHttpClient.this.clientHeaderMap.keySet().iterator();
while (it.hasNext()) {
String str = (String) it.next();
httpRequest.addHeader(str, (String) AsyncHttpClient.this.clientHeaderMap.get(str));
}
}
});
this.httpClient.addResponseInterceptor(
new HttpResponseInterceptor() {
public void process(HttpResponse httpResponse, HttpContext httpContext) {
HttpEntity entity = httpResponse.getEntity();
if (entity != null) {
Header contentEncoding = entity.getContentEncoding();
if (contentEncoding != null) {
HeaderElement[] elements = contentEncoding.getElements();
int length = elements.length;
int i = 0;
while (i < length) {
if (elements[i].getName().equalsIgnoreCase(ENCODING_GZIP)) {
httpResponse.setEntity(new InflatingEntity(httpResponse.getEntity()));
return;
} else {
i++;
}
}
}
}
}
});
this.httpClient.setHttpRequestRetryHandler(new RetryHandler(5));
this.threadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool();
this.requestMap = new WeakHashMap();
this.clientHeaderMap = new HashMap();
}
