Merge pull request square#385 from square/dimitris/download-stats

Add download stats.

Author: dnkoutso

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

@@ -47,35 +47,66 @@ class Response {
     final InputStream stream;
     final Bitmap bitmap;
     final boolean cached;
+    final long contentLength;
 
     /**
      * Response image and info.
      *
      * @param bitmap Image.
      * @param loadedFromCache {@code true} if the source of the image is from a local disk cache.
+     * @deprecated Use {@link Response#Response(android.graphics.Bitmap, boolean, long)} instead.
      */
+    @Deprecated @SuppressWarnings("UnusedDeclaration")
     public Response(Bitmap bitmap, boolean loadedFromCache) {
+      this(bitmap, loadedFromCache, 0);
+    }
+
+    /**
+     * Response stream and info.
+     *
+     * @param stream Image data stream.
+     * @param loadedFromCache {@code true} if the source of the stream is from a local disk cache.
+     * @deprecated Use {@link Response#Response(java.io.InputStream, boolean, long)} instead.
+     */
+    @Deprecated @SuppressWarnings("UnusedDeclaration")
+    public Response(InputStream stream, boolean loadedFromCache) {
+      this(stream, loadedFromCache, 0);
+    }
+
+    /**
+     * Response image and info.
+     *
+     * @param bitmap Image.
+     * @param loadedFromCache {@code true} if the source of the image is from a local disk cache.
+     * @param contentLength The content length of the response, typically derived by the
+     * {@code Content-Length} HTTP header.
+     */
+    public Response(Bitmap bitmap, boolean loadedFromCache, long contentLength) {
       if (bitmap == null) {
         throw new IllegalArgumentException("Bitmap may not be null.");
       }
       this.stream = null;
       this.bitmap = bitmap;
       this.cached = loadedFromCache;
+      this.contentLength = contentLength;
     }
 
     /**
      * Response stream and info.
      *
      * @param stream Image data stream.
      * @param loadedFromCache {@code true} if the source of the stream is from a local disk cache.
+     * @param contentLength The content length of the response, typically derived by the
+     * {@code Content-Length} HTTP header.
      */
-    public Response(InputStream stream, boolean loadedFromCache) {
+    public Response(InputStream stream, boolean loadedFromCache, long contentLength) {
       if (stream == null) {
         throw new IllegalArgumentException("Stream may not be null.");
       }
       this.stream = stream;
       this.bitmap = null;
       this.cached = loadedFromCache;
+      this.contentLength = contentLength;
     }
 
     /**
@@ -95,5 +126,10 @@ public InputStream getInputStream() {
     public Bitmap getBitmap() {
       return bitmap;
     }
+
+    /** Content length of the response. */
+    public long getContentLength() {
+      return contentLength;
+    }
   }
 }

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

@@ -56,6 +56,12 @@ public NetworkBitmapHunter(Picasso picasso, Dispatcher dispatcher, Cache cache,
     }
 
     InputStream is = response.getInputStream();
