Best way to use HttpClient in Android

Many Android applications access the Internet resources over HTTP (and my projects are no exception). There are 2 common ways to do that: use Apache HttpClient 4.x (which is included in Android) or use HttpURLConnection (from Java). Google stated in a September 29, 2011 blog post that they prefer you use HttpURLConnection, but many apps and a large number of Java libraries already use HttpClient and won’t be changing soon (if ever). So HttpClient is here to stay.

With that in mind, the performance and footprint of HttpClient can vary widely based on how its set up. Here are my recommendations:

  • Always use one HttpClient instance for your entire application. HttpClient is not free to instantiate – each additional instance takes time to create and uses more memory. However, more importantly, using one instance allows HttpClient to pool and reuse connections along with other optimizations that can make big differences in how your application performs.
  • Use a thread safe connection manager. If you’re using one global HttpClient, it will be accessed by multiple threads concurrently – so if you don’t use a thread safe connection manager, Bad Things will happen.
  • Use Android’s and if they’re available. Using these instead of the base HttpClient SSLSocketFactorywill reduce round trips when connecting to the same https site multiple times, making your application feel faster.
  • Set the user agent to something useful. That way, the server’s logs will be far more useful, which may save you (or someone else) a lot of time later if (when) a problem occurs.

With all that said, here’s how I get my global HttpClient instance. This code should work on all Android versions (it should even work all the way back to 1.0 – if anyone cares). I use Google Guice‘s Provider interface and injection to get the application, but you can easily adopt this to a form that doesn’t use Guice.

import java.lang.reflect.Method;
import java.util.Locale;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.ClientConnectionManager;
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.scheme.SocketFactory;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.AbstractHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import android.content.Context;
import android.os.Build;
import android.util.Log;
public class HttpClientProvider implements Provider {
	Application application;
    // Wait this many milliseconds max for the TCP connection to be established
    private static final int CONNECTION_TIMEOUT = 60 * 1000;
    // Wait this many milliseconds max for the server to send us data once the connection has been established
    private static final int SO_TIMEOUT = 5 * 60 * 1000;
    private String getUserAgent(String defaultHttpClientUserAgent){
    	String versionName;
		try {
			versionName = application.getPackageManager().getPackageInfo(
					application.getPackageName(), 0).versionName;
		} catch (NameNotFoundException e) {
			throw new RuntimeException(e);
		StringBuilder ret = new StringBuilder();
		ret.append(" (");
		ret.append("Linux; U; Android ");
		ret.append("; ");
		ret.append("; ");
			ret.append(" ");
		return ret.toString();
	public HttpClient get() {
		AbstractHttpClient client = new DefaultHttpClient(){
		    protected ClientConnectionManager createClientConnectionManager() {
		        SchemeRegistry registry = new SchemeRegistry();
		                new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
		                new Scheme("https", getHttpsSocketFactory(), 443));
		        HttpParams params = getParams();
		        HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
		        HttpConnectionParams.setSoTimeout(params, SO_TIMEOUT);
		        HttpProtocolParams.setUserAgent(params, getUserAgent(HttpProtocolParams.getUserAgent(params)));
		        return new ThreadSafeClientConnManager(params, registry);
		    /** Gets an HTTPS socket factory with SSL Session Caching if such support is available, otherwise falls back to a non-caching factory
		     * @return
		    protected SocketFactory getHttpsSocketFactory(){
				try {
					Class sslSessionCacheClass = Class.forName("");
			    	Object sslSessionCache = sslSessionCacheClass.getConstructor(Context.class).newInstance(application);
			    	Method getHttpSocketFactory = Class.forName("").getMethod("getHttpSocketFactory", new Class[]{int.class, sslSessionCacheClass});
			    	return (SocketFactory) getHttpSocketFactory.invoke(null, CONNECTION_TIMEOUT, sslSessionCache);
				}catch(Exception e){
					Log.e("HttpClientProvider", "Unable to use to get a SSL session caching socket factory, falling back to a non-caching socket factory",e);
					return SSLSocketFactory.getSocketFactory();
        return client;

I use this approach in my CallerID app (source) and an upcoming app (that I cannot yet talk about). I’ve also submitted patches (which have been accepted) to reddit is fun, so it will use this approach in its next version.

CC BY-SA 4.0 Best way to use HttpClient in Android by Craig Andrews is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.

7 thoughts on “Best way to use HttpClient in Android

  1. Hi,

    Getting the following error when the httpclient is being called on the second attempt

    Connection pool shut down

    I’ve created the the following module


    And I then inject this into my asycntask

    private HttpClient iHttpClient;

    Any ideas?


  2. Thanks for posting! Reusing an HttpClient as you demonstrated above appears to have made a significant difference in our application’s performance. Now I just need to figure out how to add caching (I’m attempting to use apache’s httpclient-cache as you suggested in a related post).

    a) If you don’t know how to make injection work properly (as I don’t yet), you get NullPointerExceptions. Instead – I changed application to be a Context and made it static and then set it to Context.getApplicationContext() when I had a reference to a context object.
    b) I didn’t see the same code or similar code to what you have above in either your Caller ID application or in reddit is fun (I was at least hoping to see a complete working example of injection).

  3. @Chuck Doucette
    Since HttpClient use in Android is discouraged, I made the HttpResponseCache library (see my other post on that topic) which doesn’t use HttpClient. Once I did that, I changed my CallerID application to use HttpUrlConnection and HttpResponseCache instead of HttpClient and HttpClient-Cache.

    However, all the CallerID history is available. Here’s a link to the tree just before I changed the application to no longer use HttpClient:

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.