Import of Volley from GitHub to AOSP.android-s-beta-5android-s-beta-4android-s-beta-3android-s-beta-5android-s-beta-4

Android.bp has been updated to account for the new source directory structure.

  - 0dc50bcfd021c204a9e6c9e7e6befbdfa1027247 Refactor Volley into a multi-module project. (#418) by Jeff Davidson <jpd@google.com>
  - 763c86b0bc9f66a8bb499f6a8b7fd3bdc87621a8 Remove new constructors from JsonRequests which are break... by Jeff Davidson <jpd@google.com>
  - 8d1b1a59e7cd1b1d3c6d8686f8831cea08f80d1f Add @NonNull annotations to Volley (#413) by Kamal Faraj <kfaraj.dev@gmail.com>
  - 5ba41f8670413973f587e435598f9f1724fa26e9 Allow sending any JSON with JsonArrayRequest & JsonObject... by Paul Smith <paulsmithkc@gmail.com>
  - 784cdd755392a6080e5eb0bf94bd7bf4ea31cf17 Update SNAPSHOT version after 1.2.0 release by Jeff Davidson <jpd@google.com>
  - 0d6497bab417a5f78b3c8e03ea157ada0fbfbc5d Add developers stanza to Volley POM. (#400) by Jeff Davidson <jpd@google.com>
  - 36274bf515a699ae5a7fe3d321206d1b803226d8 API cleanup for Async Volley stack ahead of 1.2.0 release... by Jeff Davidson <jpd@google.com>
  - 03f0144843fcf9ebafe512647c1c588975429452 Update environment variable name for snapshot pushes. (#3... by Jeff Davidson <jpd@google.com>
  - 3bd1975652687d2baa1b11a7f02b135edede8523 Publish SNAPSHOT builds to OSSRH instead of OJO. (#397) by Jeff Davidson <jpd@google.com>
  - 0e0c3d9cfa694f8f1400a9e9abc4bc11761fdb52 Invoke RetryPolicy#retry in the blocking executor. (#393) by Jeff Davidson <jpd@google.com>
  - b51831a48f06ad28f627c3624e5edb41598a2bf8 Use a consistent timebase when evaluating soft/hard TTLs.... by Jeff Davidson <jpd@google.com>
  - cd0839113b100f163df1ebd04ce6d5b9e36e9863 Migrate from Travis CI to GitHub Actions. (#381) by Jeff Davidson <jpd@google.com>
  - bdc0e393199ebf9e67c4e29e665252818eed4639 Clean up cache initialization in AsyncRequestQueue. (#380) by Jeff Davidson <jpd@google.com>
  - 1c0ade36edde15d02844b40351ab6f80c63b71b3 Actually allow applications to provide custom executors. by Jeff Davidson <jpd@google.com>

GitOrigin-RevId: 0dc50bcfd021c204a9e6c9e7e6befbdfa1027247
Change-Id: I4b8e4098ad5c349cb83efc867273fac1d3582a34

1 files changed, 0 insertions, 176 deletions

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