+    if (is == null) {
+      return null;
+    }
+    if (loadedFrom == NETWORK && response.getContentLength() > 0) {
+      stats.dispatchDownloadFinished(response.getContentLength());
+    }
     try {
       return decodeStream(is, data);
     } finally {
@@ -73,9 +79,6 @@ public NetworkBitmapHunter(Picasso picasso, Dispatcher dispatcher, Cache cache,
   }
 
   private Bitmap decodeStream(InputStream stream, Request data) throws IOException {
-    if (stream == null) {
-      return null;
-    }
     MarkableInputStream markStream = new MarkableInputStream(stream);
     stream = markStream;
 

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

@@ -112,8 +112,10 @@ protected OkHttpClient getClient() {
     if (responseSource == null) {
       responseSource = connection.getHeaderField(RESPONSE_SOURCE_ANDROID);
     }
+
+    long contentLength = connection.getHeaderFieldInt("Content-Length", 0);
     boolean fromCache = parseResponseSourceHeader(responseSource);
 
-    return new Response(connection.getInputStream(), fromCache);
+    return new Response(connection.getInputStream(), fromCache, contentLength);
   }
 }

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

@@ -227,7 +227,11 @@ public RequestCreator load(int resourceId) {
     this.debugging = debugging;
   }
 
-  /** Creates a {@link StatsSnapshot} of the current stats for this instance. */
+  /**
+   * Creates a {@link StatsSnapshot} of the current stats for this instance.
+   * <b>NOTE:</b> The snapshot may not always be completely up-to-date if requests are still in
+   * progress.
+   */
   @SuppressWarnings("UnusedDeclaration") public StatsSnapshot getSnapshot() {
     return stats.createSnapshot();
   }

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

@@ -28,6 +28,7 @@ class Stats {
   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 int DOWNLOAD_FINISHED = 4;
 
   private static final String STATS_THREAD_NAME = Utils.THREAD_PREFIX + "Stats";
 
@@ -37,10 +38,13 @@ class Stats {
 
   long cacheHits;
   long cacheMisses;
+  long totalDownloadSize;
   long totalOriginalBitmapSize;
   long totalTransformedBitmapSize;
+  long averageDownloadSize;
   long averageOriginalBitmapSize;
   long averageTransformedBitmapSize;
+  int downloadCount;
   int originalBitmapCount;
   int transformedBitmapCount;
 
@@ -59,6 +63,10 @@ void dispatchBitmapTransformed(Bitmap bitmap) {
     processBitmap(bitmap, BITMAP_TRANSFORMED_FINISHED);
   }
 
+  void dispatchDownloadFinished(long size) {
+    handler.sendMessage(handler.obtainMessage(DOWNLOAD_FINISHED, size));
+  }
+
   void dispatchCacheHit() {
     handler.sendEmptyMessage(CACHE_HIT);
   }
@@ -79,6 +87,12 @@ void performCacheMiss() {
     cacheMisses++;
   }
 
+  void performDownloadFinished(Long size) {
+    downloadCount++;
+    totalDownloadSize += size;
+    averageDownloadSize = getAverage(downloadCount, totalDownloadSize);
+  }
+
   void performBitmapDecoded(long size) {
     originalBitmapCount++;
     totalOriginalBitmapSize += size;
@@ -91,11 +105,11 @@ void performBitmapTransformed(long size) {
     averageTransformedBitmapSize = getAverage(originalBitmapCount, totalTransformedBitmapSize);
   }
 
-  synchronized StatsSnapshot createSnapshot() {
+  StatsSnapshot createSnapshot() {
     return new StatsSnapshot(cache.maxSize(), cache.size(), cacheHits, cacheMisses,
-        totalOriginalBitmapSize, totalTransformedBitmapSize, averageOriginalBitmapSize,
-        averageTransformedBitmapSize, originalBitmapCount, transformedBitmapCount,
-        System.currentTimeMillis());
+        totalDownloadSize, totalOriginalBitmapSize, totalTransformedBitmapSize, averageDownloadSize,
+        averageOriginalBitmapSize, averageTransformedBitmapSize, downloadCount, originalBitmapCount,
+        transformedBitmapCount, System.currentTimeMillis());
   }
 
   private void processBitmap(Bitmap bitmap, int what) {
@@ -131,6 +145,9 @@ public StatsHandler(Looper looper, Stats stats) {
         case BITMAP_TRANSFORMED_FINISHED:
           stats.performBitmapTransformed(msg.arg1);
           break;
+        case DOWNLOAD_FINISHED:
+          stats.performDownloadFinished((Long) msg.obj);
+          break;
         default:
           Picasso.HANDLER.post(new Runnable() {
             @Override public void run() {

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

@@ -27,34 +27,40 @@ public class StatsSnapshot {
   public final int size;
   public final long cacheHits;
   public final long cacheMisses;
+  public final long totalDownloadSize;
   public final long totalOriginalBitmapSize;
   public final long totalTransformedBitmapSize;
+  public final long averageDownloadSize;
   public final long averageOriginalBitmapSize;
   public final long averageTransformedBitmapSize;
+  public final int downloadCount;
   public final int originalBitmapCount;
   public final int transformedBitmapCount;
 
   public final long timeStamp;
 
   public StatsSnapshot(int maxSize, int size, long cacheHits, long cacheMisses,
-      long totalOriginalBitmapSize, long totalTransformedBitmapSize, long averageOriginalBitmapSize,
-      long averageTransformedBitmapSize, int originalBitmapCount, int transformedBitmapCount,
-      long timeStamp) {
+      long totalDownloadSize, long totalOriginalBitmapSize, long totalTransformedBitmapSize,
+      long averageDownloadSize, long averageOriginalBitmapSize, long averageTransformedBitmapSize,
+      int downloadCount, int originalBitmapCount, int transformedBitmapCount, long timeStamp) {
     this.maxSize = maxSize;
     this.size = size;
     this.cacheHits = cacheHits;
     this.cacheMisses = cacheMisses;
+    this.totalDownloadSize = totalDownloadSize;
     this.totalOriginalBitmapSize = totalOriginalBitmapSize;
     this.totalTransformedBitmapSize = totalTransformedBitmapSize;
+    this.averageDownloadSize = averageDownloadSize;
     this.averageOriginalBitmapSize = averageOriginalBitmapSize;
     this.averageTransformedBitmapSize = averageTransformedBitmapSize;
+    this.downloadCount = downloadCount;
     this.originalBitmapCount = originalBitmapCount;
     this.transformedBitmapCount = transformedBitmapCount;
     this.timeStamp = timeStamp;
   }
 
   /** Prints out this {@link StatsSnapshot} into log. */
-  public void dump() {
+  @SuppressWarnings("UnusedDeclaration") public void dump() {
     StringWriter logWriter = new StringWriter();
     dump(new PrintWriter(logWriter));
     Log.i(TAG, logWriter.toString());
@@ -74,6 +80,13 @@ public void dump(PrintWriter writer) {
     writer.println(cacheHits);
     writer.print("  Cache Misses: ");
     writer.println(cacheMisses);
+    writer.println("Network Stats");
+    writer.print("  Download Count: ");
+    writer.println(downloadCount);
+    writer.print("  Total Download Size: ");
+    writer.println(totalDownloadSize);
+    writer.print("  Average Download Size: ");
+    writer.println(averageDownloadSize);
     writer.println("Bitmap Stats");
     writer.print("  Total Bitmaps Decoded: ");
     writer.println(originalBitmapCount);
@@ -101,6 +114,12 @@ public void dump(PrintWriter writer) {
         + cacheHits
         + ", cacheMisses="
         + cacheMisses
+        + ", downloadCount="
+        + downloadCount
+        + ", totalDownloadSize="
+        + totalDownloadSize
+        + ", averageDownloadSize="
+        + averageDownloadSize
         + ", totalOriginalBitmapSize="
         + totalOriginalBitmapSize
         + ", totalTransformedBitmapSize="

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

@@ -67,9 +67,10 @@ protected HttpURLConnection openConnection(Uri path) throws IOException {
       throw new ResponseException(responseCode + " " + connection.getResponseMessage());
     }
 
+    long contentLength = connection.getHeaderFieldInt("Content-Length", 0);
     boolean fromCache = parseResponseSourceHeader(connection.getHeaderField(RESPONSE_SOURCE));
 
-    return new Response(connection.getInputStream(), fromCache);
+    return new Response(connection.getInputStream(), fromCache, contentLength);
   }
 
   private static void installCacheIfNeeded(Context context) {

picasso/src/test/java/com/squareup/picasso/NetworkBitmapHunterTest.java

@@ -30,12 +30,14 @@
 import static android.graphics.Bitmap.Config.ARGB_8888;
 import static com.squareup.picasso.TestUtils.URI_1;
 import static com.squareup.picasso.TestUtils.URI_KEY_1;
+import static com.squareup.picasso.TestUtils.mockInputStream;
 import static com.squareup.picasso.TestUtils.mockNetworkInfo;
 import static org.fest.assertions.api.Assertions.assertThat;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyBoolean;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
 import static org.mockito.Mockito.when;
 import static org.mockito.MockitoAnnotations.initMocks;
 
@@ -109,11 +111,41 @@ public class NetworkBitmapHunterTest {
     assertThat(hunter.shouldRetry(true, info)).isFalse();
   }
 
+  @Test public void noCacheAndKnownContentLengthDispatchToStats() throws Exception {
+    Downloader.Response response = new Downloader.Response(mockInputStream(), false, 1024);
+    when(downloader.load(any(Uri.class), anyBoolean())).thenReturn(response);
+    Action action = TestUtils.mockAction(URI_KEY_1, URI_1);
+    NetworkBitmapHunter hunter =
+        new NetworkBitmapHunter(picasso, dispatcher, cache, stats, action, downloader);
+    hunter.decode(action.getData());
+    verify(stats).dispatchDownloadFinished(response.contentLength);
+  }
+
+  @Test public void unknownContentLengthDoesNotDispatchToStats() throws Exception {
+    Downloader.Response response = new Downloader.Response(mockInputStream(), false, 0);
+    when(downloader.load(any(Uri.class), anyBoolean())).thenReturn(response);
+    Action action = TestUtils.mockAction(URI_KEY_1, URI_1);
+    NetworkBitmapHunter hunter =
+        new NetworkBitmapHunter(picasso, dispatcher, cache, stats, action, downloader);
+    hunter.decode(action.getData());
+    verifyZeroInteractions(stats);
+  }
+
+  @Test public void cachedResponseDoesNotDispatchToStats() throws Exception {
+    Downloader.Response response = new Downloader.Response(mockInputStream(), true, 1024);
+    when(downloader.load(any(Uri.class), anyBoolean())).thenReturn(response);
+    Action action = TestUtils.mockAction(URI_KEY_1, URI_1);
+    NetworkBitmapHunter hunter =
+        new NetworkBitmapHunter(picasso, dispatcher, cache, stats, action, downloader);
+    hunter.decode(action.getData());
+    verifyZeroInteractions(stats);
+  }
+
   @Test public void downloaderCanReturnBitmapDirectly() throws Exception {
     final Bitmap expected = Bitmap.createBitmap(10, 10, ARGB_8888);
     Downloader bitmapDownloader = new Downloader() {
       @Override public Response load(Uri uri, boolean localCacheOnly) throws IOException {
-        return new Response(expected, false);
+        return new Response(expected, false, 0);
       }
     };
     Action action = TestUtils.mockAction(URI_KEY_1, URI_1);

picasso/src/test/java/com/squareup/picasso/OkHttpDownloaderTest.java

@@ -86,6 +86,12 @@ public class OkHttpDownloaderTest {
     assertThat(response3.cached).isTrue();
   }
 
+  @Test public void readsContentLengthHeader() throws Exception {
+    server.enqueue(new MockResponse().addHeader("Content-Length", 1024));
+    Downloader.Response response = loader.load(URL, true);
+    assertThat(response.contentLength).isEqualTo(1024);
+  }
+
   @Test public void throwsResponseException() throws Exception {
     server.enqueue(new MockResponse().setStatus("HTTP/1.1 401 Not Authorized"));
     try {

picasso/src/test/java/com/squareup/picasso/TestUtils.java

@@ -24,6 +24,8 @@
 import android.view.ViewTreeObserver;
 import android.widget.ImageView;
 import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
@@ -150,6 +152,10 @@ static NetworkInfo mockNetworkInfo() {
     return mock(NetworkInfo.class);
   }
 
+  static InputStream mockInputStream() throws IOException {
+    return mock(InputStream.class);
+  }
+
   static BitmapHunter mockHunter(String key, Bitmap result, boolean skipCache) {
     Request data = new Request.Builder(URI_1).build();
     BitmapHunter hunter = mock(BitmapHunter.class);

picasso/src/test/java/com/squareup/picasso/UrlConnectionDownloaderTest.java

@@ -109,6 +109,12 @@ public class UrlConnectionDownloaderTest {
     assertThat(response2.cached).isTrue();
   }
 
+  @Test public void readsContentLengthHeader() throws Exception {
+    server.enqueue(new MockResponse().addHeader("Content-Length", 1024));
+    Downloader.Response response = loader.load(URL, true);
+    assertThat(response.contentLength).isEqualTo(1024);
+  }
+
   @Test public void throwsResponseException() throws Exception {
     server.enqueue(new MockResponse().setStatus("HTTP/1.1 401 Not Authorized"));
     try {