Mark ab/6881855 as merged
Bug: 172690556
Change-Id: Ie75baec709bf8ac786637b8b0c318a93ae14c365
diff --git a/Android.bp b/Android.bp
index c13de29..a6f715c 100644
--- a/Android.bp
+++ b/Android.bp
@@ -21,6 +21,10 @@
min_sdk_version: "8",
srcs: ["src/main/java/**/*.java"],
+ // Exclude Cronet support for now. Can be enabled later if/when Cronet is made available as a
+ // compilation dependency for Volley clients.
+ exclude_srcs: ["src/main/java/com/android/volley/cronet/**/*"],
+
libs: [
// Only needed at compile-time.
"androidx.annotation_annotation",
diff --git a/bintray.gradle b/bintray.gradle
index 9007c31..b642b41 100644
--- a/bintray.gradle
+++ b/bintray.gradle
@@ -43,6 +43,12 @@
version project.version
pom {
packaging 'aar'
+ licenses {
+ license {
+ name = "The Apache License, Version 2.0"
+ url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
+ }
+ }
}
// Release AAR, Sources, and JavaDoc
diff --git a/build.gradle b/build.gradle
index 828a192..544771c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -62,7 +62,6 @@
buildToolsVersion = '28.0.3'
defaultConfig {
- // Keep in sync with src/main/AndroidManifest.xml
minSdkVersion 8
}
}
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 9d8a946..104b82e 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.2-all.zip
diff --git a/rules.gradle b/rules.gradle
index fd660cd..e0aef80 100644
--- a/rules.gradle
+++ b/rules.gradle
@@ -21,14 +21,16 @@
dependencies {
implementation "androidx.annotation:annotation:1.0.1"
+ compileOnly "org.chromium.net:cronet-embedded:76.3809.111"
}
// Check if the android plugin version supports unit testing.
-if (configurations.findByName("testCompile")) {
+if (configurations.findByName("testImplementation")) {
dependencies {
- testCompile "junit:junit:4.12"
- testCompile "org.hamcrest:hamcrest-library:1.3"
- testCompile "org.mockito:mockito-core:2.19.0"
- testCompile "org.robolectric:robolectric:3.4.2"
+ testImplementation "org.chromium.net:cronet-embedded:76.3809.111"
+ testImplementation "junit:junit:4.12"
+ testImplementation "org.hamcrest:hamcrest-library:1.3"
+ testImplementation "org.mockito:mockito-core:2.19.0"
+ testImplementation "org.robolectric:robolectric:3.4.2"
}
}
diff --git a/src/main/AndroidManifest.xml b/src/main/AndroidManifest.xml
index da8d33e..ba3a2a7 100644
--- a/src/main/AndroidManifest.xml
+++ b/src/main/AndroidManifest.xml
@@ -1,15 +1,2 @@
<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
- xmlns:tools="http://schemas.android.com/tools"
- package="com.android.volley"
- android:versionCode="1"
- android:versionName="1.0" >
-
- <!-- Keep in sync with build.gradle -->
- <uses-sdk
- android:minSdkVersion="8"
- tools:ignore="GradleOverrides" />
-
- <application />
-
-</manifest>
+<manifest package="com.android.volley" />
diff --git a/src/main/java/com/android/volley/AsyncCache.java b/src/main/java/com/android/volley/AsyncCache.java
new file mode 100644
index 0000000..3cddb4b
--- /dev/null
+++ b/src/main/java/com/android/volley/AsyncCache.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley;
+
+import androidx.annotation.Nullable;
+
+/** Asynchronous equivalent to the {@link Cache} interface. */
+public abstract class AsyncCache {
+
+ public interface OnGetCompleteCallback {
+ /**
+ * Invoked when the read from the cache is complete.
+ *
+ * @param entry The entry read from the cache, or null if the read failed or the key did not
+ * exist in the cache.
+ */
+ void onGetComplete(@Nullable Cache.Entry entry);
+ }
+
+ /**
+ * Retrieves an entry from the cache and sends it back through the {@link
+ * OnGetCompleteCallback#onGetComplete} function
+ *
+ * @param key Cache key
+ * @param callback Callback that will be notified when the information has been retrieved
+ */
+ public abstract void get(String key, OnGetCompleteCallback callback);
+
+ public interface OnWriteCompleteCallback {
+ /** Invoked when the cache operation is complete */
+ void onWriteComplete();
+ }
+
+ /**
+ * Writes a {@link Cache.Entry} to the cache, and calls {@link
+ * OnWriteCompleteCallback#onWriteComplete} after the operation is finished.
+ *
+ * @param key Cache key
+ * @param entry The entry to be written to the cache
+ * @param callback Callback that will be notified when the information has been written
+ */
+ public abstract void put(String key, Cache.Entry entry, OnWriteCompleteCallback callback);
+
+ /**
+ * Clears the cache. Deletes all cached files from disk. Calls {@link
+ * OnWriteCompleteCallback#onWriteComplete} after the operation is finished.
+ */
+ public abstract void clear(OnWriteCompleteCallback callback);
+
+ /**
+ * Initializes the cache and calls {@link OnWriteCompleteCallback#onWriteComplete} after the
+ * operation is finished.
+ */
+ public abstract void initialize(OnWriteCompleteCallback callback);
+
+ /**
+ * Invalidates an entry in the cache and calls {@link OnWriteCompleteCallback#onWriteComplete}
+ * after the operation is finished.
+ *
+ * @param key Cache key
+ * @param fullExpire True to fully expire the entry, false to soft expire
+ * @param callback Callback that's invoked once the entry has been invalidated
+ */
+ public abstract void invalidate(
+ String key, boolean fullExpire, OnWriteCompleteCallback callback);
+
+ /**
+ * Removes a {@link Cache.Entry} from the cache, and calls {@link
+ * OnWriteCompleteCallback#onWriteComplete} after the operation is finished.
+ *
+ * @param key Cache key
+ * @param callback Callback that's invoked once the entry has been removed
+ */
+ public abstract void remove(String key, OnWriteCompleteCallback callback);
+}
diff --git a/src/main/java/com/android/volley/AsyncNetwork.java b/src/main/java/com/android/volley/AsyncNetwork.java
new file mode 100644
index 0000000..ad19c03
--- /dev/null
+++ b/src/main/java/com/android/volley/AsyncNetwork.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley;
+
+import androidx.annotation.RestrictTo;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicReference;
+
+/** An asynchronous implementation of {@link Network} to perform requests. */
+public abstract class AsyncNetwork implements Network {
+ private ExecutorService mBlockingExecutor;
+ private ExecutorService mNonBlockingExecutor;
+ private ScheduledExecutorService mNonBlockingScheduledExecutor;
+
+ protected AsyncNetwork() {}
+
+ /** Interface for callback to be called after request is processed. */
+ public interface OnRequestComplete {
+ /** Method to be called after successful network request. */
+ void onSuccess(NetworkResponse networkResponse);
+
+ /** Method to be called after unsuccessful network request. */
+ void onError(VolleyError volleyError);
+ }
+
+ /**
+ * Non-blocking method to perform the specified request.
+ *
+ * @param request Request to process
+ * @param callback to be called once NetworkResponse is received
+ */
+ public abstract void performRequest(Request<?> request, OnRequestComplete callback);
+
+ /**
+ * Blocking method to perform network request.
+ *
+ * @param request Request to process
+ * @return response retrieved from the network
+ * @throws VolleyError in the event of an error
+ */
+ @Override
+ public NetworkResponse performRequest(Request<?> request) throws VolleyError {
+ final CountDownLatch latch = new CountDownLatch(1);
+ final AtomicReference<NetworkResponse> response = new AtomicReference<>();
+ final AtomicReference<VolleyError> error = new AtomicReference<>();
+ performRequest(
+ request,
+ new OnRequestComplete() {
+ @Override
+ public void onSuccess(NetworkResponse networkResponse) {
+ response.set(networkResponse);
+ latch.countDown();
+ }
+
+ @Override
+ public void onError(VolleyError volleyError) {
+ error.set(volleyError);
+ latch.countDown();
+ }
+ });
+ try {
+ latch.await();
+ } catch (InterruptedException e) {
+ VolleyLog.e(e, "while waiting for CountDownLatch");
+ Thread.currentThread().interrupt();
+ throw new VolleyError(e);
+ }
+
+ if (response.get() != null) {
+ return response.get();
+ } else if (error.get() != null) {
+ throw error.get();
+ } else {
+ throw new VolleyError("Neither response entry was set");
+ }
+ }
+
+ /**
+ * This method sets the non blocking executor to be used by the network for non-blocking tasks.
+ *
+ * <p>This method must be called before performing any requests.
+ */
+ @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+ public void setNonBlockingExecutor(ExecutorService executor) {
+ mNonBlockingExecutor = executor;
+ }
+
+ /**
+ * This method sets the blocking executor to be used by the network for potentially blocking
+ * tasks.
+ *
+ * <p>This method must be called before performing any requests.
+ */
+ @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+ public void setBlockingExecutor(ExecutorService executor) {
+ mBlockingExecutor = executor;
+ }
+
+ /**
+ * This method sets the scheduled executor to be used by the network for non-blocking tasks to
+ * be scheduled.
+ *
+ * <p>This method must be called before performing any requests.
+ */
+ @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+ public void setNonBlockingScheduledExecutor(ScheduledExecutorService executor) {
+ mNonBlockingScheduledExecutor = executor;
+ }
+
+ /** Gets blocking executor to perform any potentially blocking tasks. */
+ protected ExecutorService getBlockingExecutor() {
+ return mBlockingExecutor;
+ }
+
+ /** Gets non-blocking executor to perform any non-blocking tasks. */
+ protected ExecutorService getNonBlockingExecutor() {
+ return mNonBlockingExecutor;
+ }
+
+ /** Gets scheduled executor to perform any non-blocking tasks that need to be scheduled. */
+ protected ScheduledExecutorService getNonBlockingScheduledExecutor() {
+ return mNonBlockingScheduledExecutor;
+ }
+}
diff --git a/src/main/java/com/android/volley/AsyncRequestQueue.java b/src/main/java/com/android/volley/AsyncRequestQueue.java
new file mode 100644
index 0000000..3754866
--- /dev/null
+++ b/src/main/java/com/android/volley/AsyncRequestQueue.java
@@ -0,0 +1,626 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.android.volley.AsyncCache.OnGetCompleteCallback;
+import com.android.volley.AsyncNetwork.OnRequestComplete;
+import com.android.volley.Cache.Entry;
+import java.net.HttpURLConnection;
+import java.util.Comparator;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * An asynchronous request dispatch queue.
+ *
+ * <p>Add requests to the queue with {@link #add(Request)}. Once completed, responses will be
+ * delivered on the main thread (unless a custom {@link ResponseDelivery} has been provided)
+ */
+public class AsyncRequestQueue extends RequestQueue {
+ /** Default number of blocking threads to start. */
+ private static final int DEFAULT_BLOCKING_THREAD_POOL_SIZE = 4;
+
+ /**
+ * AsyncCache used to retrieve and store responses.
+ *
+ * <p>{@code null} indicates use of blocking Cache.
+ */
+ @Nullable private final AsyncCache mAsyncCache;
+
+ /** AsyncNetwork used to perform nework requests. */
+ private final AsyncNetwork mNetwork;
+
+ /** Executor for non-blocking tasks. */
+ private ExecutorService mNonBlockingExecutor;
+
+ /** Executor to be used for non-blocking tasks that need to be scheduled. */
+ private ScheduledExecutorService mNonBlockingScheduledExecutor;
+
+ /**
+ * Executor for blocking tasks.
+ *
+ * <p>Some tasks in handling requests may not be easy to implement in a non-blocking way, such
+ * as reading or parsing the response data. This executor is used to run these tasks.
+ */
+ private ExecutorService mBlockingExecutor;
+
+ /**
+ * This interface may be used by advanced applications to provide custom executors according to
+ * their needs. Apps must create ExecutorServices dynamically given a blocking queue rather than
+ * providing them directly so that Volley can provide a PriorityQueue which will prioritize
+ * requests according to Request#getPriority.
+ */
+ private ExecutorFactory mExecutorFactory;
+
+ /** Manage list of waiting requests and de-duplicate requests with same cache key. */
+ private final WaitingRequestManager mWaitingRequestManager = new WaitingRequestManager(this);
+
+ /**
+ * Sets all the variables, but processing does not begin until {@link #start()} is called.
+ *
+ * @param cache to use for persisting responses to disk. If an AsyncCache was provided, then
+ * this will be a {@link ThrowingCache}
+ * @param network to perform HTTP requests
+ * @param asyncCache to use for persisting responses to disk. May be null to indicate use of
+ * blocking cache
+ * @param responseDelivery interface for posting responses and errors
+ * @param executorFactory Interface to be used to provide custom executors according to the
+ * users needs.
+ */
+ private AsyncRequestQueue(
+ Cache cache,
+ AsyncNetwork network,
+ @Nullable AsyncCache asyncCache,
+ ResponseDelivery responseDelivery,
+ ExecutorFactory executorFactory) {
+ super(cache, network, /* threadPoolSize= */ 0, responseDelivery);
+ mAsyncCache = asyncCache;
+ mNetwork = network;
+ mExecutorFactory = executorFactory;
+ }
+
+ /** Sets the executors and initializes the cache. */
+ @Override
+ public void start() {
+ stop(); // Make sure any currently running threads are stopped
+
+ // Create blocking / non-blocking executors and set them in the network and stack.
+ mNonBlockingExecutor = mExecutorFactory.createNonBlockingExecutor(getBlockingQueue());
+ mBlockingExecutor = mExecutorFactory.createBlockingExecutor(getBlockingQueue());
+ mNonBlockingScheduledExecutor = mExecutorFactory.createNonBlockingScheduledExecutor();
+ mNetwork.setBlockingExecutor(mBlockingExecutor);
+ mNetwork.setNonBlockingExecutor(mNonBlockingExecutor);
+ mNetwork.setNonBlockingScheduledExecutor(mNonBlockingScheduledExecutor);
+
+ mNonBlockingExecutor.execute(
+ new Runnable() {
+ @Override
+ public void run() {
+ // This is intentionally blocking, because we don't want to process any
+ // requests until the cache is initialized.
+ if (mAsyncCache != null) {
+ final CountDownLatch latch = new CountDownLatch(1);
+ mAsyncCache.initialize(
+ new AsyncCache.OnWriteCompleteCallback() {
+ @Override
+ public void onWriteComplete() {
+ latch.countDown();
+ }
+ });
+ try {
+ latch.await();
+ } catch (InterruptedException e) {
+ VolleyLog.e(
+ e, "Thread was interrupted while initializing the cache.");
+ Thread.currentThread().interrupt();
+ throw new RuntimeException(e);
+ }
+ } else {
+ getCache().initialize();
+ }
+ }
+ });
+ }
+
+ /** Shuts down and nullifies both executors */
+ @Override
+ public void stop() {
+ if (mNonBlockingExecutor != null) {
+ mNonBlockingExecutor.shutdownNow();
+ mNonBlockingExecutor = null;
+ }
+ if (mBlockingExecutor != null) {
+ mBlockingExecutor.shutdownNow();
+ mBlockingExecutor = null;
+ }
+ if (mNonBlockingScheduledExecutor != null) {
+ mNonBlockingScheduledExecutor.shutdownNow();
+ mNonBlockingScheduledExecutor = null;
+ }
+ }
+
+ /** Begins the request by sending it to the Cache or Network. */
+ @Override
+ <T> void beginRequest(Request<T> request) {
+ // If the request is uncacheable, send it over the network.
+ if (request.shouldCache()) {
+ if (mAsyncCache != null) {
+ mNonBlockingExecutor.execute(new CacheTask<>(request));
+ } else {
+ mBlockingExecutor.execute(new CacheTask<>(request));
+ }
+ } else {
+ sendRequestOverNetwork(request);
+ }
+ }
+
+ @Override
+ <T> void sendRequestOverNetwork(Request<T> request) {
+ mNonBlockingExecutor.execute(new NetworkTask<>(request));
+ }
+
+ /** Runnable that gets an entry from the cache. */
+ private class CacheTask<T> extends RequestTask<T> {
+ CacheTask(Request<T> request) {
+ super(request);
+ }
+
+ @Override
+ public void run() {
+ // If the request has been canceled, don't bother dispatching it.
+ if (mRequest.isCanceled()) {
+ mRequest.finish("cache-discard-canceled");
+ return;
+ }
+
+ mRequest.addMarker("cache-queue-take");
+
+ // Attempt to retrieve this item from cache.
+ if (mAsyncCache != null) {
+ mAsyncCache.get(
+ mRequest.getCacheKey(),
+ new OnGetCompleteCallback() {
+ @Override
+ public void onGetComplete(Entry entry) {
+ handleEntry(entry, mRequest);
+ }
+ });
+ } else {
+ Entry entry = getCache().get(mRequest.getCacheKey());
+ handleEntry(entry, mRequest);
+ }
+ }
+ }
+
+ /** Helper method that handles the cache entry after getting it from the Cache. */
+ private void handleEntry(final Entry entry, final Request<?> mRequest) {
+ if (entry == null) {
+ mRequest.addMarker("cache-miss");
+ // Cache miss; send off to the network dispatcher.
+ if (!mWaitingRequestManager.maybeAddToWaitingRequests(mRequest)) {
+ sendRequestOverNetwork(mRequest);
+ }
+ return;
+ }
+
+ // If it is completely expired, just send it to the network.
+ if (entry.isExpired()) {
+ mRequest.addMarker("cache-hit-expired");
+ mRequest.setCacheEntry(entry);
+ if (!mWaitingRequestManager.maybeAddToWaitingRequests(mRequest)) {
+ sendRequestOverNetwork(mRequest);
+ }
+ return;
+ }
+
+ // We have a cache hit; parse its data for delivery back to the request.
+ mBlockingExecutor.execute(new CacheParseTask<>(mRequest, entry));
+ }
+
+ private class CacheParseTask<T> extends RequestTask<T> {
+ Cache.Entry entry;
+
+ CacheParseTask(Request<T> request, Cache.Entry entry) {
+ super(request);
+ this.entry = entry;
+ }
+
+ @Override
+ public void run() {
+ mRequest.addMarker("cache-hit");
+ Response<?> response =
+ mRequest.parseNetworkResponse(
+ new NetworkResponse(
+ HttpURLConnection.HTTP_OK,
+ entry.data,
+ /* notModified= */ false,
+ /* networkTimeMs= */ 0,
+ entry.allResponseHeaders));
+ mRequest.addMarker("cache-hit-parsed");
+
+ if (!entry.refreshNeeded()) {
+ // Completely unexpired cache hit. Just deliver the response.
+ getResponseDelivery().postResponse(mRequest, response);
+ } else {
+ // Soft-expired cache hit. We can deliver the cached response,
+ // but we need to also send the request to the network for
+ // refreshing.
+ mRequest.addMarker("cache-hit-refresh-needed");
+ mRequest.setCacheEntry(entry);
+ // Mark the response as intermediate.
+ response.intermediate = true;
+
+ if (!mWaitingRequestManager.maybeAddToWaitingRequests(mRequest)) {
+ // Post the intermediate response back to the user and have
+ // the delivery then forward the request along to the network.
+ getResponseDelivery()
+ .postResponse(
+ mRequest,
+ response,
+ new Runnable() {
+ @Override
+ public void run() {
+ sendRequestOverNetwork(mRequest);
+ }
+ });
+ } else {
+ // request has been added to list of waiting requests
+ // to receive the network response from the first request once it
+ // returns.
+ getResponseDelivery().postResponse(mRequest, response);
+ }
+ }
+ }
+ }
+
+ private class ParseErrorTask<T> extends RequestTask<T> {
+ VolleyError volleyError;
+
+ ParseErrorTask(Request<T> request, VolleyError volleyError) {
+ super(request);
+ this.volleyError = volleyError;
+ }
+
+ @Override
+ public void run() {
+ VolleyError parsedError = mRequest.parseNetworkError(volleyError);
+ getResponseDelivery().postError(mRequest, parsedError);
+ mRequest.notifyListenerResponseNotUsable();
+ }
+ }
+
+ /** Runnable that performs the network request */
+ private class NetworkTask<T> extends RequestTask<T> {
+ NetworkTask(Request<T> request) {
+ super(request);
+ }
+
+ @Override
+ public void run() {
+ // If the request was cancelled already, do not perform the network request.
+ if (mRequest.isCanceled()) {
+ mRequest.finish("network-discard-cancelled");
+ mRequest.notifyListenerResponseNotUsable();
+ return;
+ }
+
+ final long startTimeMs = SystemClock.elapsedRealtime();
+ mRequest.addMarker("network-queue-take");
+
+ // TODO: Figure out what to do with traffic stats tags. Can this be pushed to the
+ // HTTP stack, or is it no longer feasible to support?
+
+ // Perform the network request.
+ mNetwork.performRequest(
+ mRequest,
+ new OnRequestComplete() {
+ @Override
+ public void onSuccess(final NetworkResponse networkResponse) {
+ mRequest.addMarker("network-http-complete");
+
+ // If the server returned 304 AND we delivered a response already,
+ // we're done -- don't deliver a second identical response.
+ if (networkResponse.notModified && mRequest.hasHadResponseDelivered()) {
+ mRequest.finish("not-modified");
+ mRequest.notifyListenerResponseNotUsable();
+ return;
+ }
+
+ // Parse the response here on the worker thread.
+ mBlockingExecutor.execute(
+ new NetworkParseTask<>(mRequest, networkResponse));
+ }
+
+ @Override
+ public void onError(final VolleyError volleyError) {
+ volleyError.setNetworkTimeMs(
+ SystemClock.elapsedRealtime() - startTimeMs);
+ mBlockingExecutor.execute(new ParseErrorTask<>(mRequest, volleyError));
+ }
+ });
+ }
+ }
+
+ /** Runnable that parses a network response. */
+ private class NetworkParseTask<T> extends RequestTask<T> {
+ NetworkResponse networkResponse;
+
+ NetworkParseTask(Request<T> request, NetworkResponse networkResponse) {
+ super(request);
+ this.networkResponse = networkResponse;
+ }
+
+ @Override
+ public void run() {
+ final Response<?> response = mRequest.parseNetworkResponse(networkResponse);
+ mRequest.addMarker("network-parse-complete");
+
+ // Write to cache if applicable.
+ // TODO: Only update cache metadata instead of entire
+ // record for 304s.
+ if (mRequest.shouldCache() && response.cacheEntry != null) {
+ if (mAsyncCache != null) {
+ mNonBlockingExecutor.execute(new CachePutTask<>(mRequest, response));
+ } else {
+ mBlockingExecutor.execute(new CachePutTask<>(mRequest, response));
+ }
+ } else {
+ finishRequest(mRequest, response, /* cached= */ false);
+ }
+ }
+ }
+
+ private class CachePutTask<T> extends RequestTask<T> {
+ Response<?> response;
+
+ CachePutTask(Request<T> request, Response<?> response) {
+ super(request);
+ this.response = response;
+ }
+
+ @Override
+ public void run() {
+ if (mAsyncCache != null) {
+ mAsyncCache.put(
+ mRequest.getCacheKey(),
+ response.cacheEntry,
+ new AsyncCache.OnWriteCompleteCallback() {
+ @Override
+ public void onWriteComplete() {
+ finishRequest(mRequest, response, /* cached= */ true);
+ }
+ });
+ } else {
+ getCache().put(mRequest.getCacheKey(), response.cacheEntry);
+ finishRequest(mRequest, response, /* cached= */ true);
+ }
+ }
+ }
+
+ /** Posts response and notifies listener */
+ private void finishRequest(Request<?> mRequest, Response<?> response, boolean cached) {
+ if (cached) {
+ mRequest.addMarker("network-cache-written");
+ }
+ // Post the response back.
+ mRequest.markDelivered();
+ getResponseDelivery().postResponse(mRequest, response);
+ mRequest.notifyListenerResponseReceived(response);
+ }
+
+ /**
+ * This class may be used by advanced applications to provide custom executors according to
+ * their needs. Apps must create ExecutorServices dynamically given a blocking queue rather than
+ * providing them directly so that Volley can provide a PriorityQueue which will prioritize
+ * requests according to Request#getPriority.
+ */
+ public abstract static class ExecutorFactory {
+ abstract ExecutorService createNonBlockingExecutor(BlockingQueue<Runnable> taskQueue);
+
+ abstract ExecutorService createBlockingExecutor(BlockingQueue<Runnable> taskQueue);
+
+ abstract ScheduledExecutorService createNonBlockingScheduledExecutor();
+ }
+
+ /** Provides a BlockingQueue to be used to create executors. */
+ private static PriorityBlockingQueue<Runnable> getBlockingQueue() {
+ return new PriorityBlockingQueue<>(
+ /* initialCapacity= */ 11,
+ new Comparator<Runnable>() {
+ @Override
+ public int compare(Runnable r1, Runnable r2) {
+ // Vanilla runnables are prioritized first, then RequestTasks are ordered
+ // by the underlying Request.
+ if (r1 instanceof RequestTask) {
+ if (r2 instanceof RequestTask) {
+ return ((RequestTask<?>) r1).compareTo(((RequestTask<?>) r2));
+ }
+ return 1;
+ }
+ return r2 instanceof RequestTask ? -1 : 0;
+ }
+ });
+ }
+
+ /**
+ * Builder is used to build an instance of {@link AsyncRequestQueue} from values configured by
+ * the setters.
+ */
+ public static class Builder {
+ @Nullable private AsyncCache mAsyncCache = null;
+ private final AsyncNetwork mNetwork;
+ @Nullable private Cache mCache = null;
+ @Nullable private ExecutorFactory mExecutorFactory = null;
+ @Nullable private ResponseDelivery mResponseDelivery = null;
+
+ public Builder(AsyncNetwork asyncNetwork) {
+ if (asyncNetwork == null) {
+ throw new IllegalArgumentException("Network cannot be null");
+ }
+ mNetwork = asyncNetwork;
+ }
+
+ /**
+ * Sets the executor factory to be used by the AsyncRequestQueue. If this is not called,
+ * Volley will create suitable private thread pools.
+ */
+ public Builder setExecutorFactory(ExecutorFactory executorFactory) {
+ mExecutorFactory = executorFactory;
+ return this;
+ }
+
+ /**
+ * Sets the response deliver to be used by the AsyncRequestQueue. If this is not called, we
+ * will default to creating a new {@link ExecutorDelivery} with the application's main
+ * thread.
+ */
+ public Builder setResponseDelivery(ResponseDelivery responseDelivery) {
+ mResponseDelivery = responseDelivery;
+ return this;
+ }
+
+ /** Sets the AsyncCache to be used by the AsyncRequestQueue. */
+ public Builder setAsyncCache(AsyncCache asyncCache) {
+ mAsyncCache = asyncCache;
+ return this;
+ }
+
+ /** Sets the Cache to be used by the AsyncRequestQueue. */
+ public Builder setCache(Cache cache) {
+ mCache = cache;
+ return this;
+ }
+
+ /** Provides a default ExecutorFactory to use, if one is never set. */
+ private ExecutorFactory getDefaultExecutorFactory() {
+ return new ExecutorFactory() {
+ @Override
+ public ExecutorService createNonBlockingExecutor(
+ BlockingQueue<Runnable> taskQueue) {
+ return getNewThreadPoolExecutor(
+ /* maximumPoolSize= */ 1,
+ /* threadNameSuffix= */ "Non-BlockingExecutor",
+ taskQueue);
+ }
+
+ @Override
+ public ExecutorService createBlockingExecutor(BlockingQueue<Runnable> taskQueue) {
+ return getNewThreadPoolExecutor(
+ /* maximumPoolSize= */ DEFAULT_BLOCKING_THREAD_POOL_SIZE,
+ /* threadNameSuffix= */ "BlockingExecutor",
+ taskQueue);
+ }
+
+ @Override
+ public ScheduledExecutorService createNonBlockingScheduledExecutor() {
+ return new ScheduledThreadPoolExecutor(
+ /* corePoolSize= */ 0, getThreadFactory("ScheduledExecutor"));
+ }
+
+ private ThreadPoolExecutor getNewThreadPoolExecutor(
+ int maximumPoolSize,
+ final String threadNameSuffix,
+ BlockingQueue<Runnable> taskQueue) {
+ return new ThreadPoolExecutor(
+ /* corePoolSize= */ 0,
+ /* maximumPoolSize= */ maximumPoolSize,
+ /* keepAliveTime= */ 60,
+ /* unit= */ TimeUnit.SECONDS,
+ taskQueue,
+ getThreadFactory(threadNameSuffix));
+ }
+
+ private ThreadFactory getThreadFactory(final String threadNameSuffix) {
+ return new ThreadFactory() {
+ @Override
+ public Thread newThread(@NonNull Runnable runnable) {
+ Thread t = Executors.defaultThreadFactory().newThread(runnable);
+ t.setName("Volley-" + threadNameSuffix);
+ return t;
+ }
+ };
+ }
+ };
+ }
+
+ public AsyncRequestQueue build() {
+ // If neither cache is set by the caller, throw an illegal argument exception.
+ if (mCache == null && mAsyncCache == null) {
+ throw new IllegalArgumentException("You must set one of the cache objects");
+ }
+ if (mCache == null) {
+ // if no cache is provided, we will provide one that throws
+ // UnsupportedOperationExceptions to pass into the parent class.
+ mCache = new ThrowingCache();
+ }
+ if (mResponseDelivery == null) {
+ mResponseDelivery = new ExecutorDelivery(new Handler(Looper.getMainLooper()));
+ }
+ if (mExecutorFactory == null) {
+ mExecutorFactory = getDefaultExecutorFactory();
+ }
+ return new AsyncRequestQueue(
+ mCache, mNetwork, mAsyncCache, mResponseDelivery, mExecutorFactory);
+ }
+ }
+
+ /** A cache that throws an error if a method is called. */
+ private static class ThrowingCache implements Cache {
+ @Override
+ public Entry get(String key) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void put(String key, Entry entry) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void initialize() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void invalidate(String key, boolean fullExpire) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void remove(String key) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void clear() {
+ throw new UnsupportedOperationException();
+ }
+ }
+}
diff --git a/src/main/java/com/android/volley/CacheDispatcher.java b/src/main/java/com/android/volley/CacheDispatcher.java
index 12b1035..1bfc0ea 100644
--- a/src/main/java/com/android/volley/CacheDispatcher.java
+++ b/src/main/java/com/android/volley/CacheDispatcher.java
@@ -18,10 +18,6 @@
import android.os.Process;
import androidx.annotation.VisibleForTesting;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
import java.util.concurrent.BlockingQueue;
/**
@@ -72,7 +68,7 @@
mNetworkQueue = networkQueue;
mCache = cache;
mDelivery = delivery;
- mWaitingRequestManager = new WaitingRequestManager(this);
+ mWaitingRequestManager = new WaitingRequestManager(this, networkQueue, delivery);
}
/**
@@ -207,113 +203,4 @@
request.sendEvent(RequestQueue.RequestEvent.REQUEST_CACHE_LOOKUP_FINISHED);
}
}
-
- private static class WaitingRequestManager implements Request.NetworkRequestCompleteListener {
-
- /**
- * Staging area for requests that already have a duplicate request in flight.
- *
- * <ul>
- * <li>containsKey(cacheKey) indicates that there is a request in flight for the given
- * cache key.
- * <li>get(cacheKey) returns waiting requests for the given cache key. The in flight
- * request is <em>not</em> contained in that list. Is null if no requests are staged.
- * </ul>
- */
- private final Map<String, List<Request<?>>> mWaitingRequests = new HashMap<>();
-
- private final CacheDispatcher mCacheDispatcher;
-
- WaitingRequestManager(CacheDispatcher cacheDispatcher) {
- mCacheDispatcher = cacheDispatcher;
- }
-
- /** Request received a valid response that can be used by other waiting requests. */
- @Override
- public void onResponseReceived(Request<?> request, Response<?> response) {
- if (response.cacheEntry == null || response.cacheEntry.isExpired()) {
- onNoUsableResponseReceived(request);
- return;
- }
- String cacheKey = request.getCacheKey();
- List<Request<?>> waitingRequests;
- synchronized (this) {
- waitingRequests = mWaitingRequests.remove(cacheKey);
- }
- if (waitingRequests != null) {
- if (VolleyLog.DEBUG) {
- VolleyLog.v(
- "Releasing %d waiting requests for cacheKey=%s.",
- waitingRequests.size(), cacheKey);
- }
- // Process all queued up requests.
- for (Request<?> waiting : waitingRequests) {
- mCacheDispatcher.mDelivery.postResponse(waiting, response);
- }
- }
- }
-
- /** No valid response received from network, release waiting requests. */
- @Override
- public synchronized void onNoUsableResponseReceived(Request<?> request) {
- String cacheKey = request.getCacheKey();
- List<Request<?>> waitingRequests = mWaitingRequests.remove(cacheKey);
- if (waitingRequests != null && !waitingRequests.isEmpty()) {
- if (VolleyLog.DEBUG) {
- VolleyLog.v(
- "%d waiting requests for cacheKey=%s; resend to network",
- waitingRequests.size(), cacheKey);
- }
- Request<?> nextInLine = waitingRequests.remove(0);
- mWaitingRequests.put(cacheKey, waitingRequests);
- nextInLine.setNetworkRequestCompleteListener(this);
- try {
- mCacheDispatcher.mNetworkQueue.put(nextInLine);
- } catch (InterruptedException iex) {
- VolleyLog.e("Couldn't add request to queue. %s", iex.toString());
- // Restore the interrupted status of the calling thread (i.e. NetworkDispatcher)
- Thread.currentThread().interrupt();
- // Quit the current CacheDispatcher thread.
- mCacheDispatcher.quit();
- }
- }
- }
-
- /**
- * For cacheable requests, if a request for the same cache key is already in flight, add it
- * to a queue to wait for that in-flight request to finish.
- *
- * @return whether the request was queued. If false, we should continue issuing the request
- * over the network. If true, we should put the request on hold to be processed when the
- * in-flight request finishes.
- */
- private synchronized boolean maybeAddToWaitingRequests(Request<?> request) {
- String cacheKey = request.getCacheKey();
- // Insert request into stage if there's already a request with the same cache key
- // in flight.
- if (mWaitingRequests.containsKey(cacheKey)) {
- // There is already a request in flight. Queue up.
- List<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
- if (stagedRequests == null) {
- stagedRequests = new ArrayList<>();
- }
- request.addMarker("waiting-for-response");
- stagedRequests.add(request);
- mWaitingRequests.put(cacheKey, stagedRequests);
- if (VolleyLog.DEBUG) {
- VolleyLog.d("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
- }
- return true;
- } else {
- // Insert 'null' queue for this cacheKey, indicating there is now a request in
- // flight.
- mWaitingRequests.put(cacheKey, null);
- request.setNetworkRequestCompleteListener(this);
- if (VolleyLog.DEBUG) {
- VolleyLog.d("new request, sending to network %s", cacheKey);
- }
- return false;
- }
- }
- }
}
diff --git a/src/main/java/com/android/volley/Request.java b/src/main/java/com/android/volley/Request.java
index 2b53f96..b60dc74 100644
--- a/src/main/java/com/android/volley/Request.java
+++ b/src/main/java/com/android/volley/Request.java
@@ -107,6 +107,9 @@
/** Whether the request should be retried in the event of an HTTP 5xx (server) error. */
private boolean mShouldRetryServerErrors = false;
+ /** Whether the request should be retried in the event of a {@link NoConnectionError}. */
+ private boolean mShouldRetryConnectionErrors = false;
+
/** The retry policy for this request. */
private RetryPolicy mRetryPolicy;
@@ -534,6 +537,25 @@
}
/**
+ * Sets whether or not the request should be retried in the event that no connection could be
+ * established.
+ *
+ * @return This Request object to allow for chaining.
+ */
+ public final Request<?> setShouldRetryConnectionErrors(boolean shouldRetryConnectionErrors) {
+ mShouldRetryConnectionErrors = shouldRetryConnectionErrors;
+ return this;
+ }
+
+ /**
+ * Returns true if this request should be retried in the event that no connection could be
+ * established.
+ */
+ public final boolean shouldRetryConnectionErrors() {
+ return mShouldRetryConnectionErrors;
+ }
+
+ /**
* Priority values. Requests will be processed from higher priorities to lower priorities, in
* FIFO order.
*/
diff --git a/src/main/java/com/android/volley/RequestQueue.java b/src/main/java/com/android/volley/RequestQueue.java
index c127c7f..6db0b1c 100644
--- a/src/main/java/com/android/volley/RequestQueue.java
+++ b/src/main/java/com/android/volley/RequestQueue.java
@@ -263,13 +263,17 @@
request.addMarker("add-to-queue");
sendRequestEvent(request, RequestEvent.REQUEST_QUEUED);
+ beginRequest(request);
+ return request;
+ }
+
+ <T> void beginRequest(Request<T> request) {
// If the request is uncacheable, skip the cache queue and go straight to the network.
if (!request.shouldCache()) {
- mNetworkQueue.add(request);
- return request;
+ sendRequestOverNetwork(request);
+ } else {
+ mCacheQueue.add(request);
}
- mCacheQueue.add(request);
- return request;
}
/**
@@ -327,4 +331,12 @@
mFinishedListeners.remove(listener);
}
}
+
+ public ResponseDelivery getResponseDelivery() {
+ return mDelivery;
+ }
+
+ <T> void sendRequestOverNetwork(Request<T> request) {
+ mNetworkQueue.add(request);
+ }
}
diff --git a/src/main/java/com/android/volley/RequestTask.java b/src/main/java/com/android/volley/RequestTask.java
new file mode 100644
index 0000000..8eeaf2c
--- /dev/null
+++ b/src/main/java/com/android/volley/RequestTask.java
@@ -0,0 +1,15 @@
+package com.android.volley;
+
+/** Abstract runnable that's a task to be completed by the RequestQueue. */
+public abstract class RequestTask<T> implements Runnable {
+ final Request<T> mRequest;
+
+ public RequestTask(Request<T> request) {
+ mRequest = request;
+ }
+
+ @SuppressWarnings("unchecked")
+ public int compareTo(RequestTask<?> other) {
+ return mRequest.compareTo((Request<T>) other.mRequest);
+ }
+}
diff --git a/src/main/java/com/android/volley/WaitingRequestManager.java b/src/main/java/com/android/volley/WaitingRequestManager.java
new file mode 100644
index 0000000..682e339
--- /dev/null
+++ b/src/main/java/com/android/volley/WaitingRequestManager.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.BlockingQueue;
+
+/**
+ * Callback to notify the caller when the network request returns. Valid responses can be used by
+ * all duplicate requests.
+ */
+class WaitingRequestManager implements Request.NetworkRequestCompleteListener {
+
+ /**
+ * Staging area for requests that already have a duplicate request in flight.
+ *
+ * <ul>
+ * <li>containsKey(cacheKey) indicates that there is a request in flight for the given cache
+ * key.
+ * <li>get(cacheKey) returns waiting requests for the given cache key. The in flight request
+ * is <em>not</em> contained in that list. Is null if no requests are staged.
+ * </ul>
+ */
+ private final Map<String, List<Request<?>>> mWaitingRequests = new HashMap<>();
+
+ private final ResponseDelivery mResponseDelivery;
+
+ /**
+ * RequestQueue that is passed in by the AsyncRequestQueue. This is null when this instance is
+ * initialized by the {@link CacheDispatcher}
+ */
+ @Nullable private final RequestQueue mRequestQueue;
+
+ /**
+ * CacheDispacter that is passed in by the CacheDispatcher. This is null when this instance is
+ * initialized by the {@link AsyncRequestQueue}
+ */
+ @Nullable private final CacheDispatcher mCacheDispatcher;
+
+ /**
+ * BlockingQueue that is passed in by the CacheDispatcher. This is null when this instance is
+ * initialized by the {@link AsyncRequestQueue}
+ */
+ @Nullable private final BlockingQueue<Request<?>> mNetworkQueue;
+
+ WaitingRequestManager(@NonNull RequestQueue requestQueue) {
+ mRequestQueue = requestQueue;
+ mResponseDelivery = mRequestQueue.getResponseDelivery();
+ mCacheDispatcher = null;
+ mNetworkQueue = null;
+ }
+
+ WaitingRequestManager(
+ @NonNull CacheDispatcher cacheDispatcher,
+ @NonNull BlockingQueue<Request<?>> networkQueue,
+ ResponseDelivery responseDelivery) {
+ mRequestQueue = null;
+ mResponseDelivery = responseDelivery;
+ mCacheDispatcher = cacheDispatcher;
+ mNetworkQueue = networkQueue;
+ }
+
+ /** Request received a valid response that can be used by other waiting requests. */
+ @Override
+ public void onResponseReceived(Request<?> request, Response<?> response) {
+ if (response.cacheEntry == null || response.cacheEntry.isExpired()) {
+ onNoUsableResponseReceived(request);
+ return;
+ }
+ String cacheKey = request.getCacheKey();
+ List<Request<?>> waitingRequests;
+ synchronized (this) {
+ waitingRequests = mWaitingRequests.remove(cacheKey);
+ }
+ if (waitingRequests != null) {
+ if (VolleyLog.DEBUG) {
+ VolleyLog.v(
+ "Releasing %d waiting requests for cacheKey=%s.",
+ waitingRequests.size(), cacheKey);
+ }
+ // Process all queued up requests.
+ for (Request<?> waiting : waitingRequests) {
+ mResponseDelivery.postResponse(waiting, response);
+ }
+ }
+ }
+
+ /** No valid response received from network, release waiting requests. */
+ @Override
+ public synchronized void onNoUsableResponseReceived(Request<?> request) {
+ String cacheKey = request.getCacheKey();
+ List<Request<?>> waitingRequests = mWaitingRequests.remove(cacheKey);
+ if (waitingRequests != null && !waitingRequests.isEmpty()) {
+ if (VolleyLog.DEBUG) {
+ VolleyLog.v(
+ "%d waiting requests for cacheKey=%s; resend to network",
+ waitingRequests.size(), cacheKey);
+ }
+ Request<?> nextInLine = waitingRequests.remove(0);
+ mWaitingRequests.put(cacheKey, waitingRequests);
+ nextInLine.setNetworkRequestCompleteListener(this);
+ // RequestQueue will be non-null if this instance was created in AsyncRequestQueue.
+ if (mRequestQueue != null) {
+ // Will send the network request from the RequestQueue.
+ mRequestQueue.sendRequestOverNetwork(nextInLine);
+ } else if (mCacheDispatcher != null && mNetworkQueue != null) {
+ // If we're not using the AsyncRequestQueue, then submit it to the network queue.
+ try {
+ mNetworkQueue.put(nextInLine);
+ } catch (InterruptedException iex) {
+ VolleyLog.e("Couldn't add request to queue. %s", iex.toString());
+ // Restore the interrupted status of the calling thread (i.e. NetworkDispatcher)
+ Thread.currentThread().interrupt();
+ // Quit the current CacheDispatcher thread.
+ mCacheDispatcher.quit();
+ }
+ }
+ }
+ }
+
+ /**
+ * For cacheable requests, if a request for the same cache key is already in flight, add it to a
+ * queue to wait for that in-flight request to finish.
+ *
+ * @return whether the request was queued. If false, we should continue issuing the request over
+ * the network. If true, we should put the request on hold to be processed when the
+ * in-flight request finishes.
+ */
+ synchronized boolean maybeAddToWaitingRequests(Request<?> request) {
+ String cacheKey = request.getCacheKey();
+ // Insert request into stage if there's already a request with the same cache key
+ // in flight.
+ if (mWaitingRequests.containsKey(cacheKey)) {
+ // There is already a request in flight. Queue up.
+ List<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
+ if (stagedRequests == null) {
+ stagedRequests = new ArrayList<>();
+ }
+ request.addMarker("waiting-for-response");
+ stagedRequests.add(request);
+ mWaitingRequests.put(cacheKey, stagedRequests);
+ if (VolleyLog.DEBUG) {
+ VolleyLog.d("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
+ }
+ return true;
+ } else {
+ // Insert 'null' queue for this cacheKey, indicating there is now a request in
+ // flight.
+ mWaitingRequests.put(cacheKey, null);
+ request.setNetworkRequestCompleteListener(this);
+ if (VolleyLog.DEBUG) {
+ VolleyLog.d("new request, sending to network %s", cacheKey);
+ }
+ return false;
+ }
+ }
+}
diff --git a/src/main/java/com/android/volley/cronet/CronetHttpStack.java b/src/main/java/com/android/volley/cronet/CronetHttpStack.java
new file mode 100644
index 0000000..f3baace
--- /dev/null
+++ b/src/main/java/com/android/volley/cronet/CronetHttpStack.java
@@ -0,0 +1,631 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley.cronet;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.Base64;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import com.android.volley.AuthFailureError;
+import com.android.volley.Header;
+import com.android.volley.Request;
+import com.android.volley.RequestTask;
+import com.android.volley.VolleyLog;
+import com.android.volley.toolbox.AsyncHttpStack;
+import com.android.volley.toolbox.ByteArrayPool;
+import com.android.volley.toolbox.HttpHeaderParser;
+import com.android.volley.toolbox.HttpResponse;
+import com.android.volley.toolbox.PoolingByteArrayOutputStream;
+import com.android.volley.toolbox.UrlRewriter;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.WritableByteChannel;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import org.chromium.net.CronetEngine;
+import org.chromium.net.CronetException;
+import org.chromium.net.UploadDataProvider;
+import org.chromium.net.UploadDataProviders;
+import org.chromium.net.UrlRequest;
+import org.chromium.net.UrlRequest.Callback;
+import org.chromium.net.UrlResponseInfo;
+
+/**
+ * A {@link AsyncHttpStack} that's based on Cronet's fully asynchronous API for network requests.
+ */
+public class CronetHttpStack extends AsyncHttpStack {
+
+ private final CronetEngine mCronetEngine;
+ private final ByteArrayPool mPool;
+ private final UrlRewriter mUrlRewriter;
+ private final RequestListener mRequestListener;
+
+ // cURL logging support
+ private final boolean mCurlLoggingEnabled;
+ private final CurlCommandLogger mCurlCommandLogger;
+ private final boolean mLogAuthTokensInCurlCommands;
+
+ private CronetHttpStack(
+ CronetEngine cronetEngine,
+ ByteArrayPool pool,
+ UrlRewriter urlRewriter,
+ RequestListener requestListener,
+ boolean curlLoggingEnabled,
+ CurlCommandLogger curlCommandLogger,
+ boolean logAuthTokensInCurlCommands) {
+ mCronetEngine = cronetEngine;
+ mPool = pool;
+ mUrlRewriter = urlRewriter;
+ mRequestListener = requestListener;
+ mCurlLoggingEnabled = curlLoggingEnabled;
+ mCurlCommandLogger = curlCommandLogger;
+ mLogAuthTokensInCurlCommands = logAuthTokensInCurlCommands;
+
+ mRequestListener.initialize(this);
+ }
+
+ @Override
+ public void executeRequest(
+ final Request<?> request,
+ final Map<String, String> additionalHeaders,
+ final OnRequestComplete callback) {
+ if (getBlockingExecutor() == null || getNonBlockingExecutor() == null) {
+ throw new IllegalStateException("Must set blocking and non-blocking executors");
+ }
+ final Callback urlCallback =
+ new Callback() {
+ PoolingByteArrayOutputStream bytesReceived = null;
+ WritableByteChannel receiveChannel = null;
+
+ @Override
+ public void onRedirectReceived(
+ UrlRequest urlRequest,
+ UrlResponseInfo urlResponseInfo,
+ String newLocationUrl) {
+ urlRequest.followRedirect();
+ }
+
+ @Override
+ public void onResponseStarted(
+ UrlRequest urlRequest, UrlResponseInfo urlResponseInfo) {
+ bytesReceived =
+ new PoolingByteArrayOutputStream(
+ mPool, getContentLength(urlResponseInfo));
+ receiveChannel = Channels.newChannel(bytesReceived);
+ urlRequest.read(ByteBuffer.allocateDirect(1024));
+ }
+
+ @Override
+ public void onReadCompleted(
+ UrlRequest urlRequest,
+ UrlResponseInfo urlResponseInfo,
+ ByteBuffer byteBuffer) {
+ byteBuffer.flip();
+ try {
+ receiveChannel.write(byteBuffer);
+ byteBuffer.clear();
+ urlRequest.read(byteBuffer);
+ } catch (IOException e) {
+ urlRequest.cancel();
+ callback.onError(e);
+ }
+ }
+
+ @Override
+ public void onSucceeded(
+ UrlRequest urlRequest, UrlResponseInfo urlResponseInfo) {
+ List<Header> headers = getHeaders(urlResponseInfo.getAllHeadersAsList());
+ HttpResponse response =
+ new HttpResponse(
+ urlResponseInfo.getHttpStatusCode(),
+ headers,
+ bytesReceived.toByteArray());
+ callback.onSuccess(response);
+ }
+
+ @Override
+ public void onFailed(
+ UrlRequest urlRequest,
+ UrlResponseInfo urlResponseInfo,
+ CronetException e) {
+ callback.onError(e);
+ }
+ };
+
+ String url = request.getUrl();
+ String rewritten = mUrlRewriter.rewriteUrl(url);
+ if (rewritten == null) {
+ callback.onError(new IOException("URL blocked by rewriter: " + url));
+ return;
+ }
+ url = rewritten;
+
+ // We can call allowDirectExecutor here and run directly on the network thread, since all
+ // the callbacks are non-blocking.
+ final UrlRequest.Builder builder =
+ mCronetEngine
+ .newUrlRequestBuilder(url, urlCallback, getNonBlockingExecutor())
+ .allowDirectExecutor()
+ .disableCache()
+ .setPriority(getPriority(request));
+ // request.getHeaders() may be blocking, so submit it to the blocking executor.
+ getBlockingExecutor()
+ .execute(
+ new SetUpRequestTask<>(request, url, builder, additionalHeaders, callback));
+ }
+
+ private class SetUpRequestTask<T> extends RequestTask<T> {
+ UrlRequest.Builder builder;
+ String url;
+ Map<String, String> additionalHeaders;
+ OnRequestComplete callback;
+ Request<T> request;
+
+ SetUpRequestTask(
+ Request<T> request,
+ String url,
+ UrlRequest.Builder builder,
+ Map<String, String> additionalHeaders,
+ OnRequestComplete callback) {
+ super(request);
+ // Note that this URL may be different from Request#getUrl() due to the UrlRewriter.
+ this.url = url;
+ this.builder = builder;
+ this.additionalHeaders = additionalHeaders;
+ this.callback = callback;
+ this.request = request;
+ }
+
+ @Override
+ public void run() {
+ try {
+ mRequestListener.onRequestPrepared(request, builder);
+ CurlLoggedRequestParameters requestParameters = new CurlLoggedRequestParameters();
+ setHttpMethod(requestParameters, request);
+ setRequestHeaders(requestParameters, request, additionalHeaders);
+ requestParameters.applyToRequest(builder, getNonBlockingExecutor());
+ UrlRequest urlRequest = builder.build();
+ if (mCurlLoggingEnabled) {
+ mCurlCommandLogger.logCurlCommand(generateCurlCommand(url, requestParameters));
+ }
+ urlRequest.start();
+ } catch (AuthFailureError authFailureError) {
+ callback.onAuthError(authFailureError);
+ }
+ }
+ }
+
+ @VisibleForTesting
+ public static List<Header> getHeaders(List<Map.Entry<String, String>> headersList) {
+ List<Header> headers = new ArrayList<>();
+ for (Map.Entry<String, String> header : headersList) {
+ headers.add(new Header(header.getKey(), header.getValue()));
+ }
+ return headers;
+ }
+
+ /** Sets the connection parameters for the UrlRequest */
+ private void setHttpMethod(CurlLoggedRequestParameters requestParameters, Request<?> request)
+ throws AuthFailureError {
+ switch (request.getMethod()) {
+ case Request.Method.DEPRECATED_GET_OR_POST:
+ // This is the deprecated way that needs to be handled for backwards compatibility.
+ // If the request's post body is null, then the assumption is that the request is
+ // GET. Otherwise, it is assumed that the request is a POST.
+ byte[] postBody = request.getPostBody();
+ if (postBody != null) {
+ requestParameters.setHttpMethod("POST");
+ addBodyIfExists(requestParameters, request.getPostBodyContentType(), postBody);
+ } else {
+ requestParameters.setHttpMethod("GET");
+ }
+ break;
+ case Request.Method.GET:
+ // Not necessary to set the request method because connection defaults to GET but
+ // being explicit here.
+ requestParameters.setHttpMethod("GET");
+ break;
+ case Request.Method.DELETE:
+ requestParameters.setHttpMethod("DELETE");
+ break;
+ case Request.Method.POST:
+ requestParameters.setHttpMethod("POST");
+ addBodyIfExists(requestParameters, request.getBodyContentType(), request.getBody());
+ break;
+ case Request.Method.PUT:
+ requestParameters.setHttpMethod("PUT");
+ addBodyIfExists(requestParameters, request.getBodyContentType(), request.getBody());
+ break;
+ case Request.Method.HEAD:
+ requestParameters.setHttpMethod("HEAD");
+ break;
+ case Request.Method.OPTIONS:
+ requestParameters.setHttpMethod("OPTIONS");
+ break;
+ case Request.Method.TRACE:
+ requestParameters.setHttpMethod("TRACE");
+ break;
+ case Request.Method.PATCH:
+ requestParameters.setHttpMethod("PATCH");
+ addBodyIfExists(requestParameters, request.getBodyContentType(), request.getBody());
+ break;
+ default:
+ throw new IllegalStateException("Unknown method type.");
+ }
+ }
+
+ /**
+ * Sets the request headers for the UrlRequest.
+ *
+ * @param requestParameters parameters that we are adding the request headers to
+ * @param request to get the headers from
+ * @param additionalHeaders for the UrlRequest
+ * @throws AuthFailureError is thrown if Request#getHeaders throws ones
+ */
+ private void setRequestHeaders(
+ CurlLoggedRequestParameters requestParameters,
+ Request<?> request,
+ Map<String, String> additionalHeaders)
+ throws AuthFailureError {
+ requestParameters.putAllHeaders(additionalHeaders);
+ // Request.getHeaders() takes precedence over the given additional (cache) headers).
+ requestParameters.putAllHeaders(request.getHeaders());
+ }
+
+ /** Sets the UploadDataProvider of the UrlRequest.Builder */
+ private void addBodyIfExists(
+ CurlLoggedRequestParameters requestParameters,
+ String contentType,
+ @Nullable byte[] body) {
+ requestParameters.setBody(contentType, body);
+ }
+
+ /** Helper method that maps Volley's request priority to Cronet's */
+ private int getPriority(Request<?> request) {
+ switch (request.getPriority()) {
+ case LOW:
+ return UrlRequest.Builder.REQUEST_PRIORITY_LOW;
+ case HIGH:
+ case IMMEDIATE:
+ return UrlRequest.Builder.REQUEST_PRIORITY_HIGHEST;
+ case NORMAL:
+ default:
+ return UrlRequest.Builder.REQUEST_PRIORITY_MEDIUM;
+ }
+ }
+
+ private int getContentLength(UrlResponseInfo urlResponseInfo) {
+ List<String> content = urlResponseInfo.getAllHeaders().get("Content-Length");
+ if (content == null) {
+ return 1024;
+ } else {
+ return Integer.parseInt(content.get(0));
+ }
+ }
+
+ private String generateCurlCommand(String url, CurlLoggedRequestParameters requestParameters) {
+ StringBuilder builder = new StringBuilder("curl ");
+
+ // HTTP method
+ builder.append("-X ").append(requestParameters.getHttpMethod()).append(" ");
+
+ // Request headers
+ for (Map.Entry<String, String> header : requestParameters.getHeaders().entrySet()) {
+ builder.append("--header \"").append(header.getKey()).append(": ");
+ if (!mLogAuthTokensInCurlCommands
+ && ("Authorization".equals(header.getKey())
+ || "Cookie".equals(header.getKey()))) {
+ builder.append("[REDACTED]");
+ } else {
+ builder.append(header.getValue());
+ }
+ builder.append("\" ");
+ }
+
+ // URL
+ builder.append("\"").append(url).append("\"");
+
+ // Request body (if any)
+ if (requestParameters.getBody() != null) {
+ if (requestParameters.getBody().length >= 1024) {
+ builder.append(" [REQUEST BODY TOO LARGE TO INCLUDE]");
+ } else if (isBinaryContentForLogging(requestParameters)) {
+ String base64 = Base64.encodeToString(requestParameters.getBody(), Base64.NO_WRAP);
+ builder.insert(0, "echo '" + base64 + "' | base64 -d > /tmp/$$.bin; ")
+ .append(" --data-binary @/tmp/$$.bin");
+ } else {
+ // Just assume the request body is UTF-8 since this is for debugging.
+ try {
+ builder.append(" --data-ascii \"")
+ .append(new String(requestParameters.getBody(), "UTF-8"))
+ .append("\"");
+ } catch (UnsupportedEncodingException e) {
+ throw new RuntimeException("Could not encode to UTF-8", e);
+ }
+ }
+ }
+
+ return builder.toString();
+ }
+
+ /** Rough heuristic to determine whether the request body is binary, for logging purposes. */
+ private boolean isBinaryContentForLogging(CurlLoggedRequestParameters requestParameters) {
+ // Check to see if the content is gzip compressed - this means it should be treated as
+ // binary content regardless of the content type.
+ String contentEncoding = requestParameters.getHeaders().get("Content-Encoding");
+ if (contentEncoding != null) {
+ String[] encodings = TextUtils.split(contentEncoding, ",");
+ for (String encoding : encodings) {
+ if ("gzip".equals(encoding.trim())) {
+ return true;
+ }
+ }
+ }
+
+ // If the content type is a known text type, treat it as text content.
+ String contentType = requestParameters.getHeaders().get("Content-Type");
+ if (contentType != null) {
+ return !contentType.startsWith("text/")
+ && !contentType.startsWith("application/xml")
+ && !contentType.startsWith("application/json");
+ }
+
+ // Otherwise, assume it is binary content.
+ return true;
+ }
+
+ /**
+ * Builder is used to build an instance of {@link CronetHttpStack} from values configured by the
+ * setters.
+ */
+ public static class Builder {
+ private static final int DEFAULT_POOL_SIZE = 4096;
+ private CronetEngine mCronetEngine;
+ private final Context context;
+ private ByteArrayPool mPool;
+ private UrlRewriter mUrlRewriter;
+ private RequestListener mRequestListener;
+ private boolean mCurlLoggingEnabled;
+ private CurlCommandLogger mCurlCommandLogger;
+ private boolean mLogAuthTokensInCurlCommands;
+
+ public Builder(Context context) {
+ this.context = context;
+ }
+
+ /** Sets the CronetEngine to be used. Defaults to a vanialla CronetEngine. */
+ public Builder setCronetEngine(CronetEngine engine) {
+ mCronetEngine = engine;
+ return this;
+ }
+
+ /** Sets the ByteArrayPool to be used. Defaults to a new pool with 4096 bytes. */
+ public Builder setPool(ByteArrayPool pool) {
+ mPool = pool;
+ return this;
+ }
+
+ /** Sets the UrlRewriter to be used. Default is to return the original string. */
+ public Builder setUrlRewriter(UrlRewriter urlRewriter) {
+ mUrlRewriter = urlRewriter;
+ return this;
+ }
+
+ /** Set the optional RequestListener to be used. */
+ public Builder setRequestListener(RequestListener requestListener) {
+ mRequestListener = requestListener;
+ return this;
+ }
+
+ /**
+ * Sets whether cURL logging should be enabled for debugging purposes.
+ *
+ * <p>When enabled, for each request dispatched to the network, a roughly-equivalent cURL
+ * command will be logged to logcat.
+ *
+ * <p>The command may be missing some headers that are added by Cronet automatically, and
+ * the full request body may not be included if it is too large. To inspect the full
+ * requests and responses, see {@code CronetEngine#startNetLogToFile}.
+ *
+ * <p>WARNING: This is only intended for debugging purposes and should never be enabled on
+ * production devices.
+ *
+ * @see #setCurlCommandLogger(CurlCommandLogger)
+ * @see #setLogAuthTokensInCurlCommands(boolean)
+ */
+ public Builder setCurlLoggingEnabled(boolean curlLoggingEnabled) {
+ mCurlLoggingEnabled = curlLoggingEnabled;
+ return this;
+ }
+
+ /**
+ * Sets the function used to log cURL commands.
+ *
+ * <p>Allows customization of the logging performed when cURL logging is enabled.
+ *
+ * <p>By default, when cURL logging is enabled, cURL commands are logged using {@link
+ * VolleyLog#v}, e.g. at the verbose log level with the same log tag used by the rest of
+ * Volley. This function may optionally be invoked to provide a custom logger.
+ *
+ * @see #setCurlLoggingEnabled(boolean)
+ */
+ public Builder setCurlCommandLogger(CurlCommandLogger curlCommandLogger) {
+ mCurlCommandLogger = curlCommandLogger;
+ return this;
+ }
+
+ /**
+ * Sets whether to log known auth tokens in cURL commands, or redact them.
+ *
+ * <p>By default, headers which may contain auth tokens (e.g. Authorization or Cookie) will
+ * have their values redacted. Passing true to this method will disable this redaction and
+ * log the values of these headers.
+ *
+ * <p>This heuristic is not perfect; tokens that are logged in unknown headers, or in the
+ * request body itself, will not be redacted as they cannot be detected generically.
+ *
+ * @see #setCurlLoggingEnabled(boolean)
+ */
+ public Builder setLogAuthTokensInCurlCommands(boolean logAuthTokensInCurlCommands) {
+ mLogAuthTokensInCurlCommands = logAuthTokensInCurlCommands;
+ return this;
+ }
+
+ public CronetHttpStack build() {
+ if (mCronetEngine == null) {
+ mCronetEngine = new CronetEngine.Builder(context).build();
+ }
+ if (mUrlRewriter == null) {
+ mUrlRewriter =
+ new UrlRewriter() {
+ @Override
+ public String rewriteUrl(String originalUrl) {
+ return originalUrl;
+ }
+ };
+ }
+ if (mRequestListener == null) {
+ mRequestListener = new RequestListener() {};
+ }
+ if (mPool == null) {
+ mPool = new ByteArrayPool(DEFAULT_POOL_SIZE);
+ }
+ if (mCurlCommandLogger == null) {
+ mCurlCommandLogger =
+ new CurlCommandLogger() {
+ @Override
+ public void logCurlCommand(String curlCommand) {
+ VolleyLog.v(curlCommand);
+ }
+ };
+ }
+ return new CronetHttpStack(
+ mCronetEngine,
+ mPool,
+ mUrlRewriter,
+ mRequestListener,
+ mCurlLoggingEnabled,
+ mCurlCommandLogger,
+ mLogAuthTokensInCurlCommands);
+ }
+ }
+
+ /** Callback interface allowing clients to intercept different parts of the request flow. */
+ public abstract static class RequestListener {
+ private CronetHttpStack mStack;
+
+ void initialize(CronetHttpStack stack) {
+ mStack = stack;
+ }
+
+ /**
+ * Called when a request is prepared and about to be sent over the network.
+ *
+ * <p>Clients may use this callback to customize UrlRequests before they are dispatched,
+ * e.g. to enable socket tagging or request finished listeners.
+ */
+ public void onRequestPrepared(Request<?> request, UrlRequest.Builder requestBuilder) {}
+
+ /** @see AsyncHttpStack#getNonBlockingExecutor() */
+ protected Executor getNonBlockingExecutor() {
+ return mStack.getNonBlockingExecutor();
+ }
+
+ /** @see AsyncHttpStack#getBlockingExecutor() */
+ protected Executor getBlockingExecutor() {
+ return mStack.getBlockingExecutor();
+ }
+ }
+
+ /**
+ * Interface for logging cURL commands for requests.
+ *
+ * @see Builder#setCurlCommandLogger(CurlCommandLogger)
+ */
+ public interface CurlCommandLogger {
+ /** Log the given cURL command. */
+ void logCurlCommand(String curlCommand);
+ }
+
+ /**
+ * Internal container class for request parameters that impact logged cURL commands.
+ *
+ * <p>When cURL logging is enabled, an equivalent cURL command to a given request must be
+ * generated and logged. However, the Cronet UrlRequest object is write-only. So, we write any
+ * relevant parameters into this read-write container so they can be referenced when generating
+ * the cURL command (if needed) and then merged into the UrlRequest.
+ */
+ private static class CurlLoggedRequestParameters {
+ private final TreeMap<String, String> mHeaders =
+ new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+ private String mHttpMethod;
+ @Nullable private byte[] mBody;
+
+ /**
+ * Return the headers to be used for the request.
+ *
+ * <p>The returned map is case-insensitive.
+ */
+ TreeMap<String, String> getHeaders() {
+ return mHeaders;
+ }
+
+ /** Apply all the headers in the given map to the request. */
+ void putAllHeaders(Map<String, String> headers) {
+ mHeaders.putAll(headers);
+ }
+
+ String getHttpMethod() {
+ return mHttpMethod;
+ }
+
+ void setHttpMethod(String httpMethod) {
+ mHttpMethod = httpMethod;
+ }
+
+ @Nullable
+ byte[] getBody() {
+ return mBody;
+ }
+
+ void setBody(String contentType, @Nullable byte[] body) {
+ mBody = body;
+ if (body != null && !mHeaders.containsKey(HttpHeaderParser.HEADER_CONTENT_TYPE)) {
+ // Set the content-type unless it was already set (by Request#getHeaders).
+ mHeaders.put(HttpHeaderParser.HEADER_CONTENT_TYPE, contentType);
+ }
+ }
+
+ void applyToRequest(UrlRequest.Builder builder, ExecutorService nonBlockingExecutor) {
+ for (Map.Entry<String, String> header : mHeaders.entrySet()) {
+ builder.addHeader(header.getKey(), header.getValue());
+ }
+ builder.setHttpMethod(mHttpMethod);
+ if (mBody != null) {
+ UploadDataProvider dataProvider = UploadDataProviders.create(mBody);
+ builder.setUploadDataProvider(dataProvider, nonBlockingExecutor);
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/android/volley/toolbox/AsyncHttpStack.java b/src/main/java/com/android/volley/toolbox/AsyncHttpStack.java
new file mode 100644
index 0000000..bafab8c
--- /dev/null
+++ b/src/main/java/com/android/volley/toolbox/AsyncHttpStack.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley.toolbox;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import com.android.volley.AuthFailureError;
+import com.android.volley.Request;
+import com.android.volley.VolleyLog;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.atomic.AtomicReference;
+
+/** Asynchronous extension of the {@link BaseHttpStack} class. */
+public abstract class AsyncHttpStack extends BaseHttpStack {
+ private ExecutorService mBlockingExecutor;
+ private ExecutorService mNonBlockingExecutor;
+
+ public interface OnRequestComplete {
+ /** Invoked when the stack successfully completes a request. */
+ void onSuccess(HttpResponse httpResponse);
+
+ /** Invoked when the stack throws an {@link AuthFailureError} during a request. */
+ void onAuthError(AuthFailureError authFailureError);
+
+ /** Invoked when the stack throws an {@link IOException} during a request. */
+ void onError(IOException ioException);
+ }
+
+ /**
+ * Makes an HTTP request with the given parameters, and calls the {@link OnRequestComplete}
+ * callback, with either the {@link HttpResponse} or error that was thrown.
+ *
+ * @param request to perform
+ * @param additionalHeaders to be sent together with {@link Request#getHeaders()}
+ * @param callback to be called after retrieving the {@link HttpResponse} or throwing an error.
+ */
+ public abstract void executeRequest(
+ Request<?> request, Map<String, String> additionalHeaders, OnRequestComplete callback);
+
+ /**
+ * This method sets the non blocking executor to be used by the stack for non-blocking tasks.
+ * This method must be called before executing any requests.
+ */
+ @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+ public void setNonBlockingExecutor(ExecutorService executor) {
+ mNonBlockingExecutor = executor;
+ }
+
+ /**
+ * This method sets the blocking executor to be used by the stack for potentially blocking
+ * tasks. This method must be called before executing any requests.
+ */
+ @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+ public void setBlockingExecutor(ExecutorService executor) {
+ mBlockingExecutor = executor;
+ }
+
+ /** Gets blocking executor to perform any potentially blocking tasks. */
+ protected ExecutorService getBlockingExecutor() {
+ return mBlockingExecutor;
+ }
+
+ /** Gets non-blocking executor to perform any non-blocking tasks. */
+ protected ExecutorService getNonBlockingExecutor() {
+ return mNonBlockingExecutor;
+ }
+
+ /**
+ * Performs an HTTP request with the given parameters.
+ *
+ * @param request the request to perform
+ * @param additionalHeaders additional headers to be sent together with {@link
+ * Request#getHeaders()}
+ * @return the {@link HttpResponse}
+ * @throws IOException if an I/O error occurs during the request
+ * @throws AuthFailureError if an authentication failure occurs during the request
+ */
+ @Override
+ public final HttpResponse executeRequest(
+ Request<?> request, Map<String, String> additionalHeaders)
+ throws IOException, AuthFailureError {
+ final CountDownLatch latch = new CountDownLatch(1);
+ final AtomicReference<Response> entry = new AtomicReference<>();
+ executeRequest(
+ request,
+ additionalHeaders,
+ new OnRequestComplete() {
+ @Override
+ public void onSuccess(HttpResponse httpResponse) {
+ Response response =
+ new Response(
+ httpResponse,
+ /* ioException= */ null,
+ /* authFailureError= */ null);
+ entry.set(response);
+ latch.countDown();
+ }
+
+ @Override
+ public void onAuthError(AuthFailureError authFailureError) {
+ Response response =
+ new Response(
+ /* httpResponse= */ null,
+ /* ioException= */ null,
+ authFailureError);
+ entry.set(response);
+ latch.countDown();
+ }
+
+ @Override
+ public void onError(IOException ioException) {
+ Response response =
+ new Response(
+ /* httpResponse= */ null,
+ ioException,
+ /* authFailureError= */ null);
+ entry.set(response);
+ latch.countDown();
+ }
+ });
+ try {
+ latch.await();
+ } catch (InterruptedException e) {
+ VolleyLog.e(e, "while waiting for CountDownLatch");
+ Thread.currentThread().interrupt();
+ throw new InterruptedIOException(e.toString());
+ }
+ Response response = entry.get();
+ if (response.httpResponse != null) {
+ return response.httpResponse;
+ } else if (response.ioException != null) {
+ throw response.ioException;
+ } else {
+ throw response.authFailureError;
+ }
+ }
+
+ private static class Response {
+ HttpResponse httpResponse;
+ IOException ioException;
+ AuthFailureError authFailureError;
+
+ private Response(
+ @Nullable HttpResponse httpResponse,
+ @Nullable IOException ioException,
+ @Nullable AuthFailureError authFailureError) {
+ this.httpResponse = httpResponse;
+ this.ioException = ioException;
+ this.authFailureError = authFailureError;
+ }
+ }
+}
diff --git a/src/main/java/com/android/volley/toolbox/BasicAsyncNetwork.java b/src/main/java/com/android/volley/toolbox/BasicAsyncNetwork.java
new file mode 100644
index 0000000..55892a0
--- /dev/null
+++ b/src/main/java/com/android/volley/toolbox/BasicAsyncNetwork.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley.toolbox;
+
+import static com.android.volley.toolbox.NetworkUtility.logSlowRequests;
+
+import android.os.SystemClock;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import com.android.volley.AsyncNetwork;
+import com.android.volley.AuthFailureError;
+import com.android.volley.Header;
+import com.android.volley.NetworkResponse;
+import com.android.volley.Request;
+import com.android.volley.RequestTask;
+import com.android.volley.VolleyError;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+
+/** A network performing Volley requests over an {@link HttpStack}. */
+public class BasicAsyncNetwork extends AsyncNetwork {
+
+ private final AsyncHttpStack mAsyncStack;
+ private final ByteArrayPool mPool;
+
+ /**
+ * @param httpStack HTTP stack to be used
+ * @param pool a buffer pool that improves GC performance in copy operations
+ */
+ private BasicAsyncNetwork(AsyncHttpStack httpStack, ByteArrayPool pool) {
+ mAsyncStack = httpStack;
+ mPool = pool;
+ }
+
+ @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+ @Override
+ public void setBlockingExecutor(ExecutorService executor) {
+ super.setBlockingExecutor(executor);
+ mAsyncStack.setBlockingExecutor(executor);
+ }
+
+ @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+ @Override
+ public void setNonBlockingExecutor(ExecutorService executor) {
+ super.setNonBlockingExecutor(executor);
+ mAsyncStack.setNonBlockingExecutor(executor);
+ }
+
+ /* Method to be called after a successful network request */
+ private void onRequestSucceeded(
+ final Request<?> request,
+ final long requestStartMs,
+ final HttpResponse httpResponse,
+ final OnRequestComplete callback) {
+ final int statusCode = httpResponse.getStatusCode();
+ final List<Header> responseHeaders = httpResponse.getHeaders();
+ // Handle cache validation.
+ if (statusCode == HttpURLConnection.HTTP_NOT_MODIFIED) {
+ long requestDuration = SystemClock.elapsedRealtime() - requestStartMs;
+ callback.onSuccess(
+ NetworkUtility.getNotModifiedNetworkResponse(
+ request, requestDuration, responseHeaders));
+ return;
+ }
+
+ byte[] responseContents = httpResponse.getContentBytes();
+ if (responseContents == null && httpResponse.getContent() == null) {
+ // Add 0 byte response as a way of honestly representing a
+ // no-content request.
+ responseContents = new byte[0];
+ }
+
+ if (responseContents != null) {
+ onResponseRead(
+ requestStartMs,
+ statusCode,
+ httpResponse,
+ request,
+ callback,
+ responseHeaders,
+ responseContents);
+ return;
+ }
+
+ // The underlying AsyncHttpStack does not support asynchronous reading of the response into
+ // a byte array, so we need to submit a blocking task to copy the response from the
+ // InputStream instead.
+ final InputStream inputStream = httpResponse.getContent();
+ getBlockingExecutor()
+ .execute(
+ new ResponseParsingTask<>(
+ inputStream,
+ httpResponse,
+ request,
+ callback,
+ requestStartMs,
+ responseHeaders,
+ statusCode));
+ }
+
+ /* Method to be called after a failed network request */
+ private void onRequestFailed(
+ Request<?> request,
+ OnRequestComplete callback,
+ IOException exception,
+ long requestStartMs,
+ @Nullable HttpResponse httpResponse,
+ @Nullable byte[] responseContents) {
+ try {
+ NetworkUtility.handleException(
+ request, exception, requestStartMs, httpResponse, responseContents);
+ } catch (VolleyError volleyError) {
+ callback.onError(volleyError);
+ return;
+ }
+ performRequest(request, callback);
+ }
+
+ @Override
+ public void performRequest(final Request<?> request, final OnRequestComplete callback) {
+ if (getBlockingExecutor() == null) {
+ throw new IllegalStateException(
+ "mBlockingExecuter must be set before making a request");
+ }
+ final long requestStartMs = SystemClock.elapsedRealtime();
+ // Gather headers.
+ final Map<String, String> additionalRequestHeaders =
+ HttpHeaderParser.getCacheHeaders(request.getCacheEntry());
+ mAsyncStack.executeRequest(
+ request,
+ additionalRequestHeaders,
+ new AsyncHttpStack.OnRequestComplete() {
+ @Override
+ public void onSuccess(HttpResponse httpResponse) {
+ onRequestSucceeded(request, requestStartMs, httpResponse, callback);
+ }
+
+ @Override
+ public void onAuthError(AuthFailureError authFailureError) {
+ callback.onError(authFailureError);
+ }
+
+ @Override
+ public void onError(IOException ioException) {
+ onRequestFailed(
+ request,
+ callback,
+ ioException,
+ requestStartMs,
+ /* httpResponse= */ null,
+ /* responseContents= */ null);
+ }
+ });
+ }
+
+ /* Helper method that determines what to do after byte[] is received */
+ private void onResponseRead(
+ long requestStartMs,
+ int statusCode,
+ HttpResponse httpResponse,
+ Request<?> request,
+ OnRequestComplete callback,
+ List<Header> responseHeaders,
+ byte[] responseContents) {
+ // if the request is slow, log it.
+ long requestLifetime = SystemClock.elapsedRealtime() - requestStartMs;
+ logSlowRequests(requestLifetime, request, responseContents, statusCode);
+
+ if (statusCode < 200 || statusCode > 299) {
+ onRequestFailed(
+ request,
+ callback,
+ new IOException(),
+ requestStartMs,
+ httpResponse,
+ responseContents);
+ return;
+ }
+
+ callback.onSuccess(
+ new NetworkResponse(
+ statusCode,
+ responseContents,
+ /* notModified= */ false,
+ SystemClock.elapsedRealtime() - requestStartMs,
+ responseHeaders));
+ }
+
+ private class ResponseParsingTask<T> extends RequestTask<T> {
+ InputStream inputStream;
+ HttpResponse httpResponse;
+ Request<T> request;
+ OnRequestComplete callback;
+ long requestStartMs;
+ List<Header> responseHeaders;
+ int statusCode;
+
+ ResponseParsingTask(
+ InputStream inputStream,
+ HttpResponse httpResponse,
+ Request<T> request,
+ OnRequestComplete callback,
+ long requestStartMs,
+ List<Header> responseHeaders,
+ int statusCode) {
+ super(request);
+ this.inputStream = inputStream;
+ this.httpResponse = httpResponse;
+ this.request = request;
+ this.callback = callback;
+ this.requestStartMs = requestStartMs;
+ this.responseHeaders = responseHeaders;
+ this.statusCode = statusCode;
+ }
+
+ @Override
+ public void run() {
+ byte[] finalResponseContents;
+ try {
+ finalResponseContents =
+ NetworkUtility.inputStreamToBytes(
+ inputStream, httpResponse.getContentLength(), mPool);
+ } catch (IOException e) {
+ onRequestFailed(request, callback, e, requestStartMs, httpResponse, null);
+ return;
+ }
+ onResponseRead(
+ requestStartMs,
+ statusCode,
+ httpResponse,
+ request,
+ callback,
+ responseHeaders,
+ finalResponseContents);
+ }
+ }
+
+ /**
+ * Builder is used to build an instance of {@link BasicAsyncNetwork} from values configured by
+ * the setters.
+ */
+ public static class Builder {
+ private static final int DEFAULT_POOL_SIZE = 4096;
+ @NonNull private AsyncHttpStack mAsyncStack;
+ private ByteArrayPool mPool;
+
+ public Builder(@NonNull AsyncHttpStack httpStack) {
+ mAsyncStack = httpStack;
+ mPool = null;
+ }
+
+ /**
+ * Sets the ByteArrayPool to be used. If not set, it will default to a pool with the default
+ * pool size.
+ */
+ public Builder setPool(ByteArrayPool pool) {
+ mPool = pool;
+ return this;
+ }
+
+ /** Builds the {@link com.android.volley.toolbox.BasicAsyncNetwork} */
+ public BasicAsyncNetwork build() {
+ if (mPool == null) {
+ mPool = new ByteArrayPool(DEFAULT_POOL_SIZE);
+ }
+ return new BasicAsyncNetwork(mAsyncStack, mPool);
+ }
+ }
+}
diff --git a/src/main/java/com/android/volley/toolbox/BasicNetwork.java b/src/main/java/com/android/volley/toolbox/BasicNetwork.java
index b527cb9..06427fe 100644
--- a/src/main/java/com/android/volley/toolbox/BasicNetwork.java
+++ b/src/main/java/com/android/volley/toolbox/BasicNetwork.java
@@ -17,41 +17,21 @@
package com.android.volley.toolbox;
import android.os.SystemClock;
-import com.android.volley.AuthFailureError;
-import com.android.volley.Cache;
-import com.android.volley.Cache.Entry;
-import com.android.volley.ClientError;
import com.android.volley.Header;
import com.android.volley.Network;
-import com.android.volley.NetworkError;
import com.android.volley.NetworkResponse;
-import com.android.volley.NoConnectionError;
import com.android.volley.Request;
-import com.android.volley.RetryPolicy;
-import com.android.volley.ServerError;
-import com.android.volley.TimeoutError;
import com.android.volley.VolleyError;
-import com.android.volley.VolleyLog;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
-import java.net.MalformedURLException;
-import java.net.SocketTimeoutException;
-import java.util.ArrayList;
import java.util.Collections;
-import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.Set;
import java.util.TreeMap;
-import java.util.TreeSet;
/** A network performing Volley requests over an {@link HttpStack}. */
public class BasicNetwork implements Network {
- protected static final boolean DEBUG = VolleyLog.DEBUG;
-
- private static final int SLOW_REQUEST_THRESHOLD_MS = 3000;
-
private static final int DEFAULT_POOL_SIZE = 4096;
/**
@@ -119,37 +99,24 @@
try {
// Gather headers.
Map<String, String> additionalRequestHeaders =
- getCacheHeaders(request.getCacheEntry());
+ HttpHeaderParser.getCacheHeaders(request.getCacheEntry());
httpResponse = mBaseHttpStack.executeRequest(request, additionalRequestHeaders);
int statusCode = httpResponse.getStatusCode();
responseHeaders = httpResponse.getHeaders();
// Handle cache validation.
if (statusCode == HttpURLConnection.HTTP_NOT_MODIFIED) {
- Entry entry = request.getCacheEntry();
- if (entry == null) {
- return new NetworkResponse(
- HttpURLConnection.HTTP_NOT_MODIFIED,
- /* data= */ null,
- /* notModified= */ true,
- SystemClock.elapsedRealtime() - requestStart,
- responseHeaders);
- }
- // Combine cached and response headers so the response will be complete.
- List<Header> combinedHeaders = combineHeaders(responseHeaders, entry);
- return new NetworkResponse(
- HttpURLConnection.HTTP_NOT_MODIFIED,
- entry.data,
- /* notModified= */ true,
- SystemClock.elapsedRealtime() - requestStart,
- combinedHeaders);
+ long requestDuration = SystemClock.elapsedRealtime() - requestStart;
+ return NetworkUtility.getNotModifiedNetworkResponse(
+ request, requestDuration, responseHeaders);
}
// Some responses such as 204s do not have content. We must check.
InputStream inputStream = httpResponse.getContent();
if (inputStream != null) {
responseContents =
- inputStreamToBytes(inputStream, httpResponse.getContentLength());
+ NetworkUtility.inputStreamToBytes(
+ inputStream, httpResponse.getContentLength(), mPool);
} else {
// Add 0 byte response as a way of honestly representing a
// no-content request.
@@ -158,7 +125,8 @@
// if the request is slow, log it.
long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
- logSlowRequests(requestLifetime, request, responseContents, statusCode);
+ NetworkUtility.logSlowRequests(
+ requestLifetime, request, responseContents, statusCode);
if (statusCode < 200 || statusCode > 299) {
throw new IOException();
@@ -169,144 +137,15 @@
/* notModified= */ false,
SystemClock.elapsedRealtime() - requestStart,
responseHeaders);
- } catch (SocketTimeoutException e) {
- attemptRetryOnException("socket", request, new TimeoutError());
- } catch (MalformedURLException e) {
- throw new RuntimeException("Bad URL " + request.getUrl(), e);
} catch (IOException e) {
- int statusCode;
- if (httpResponse != null) {
- statusCode = httpResponse.getStatusCode();
- } else {
- throw new NoConnectionError(e);
- }
- VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());
- NetworkResponse networkResponse;
- if (responseContents != null) {
- networkResponse =
- new NetworkResponse(
- statusCode,
- responseContents,
- /* notModified= */ false,
- SystemClock.elapsedRealtime() - requestStart,
- responseHeaders);
- if (statusCode == HttpURLConnection.HTTP_UNAUTHORIZED
- || statusCode == HttpURLConnection.HTTP_FORBIDDEN) {
- attemptRetryOnException(
- "auth", request, new AuthFailureError(networkResponse));
- } else if (statusCode >= 400 && statusCode <= 499) {
- // Don't retry other client errors.
- throw new ClientError(networkResponse);
- } else if (statusCode >= 500 && statusCode <= 599) {
- if (request.shouldRetryServerErrors()) {
- attemptRetryOnException(
- "server", request, new ServerError(networkResponse));
- } else {
- throw new ServerError(networkResponse);
- }
- } else {
- // 3xx? No reason to retry.
- throw new ServerError(networkResponse);
- }
- } else {
- attemptRetryOnException("network", request, new NetworkError());
- }
+ // This will either throw an exception, breaking us from the loop, or will loop
+ // again and retry the request.
+ NetworkUtility.handleException(
+ request, e, requestStart, httpResponse, responseContents);
}
}
}
- /** Logs requests that took over SLOW_REQUEST_THRESHOLD_MS to complete. */
- private void logSlowRequests(
- long requestLifetime, Request<?> request, byte[] responseContents, int statusCode) {
- if (DEBUG || requestLifetime > SLOW_REQUEST_THRESHOLD_MS) {
- VolleyLog.d(
- "HTTP response for request=<%s> [lifetime=%d], [size=%s], "
- + "[rc=%d], [retryCount=%s]",
- request,
- requestLifetime,
- responseContents != null ? responseContents.length : "null",
- statusCode,
- request.getRetryPolicy().getCurrentRetryCount());
- }
- }
-
- /**
- * Attempts to prepare the request for a retry. If there are no more attempts remaining in the
- * request's retry policy, a timeout exception is thrown.
- *
- * @param request The request to use.
- */
- private static void attemptRetryOnException(
- String logPrefix, Request<?> request, VolleyError exception) throws VolleyError {
- RetryPolicy retryPolicy = request.getRetryPolicy();
- int oldTimeout = request.getTimeoutMs();
-
- try {
- retryPolicy.retry(exception);
- } catch (VolleyError e) {
- request.addMarker(
- String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout));
- throw e;
- }
- request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout));
- }
-
- private Map<String, String> getCacheHeaders(Cache.Entry entry) {
- // If there's no cache entry, we're done.
- if (entry == null) {
- return Collections.emptyMap();
- }
-
- Map<String, String> headers = new HashMap<>();
-
- if (entry.etag != null) {
- headers.put("If-None-Match", entry.etag);
- }
-
- if (entry.lastModified > 0) {
- headers.put(
- "If-Modified-Since", HttpHeaderParser.formatEpochAsRfc1123(entry.lastModified));
- }
-
- return headers;
- }
-
- protected void logError(String what, String url, long start) {
- long now = SystemClock.elapsedRealtime();
- VolleyLog.v("HTTP ERROR(%s) %d ms to fetch %s", what, (now - start), url);
- }
-
- /** Reads the contents of an InputStream into a byte[]. */
- private byte[] inputStreamToBytes(InputStream in, int contentLength)
- throws IOException, ServerError {
- PoolingByteArrayOutputStream bytes = new PoolingByteArrayOutputStream(mPool, contentLength);
- byte[] buffer = null;
- try {
- if (in == null) {
- throw new ServerError();
- }
- buffer = mPool.getBuf(1024);
- int count;
- while ((count = in.read(buffer)) != -1) {
- bytes.write(buffer, 0, count);
- }
- return bytes.toByteArray();
- } finally {
- try {
- // Close the InputStream and release the resources by "consuming the content".
- if (in != null) {
- in.close();
- }
- } catch (IOException e) {
- // This can happen if there was an exception above that left the stream in
- // an invalid state.
- VolleyLog.v("Error occurred when closing InputStream");
- }
- mPool.returnBuf(buffer);
- bytes.close();
- }
- }
-
/**
* Converts Headers[] to Map<String, String>.
*
@@ -321,49 +160,4 @@
}
return result;
}
-
- /**
- * Combine cache headers with network response headers for an HTTP 304 response.
- *
- * <p>An HTTP 304 response does not have all header fields. We have to use the header fields
- * from the cache entry plus the new ones from the response. See also:
- * http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5
- *
- * @param responseHeaders Headers from the network response.
- * @param entry The cached response.
- * @return The combined list of headers.
- */
- private static List<Header> combineHeaders(List<Header> responseHeaders, Entry entry) {
- // First, create a case-insensitive set of header names from the network
- // response.
- Set<String> headerNamesFromNetworkResponse = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
- if (!responseHeaders.isEmpty()) {
- for (Header header : responseHeaders) {
- headerNamesFromNetworkResponse.add(header.getName());
- }
- }
-
- // Second, add headers from the cache entry to the network response as long as
- // they didn't appear in the network response, which should take precedence.
- List<Header> combinedHeaders = new ArrayList<>(responseHeaders);
- if (entry.allResponseHeaders != null) {
- if (!entry.allResponseHeaders.isEmpty()) {
- for (Header header : entry.allResponseHeaders) {
- if (!headerNamesFromNetworkResponse.contains(header.getName())) {
- combinedHeaders.add(header);
- }
- }
- }
- } else {
- // Legacy caches only have entry.responseHeaders.
- if (!entry.responseHeaders.isEmpty()) {
- for (Map.Entry<String, String> header : entry.responseHeaders.entrySet()) {
- if (!headerNamesFromNetworkResponse.contains(header.getKey())) {
- combinedHeaders.add(new Header(header.getKey(), header.getValue()));
- }
- }
- }
- }
- return combinedHeaders;
- }
}
diff --git a/src/main/java/com/android/volley/toolbox/FileSupplier.java b/src/main/java/com/android/volley/toolbox/FileSupplier.java
new file mode 100644
index 0000000..70898a6
--- /dev/null
+++ b/src/main/java/com/android/volley/toolbox/FileSupplier.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley.toolbox;
+
+import java.io.File;
+
+/** Represents a supplier for {@link File}s. */
+public interface FileSupplier {
+ File get();
+}
diff --git a/src/main/java/com/android/volley/toolbox/HttpHeaderParser.java b/src/main/java/com/android/volley/toolbox/HttpHeaderParser.java
index 1b410af..0b29e80 100644
--- a/src/main/java/com/android/volley/toolbox/HttpHeaderParser.java
+++ b/src/main/java/com/android/volley/toolbox/HttpHeaderParser.java
@@ -17,6 +17,8 @@
package com.android.volley.toolbox;
import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.RestrictTo.Scope;
import com.android.volley.Cache;
import com.android.volley.Header;
import com.android.volley.NetworkResponse;
@@ -24,17 +26,22 @@
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.Date;
+import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
+import java.util.Set;
import java.util.TimeZone;
import java.util.TreeMap;
+import java.util.TreeSet;
/** Utility methods for parsing HTTP headers. */
public class HttpHeaderParser {
- static final String HEADER_CONTENT_TYPE = "Content-Type";
+ @RestrictTo({Scope.LIBRARY_GROUP})
+ public static final String HEADER_CONTENT_TYPE = "Content-Type";
private static final String DEFAULT_CONTENT_CHARSET = "ISO-8859-1";
@@ -226,4 +233,69 @@
}
return allHeaders;
}
+
+ /**
+ * Combine cache headers with network response headers for an HTTP 304 response.
+ *
+ * <p>An HTTP 304 response does not have all header fields. We have to use the header fields
+ * from the cache entry plus the new ones from the response. See also:
+ * http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5
+ *
+ * @param responseHeaders Headers from the network response.
+ * @param entry The cached response.
+ * @return The combined list of headers.
+ */
+ static List<Header> combineHeaders(List<Header> responseHeaders, Cache.Entry entry) {
+ // First, create a case-insensitive set of header names from the network
+ // response.
+ Set<String> headerNamesFromNetworkResponse = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
+ if (!responseHeaders.isEmpty()) {
+ for (Header header : responseHeaders) {
+ headerNamesFromNetworkResponse.add(header.getName());
+ }
+ }
+
+ // Second, add headers from the cache entry to the network response as long as
+ // they didn't appear in the network response, which should take precedence.
+ List<Header> combinedHeaders = new ArrayList<>(responseHeaders);
+ if (entry.allResponseHeaders != null) {
+ if (!entry.allResponseHeaders.isEmpty()) {
+ for (Header header : entry.allResponseHeaders) {
+ if (!headerNamesFromNetworkResponse.contains(header.getName())) {
+ combinedHeaders.add(header);
+ }
+ }
+ }
+ } else {
+ // Legacy caches only have entry.responseHeaders.
+ if (!entry.responseHeaders.isEmpty()) {
+ for (Map.Entry<String, String> header : entry.responseHeaders.entrySet()) {
+ if (!headerNamesFromNetworkResponse.contains(header.getKey())) {
+ combinedHeaders.add(new Header(header.getKey(), header.getValue()));
+ }
+ }
+ }
+ }
+ return combinedHeaders;
+ }
+
+ static Map<String, String> getCacheHeaders(Cache.Entry entry) {
+ // If there's no cache entry, we're done.
+ if (entry == null) {
+ return Collections.emptyMap();
+ }
+
+ Map<String, String> headers = new HashMap<>();
+
+ if (entry.etag != null) {
+ headers.put("If-None-Match", entry.etag);
+ }
+
+ if (entry.lastModified > 0) {
+ headers.put(
+ "If-Modified-Since", HttpHeaderParser.formatEpochAsRfc1123(entry.lastModified));
+ }
+
+ return headers;
+ }
}
diff --git a/src/main/java/com/android/volley/toolbox/HttpResponse.java b/src/main/java/com/android/volley/toolbox/HttpResponse.java
index 9a9294f..595f926 100644
--- a/src/main/java/com/android/volley/toolbox/HttpResponse.java
+++ b/src/main/java/com/android/volley/toolbox/HttpResponse.java
@@ -15,7 +15,9 @@
*/
package com.android.volley.toolbox;
+import androidx.annotation.Nullable;
import com.android.volley.Header;
+import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.Collections;
import java.util.List;
@@ -26,7 +28,8 @@
private final int mStatusCode;
private final List<Header> mHeaders;
private final int mContentLength;
- private final InputStream mContent;
+ @Nullable private final InputStream mContent;
+ @Nullable private final byte[] mContentBytes;
/**
* Construct a new HttpResponse for an empty response body.
@@ -53,6 +56,23 @@
mHeaders = headers;
mContentLength = contentLength;
mContent = content;
+ mContentBytes = null;
+ }
+
+ /**
+ * Construct a new HttpResponse.
+ *
+ * @param statusCode the HTTP status code of the response
+ * @param headers the response headers
+ * @param contentBytes a byte[] of the response content. This is an optimization for HTTP stacks
+ * that natively support returning a byte[].
+ */
+ public HttpResponse(int statusCode, List<Header> headers, byte[] contentBytes) {
+ mStatusCode = statusCode;
+ mHeaders = headers;
+ mContentLength = contentBytes.length;
+ mContentBytes = contentBytes;
+ mContent = null;
}
/** Returns the HTTP status code of the response. */
@@ -71,10 +91,28 @@
}
/**
+ * If a byte[] was already provided by an HTTP stack that natively supports returning one, this
+ * method will return that byte[] as an optimization over copying the bytes from an input
+ * stream. It may return null, even if the response has content, as long as mContent is
+ * provided.
+ */
+ @Nullable
+ public final byte[] getContentBytes() {
+ return mContentBytes;
+ }
+
+ /**
* Returns an {@link InputStream} of the response content. May be null to indicate that the
* response has no content.
*/
+ @Nullable
public final InputStream getContent() {
- return mContent;
+ if (mContent != null) {
+ return mContent;
+ } else if (mContentBytes != null) {
+ return new ByteArrayInputStream(mContentBytes);
+ } else {
+ return null;
+ }
}
}
diff --git a/src/main/java/com/android/volley/toolbox/HurlStack.java b/src/main/java/com/android/volley/toolbox/HurlStack.java
index 9c38023..35c6a72 100644
--- a/src/main/java/com/android/volley/toolbox/HurlStack.java
+++ b/src/main/java/com/android/volley/toolbox/HurlStack.java
@@ -41,13 +41,7 @@
private static final int HTTP_CONTINUE = 100;
/** An interface for transforming URLs before use. */
- public interface UrlRewriter {
- /**
- * Returns a URL to use instead of the provided one, or null to indicate this URL should not
- * be used at all.
- */
- String rewriteUrl(String originalUrl);
- }
+ public interface UrlRewriter extends com.android.volley.toolbox.UrlRewriter {}
private final UrlRewriter mUrlRewriter;
private final SSLSocketFactory mSslSocketFactory;
diff --git a/src/main/java/com/android/volley/toolbox/NetworkUtility.java b/src/main/java/com/android/volley/toolbox/NetworkUtility.java
new file mode 100644
index 0000000..44d5904
--- /dev/null
+++ b/src/main/java/com/android/volley/toolbox/NetworkUtility.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley.toolbox;
+
+import android.os.SystemClock;
+import androidx.annotation.Nullable;
+import com.android.volley.AuthFailureError;
+import com.android.volley.Cache;
+import com.android.volley.ClientError;
+import com.android.volley.Header;
+import com.android.volley.NetworkError;
+import com.android.volley.NetworkResponse;
+import com.android.volley.NoConnectionError;
+import com.android.volley.Request;
+import com.android.volley.RetryPolicy;
+import com.android.volley.ServerError;
+import com.android.volley.TimeoutError;
+import com.android.volley.VolleyError;
+import com.android.volley.VolleyLog;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.SocketTimeoutException;
+import java.util.List;
+
+/**
+ * Utility class for methods that are shared between {@link BasicNetwork} and {@link
+ * BasicAsyncNetwork}
+ */
+public final class NetworkUtility {
+ private static final int SLOW_REQUEST_THRESHOLD_MS = 3000;
+
+ private NetworkUtility() {}
+
+ /** Logs requests that took over SLOW_REQUEST_THRESHOLD_MS to complete. */
+ static void logSlowRequests(
+ long requestLifetime, Request<?> request, byte[] responseContents, int statusCode) {
+ if (VolleyLog.DEBUG || requestLifetime > SLOW_REQUEST_THRESHOLD_MS) {
+ VolleyLog.d(
+ "HTTP response for request=<%s> [lifetime=%d], [size=%s], "
+ + "[rc=%d], [retryCount=%s]",
+ request,
+ requestLifetime,
+ responseContents != null ? responseContents.length : "null",
+ statusCode,
+ request.getRetryPolicy().getCurrentRetryCount());
+ }
+ }
+
+ static NetworkResponse getNotModifiedNetworkResponse(
+ Request<?> request, long requestDuration, List<Header> responseHeaders) {
+ Cache.Entry entry = request.getCacheEntry();
+ if (entry == null) {
+ return new NetworkResponse(
+ HttpURLConnection.HTTP_NOT_MODIFIED,
+ /* data= */ null,
+ /* notModified= */ true,
+ requestDuration,
+ responseHeaders);
+ }
+ // Combine cached and response headers so the response will be complete.
+ List<Header> combinedHeaders = HttpHeaderParser.combineHeaders(responseHeaders, entry);
+ return new NetworkResponse(
+ HttpURLConnection.HTTP_NOT_MODIFIED,
+ entry.data,
+ /* notModified= */ true,
+ requestDuration,
+ combinedHeaders);
+ }
+
+ /** Reads the contents of an InputStream into a byte[]. */
+ static byte[] inputStreamToBytes(InputStream in, int contentLength, ByteArrayPool pool)
+ throws IOException {
+ PoolingByteArrayOutputStream bytes = new PoolingByteArrayOutputStream(pool, contentLength);
+ byte[] buffer = null;
+ try {
+ buffer = pool.getBuf(1024);
+ int count;
+ while ((count = in.read(buffer)) != -1) {
+ bytes.write(buffer, 0, count);
+ }
+ return bytes.toByteArray();
+ } finally {
+ try {
+ // Close the InputStream and release the resources by "consuming the content".
+ if (in != null) {
+ in.close();
+ }
+ } catch (IOException e) {
+ // This can happen if there was an exception above that left the stream in
+ // an invalid state.
+ VolleyLog.v("Error occurred when closing InputStream");
+ }
+ pool.returnBuf(buffer);
+ bytes.close();
+ }
+ }
+
+ /**
+ * Attempts to prepare the request for a retry. If there are no more attempts remaining in the
+ * request's retry policy, a timeout exception is thrown.
+ *
+ * @param request The request to use.
+ */
+ private static void attemptRetryOnException(
+ final String logPrefix, final Request<?> request, final VolleyError exception)
+ throws VolleyError {
+ final RetryPolicy retryPolicy = request.getRetryPolicy();
+ final int oldTimeout = request.getTimeoutMs();
+ try {
+ retryPolicy.retry(exception);
+ } catch (VolleyError e) {
+ request.addMarker(
+ String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout));
+ throw e;
+ }
+ request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout));
+ }
+
+ /**
+ * Based on the exception thrown, decides whether to attempt to retry, or to throw the error.
+ * Also handles logging.
+ */
+ static void handleException(
+ Request<?> request,
+ IOException exception,
+ long requestStartMs,
+ @Nullable HttpResponse httpResponse,
+ @Nullable byte[] responseContents)
+ throws VolleyError {
+ if (exception instanceof SocketTimeoutException) {
+ attemptRetryOnException("socket", request, new TimeoutError());
+ } else if (exception instanceof MalformedURLException) {
+ throw new RuntimeException("Bad URL " + request.getUrl(), exception);
+ } else {
+ int statusCode;
+ if (httpResponse != null) {
+ statusCode = httpResponse.getStatusCode();
+ } else {
+ if (request.shouldRetryConnectionErrors()) {
+ attemptRetryOnException("connection", request, new NoConnectionError());
+ return;
+ } else {
+ throw new NoConnectionError(exception);
+ }
+ }
+ VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());
+ NetworkResponse networkResponse;
+ if (responseContents != null) {
+ List<Header> responseHeaders;
+ responseHeaders = httpResponse.getHeaders();
+ networkResponse =
+ new NetworkResponse(
+ statusCode,
+ responseContents,
+ /* notModified= */ false,
+ SystemClock.elapsedRealtime() - requestStartMs,
+ responseHeaders);
+ if (statusCode == HttpURLConnection.HTTP_UNAUTHORIZED
+ || statusCode == HttpURLConnection.HTTP_FORBIDDEN) {
+ attemptRetryOnException("auth", request, new AuthFailureError(networkResponse));
+ } else if (statusCode >= 400 && statusCode <= 499) {
+ // Don't retry other client errors.
+ throw new ClientError(networkResponse);
+ } else if (statusCode >= 500 && statusCode <= 599) {
+ if (request.shouldRetryServerErrors()) {
+ attemptRetryOnException(
+ "server", request, new ServerError(networkResponse));
+ } else {
+ throw new ServerError(networkResponse);
+ }
+ } else {
+ // 3xx? No reason to retry.
+ throw new ServerError(networkResponse);
+ }
+ } else {
+ attemptRetryOnException("network", request, new NetworkError());
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/android/volley/toolbox/NoAsyncCache.java b/src/main/java/com/android/volley/toolbox/NoAsyncCache.java
new file mode 100644
index 0000000..aa4aeea
--- /dev/null
+++ b/src/main/java/com/android/volley/toolbox/NoAsyncCache.java
@@ -0,0 +1,37 @@
+package com.android.volley.toolbox;
+
+import com.android.volley.AsyncCache;
+import com.android.volley.Cache;
+
+/** An AsyncCache that doesn't cache anything. */
+public class NoAsyncCache extends AsyncCache {
+ @Override
+ public void get(String key, OnGetCompleteCallback callback) {
+ callback.onGetComplete(null);
+ }
+
+ @Override
+ public void put(String key, Cache.Entry entry, OnWriteCompleteCallback callback) {
+ callback.onWriteComplete();
+ }
+
+ @Override
+ public void clear(OnWriteCompleteCallback callback) {
+ callback.onWriteComplete();
+ }
+
+ @Override
+ public void initialize(OnWriteCompleteCallback callback) {
+ callback.onWriteComplete();
+ }
+
+ @Override
+ public void invalidate(String key, boolean fullExpire, OnWriteCompleteCallback callback) {
+ callback.onWriteComplete();
+ }
+
+ @Override
+ public void remove(String key, OnWriteCompleteCallback callback) {
+ callback.onWriteComplete();
+ }
+}
diff --git a/src/main/java/com/android/volley/toolbox/UrlRewriter.java b/src/main/java/com/android/volley/toolbox/UrlRewriter.java
new file mode 100644
index 0000000..8bbb770
--- /dev/null
+++ b/src/main/java/com/android/volley/toolbox/UrlRewriter.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley.toolbox;
+
+import androidx.annotation.Nullable;
+
+/** An interface for transforming URLs before use. */
+public interface UrlRewriter {
+ /**
+ * Returns a URL to use instead of the provided one, or null to indicate this URL should not be
+ * used at all.
+ */
+ @Nullable
+ String rewriteUrl(String originalUrl);
+}
diff --git a/src/test/java/com/android/volley/AsyncRequestQueueTest.java b/src/test/java/com/android/volley/AsyncRequestQueueTest.java
new file mode 100644
index 0000000..54ff0a1
--- /dev/null
+++ b/src/test/java/com/android/volley/AsyncRequestQueueTest.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import com.android.volley.mock.ShadowSystemClock;
+import com.android.volley.toolbox.NoAsyncCache;
+import com.android.volley.toolbox.StringRequest;
+import com.android.volley.utils.ImmediateResponseDelivery;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+/** Unit tests for AsyncRequestQueue, with all dependencies mocked out */
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = {ShadowSystemClock.class})
+public class AsyncRequestQueueTest {
+
+ @Mock private AsyncNetwork mMockNetwork;
+ @Mock private ScheduledExecutorService mMockScheduledExecutor;
+ private AsyncRequestQueue queue;
+
+ @Before
+ public void setUp() throws Exception {
+ ResponseDelivery mDelivery = new ImmediateResponseDelivery();
+ initMocks(this);
+ queue =
+ new AsyncRequestQueue.Builder(mMockNetwork)
+ .setAsyncCache(new NoAsyncCache())
+ .setResponseDelivery(mDelivery)
+ .setExecutorFactory(
+ new AsyncRequestQueue.ExecutorFactory() {
+ @Override
+ public ExecutorService createNonBlockingExecutor(
+ BlockingQueue<Runnable> taskQueue) {
+ return MoreExecutors.newDirectExecutorService();
+ }
+
+ @Override
+ public ExecutorService createBlockingExecutor(
+ BlockingQueue<Runnable> taskQueue) {
+ return MoreExecutors.newDirectExecutorService();
+ }
+
+ @Override
+ public ScheduledExecutorService
+ createNonBlockingScheduledExecutor() {
+ return mMockScheduledExecutor;
+ }
+ })
+ .build();
+ }
+
+ @Test
+ public void cancelAll_onlyCorrectTag() throws Exception {
+ queue.start();
+ Object tagA = new Object();
+ Object tagB = new Object();
+ StringRequest req1 = mock(StringRequest.class);
+ when(req1.getTag()).thenReturn(tagA);
+ StringRequest req2 = mock(StringRequest.class);
+ when(req2.getTag()).thenReturn(tagB);
+ StringRequest req3 = mock(StringRequest.class);
+ when(req3.getTag()).thenReturn(tagA);
+ StringRequest req4 = mock(StringRequest.class);
+ when(req4.getTag()).thenReturn(tagA);
+
+ queue.add(req1); // A
+ queue.add(req2); // B
+ queue.add(req3); // A
+ queue.cancelAll(tagA);
+ queue.add(req4); // A
+
+ verify(req1).cancel(); // A cancelled
+ verify(req3).cancel(); // A cancelled
+ verify(req2, never()).cancel(); // B not cancelled
+ verify(req4, never()).cancel(); // A added after cancel not cancelled
+ queue.stop();
+ }
+
+ @Test
+ public void add_notifiesListener() throws Exception {
+ RequestQueue.RequestEventListener listener = mock(RequestQueue.RequestEventListener.class);
+ queue.start();
+ queue.addRequestEventListener(listener);
+ StringRequest req = mock(StringRequest.class);
+
+ queue.add(req);
+
+ verify(listener).onRequestEvent(req, RequestQueue.RequestEvent.REQUEST_QUEUED);
+ verifyNoMoreInteractions(listener);
+ queue.stop();
+ }
+
+ @Test
+ public void finish_notifiesListener() throws Exception {
+ RequestQueue.RequestEventListener listener = mock(RequestQueue.RequestEventListener.class);
+ queue.start();
+ queue.addRequestEventListener(listener);
+ StringRequest req = mock(StringRequest.class);
+
+ queue.finish(req);
+
+ verify(listener).onRequestEvent(req, RequestQueue.RequestEvent.REQUEST_FINISHED);
+ verifyNoMoreInteractions(listener);
+ queue.stop();
+ }
+
+ @Test
+ public void sendRequestEvent_notifiesListener() throws Exception {
+ StringRequest req = mock(StringRequest.class);
+ RequestQueue.RequestEventListener listener = mock(RequestQueue.RequestEventListener.class);
+ queue.start();
+ queue.addRequestEventListener(listener);
+
+ queue.sendRequestEvent(req, RequestQueue.RequestEvent.REQUEST_NETWORK_DISPATCH_STARTED);
+
+ verify(listener)
+ .onRequestEvent(req, RequestQueue.RequestEvent.REQUEST_NETWORK_DISPATCH_STARTED);
+ verifyNoMoreInteractions(listener);
+ queue.stop();
+ }
+
+ @Test
+ public void removeRequestEventListener_removesListener() throws Exception {
+ StringRequest req = mock(StringRequest.class);
+ RequestQueue.RequestEventListener listener = mock(RequestQueue.RequestEventListener.class);
+ queue.start();
+ queue.addRequestEventListener(listener);
+ queue.removeRequestEventListener(listener);
+
+ queue.sendRequestEvent(req, RequestQueue.RequestEvent.REQUEST_NETWORK_DISPATCH_STARTED);
+
+ verifyNoMoreInteractions(listener);
+ queue.stop();
+ }
+}
diff --git a/src/test/java/com/android/volley/cronet/CronetHttpStackTest.java b/src/test/java/com/android/volley/cronet/CronetHttpStackTest.java
new file mode 100644
index 0000000..cedb6ff
--- /dev/null
+++ b/src/test/java/com/android/volley/cronet/CronetHttpStackTest.java
@@ -0,0 +1,381 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley.cronet;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.android.volley.Header;
+import com.android.volley.cronet.CronetHttpStack.CurlCommandLogger;
+import com.android.volley.mock.TestRequest;
+import com.android.volley.toolbox.AsyncHttpStack.OnRequestComplete;
+import com.android.volley.toolbox.UrlRewriter;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import org.chromium.net.CronetEngine;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+@RunWith(RobolectricTestRunner.class)
+public class CronetHttpStackTest {
+ @Mock private CurlCommandLogger mMockCurlCommandLogger;
+ @Mock private OnRequestComplete mMockOnRequestComplete;
+ @Mock private UrlRewriter mMockUrlRewriter;
+
+ // A fake would be ideal here, but Cronet doesn't (yet) provide one, and at the moment we aren't
+ // exercising the full response flow.
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ private CronetEngine mMockCronetEngine;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ }
+
+ @Test
+ public void curlLogging_disabled() {
+ CronetHttpStack stack =
+ createStack(
+ new Consumer<CronetHttpStack.Builder>() {
+ @Override
+ public void accept(CronetHttpStack.Builder builder) {
+ // Default parameters should not enable cURL logging.
+ }
+ });
+
+ stack.executeRequest(
+ new TestRequest.Get(), ImmutableMap.<String, String>of(), mMockOnRequestComplete);
+
+ verify(mMockCurlCommandLogger, never()).logCurlCommand(anyString());
+ }
+
+ @Test
+ public void curlLogging_simpleTextRequest() {
+ CronetHttpStack stack =
+ createStack(
+ new Consumer<CronetHttpStack.Builder>() {
+ @Override
+ public void accept(CronetHttpStack.Builder builder) {
+ builder.setCurlLoggingEnabled(true);
+ }
+ });
+
+ stack.executeRequest(
+ new TestRequest.Get(), ImmutableMap.<String, String>of(), mMockOnRequestComplete);
+
+ ArgumentCaptor<String> curlCommandCaptor = ArgumentCaptor.forClass(String.class);
+ verify(mMockCurlCommandLogger).logCurlCommand(curlCommandCaptor.capture());
+ assertEquals("curl -X GET \"http://foo.com\"", curlCommandCaptor.getValue());
+ }
+
+ @Test
+ public void curlLogging_rewrittenUrl() {
+ CronetHttpStack stack =
+ createStack(
+ new Consumer<CronetHttpStack.Builder>() {
+ @Override
+ public void accept(CronetHttpStack.Builder builder) {
+ builder.setCurlLoggingEnabled(true)
+ .setUrlRewriter(mMockUrlRewriter);
+ }
+ });
+ when(mMockUrlRewriter.rewriteUrl("http://foo.com")).thenReturn("http://bar.com");
+
+ stack.executeRequest(
+ new TestRequest.Get(), ImmutableMap.<String, String>of(), mMockOnRequestComplete);
+
+ ArgumentCaptor<String> curlCommandCaptor = ArgumentCaptor.forClass(String.class);
+ verify(mMockCurlCommandLogger).logCurlCommand(curlCommandCaptor.capture());
+ assertEquals("curl -X GET \"http://bar.com\"", curlCommandCaptor.getValue());
+ }
+
+ @Test
+ public void curlLogging_headers_withoutTokens() {
+ CronetHttpStack stack =
+ createStack(
+ new Consumer<CronetHttpStack.Builder>() {
+ @Override
+ public void accept(CronetHttpStack.Builder builder) {
+ builder.setCurlLoggingEnabled(true);
+ }
+ });
+
+ stack.executeRequest(
+ new TestRequest.Delete() {
+ @Override
+ public Map<String, String> getHeaders() {
+ return ImmutableMap.of(
+ "SomeHeader", "SomeValue",
+ "Authorization", "SecretToken");
+ }
+ },
+ ImmutableMap.of("SomeOtherHeader", "SomeValue"),
+ mMockOnRequestComplete);
+
+ ArgumentCaptor<String> curlCommandCaptor = ArgumentCaptor.forClass(String.class);
+ verify(mMockCurlCommandLogger).logCurlCommand(curlCommandCaptor.capture());
+ // NOTE: Header order is stable because the implementation uses a TreeMap.
+ assertEquals(
+ "curl -X DELETE --header \"Authorization: [REDACTED]\" "
+ + "--header \"SomeHeader: SomeValue\" "
+ + "--header \"SomeOtherHeader: SomeValue\" \"http://foo.com\"",
+ curlCommandCaptor.getValue());
+ }
+
+ @Test
+ public void curlLogging_headers_withTokens() {
+ CronetHttpStack stack =
+ createStack(
+ new Consumer<CronetHttpStack.Builder>() {
+ @Override
+ public void accept(CronetHttpStack.Builder builder) {
+ builder.setCurlLoggingEnabled(true)
+ .setLogAuthTokensInCurlCommands(true);
+ }
+ });
+
+ stack.executeRequest(
+ new TestRequest.Delete() {
+ @Override
+ public Map<String, String> getHeaders() {
+ return ImmutableMap.of(
+ "SomeHeader", "SomeValue",
+ "Authorization", "SecretToken");
+ }
+ },
+ ImmutableMap.of("SomeOtherHeader", "SomeValue"),
+ mMockOnRequestComplete);
+
+ ArgumentCaptor<String> curlCommandCaptor = ArgumentCaptor.forClass(String.class);
+ verify(mMockCurlCommandLogger).logCurlCommand(curlCommandCaptor.capture());
+ // NOTE: Header order is stable because the implementation uses a TreeMap.
+ assertEquals(
+ "curl -X DELETE --header \"Authorization: SecretToken\" "
+ + "--header \"SomeHeader: SomeValue\" "
+ + "--header \"SomeOtherHeader: SomeValue\" \"http://foo.com\"",
+ curlCommandCaptor.getValue());
+ }
+
+ @Test
+ public void curlLogging_textRequest() {
+ CronetHttpStack stack =
+ createStack(
+ new Consumer<CronetHttpStack.Builder>() {
+ @Override
+ public void accept(CronetHttpStack.Builder builder) {
+ builder.setCurlLoggingEnabled(true);
+ }
+ });
+
+ stack.executeRequest(
+ new TestRequest.PostWithBody() {
+ @Override
+ public byte[] getBody() {
+ try {
+ return "hello".getBytes("UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public String getBodyContentType() {
+ return "text/plain; charset=UTF-8";
+ }
+ },
+ ImmutableMap.<String, String>of(),
+ mMockOnRequestComplete);
+
+ ArgumentCaptor<String> curlCommandCaptor = ArgumentCaptor.forClass(String.class);
+ verify(mMockCurlCommandLogger).logCurlCommand(curlCommandCaptor.capture());
+ assertEquals(
+ "curl -X POST "
+ + "--header \"Content-Type: text/plain; charset=UTF-8\" \"http://foo.com\" "
+ + "--data-ascii \"hello\"",
+ curlCommandCaptor.getValue());
+ }
+
+ @Test
+ public void curlLogging_gzipTextRequest() {
+ CronetHttpStack stack =
+ createStack(
+ new Consumer<CronetHttpStack.Builder>() {
+ @Override
+ public void accept(CronetHttpStack.Builder builder) {
+ builder.setCurlLoggingEnabled(true);
+ }
+ });
+
+ stack.executeRequest(
+ new TestRequest.PostWithBody() {
+ @Override
+ public byte[] getBody() {
+ return new byte[] {1, 2, 3, 4, 5};
+ }
+
+ @Override
+ public String getBodyContentType() {
+ return "text/plain";
+ }
+
+ @Override
+ public Map<String, String> getHeaders() {
+ return ImmutableMap.of("Content-Encoding", "gzip, identity");
+ }
+ },
+ ImmutableMap.<String, String>of(),
+ mMockOnRequestComplete);
+
+ ArgumentCaptor<String> curlCommandCaptor = ArgumentCaptor.forClass(String.class);
+ verify(mMockCurlCommandLogger).logCurlCommand(curlCommandCaptor.capture());
+ assertEquals(
+ "echo 'AQIDBAU=' | base64 -d > /tmp/$$.bin; curl -X POST "
+ + "--header \"Content-Encoding: gzip, identity\" "
+ + "--header \"Content-Type: text/plain\" \"http://foo.com\" "
+ + "--data-binary @/tmp/$$.bin",
+ curlCommandCaptor.getValue());
+ }
+
+ @Test
+ public void curlLogging_binaryRequest() {
+ CronetHttpStack stack =
+ createStack(
+ new Consumer<CronetHttpStack.Builder>() {
+ @Override
+ public void accept(CronetHttpStack.Builder builder) {
+ builder.setCurlLoggingEnabled(true);
+ }
+ });
+
+ stack.executeRequest(
+ new TestRequest.PostWithBody() {
+ @Override
+ public byte[] getBody() {
+ return new byte[] {1, 2, 3, 4, 5};
+ }
+
+ @Override
+ public String getBodyContentType() {
+ return "application/octet-stream";
+ }
+ },
+ ImmutableMap.<String, String>of(),
+ mMockOnRequestComplete);
+
+ ArgumentCaptor<String> curlCommandCaptor = ArgumentCaptor.forClass(String.class);
+ verify(mMockCurlCommandLogger).logCurlCommand(curlCommandCaptor.capture());
+ assertEquals(
+ "echo 'AQIDBAU=' | base64 -d > /tmp/$$.bin; curl -X POST "
+ + "--header \"Content-Type: application/octet-stream\" \"http://foo.com\" "
+ + "--data-binary @/tmp/$$.bin",
+ curlCommandCaptor.getValue());
+ }
+
+ @Test
+ public void curlLogging_largeRequest() {
+ CronetHttpStack stack =
+ createStack(
+ new Consumer<CronetHttpStack.Builder>() {
+ @Override
+ public void accept(CronetHttpStack.Builder builder) {
+ builder.setCurlLoggingEnabled(true);
+ }
+ });
+
+ stack.executeRequest(
+ new TestRequest.PostWithBody() {
+ @Override
+ public byte[] getBody() {
+ return new byte[2048];
+ }
+
+ @Override
+ public String getBodyContentType() {
+ return "application/octet-stream";
+ }
+ },
+ ImmutableMap.<String, String>of(),
+ mMockOnRequestComplete);
+
+ ArgumentCaptor<String> curlCommandCaptor = ArgumentCaptor.forClass(String.class);
+ verify(mMockCurlCommandLogger).logCurlCommand(curlCommandCaptor.capture());
+ assertEquals(
+ "curl -X POST "
+ + "--header \"Content-Type: application/octet-stream\" \"http://foo.com\" "
+ + "[REQUEST BODY TOO LARGE TO INCLUDE]",
+ curlCommandCaptor.getValue());
+ }
+
+ @Test
+ public void getHeadersEmptyTest() {
+ List<Map.Entry<String, String>> list = new ArrayList<>();
+ List<Header> actual = CronetHttpStack.getHeaders(list);
+ List<Header> expected = new ArrayList<>();
+ assertEquals(expected, actual);
+ }
+
+ @Test
+ public void getHeadersNonEmptyTest() {
+ Map<String, String> headers = new HashMap<>();
+ for (int i = 1; i < 5; i++) {
+ headers.put("key" + i, "value" + i);
+ }
+ List<Map.Entry<String, String>> list = new ArrayList<>(headers.entrySet());
+ List<Header> actual = CronetHttpStack.getHeaders(list);
+ List<Header> expected = new ArrayList<>();
+ for (int i = 1; i < 5; i++) {
+ expected.add(new Header("key" + i, "value" + i));
+ }
+ assertHeaderListsEqual(expected, actual);
+ }
+
+ private void assertHeaderListsEqual(List<Header> expected, List<Header> actual) {
+ assertEquals(expected.size(), actual.size());
+ for (int i = 0; i < expected.size(); i++) {
+ assertEquals(expected.get(i).getName(), actual.get(i).getName());
+ assertEquals(expected.get(i).getValue(), actual.get(i).getValue());
+ }
+ }
+
+ private CronetHttpStack createStack(Consumer<CronetHttpStack.Builder> stackEditor) {
+ CronetHttpStack.Builder builder =
+ new CronetHttpStack.Builder(RuntimeEnvironment.application)
+ .setCronetEngine(mMockCronetEngine)
+ .setCurlCommandLogger(mMockCurlCommandLogger);
+ stackEditor.accept(builder);
+ CronetHttpStack stack = builder.build();
+ stack.setBlockingExecutor(MoreExecutors.newDirectExecutorService());
+ stack.setNonBlockingExecutor(MoreExecutors.newDirectExecutorService());
+ return stack;
+ }
+}
diff --git a/src/test/java/com/android/volley/mock/MockAsyncStack.java b/src/test/java/com/android/volley/mock/MockAsyncStack.java
new file mode 100644
index 0000000..5ea8343
--- /dev/null
+++ b/src/test/java/com/android/volley/mock/MockAsyncStack.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley.mock;
+
+import com.android.volley.AuthFailureError;
+import com.android.volley.Request;
+import com.android.volley.toolbox.AsyncHttpStack;
+import com.android.volley.toolbox.HttpResponse;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class MockAsyncStack extends AsyncHttpStack {
+
+ private HttpResponse mResponseToReturn;
+
+ private IOException mExceptionToThrow;
+
+ private String mLastUrl;
+
+ private Map<String, String> mLastHeaders;
+
+ private byte[] mLastPostBody;
+
+ public String getLastUrl() {
+ return mLastUrl;
+ }
+
+ public Map<String, String> getLastHeaders() {
+ return mLastHeaders;
+ }
+
+ public byte[] getLastPostBody() {
+ return mLastPostBody;
+ }
+
+ public void setResponseToReturn(HttpResponse response) {
+ mResponseToReturn = response;
+ }
+
+ public void setExceptionToThrow(IOException exception) {
+ mExceptionToThrow = exception;
+ }
+
+ @Override
+ public void executeRequest(
+ Request<?> request, Map<String, String> additionalHeaders, OnRequestComplete callback) {
+ if (mExceptionToThrow != null) {
+ callback.onError(mExceptionToThrow);
+ return;
+ }
+ mLastUrl = request.getUrl();
+ mLastHeaders = new HashMap<>();
+ try {
+ if (request.getHeaders() != null) {
+ mLastHeaders.putAll(request.getHeaders());
+ }
+ } catch (AuthFailureError authFailureError) {
+ callback.onAuthError(authFailureError);
+ return;
+ }
+ if (additionalHeaders != null) {
+ mLastHeaders.putAll(additionalHeaders);
+ }
+ try {
+ mLastPostBody = request.getBody();
+ } catch (AuthFailureError e) {
+ mLastPostBody = null;
+ }
+ callback.onSuccess(mResponseToReturn);
+ }
+}
diff --git a/src/test/java/com/android/volley/toolbox/BasicAsyncNetworkTest.java b/src/test/java/com/android/volley/toolbox/BasicAsyncNetworkTest.java
new file mode 100644
index 0000000..91d4062
--- /dev/null
+++ b/src/test/java/com/android/volley/toolbox/BasicAsyncNetworkTest.java
@@ -0,0 +1,508 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.volley.toolbox;
+
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import com.android.volley.AsyncNetwork;
+import com.android.volley.AuthFailureError;
+import com.android.volley.Cache.Entry;
+import com.android.volley.Header;
+import com.android.volley.NetworkResponse;
+import com.android.volley.NoConnectionError;
+import com.android.volley.Request;
+import com.android.volley.Response;
+import com.android.volley.RetryPolicy;
+import com.android.volley.ServerError;
+import com.android.volley.TimeoutError;
+import com.android.volley.VolleyError;
+import com.android.volley.mock.MockAsyncStack;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.SocketTimeoutException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public class BasicAsyncNetworkTest {
+
+ @Mock private RetryPolicy mMockRetryPolicy;
+ @Mock private AsyncNetwork.OnRequestComplete mockCallback;
+ private ExecutorService executor = MoreExecutors.newDirectExecutorService();
+
+ @Before
+ public void setUp() throws Exception {
+ initMocks(this);
+ }
+
+ @Test
+ public void headersAndPostParams() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ HttpResponse fakeResponse =
+ new HttpResponse(
+ 200,
+ Collections.<Header>emptyList(),
+ "foobar".getBytes(StandardCharsets.UTF_8));
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ Entry entry = new Entry();
+ entry.etag = "foobar";
+ entry.lastModified = 1503102002000L;
+ request.setCacheEntry(entry);
+ perform(request, httpNetwork).get();
+ assertEquals("foo", mockAsyncStack.getLastHeaders().get("requestheader"));
+ assertEquals("foobar", mockAsyncStack.getLastHeaders().get("If-None-Match"));
+ assertEquals(
+ "Sat, 19 Aug 2017 00:20:02 GMT",
+ mockAsyncStack.getLastHeaders().get("If-Modified-Since"));
+ assertEquals(
+ "requestpost=foo&",
+ new String(mockAsyncStack.getLastPostBody(), StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void headersAndPostParamsStream() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ ByteArrayInputStream stream = new ByteArrayInputStream("foobar".getBytes("UTF-8"));
+ HttpResponse fakeResponse =
+ new HttpResponse(200, Collections.<Header>emptyList(), 6, stream);
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ Entry entry = new Entry();
+ entry.etag = "foobar";
+ entry.lastModified = 1503102002000L;
+ request.setCacheEntry(entry);
+ perform(request, httpNetwork).get();
+ assertEquals("foo", mockAsyncStack.getLastHeaders().get("requestheader"));
+ assertEquals("foobar", mockAsyncStack.getLastHeaders().get("If-None-Match"));
+ assertEquals(
+ "Sat, 19 Aug 2017 00:20:02 GMT",
+ mockAsyncStack.getLastHeaders().get("If-Modified-Since"));
+ assertEquals(
+ "requestpost=foo&",
+ new String(mockAsyncStack.getLastPostBody(), StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void notModified() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ List<Header> headers = new ArrayList<>();
+ headers.add(new Header("ServerKeyA", "ServerValueA"));
+ headers.add(new Header("ServerKeyB", "ServerValueB"));
+ headers.add(new Header("SharedKey", "ServerValueShared"));
+ headers.add(new Header("sharedcaseinsensitivekey", "ServerValueShared1"));
+ headers.add(new Header("SharedCaseInsensitiveKey", "ServerValueShared2"));
+ HttpResponse fakeResponse = new HttpResponse(HttpURLConnection.HTTP_NOT_MODIFIED, headers);
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ Entry entry = new Entry();
+ entry.allResponseHeaders = new ArrayList<>();
+ entry.allResponseHeaders.add(new Header("CachedKeyA", "CachedValueA"));
+ entry.allResponseHeaders.add(new Header("CachedKeyB", "CachedValueB"));
+ entry.allResponseHeaders.add(new Header("SharedKey", "CachedValueShared"));
+ entry.allResponseHeaders.add(new Header("SHAREDCASEINSENSITIVEKEY", "CachedValueShared1"));
+ entry.allResponseHeaders.add(new Header("shAREDcaSEinSENSITIVEkeY", "CachedValueShared2"));
+ request.setCacheEntry(entry);
+ httpNetwork.performRequest(request, mockCallback);
+ NetworkResponse response = perform(request, httpNetwork).get();
+ List<Header> expectedHeaders = new ArrayList<>();
+ // Should have all server headers + cache headers that didn't show up in server response.
+ expectedHeaders.add(new Header("ServerKeyA", "ServerValueA"));
+ expectedHeaders.add(new Header("ServerKeyB", "ServerValueB"));
+ expectedHeaders.add(new Header("SharedKey", "ServerValueShared"));
+ expectedHeaders.add(new Header("sharedcaseinsensitivekey", "ServerValueShared1"));
+ expectedHeaders.add(new Header("SharedCaseInsensitiveKey", "ServerValueShared2"));
+ expectedHeaders.add(new Header("CachedKeyA", "CachedValueA"));
+ expectedHeaders.add(new Header("CachedKeyB", "CachedValueB"));
+ assertThat(expectedHeaders, containsInAnyOrder(response.allHeaders.toArray(new Header[0])));
+ }
+
+ @Test
+ public void notModified_legacyCache() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ List<Header> headers = new ArrayList<>();
+ headers.add(new Header("ServerKeyA", "ServerValueA"));
+ headers.add(new Header("ServerKeyB", "ServerValueB"));
+ headers.add(new Header("SharedKey", "ServerValueShared"));
+ headers.add(new Header("sharedcaseinsensitivekey", "ServerValueShared1"));
+ headers.add(new Header("SharedCaseInsensitiveKey", "ServerValueShared2"));
+ HttpResponse fakeResponse = new HttpResponse(HttpURLConnection.HTTP_NOT_MODIFIED, headers);
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ Entry entry = new Entry();
+ entry.responseHeaders = new HashMap<>();
+ entry.responseHeaders.put("CachedKeyA", "CachedValueA");
+ entry.responseHeaders.put("CachedKeyB", "CachedValueB");
+ entry.responseHeaders.put("SharedKey", "CachedValueShared");
+ entry.responseHeaders.put("SHAREDCASEINSENSITIVEKEY", "CachedValueShared1");
+ entry.responseHeaders.put("shAREDcaSEinSENSITIVEkeY", "CachedValueShared2");
+ request.setCacheEntry(entry);
+ NetworkResponse response = perform(request, httpNetwork).get();
+ List<Header> expectedHeaders = new ArrayList<>();
+ // Should have all server headers + cache headers that didn't show up in server response.
+ expectedHeaders.add(new Header("ServerKeyA", "ServerValueA"));
+ expectedHeaders.add(new Header("ServerKeyB", "ServerValueB"));
+ expectedHeaders.add(new Header("SharedKey", "ServerValueShared"));
+ expectedHeaders.add(new Header("sharedcaseinsensitivekey", "ServerValueShared1"));
+ expectedHeaders.add(new Header("SharedCaseInsensitiveKey", "ServerValueShared2"));
+ expectedHeaders.add(new Header("CachedKeyA", "CachedValueA"));
+ expectedHeaders.add(new Header("CachedKeyB", "CachedValueB"));
+ assertThat(expectedHeaders, containsInAnyOrder(response.allHeaders.toArray(new Header[0])));
+ }
+
+ @Test
+ public void socketTimeout() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ mockAsyncStack.setExceptionToThrow(new SocketTimeoutException());
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ // should retry socket timeouts
+ verify(mMockRetryPolicy).retry(any(TimeoutError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+
+ @Test
+ public void noConnectionDefault() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ mockAsyncStack.setExceptionToThrow(new IOException());
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ // should not retry when there is no connection
+ verify(mMockRetryPolicy, never()).retry(any(VolleyError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+
+ @Test
+ public void noConnectionRetry() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ mockAsyncStack.setExceptionToThrow(new IOException());
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ request.setShouldRetryConnectionErrors(true);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ // should retry when there is no connection
+ verify(mMockRetryPolicy).retry(any(NoConnectionError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+
+ @Test
+ public void noConnectionNoRetry() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ mockAsyncStack.setExceptionToThrow(new IOException());
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ request.setShouldRetryConnectionErrors(false);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ // should not retry when there is no connection
+ verify(mMockRetryPolicy, never()).retry(any(VolleyError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+
+ @Test
+ public void unauthorized() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ HttpResponse fakeResponse = new HttpResponse(401, Collections.<Header>emptyList());
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ // should retry in case it's an auth failure.
+ verify(mMockRetryPolicy).retry(any(AuthFailureError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+
+ @Test(expected = RuntimeException.class)
+ public void malformedUrlRequest() throws VolleyError, ExecutionException, InterruptedException {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ mockAsyncStack.setExceptionToThrow(new MalformedURLException());
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ perform(request, httpNetwork).get();
+ }
+
+ @Test
+ public void forbidden() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ HttpResponse fakeResponse = new HttpResponse(403, Collections.<Header>emptyList());
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ // should retry in case it's an auth failure.
+ verify(mMockRetryPolicy).retry(any(AuthFailureError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+
+ @Test
+ public void redirect() throws Exception {
+ for (int i = 300; i <= 399; i++) {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ HttpResponse fakeResponse = new HttpResponse(i, Collections.<Header>emptyList());
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ if (i != 304) {
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ } else {
+ verify(mockCallback, never()).onError(any(VolleyError.class));
+ verify(mockCallback, times(1)).onSuccess(any(NetworkResponse.class));
+ }
+ // should not retry 300 responses.
+ verify(mMockRetryPolicy, never()).retry(any(VolleyError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+ }
+
+ @Test
+ public void otherClientError() throws Exception {
+ for (int i = 400; i <= 499; i++) {
+ if (i == 401 || i == 403) {
+ // covered above.
+ continue;
+ }
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ HttpResponse fakeResponse = new HttpResponse(i, Collections.<Header>emptyList());
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ // should not retry other 400 errors.
+ verify(mMockRetryPolicy, never()).retry(any(VolleyError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+ }
+
+ @Test
+ public void serverError_enableRetries() throws Exception {
+ for (int i = 500; i <= 599; i++) {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ HttpResponse fakeResponse = new HttpResponse(i, Collections.<Header>emptyList());
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork =
+ new BasicAsyncNetwork.Builder(mockAsyncStack)
+ .setPool(new ByteArrayPool(4096))
+ .build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ request.setShouldRetryServerErrors(true);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ // should retry all 500 errors
+ verify(mMockRetryPolicy).retry(any(ServerError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+ }
+
+ @Test
+ public void serverError_disableRetries() throws Exception {
+ for (int i = 500; i <= 599; i++) {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ HttpResponse fakeResponse = new HttpResponse(i, Collections.<Header>emptyList());
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onError(any(VolleyError.class));
+ verify(mockCallback, never()).onSuccess(any(NetworkResponse.class));
+ // should not retry any 500 error w/ HTTP 500 retries turned off (the default).
+ verify(mMockRetryPolicy, never()).retry(any(VolleyError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+ }
+
+ @Test
+ public void notModifiedShortCircuit() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ List<Header> headers = new ArrayList<>();
+ headers.add(new Header("ServerKeyA", "ServerValueA"));
+ headers.add(new Header("ServerKeyB", "ServerValueB"));
+ headers.add(new Header("SharedKey", "ServerValueShared"));
+ headers.add(new Header("sharedcaseinsensitivekey", "ServerValueShared1"));
+ headers.add(new Header("SharedCaseInsensitiveKey", "ServerValueShared2"));
+ HttpResponse fakeResponse = new HttpResponse(HttpURLConnection.HTTP_NOT_MODIFIED, headers);
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onSuccess(any(NetworkResponse.class));
+ verify(mockCallback, never()).onError(any(VolleyError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+
+ @Test
+ public void performRequestSuccess() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ HttpResponse fakeResponse =
+ new HttpResponse(
+ 200,
+ Collections.<Header>emptyList(),
+ "foobar".getBytes(StandardCharsets.UTF_8));
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ httpNetwork.setBlockingExecutor(executor);
+ Request<String> request = buildRequest();
+ Entry entry = new Entry();
+ entry.etag = "foobar";
+ entry.lastModified = 1503102002000L;
+ request.setCacheEntry(entry);
+ httpNetwork.performRequest(request, mockCallback);
+ verify(mockCallback, times(1)).onSuccess(any(NetworkResponse.class));
+ verify(mockCallback, never()).onError(any(VolleyError.class));
+ reset(mMockRetryPolicy, mockCallback);
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void performRequestNeverSetExecutorTest() throws Exception {
+ MockAsyncStack mockAsyncStack = new MockAsyncStack();
+ HttpResponse fakeResponse = new HttpResponse(200, Collections.<Header>emptyList());
+ mockAsyncStack.setResponseToReturn(fakeResponse);
+ BasicAsyncNetwork httpNetwork = new BasicAsyncNetwork.Builder(mockAsyncStack).build();
+ Request<String> request = buildRequest();
+ perform(request, httpNetwork).get();
+ }
+
+ /** Helper functions */
+ private CompletableFuture<NetworkResponse> perform(Request<?> request, AsyncNetwork network)
+ throws VolleyError {
+ final CompletableFuture<NetworkResponse> future = new CompletableFuture<>();
+ network.performRequest(
+ request,
+ new AsyncNetwork.OnRequestComplete() {
+ @Override
+ public void onSuccess(NetworkResponse networkResponse) {
+ future.complete(networkResponse);
+ }
+
+ @Override
+ public void onError(VolleyError volleyError) {
+ future.complete(null);
+ }
+ });
+ return future;
+ }
+
+ private static Request<String> buildRequest() {
+ return new Request<String>(Request.Method.GET, "http://foo", null) {
+
+ @Override
+ protected Response<String> parseNetworkResponse(NetworkResponse response) {
+ return null;
+ }
+
+ @Override
+ protected void deliverResponse(String response) {}
+
+ @Override
+ public Map<String, String> getHeaders() {
+ Map<String, String> result = new HashMap<String, String>();
+ result.put("requestheader", "foo");
+ return result;
+ }
+
+ @Override
+ public Map<String, String> getParams() {
+ Map<String, String> result = new HashMap<String, String>();
+ result.put("requestpost", "foo");
+ return result;
+ }
+ };
+ }
+}
diff --git a/src/test/java/com/android/volley/toolbox/BasicNetworkTest.java b/src/test/java/com/android/volley/toolbox/BasicNetworkTest.java
index fec0694..3630379 100644
--- a/src/test/java/com/android/volley/toolbox/BasicNetworkTest.java
+++ b/src/test/java/com/android/volley/toolbox/BasicNetworkTest.java
@@ -30,6 +30,7 @@
import com.android.volley.Cache.Entry;
import com.android.volley.Header;
import com.android.volley.NetworkResponse;
+import com.android.volley.NoConnectionError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.RetryPolicy;
@@ -176,7 +177,7 @@
}
@Test
- public void noConnection() throws Exception {
+ public void noConnectionDefault() throws Exception {
MockHttpStack mockHttpStack = new MockHttpStack();
mockHttpStack.setExceptionToThrow(new IOException());
BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
@@ -193,6 +194,43 @@
}
@Test
+ public void noConnectionRetry() throws Exception {
+ MockHttpStack mockHttpStack = new MockHttpStack();
+ mockHttpStack.setExceptionToThrow(new IOException());
+ BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ request.setShouldRetryConnectionErrors(true);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ try {
+ httpNetwork.performRequest(request);
+ } catch (VolleyError e) {
+ // expected
+ }
+ // should retry when there is no connection
+ verify(mMockRetryPolicy).retry(any(NoConnectionError.class));
+ reset(mMockRetryPolicy);
+ }
+
+ @Test
+ public void noConnectionNoRetry() throws Exception {
+ MockHttpStack mockHttpStack = new MockHttpStack();
+ mockHttpStack.setExceptionToThrow(new IOException());
+ BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
+ Request<String> request = buildRequest();
+ request.setRetryPolicy(mMockRetryPolicy);
+ request.setShouldRetryConnectionErrors(false);
+ doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
+ try {
+ httpNetwork.performRequest(request);
+ } catch (VolleyError e) {
+ // expected
+ }
+ // should not retry when there is no connection
+ verify(mMockRetryPolicy, never()).retry(any(VolleyError.class));
+ }
+
+ @Test
public void unauthorized() throws Exception {
MockHttpStack mockHttpStack = new MockHttpStack();
HttpResponse fakeResponse = new HttpResponse(401, Collections.<Header>emptyList());
diff --git a/src/test/java/com/android/volley/toolbox/DiskBasedCacheTest.java b/src/test/java/com/android/volley/toolbox/DiskBasedCacheTest.java
index ccf68fa..db6e491 100644
--- a/src/test/java/com/android/volley/toolbox/DiskBasedCacheTest.java
+++ b/src/test/java/com/android/volley/toolbox/DiskBasedCacheTest.java
@@ -59,7 +59,7 @@
import org.robolectric.annotation.Config;
@RunWith(RobolectricTestRunner.class)
-@Config(manifest = "src/main/AndroidManifest.xml", sdk = 16)
+@Config(sdk = 16)
public class DiskBasedCacheTest {
private static final int MAX_SIZE = 1024 * 1024;
diff --git a/src/test/java/com/android/volley/utils/CacheTestUtils.java b/src/test/java/com/android/volley/utils/CacheTestUtils.java
index 49ab996..5980712 100644
--- a/src/test/java/com/android/volley/utils/CacheTestUtils.java
+++ b/src/test/java/com/android/volley/utils/CacheTestUtils.java
@@ -16,6 +16,11 @@
package com.android.volley.utils;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+
import com.android.volley.Cache;
import java.util.Random;
@@ -51,4 +56,34 @@
public static Cache.Entry makeRandomCacheEntry(byte[] data) {
return makeRandomCacheEntry(data, false, false);
}
+
+ public static void assertThatEntriesAreEqual(Cache.Entry actual, Cache.Entry expected) {
+ assertNotNull(actual);
+ assertThat(actual.data, is(equalTo(expected.data)));
+ assertThat(actual.etag, is(equalTo(expected.etag)));
+ assertThat(actual.lastModified, is(equalTo(expected.lastModified)));
+ assertThat(actual.responseHeaders, is(equalTo(expected.responseHeaders)));
+ assertThat(actual.serverDate, is(equalTo(expected.serverDate)));
+ assertThat(actual.softTtl, is(equalTo(expected.softTtl)));
+ assertThat(actual.ttl, is(equalTo(expected.ttl)));
+ }
+
+ public static Cache.Entry randomData(int length) {
+ Cache.Entry entry = new Cache.Entry();
+ byte[] data = new byte[length];
+ new Random(42).nextBytes(data); // explicit seed for reproducible results
+ entry.data = data;
+ return entry;
+ }
+
+ public static int getEntrySizeOnDisk(String key) {
+ // Header size is:
+ // 4 bytes for magic int
+ // 8 + len(key) bytes for key (long length)
+ // 8 bytes for etag (long length + 0 characters)
+ // 32 bytes for serverDate, lastModified, ttl, and softTtl longs
+ // 4 bytes for length of header list int
+ // == 56 + len(key) bytes total.
+ return 56 + key.length();
+ }
}
