@scr2em/capacitor-scanner 6.0.29 → 6.0.31

package/README.md

@@ -262,7 +262,7 @@ Set the camera zoom level.
 
 #### StartOptions
 
-<code>{ /** * Barcode formats to detect when barcodeDetection is enabled. */ formats?: BarcodeFormat[]; /** * Camera direction to use. Defaults to 'BACK'. */ cameraDirection?: 'BACK' | 'FRONT'; /** * Enable barcode detection on start. Defaults to false. * When enabled, the camera will automatically detect barcodes and emit 'barcodeScanned' events. */ barcodeDetection?: boolean; /** * Whether to show the highlight overlay for detected barcodes. Defaults to false. * Only applies when barcodeDetection is true. */ barcodeHighlight?: boolean; /** * Enable object detection (business card) on start. Defaults to false. * When enabled, the camera will automatically detect business cards and emit 'rectangleDetected' events. */ objectDetection?: boolean; /** * Whether to show the highlight overlay for detected business cards. Defaults to true. * Only applies when objectDetection is true. */ objectHighlight?: boolean; /** * Minimum interval in seconds between consecutive 'rectangleDetected' events. * Only applies when objectDetection is true. * Defaults to 0 (no throttling beyond initial stability check). */ rectangleEmitIntervalSeconds?: number; debounceTimeInMilli?: number; /** * Optional regex pattern to filter scanned barcodes. * If provided, only barcodes matching this pattern will be reported. */ regex?: string; /** * Optional regex flags (e.g., 'i' for case-insensitive, 'm' for multiline). */ regexFlags?: string; }</code>
+<code>{ /** * Barcode formats to detect when barcodeDetection is enabled. */ formats?: BarcodeFormat[]; /** * Camera direction to use. Defaults to 'BACK'. */ cameraDirection?: 'BACK' | 'FRONT'; /** * Enable barcode detection on start. Defaults to false. * When enabled, the camera will automatically detect barcodes and emit 'barcodeScanned' events. */ barcodeDetection?: boolean; /** * Whether to show the highlight overlay for detected barcodes. Defaults to false. * Only applies when barcodeDetection is true. */ barcodeHighlight?: boolean; /** * Enable object detection (business card) on start. Defaults to false. * When enabled, the camera will automatically detect business cards and emit 'rectangleDetected' events. */ objectDetection?: boolean; /** * Whether to show the highlight overlay for detected business cards. Defaults to true. * Only applies when objectDetection is true. */ objectHighlight?: boolean; /** * Minimum interval in seconds between consecutive 'rectangleDetected' events. * Only applies when objectDetection is true. * Defaults to 0 (no throttling beyond initial stability check). */ rectangleEmitIntervalSeconds?: number; /** * Optional regex pattern to filter scanned barcodes. * If provided, only barcodes matching this pattern will be reported. */ regex?: string; /** * Optional regex flags (e.g., 'i' for case-insensitive, 'm' for multiline). */ regexFlags?: string; /** * Duration in seconds to pause rectangle detection after a barcode is successfully scanned. * When both barcode and object detection are enabled, this gives barcode scanning priority * by temporarily suppressing rectangle detection after a barcode is emitted. * Defaults to 0 (no throttle, both detections run simultaneously). */ detectionThrottleSeconds?: number; }</code>
 
 
 #### CapturePhotoOptions

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

