HTTP Client Configuration

/**
 * Configures and creates HTTP connections. Most applications can use a single
 * OkHttpClient for all of their HTTP requests - benefiting from a shared
 * response cache, thread pool, connection re-use, etc.
 */
public class OkHttpClient implements Cloneable {
    public OkHttpClient();
    public Call newCall(Request request);
    public OkHttpClient clone();
}

// Create default client
OkHttpClient client = new OkHttpClient();

// Create and execute request
Request request = new Request.Builder()
    .url("https://api.example.com/data")
    .build();

Response response = client.newCall(request).execute();

/**
 * Sets the default connect timeout for new connections. A value of 0 means no timeout.
 * @param timeout timeout duration
 * @param unit time unit for timeout
 */
public void setConnectTimeout(long timeout, TimeUnit unit);

/** Default connect timeout (in milliseconds). */
public int getConnectTimeout();

/**
 * Sets the default read timeout for new connections. A value of 0 means no timeout.
 * @param timeout timeout duration  
 * @param unit time unit for timeout
 */
public void setReadTimeout(long timeout, TimeUnit unit);

/** Default read timeout (in milliseconds). */
public int getReadTimeout();

/**
 * Sets the default write timeout for new connections. A value of 0 means no timeout.
 * @param timeout timeout duration
 * @param unit time unit for timeout  
 */
public void setWriteTimeout(long timeout, TimeUnit unit);

/** Default write timeout (in milliseconds). */
public int getWriteTimeout();

OkHttpClient client = new OkHttpClient();
client.setConnectTimeout(30, TimeUnit.SECONDS);
client.setReadTimeout(60, TimeUnit.SECONDS);
client.setWriteTimeout(60, TimeUnit.SECONDS);

/**
 * Sets the HTTP proxy that will be used by connections created by this
 * client. This takes precedence over ProxySelector.
 * @param proxy the proxy to use, or Proxy.NO_PROXY to disable proxy use
 * @return this client for method chaining
 */
public OkHttpClient setProxy(Proxy proxy);

public Proxy getProxy();

/**
 * Sets the proxy selection policy to be used if no explicit proxy is specified.
 * @param proxySelector the proxy selector to use
 * @return this client for method chaining
 */
public OkHttpClient setProxySelector(ProxySelector proxySelector);

public ProxySelector getProxySelector();

// Set explicit proxy
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.example.com", 8080));
client.setProxy(proxy);

// Disable proxy
client.setProxy(Proxy.NO_PROXY);

// Use system proxy selector
client.setProxySelector(ProxySelector.getDefault());

/**
 * Sets the cookie handler to be used to read outgoing cookies and write
 * incoming cookies.
 * @param cookieHandler the cookie handler to use
 * @return this client for method chaining
 */
public OkHttpClient setCookieHandler(CookieHandler cookieHandler);

public CookieHandler getCookieHandler();

// Use system cookie manager
CookieManager cookieManager = new CookieManager();
cookieManager.setCookiePolicy(CookiePolicy.ACCEPT_ALL);
client.setCookieHandler(cookieManager);

/**
 * Sets the response cache to be used to read and write cached responses.
 * @param cache the cache to use
 * @return this client for method chaining
 */
public OkHttpClient setCache(Cache cache);

public Cache getCache();

// Create cache in app's cache directory
File cacheDir = new File(context.getCacheDir(), "http-cache");
Cache cache = new Cache(cacheDir, 10 * 1024 * 1024); // 10 MB
client.setCache(cache);

/**
 * Sets the DNS service used to lookup IP addresses for hostnames.
 * @param dns the DNS service to use
 * @return this client for method chaining
 */
public OkHttpClient setDns(Dns dns);

public Dns getDns();

/**
 * Sets the socket factory used to create connections. OkHttp only uses
 * the parameterless createSocket() method to create unconnected sockets.
 * @param socketFactory the socket factory to use
 * @return this client for method chaining
 */
public OkHttpClient setSocketFactory(SocketFactory socketFactory);

public SocketFactory getSocketFactory();

/**
 * Sets the socket factory used to secure HTTPS connections.
 * @param sslSocketFactory the SSL socket factory to use
 * @return this client for method chaining
 */
public OkHttpClient setSslSocketFactory(SSLSocketFactory sslSocketFactory);

public SSLSocketFactory getSslSocketFactory();

/**
 * Sets the verifier used to confirm that response certificates apply to
 * requested hostnames for HTTPS connections.
 * @param hostnameVerifier the hostname verifier to use
 * @return this client for method chaining
 */
