Volley7 – networkdispatcher obtains data from the network [easy to understand]

Hello everyone , I meet you again , I'm the king of the whole stack .

Source code ：

  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 }

Copy

NetworkDispatcher

Publisher ： Full stack programmer stack length , Reprint please indicate the source ：https://javaforall.cn/108121.html Link to the original text ：https://javaforall.cn