Implements ImageDecoders to decouple decoding from downloading.

Author: rharter

build.gradle

@@ -11,6 +11,7 @@ buildscript {
 
   ext.deps = [
     androidPlugin: 'com.android.tools.build:gradle:3.2.0-rc02',
+    androidSvg: 'com.caverock:androidsvg:1.2.2-beta-1@aar',
     okhttp: "com.squareup.okhttp3:okhttp:${versions.okhttp}",
     mockWebServer: "com.squareup.okhttp3:mockwebserver:${versions.okhttp}",
     pollexor: 'com.squareup:pollexor:2.0.4',

picasso-sample/src/main/java/com/example/picasso/Data.java

@@ -15,7 +15,7 @@ final class Data {
       BASE + "Q54zMKT" + EXT, BASE + "9t6hLbm" + EXT, BASE + "F8n3Ic6" + EXT,
       BASE + "P5ZRSvT" + EXT, BASE + "jbemFzr" + EXT, BASE + "8B7haIK" + EXT,
       BASE + "aSeTYQr" + EXT, BASE + "OKvWoTh" + EXT, BASE + "zD3gT4Z" + EXT,
-      BASE + "z77CaIt" + EXT,
+      BASE + "z77CaIt" + EXT, "https://dev.w3.org/SVG/tools/svgweb/samples/svg-files/android.svg"
   };
 
   private Data() {

picasso/build.gradle

@@ -28,6 +28,7 @@ android {
 
 dependencies {
   api deps.okhttp
+  implementation deps.androidSvg
   implementation deps.supportAnnotations
   implementation deps.supportCompat
   implementation deps.supportExifInterface

picasso/src/main/java/com/squareup/picasso3/AssetRequestHandler.java

@@ -17,12 +17,11 @@
 
 import android.content.Context;
 import android.content.res.AssetManager;
-import android.graphics.Bitmap;
 import android.net.Uri;
 import android.support.annotation.NonNull;
 import java.io.IOException;
+import okio.BufferedSource;
 import okio.Okio;
-import okio.Source;
 
 import static android.content.ContentResolver.SCHEME_FILE;
 import static com.squareup.picasso3.BitmapUtils.decodeStream;
@@ -56,11 +55,17 @@ public void load(@NonNull Picasso picasso, @NonNull Request request, @NonNull Ca
 
     boolean signaledCallback = false;
     try {
-      Source source = Okio.source(assetManager.open(getFilePath(request)));
+      BufferedSource source = Okio.buffer(Okio.source(assetManager.open(getFilePath(request))));
       try {
-        Bitmap bitmap = decodeStream(source, request);
+        ImageDecoder imageDecoder = request.decoderFactory.getImageDecoderForSource(source);
+        if (imageDecoder == null) {
+          callback.onError(
+              new IllegalStateException("No image decoder for source: " + getFilePath(request)));
+          return;
+        }
+        ImageDecoder.Image image = imageDecoder.decodeImage(source, request);
         signaledCallback = true;
-        callback.onSuccess(new Result(bitmap, DISK));
+        callback.onSuccess(new Result(image.bitmap, image.drawable, DISK, image.exifOrientation));
       } finally {
         try {
           source.close();

picasso/src/main/java/com/squareup/picasso3/BitmapImageDecoder.java

@@ -0,0 +1,71 @@
+package com.squareup.picasso3;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.Build;
+import java.io.IOException;
+import java.io.InputStream;
+import okio.BufferedSource;
+
+import static com.squareup.picasso3.BitmapUtils.calculateInSampleSize;
+import static com.squareup.picasso3.BitmapUtils.createBitmapOptions;
+import static com.squareup.picasso3.BitmapUtils.requiresInSampleSize;
+
+public final class BitmapImageDecoder implements ImageDecoder {
+
+  @Override public boolean canHandleSource(BufferedSource source) {
+    try {
+      if (Utils.isWebPFile(source)) {
+        return true;
+      }
+
+      InputStream stream = new SourceBufferingInputStream(source);
+      BitmapFactory.Options options = new BitmapFactory.Options();
+      options.inJustDecodeBounds = true;
+      BitmapFactory.decodeStream(stream, null, options);
+      // we successfully decoded the bounds
+      return options.outWidth > 0 && options.outHeight > 0;
+    } catch (IOException e) {
+      return false;
+    }
+  }
+
+  /**
+   * Decode a byte stream into a Bitmap. This method will take into account additional information
+   * about the supplied request in order to do the decoding efficiently (such as through leveraging
+   * {@code inSampleSize}).
+   */
+  @Override public Image decodeImage(BufferedSource source, Request request) throws IOException {
+    boolean isWebPFile = Utils.isWebPFile(source);
+    boolean isPurgeable = request.purgeable && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP;
+    BitmapFactory.Options options = createBitmapOptions(request);
+    boolean calculateSize = requiresInSampleSize(options);
+
+    Bitmap bitmap;
+    // We decode from a byte array because, a) when decoding a WebP network stream, BitmapFactory
+    // throws a JNI Exception, so we workaround by decoding a byte array, or b) user requested
+    // purgeable, which only affects bitmaps decoded from byte arrays.
+    if (isWebPFile || isPurgeable) {
+      byte[] bytes = source.readByteArray();
+      if (calculateSize) {
+        BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
+        calculateInSampleSize(request.targetWidth, request.targetHeight, options,
+            request);
+      }
+      bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
+    } else {
+      if (calculateSize) {
+        InputStream stream = new SourceBufferingInputStream(source);
+        BitmapFactory.decodeStream(stream, null, options);
+        calculateInSampleSize(request.targetWidth, request.targetHeight, options,
+            request);
+      }
+      bitmap = BitmapFactory.decodeStream(source.inputStream(), null, options);
+    }
+    if (bitmap == null) {
+      // Treat null as an IO exception, we will eventually retry.
+      throw new IOException("Failed to decode bitmap.");
+    }
+    return new Image(bitmap);
+  }
+}

picasso/src/main/java/com/squareup/picasso3/ContactsPhotoRequestHandler.java

@@ -18,13 +18,13 @@
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.UriMatcher;
-import android.graphics.Bitmap;
 import android.net.Uri;
 import android.provider.ContactsContract;
 import android.support.annotation.NonNull;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
+import okio.BufferedSource;
 import okio.Okio;
 import okio.Source;
 
@@ -78,9 +78,16 @@ public void load(@NonNull Picasso picasso, @NonNull Request request, @NonNull Ca
     try {
       Uri requestUri = checkNotNull(request.uri, "request.uri == null");
       Source source = getSource(requestUri);
-      Bitmap bitmap = decodeStream(source, request);
+
+      BufferedSource bufferedSource = Okio.buffer(source);
+      ImageDecoder imageDecoder = request.decoderFactory.getImageDecoderForSource(bufferedSource);
+      if (imageDecoder == null) {
+        callback.onError(new IllegalStateException("No image decoder for source: " + request));
+        return;
+      }
+      ImageDecoder.Image image = imageDecoder.decodeImage(bufferedSource, request);
       signaledCallback = true;
-      callback.onSuccess(new Result(bitmap, DISK));
+      callback.onSuccess(new Result(image.bitmap, image.drawable, DISK, image.exifOrientation));
     } catch (Exception e) {
       if (!signaledCallback) {
         callback.onError(e);

picasso/src/main/java/com/squareup/picasso3/ContentStreamRequestHandler.java

@@ -17,13 +17,13 @@
 
 import android.content.ContentResolver;
 import android.content.Context;
-import android.graphics.Bitmap;
 import android.net.Uri;
 import android.support.annotation.NonNull;
 import android.support.media.ExifInterface;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
+import okio.BufferedSource;
 import okio.Okio;
 import okio.Source;
 
@@ -52,10 +52,17 @@ public void load(@NonNull Picasso picasso, @NonNull Request request, @NonNull Ca
     try {
       Uri requestUri = checkNotNull(request.uri, "request.uri == null");
       Source source = getSource(requestUri);
-      Bitmap bitmap = decodeStream(source, request);
+
+      BufferedSource bufferedSource = Okio.buffer(source);
+      ImageDecoder imageDecoder = request.decoderFactory.getImageDecoderForSource(bufferedSource);
+      if (imageDecoder == null) {
+        callback.onError(new IllegalStateException("No image decoder for request: " + request));
+        return;
+      }
+      ImageDecoder.Image image = imageDecoder.decodeImage(bufferedSource, request);
       int exifRotation = getExifOrientation(requestUri);
       signaledCallback = true;
-      callback.onSuccess(new Result(bitmap, DISK, exifRotation));
+      callback.onSuccess(new Result(image.bitmap, image.drawable, DISK, exifRotation));
     } catch (Exception e) {
       if (!signaledCallback) {
         callback.onError(e);

picasso/src/main/java/com/squareup/picasso3/FileRequestHandler.java

@@ -16,13 +16,13 @@
 package com.squareup.picasso3;
 
 import android.content.Context;
-import android.graphics.Bitmap;
 import android.net.Uri;
 import android.support.annotation.NonNull;
 import android.support.media.ExifInterface;
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import okio.Source;
+import okio.BufferedSource;
+import okio.Okio;
 
 import static android.content.ContentResolver.SCHEME_FILE;
 import static android.support.media.ExifInterface.ORIENTATION_NORMAL;
@@ -47,11 +47,16 @@ public void load(@NonNull Picasso picasso, @NonNull Request request, @NonNull Ca
     boolean signaledCallback = false;
     try {
       Uri requestUri = checkNotNull(request.uri, "request.uri == null");
-      Source source = getSource(requestUri);
-      Bitmap bitmap = decodeStream(source, request);
+      BufferedSource source = Okio.buffer(getSource(requestUri));
+      ImageDecoder imageDecoder = request.decoderFactory.getImageDecoderForSource(source);
+      if (imageDecoder == null) {
+        callback.onError(new IllegalStateException("No image decoder for request: " + request));
+        return;
+      }
+      ImageDecoder.Image image = imageDecoder.decodeImage(source, request);
       int exifRotation = getExifOrientation(requestUri);
       signaledCallback = true;
-      callback.onSuccess(new Result(bitmap, DISK, exifRotation));
+      callback.onSuccess(new Result(image.bitmap, image.drawable, DISK, exifRotation));
     } catch (Exception e) {
       if (!signaledCallback) {
         callback.onError(e);

picasso/src/main/java/com/squareup/picasso3/ImageDecoder.java

@@ -0,0 +1,34 @@
+package com.squareup.picasso3;
+
+import android.graphics.Bitmap;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import java.io.IOException;
+import okio.BufferedSource;
+
+public interface ImageDecoder {
+
+  final class Image {
+    @Nullable public final Bitmap bitmap;
+    @Nullable public final Drawable drawable;
+    public final int exifOrientation;
+
+    public Image(@NonNull Bitmap bitmap) {
+      this(bitmap, null, 0);
+    }
+
+    public Image(@NonNull Drawable drawable) {
+      this(null, drawable, 0);
+    }
+
+    public Image(@Nullable Bitmap bitmap, @Nullable Drawable drawable, int exifOrientation) {
+      this.bitmap = bitmap;
+      this.drawable = drawable;
+      this.exifOrientation = exifOrientation;
+    }
+  }
+
+  boolean canHandleSource(BufferedSource source);
+  Image decodeImage(BufferedSource source, Request request) throws IOException;
+}

picasso/src/main/java/com/squareup/picasso3/ImageDecoderFactory.java

@@ -0,0 +1,28 @@
+package com.squareup.picasso3;
+
+import android.support.annotation.Nullable;
+import java.util.List;
+import okio.BufferedSource;
+
+final class ImageDecoderFactory {
+
+  private final List<ImageDecoder> decoders;
+
+  ImageDecoderFactory(List<ImageDecoder> decoders) {
+    this.decoders = decoders;
+  }
+
+  /**
+   * Returns the first {@link ImageDecoder} that can handle the supplied <code>source</code>.
+   * @param source The source of the image data.
+   * @return The first ImageDecoder that can decode the source, or null.
+   */
+  @Nullable ImageDecoder getImageDecoderForSource(BufferedSource source) {
+    for (ImageDecoder decoder : decoders) {
+      if (decoder.canHandleSource(source)) {
+        return decoder;
+      }
+    }
+    return null;
+  }
+}