public OkHttpClient setHostnameVerifier(HostnameVerifier hostnameVerifier);

public HostnameVerifier getHostnameVerifier();

/**
 * Sets the certificate pinner that constrains which certificates are trusted.
 * @param certificatePinner the certificate pinner to use
 * @return this client for method chaining
 */
public OkHttpClient setCertificatePinner(CertificatePinner certificatePinner);

public CertificatePinner getCertificatePinner();

/**
 * Sets the authenticator used to respond to challenges from the remote web
 * server or proxy server.
 * @param authenticator the authenticator to use
 * @return this client for method chaining
 */
public OkHttpClient setAuthenticator(Authenticator authenticator);

public Authenticator getAuthenticator();

/**
 * Sets the connection pool used to recycle HTTP and HTTPS connections.
 * @param connectionPool the connection pool to use
 * @return this client for method chaining
 */
public OkHttpClient setConnectionPool(ConnectionPool connectionPool);

public ConnectionPool getConnectionPool();

/**
 * Configure this client to follow redirects from HTTPS to HTTP and from HTTP
 * to HTTPS.
 * @param followProtocolRedirects whether to follow protocol redirects
 * @return this client for method chaining
 */
public OkHttpClient setFollowSslRedirects(boolean followProtocolRedirects);

public boolean getFollowSslRedirects();

/**
 * Configure this client to follow redirects.
 * @param followRedirects whether to follow redirects
 */
public void setFollowRedirects(boolean followRedirects);

public boolean getFollowRedirects();

/**
 * Configure this client to retry or not when a connectivity problem is encountered.
 * @param retryOnConnectionFailure whether to retry on connection failure
 */
public void setRetryOnConnectionFailure(boolean retryOnConnectionFailure);

public boolean getRetryOnConnectionFailure();

/**
 * Configure the protocols used by this client to communicate with remote
 * servers. By default this client will prefer the most efficient transport
 * available, falling back to more ubiquitous protocols.
 * @param protocols the protocols to use, in order of preference
 * @return this client for method chaining
 */
public OkHttpClient setProtocols(List<Protocol> protocols);

public List<Protocol> getProtocols();

/**
 * Sets the connection specifications for socket connections.
 * @param connectionSpecs the connection specifications to use
 * @return this client for method chaining
 */
public OkHttpClient setConnectionSpecs(List<ConnectionSpec> connectionSpecs);

public List<ConnectionSpec> getConnectionSpecs();

/**
 * Returns a modifiable list of interceptors that observe the full span of each call.
 * @return modifiable list of application interceptors
 */
public List<Interceptor> interceptors();

/**
 * Returns a modifiable list of interceptors that observe a single network request and response.
 * @return modifiable list of network interceptors
 */
public List<Interceptor> networkInterceptors();

// Add logging interceptor
client.interceptors().add(new HttpLoggingInterceptor());

// Add authentication interceptor
client.interceptors().add(new Interceptor() {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request original = chain.request();
        Request.Builder requestBuilder = original.newBuilder()
            .header("Authorization", "Bearer " + getAccessToken());
        Request request = requestBuilder.build();
        return chain.proceed(request);
    }
});

/**
 * Sets the dispatcher used to set policy and execute asynchronous requests.
 * @param dispatcher the dispatcher to use
 * @return this client for method chaining
 */
public OkHttpClient setDispatcher(Dispatcher dispatcher);

public Dispatcher getDispatcher();

/**
 * Prepares the request to be executed at some point in the future.
 * @param request the request to prepare
 * @return a Call ready for execution
 */
public Call newCall(Request request);

/**
 * Cancels all scheduled or in-flight calls tagged with tag. Requests
 * that are already complete cannot be canceled.
 * @param tag the tag to match for cancellation
 * @return this client for method chaining
 */
public OkHttpClient cancel(Object tag);

/**
 * Returns a shallow copy of this OkHttpClient.
 * @return a new OkHttpClient with the same configuration
 */
@Override 
public OkHttpClient clone();

// Create base client
OkHttpClient baseClient = new OkHttpClient();
baseClient.setConnectTimeout(30, TimeUnit.SECONDS);

// Create specialized client for API calls
OkHttpClient apiClient = baseClient.clone();
apiClient.interceptors().add(new ApiKeyInterceptor());

// Create specialized client for file uploads
OkHttpClient uploadClient = baseClient.clone();
uploadClient.setReadTimeout(300, TimeUnit.SECONDS);
uploadClient.setWriteTimeout(300, TimeUnit.SECONDS);