Home | History | Annotate | Download | only in volley 
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.volley;
     18 
     19 import android.net.TrafficStats;
     20 import android.os.Build;
     21 import android.os.Process;
     22 
     23 import java.util.concurrent.BlockingQueue;
     24 
     25 /**
     26  * Provides a thread for performing network dispatch from a queue of requests.
     27  *
     28  * Requests added to the specified queue are processed from the network via a
     29  * specified {@link Network} interface. Responses are committed to cache, if
     30  * eligible, using a specified {@link Cache} interface. Valid responses and
     31  * errors are posted back to the caller via a {@link ResponseDelivery}.
     32  */
     33 @SuppressWarnings("rawtypes")
     34 public class NetworkDispatcher extends Thread {
     35     /** The queue of requests to service. */
     36     private final BlockingQueue<Request> mQueue;
     37     /** The network interface for processing requests. */
     38     private final Network mNetwork;
     39     /** The cache to write to. */
     40     private final Cache mCache;
     41     /** For posting responses and errors. */
     42     private final ResponseDelivery mDelivery;
     43     /** Used for telling us to die. */
     44     private volatile boolean mQuit = false;
     45 
     46     /**
     47      * Creates a new network dispatcher thread.  You must call {@link #start()}
     48      * in order to begin processing.
     49      *
     50      * @param queue Queue of incoming requests for triage
     51      * @param network Network interface to use for performing requests
     52      * @param cache Cache interface to use for writing responses to cache
     53      * @param delivery Delivery interface to use for posting responses
     54      */
     55     public NetworkDispatcher(BlockingQueue<Request> queue,
     56             Network network, Cache cache,
     57             ResponseDelivery delivery) {
     58         mQueue = queue;
     59         mNetwork = network;
     60         mCache = cache;
     61         mDelivery = delivery;
     62     }
     63 
     64     /**
     65      * Forces this dispatcher to quit immediately.  If any requests are still in
     66      * the queue, they are not guaranteed to be processed.
     67      */
     68     public void quit() {
     69         mQuit = true;
     70         interrupt();
     71     }
     72 
     73     @Override
     74     public void run() {
     75         Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
     76         Request request;
     77         while (true) {
     78             try {
     79                 // Take a request from the queue.
     80                 request = mQueue.take();
     81             } catch (InterruptedException e) {
     82                 // We may have been interrupted because it was time to quit.
     83                 if (mQuit) {
     84                     return;
     85                 }
     86                 continue;
     87             }
     88 
     89             try {
     90                 request.addMarker("network-queue-take");
     91 
     92                 // If the request was cancelled already, do not perform the
     93                 // network request.
     94                 if (request.isCanceled()) {
     95                     request.finish("network-discard-cancelled");
     96                     continue;
     97                 }
     98 
     99                 // Tag the request (if API >= 14)
    100                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
    101                     TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());
    102                 }
    103 
    104                 // Perform the network request.
    105                 NetworkResponse networkResponse = mNetwork.performRequest(request);
    106                 request.addMarker("network-http-complete");
    107 
    108                 // If the server returned 304 AND we delivered a response already,
    109                 // we're done -- don't deliver a second identical response.
    110                 if (networkResponse.notModified && request.hasHadResponseDelivered()) {
    111                     request.finish("not-modified");
    112                     continue;
    113                 }
    114 
    115                 // Parse the response here on the worker thread.
    116                 Response<?> response = request.parseNetworkResponse(networkResponse);
    117                 request.addMarker("network-parse-complete");
    118 
    119                 // Write to cache if applicable.
    120                 // TODO: Only update cache metadata instead of entire record for 304s.
    121                 if (request.shouldCache() && response.cacheEntry != null) {
    122                     mCache.put(request.getCacheKey(), response.cacheEntry);
    123                     request.addMarker("network-cache-written");
    124                 }
    125 
    126                 // Post the response back.
    127                 request.markDelivered();
    128                 mDelivery.postResponse(request, response);
    129             } catch (VolleyError volleyError) {
    130                 parseAndDeliverNetworkError(request, volleyError);
    131             } catch (Exception e) {
    132                 VolleyLog.e(e, "Unhandled exception %s", e.toString());
    133                 mDelivery.postError(request, new VolleyError(e));
    134             }
    135         }
    136     }
    137 
    138     private void parseAndDeliverNetworkError(Request<?> request, VolleyError error) {
    139         error = request.parseNetworkError(error);
    140         mDelivery.postError(request, error);
    141     }
    142 }
    143