Ensure lint is quiet for styles, fix handler to be static class.

Author: dnkoutso

picasso-sample/lint.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<lint>
+  <issue id="NewApi">
+    <ignore path="res/values/styles.xml" />
+  </issue>
+</lint>

picasso/src/main/java/com/squareup/picasso/Dispatcher.java

@@ -80,7 +80,7 @@ class Dispatcher {
     this.context = context;
     this.service = service;
     this.hunterMap = new LinkedHashMap<String, BitmapHunter>();
-    this.handler = new DispatcherHandler(dispatcherThread.getLooper());
+    this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);
     this.downloader = downloader;
     this.mainThreadHandler = mainThreadHandler;
     this.cache = cache;
@@ -208,53 +208,60 @@ private void batch(BitmapHunter hunter) {
     }
   }
 
-  private class DispatcherHandler extends Handler {
-    public DispatcherHandler(Looper looper) {
+  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(Message msg) {
+    @Override public void handleMessage(final Message msg) {
       switch (msg.what) {
         case REQUEST_SUBMIT: {
           Action action = (Action) msg.obj;
-          performSubmit(action);
+          dispatcher.performSubmit(action);
           break;
         }
         case REQUEST_CANCEL: {
           Action action = (Action) msg.obj;
-          performCancel(action);
+          dispatcher.performCancel(action);
           break;
         }
         case HUNTER_COMPLETE: {
           BitmapHunter hunter = (BitmapHunter) msg.obj;
-          performComplete(hunter);
+          dispatcher.performComplete(hunter);
           break;
         }
         case HUNTER_RETRY: {
           BitmapHunter hunter = (BitmapHunter) msg.obj;
-          performRetry(hunter);
+          dispatcher.performRetry(hunter);
           break;
         }
         case HUNTER_DECODE_FAILED: {
           BitmapHunter hunter = (BitmapHunter) msg.obj;
-          performError(hunter);
+          dispatcher.performError(hunter);
           break;
         }
         case HUNTER_DELAY_NEXT_BATCH: {
-          performBatchComplete();
+          dispatcher.performBatchComplete();
           break;
         }
         case NETWORK_STATE_CHANGE: {
           NetworkInfo info = (NetworkInfo) msg.obj;
-          performNetworkStateChange(info);
+          dispatcher.performNetworkStateChange(info);
           break;
         }
         case AIRPLANE_MODE_CHANGE: {
-          performAirplaneModeChange(msg.arg1 == AIRPLANE_MODE_ON);
+          dispatcher.performAirplaneModeChange(msg.arg1 == AIRPLANE_MODE_ON);
           break;
         }
         default:
-          throw new AssertionError("Unknown handler message received: " + msg.what);
+          Picasso.HANDLER.post(new Runnable() {
+            @Override public void run() {
+              throw new AssertionError("Unknown handler message received: " + msg.what);
+            }
+          });
       }
     }
   }

picasso/src/main/java/com/squareup/picasso/Stats.java

@@ -24,11 +24,10 @@
 import static android.os.Process.THREAD_PRIORITY_BACKGROUND;
 
 class Stats {
-  private static final int REQUESTED_COMPLETED = 0;
-  private static final int CACHE_HIT = 1;
-  private static final int CACHE_MISS = 2;
-  private static final int BITMAP_DECODE_FINISHED = 3;
-  private static final int BITMAP_TRANSFORMED_FINISHED = 4;
+  private static final int CACHE_HIT = 0;
+  private static final int CACHE_MISS = 1;
+  private static final int BITMAP_DECODE_FINISHED = 2;
+  private static final int BITMAP_TRANSFORMED_FINISHED = 3;
 
   private static final String STATS_THREAD_NAME = Utils.THREAD_PREFIX + "Stats";
 
@@ -49,7 +48,7 @@ class Stats {
     this.cache = cache;
     this.statsThread = new HandlerThread(STATS_THREAD_NAME, THREAD_PRIORITY_BACKGROUND);
     this.statsThread.start();
-    this.handler = new StatsHandler(statsThread.getLooper());
+    this.handler = new StatsHandler(statsThread.getLooper(), this);
   }
 
   void dispatchBitmapDecoded(Bitmap bitmap) {
@@ -89,8 +88,7 @@ void performBitmapDecoded(long size) {
   void performBitmapTransformed(long size) {
     transformedBitmapCount++;
     totalTransformedBitmapSize += size;
-    averageTransformedBitmapSize =
-        getAverage(originalBitmapCount, totalTransformedBitmapSize);
+    averageTransformedBitmapSize = getAverage(originalBitmapCount, totalTransformedBitmapSize);
   }
 
   synchronized StatsSnapshot createSnapshot() {
@@ -110,37 +108,35 @@ private static long getAverage(int count, long totalSize) {
     return totalSize / count;
   }
 
-  private class StatsHandler extends Handler {
+  private static class StatsHandler extends Handler {
 
-    public StatsHandler(Looper looper) {
+    private final Stats stats;
+
+    public StatsHandler(Looper looper, Stats stats) {
       super(looper);
+      this.stats = stats;
     }
 
     @Override public void handleMessage(final Message msg) {
-      synchronized (Stats.this) {
-        switch (msg.what) {
-          case CACHE_HIT:
-            performCacheHit();
-            break;
-          case CACHE_MISS:
-            performCacheMiss();
-            break;
-          case BITMAP_DECODE_FINISHED:
-            performBitmapDecoded(msg.arg1);
-            break;
-          case BITMAP_TRANSFORMED_FINISHED:
-            performBitmapTransformed(msg.arg1);
-            break;
-          case REQUESTED_COMPLETED:
-            break;
-          default:
-            Handler mainHandler = new Handler(Looper.getMainLooper());
-            mainHandler.post(new Runnable() {
-              @Override public void run() {
-                throw new AssertionError("Unhandled stats message." + msg.what);
-              }
-            });
-        }
+      switch (msg.what) {
+        case CACHE_HIT:
+          stats.performCacheHit();
+          break;
+        case CACHE_MISS:
+          stats.performCacheMiss();
+          break;
+        case BITMAP_DECODE_FINISHED:
+          stats.performBitmapDecoded(msg.arg1);
+          break;
+        case BITMAP_TRANSFORMED_FINISHED:
+          stats.performBitmapTransformed(msg.arg1);
+          break;
+        default:
+          Picasso.HANDLER.post(new Runnable() {
+            @Override public void run() {
+              throw new AssertionError("Unhandled stats message." + msg.what);
+            }
+          });
       }
     }
   }