@scr2em/capacitor-scanner 6.0.8 → 6.0.9

package/android/src/main/java/com/leadliaion/capacitorscanner/CapacitorScannerPlugin.java

@@ -6,7 +6,10 @@ import android.content.pm.PackageManager;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Color;
+import android.graphics.Matrix;
+import androidx.exifinterface.media.ExifInterface;
 import android.net.Uri;
+import android.os.Build;
 import android.provider.Settings;
 import android.util.Base64;
 import android.util.DisplayMetrics;
@@ -51,8 +54,10 @@ import com.google.mlkit.vision.barcode.BarcodeScannerOptions;
 import com.google.mlkit.vision.barcode.BarcodeScanning;
 import com.google.mlkit.vision.common.InputImage;
 
+import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
@@ -392,11 +397,9 @@ public class CapacitorScannerPlugin extends Plugin {
             return;
         }
 
-        // Ratio must be between 0 and 1, where 0 or 1 means no reduction.
         Double qualityRatioObj = call.getDouble("qualityRatio", 1.0);
         double qualityRatio = qualityRatioObj != null ? qualityRatioObj : 1.0;
 
-
         // Temporary stream to receive the captured image data.
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
 
@@ -412,32 +415,94 @@ public class CapacitorScannerPlugin extends Plugin {
                             byte[] originalBytes = outputStream.toByteArray();
                             int originalSize = originalBytes.length; // in bytes
 
+                            BitmapFactory.Options options = new BitmapFactory.Options();
+                            options.inJustDecodeBounds = true;
+                            BitmapFactory.decodeByteArray(originalBytes, 0, originalSize, options);
+
                             // If qualityRatio is between 0 and 1 exclusively, perform quality reduction.
                             if (qualityRatio > 0 && qualityRatio < 1) {
                                 // Calculate the target size in bytes.
                                 int targetSize = (int) (originalSize * qualityRatio);
 
+                                // Read EXIF orientation data from original image
+                                int orientation = ExifInterface.ORIENTATION_UNDEFINED;
+
+                                try {
+                                    InputStream inputStream = new ByteArrayInputStream(originalBytes);
+                                    ExifInterface exif = null;
+                                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                                        exif = new ExifInterface(inputStream);
+                                        orientation = exif.getAttributeInt(
+                                                ExifInterface.TAG_ORIENTATION,
+                                                ExifInterface.ORIENTATION_UNDEFINED);
+                                    }
+                                    inputStream.close();
+                                } catch (IOException e) {
+                                    echo("Warning: Could not read EXIF orientation: " + e.getMessage());
+                                }
+
+
                                 // Decode the captured image into a Bitmap.
-                                Bitmap originalBitmap = BitmapFactory.decodeByteArray(originalBytes, 0, originalSize);
+                                options.inJustDecodeBounds = false;
+                                options.inSampleSize = calculateInSampleSize(options, 1024, 1024); // Max size of 1024x1024
+                                Bitmap originalBitmap = BitmapFactory.decodeByteArray(originalBytes, 0, originalSize, options);
                                 if (originalBitmap == null) {
                                     call.reject("Failed to decode captured image.");
                                     return;
                                 }
 
+                                // Apply rotation based on EXIF orientation
+                                Matrix matrix = new Matrix();
+                                switch (orientation) {
+                                    case ExifInterface.ORIENTATION_ROTATE_90:
+                                        matrix.postRotate(90);
+                                        break;
+                                    case ExifInterface.ORIENTATION_ROTATE_180:
+                                        matrix.postRotate(180);
+                                        break;
+                                    case ExifInterface.ORIENTATION_ROTATE_270:
+                                        matrix.postRotate(270);
+                                        break;
+                                    case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
+                                        matrix.postScale(-1, 1);
+                                        break;
+                                    case ExifInterface.ORIENTATION_FLIP_VERTICAL:
+                                        matrix.postScale(1, -1);
+                                        break;
+                                }
+
+                                // Apply the rotation if needed
+                                if (!matrix.isIdentity()) {
+                                    Bitmap rotatedBitmap = Bitmap.createBitmap(
+                                            originalBitmap, 0, 0,
+                                            originalBitmap.getWidth(), originalBitmap.getHeight(),
+                                            matrix, true);
+                                    originalBitmap.recycle();  // Recycle the old bitmap to free memory.
+                                    originalBitmap = rotatedBitmap;
+                                }
+
                                 // Prepare a stream to hold the compressed bitmap.
                                 ByteArrayOutputStream compressedStream = new ByteArrayOutputStream();
-                                int quality = 100;  // start with maximum quality (100)
+                                int quality = 100;  // Start with maximum quality (100)
 
-                                // Iteratively compress the bitmap until it reaches the target file size.
+                                // Iteratively compress the bitmap until it reaches the target file size or quality drops to 10%.
+                                int maxIterations = 10;  // Limit iterations to prevent excessive looping.
+                                int iterations = 0;
                                 do {
                                     compressedStream.reset();
                                     originalBitmap.compress(Bitmap.CompressFormat.JPEG, quality, compressedStream);
-                                    quality -= 5; // Lower the quality step by step.
-                                } while (compressedStream.toByteArray().length > targetSize && quality > 10);
+                                    quality -= 5; // Reduce quality step by step.
+                                    iterations++;
+                                } while (compressedStream.toByteArray().length > targetSize && quality > 10 && iterations < maxIterations);
 
                                 // Use the compressed image bytes.
                                 originalBytes = compressedStream.toByteArray();
 
+                                Bitmap finalBitmap = BitmapFactory.decodeByteArray(originalBytes, 0, originalBytes.length);
+                                if (finalBitmap != null) {
+                                    finalBitmap.recycle();
+                                }
+
                                 // Cleanup: recycle the bitmap and close the compressed stream.
                                 originalBitmap.recycle();
                                 compressedStream.close();
@@ -451,6 +516,7 @@ public class CapacitorScannerPlugin extends Plugin {
                         } catch (Exception e) {
                             call.reject("Failed to process image: " + e.getMessage());
                         } finally {
+                            // Ensure resources are cleaned up.
                             try {
                                 outputStream.close();
                             } catch (IOException e) {
@@ -472,7 +538,23 @@ public class CapacitorScannerPlugin extends Plugin {
                 });
     }
 
+    private int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
+        // Calculate the largest inSampleSize that is a power of 2 and keeps the image smaller than the requested width/height.
+        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;
 
+            // Calculate the largest inSampleSize value that is a power of 2 and keeps the image smaller than the requested width/height.
+            while ((halfHeight / inSampleSize) > reqHeight && (halfWidth / inSampleSize) > reqWidth) {
+                inSampleSize *= 2;
+            }
+        }
+        return inSampleSize;
+    }
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scr2em/capacitor-scanner",
-  "version": "6.0.8",
+  "version": "6.0.9",
   "description": "scan codes",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",