FileDocCategorySizeDatePackage
CacheDispatcher.javaAPI DocAndroid 5.1 API6004Thu Mar 12 22:22:56 GMT 2015com.android.volley

CacheDispatcher

public class CacheDispatcher extends Thread
Provides a thread for performing cache triage on a queue of requests. 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}.

Fields Summary
private static final boolean
DEBUG
private final BlockingQueue
mCacheQueue
The queue of requests coming in for triage.
private final BlockingQueue
mNetworkQueue
The queue of requests going out to the network.
private final Cache
mCache
The cache to read from.
private final ResponseDelivery
mDelivery
For posting responses.
private volatile boolean
mQuit
Used for telling us to die.
Constructors Summary
public CacheDispatcher(BlockingQueue cacheQueue, BlockingQueue networkQueue, Cache cache, ResponseDelivery delivery)
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


                                                              
     
               
                
        mCacheQueue = cacheQueue;
        mNetworkQueue = networkQueue;
        mCache = cache;
        mDelivery = delivery;
Methods Summary
public voidquit()
Forces this dispatcher to quit immediately. If any requests are still in the queue, they are not guaranteed to be processed.

        mQuit = true;
        interrupt();
public voidrun()

        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 {
                // Get a request from the cache triage queue, blocking until
                // at least one is available.
                final Request<?> request = mCacheQueue.take();
                request.addMarker("cache-queue-take");

                // If the request has been canceled, don't bother dispatching it.
                if (request.isCanceled()) {
                    request.finish("cache-discard-canceled");
                    continue;
                }

                // 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.
                    mNetworkQueue.put(request);
                    continue;
                }

                // If it is completely expired, just send it to the network.
                if (entry.isExpired()) {
                    request.addMarker("cache-hit-expired");
                    request.setCacheEntry(entry);
                    mNetworkQueue.put(request);
                    continue;
                }

                // 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 (!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;

                    // 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) {
                                // Not much we can do about this.
                            }
                        }
                    });
                }

            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
                continue;
            }
        }