Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am 00502e89: Merge "Changes associated with an OkHttp upgrade"

Browse Source 
* commit '00502e89603fa460cfd29d8759d74e38946105d4':
  Changes associated with an OkHttp upgrade
This commit is contained in:
Neil Fuller
2015-01-20 12:56:34 +00:00
committed by Android Git Automerger
parent 17f50f8119 00502e8960
commit 7382c02d62
2 changed files with 60 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
core/java/android/net/Network.java
View File

@@ -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);
}
/**

73
core/java/android/net/http/HttpResponseCache.java
View File

@@ -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();
}
}