[WIP] Implements ImageDecoders to decouple decoding from downloading.

build.gradle

@@ -10,7 +10,8 @@ buildscript {
   ]
 
   ext.deps = [
-    androidPlugin: 'com.android.tools.build:gradle:3.2.1',
+    androidPlugin: 'com.android.tools.build:gradle:3.3.0',
+    androidSvg: 'com.caverock:androidsvg-aar:1.3',
     okhttp: "com.squareup.okhttp3:okhttp:${versions.okhttp}",
     okio: "com.squareup.okio:okio:${versions.okio}",
     mockWebServer: "com.squareup.okhttp3:mockwebserver:${versions.okhttp}",
@@ -99,7 +100,7 @@ subprojects {
   version = VERSION_NAME
 
   afterEvaluate {
-    tasks.findByName('check').dependsOn('checkstyle')
+    tasks.getByName('check').dependsOn('checkstyle')
   }
 
   apply plugin: 'net.ltgt.errorprone'

decoders/svg/README.md

@@ -0,0 +1,15 @@
+Picasso SVG Image Decoder
+====================================
+
+An image decoder that allows Picasso to decode SVG images.
+
+Usage
+-----
+
+Provide an instance of `SvgImageDecoder` when creating a `Picasso` instance.
+
+```java
+Picasso p = new Picasso.Builder(context)
+    .addImageDecoder(new SvgImageDecoder())
+    .build();
+```

decoders/svg/build.gradle

@@ -0,0 +1,34 @@
+apply plugin: 'com.android.library'
+
+android {
+  compileSdkVersion versions.compileSdk
+
+  defaultConfig {
+    minSdkVersion versions.minSdk
+  }
+
+  compileOptions {
+    sourceCompatibility versions.sourceCompatibility
+    targetCompatibility versions.targetCompatibility
+  }
+
+  lintOptions {
+    textOutput 'stdout'
+    textReport true
+    lintConfig file('lint.xml')
+  }
+}
+
+dependencies {
+  api project(':picasso')
+  implementation deps.androidSvg
+  compileOnly deps.androidxAnnotations
+  testImplementation deps.junit
+  testImplementation deps.robolectric
+  testImplementation deps.truth
+  testImplementation deps.mockito
+
+  annotationProcessor deps.nullaway
+}
+
+apply from: rootProject.file('gradle/gradle-mvn-push.gradle')

decoders/svg/gradle.properties

@@ -0,0 +1,4 @@
+POM_ARTIFACT_ID=picasso-decoder-svg
+POM_NAME=Picasso SVG Descoder
+POM_DESCRIPTION=An image decoder that supports SVG images.
+POM_PACKAGING=aar

decoders/svg/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="com.squareup.picasso3.decoder.svg" />

decoders/svg/src/main/java/com/squareup/picasso3/decoder/svg/SvgImageDecoder.java

@@ -0,0 +1,52 @@
+package com.squareup.picasso3.decoder.svg;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import com.caverock.androidsvg.SVG;
+import com.caverock.androidsvg.SVGParseException;
+import com.squareup.picasso3.ImageDecoder;
+import com.squareup.picasso3.Request;
+import java.io.IOException;
+import okio.BufferedSource;
+
+class SvgImageDecoder implements ImageDecoder {
+
+  @Override public boolean canHandleSource(BufferedSource source) {
+    try {
+      SVG.getFromInputStream(source.inputStream());
+      return true;
+    } catch (SVGParseException e) {
+      return false;
+    }
+  }
+
+  @Override public Image decodeImage(BufferedSource source, Request request) throws IOException {
+    try {
+      SVG svg = SVG.getFromInputStream(source.inputStream());
+      if (request.hasSize()) {
+        if (request.targetWidth != 0) {
+          svg.setDocumentWidth(request.targetWidth);
+        }
+        if (request.targetHeight != 0) {
+          svg.setDocumentHeight(request.targetHeight);
+        }
+      }
+
+      int width = (int) svg.getDocumentWidth();
+      if (width == -1) {
+        width = (int) svg.getDocumentViewBox().width();
+      }
+      int height = (int) svg.getDocumentHeight();
+      if (height == -1) {
+        height = (int) svg.getDocumentViewBox().height();
+      }
+      Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+      Canvas canvas = new Canvas(bitmap);
+      svg.renderToCanvas(canvas);
+
+      return new Image(bitmap);
+    } catch (SVGParseException e) {
+      throw new IOException(e);
+    }
+  }
+}

decoders/svg/src/test/java/com/squareup/picasso3/decoder/svg/SvgImageDecoderTest.java

@@ -0,0 +1,67 @@
+package com.squareup.picasso3.decoder.svg;
+
+import android.net.Uri;
+import com.squareup.picasso3.Request;
+import java.io.IOException;
+import java.io.InputStream;
+import okio.BufferedSource;
+import okio.Okio;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.squareup.picasso3.ImageDecoder.Image;
+import static org.mockito.Mockito.mock;
+
+@RunWith(RobolectricTestRunner.class)
+public class SvgImageDecoderTest {
+
+  private SvgImageDecoder decoder;
+
+  @Before public void setup() {
+    decoder = new SvgImageDecoder();
+  }
+
+  @Test public void canHandleSource_forSvg_returnsTrue() {
+    BufferedSource svg = bufferResource("/android.svg");
+    assertThat(decoder.canHandleSource(svg)).isTrue();
+  }
+
+  @Test public void canHandleSource_forBitmap_returnsFalse() {
+    BufferedSource jpg = bufferResource("/image.jpg");
+    assertThat(decoder.canHandleSource(jpg)).isFalse();
+  }
+
+  @Test public void decodeImage_withoutTargetSize_returnsNativelySizedImage() throws IOException {
+    BufferedSource svg = bufferResource("/android.svg");
+    Request request = new Request.Builder(mock(Uri.class)).build();
+    Image image = decoder.decodeImage(svg, request);
+
+    assertThat(image.bitmap).isNotNull();
+    assertThat(image.bitmap.getWidth()).isEqualTo(96);
+    assertThat(image.bitmap.getHeight()).isEqualTo(105);
+  }
+
+  @Test public void decodeImage_withTargetSize_returnsResizedImage() throws IOException {
+    BufferedSource svg = bufferResource("/android.svg");
+    Request request = new Request.Builder(mock(Uri.class))
+        .resize(50, 50)
+        .build();
+    Image image = decoder.decodeImage(svg, request);
+
+    assertThat(image.bitmap).isNotNull();
+    assertThat(image.bitmap.getWidth()).isEqualTo(50);
+    assertThat(image.bitmap.getHeight()).isEqualTo(50);
+  }
+
+  private BufferedSource bufferResource(String name) {
+    InputStream in = SvgImageDecoderTest.class.getResourceAsStream(name);
+    if (in == null) {
+      throw new IllegalArgumentException("Unknown resource for name: " + name);
+    }
+    return Okio.buffer(Okio.source(in));
+  }
+
+}

decoders/svg/src/test/resources/robolectric.properties

@@ -0,0 +1,3 @@
+sdk: 18
+constants: com.squareup.picasso3.BuildConfig
+manifest: --default

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/src/main/java/com/squareup/picasso3/AssetRequestHandler.java

@@ -17,15 +17,13 @@
 
 import android.content.Context;
 import android.content.res.AssetManager;
-import android.graphics.Bitmap;
 import android.net.Uri;
 import androidx.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;
 import static com.squareup.picasso3.Picasso.LoadedFrom.DISK;
 import static com.squareup.picasso3.Utils.checkNotNull;
 
@@ -56,11 +54,18 @@ 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,33 @@
+package com.squareup.picasso3;
+
+import android.graphics.BitmapFactory;
+import androidx.annotation.NonNull;
+import java.io.IOException;
+import okio.BufferedSource;
+
+import static com.squareup.picasso3.BitmapUtils.decodeStream;
+
+public final class BitmapImageDecoder implements ImageDecoder {
+
+  @Override public boolean canHandleSource(@NonNull BufferedSource source) {
+    try {
+      if (Utils.isWebPFile(source)) {
+        return true;
+      }
+
+      BitmapFactory.Options options = new BitmapFactory.Options();
+      options.inJustDecodeBounds = true;
+      BitmapFactory.decodeStream(source.inputStream(), null, options);
+      // we successfully decoded the bounds
+      return options.outWidth > 0 && options.outHeight > 0;
+    } catch (IOException e) {
+      return false;
+    }
+  }
+
+  @NonNull @Override
+  public Image decodeImage(@NonNull BufferedSource source, @NonNull Request request)
+      throws IOException {
+    return new Image(decodeStream(source, request));
+  }
+}

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

@@ -15,7 +15,6 @@
  */
 package com.squareup.picasso3;
 
-import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
@@ -106,22 +105,21 @@ static Bitmap decodeStream(Source source, Request request) throws IOException {
     ExceptionCatchingSource exceptionCatchingSource = new ExceptionCatchingSource(source);
     BufferedSource bufferedSource = Okio.buffer(exceptionCatchingSource);
     Bitmap bitmap = SDK_INT >= 28
-        ? decodeStreamP(request, bufferedSource)
-        : decodeStreamPreP(request, bufferedSource);
+        ? decodeStreamP(bufferedSource, request)
+        : decodeStreamPreP(bufferedSource, request);
     exceptionCatchingSource.throwIfCaught();
     return bitmap;
   }
 
   @RequiresApi(28)
-  @SuppressLint("Override")
-  private static Bitmap decodeStreamP(Request request, BufferedSource bufferedSource)
-      throws IOException {
-    ImageDecoder.Source imageSource =
-        ImageDecoder.createSource(ByteBuffer.wrap(bufferedSource.readByteArray()));
+  private static Bitmap decodeStreamP(BufferedSource source, Request request) throws IOException {
+    android.graphics.ImageDecoder.Source imageSource =
+        android.graphics.ImageDecoder.createSource(ByteBuffer.wrap(source.readByteArray()));
     return decodeImageSource(imageSource, request);
   }
 
-  private static Bitmap decodeStreamPreP(Request request, BufferedSource bufferedSource)
+  @NonNull
+  private static Bitmap decodeStreamPreP(BufferedSource bufferedSource, Request request)
       throws IOException {
     boolean isWebPFile = Utils.isWebPFile(bufferedSource);
     boolean isPurgeable = request.purgeable && SDK_INT < Build.VERSION_CODES.LOLLIPOP;

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

@@ -18,19 +18,18 @@
 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 androidx.annotation.NonNull;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
+import okio.BufferedSource;
 import okio.Okio;
 import okio.Source;
 
 import static android.content.ContentResolver.SCHEME_CONTENT;
 import static android.provider.ContactsContract.Contacts.openContactPhotoInputStream;
-import static com.squareup.picasso3.BitmapUtils.decodeStream;
 import static com.squareup.picasso3.Picasso.LoadedFrom.DISK;
 import static com.squareup.picasso3.Utils.checkNotNull;
 
@@ -78,9 +77,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);