@scr2em/capacitor-scanner 6.0.18 → 6.0.20

package/android/build.gradle

@@ -26,7 +26,7 @@ buildscript {
 }
 
 apply plugin: 'com.android.library'
-
+apply plugin: 'kotlin-android'
 android {
     namespace "com.leadliaion.capacitorscanner"
     compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
@@ -46,6 +46,9 @@ android {
     lintOptions {
         abortOnError false
     }
+    kotlinOptions {
+        jvmTarget = '17'
+    }
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_17
         targetCompatibility JavaVersion.VERSION_17
@@ -76,7 +79,6 @@ dependencies {
 
     // Exposed as 'api' so consuming apps get them transitively
     api 'org.opencv:opencv:4.12.0'
-    implementation files('libs/rectangle-detector-release.aar')
     api "androidx.camera:camera-core:1.5.1"
     api "androidx.camera:camera-camera2:1.5.1"
     api "androidx.camera:camera-lifecycle:1.5.1"

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

@@ -137,9 +137,11 @@ public class CapacitorScannerPlugin extends Plugin {
     private long lastRectangleProcessingTime = 0;
     private long lastRectangleDetectionTime = 0; // Tracks when we last had a valid rectangle detection
     private int processingFrequency = 10; // Default: 10 rectangle detections per second
-    
+
     /**
-     * Calculates the processing interval in milliseconds based on the desired frequency per second.
+     * Calculates the processing interval in milliseconds based on the desired
+     * frequency per second.
+     * 
      * @param frequency Number of processing operations per second
      * @return Processing interval in milliseconds
      */
@@ -159,7 +161,8 @@ public class CapacitorScannerPlugin extends Plugin {
                 .setBarcodeFormats(Barcode.FORMAT_ALL_FORMATS)
                 .build());
 
-        // Initialize rectangle detector like the sample (use default constructor, not DetectionAccuracy.Passive)
+        // Initialize rectangle detector like the sample (use default constructor, not
+        // DetectionAccuracy.Passive)
         try {
             rectangleDetector = RectangleDetector.Companion.getInstance(DetectionAccuracy.Aggressive);
             echo("Rectangle detector initialized successfully");
@@ -298,7 +301,8 @@ public class CapacitorScannerPlugin extends Plugin {
 
     private Camera camera;
 
-    private void bindCamera(@NonNull ProcessCameraProvider cameraProvider, PreviewView previewView, int lensFacing, PluginCall call) {
+    private void bindCamera(@NonNull ProcessCameraProvider cameraProvider, PreviewView previewView, int lensFacing,
+            PluginCall call) {
         cameraProvider.unbindAll();
 
         // Get preview view dimensions (like sample)
@@ -362,7 +366,8 @@ public class CapacitorScannerPlugin extends Plugin {
 
         try {
             // Store the Camera instance for later use
-            camera = cameraProvider.bindToLifecycle(getActivity(), cameraSelector, preview, imageCapture, imageAnalysis);
+            camera = cameraProvider.bindToLifecycle(getActivity(), cameraSelector, preview, imageCapture,
+                    imageAnalysis);
             preview.setSurfaceProvider(previewView.getSurfaceProvider());
         } catch (Exception e) {
             echo("Failed to bind camera to lifecycle: " + e.getMessage());
@@ -387,7 +392,8 @@ public class CapacitorScannerPlugin extends Plugin {
                 @ExperimentalGetImage
                 android.media.Image mediaImage = imageProxy.getImage();
                 if (mediaImage != null) {
-                    InputImage image = InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
+                    InputImage image = InputImage.fromMediaImage(mediaImage,
+                            imageProxy.getImageInfo().getRotationDegrees());
 
                     // Barcode detection
                     if (scanner != null) {
@@ -395,7 +401,8 @@ public class CapacitorScannerPlugin extends Plugin {
                                 .addOnSuccessListener(executor, barcodes -> {
                                     processBarcodes(barcodes);
                                     if (enabledDetectionTypes.contains("barcode")) {
-                                        displayDetectedBarcodes(barcodes, imageProxy.getWidth(), imageProxy.getHeight(), imageProxy.getImageInfo().getRotationDegrees());
+                                        displayDetectedBarcodes(barcodes, imageProxy.getWidth(), imageProxy.getHeight(),
+                                                imageProxy.getImageInfo().getRotationDegrees());
                                     }
                                 })
                                 .addOnFailureListener(executor, e -> {
@@ -419,14 +426,16 @@ public class CapacitorScannerPlugin extends Plugin {
                                 // Convert ImageProxy to Bitmap using the sample's toBitmap method
                                 bitmap = imageProxyToBitmap(imageProxy);
 
-                                echo("Converting image for rectangle detection - bitmap size: " + bitmap.getWidth() + "x" + bitmap.getHeight());
+                                echo("Converting image for rectangle detection - bitmap size: " + bitmap.getWidth()
+                                        + "x" + bitmap.getHeight());
 
                                 long startTime = System.currentTimeMillis();
                                 DetectionResult rawResult = rectangleDetector.detectRectangles(bitmap);
                                 echo("Rectangle detection took " + (System.currentTimeMillis() - startTime) + "ms");
 
                                 // Apply geometric filtering to eliminate false positives
-                                List<Rectangle> filteredRectangles = filterRectangles(rawResult.getRectangles(), rawResult.getImageSize());
+                                List<Rectangle> filteredRectangles = filterRectangles(rawResult.getRectangles(),
+                                        rawResult.getImageSize());
 
                                 // 2) record hit/miss in sliding window
                                 boolean isHit = !filteredRectangles.isEmpty();
@@ -435,7 +444,7 @@ public class CapacitorScannerPlugin extends Plugin {
                                     detectionHistory.poll();
                                 }
                                 if (isHit) {
-                                    lastGoodRects = filteredRectangles;  // update last known good
+                                    lastGoodRects = filteredRectangles; // update last known good
                                     echo("✅ Hit - saved " + filteredRectangles.size() + " good rectangles");
                                 } else {
                                     echo("❌ Miss - keeping " + lastGoodRects.size() + " previous rectangles");
@@ -448,12 +457,14 @@ public class CapacitorScannerPlugin extends Plugin {
                                 } else {
                                     // For older Android versions, count manually
                                     for (Boolean hit : detectionHistory) {
-                                        if (hit) hits++;
+                                        if (hit)
+                                            hits++;
                                     }
                                 }
                                 boolean shouldShow = hits >= Math.ceil(PRESENCE_THRESHOLD * detectionHistory.size());
                                 List<Rectangle> rectanglesToShow = shouldShow ? lastGoodRects : Collections.emptyList();
-                                echo("Window: " + hits + "/" + detectionHistory.size() + " hits - shouldShow: " + shouldShow);
+                                echo("Window: " + hits + "/" + detectionHistory.size() + " hits - shouldShow: "
+                                        + shouldShow);
 
                                 // Create detection result with the rectangles we decided to show
                                 detectionResult = new DetectionResult(rawResult.getImageSize(), rectanglesToShow);
@@ -464,7 +475,8 @@ public class CapacitorScannerPlugin extends Plugin {
                                     lastRectangleDetectionTime = currentTime;
                                 }
 
-                                // Process rectangle detection results to emit events if we're showing rectangles
+                                // Process rectangle detection results to emit events if we're showing
+                                // rectangles
                                 if (!rectanglesToShow.isEmpty()) {
                                     processRectangles(detectionResult);
                                 }
@@ -474,7 +486,8 @@ public class CapacitorScannerPlugin extends Plugin {
                             } catch (Exception e) {
                                 echo("Failed to process image for rectangle detection: " + e.getMessage());
                                 e.printStackTrace();
-                                detectionResult = new DetectionResult(new Size(imageProxy.getWidth(), imageProxy.getHeight()), new ArrayList<>());
+                                detectionResult = new DetectionResult(
+                                        new Size(imageProxy.getWidth(), imageProxy.getHeight()), new ArrayList<>());
                             } finally {
                                 // Cleanup bitmap resource in all code paths
                                 if (bitmap != null) {
@@ -483,14 +496,17 @@ public class CapacitorScannerPlugin extends Plugin {
                             }
                         } else {
                             // For frames we're not processing, reuse the last good detection result
-                            // This ensures the UI stays smooth even though we're only detecting 10 times/second
+                            // This ensures the UI stays smooth even though we're only detecting 10
+                            // times/second
                             if (lastGoodDetectionResult != null &&
                                     (currentTime - lastRectangleDetectionTime) < CACHE_MS) {
                                 detectionResult = lastGoodDetectionResult;
-                                echo("Reusing last good detection result (age: " + (currentTime - lastRectangleProcessingTime) + "ms)");
+                                echo("Reusing last good detection result (age: "
+                                        + (currentTime - lastRectangleProcessingTime) + "ms)");
                             } else {
                                 // Create empty result if we have no recent good detection
-                                detectionResult = new DetectionResult(new Size(imageProxy.getWidth(), imageProxy.getHeight()), new ArrayList<>());
+                                detectionResult = new DetectionResult(
+                                        new Size(imageProxy.getWidth(), imageProxy.getHeight()), new ArrayList<>());
                             }
                         }
 
@@ -524,8 +540,9 @@ public class CapacitorScannerPlugin extends Plugin {
         float imgWidth = imageSize.getWidth();
         float imgHeight = imageSize.getHeight();
         float imageArea = imgWidth * imgHeight;
-        
-        // Sort rectangles by quality score (highest first) to prioritize better detections
+
+        // Sort rectangles by quality score (highest first) to prioritize better
+        // detections
         List<Rectangle> sortedRectangles = new ArrayList<>(rectangles);
         Collections.sort(sortedRectangles, (r1, r2) -> {
             float score1 = calculateRectangleQualityScore(r1, imageSize);
@@ -540,31 +557,31 @@ public class CapacitorScannerPlugin extends Plugin {
             float areaRatio = rectArea / imageArea;
             float rectangularity = calculateRectangularity(rect);
             float aspectRatio = calculateAspectRatio(rect);
-            
+
             // Skip if too small relative to image (increased from 0.01 to 0.03)
             if (areaRatio < 0.03f) {
                 echo("Filtered out tiny rectangle: " + areaRatio);
                 continue;
             }
-            
+
             // Skip if too large (likely a false positive like the whole screen)
             if (areaRatio > 0.8f) {
                 echo("Filtered out too large rectangle: " + areaRatio);
                 continue;
             }
-            
+
             // Filter based on rectangularity (how close to being a perfect rectangle)
             if (rectangularity < 0.8f) {
                 echo("Filtered out non-rectangular shape: " + rectangularity);
                 continue;
             }
-            
+
             // Filter extreme aspect ratios (too narrow or too wide)
             if (aspectRatio < 0.2f || aspectRatio > 5.0f) {
                 echo("Filtered out bad aspect ratio: " + aspectRatio);
                 continue;
             }
-            
+
             // Check if this rectangle is a duplicate of one we already kept
             boolean isDuplicate = false;
             for (Rectangle existingRect : filteredRectangles) {
@@ -574,147 +591,153 @@ public class CapacitorScannerPlugin extends Plugin {
                     break;
                 }
             }
-            
+
             if (!isDuplicate) {
                 filteredRectangles.add(rect);
             }
         }
-        
+
         echo("Rectangle filtering: " + rectangles.size() + " → " + filteredRectangles.size() + " rectangles");
         return filteredRectangles;
     }
-    
+
     // Calculate area of rectangle
     private float getRectangleArea(Rectangle rect) {
         // Use shoelace formula to calculate area of quadrilateral
         return 0.5f * Math.abs(
-            (rect.getTopLeft().x * rect.getTopRight().y - rect.getTopRight().x * rect.getTopLeft().y) +
-            (rect.getTopRight().x * rect.getBottomRight().y - rect.getBottomRight().x * rect.getTopRight().y) +
-            (rect.getBottomRight().x * rect.getBottomLeft().y - rect.getBottomLeft().x * rect.getBottomRight().y) +
-            (rect.getBottomLeft().x * rect.getTopLeft().y - rect.getTopLeft().x * rect.getBottomLeft().y)
-        );
+                (rect.getTopLeft().x * rect.getTopRight().y - rect.getTopRight().x * rect.getTopLeft().y) +
+                        (rect.getTopRight().x * rect.getBottomRight().y
+                                - rect.getBottomRight().x * rect.getTopRight().y)
+                        +
+                        (rect.getBottomRight().x * rect.getBottomLeft().y
+                                - rect.getBottomLeft().x * rect.getBottomRight().y)
+                        +
+                        (rect.getBottomLeft().x * rect.getTopLeft().y - rect.getTopLeft().x * rect.getBottomLeft().y));
     }
-    
+
     // Check if two rectangles are similar enough to be considered duplicates
     private boolean isSimilarRectangle(Rectangle rect1, Rectangle rect2) {
         // Calculate center points
-        float cx1 = (float) (rect1.getTopLeft().x + rect1.getTopRight().x + rect1.getBottomLeft().x + rect1.getBottomRight().x) / 4;
-        float cy1 = (float) (rect1.getTopLeft().y + rect1.getTopRight().y + rect1.getBottomLeft().y + rect1.getBottomRight().y) / 4;
-        
-        float cx2 = (float) (rect2.getTopLeft().x + rect2.getTopRight().x + rect2.getBottomLeft().x + rect2.getBottomRight().x) / 4;
-        float cy2 = (float) (rect2.getTopLeft().y + rect2.getTopRight().y + rect2.getBottomLeft().y + rect2.getBottomRight().y) / 4;
-        
+        float cx1 = (float) (rect1.getTopLeft().x + rect1.getTopRight().x + rect1.getBottomLeft().x
+                + rect1.getBottomRight().x) / 4;
+        float cy1 = (float) (rect1.getTopLeft().y + rect1.getTopRight().y + rect1.getBottomLeft().y
+                + rect1.getBottomRight().y) / 4;
+
+        float cx2 = (float) (rect2.getTopLeft().x + rect2.getTopRight().x + rect2.getBottomLeft().x
+                + rect2.getBottomRight().x) / 4;
+        float cy2 = (float) (rect2.getTopLeft().y + rect2.getTopRight().y + rect2.getBottomLeft().y
+                + rect2.getBottomRight().y) / 4;
+
         // Calculate distances between centers
         float distanceBetweenCenters = (float) Math.sqrt(Math.pow(cx2 - cx1, 2) + Math.pow(cy2 - cy1, 2));
-        
+
         // Calculate diagonal lengths as reference
         float diag1 = (float) Math.sqrt(
-            Math.pow(rect1.getTopLeft().x - rect1.getBottomRight().x, 2) + 
-            Math.pow(rect1.getTopLeft().y - rect1.getBottomRight().y, 2)
-        );
+                Math.pow(rect1.getTopLeft().x - rect1.getBottomRight().x, 2) +
+                        Math.pow(rect1.getTopLeft().y - rect1.getBottomRight().y, 2));
         float diag2 = (float) Math.sqrt(
-            Math.pow(rect2.getTopLeft().x - rect2.getBottomRight().x, 2) + 
-            Math.pow(rect2.getTopLeft().y - rect2.getBottomRight().y, 2)
-        );
-        
+                Math.pow(rect2.getTopLeft().x - rect2.getBottomRight().x, 2) +
+                        Math.pow(rect2.getTopLeft().y - rect2.getBottomRight().y, 2));
+
         float avgDiag = (diag1 + diag2) / 2;
-        
+
         // Make duplicate detection more strict (reduced from 0.15 to 0.1)
-        // If centers are close relative to the rectangle size, they're likely duplicates
+        // If centers are close relative to the rectangle size, they're likely
+        // duplicates
         return distanceBetweenCenters < (0.1f * avgDiag);
     }
-    
-    // Calculate how rectangular a shape is (1.0 = perfect rectangle, lower = less rectangular)
+
+    // Calculate how rectangular a shape is (1.0 = perfect rectangle, lower = less
+    // rectangular)
     private float calculateRectangularity(Rectangle rect) {
-        // Check angles between adjacent sides - should be close to 90 degrees in a rectangle
+        // Check angles between adjacent sides - should be close to 90 degrees in a
+        // rectangle
         android.graphics.Point topLeft = rect.getTopLeft();
         android.graphics.Point topRight = rect.getTopRight();
         android.graphics.Point bottomRight = rect.getBottomRight();
         android.graphics.Point bottomLeft = rect.getBottomLeft();
-        
+
         // Calculate vectors for the four sides
-        float[] side1x = {topRight.x - topLeft.x, topRight.y - topLeft.y};
-        float[] side2x = {bottomRight.x - topRight.x, bottomRight.y - topRight.y};
-        float[] side3x = {bottomLeft.x - bottomRight.x, bottomLeft.y - bottomRight.y};
-        float[] side4x = {topLeft.x - bottomLeft.x, topLeft.y - bottomLeft.y};
-        
+        float[] side1x = { topRight.x - topLeft.x, topRight.y - topLeft.y };
+        float[] side2x = { bottomRight.x - topRight.x, bottomRight.y - topRight.y };
+        float[] side3x = { bottomLeft.x - bottomRight.x, bottomLeft.y - bottomRight.y };
+        float[] side4x = { topLeft.x - bottomLeft.x, topLeft.y - bottomLeft.y };
+
         // Calculate angles between sides (dot product)
         float angle1 = calculateAngle(side1x, side2x);
         float angle2 = calculateAngle(side2x, side3x);
         float angle3 = calculateAngle(side3x, side4x);
         float angle4 = calculateAngle(side4x, side1x);
-        
+
         // For a perfect rectangle, all angles would be 90 degrees (or PI/2 radians)
         // Calculate deviation from 90 degrees for each angle
-        float dev1 = Math.abs(angle1 - (float)(Math.PI/2));
-        float dev2 = Math.abs(angle2 - (float)(Math.PI/2));
-        float dev3 = Math.abs(angle3 - (float)(Math.PI/2));
-        float dev4 = Math.abs(angle4 - (float)(Math.PI/2));
-        
+        float dev1 = Math.abs(angle1 - (float) (Math.PI / 2));
+        float dev2 = Math.abs(angle2 - (float) (Math.PI / 2));
+        float dev3 = Math.abs(angle3 - (float) (Math.PI / 2));
+        float dev4 = Math.abs(angle4 - (float) (Math.PI / 2));
+
         // Calculate average deviation, normalized to 0-1 range
         float avgDev = (dev1 + dev2 + dev3 + dev4) / 4;
-        
+
         // 1.0 = perfect rectangle, 0 = not rectangular at all
-        return Math.max(0, 1.0f - (avgDev / (float)(Math.PI/4)));
+        return Math.max(0, 1.0f - (avgDev / (float) (Math.PI / 4)));
     }
-    
+
     // Calculate angle between two vectors in radians
     private float calculateAngle(float[] v1, float[] v2) {
         // Calculate dot product
         float dotProduct = v1[0] * v2[0] + v1[1] * v2[1];
-        
+
         // Calculate magnitudes
-        float mag1 = (float)Math.sqrt(v1[0] * v1[0] + v1[1] * v1[1]);
-        float mag2 = (float)Math.sqrt(v2[0] * v2[0] + v2[1] * v2[1]);
-        
+        float mag1 = (float) Math.sqrt(v1[0] * v1[0] + v1[1] * v1[1]);
+        float mag2 = (float) Math.sqrt(v2[0] * v2[0] + v2[1] * v2[1]);
+
         // Avoid division by zero
-        if (mag1 == 0 || mag2 == 0) return 0;
-        
+        if (mag1 == 0 || mag2 == 0)
+            return 0;
+
         // Calculate angle
         float cosAngle = dotProduct / (mag1 * mag2);
-        
+
         // Ensure value is in [-1,1] range to avoid domain errors with acos
         cosAngle = Math.max(-1.0f, Math.min(1.0f, cosAngle));
-        
-        return (float)Math.acos(cosAngle);
+
+        return (float) Math.acos(cosAngle);
     }
-    
+
     // Calculate aspect ratio (width/height) using the average of opposite sides
     private float calculateAspectRatio(Rectangle rect) {
         android.graphics.Point topLeft = rect.getTopLeft();
         android.graphics.Point topRight = rect.getTopRight();
         android.graphics.Point bottomRight = rect.getBottomRight();
         android.graphics.Point bottomLeft = rect.getBottomLeft();
-        
-        float topWidth = (float)Math.sqrt(
-            Math.pow(topRight.x - topLeft.x, 2) + 
-            Math.pow(topRight.y - topLeft.y, 2)
-        );
-        
-        float bottomWidth = (float)Math.sqrt(
-            Math.pow(bottomRight.x - bottomLeft.x, 2) + 
-            Math.pow(bottomRight.y - bottomLeft.y, 2)
-        );
-        
-        float leftHeight = (float)Math.sqrt(
-            Math.pow(bottomLeft.x - topLeft.x, 2) + 
-            Math.pow(bottomLeft.y - topLeft.y, 2)
-        );
-        
-        float rightHeight = (float)Math.sqrt(
-            Math.pow(bottomRight.x - topRight.x, 2) + 
-            Math.pow(bottomRight.y - topRight.y, 2)
-        );
-        
+
+        float topWidth = (float) Math.sqrt(
+                Math.pow(topRight.x - topLeft.x, 2) +
+                        Math.pow(topRight.y - topLeft.y, 2));
+
+        float bottomWidth = (float) Math.sqrt(
+                Math.pow(bottomRight.x - bottomLeft.x, 2) +
+                        Math.pow(bottomRight.y - bottomLeft.y, 2));
+
+        float leftHeight = (float) Math.sqrt(
+                Math.pow(bottomLeft.x - topLeft.x, 2) +
+                        Math.pow(bottomLeft.y - topLeft.y, 2));
+
+        float rightHeight = (float) Math.sqrt(
+                Math.pow(bottomRight.x - topRight.x, 2) +
+                        Math.pow(bottomRight.y - topRight.y, 2));
+
         float avgWidth = (topWidth + bottomWidth) / 2;
         float avgHeight = (leftHeight + rightHeight) / 2;
-        
+
         // Avoid division by zero
-        if (avgHeight == 0) return 0;
-        
+        if (avgHeight == 0)
+            return 0;
+
         return avgWidth / avgHeight;
     }
-    
+
     // Calculate a quality score for the rectangle (higher = better)
     private float calculateRectangleQualityScore(Rectangle rect, Size imageSize) {
         float rectangularity = calculateRectangularity(rect);
@@ -722,19 +745,21 @@ public class CapacitorScannerPlugin extends Plugin {
         float area = getRectangleArea(rect);
         float imageArea = imageSize.getWidth() * imageSize.getHeight();
         float areaRatio = area / imageArea;
-        
-        // Ideal aspect ratio score (1.0 = golden ratio, decreases as we move away from it)
+
+        // Ideal aspect ratio score (1.0 = golden ratio, decreases as we move away from
+        // it)
         float idealAspect = 1.6f; // Close to golden ratio
         float aspectScore = 1.0f - Math.min(1.0f, Math.abs(aspectRatio - idealAspect) / 2.0f);
-        
-        // Ideal area score (0 for tiny or huge rectangles, 1.0 for rectangles that take up reasonable portion)
+
+        // Ideal area score (0 for tiny or huge rectangles, 1.0 for rectangles that take
+        // up reasonable portion)
         float areaScore = 0;
         if (areaRatio > 0.05f && areaRatio < 0.7f) {
             // Parabolic function that peaks at around 0.3 of the image area
             areaScore = 1.0f - 4.0f * (areaRatio - 0.3f) * (areaRatio - 0.3f);
             areaScore = Math.max(0, areaScore);
         }
-        
+
         // Weighted combination of factors
         return (0.5f * rectangularity) + (0.3f * aspectScore) + (0.2f * areaScore);
     }
@@ -771,7 +796,8 @@ public class CapacitorScannerPlugin extends Plugin {
                     data.put("scannedCode", rawValue);
                     data.put("format", BarcodeFormatHelper.barcodeFormatToString(format));
                     notifyListeners("barcodeScanned", data, true);
-                    echo("Barcode " + rawValue + " scanned with format: " + BarcodeFormatHelper.barcodeFormatToString(format));
+                    echo("Barcode " + rawValue + " scanned with format: "
+                            + BarcodeFormatHelper.barcodeFormatToString(format));
                 }
             }
         }
@@ -792,7 +818,7 @@ public class CapacitorScannerPlugin extends Plugin {
                 // Find the largest rectangle if multiple are detected
                 Rectangle largestRectangle = null;
                 float largestArea = 0;
-                
+
                 for (Rectangle rectangle : rectangles) {
                     float area = getRectangleArea(rectangle);
                     if (area > largestArea) {
@@ -800,13 +826,13 @@ public class CapacitorScannerPlugin extends Plugin {
                         largestRectangle = rectangle;
                     }
                 }
-                
+
                 // Emit event with detected: true for the largest rectangle
                 JSObject data = new JSObject();
                 data.put("detected", true);
                 echo("Emitting rectangleDetected event with {detected: true} at " + currentTime);
                 notifyListeners("rectangleDetected", data, true);
-                
+
                 // Update the last notification timestamp
                 lastRectangleNotificationTime = currentTime;
             } else {
@@ -852,13 +878,13 @@ public class CapacitorScannerPlugin extends Plugin {
         for (DetectionResult result : recentDetectionResults) {
             if (result != null && !result.getRectangles().isEmpty()) {
                 resultsWithRectangles++;
-                
+
                 // Calculate quality score for this detection result
                 float qualityScore = 0;
                 for (Rectangle rect : result.getRectangles()) {
                     qualityScore += calculateRectangleQualityScore(rect, result.getImageSize());
                 }
-                
+
                 // Factor in both number of rectangles and their quality
                 if (qualityScore > bestQualityScore) {
                     bestQualityScore = qualityScore;
@@ -945,8 +971,10 @@ public class CapacitorScannerPlugin extends Plugin {
         RectF srcRect = new RectF(0, 0, imageAnalysisWidth, imageAnalysisHeight);
         RectF dstRect = new RectF(0, 0, viewWidth, viewHeight);
 
-        // Configure the matrix to scale and translate the source rectangle to fill the destination,
-        // preserving aspect ratio. This is the equivalent of PreviewView's ScaleType.FILL_CENTER.
+        // Configure the matrix to scale and translate the source rectangle to fill the
+        // destination,
+        // preserving aspect ratio. This is the equivalent of PreviewView's
+        // ScaleType.FILL_CENTER.
         matrix.setRectToRect(srcRect, dstRect, Matrix.ScaleToFit.FILL);
 
         // Apply the transformation to the barcode's bounding box
@@ -1028,21 +1056,21 @@ public class CapacitorScannerPlugin extends Plugin {
             lastRectangleNotificationTime = 0;
             lastRectangleProcessingTime = 0;
             lastRectangleDetectionTime = 0;
-            
+
             // Clear detection histories and caches
             enabledDetectionTypes.clear();
             recentDetectionResults.clear();
             detectionHistory.clear();
             lastGoodRects = Collections.emptyList();
-            
+
             // Clear overlay rectangles
             synchronized (overlayLock) {
                 currentBarcodeRects.clear();
                 currentRectangleRects.clear();
             }
-            
+
             echo("All detection state variables have been reset");
-            
+
             call.resolve();
         });
     }
@@ -1062,7 +1090,7 @@ public class CapacitorScannerPlugin extends Plugin {
         lastGoodRects = Collections.emptyList();
         lastGoodRectangleTime = 0;
         lastGoodDetectionResult = null;
-        
+
         // Clear previous detection overlays
         if (detectionOverlay != null) {
             getActivity().runOnUiThread(() -> {
@@ -1092,10 +1120,11 @@ public class CapacitorScannerPlugin extends Plugin {
                 // Get value as double and convert to float
                 double paddingValue = call.getData().getDouble("paddingRatio");
                 float paddingRatioFloat = (float) paddingValue;
-                
+
                 // Validate that paddingRatio is between 0 and 1
                 if (paddingRatioFloat < 0 || paddingRatioFloat > 1) {
-                    echo("Invalid paddingRatio value: " + paddingRatioFloat + " - must be between 0 and 1. Using default 0.01f");
+                    echo("Invalid paddingRatio value: " + paddingRatioFloat
+                            + " - must be between 0 and 1. Using default 0.01f");
                     paddingRatio = 0.01f;
                 } else {
                     paddingRatio = paddingRatioFloat;
@@ -1119,7 +1148,9 @@ public class CapacitorScannerPlugin extends Plugin {
         }
 
         if (enabledDetectionTypes.contains("barcode") || enabledDetectionTypes.contains("businessCard")) {
-            setupDetectionOverlay();
+            getActivity().runOnUiThread(() -> {
+                setupDetectionOverlay();
+            });
         }
 
         call.resolve(result);
@@ -1173,7 +1204,8 @@ public class CapacitorScannerPlugin extends Plugin {
 
                             // Decode the image into a Bitmap
                             options.inJustDecodeBounds = false;
-                            Bitmap originalBitmap = BitmapFactory.decodeByteArray(originalBytes, 0, originalBytes.length, options);
+                            Bitmap originalBitmap = BitmapFactory.decodeByteArray(originalBytes, 0,
+                                    originalBytes.length, options);
                             if (originalBitmap == null) {
                                 call.reject("Failed to decode captured image.");
                                 return;
@@ -1189,13 +1221,12 @@ public class CapacitorScannerPlugin extends Plugin {
                                 // Scale the overlay rect from preview coordinates to bitmap coordinates
                                 float scaleX = (float) originalBitmap.getWidth() / previewView.getWidth();
                                 float scaleY = (float) originalBitmap.getHeight() / previewView.getHeight();
-                                
+
                                 RectF scaledRectF = new RectF(
-                                    largestRectF.left * scaleX,
-                                    largestRectF.top * scaleY,
-                                    largestRectF.right * scaleX,
-                                    largestRectF.bottom * scaleY
-                                );
+                                        largestRectF.left * scaleX,
+                                        largestRectF.top * scaleY,
+                                        largestRectF.right * scaleX,
+                                        largestRectF.bottom * scaleY);
 
                                 // **FIX**: Un-mirror the coordinates for cropping if using the front camera
                                 if (currentLensFacing == CameraSelector.LENS_FACING_FRONT) {
@@ -1204,35 +1235,34 @@ public class CapacitorScannerPlugin extends Plugin {
                                     scaledRectF.left = bitmapWidth - scaledRectF.right;
                                     scaledRectF.right = bitmapWidth - left;
                                 }
-                                
+
                                 // Calculate 1% padding based on the full image dimensions
                                 float paddingX = originalBitmap.getWidth() * paddingRatio;
                                 float paddingY = originalBitmap.getHeight() * paddingRatio;
-                                
+
                                 // Apply 2% padding to the rectangle while keeping it within image bounds
                                 RectF paddedRectF = new RectF(
-                                    Math.max(0, scaledRectF.left - paddingX),
-                                    Math.max(0, scaledRectF.top - paddingY),
-                                    Math.min(originalBitmap.getWidth(), scaledRectF.right + paddingX),
-                                    Math.min(originalBitmap.getHeight(), scaledRectF.bottom + paddingY)
-                                );
-                                
+                                        Math.max(0, scaledRectF.left - paddingX),
+                                        Math.max(0, scaledRectF.top - paddingY),
+                                        Math.min(originalBitmap.getWidth(), scaledRectF.right + paddingX),
+                                        Math.min(originalBitmap.getHeight(), scaledRectF.bottom + paddingY));
+
                                 // Convert scaled RectF to Rect (for cropping)
                                 Rect largestRect = new Rect(
                                         Math.round(paddedRectF.left),
                                         Math.round(paddedRectF.top),
                                         Math.round(paddedRectF.right),
-                                        Math.round(paddedRectF.bottom)
-                                );
+                                        Math.round(paddedRectF.bottom));
 
                                 // Log dimensions for debugging
-                                echo("📏 Cropping - Preview: " + previewView.getWidth() + "x" + previewView.getHeight() + 
-                                     ", Bitmap: " + originalBitmap.getWidth() + "x" + originalBitmap.getHeight() +
-                                     ", Scale: " + scaleX + "x" + scaleY);
-                                echo("🔍 Original Rect: " + largestRectF.toString() + 
-                                     " → Scaled Rect: " + scaledRectF.toString() + 
-                                     " → Padded Rect: " + paddedRectF.toString());
-                                
+                                echo("📏 Cropping - Preview: " + previewView.getWidth() + "x" + previewView.getHeight()
+                                        +
+                                        ", Bitmap: " + originalBitmap.getWidth() + "x" + originalBitmap.getHeight() +
+                                        ", Scale: " + scaleX + "x" + scaleY);
+                                echo("🔍 Original Rect: " + largestRectF.toString() +
+                                        " → Scaled Rect: " + scaledRectF.toString() +
+                                        " → Padded Rect: " + paddedRectF.toString());
+
                                 // Crop the image based on the largest rectangle
                                 processedBitmap = cropBitmap(originalBitmap, largestRect);
                             } else {
@@ -1303,12 +1333,13 @@ public class CapacitorScannerPlugin extends Plugin {
     }
 
     // **SAMPLE METHOD**: Rotate bitmap if needed (exact sample logic)
-// Adjust the image's rotation based on its EXIF orientation
+    // Adjust the image's rotation based on its EXIF orientation
     private Bitmap rotateBitmap(Bitmap bitmap, int rotationDegrees) {
         if (rotationDegrees != 0) {
             Matrix matrix = new Matrix();
             matrix.postRotate(rotationDegrees);
-            Bitmap rotatedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+            Bitmap rotatedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix,
+                    true);
             if (rotatedBitmap != bitmap) {
                 bitmap.recycle(); // Recycle original bitmap if a new one was created
             }
@@ -1495,7 +1526,8 @@ public class CapacitorScannerPlugin extends Plugin {
             case ImageFormat.JPEG -> toBitmapFromJpegFormatImage(imageProxy);
             case ImageFormat.YUV_420_888 -> toBitmapFromYUVFormatImage(imageProxy);
             default ->
-                    throw new UnsupportedOperationException("ImageProxy has unsupported image format: " + imageProxy.getFormat());
+                throw new UnsupportedOperationException(
+                        "ImageProxy has unsupported image format: " + imageProxy.getFormat());
         };
     }
 
@@ -1506,13 +1538,14 @@ public class CapacitorScannerPlugin extends Plugin {
         byte[] bytes = new byte[buffer.remaining()];
         buffer.get(bytes);
         Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
-        return rotateBitmap(cropBitmap(bitmap, imageProxy.getCropRect()), imageProxy.getImageInfo().getRotationDegrees());
+        return rotateBitmap(cropBitmap(bitmap, imageProxy.getCropRect()),
+                imageProxy.getImageInfo().getRotationDegrees());
     }
 
     // **SAMPLE METHOD**: Handle YUV format images (exact sample logic)
     private Bitmap toBitmapFromYUVFormatImage(ImageProxy imageProxy) {
         byte[] nv21 = toNV21ByteArray(imageProxy);
-        YuvImage yuvImage = new YuvImage(nv21, ImageFormat.NV21, 
+        YuvImage yuvImage = new YuvImage(nv21, ImageFormat.NV21,
                 imageProxy.getCropRect().width(), imageProxy.getCropRect().height(), null);
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         yuvImage.compressToJpeg(new Rect(0, 0, yuvImage.getWidth(), yuvImage.getHeight()), 80, out);
@@ -1528,13 +1561,13 @@ public class CapacitorScannerPlugin extends Plugin {
         int ySize = cropRect.width() * cropRect.height();
         int uvSize = cropRect.width() * cropRect.height() / 4;
         byte[] nv21 = new byte[ySize + uvSize * 2];
-        
+
         ImageProxy.PlaneProxy[] planes = imageProxy.getPlanes();
         for (int planeIndex = 0; planeIndex < planes.length; planeIndex++) {
             ImageProxy.PlaneProxy plane = planes[planeIndex];
             int outputStride;
             int outputOffset;
-            
+
             switch (planeIndex) {
                 case 0:
                     outputStride = 1;
@@ -1551,24 +1584,23 @@ public class CapacitorScannerPlugin extends Plugin {
                 default:
                     continue;
             }
-            
+
             ByteBuffer planeBuffer = plane.getBuffer();
             int rowStride = plane.getRowStride();
             int pixelStride = plane.getPixelStride();
-            
-            Rect planeCrop = (planeIndex == 0) ? cropRect : 
-                    new Rect(cropRect.left / 2, cropRect.top / 2, cropRect.right / 2, cropRect.bottom / 2);
-            
+
+            Rect planeCrop = (planeIndex == 0) ? cropRect
+                    : new Rect(cropRect.left / 2, cropRect.top / 2, cropRect.right / 2, cropRect.bottom / 2);
+
             int planeWidth = planeCrop.width();
             int planeHeight = planeCrop.height();
             byte[] rowBuffer = new byte[plane.getRowStride()];
-            
-            int rowLength = (pixelStride == 1 && outputStride == 1) ? planeWidth : 
-                    (planeWidth - 1) * pixelStride + 1;
-            
+
+            int rowLength = (pixelStride == 1 && outputStride == 1) ? planeWidth : (planeWidth - 1) * pixelStride + 1;
+
             for (int row = 0; row < planeHeight; row++) {
                 planeBuffer.position((row + planeCrop.top) * rowStride + planeCrop.left * pixelStride);
-                
+
                 if (pixelStride == 1 && outputStride == 1) {
                     planeBuffer.get(nv21, outputOffset, rowLength);
                     outputOffset += rowLength;
@@ -1581,7 +1613,7 @@ public class CapacitorScannerPlugin extends Plugin {
                 }
             }
         }
-        
+
         return nv21;
     }
 
@@ -1599,7 +1631,7 @@ public class CapacitorScannerPlugin extends Plugin {
                 case ExifInterface.ORIENTATION_ROTATE_270:
                     return 270;
                 default:
-                    return 0;  // No rotation
+                    return 0; // No rotation
             }
         } catch (IOException e) {
             e.printStackTrace();
@@ -1607,7 +1639,8 @@ public class CapacitorScannerPlugin extends Plugin {
         return 0;
     }
 
-    private void displayDetectedRectangles(DetectionResult detectionResult, int imageWidth, int imageHeight, int rotationDegrees) {
+    private void displayDetectedRectangles(DetectionResult detectionResult, int imageWidth, int imageHeight,
+            int rotationDegrees) {
         if (detectionOverlay == null || previewView == null) {
             return;
         }
@@ -1623,50 +1656,47 @@ public class CapacitorScannerPlugin extends Plugin {
 
         echo("🔄 Sample coordinate transformation - Preview: " + previewWidth + "x" + previewHeight +
                 ", Image: " + imageWidth + "x" + imageHeight + ", Rotation: " + rotationDegrees);
-        
+
         // Create preview size from actual preview dimensions
         Size previewSize = new Size(previewWidth, previewHeight);
-        
+
         // Transform rectangles using sample's exact logic
         RectF previewRectInImage = previewRectInImage(detectionResult.getImageSize(), previewSize);
         List<Rectangle> transformedRectangles = new ArrayList<>();
-        
+
         for (Rectangle rectangle : detectionResult.getRectangles()) {
             // Use separate scale ratios for width and height to fix vertical shifting
             float scaleRatioWidth = previewSize.getWidth() / previewRectInImage.width();
             float scaleRatioHeight = previewSize.getHeight() / previewRectInImage.height();
-            
+
             // Use the correct scale ratio for each dimension
             android.graphics.Point transformedTopLeft = new android.graphics.Point(
                     Math.round((rectangle.getTopLeft().x - previewRectInImage.left) * scaleRatioWidth),
-                    Math.round((rectangle.getTopLeft().y - previewRectInImage.top) * scaleRatioHeight)
-            );
+                    Math.round((rectangle.getTopLeft().y - previewRectInImage.top) * scaleRatioHeight));
             android.graphics.Point transformedTopRight = new android.graphics.Point(
                     Math.round((rectangle.getTopRight().x - previewRectInImage.left) * scaleRatioWidth),
-                    Math.round((rectangle.getTopRight().y - previewRectInImage.top) * scaleRatioHeight)
-            );
+                    Math.round((rectangle.getTopRight().y - previewRectInImage.top) * scaleRatioHeight));
             android.graphics.Point transformedBottomLeft = new android.graphics.Point(
                     Math.round((rectangle.getBottomLeft().x - previewRectInImage.left) * scaleRatioWidth),
-                    Math.round((rectangle.getBottomLeft().y - previewRectInImage.top) * scaleRatioHeight)
-            );
+                    Math.round((rectangle.getBottomLeft().y - previewRectInImage.top) * scaleRatioHeight));
             android.graphics.Point transformedBottomRight = new android.graphics.Point(
                     Math.round((rectangle.getBottomRight().x - previewRectInImage.left) * scaleRatioWidth),
-                    Math.round((rectangle.getBottomRight().y - previewRectInImage.top) * scaleRatioHeight)
-            );
-            
-            transformedRectangles.add(new Rectangle(transformedTopLeft, transformedTopRight, 
+                    Math.round((rectangle.getBottomRight().y - previewRectInImage.top) * scaleRatioHeight));
+
+            transformedRectangles.add(new Rectangle(transformedTopLeft, transformedTopRight,
                     transformedBottomLeft, transformedBottomRight));
         }
-        
+
         final List<RectF> overlayRects = new ArrayList<>();
         for (Rectangle rect : transformedRectangles) {
             // Create bounding box from transformed corner points
             RectF transformedRect = getRectF(rect);
             overlayRects.add(transformedRect);
-            
-            echo("✅ Sample transformation: " + 
-                    "Original corners: (" + detectionResult.getRectangles().get(overlayRects.size()-1).getTopLeft().x + "," + 
-                    detectionResult.getRectangles().get(overlayRects.size()-1).getTopLeft().y + ") → " +
+
+            echo("✅ Sample transformation: " +
+                    "Original corners: (" + detectionResult.getRectangles().get(overlayRects.size() - 1).getTopLeft().x
+                    + "," +
+                    detectionResult.getRectangles().get(overlayRects.size() - 1).getTopLeft().y + ") → " +
                     "Preview rect: " + transformedRect.toString());
         }
 
@@ -1679,17 +1709,18 @@ public class CapacitorScannerPlugin extends Plugin {
     @NonNull
     private RectF getRectF(Rectangle rect) {
         float minX = Math.min(Math.min(rect.getTopLeft().x, rect.getTopRight().x),
-                             Math.min(rect.getBottomLeft().x, rect.getBottomRight().x));
+                Math.min(rect.getBottomLeft().x, rect.getBottomRight().x));
         float minY = Math.min(Math.min(rect.getTopLeft().y, rect.getTopRight().y),
-                             Math.min(rect.getBottomLeft().y, rect.getBottomRight().y));
+                Math.min(rect.getBottomLeft().y, rect.getBottomRight().y));
         float maxX = Math.max(Math.max(rect.getTopLeft().x, rect.getTopRight().x),
-                             Math.max(rect.getBottomLeft().x, rect.getBottomRight().x));
+                Math.max(rect.getBottomLeft().x, rect.getBottomRight().x));
         float maxY = Math.max(Math.max(rect.getTopLeft().y, rect.getTopRight().y),
-                             Math.max(rect.getBottomLeft().y, rect.getBottomRight().y));
+                Math.max(rect.getBottomLeft().y, rect.getBottomRight().y));
 
         RectF boundingBox = new RectF(minX, minY, maxX, maxY);
 
-        // **FIX**: Horizontally flip the coordinates if the front camera is active to match the mirrored preview
+        // **FIX**: Horizontally flip the coordinates if the front camera is active to
+        // match the mirrored preview
         if (currentLensFacing == CameraSelector.LENS_FACING_FRONT) {
             float left = boundingBox.left;
             boundingBox.left = previewView.getWidth() - boundingBox.right;
@@ -1699,18 +1730,19 @@ public class CapacitorScannerPlugin extends Plugin {
         return boundingBox;
     }
 
-    // **SAMPLE METHOD**: Calculate preview rect in image coordinates (exact sample logic)
+    // **SAMPLE METHOD**: Calculate preview rect in image coordinates (exact sample
+    // logic)
     private RectF previewRectInImage(Size imageSize, Size previewSize) {
         float widthRatio = (float) previewSize.getWidth() / imageSize.getWidth();
         float heightRatio = (float) previewSize.getHeight() / imageSize.getHeight();
-        
+
         if (widthRatio > heightRatio) {
             // Preview wider - image cropped top/bottom
             float previewHeightInImage = previewSize.getHeight() / widthRatio;
             float topOffset = (imageSize.getHeight() - previewHeightInImage) / 2;
             return new RectF(0f, topOffset, imageSize.getWidth(), topOffset + previewHeightInImage);
         } else {
-            // Preview taller - image cropped left/right  
+            // Preview taller - image cropped left/right
             float previewWidthInImage = previewSize.getWidth() / heightRatio;
             float leftOffset = (imageSize.getWidth() - previewWidthInImage) / 2;
             return new RectF(leftOffset, 0f, leftOffset + previewWidthInImage, imageSize.getHeight());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scr2em/capacitor-scanner",
-  "version": "6.0.18",
+  "version": "6.0.20",
   "description": "scan codes",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -8,6 +8,7 @@
   "unpkg": "dist/plugin.js",
   "files": [
     "android/src/main/",
+  	"android/libs/rectangle-detector-release.aar",
     "android/build.gradle",
     "dist/",
     "ios/Sources",

package/android/src/main/libs/rectangle-detector/build.gradle

@@ -1,73 +0,0 @@
-plugins {
-    id 'com.android.library'
-    id 'kotlin-android'
-    id 'maven-publish'
-    id 'org.jetbrains.dokka'
-}
-
-group = 'com.github.smartbank-inc'
-
-android {
-    namespace "com.smartbank.rectangledetector"
-    compileSdkVersion compile_sdk_version
-
-    defaultConfig {
-        minSdkVersion 23
-        targetSdkVersion target_sdk_version
-        versionCode version_code
-        versionName version_name
-
-        consumerProguardFiles "consumer-rules.pro"
-    }
-
-    buildTypes {
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
-        }
-    }
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_17
-        targetCompatibility JavaVersion.VERSION_17
-    }
-    kotlinOptions {
-        jvmTarget = '17'
-    }
-}
-
-repositories {
-    google()
-    mavenCentral()
-}
-
-dependencies {
-    implementation 'org.opencv:opencv:4.12.0'
-}
-
-afterEvaluate {
-    tasks.register('androidSourcesJar', Jar) {
-        archiveClassifier.convention('sources')
-        archiveClassifier.set('sources')
-        from android.sourceSets.main.java.source
-    }
-
-    tasks.register('androidJavadocsJar', Jar) {
-        dependsOn dokkaJavadoc
-        archiveClassifier.convention('javadoc')
-        archiveClassifier.set('javadoc')
-        from dokkaJavadoc.outputDirectory
-    }
-
-    publishing {
-        publications {
-            release(MavenPublication) {
-                from components.release
-                groupId = 'com.github.smartbank-inc'
-                artifactId = 'android-rectangle-detector'
-                version = version_name
-                artifact androidSourcesJar
-                artifact androidJavadocsJar
-            }
-        }
-    }
-}

package/android/src/main/libs/rectangle-detector/proguard-rules.pro

@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile

package/android/src/main/libs/rectangle-detector/src/main/AndroidManifest.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest />