Improved Bitmap resize on Android

packages/image_picker/image_picker_android/CHANGELOG.md

@@ -1,5 +1,6 @@
 ## 0.8.5+10
 
+* Improved Bitmap resizing.
 * Clarifies explanation of endorsement in README.
 * Aligns Dart and Flutter SDK constraints.
 

packages/image_picker/image_picker_android/android/src/main/java/io/flutter/plugins/imagepicker/ImageResizer.java

@@ -6,6 +6,7 @@
 
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
+import android.graphics.Point;
 import android.util.Log;
 import androidx.annotation.Nullable;
 import java.io.ByteArrayOutputStream;
@@ -33,8 +34,10 @@ String resizeImageIfNeeded(
       @Nullable Double maxWidth,
       @Nullable Double maxHeight,
       @Nullable Integer imageQuality) {
-    Bitmap bmp = decodeFile(imagePath);
-    if (bmp == null) {
+    BitmapFactory.Options queryOptions = new BitmapFactory.Options();
+    queryOptions.inJustDecodeBounds = true;
+    decodeFile(imagePath, queryOptions);
+    if (queryOptions.outWidth == -1 || queryOptions.outHeight == -1) {
       return null;
     }
     boolean shouldScale =
@@ -45,7 +48,18 @@ String resizeImageIfNeeded(
     try {
       String[] pathParts = imagePath.split("/");
       String imageName = pathParts[pathParts.length - 1];
-      File file = resizedImage(bmp, maxWidth, maxHeight, imageQuality, imageName);
+      Point size =
+          calculateSize(
+              Double.valueOf(queryOptions.outWidth),
+              Double.valueOf(queryOptions.outHeight),
+              maxWidth,
+              maxHeight);
+      BitmapFactory.Options options = new BitmapFactory.Options();
+      options.inSampleSize = calculateInSampleSize(options, size.x, size.y);
+      options.inJustDecodeBounds = false;
+      File file =
+          resizedImage(
+              decodeFile(imagePath, options), maxWidth, maxHeight, imageQuality, imageName);
       copyExif(imagePath, file.getPath());
       return file.getPath();
     } catch (IOException e) {
@@ -63,6 +77,15 @@ private File resizedImage(
       imageQuality = 100;
     }
 
+    Point size = calculateSize(originalWidth, originalHeight, maxWidth, maxHeight);
+    Bitmap scaledBmp = createScaledBitmap(bmp, size.x, size.y, false);
+    File file =
+        createImageOnExternalDirectory("/scaled_" + outputImageName, scaledBmp, imageQuality);
+    return file;
+  }
+
+  private Point calculateSize(
+      Double originalWidth, Double originalHeight, Double maxWidth, Double maxHeight) {
     boolean hasMaxWidth = maxWidth != null;
     boolean hasMaxHeight = maxHeight != null;
 
@@ -98,10 +121,7 @@ private File resizedImage(
       }
     }
 
-    Bitmap scaledBmp = createScaledBitmap(bmp, width.intValue(), height.intValue(), false);
-    File file =
-        createImageOnExternalDirectory("/scaled_" + outputImageName, scaledBmp, imageQuality);
-    return file;
+    return new Point(width.intValue(), height.intValue());
   }
 
   private File createFile(File externalFilesDirectory, String child) {
@@ -120,8 +140,8 @@ private void copyExif(String filePathOri, String filePathDest) {
     exifDataCopier.copyExif(filePathOri, filePathDest);
   }
 
-  private Bitmap decodeFile(String path) {
-    return BitmapFactory.decodeFile(path);
+  private Bitmap decodeFile(String path, @Nullable BitmapFactory.Options opts) {
+    return BitmapFactory.decodeFile(path, opts);
   }
 
   private Bitmap createScaledBitmap(Bitmap bmp, int width, int height, boolean filter) {
@@ -132,6 +152,20 @@ private boolean isImageQualityValid(Integer imageQuality) {
     return imageQuality != null && imageQuality > 0 && imageQuality < 100;
   }
 
+  private int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
+    final int height = options.outHeight;
+    final int width = options.outWidth;
+    int inSampleSize = 1;
+    if (height > reqHeight || width > reqWidth) {
+      final int halfHeight = height / 2;
+      final int halfWidth = width / 2;
+      while ((halfHeight / inSampleSize) >= reqHeight && (halfWidth / inSampleSize) >= reqWidth) {
+        inSampleSize *= 2;
+      }
+    }
+    return inSampleSize;
+  }
+
   private File createImageOnExternalDirectory(String name, Bitmap bitmap, int imageQuality)
       throws IOException {
     ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

packages/image_picker/image_picker_android/android/src/test/java/io/flutter/plugins/imagepicker/ImageResizerTest.java

@@ -6,16 +6,25 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.times;
 
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import java.io.File;
 import java.io.IOException;
+import java.util.List;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
 
@@ -78,4 +87,32 @@ public void onResizeImageIfNeeded_WhenParentDirectoryDoesNotExists_ShouldNotCras
     String outoutFile = invalidResizer.resizeImageIfNeeded(imageFile.getPath(), null, 50.0, null);
     assertThat(outoutFile, equalTo(nonExistentDirectory.getPath() + "/scaled_pngImage.png"));
   }
+
+  @Test
+  public void onResizeImageIfNeeded_WhenResizeIsNotNecessary_ShouldOnlyQueryBitmap() {
+    try (MockedStatic<BitmapFactory> mockBitmapFactory =
+        mockStatic(BitmapFactory.class, Mockito.CALLS_REAL_METHODS)) {
+      String outoutFile = resizer.resizeImageIfNeeded(imageFile.getPath(), null, null, null);
+      ArgumentCaptor<BitmapFactory.Options> argument =
+          ArgumentCaptor.forClass(BitmapFactory.Options.class);
+      mockBitmapFactory.verify(() -> BitmapFactory.decodeFile(anyString(), argument.capture()));
+      BitmapFactory.Options capturedOptions = argument.getValue();
+      assertTrue(capturedOptions.inJustDecodeBounds);
+    }
+  }
+
+  @Test
+  public void onResizeImageIfNeeded_WhenResizeIsNecessary_ShouldAllocateBitmap() {
+    try (MockedStatic<BitmapFactory> mockBitmapFactory =
+        mockStatic(BitmapFactory.class, Mockito.CALLS_REAL_METHODS)) {
+      String outoutFile = resizer.resizeImageIfNeeded(imageFile.getPath(), 50.0, 50.0, null);
+      ArgumentCaptor<BitmapFactory.Options> argument =
+          ArgumentCaptor.forClass(BitmapFactory.Options.class);
+      mockBitmapFactory.verify(
+          () -> BitmapFactory.decodeFile(anyString(), argument.capture()), times(2));
+      List<BitmapFactory.Options> capturedOptions = argument.getAllValues();
+      assertTrue(capturedOptions.get(0).inJustDecodeBounds);
+      assertFalse(capturedOptions.get(1).inJustDecodeBounds);
+    }
+  }
 }