@@ -143,6 +143,10 @@ public class CapacitorScannerPlugin extends Plugin {
     // Configurable interval between rectangle detection event emissions (in milliseconds)
     private long rectangleEmitIntervalMs = 0; // Default: 0 (no throttling)
 
+    // Detection throttle: pause rectangle detection after a successful barcode scan
+    private long detectionThrottleMs = 0; // Default: 0 (no throttle)
+    private long lastSuccessfulBarcodeScanTime = 0;
+
     /**
      * Calculates the processing interval in milliseconds based on the desired
      * frequency per second.
@@ -230,6 +234,19 @@ public class CapacitorScannerPlugin extends Plugin {
                 }
             }
 
+            // Read detection throttle
+            if (call.getData().has("detectionThrottleSeconds")) {
+                try {
+                    double throttleSeconds = call.getData().getDouble("detectionThrottleSeconds");
+                    detectionThrottleMs = Math.max(0, (long) (throttleSeconds * 1000));
+                } catch (Exception e) {
+                    detectionThrottleMs = 0;
+                }
+            } else {
+                detectionThrottleMs = 0;
+            }
+            lastSuccessfulBarcodeScanTime = 0;
+
             try {
                 String cameraDirectionStr = call.getString("cameraDirection", "BACK");
                 int lensFacing;
@@ -449,152 +466,169 @@ public class CapacitorScannerPlugin extends Plugin {
 
         @Override
         public void analyze(@NonNull ImageProxy imageProxy) {
-            try (imageProxy) {
-                @ExperimentalGetImage
-                android.media.Image mediaImage = imageProxy.getImage();
-                if (mediaImage != null) {
-                    InputImage image = InputImage.fromMediaImage(mediaImage,
-                            imageProxy.getImageInfo().getRotationDegrees());
-
-                    // Barcode detection - only process if barcode detection is enabled
-                    if (scanner != null && enabledDetectionTypes.contains("barcode")) {
-                        scanner.process(image)
-                                .addOnSuccessListener(executor, barcodes -> {
-                                    processBarcodes(barcodes);
-                                    // Only display barcode overlay if highlight is enabled
-                                    if (enabledHighlightTypes.contains("barcode")) {
-                                        displayDetectedBarcodes(barcodes, imageProxy.getWidth(), imageProxy.getHeight(),
-                                                imageProxy.getImageInfo().getRotationDegrees());
-                                    }
-                                })
-                                .addOnFailureListener(executor, e -> {
-                                    echo("Failed to process image for barcode: " + e.getMessage());
-                                });
-                    }
+            @ExperimentalGetImage
+            android.media.Image mediaImage = imageProxy.getImage();
+            if (mediaImage == null) {
+                imageProxy.close();
+                return;
+            }
 
-                    // Rectangle detection
-                    if (rectangleDetector != null && enabledDetectionTypes.contains("businessCard")) {
-                        DetectionResult detectionResult = null;
-
-                        // Only perform detection if enough time has passed since last detection
-                        // This throttles processing based on configured frequency
-                        long currentTime = System.currentTimeMillis();
-                        long processingIntervalMs = calculateProcessingInterval(processingFrequency);
-                        if (currentTime - lastRectangleProcessingTime >= processingIntervalMs) {
-                            // Perform new detection
-                            echo("Starting rectangle detection for businessCard");
-                            Bitmap bitmap = null;
-                            try {
-                                // Convert ImageProxy to Bitmap using the sample's toBitmap method
-                                bitmap = imageProxyToBitmap(imageProxy);
+            // Capture metadata upfront so it's available after imageProxy is closed
+            final int imageWidth = imageProxy.getWidth();
+            final int imageHeight = imageProxy.getHeight();
+            final int rotationDegrees = imageProxy.getImageInfo().getRotationDegrees();
 
-                                echo("Converting image for rectangle detection - bitmap size: " + bitmap.getWidth()
-                                        + "x" + bitmap.getHeight());
+            try {
+                InputImage image = InputImage.fromMediaImage(mediaImage, rotationDegrees);
+
+                boolean barcodeEnabled = scanner != null && enabledDetectionTypes.contains("barcode");
+                boolean isRectangleThrottled = detectionThrottleMs > 0
+                        && lastSuccessfulBarcodeScanTime > 0
+                        && (System.currentTimeMillis() - lastSuccessfulBarcodeScanTime) < detectionThrottleMs;
+                boolean rectangleEnabled = rectangleDetector != null
+                        && enabledDetectionTypes.contains("businessCard")
+                        && !isRectangleThrottled;
+
+                // Clear rectangle overlay when throttled
+                if (isRectangleThrottled && enabledDetectionTypes.contains("businessCard")) {
+                    getActivity().runOnUiThread(() -> {
+                        synchronized (overlayLock) {
+                            currentRectangleRects.clear();
+                            updateOverlayDetections(currentBarcodeRects, currentRectangleRects);
+                        }
+                    });
+                }
 
-                                long startTime = System.currentTimeMillis();
-                                DetectionResult rawResult = rectangleDetector.detectRectangles(bitmap);
-                                echo("Rectangle detection took " + (System.currentTimeMillis() - startTime) + "ms");
+                // Rectangle detection (synchronous) - runs first while imageProxy is still open
+                if (rectangleEnabled) {
+                    DetectionResult detectionResult = null;
+
+                    // Only perform detection if enough time has passed since last detection
+                    // This throttles processing based on configured frequency
+                    long currentTime = System.currentTimeMillis();
+                    long processingIntervalMs = calculateProcessingInterval(processingFrequency);
+                    if (currentTime - lastRectangleProcessingTime >= processingIntervalMs) {
+                        // Perform new detection
+                        Bitmap bitmap = null;
+                        try {
+                            // Convert ImageProxy to Bitmap using the sample's toBitmap method
+                            bitmap = imageProxyToBitmap(imageProxy);
 
-                                // Apply geometric filtering to eliminate false positives
-                                List<Rectangle> filteredRectangles = filterRectangles(rawResult.getRectangles(),
-                                        rawResult.getImageSize());
+                            DetectionResult rawResult = rectangleDetector.detectRectangles(bitmap);
 
-                                // 2) record hit/miss in sliding window
-                                boolean isHit = !filteredRectangles.isEmpty();
-                                detectionHistory.add(isHit);
-                                if (detectionHistory.size() > DETECTION_WINDOW) {
-                                    detectionHistory.poll();
-                                }
-                                if (isHit) {
-                                    lastGoodRects = filteredRectangles; // update last known good
-                                    echo("✅ Hit - saved " + filteredRectangles.size() + " good rectangles");
-                                } else {
-                                    echo("❌ Miss - keeping " + lastGoodRects.size() + " previous rectangles");
-                                }
+                            // Apply geometric filtering to eliminate false positives
+                            List<Rectangle> filteredRectangles = filterRectangles(rawResult.getRectangles(),
+                                    rawResult.getImageSize());
 
-                                // 3) decide whether to show based on sliding window
-                                long hits = 0;
-                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-                                    hits = detectionHistory.stream().filter(b -> b).count();
-                                } else {
-                                    // For older Android versions, count manually
-                                    for (Boolean hit : detectionHistory) {
-                                        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);
-
-                                // Create detection result with the rectangles we decided to show
-                                detectionResult = new DetectionResult(rawResult.getImageSize(), rectanglesToShow);
-
-                                // Store the detection result for reuse on non-processing frames
-                                if (!rectanglesToShow.isEmpty()) {
-                                    lastGoodDetectionResult = detectionResult;
-                                    lastRectangleDetectionTime = currentTime;
-                                }
+                            // 2) record hit/miss in sliding window
+                            boolean isHit = !filteredRectangles.isEmpty();
+                            detectionHistory.add(isHit);
+                            if (detectionHistory.size() > DETECTION_WINDOW) {
+                                detectionHistory.poll();
+                            }
+                            if (isHit) {
+                                lastGoodRects = filteredRectangles; // update last known good
+                            }
 
-                                // Process rectangle detection results to emit events if we're showing
-                                // rectangles
-                                if (!rectanglesToShow.isEmpty()) {
-                                    processRectangles(detectionResult);
+                            // 3) decide whether to show based on sliding window
+                            long hits = 0;
+                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                                hits = detectionHistory.stream().filter(b -> b).count();
+                            } else {
+                                // For older Android versions, count manually
+                                for (Boolean hit : detectionHistory) {
+                                    if (hit)
+                                        hits++;
                                 }
+                            }
+                            boolean shouldShow = hits >= Math.ceil(PRESENCE_THRESHOLD * detectionHistory.size());
+                            List<Rectangle> rectanglesToShow = shouldShow ? lastGoodRects : Collections.emptyList();
 
-                                // Update last processing time
-                                lastRectangleProcessingTime = currentTime;
-                            } 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<>());
-                            } finally {
-                                // Cleanup bitmap resource in all code paths
-                                if (bitmap != null) {
-                                    bitmap.recycle();
-                                }
+                            // Create detection result with the rectangles we decided to show
+                            detectionResult = new DetectionResult(rawResult.getImageSize(), rectanglesToShow);
+
+                            // Store the detection result for reuse on non-processing frames
+                            if (!rectanglesToShow.isEmpty()) {
+                                lastGoodDetectionResult = detectionResult;
+                                lastRectangleDetectionTime = currentTime;
                             }
-                        } 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
-                            if (lastGoodDetectionResult != null &&
-                                    (currentTime - lastRectangleDetectionTime) < CACHE_MS) {
-                                detectionResult = lastGoodDetectionResult;
-                                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<>());
+
+                            // Process rectangle detection results to emit events if we're showing
+                            // rectangles
+                            if (!rectanglesToShow.isEmpty()) {
+                                processRectangles(detectionResult);
                             }
-                        }
 
-                        // Always display detection results for every frame to keep UI smooth
-                        // This runs for both freshly detected rectangles and reused detection results
-                        final DetectionResult finalResult = detectionResult;
-                        getActivity().runOnUiThread(() -> {
-                            // Only display rectangle overlay if highlight is enabled
-                            if (enabledHighlightTypes.contains("businessCard")) {
-                                // Show the rectangles
-                                displayDetectedRectangles(finalResult,
-                                        imageProxy.getWidth(),
-                                        imageProxy.getHeight(),
-                                        imageProxy.getImageInfo().getRotationDegrees());
+                            // Update last processing time
+                            lastRectangleProcessingTime = currentTime;
+                        } catch (Exception e) {
+                            echo("Failed to process image for rectangle detection: " + e.getMessage());
+                            e.printStackTrace();
+                            detectionResult = new DetectionResult(
+                                    new Size(imageWidth, imageHeight), new ArrayList<>());
+                        } finally {
+                            // Cleanup bitmap resource in all code paths
+                            if (bitmap != null) {
+                                bitmap.recycle();
                             }
-                        });
+                        }
                     } else {
-                        // When businessCard detection is disabled, we don't need to do anything here.
-                        // The overlay is cleared by the disableObjectDetection method.
+                        // 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
+                        if (lastGoodDetectionResult != null &&
+                                (currentTime - lastRectangleDetectionTime) < CACHE_MS) {
+                            detectionResult = lastGoodDetectionResult;
+                        } else {
+                            // Create empty result if we have no recent good detection
+                            detectionResult = new DetectionResult(
+                                    new Size(imageWidth, imageHeight), new ArrayList<>());
+                        }
                     }
+
+                    // Always display detection results for every frame to keep UI smooth
+                    // This runs for both freshly detected rectangles and reused detection results
+                    final DetectionResult finalResult = detectionResult;
+                    getActivity().runOnUiThread(() -> {
+                        // Only display rectangle overlay if highlight is enabled
+                        if (enabledHighlightTypes.contains("businessCard")) {
+                            // Show the rectangles
+                            displayDetectedRectangles(finalResult,
+                                    imageWidth,
+                                    imageHeight,
+                                    rotationDegrees);
+                        }
+                    });
+                }
+
+                // Barcode detection (async) - close imageProxy only after ML Kit finishes
+                // processing. The imageProxy must stay open so ML Kit can read the underlying
+                // image buffer.
+                if (barcodeEnabled) {
+                    scanner.process(image)
+                            .addOnSuccessListener(executor, barcodes -> {
+                                processBarcodes(barcodes);
+                                // Only display barcode overlay if highlight is enabled
+                                if (enabledHighlightTypes.contains("barcode")) {
+                                    displayDetectedBarcodes(barcodes, imageWidth, imageHeight,
+                                            rotationDegrees);
+                                }
+                            })
+                            .addOnFailureListener(executor, e -> {
+                                echo("Failed to process image for barcode: " + e.getMessage());
+                            })
+                            .addOnCompleteListener(executor, task -> {
+                                imageProxy.close();
+                            });
+                } else {
+                    // No async work pending — safe to close now
+                    imageProxy.close();
                 }
             } catch (Exception e) {
                 echo("Unexpected error in image analysis: " + e.getMessage());
                 e.printStackTrace();
+                imageProxy.close();
             }
-            // Always close the ImageProxy, in all code paths
         }
     }
 
@@ -874,6 +908,10 @@ public class CapacitorScannerPlugin extends Plugin {
                     data.put("scannedCode", rawValue);
                     data.put("format", BarcodeFormatHelper.barcodeFormatToString(format));
                     notifyListeners("barcodeScanned", data, true);
+
+                    // Record successful scan time for detection throttle
+                    lastSuccessfulBarcodeScanTime = System.currentTimeMillis();
+
                     echo("Barcode " + rawValue + " scanned with format: "
                             + BarcodeFormatHelper.barcodeFormatToString(format));
                 }
@@ -1148,6 +1186,8 @@ public class CapacitorScannerPlugin extends Plugin {
         lastRectangleProcessingTime = 0;
         lastRectangleDetectionTime = 0;
         rectangleEmitIntervalMs = 0;
+        detectionThrottleMs = 0;
+        lastSuccessfulBarcodeScanTime = 0;
 
         // Clear detection histories and caches
         enabledDetectionTypes.clear();

package/dist/docs.json

@@ -344,7 +344,7 @@
       "docs": "",
       "types": [
         {
-          "text": "{\n  /**\n   * Barcode formats to detect when barcodeDetection is enabled.\n   */\n  formats?: BarcodeFormat[];\n  /**\n   * Camera direction to use. Defaults to 'BACK'.\n   */\n  cameraDirection?: 'BACK' | 'FRONT';\n  /**\n   * Enable barcode detection on start. Defaults to false.\n   * When enabled, the camera will automatically detect barcodes and emit 'barcodeScanned' events.\n   */\n  barcodeDetection?: boolean;\n  /**\n   * Whether to show the highlight overlay for detected barcodes. Defaults to false.\n   * Only applies when barcodeDetection is true.\n   */\n  barcodeHighlight?: boolean;\n  /**\n   * Enable object detection (business card) on start. Defaults to false.\n   * When enabled, the camera will automatically detect business cards and emit 'rectangleDetected' events.\n   */\n  objectDetection?: boolean;\n  /**\n   * Whether to show the highlight overlay for detected business cards. Defaults to true.\n   * Only applies when objectDetection is true.\n   */\n  objectHighlight?: boolean;\n  /**\n   * Minimum interval in seconds between consecutive 'rectangleDetected' events.\n   * Only applies when objectDetection is true.\n   * Defaults to 0 (no throttling beyond initial stability check).\n   */\n  rectangleEmitIntervalSeconds?: number;\n  debounceTimeInMilli?: number;\n  /**\n   * Optional regex pattern to filter scanned barcodes.\n   * If provided, only barcodes matching this pattern will be reported.\n   */\n  regex?: string;\n  /**\n   * Optional regex flags (e.g., 'i' for case-insensitive, 'm' for multiline).\n   */\n  regexFlags?: string;\n}",
+          "text": "{\n  /**\n   * Barcode formats to detect when barcodeDetection is enabled.\n   */\n  formats?: BarcodeFormat[];\n  /**\n   * Camera direction to use. Defaults to 'BACK'.\n   */\n  cameraDirection?: 'BACK' | 'FRONT';\n  /**\n   * Enable barcode detection on start. Defaults to false.\n   * When enabled, the camera will automatically detect barcodes and emit 'barcodeScanned' events.\n   */\n  barcodeDetection?: boolean;\n  /**\n   * Whether to show the highlight overlay for detected barcodes. Defaults to false.\n   * Only applies when barcodeDetection is true.\n   */\n  barcodeHighlight?: boolean;\n  /**\n   * Enable object detection (business card) on start. Defaults to false.\n   * When enabled, the camera will automatically detect business cards and emit 'rectangleDetected' events.\n   */\n  objectDetection?: boolean;\n  /**\n   * Whether to show the highlight overlay for detected business cards. Defaults to true.\n   * Only applies when objectDetection is true.\n   */\n  objectHighlight?: boolean;\n  /**\n   * Minimum interval in seconds between consecutive 'rectangleDetected' events.\n   * Only applies when objectDetection is true.\n   * Defaults to 0 (no throttling beyond initial stability check).\n   */\n  rectangleEmitIntervalSeconds?: number;\n  /**\n   * Optional regex pattern to filter scanned barcodes.\n   * If provided, only barcodes matching this pattern will be reported.\n   */\n  regex?: string;\n  /**\n   * Optional regex flags (e.g., 'i' for case-insensitive, 'm' for multiline).\n   */\n  regexFlags?: string;\n  /**\n   * Duration in seconds to pause rectangle detection after a barcode is successfully scanned.\n   * When both barcode and object detection are enabled, this gives barcode scanning priority\n   * by temporarily suppressing rectangle detection after a barcode is emitted.\n   * Defaults to 0 (no throttle, both detections run simultaneously).\n   */\n  detectionThrottleSeconds?: number;\n}",
           "complexTypes": [
             "BarcodeFormat"
           ]

