The Tor Browser: mobile/android/thirdparty/com/squareup/picasso/Dispatcher.java@6474c204b198 (annotated)

mobile/android/thirdparty/com/squareup/picasso/Dispatcher.java@6474c204b198 (annotated)

mobile/android/thirdparty/com/squareup/picasso/Dispatcher.java

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /*
  * Copyright (C) 2013 Square, Inc.
  *
  * 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.squareup.picasso;
 import android.Manifest;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
 import android.os.Message;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import static android.content.Context.CONNECTIVITY_SERVICE;
 import static android.content.Intent.ACTION_AIRPLANE_MODE_CHANGED;
 import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;
 import static android.os.Process.THREAD_PRIORITY_BACKGROUND;
 import static com.squareup.picasso.BitmapHunter.forRequest;
 class Dispatcher {
   private static final int RETRY_DELAY = 500;
   private static final int AIRPLANE_MODE_ON = 1;
   private static final int AIRPLANE_MODE_OFF = 0;
   static final int REQUEST_SUBMIT = 1;
   static final int REQUEST_CANCEL = 2;
   static final int REQUEST_GCED = 3;
   static final int HUNTER_COMPLETE = 4;
   static final int HUNTER_RETRY = 5;
   static final int HUNTER_DECODE_FAILED = 6;
   static final int HUNTER_DELAY_NEXT_BATCH = 7;
   static final int HUNTER_BATCH_COMPLETE = 8;
   static final int NETWORK_STATE_CHANGE = 9;
   static final int AIRPLANE_MODE_CHANGE = 10;
   private static final String DISPATCHER_THREAD_NAME = "Dispatcher";
   private static final int BATCH_DELAY = 200; // ms
   final DispatcherThread dispatcherThread;
   final Context context;
   final ExecutorService service;
   final Downloader downloader;
   final Map<String, BitmapHunter> hunterMap;
   final Handler handler;
   final Handler mainThreadHandler;
   final Cache cache;
   final Stats stats;
   final List<BitmapHunter> batch;
   final NetworkBroadcastReceiver receiver;
   NetworkInfo networkInfo;
   boolean airplaneMode;
   Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler,
       Downloader downloader, Cache cache, Stats stats) {
     this.dispatcherThread = new DispatcherThread();
     this.dispatcherThread.start();
     this.context = context;
     this.service = service;
     this.hunterMap = new LinkedHashMap<String, BitmapHunter>();
     this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);
     this.downloader = downloader;
     this.mainThreadHandler = mainThreadHandler;
     this.cache = cache;
     this.stats = stats;
     this.batch = new ArrayList<BitmapHunter>(4);
     this.airplaneMode = Utils.isAirplaneModeOn(this.context);
     this.receiver = new NetworkBroadcastReceiver(this.context);
     receiver.register();
   }
   void shutdown() {
     service.shutdown();
     dispatcherThread.quit();
     receiver.unregister();
   }
   void dispatchSubmit(Action action) {
     handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action));
   }
   void dispatchCancel(Action action) {
     handler.sendMessage(handler.obtainMessage(REQUEST_CANCEL, action));
   }
   void dispatchComplete(BitmapHunter hunter) {
     handler.sendMessage(handler.obtainMessage(HUNTER_COMPLETE, hunter));
   }
   void dispatchRetry(BitmapHunter hunter) {
     handler.sendMessageDelayed(handler.obtainMessage(HUNTER_RETRY, hunter), RETRY_DELAY);
   }
   void dispatchFailed(BitmapHunter hunter) {
     handler.sendMessage(handler.obtainMessage(HUNTER_DECODE_FAILED, hunter));
   }
   void dispatchNetworkStateChange(NetworkInfo info) {
     handler.sendMessage(handler.obtainMessage(NETWORK_STATE_CHANGE, info));
   }
   void dispatchAirplaneModeChange(boolean airplaneMode) {
     handler.sendMessage(handler.obtainMessage(AIRPLANE_MODE_CHANGE,
         airplaneMode ? AIRPLANE_MODE_ON : AIRPLANE_MODE_OFF, 0));
   }
   void performSubmit(Action action) {
     BitmapHunter hunter = hunterMap.get(action.getKey());
     if (hunter != null) {
       hunter.attach(action);
       return;
     }
     if (service.isShutdown()) {
       return;
     }
     hunter = forRequest(context, action.getPicasso(), this, cache, stats, action, downloader);
     hunter.future = service.submit(hunter);
     hunterMap.put(action.getKey(), hunter);
   }
   void performCancel(Action action) {
     String key = action.getKey();
     BitmapHunter hunter = hunterMap.get(key);
     if (hunter != null) {
       hunter.detach(action);
       if (hunter.cancel()) {
         hunterMap.remove(key);
       }
     }
   }
   void performRetry(BitmapHunter hunter) {
     if (hunter.isCancelled()) return;
     if (service.isShutdown()) {
       performError(hunter);
       return;
     }
     if (hunter.shouldRetry(airplaneMode, networkInfo)) {
       hunter.future = service.submit(hunter);
     } else {
       performError(hunter);
     }
   }
   void performComplete(BitmapHunter hunter) {
     if (!hunter.shouldSkipMemoryCache()) {
       cache.set(hunter.getKey(), hunter.getResult());
     }
     hunterMap.remove(hunter.getKey());
     batch(hunter);
   }
   void performBatchComplete() {
     List<BitmapHunter> copy = new ArrayList<BitmapHunter>(batch);
     batch.clear();
     mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy));
   }
   void performError(BitmapHunter hunter) {
     hunterMap.remove(hunter.getKey());
     batch(hunter);
   }
   void performAirplaneModeChange(boolean airplaneMode) {
     this.airplaneMode = airplaneMode;
   }
   void performNetworkStateChange(NetworkInfo info) {
     networkInfo = info;
     if (service instanceof PicassoExecutorService) {
       ((PicassoExecutorService) service).adjustThreadCount(info);
     }
   }
   private void batch(BitmapHunter hunter) {
     if (hunter.isCancelled()) {
       return;
     }
     batch.add(hunter);
     if (!handler.hasMessages(HUNTER_DELAY_NEXT_BATCH)) {
       handler.sendEmptyMessageDelayed(HUNTER_DELAY_NEXT_BATCH, BATCH_DELAY);
     }
   }
   private static class DispatcherHandler extends Handler {
     private final Dispatcher dispatcher;
     public DispatcherHandler(Looper looper, Dispatcher dispatcher) {
       super(looper);
       this.dispatcher = dispatcher;
     }
     @Override public void handleMessage(final Message msg) {
       switch (msg.what) {
         case REQUEST_SUBMIT: {
           Action action = (Action) msg.obj;
           dispatcher.performSubmit(action);
           break;
         }
         case REQUEST_CANCEL: {
           Action action = (Action) msg.obj;
           dispatcher.performCancel(action);
           break;
         }
         case HUNTER_COMPLETE: {
           BitmapHunter hunter = (BitmapHunter) msg.obj;
           dispatcher.performComplete(hunter);
           break;
         }
         case HUNTER_RETRY: {
           BitmapHunter hunter = (BitmapHunter) msg.obj;
           dispatcher.performRetry(hunter);
           break;
         }
         case HUNTER_DECODE_FAILED: {
           BitmapHunter hunter = (BitmapHunter) msg.obj;
           dispatcher.performError(hunter);
           break;
         }
         case HUNTER_DELAY_NEXT_BATCH: {
           dispatcher.performBatchComplete();
           break;
         }
         case NETWORK_STATE_CHANGE: {
           NetworkInfo info = (NetworkInfo) msg.obj;
           dispatcher.performNetworkStateChange(info);
           break;
         }
         case AIRPLANE_MODE_CHANGE: {
           dispatcher.performAirplaneModeChange(msg.arg1 == AIRPLANE_MODE_ON);
           break;
         }
         default:
           Picasso.HANDLER.post(new Runnable() {
             @Override public void run() {
               throw new AssertionError("Unknown handler message received: " + msg.what);
             }
           });
       }
     }
   }
   static class DispatcherThread extends HandlerThread {
     DispatcherThread() {
       super(Utils.THREAD_PREFIX + DISPATCHER_THREAD_NAME, THREAD_PRIORITY_BACKGROUND);
     }
   }
   private class NetworkBroadcastReceiver extends BroadcastReceiver {
     private static final String EXTRA_AIRPLANE_STATE = "state";
     private final ConnectivityManager connectivityManager;
     NetworkBroadcastReceiver(Context context) {
       connectivityManager = (ConnectivityManager) context.getSystemService(CONNECTIVITY_SERVICE);
     }
     void register() {
       boolean shouldScanState = service instanceof PicassoExecutorService && //
           Utils.hasPermission(context, Manifest.permission.ACCESS_NETWORK_STATE);
       IntentFilter filter = new IntentFilter();
       filter.addAction(ACTION_AIRPLANE_MODE_CHANGED);
       if (shouldScanState) {
         filter.addAction(CONNECTIVITY_ACTION);
       }
       context.registerReceiver(this, filter);
     }
     void unregister() {
       context.unregisterReceiver(this);
     }
     @Override public void onReceive(Context context, Intent intent) {
       // On some versions of Android this may be called with a null Intent
       if (null == intent) {
         return;
       }
       String action = intent.getAction();
       Bundle extras = intent.getExtras();
       if (ACTION_AIRPLANE_MODE_CHANGED.equals(action)) {
         dispatchAirplaneModeChange(extras.getBoolean(EXTRA_AIRPLANE_STATE, false));
       } else if (CONNECTIVITY_ACTION.equals(action)) {
         dispatchNetworkStateChange(connectivityManager.getActiveNetworkInfo());
       }
     }
   }
 }

The Tor Browser / annotate

mobile/android/thirdparty/com/squareup/picasso/Dispatcher.java@6474c204b198 (annotated)

mobile/android/thirdparty/com/squareup/picasso/Dispatcher.java