1 files changed, 176 insertions, 0 deletions
diff --git a/core/src/main/java/com/android/volley/WaitingRequestManager.java b/core/src/main/java/com/android/volley/WaitingRequestManager.java
new file mode 100644
index 0000000..682e339
--- /dev/null
+++ b/core/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;
+        }
+    }
+}