package/dist/esm/definitions.d.ts

@@ -105,7 +105,6 @@ export declare type StartOptions = {
      * Defaults to 0 (no throttling beyond initial stability check).
      */
     rectangleEmitIntervalSeconds?: number;
-    debounceTimeInMilli?: number;
     /**
      * Optional regex pattern to filter scanned barcodes.
      * If provided, only barcodes matching this pattern will be reported.
@@ -115,6 +114,13 @@ export declare type StartOptions = {
      * Optional regex flags (e.g., 'i' for case-insensitive, 'm' for multiline).
      */
     regexFlags?: string;
+    /**
+     * Duration in seconds to pause rectangle detection after a barcode is successfully scanned.
+     * When both barcode and object detection are enabled, this gives barcode scanning priority
+     * by temporarily suppressing rectangle detection after a barcode is emitted.
+     * Defaults to 0 (no throttle, both detections run simultaneously).
+     */
+    detectionThrottleSeconds?: number;
 };
 export declare type BarcodeScannedEvent = {
     scannedCode: string;

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAmKA,MAAM,CAAN,IAAY,aAYX;AAZD,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,mCAAkB,CAAA;IAClB,mCAAkB,CAAA;IAClB,qCAAoB,CAAA;IACpB,2CAA0B,CAAA;IAC1B,+BAAc,CAAA;IACd,iCAAgB,CAAA;IAChB,gCAAe,CAAA;IACf,mCAAkB,CAAA;IAClB,mCAAkB,CAAA;IAClB,+BAAc,CAAA;AAChB,CAAC,EAZW,aAAa,KAAb,aAAa,QAYxB","sourcesContent":["export interface CapacitorScannerPlugin {\n  /**\n   * Start the camera preview with optional barcode and object detection.\n   * @param options - Configuration options for the camera and detection\n   */\n  start(options?: StartOptions): Promise<void>;\n\n  /**\n   * Stop the camera preview and all detection.\n   */\n  stop(): Promise<void>;\n\n  openSettings(): Promise<void>;\n\n  capturePhoto(options?: CapturePhotoOptions): Promise<CapturePhotoResult>;\n\n  checkPermissions(): Promise<PermissionsResult>;\n\n  requestPermissions(): Promise<PermissionsResult>;\n\n  flipCamera(): Promise<void>;\n\n  toggleFlash(): Promise<FlashResult>;\n\n  addListener(event: 'barcodeScanned', listenerFunc: (result: BarcodeScannedEvent) => void): Promise<void>;\n\n  addListener(event: 'rectangleDetected', listenerFunc: (result: RectangleDetectedEvent) => void): Promise<void>;\n\n  removeAllListeners(): Promise<void>;\n\n  /**\n   * Enable object detection (business card). This will start detecting business cards.\n   * @param options - Optional configuration for object detection\n   */\n  enableObjectDetection(options?: ObjectDetectionOptions): Promise<{ enabled: true }>;\n\n  /**\n   * Disable object detection. This will stop detecting business cards.\n   */\n  disableObjectDetection(): Promise<{ enabled: false }>;\n\n  /**\n   * Enable barcode detection. This will start detecting barcodes.\n   * @param options - Optional configuration for barcode detection\n   */\n  enableBarcodeDetection(options?: BarcodeDetectionOptions): Promise<{ enabled: true }>;\n\n  /**\n   * Disable barcode detection. This will stop detecting barcodes and clear cached barcodes.\n   */\n  disableBarcodeDetection(): Promise<{ enabled: false }>;\n\n  /**\n   * Set the camera zoom level.\n   * @param options - The zoom options containing the level (1, 2, or 3)\n   */\n  zoom(options: ZoomOptions): Promise<ZoomResult>;\n}\n\nexport type BarcodeDetectionOptions = {\n  /**\n   * Whether to show the highlight overlay for detected barcodes.\n   * Defaults to false.\n   */\n  showHighlight?: boolean;\n}\n\nexport type ObjectDetectionOptions = {\n  /**\n   * Whether to show the highlight overlay for detected business cards.\n   * Defaults to true.\n   */\n  showHighlight?: boolean,\n  /**\n   * Minimum interval in seconds between consecutive 'rectangleDetected' events.\n   * After an event is emitted, no new events will be emitted until this interval passes.\n   * Set to 0 to emit events as soon as stability is detected.\n   * Defaults to 0 (no throttling beyond initial stability check).\n   */\n  emitIntervalSeconds?: number\n}\n\nexport type StartOptions = {\n  /**\n   * Barcode formats to detect when barcodeDetection is enabled.\n   */\n  formats?: BarcodeFormat[];\n  /**\n   * Camera direction to use. Defaults to 'BACK'.\n   */\n  cameraDirection?: 'BACK' | 'FRONT';\n  /**\n   * Enable barcode detection on start. Defaults to false.\n   * When enabled, the camera will automatically detect barcodes and emit 'barcodeScanned' events.\n   */\n  barcodeDetection?: boolean;\n  /**\n   * Whether to show the highlight overlay for detected barcodes. Defaults to false.\n   * Only applies when barcodeDetection is true.\n   */\n  barcodeHighlight?: boolean;\n  /**\n   * Enable object detection (business card) on start. Defaults to false.\n   * When enabled, the camera will automatically detect business cards and emit 'rectangleDetected' events.\n   */\n  objectDetection?: boolean;\n  /**\n   * Whether to show the highlight overlay for detected business cards. Defaults to true.\n   * Only applies when objectDetection is true.\n   */\n  objectHighlight?: boolean;\n  /**\n   * Minimum interval in seconds between consecutive 'rectangleDetected' events.\n   * Only applies when objectDetection is true.\n   * Defaults to 0 (no throttling beyond initial stability check).\n   */\n  rectangleEmitIntervalSeconds?: number;\n  debounceTimeInMilli?: number;\n  /**\n   * Optional regex pattern to filter scanned barcodes.\n   * If provided, only barcodes matching this pattern will be reported.\n   */\n  regex?: string;\n  /**\n   * Optional regex flags (e.g., 'i' for case-insensitive, 'm' for multiline).\n   */\n  regexFlags?: string;\n};\n\nexport type BarcodeScannedEvent = { scannedCode: string; format: string };\n\n\nexport type RectangleDetectedEvent = {\n  detected: true\n};\n\nexport type CapturePhotoOptions = {\n  /**\n   * The desired quality of the captured image, expressed as a value between 0.0 (lowest quality, smallest file size)\n   * and 1.0 (highest quality, largest file size). Defaults to 1.0.\n   * This parameter directly influences the compression level of the resulting JPEG image.\n   */\n  qualityRatio?: number;\n};\n\nexport type PermissionsResult = { camera: 'prompt' | 'denied' | 'granted' };\n\nexport type CapturePhotoResult = { imageBase64: string };\n\nexport type FlashResult = { enabled: boolean };\n\nexport type ZoomOptions = {\n  /**\n   * The zoom level to set. Must be 1, 2, or 3.\n   * - 1 = 1.0x (no zoom)\n   * - 2 = 2.0x\n   * - 3 = 3.0x\n   */\n  level: 1 | 2 | 3;\n};\n\nexport type ZoomResult = { level: number };\n\nexport enum BarcodeFormat {\n  Aztec = 'AZTEC',\n  Code39 = 'CODE_39',\n  Code93 = 'CODE_93',\n  Code128 = 'CODE_128',\n  DataMatrix = 'DATA_MATRIX',\n  Ean8 = 'EAN_8',\n  Ean13 = 'EAN_13',\n  Itf14 = 'ITF14',\n  Pdf417 = 'PDF_417',\n  QrCode = 'QR_CODE',\n  UpcE = 'UPC_E',\n}\n\ndeclare global {\n  interface PluginRegistry {\n    QRScanner: CapacitorScannerPlugin;\n  }\n}"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAyKA,MAAM,CAAN,IAAY,aAYX;AAZD,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,mCAAkB,CAAA;IAClB,mCAAkB,CAAA;IAClB,qCAAoB,CAAA;IACpB,2CAA0B,CAAA;IAC1B,+BAAc,CAAA;IACd,iCAAgB,CAAA;IAChB,gCAAe,CAAA;IACf,mCAAkB,CAAA;IAClB,mCAAkB,CAAA;IAClB,+BAAc,CAAA;AAChB,CAAC,EAZW,aAAa,KAAb,aAAa,QAYxB","sourcesContent":["export interface CapacitorScannerPlugin {\n  /**\n   * Start the camera preview with optional barcode and object detection.\n   * @param options - Configuration options for the camera and detection\n   */\n  start(options?: StartOptions): Promise<void>;\n\n  /**\n   * Stop the camera preview and all detection.\n   */\n  stop(): Promise<void>;\n\n  openSettings(): Promise<void>;\n\n  capturePhoto(options?: CapturePhotoOptions): Promise<CapturePhotoResult>;\n\n  checkPermissions(): Promise<PermissionsResult>;\n\n  requestPermissions(): Promise<PermissionsResult>;\n\n  flipCamera(): Promise<void>;\n\n  toggleFlash(): Promise<FlashResult>;\n\n  addListener(event: 'barcodeScanned', listenerFunc: (result: BarcodeScannedEvent) => void): Promise<void>;\n\n  addListener(event: 'rectangleDetected', listenerFunc: (result: RectangleDetectedEvent) => void): Promise<void>;\n\n  removeAllListeners(): Promise<void>;\n\n  /**\n   * Enable object detection (business card). This will start detecting business cards.\n   * @param options - Optional configuration for object detection\n   */\n  enableObjectDetection(options?: ObjectDetectionOptions): Promise<{ enabled: true }>;\n\n  /**\n   * Disable object detection. This will stop detecting business cards.\n   */\n  disableObjectDetection(): Promise<{ enabled: false }>;\n\n  /**\n   * Enable barcode detection. This will start detecting barcodes.\n   * @param options - Optional configuration for barcode detection\n   */\n  enableBarcodeDetection(options?: BarcodeDetectionOptions): Promise<{ enabled: true }>;\n\n  /**\n   * Disable barcode detection. This will stop detecting barcodes and clear cached barcodes.\n   */\n  disableBarcodeDetection(): Promise<{ enabled: false }>;\n\n  /**\n   * Set the camera zoom level.\n   * @param options - The zoom options containing the level (1, 2, or 3)\n   */\n  zoom(options: ZoomOptions): Promise<ZoomResult>;\n}\n\nexport type BarcodeDetectionOptions = {\n  /**\n   * Whether to show the highlight overlay for detected barcodes.\n   * Defaults to false.\n   */\n  showHighlight?: boolean;\n}\n\nexport type ObjectDetectionOptions = {\n  /**\n   * Whether to show the highlight overlay for detected business cards.\n   * Defaults to true.\n   */\n  showHighlight?: boolean,\n  /**\n   * Minimum interval in seconds between consecutive 'rectangleDetected' events.\n   * After an event is emitted, no new events will be emitted until this interval passes.\n   * Set to 0 to emit events as soon as stability is detected.\n   * Defaults to 0 (no throttling beyond initial stability check).\n   */\n  emitIntervalSeconds?: number\n}\n\nexport type StartOptions = {\n  /**\n   * Barcode formats to detect when barcodeDetection is enabled.\n   */\n  formats?: BarcodeFormat[];\n  /**\n   * Camera direction to use. Defaults to 'BACK'.\n   */\n  cameraDirection?: 'BACK' | 'FRONT';\n  /**\n   * Enable barcode detection on start. Defaults to false.\n   * When enabled, the camera will automatically detect barcodes and emit 'barcodeScanned' events.\n   */\n  barcodeDetection?: boolean;\n  /**\n   * Whether to show the highlight overlay for detected barcodes. Defaults to false.\n   * Only applies when barcodeDetection is true.\n   */\n  barcodeHighlight?: boolean;\n  /**\n   * Enable object detection (business card) on start. Defaults to false.\n   * When enabled, the camera will automatically detect business cards and emit 'rectangleDetected' events.\n   */\n  objectDetection?: boolean;\n  /**\n   * Whether to show the highlight overlay for detected business cards. Defaults to true.\n   * Only applies when objectDetection is true.\n   */\n  objectHighlight?: boolean;\n  /**\n   * Minimum interval in seconds between consecutive 'rectangleDetected' events.\n   * Only applies when objectDetection is true.\n   * Defaults to 0 (no throttling beyond initial stability check).\n   */\n  rectangleEmitIntervalSeconds?: number;\n  /**\n   * Optional regex pattern to filter scanned barcodes.\n   * If provided, only barcodes matching this pattern will be reported.\n   */\n  regex?: string;\n  /**\n   * Optional regex flags (e.g., 'i' for case-insensitive, 'm' for multiline).\n   */\n  regexFlags?: string;\n  /**\n   * Duration in seconds to pause rectangle detection after a barcode is successfully scanned.\n   * When both barcode and object detection are enabled, this gives barcode scanning priority\n   * by temporarily suppressing rectangle detection after a barcode is emitted.\n   * Defaults to 0 (no throttle, both detections run simultaneously).\n   */\n  detectionThrottleSeconds?: number;\n};\n\nexport type BarcodeScannedEvent = { scannedCode: string; format: string };\n\n\nexport type RectangleDetectedEvent = {\n  detected: true\n};\n\nexport type CapturePhotoOptions = {\n  /**\n   * The desired quality of the captured image, expressed as a value between 0.0 (lowest quality, smallest file size)\n   * and 1.0 (highest quality, largest file size). Defaults to 1.0.\n   * This parameter directly influences the compression level of the resulting JPEG image.\n   */\n  qualityRatio?: number;\n};\n\nexport type PermissionsResult = { camera: 'prompt' | 'denied' | 'granted' };\n\nexport type CapturePhotoResult = { imageBase64: string };\n\nexport type FlashResult = { enabled: boolean };\n\nexport type ZoomOptions = {\n  /**\n   * The zoom level to set. Must be 1, 2, or 3.\n   * - 1 = 1.0x (no zoom)\n   * - 2 = 2.0x\n   * - 3 = 3.0x\n   */\n  level: 1 | 2 | 3;\n};\n\nexport type ZoomResult = { level: number };\n\nexport enum BarcodeFormat {\n  Aztec = 'AZTEC',\n  Code39 = 'CODE_39',\n  Code93 = 'CODE_93',\n  Code128 = 'CODE_128',\n  DataMatrix = 'DATA_MATRIX',\n  Ean8 = 'EAN_8',\n  Ean13 = 'EAN_13',\n  Itf14 = 'ITF14',\n  Pdf417 = 'PDF_417',\n  QrCode = 'QR_CODE',\n  UpcE = 'UPC_E',\n}\n\ndeclare global {\n  interface PluginRegistry {\n    QRScanner: CapacitorScannerPlugin;\n  }\n}"]}

