Changes associated with an OkHttp upgrade (50a01d89) · Commits · e / os / android_frameworks_base

core/java/android/net/Network.java

+19 −18

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@

		package android.net;

		import android.net.NetworkUtils;
		import android.os.Parcelable;
		import android.os.Parcel;
		import android.system.ErrnoException;
		@@ -31,15 +30,14 @@ import java.net.SocketException;
		import java.net.UnknownHostException;
		import java.net.URL;
		import java.net.URLConnection;
		import java.net.URLStreamHandler;
		import java.util.concurrent.atomic.AtomicReference;
		import javax.net.SocketFactory;

		import com.android.okhttp.ConnectionPool;
		import com.android.okhttp.HostResolver;
		import com.android.okhttp.HttpHandler;
		import com.android.okhttp.HttpsHandler;
		import com.android.okhttp.OkHttpClient;
		import com.android.okhttp.OkUrlFactory;
		import com.android.okhttp.internal.Internal;

		/**
		* Identifies a {@code Network}. This is supplied to applications via
		@@ -60,10 +58,10 @@ public class Network implements Parcelable {
		// Objects used to perform per-network operations such as getSocketFactory
		// and openConnection, and a lock to protect access to them.
		private volatile NetworkBoundSocketFactory mNetworkBoundSocketFactory = null;
		// mLock should be used to control write access to mConnectionPool and mHostResolver.
		// mLock should be used to control write access to mConnectionPool and mNetwork.
		// maybeInitHttpClient() must be called prior to reading either variable.
		private volatile ConnectionPool mConnectionPool = null;
		private volatile HostResolver mHostResolver = null;
		private volatile com.android.okhttp.internal.Network mNetwork = null;
		private Object mLock = new Object();

		// Default connection pool values. These are evaluated at startup, just
		@@ -217,10 +215,10 @@ public class Network implements Parcelable {
		// out) ConnectionPools.
		private void maybeInitHttpClient() {
		synchronized (mLock) {
		if (mHostResolver == null) {
		mHostResolver = new HostResolver() {
		if (mNetwork == null) {
		mNetwork = new com.android.okhttp.internal.Network() {
		@Override
		public InetAddress[] getAllByName(String host) throws UnknownHostException {
		public InetAddress[] resolveInetAddresses(String host) throws UnknownHostException {
		return Network.this.getAllByName(host);
		}
		};
		@@ -244,23 +242,26 @@ public class Network implements Parcelable {
		public URLConnection openConnection(URL url) throws IOException {
		maybeInitHttpClient();
		String protocol = url.getProtocol();
		OkHttpClient client;
		// TODO: HttpHandler creates OkHttpClients that share the default ResponseCache.
		OkUrlFactory okUrlFactory;
		// TODO: HttpHandler creates OkUrlFactory instances that share the default ResponseCache.
		// Could this cause unexpected behavior?
		// TODO: Should the network's proxy be specified?
		if (protocol.equals("http")) {
		client = HttpHandler.createHttpOkHttpClient(null /* proxy */);
		okUrlFactory = HttpHandler.createHttpOkUrlFactory(null /* proxy */);
		} else if (protocol.equals("https")) {
		client = HttpsHandler.createHttpsOkHttpClient(null /* proxy */);
		okUrlFactory = HttpsHandler.createHttpsOkUrlFactory(null /* proxy */);
		} else {
		// OkHttpClient only supports HTTP and HTTPS and returns a null URLStreamHandler if
		// OkHttp only supports HTTP and HTTPS and returns a null URLStreamHandler if
		// passed another protocol.
		throw new MalformedURLException("Invalid URL or unrecognized protocol " + protocol);
		}
		return client.setSocketFactory(getSocketFactory())
		.setHostResolver(mHostResolver)
		.setConnectionPool(mConnectionPool)
		.open(url);
		OkHttpClient client = okUrlFactory.client();
		client.setSocketFactory(getSocketFactory()).setConnectionPool(mConnectionPool);

		// Use internal APIs to change the Network.
		Internal.instance.setNetwork(client, mNetwork);

		return okUrlFactory.open(url);
		}

		/**

core/java/android/net/http/HttpResponseCache.java

+41 −32

Original line number	Diff line number	Diff line
		@@ -16,20 +16,20 @@

		package android.net.http;

		import android.content.Context;
		import com.android.okhttp.Cache;
		import com.android.okhttp.AndroidShimResponseCache;
		import com.android.okhttp.OkCacheContainer;

		import java.io.Closeable;
		import java.io.File;
		import java.io.IOException;
		import java.net.CacheRequest;
		import java.net.CacheResponse;
		import java.net.HttpURLConnection;
		import java.net.ResponseCache;
		import java.net.URI;
		import java.net.URLConnection;
		import java.util.List;
		import java.util.Map;
		import javax.net.ssl.HttpsURLConnection;
		import org.apache.http.impl.client.DefaultHttpClient;

		/**
		* Caches HTTP and HTTPS responses to the filesystem so they may be reused,
		@@ -40,7 +40,7 @@ import org.apache.http.impl.client.DefaultHttpClient;
		* <h3>Installing an HTTP response cache</h3>
		* Enable caching of all of your application's HTTP requests by installing the
		* cache at application startup. For example, this code installs a 10 MiB cache
		* in the {@link Context#getCacheDir() application-specific cache directory} of
		* in the {@link android.content.Context#getCacheDir() application-specific cache directory} of
		* the filesystem}: <pre> {@code
		* protected void onCreate(Bundle savedInstanceState) {
		* ...
		@@ -147,11 +147,11 @@ import org.apache.http.impl.client.DefaultHttpClient;
		* } catch (Exception httpResponseCacheNotAvailable) {
		* }}</pre>
		*/
		public final class HttpResponseCache extends ResponseCache implements Closeable {
		public final class HttpResponseCache extends ResponseCache implements Closeable, OkCacheContainer {

		private final com.android.okhttp.HttpResponseCache delegate;
		private final AndroidShimResponseCache delegate;

		private HttpResponseCache(com.android.okhttp.HttpResponseCache delegate) {
		private HttpResponseCache(AndroidShimResponseCache delegate) {
		this.delegate = delegate;
		}

		@@ -161,17 +161,14 @@ public final class HttpResponseCache extends ResponseCache implements Closeable
		*/
		public static HttpResponseCache getInstalled() {
		ResponseCache installed = ResponseCache.getDefault();
		if (installed instanceof com.android.okhttp.HttpResponseCache) {
		return new HttpResponseCache(
		(com.android.okhttp.HttpResponseCache) installed);
		if (installed instanceof HttpResponseCache) {
		return (HttpResponseCache) installed;
		}

		return null;
		}

		/**
		* Creates a new HTTP response cache and {@link ResponseCache#setDefault
		* sets it} as the system default cache.
		* Creates a new HTTP response cache and sets it as the system default cache.
		*
		* @param directory the directory to hold cache data.
		* @param maxSize the maximum size of the cache in bytes.
		@@ -180,26 +177,26 @@ public final class HttpResponseCache extends ResponseCache implements Closeable
		* Most applications should respond to this exception by logging a
		* warning.
		*/
		public static HttpResponseCache install(File directory, long maxSize) throws IOException {
		public static synchronized HttpResponseCache install(File directory, long maxSize)
		throws IOException {
		ResponseCache installed = ResponseCache.getDefault();
		if (installed instanceof com.android.okhttp.HttpResponseCache) {
		com.android.okhttp.HttpResponseCache installedCache =
		(com.android.okhttp.HttpResponseCache) installed;
		if (installed instanceof HttpResponseCache) {
		HttpResponseCache installedResponseCache = (HttpResponseCache) installed;
		// don't close and reopen if an equivalent cache is already installed
		if (installedCache.getDirectory().equals(directory)
		&& installedCache.getMaxSize() == maxSize
		&& !installedCache.isClosed()) {
		return new HttpResponseCache(installedCache);
		AndroidShimResponseCache trueResponseCache = installedResponseCache.delegate;
		if (trueResponseCache.isEquivalent(directory, maxSize)) {
		return installedResponseCache;
		} else {
		// The HttpResponseCache that owns this object is about to be replaced.
		installedCache.close();
		trueResponseCache.close();
		}
		}

		com.android.okhttp.HttpResponseCache responseCache =
		new com.android.okhttp.HttpResponseCache(directory, maxSize);
		ResponseCache.setDefault(responseCache);
		return new HttpResponseCache(responseCache);
		AndroidShimResponseCache trueResponseCache =
		AndroidShimResponseCache.create(directory, maxSize);
		HttpResponseCache newResponseCache = new HttpResponseCache(trueResponseCache);
		ResponseCache.setDefault(newResponseCache);
		return newResponseCache;
		}

		@Override public CacheResponse get(URI uri, String requestMethod,
		@@ -214,10 +211,15 @@ public final class HttpResponseCache extends ResponseCache implements Closeable
		/**
		* Returns the number of bytes currently being used to store the values in
		* this cache. This may be greater than the {@link #maxSize} if a background
		* deletion is pending.
		* deletion is pending. {@code -1} is returned if the size cannot be determined.
		*/
		public long size() {
		return delegate.getSize();
		try {
		return delegate.size();
		} catch (IOException e) {
		// This can occur if the cache failed to lazily initialize.
		return -1;
		}
		}

		/**
		@@ -225,7 +227,7 @@ public final class HttpResponseCache extends ResponseCache implements Closeable
		* its data.
		*/
		public long maxSize() {
		return delegate.getMaxSize();
		return delegate.maxSize();
		}

		/**
		@@ -271,7 +273,7 @@ public final class HttpResponseCache extends ResponseCache implements Closeable
		* will remain on the filesystem.
		*/
		@Override public void close() throws IOException {
		if (ResponseCache.getDefault() == this.delegate) {
		if (ResponseCache.getDefault() == this) {
		ResponseCache.setDefault(null);
		}
		delegate.close();
		@@ -281,9 +283,16 @@ public final class HttpResponseCache extends ResponseCache implements Closeable
		* Uninstalls the cache and deletes all of its stored contents.
		*/
		public void delete() throws IOException {
		if (ResponseCache.getDefault() == this.delegate) {
		if (ResponseCache.getDefault() == this) {
		ResponseCache.setDefault(null);
		}
		delegate.delete();
		}

		/** @hide Needed for OkHttp integration. */
		@Override
		public Cache getCache() {
		return delegate.getCache();
		}

		}