volley7–NetworkDispatcher从网络中获取数据[通俗易懂]

 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.annotation.TargetApi;  20 import android.net.TrafficStats;  21 import android.os.Build;  22 import android.os.Process;  23 import android.os.SystemClock;  24  25 import java.util.concurrent.BlockingQueue;  26  27 /**  28  * Provides a thread for performing network dispatch from a queue of requests.  29  *  30  * Requests added to the specified queue are processed from the network via a  31  * specified {@link Network} interface. Responses are committed to cache, if  32  * eligible, using a specified {@link Cache} interface. Valid responses and  33  * errors are posted back to the caller via a {@link ResponseDelivery}.  34 */  35 public class NetworkDispatcher extends Thread {  36 /** The queue of requests to service. */  37 private final BlockingQueue<Request<?>> mQueue;  38 /** The network interface for processing requests. */  39 private final Network mNetwork;  40 /** The cache to write to. */  41 private final Cache mCache;  42 /** For posting responses and errors. */  43 private final ResponseDelivery mDelivery;  44 /** Used for telling us to die. */  45 private volatile boolean mQuit = false;  46  47 /**  48  * Creates a new network dispatcher thread. You must call {@link #start()}  49  * in order to begin processing.  50  *  51  * @param queue Queue of incoming requests for triage  52  * @param network Network interface to use for performing requests  53  * @param cache Cache interface to use for writing responses to cache  54  * @param delivery Delivery interface to use for posting responses  55 */  56 public NetworkDispatcher(BlockingQueue<Request<?>> queue,  57  Network network, Cache cache,  58  ResponseDelivery delivery) {  59 mQueue = queue;  60 mNetwork = network;  61 mCache = cache;  62 mDelivery = delivery;  63  }  64  65 /**  66  * Forces this dispatcher to quit immediately. If any requests are still in  67  * the queue, they are not guaranteed to be processed.  68 */  69 public void quit() {  70 mQuit = true;  71  interrupt();  72  }  73  74  @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)  75 private void addTrafficStatsTag(Request<?> request) {  76 // Tag the request (if API >= 14)  77 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {  78  TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());  79  }  80  }  81  82  @Override  83 public void run() {  84  Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  85 Request<?> request;  86 while (true) {  87 long startTimeMs = SystemClock.elapsedRealtime();  88 // release previous request object to avoid leaking request object when mQueue is drained.  89 request = null;  90 try {  91 // Take a request from the queue.  92 request = mQueue.take();  93 } catch (InterruptedException e) {  94 // We may have been interrupted because it was time to quit.  95 if (mQuit) {  96 return;  97  }  98 continue;  99  } 100 101 try { 102 request.addMarker("network-queue-take"); 103 104 // If the request was cancelled already, do not perform the 105 // network request. 106 if (request.isCanceled()) { 107 request.finish("network-discard-cancelled"); 108 continue; 109  } 110 111  addTrafficStatsTag(request); 112 113 // Perform the network request. 114 NetworkResponse networkResponse = mNetwork.performRequest(request); 115 request.addMarker("network-http-complete"); 116 117 // If the server returned 304 AND we delivered a response already, 118 // we're done -- don't deliver a second identical response. 119 if (networkResponse.notModified && request.hasHadResponseDelivered()) { 120 request.finish("not-modified"); 121 continue; 122  } 123 124 // Parse the response here on the worker thread. 125 Response<?> response = request.parseNetworkResponse(networkResponse); 126 request.addMarker("network-parse-complete"); 127 128 // Write to cache if applicable. 129 // TODO: Only update cache metadata instead of entire record for 304s. 130 if (request.shouldCache() && response.cacheEntry != null) { 131  mCache.put(request.getCacheKey(), response.cacheEntry); 132 request.addMarker("network-cache-written"); 133  } 134 135 // Post the response back. 136  request.markDelivered(); 137  mDelivery.postResponse(request, response); 138 } catch (VolleyError volleyError) { 139 volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs); 140  parseAndDeliverNetworkError(request, volleyError); 141 } catch (Exception e) { 142 VolleyLog.e(e, "Unhandled exception %s", e.toString()); 143 VolleyError volleyError = new VolleyError(e); 144 volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs); 145  mDelivery.postError(request, volleyError); 146  } 147  } 148  } 149 150 private void parseAndDeliverNetworkError(Request<?> request, VolleyError error) { 151 error = request.parseNetworkError(error); 152  mDelivery.postError(request, error); 153  } 154 }