package/ios/Sources/CapacitorScannerPlugin/CapacitorScannerPlugin.swift

@@ -51,6 +51,10 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 	private var lastBarcodeDetectionTime: Date?
 	private let barcodeVisibilityTimeout: TimeInterval = 1.0
 
+	// Detection throttle: pause rectangle detection after a successful barcode scan
+	private var detectionThrottleSeconds: TimeInterval = 0
+	private var lastSuccessfulBarcodeScanTime: Date?
+
  // Detection state (controls what detection runs)
  private var enabledDetectionTypes: Set<String> = []
  // Highlight state (controls what overlay is shown)
@@ -129,10 +133,8 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 	private func setupOverlayView() {
 		guard let cameraView = self.cameraView,
 		      let previewLayer = self.previewLayer else {
-			print("[CapacitorScanner] setupOverlayView: cameraView or previewLayer is nil")
 			return
 		}
-		print("[CapacitorScanner] setupOverlayView: setting up overlay")
 
 		// Remove existing overlay if present
 		self.overlayView?.removeFromSuperview()
@@ -466,6 +468,10 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 				self.rectangleDetector?.setEmitInterval(emitInterval)
 			}
 
+			// Read detection throttle
+			self.detectionThrottleSeconds = call.getDouble("detectionThrottleSeconds") ?? 0
+			self.lastSuccessfulBarcodeScanTime = nil
+
 			// Handle Regex Filter
 			if let pattern = call.getString("regex") {
 				let flags = call.getString("regexFlags") ?? ""
@@ -598,6 +604,8 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 		self.enabledDetectionTypes.removeAll()
 		self.enabledHighlightTypes.removeAll()
 		self.lastBarcodeDetectionTime = nil
+		self.lastSuccessfulBarcodeScanTime = nil
+		self.detectionThrottleSeconds = 0
 		self.removeOrientationChangeObserver()
 	}
 
