diff --git a/core/java/android/net/Network.java b/core/java/android/net/Network.java
index 5c126964ad3db..dfe2413a08cf3 100644
--- a/core/java/android/net/Network.java
+++ b/core/java/android/net/Network.java
@@ -16,7 +16,6 @@
package android.net;
-import android.net.NetworkUtils;
import android.os.Parcelable;
import android.os.Parcel;
import android.system.ErrnoException;
@@ -34,15 +33,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
@@ -63,10 +61,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
@@ -220,10 +218,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);
}
};
@@ -278,22 +276,25 @@ public class Network implements Parcelable {
if (proxy == null) throw new IllegalArgumentException("proxy is null");
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?
if (protocol.equals("http")) {
- client = HttpHandler.createHttpOkHttpClient(proxy);
+ okUrlFactory = HttpHandler.createHttpOkUrlFactory(proxy);
} else if (protocol.equals("https")) {
- client = HttpsHandler.createHttpsOkHttpClient(proxy);
+ okUrlFactory = HttpsHandler.createHttpsOkUrlFactory(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);
}
/**
diff --git a/core/java/android/net/http/HttpResponseCache.java b/core/java/android/net/http/HttpResponseCache.java
index 2785a15a83954..c40b1bf5c2d40 100644
--- a/core/java/android/net/http/HttpResponseCache.java
+++ b/core/java/android/net/http/HttpResponseCache.java
@@ -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;
* Installing an HTTP response cache
* 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}: {@code
* protected void onCreate(Bundle savedInstanceState) {
* ...
@@ -147,11 +147,11 @@ import org.apache.http.impl.client.DefaultHttpClient;
* } catch (Exception httpResponseCacheNotAvailable) {
* }}
*/
-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();
+ }
+
}