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, 206 deletions

diff --git a/src/main/java/com/android/volley/CacheDispatcher.java b/src/main/java/com/android/volley/CacheDispatcher.java
deleted file mode 100644
index 1bfc0ea..0000000
--- a/src/main/java/com/android/volley/CacheDispatcher.java
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * 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 android.os.Process;
-import androidx.annotation.VisibleForTesting;
-import java.util.concurrent.BlockingQueue;
-
-/**
- * Provides a thread for performing cache triage on a queue of requests.
- *
- * <p>Requests added to the specified cache queue are resolved from cache. Any deliverable response
- * is posted back to the caller via a {@link ResponseDelivery}. Cache misses and responses that
- * require refresh are enqueued on the specified network queue for processing by a {@link
- * NetworkDispatcher}.
- */
-public class CacheDispatcher extends Thread {
-
-    private static final boolean DEBUG = VolleyLog.DEBUG;
-
-    /** The queue of requests coming in for triage. */
-    private final BlockingQueue<Request<?>> mCacheQueue;
-
-    /** The queue of requests going out to the network. */
-    private final BlockingQueue<Request<?>> mNetworkQueue;
-
-    /** The cache to read from. */
-    private final Cache mCache;
-
-    /** For posting responses. */
-    private final ResponseDelivery mDelivery;
-
-    /** Used for telling us to die. */
-    private volatile boolean mQuit = false;
-
-    /** Manage list of waiting requests and de-duplicate requests with same cache key. */
-    private final WaitingRequestManager mWaitingRequestManager;
-
-    /**
-     * Creates a new cache triage dispatcher thread. You must call {@link #start()} in order to
-     * begin processing.
-     *
-     * @param cacheQueue Queue of incoming requests for triage
-     * @param networkQueue Queue to post requests that require network to
-     * @param cache Cache interface to use for resolution
-     * @param delivery Delivery interface to use for posting responses
-     */
-    public CacheDispatcher(
-            BlockingQueue<Request<?>> cacheQueue,
-            BlockingQueue<Request<?>> networkQueue,
-            Cache cache,
-            ResponseDelivery delivery) {
-        mCacheQueue = cacheQueue;
-        mNetworkQueue = networkQueue;
-        mCache = cache;
-        mDelivery = delivery;
-        mWaitingRequestManager = new WaitingRequestManager(this, networkQueue, delivery);
-    }
-
-    /**
-     * Forces this dispatcher to quit immediately. If any requests are still in the queue, they are
-     * not guaranteed to be processed.
-     */
-    public void quit() {
-        mQuit = true;
-        interrupt();
-    }
-
-    @Override
-    public void run() {
-        if (DEBUG) VolleyLog.v("start new dispatcher");
-        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
-
-        // Make a blocking call to initialize the cache.
-        mCache.initialize();
-
-        while (true) {
-            try {
-                processRequest();
-            } catch (InterruptedException e) {
-                // We may have been interrupted because it was time to quit.
-                if (mQuit) {
-                    Thread.currentThread().interrupt();
-                    return;
-                }
-                VolleyLog.e(
-                        "Ignoring spurious interrupt of CacheDispatcher thread; "
-                                + "use quit() to terminate it");
-            }
-        }
-    }
-
-    // Extracted to its own method to ensure locals have a constrained liveness scope by the GC.
-    // This is needed to avoid keeping previous request references alive for an indeterminate amount
-    // of time. Update consumer-proguard-rules.pro when modifying this. See also
-    // https://github.com/google/volley/issues/114
-    private void processRequest() throws InterruptedException {
-        // Get a request from the cache triage queue, blocking until
-        // at least one is available.
-        final Request<?> request = mCacheQueue.take();
-        processRequest(request);
-    }
-
-    @VisibleForTesting
-    void processRequest(final Request<?> request) throws InterruptedException {
-        request.addMarker("cache-queue-take");
-        request.sendEvent(RequestQueue.RequestEvent.REQUEST_CACHE_LOOKUP_STARTED);
-
-        try {
-            // If the request has been canceled, don't bother dispatching it.
-            if (request.isCanceled()) {
-                request.finish("cache-discard-canceled");
-                return;
-            }
-
-            // Attempt to retrieve this item from cache.
-            Cache.Entry entry = mCache.get(request.getCacheKey());
-            if (entry == null) {
-                request.addMarker("cache-miss");
-                // Cache miss; send off to the network dispatcher.
-                if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
-                    mNetworkQueue.put(request);
-                }
-                return;
-            }
-
-            // If it is completely expired, just send it to the network.
-            if (entry.isExpired()) {
-                request.addMarker("cache-hit-expired");
-                request.setCacheEntry(entry);
-                if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
-                    mNetworkQueue.put(request);
-                }
-                return;
-            }
-
-            // We have a cache hit; parse its data for delivery back to the request.
-            request.addMarker("cache-hit");
-            Response<?> response =
-                    request.parseNetworkResponse(
-                            new NetworkResponse(entry.data, entry.responseHeaders));
-            request.addMarker("cache-hit-parsed");
-
-            if (!response.isSuccess()) {
-                request.addMarker("cache-parsing-failed");
-                mCache.invalidate(request.getCacheKey(), true);
-                request.setCacheEntry(null);
-                if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
-                    mNetworkQueue.put(request);
-                }
-                return;
-            }
-            if (!entry.refreshNeeded()) {
-                // Completely unexpired cache hit. Just deliver the response.
-                mDelivery.postResponse(request, 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.
-                request.addMarker("cache-hit-refresh-needed");
-                request.setCacheEntry(entry);
-                // Mark the response as intermediate.
-                response.intermediate = true;
-
-                if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
-                    // Post the intermediate response back to the user and have
-                    // the delivery then forward the request along to the network.
-                    mDelivery.postResponse(
-                            request,
-                            response,
-                            new Runnable() {
-                                @Override
-                                public void run() {
-                                    try {
-                                        mNetworkQueue.put(request);
-                                    } catch (InterruptedException e) {
-                                        // Restore the interrupted status
-                                        Thread.currentThread().interrupt();
-                                    }
-                                }
-                            });
-                } else {
-                    // request has been added to list of waiting requests
-                    // to receive the network response from the first request once it returns.
-                    mDelivery.postResponse(request, response);
-                }
-            }
-        } finally {
-            request.sendEvent(RequestQueue.RequestEvent.REQUEST_CACHE_LOOKUP_FINISHED);
-        }
-    }
-}