@@ -813,6 +821,9 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 						"format": CapacitorScannerHelpers.convertBarcodeScannerFormatToString(bestObservation.symbology),
 					])
 
+					// Record successful scan time for detection throttle
+					self.lastSuccessfulBarcodeScanTime = Date()
+
 					// Reset votes after successful scan
 					self.scannedCodesVotes.clear()
 				}
@@ -825,7 +836,6 @@ public class CapacitorScannerPlugin: CAPPlugin, CAPBridgedPlugin, AVCaptureMetad
 	// MARK: - RectangleDetectorDelegate
 
 	func rectangleDetector(_ detector: RectangleDetector, didDetect corners: RectangleCorners) {
-		print("[CapacitorScanner] rectangleDetector delegate called - emitting rectangleDetected event")
 		self.notifyListeners("rectangleDetected", data: [
 			"topLeft": ["x": corners.topLeft.x, "y": corners.topLeft.y],
 			"topRight": ["x": corners.topRight.x, "y": corners.topRight.y],
@@ -1027,9 +1037,15 @@ extension CapacitorScannerPlugin: AVCaptureVideoDataOutputSampleBufferDelegate {
 			requests.append(self.barcodeDetectionRequest)
 		}
 
-		if self.enabledDetectionTypes.contains("businessCard"),
+		let isRectangleThrottled: Bool = {
+			guard self.detectionThrottleSeconds > 0,
+			      let lastScan = self.lastSuccessfulBarcodeScanTime else { return false }
+			return Date().timeIntervalSince(lastScan) < self.detectionThrottleSeconds
+		}()
+
+		if !isRectangleThrottled,
+		   self.enabledDetectionTypes.contains("businessCard"),
 		   let detector = self.rectangleDetector {
-			print("[CapacitorScanner] Processing frame for businessCard detection")
 			detector.updatePixelBuffer(pixelBuffer)
 			requests.append(detector.visionRequest)
 		}
@@ -1041,15 +1057,19 @@ extension CapacitorScannerPlugin: AVCaptureVideoDataOutputSampleBufferDelegate {
 			print("Failed to perform Vision request: \(error)")
 		}
 
-		// Check overlay timeouts
-		DispatchQueue.main.async {
-			let now = Date()
-			if let t = self.lastBarcodeDetectionTime, now.timeIntervalSince(t) > self.barcodeVisibilityTimeout {
-				self.barcodeLayer?.removeFromSuperlayer()
-				self.barcodeLayer = nil
-				self.prevBarcodeRect = nil
+		// Check overlay timeouts only when there's something to clean up
+		let needsBarcodeCheck = self.barcodeLayer != nil
+		let needsRectCheck = self.rectangleDetector != nil
+		if needsBarcodeCheck || needsRectCheck {
+			DispatchQueue.main.async {
+				let now = Date()
+				if let t = self.lastBarcodeDetectionTime, now.timeIntervalSince(t) > self.barcodeVisibilityTimeout {
+					self.barcodeLayer?.removeFromSuperlayer()
+					self.barcodeLayer = nil
+					self.prevBarcodeRect = nil
+				}
+				self.rectangleDetector?.checkTimeout()
 			}
-			self.rectangleDetector?.checkTimeout()
 		}
 	}
 }

package/ios/Sources/CapacitorScannerPlugin/RectangleDetector.swift

@@ -41,6 +41,7 @@ class RectangleDetector {
     private(set) var lastDetectedRectangle: DetectedRectangle?
     private(set) var lastDetectionTime: Date?
     private var currentPixelBuffer: CVPixelBuffer?
+    private let ciContext = CIContext(options: nil)
 
     // Stability tracking
     private var previousCorners: RectangleCorners?
@@ -73,7 +74,6 @@ class RectangleDetector {
 
     /// Configure the detector with overlay support
     func configure(overlayLayer: CALayer, previewLayer: AVCaptureVideoPreviewLayer) {
-        print("[RectangleDetector] configure called, isHighlightEnabled: \(isHighlightEnabled)")
         self.overlayParentLayer = overlayLayer
         self.previewLayer = previewLayer
 
@@ -132,41 +132,31 @@ class RectangleDetector {
 
     private func setupSmoother() {
         guard let parentLayer = overlayParentLayer, smoother == nil else {
-            print("[RectangleDetector] setupSmoother: skipped (parentLayer nil: \(overlayParentLayer == nil), smoother exists: \(smoother != nil))")
             return
         }
-        print("[RectangleDetector] setupSmoother: creating smoother")
         smoother = RectangleSmoother()
         smoother?.setup(in: parentLayer)
     }
 
     private func processDetection(_ request: VNRequest, error: Error?) {
-        print("[RectangleDetector] processDetection called")
-
         if let error = error {
-            print("[RectangleDetector] Detection error: \(error)")
             // Don't reset stability here - let checkTimeout() handle the grace period
             return
         }
 
         guard let observations = request.results as? [VNRectangleObservation] else {
-            print("[RectangleDetector] No observations in results")
             // Don't reset stability here - let checkTimeout() handle the grace period
             return
         }
 
         // Find the rectangle with highest confidence
         guard let bestCandidate = observations.max(by: { $0.confidence < $1.confidence }) else {
-            print("[RectangleDetector] No rectangles found (empty observations)")
             // Don't reset stability here - let checkTimeout() handle the grace period
             return
         }
 
-        print("[RectangleDetector] Found rectangle with confidence: \(bestCandidate.confidence)")
-
         // Check if all corners are inside the screen with buffer
         guard isInsideScreen(bestCandidate) else {
-            print("[RectangleDetector] Rectangle outside screen bounds")
             // Don't reset stability here - let checkTimeout() handle the grace period
             return
         }
@@ -204,11 +194,8 @@ class RectangleDetector {
     // MARK: - Stability Tracking
 
     private func updateStability(with corners: RectangleCorners) {
-        print("[RectangleDetector] updateStability - hasPrevious: \(previousCorners != nil), timerActive: \(stabilityStartTime != nil)")
-
         // First detection - just store corners, don't start timer yet
         guard let previous = previousCorners else {
-            print("[RectangleDetector] First detection - storing corners, no timer yet")
             previousCorners = corners
             stabilityStartTime = nil
             return
@@ -219,11 +206,9 @@ class RectangleDetector {
 
         // Check how much the rectangle moved
         let movement = maxCornerMovement(from: previous, to: corners)
-        print("[RectangleDetector] Movement: \(movement), threshold: \(stabilityThreshold)")
 
         // Too much movement - reset timer completely
         if movement >= stabilityThreshold {
-            print("[RectangleDetector] Too much movement (\(movement) >= \(stabilityThreshold)) - resetting timer")
             stabilityStartTime = nil
             return
         }
@@ -234,13 +219,11 @@ class RectangleDetector {
         if stabilityStartTime == nil {
             // Start the stability timer - but DON'T check duration yet
             stabilityStartTime = now
-            print("[RectangleDetector] Stability timer STARTED")
             return
         }
 
         // Timer was already running - check elapsed time
         let elapsed = now.timeIntervalSince(stabilityStartTime!)
-        print("[RectangleDetector] Stability elapsed: \(String(format: "%.2f", elapsed))s / \(stabilityDuration)s required")
 
         // Need to be stable for the required duration before any emission
         guard elapsed >= stabilityDuration else { return }
@@ -250,13 +233,11 @@ class RectangleDetector {
         if let lastEmit = lastEmitTime {
             let timeSinceLastEmit = now.timeIntervalSince(lastEmit)
             canEmit = timeSinceLastEmit >= emitIntervalSeconds
-            print("[RectangleDetector] Time since last emit: \(String(format: "%.2f", timeSinceLastEmit))s, interval: \(emitIntervalSeconds)s")
         } else {
             canEmit = true
         }
 
         if canEmit {
-            print("[RectangleDetector] STABLE for \(elapsed)s - emitting event")
             lastEmitTime = now
             delegate?.rectangleDetector(self, didDetect: corners)
         }
@@ -264,9 +245,6 @@ class RectangleDetector {
 
     /// Called when no valid rectangle is detected - resets all tracking state
     private func handleNoDetection() {
-        if stabilityStartTime != nil {
-            print("[RectangleDetector] No detection - resetting stability timer")
-        }
         stabilityStartTime = nil
         previousCorners = nil
     }
@@ -311,9 +289,8 @@ class RectangleDetector {
         }
 
         let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
-        let context = CIContext(options: nil)
 
-        guard let cgImage = context.createCGImage(ciImage, from: ciImage.extent) else {
+        guard let cgImage = ciContext.createCGImage(ciImage, from: ciImage.extent) else {
             lastDetectedRectangle = DetectedRectangle(observation: observation, snapshot: nil)
             return
         }

package/package.json

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