react-native-rectangle-doc-scanner 11.2.0 → 12.0.0

package/android/build.gradle

@@ -86,6 +86,7 @@ dependencies {
 
     // ML Kit object detection for live rectangle hints (Camera2 mode)
     implementation 'com.google.mlkit:object-detection:17.0.1'
+    implementation 'com.google.android.gms:play-services-mlkit-document-scanner:16.0.0-beta1'
 
     if (hasVisionCamera) {
         // VisionCamera mode - include VisionCamera dependency

package/android/src/camera2/kotlin/com/reactnativerectangledocscanner/CameraController.kt

@@ -280,10 +280,11 @@ class CameraController(
         }
 
         // Use the same rotation logic as updateTextureViewTransform
+        val tabletUpsideDownFix = if (sensorOrientation == 0 && displayRotationDegrees == 90) 180 else 0
         val effectiveRotation = if (sensorOrientation == 0) {
-            displayRotationDegrees  // Tablet: use display rotation (90°)
+            (displayRotationDegrees + tabletUpsideDownFix) % 360
         } else {
-            sensorOrientation       // Phone: use sensor orientation (90°)
+            sensorOrientation
         }
 
         Log.d(TAG, "[ANALYZE] Sensor: $sensorOrientation°, Display: $displayRotationDegrees°, Effective: $effectiveRotation°")

package/android/src/camera2/kotlin/com/reactnativerectangledocscanner/DocumentScannerView.kt

@@ -49,6 +49,7 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     var brightness: Float = 0f
     var contrast: Float = 1f
     var saturation: Float = 1f
+    var useExternalScanner: Boolean = false
 
     // State
     private var stableCounter = 0
@@ -142,6 +143,10 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     }
 
     private fun initializeCameraWhenReady() {
+        if (useExternalScanner) {
+            Log.d(TAG, "[INIT] External scanner enabled - skipping camera startup")
+            return
+        }
         // If view is already laid out, start camera immediately
         if (width > 0 && height > 0) {
             Log.d(TAG, "[INIT] View already laid out, starting camera immediately")
@@ -175,6 +180,21 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         }
     }
 
+    fun setUseExternalScanner(enabled: Boolean) {
+        if (useExternalScanner == enabled) {
+            return
+        }
+        useExternalScanner = enabled
+        Log.d(TAG, "[SET] useExternalScanner: $enabled")
+        if (enabled) {
+            stopCamera()
+            overlayView.setRectangle(null, overlayColor)
+        } else if (width > 0 && height > 0 && cameraController == null) {
+            setupCamera()
+            startCamera()
+        }
+    }
+
     private fun setupCamera() {
         try {
             Log.d(TAG, "[SETUP] Creating CameraController...")

package/android/src/camera2/kotlin/com/reactnativerectangledocscanner/DocumentScannerViewManager.kt

@@ -94,6 +94,11 @@ class DocumentScannerViewManager : SimpleViewManager<DocumentScannerView>() {
         view.saturation = saturation
     }
 
+    @ReactProp(name = "useExternalScanner")
+    fun setUseExternalScanner(view: DocumentScannerView, enabled: Boolean) {
+        view.setUseExternalScanner(enabled)
+    }
+
     override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
         return MapBuilder.of(
             "onPictureTaken",

package/android/src/common/kotlin/com/reactnativerectangledocscanner/DocumentDetector.kt

@@ -259,7 +259,7 @@ class DocumentDetector {
 
                     var largestRectangle: Rectangle? = null
                     var bestScore = 0.0
-                    val minArea = max(450.0, (srcMat.rows() * srcMat.cols()) * 0.0007)
+                    val minArea = max(350.0, (srcMat.rows() * srcMat.cols()) * 0.0005)
 
                     debugStats.contours = contours.size
 
@@ -289,7 +289,7 @@ class DocumentDetector {
                             val rect = Imgproc.minAreaRect(MatOfPoint2f(*points))
                             val rectArea = rect.size.area()
                             val rectangularity = if (rectArea > 1.0) contourArea / rectArea else 0.0
-                            if (rectangularity >= 0.6 && isCandidateValid(ordered, srcMat)) {
+                            if (rectangularity >= 0.5 && isCandidateValid(ordered, srcMat)) {
                                 debugStats.candidates += 1
                                 val score = contourArea * rectangularity
                                 if (score > bestScore) {
@@ -313,7 +313,7 @@ class DocumentDetector {
                             val rectArea = rotated.size.area()
                             if (rectArea > 1.0) {
                                 val rectangularity = contourArea / rectArea
-                                if (rectangularity >= 0.6) {
+                                if (rectangularity >= 0.5) {
                                     debugStats.candidates += 1
                                     val boxPoints = Array(4) { Point() }
                                     rotated.points(boxPoints)
@@ -497,16 +497,16 @@ class DocumentDetector {
             val rectHeight = max(leftEdgeLength, rightEdgeLength)
             val rectArea = rectWidth * rectHeight
 
-            // Check if rectangle is too small (less than 15% of view area)
-            // or too large (more than 85% - likely detecting screen instead of document)
+            // Check if rectangle is too small (less than 6% of view area)
+            // or too large (more than 95% - likely detecting screen instead of document)
             val areaRatio = rectArea / viewArea
-            if (areaRatio < 0.15) {
+            if (areaRatio < 0.06) {
                 if (BuildConfig.DEBUG) {
                     Log.d(TAG, "[QUALITY] TOO_FAR (small): area=${String.format("%.1f", rectArea)}, ratio=${String.format("%.2f", areaRatio)}")
                 }
                 return RectangleQuality.TOO_FAR
             }
-            if (areaRatio > 0.85) {
+            if (areaRatio > 0.95) {
                 if (BuildConfig.DEBUG) {
                     Log.d(TAG, "[QUALITY] TOO_FAR (large): area=${String.format("%.1f", rectArea)}, ratio=${String.format("%.2f", areaRatio)} - likely detecting screen")
                 }

package/android/src/main/kotlin/com/reactnativerectangledocscanner/DocumentScannerModule.kt

@@ -1,24 +1,49 @@
 package com.reactnativerectangledocscanner
 
+import android.app.Activity
+import android.content.Intent
 import android.graphics.BitmapFactory
+import android.net.Uri
 import android.util.Log
 import com.facebook.react.bridge.*
 import com.facebook.react.uimanager.UIManagerModule
+import com.google.mlkit.vision.documentscanner.GmsDocumentScannerOptions
+import com.google.mlkit.vision.documentscanner.GmsDocumentScanning
+import com.google.mlkit.vision.documentscanner.GmsDocumentScanningResult
 import kotlinx.coroutines.*
 import org.opencv.core.Point
+import java.io.File
+import java.io.FileOutputStream
 
 class DocumentScannerModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
+    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
 
     private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
 
     companion object {
         const val NAME = "RNPdfScannerManager"
         private const val TAG = "DocumentScannerModule"
+        private const val EXTERNAL_SCAN_REQUEST = 9401
     }
 
     override fun getName() = NAME
 
+    private data class PendingScanConfig(
+        val useBase64: Boolean,
+        val saveInAppDocument: Boolean,
+        val quality: Float,
+        val brightness: Float,
+        val contrast: Float,
+        val saturation: Float
+    )
+
+    private var pendingScanPromise: Promise? = null
+    private var pendingScanConfig: PendingScanConfig? = null
+
+    init {
+        reactContext.addActivityEventListener(this)
+    }
+
     /**
      * Capture image from the document scanner view
      * Matches iOS signature: capture(reactTag, resolver, rejecter)
@@ -46,9 +71,13 @@ class DocumentScannerModule(reactContext: ReactApplicationContext) :
                     if (view is DocumentScannerView) {
                         Log.d(TAG, "Found DocumentScannerView, triggering capture with promise")
 
-                        // Pass promise to view so it can be resolved when capture completes
-                        // This matches iOS behavior where promise is resolved with actual image data
-                        view.captureWithPromise(promise)
+                        if (view.useExternalScanner) {
+                            startExternalScan(view, promise)
+                        } else {
+                            // Pass promise to view so it can be resolved when capture completes
+                            // This matches iOS behavior where promise is resolved with actual image data
+                            view.captureWithPromise(promise)
+                        }
                     } else {
                         Log.e(TAG, "View with tag $tag is not DocumentScannerView: ${view?.javaClass?.simpleName}")
                         promise.reject("INVALID_VIEW", "View is not a DocumentScannerView")
@@ -64,6 +93,160 @@ class DocumentScannerModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    private fun startExternalScan(view: DocumentScannerView, promise: Promise) {
+        if (pendingScanPromise != null) {
+            promise.reject("SCAN_IN_PROGRESS", "Another scan is already in progress")
+            return
+        }
+
+        val activity = currentActivity ?: run {
+            promise.reject("NO_ACTIVITY", "Activity not available")
+            return
+        }
+
+        val options = GmsDocumentScannerOptions.Builder()
+            .setScannerMode(GmsDocumentScannerOptions.SCANNER_MODE_FULL)
+            .setGalleryImportAllowed(true)
+            .setPageLimit(1)
+            .setResultFormats(GmsDocumentScannerOptions.RESULT_FORMAT_JPEG)
+            .build()
+
+        val scanner = GmsDocumentScanning.getClient(options)
+
+        pendingScanPromise = promise
+        pendingScanConfig = PendingScanConfig(
+            useBase64 = view.useBase64,
+            saveInAppDocument = view.saveInAppDocument,
+            quality = view.quality,
+            brightness = view.brightness,
+            contrast = view.contrast,
+            saturation = view.saturation
+        )
+
+        scanner.getStartScanIntent(activity)
+            .addOnSuccessListener { intentSender ->
+                try {
+                    activity.startIntentSenderForResult(
+                        intentSender,
+                        EXTERNAL_SCAN_REQUEST,
+                        null,
+                        0,
+                        0,
+                        0
+                    )
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to launch ML Kit scanner", e)
+                    cleanupPendingScan()
+                    promise.reject("SCAN_LAUNCH_FAILED", "Failed to launch scanner: ${e.message}", e)
+                }
+            }
+            .addOnFailureListener { e ->
+                Log.e(TAG, "Failed to get ML Kit scan intent", e)
+                cleanupPendingScan()
+                promise.reject("SCAN_INTENT_FAILED", "Failed to start scanner: ${e.message}", e)
+            }
+    }
+
+    override fun onActivityResult(activity: Activity?, requestCode: Int, resultCode: Int, data: Intent?) {
+        if (requestCode != EXTERNAL_SCAN_REQUEST) {
+            return
+        }
+
+        val promise = pendingScanPromise ?: return
+        val config = pendingScanConfig
+        cleanupPendingScan()
+
+        if (resultCode != Activity.RESULT_OK || data == null) {
+            promise.reject("SCAN_CANCELLED", "Scan cancelled or failed")
+            return
+        }
+
+        val result = GmsDocumentScanningResult.fromActivityResultIntent(data)
+        val page = result?.pages?.firstOrNull()
+        val imageUri = page?.imageUri
+
+        if (imageUri == null || config == null) {
+            promise.reject("SCAN_NO_RESULT", "No scanned image returned")
+            return
+        }
+
+        scope.launch {
+            try {
+                val outputDir = if (config.saveInAppDocument) {
+                    reactApplicationContext.filesDir
+                } else {
+                    reactApplicationContext.cacheDir
+                }
+                val timestamp = System.currentTimeMillis()
+                val initialPath = copyUriToFile(imageUri, outputDir, "doc_scan_initial_$timestamp.jpg")
+
+                val processed = withContext(Dispatchers.IO) {
+                    ImageProcessor.processImage(
+                        imagePath = initialPath,
+                        rectangle = null,
+                        brightness = config.brightness,
+                        contrast = config.contrast,
+                        saturation = config.saturation,
+                        shouldCrop = false
+                    )
+                }
+
+                val resultMap = Arguments.createMap()
+                if (config.useBase64) {
+                    val croppedBase64 = ImageProcessor.bitmapToBase64(processed.croppedImage, config.quality)
+                    val initialBase64 = ImageProcessor.bitmapToBase64(processed.initialImage, config.quality)
+                    resultMap.putString("croppedImage", croppedBase64)
+                    resultMap.putString("initialImage", initialBase64)
+                } else {
+                    val croppedPath = ImageProcessor.saveBitmapToFile(
+                        processed.croppedImage,
+                        outputDir,
+                        "doc_scan_cropped_$timestamp.jpg",
+                        config.quality
+                    )
+                    resultMap.putString("croppedImage", croppedPath)
+                    resultMap.putString("initialImage", initialPath)
+                }
+
+                resultMap.putMap("rectangleCoordinates", null)
+                resultMap.putInt("width", processed.croppedImage.width)
+                resultMap.putInt("height", processed.croppedImage.height)
+
+                // Cleanup bitmaps to avoid leaks.
+                if (processed.croppedImage !== processed.initialImage) {
+                    processed.croppedImage.recycle()
+                    processed.initialImage.recycle()
+                } else {
+                    processed.croppedImage.recycle()
+                }
+
+                promise.resolve(resultMap)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to process scan result", e)
+                promise.reject("SCAN_PROCESS_FAILED", "Failed to process scan result: ${e.message}", e)
+            }
+        }
+    }
+
+    override fun onNewIntent(intent: Intent?) {
+        // No-op
+    }
+
+    private fun copyUriToFile(uri: Uri, outputDir: File, fileName: String): String {
+        val outputFile = File(outputDir, fileName)
+        reactApplicationContext.contentResolver.openInputStream(uri)?.use { input ->
+            FileOutputStream(outputFile).use { output ->
+                input.copyTo(output)
+            }
+        } ?: throw IllegalStateException("Failed to open input stream for URI: $uri")
+        return outputFile.absolutePath
+    }
+
+    private fun cleanupPendingScan() {
+        pendingScanPromise = null
+        pendingScanConfig = null
+    }
+
     /**
      * Apply color controls to an image
      * Matches iOS: applyColorControls(imagePath, brightness, contrast, saturation, resolver, rejecter)

package/dist/DocScanner.js

@@ -715,14 +715,15 @@ const NativeScanner = (0, react_1.forwardRef)(({ onCapture, overlayColor = DEFAU
     const overlayIsActive = autoCapture ? isAutoCapturing : (detectedRectangle?.stableCounter ?? 0) > 0;
     const detectionThreshold = autoCapture ? minStableFrames : 99999;
     return (react_1.default.createElement(react_native_1.View, { style: styles.container },
-        react_1.default.createElement(react_native_document_scanner_1.default, { ref: scannerRef, style: styles.scanner, detectionCountBeforeCapture: detectionThreshold, overlayColor: overlayColor, enableTorch: enableTorch, quality: normalizedQuality, useBase64: useBase64, manualOnly: false, detectionConfig: detectionConfig, onPictureTaken: handlePictureTaken, onError: handleError, onRectangleDetect: handleRectangleDetect }),
+        react_1.default.createElement(react_native_document_scanner_1.default, { ref: scannerRef, style: styles.scanner, detectionCountBeforeCapture: detectionThreshold, overlayColor: overlayColor, enableTorch: enableTorch, quality: normalizedQuality, useBase64: useBase64, manualOnly: react_native_1.Platform.OS === 'android', detectionConfig: detectionConfig, useExternalScanner: react_native_1.Platform.OS === 'android', onPictureTaken: handlePictureTaken, onError: handleError, onRectangleDetect: handleRectangleDetect }),
         showGrid && overlayPolygon && (react_1.default.createElement(overlay_1.ScannerOverlay, { active: overlayIsActive, color: gridColor ?? overlayColor, lineWidth: gridLineWidth, polygon: overlayPolygon, clipRect: react_native_1.Platform.OS === 'android' ? null : (detectedRectangle?.previewViewport ?? null) })),
         showManualCaptureButton && (react_1.default.createElement(react_native_1.TouchableOpacity, { style: styles.button, onPress: handleManualCapture })),
         children));
 });
 exports.DocScanner = (0, react_1.forwardRef)((props, ref) => {
+    const useExternalScanner = react_native_1.Platform.OS === 'android';
     (0, react_1.useEffect)(() => {
-        if (react_native_1.Platform.OS !== 'android') {
+        if (react_native_1.Platform.OS !== 'android' || useExternalScanner) {
             return;
         }
         if (hasVisionCamera) {
@@ -735,6 +736,9 @@ exports.DocScanner = (0, react_1.forwardRef)((props, ref) => {
             });
         }
     }, []);
+    if (useExternalScanner) {
+        return react_1.default.createElement(NativeScanner, { ref: ref, ...props });
+    }
     if (hasVisionCamera) {
         return react_1.default.createElement(VisionCameraScanner, { ref: ref, ...props });
     }

package/dist/FullDocScanner.js

@@ -124,6 +124,7 @@ const normalizeCapturedDocument = (document) => {
     };
 };
 const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3170f3', gridColor, gridLineWidth, showGrid, strings, minStableFrames, onError, enableGallery = true, cropWidth = 1200, cropHeight = 1600, type, }) => {
+    const useExternalScanner = react_native_1.Platform.OS === 'android';
     const [processing, setProcessing] = (0, react_1.useState)(false);
     const [croppedImageData, setCroppedImageData] = (0, react_1.useState)(null);
     const [isGalleryOpen, setIsGalleryOpen] = (0, react_1.useState)(false);
@@ -143,6 +144,11 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
     const rectangleHintTimeoutRef = (0, react_1.useRef)(null);
     const captureReadyTimeoutRef = (0, react_1.useRef)(null);
     const isBusinessMode = type === 'business';
+    (0, react_1.useEffect)(() => {
+        if (useExternalScanner) {
+            setCaptureReady(true);
+        }
+    }, [useExternalScanner]);
     const resetScannerView = (0, react_1.useCallback)((options) => {
         setProcessing(false);
         setCroppedImageData(null);
@@ -388,7 +394,7 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             return;
         }
         console.log('[FullDocScanner] Starting manual capture, grid detected:', rectangleDetected);
-        const captureMode = rectangleDetected ? 'grid' : 'no-grid';
+        const captureMode = useExternalScanner ? 'grid' : (rectangleDetected ? 'grid' : 'no-grid');
         captureModeRef.current = captureMode;
         captureInProgressRef.current = true;
         // Add timeout to reset state if capture hangs
@@ -536,6 +542,9 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
         resetScannerView({ remount: true });
     }, [capturedPhotos.length, isBusinessMode, resetScannerView]);
     const handleRectangleDetect = (0, react_1.useCallback)((event) => {
+        if (useExternalScanner) {
+            return;
+        }
         const stableCounter = event.stableCounter ?? 0;
         const rectangleCoordinates = event.rectangleOnScreen ?? event.rectangleCoordinates;
         const hasRectangle = Boolean(rectangleCoordinates);
@@ -589,7 +598,7 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             }
             setRectangleDetected(false);
         }
-    }, [rectangleDetected]);
+    }, [rectangleDetected, useExternalScanner]);
     (0, react_1.useEffect)(() => () => {
         if (rectangleCaptureTimeoutRef.current) {
             clearTimeout(rectangleCaptureTimeoutRef.current);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-rectangle-doc-scanner",
-  "version": "11.2.0",
+  "version": "12.0.0",
   "description": "Native-backed document scanner for React Native with customizable overlays.",
   "license": "MIT",
   "main": "dist/index.js",

package/src/DocScanner.tsx

@@ -994,7 +994,7 @@ const NativeScanner = forwardRef<DocScannerHandle, Props>(
         : detectedRectangle?.rectangleOnScreen ?? detectedRectangle?.rectangleCoordinates ?? null;
     const overlayIsActive = autoCapture ? isAutoCapturing : (detectedRectangle?.stableCounter ?? 0) > 0;
 
-  const detectionThreshold = autoCapture ? minStableFrames : 99999;
+    const detectionThreshold = autoCapture ? minStableFrames : 99999;
 
   return (
       <View style={styles.container}>
@@ -1006,8 +1006,9 @@ const NativeScanner = forwardRef<DocScannerHandle, Props>(
           enableTorch={enableTorch}
           quality={normalizedQuality}
           useBase64={useBase64}
-          manualOnly={false}
+          manualOnly={Platform.OS === 'android'}
           detectionConfig={detectionConfig}
+          useExternalScanner={Platform.OS === 'android'}
           onPictureTaken={handlePictureTaken}
           onError={handleError}
           onRectangleDetect={handleRectangleDetect}
@@ -1031,8 +1032,10 @@ const NativeScanner = forwardRef<DocScannerHandle, Props>(
 );
 
 export const DocScanner = forwardRef<DocScannerHandle, Props>((props, ref) => {
+  const useExternalScanner = Platform.OS === 'android';
+
   useEffect(() => {
-    if (Platform.OS !== 'android') {
+    if (Platform.OS !== 'android' || useExternalScanner) {
       return;
     }
     if (hasVisionCamera) {
@@ -1045,6 +1048,10 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>((props, ref) => {
     }
   }, []);
 
+  if (useExternalScanner) {
+    return <NativeScanner ref={ref} {...props} />;
+  }
+
   if (hasVisionCamera) {
     return <VisionCameraScanner ref={ref} {...props} />;
   }

package/src/FullDocScanner.tsx

@@ -187,6 +187,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
   cropHeight = 1600,
   type,
 }) => {
+  const useExternalScanner = Platform.OS === 'android';
   const [processing, setProcessing] = useState(false);
   const [croppedImageData, setCroppedImageData] = useState<PreviewImageData | null>(null);
   const [isGalleryOpen, setIsGalleryOpen] = useState(false);
@@ -208,6 +209,12 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
 
   const isBusinessMode = type === 'business';
 
+  useEffect(() => {
+    if (useExternalScanner) {
+      setCaptureReady(true);
+    }
+  }, [useExternalScanner]);
+
   const resetScannerView = useCallback(
     (options?: { remount?: boolean }) => {
       setProcessing(false);
@@ -539,7 +546,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
 
     console.log('[FullDocScanner] Starting manual capture, grid detected:', rectangleDetected);
 
-    const captureMode = rectangleDetected ? 'grid' : 'no-grid';
+    const captureMode = useExternalScanner ? 'grid' : (rectangleDetected ? 'grid' : 'no-grid');
     captureModeRef.current = captureMode;
     captureInProgressRef.current = true;
 
@@ -729,6 +736,9 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
   }, [capturedPhotos.length, isBusinessMode, resetScannerView]);
 
   const handleRectangleDetect = useCallback((event: RectangleDetectEvent) => {
+    if (useExternalScanner) {
+      return;
+    }
     const stableCounter = event.stableCounter ?? 0;
     const rectangleCoordinates = event.rectangleOnScreen ?? event.rectangleCoordinates;
     const hasRectangle = Boolean(rectangleCoordinates);
@@ -787,7 +797,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
       }
       setRectangleDetected(false);
     }
-  }, [rectangleDetected]);
+  }, [rectangleDetected, useExternalScanner]);
 
   useEffect(
     () => () => {

package/src/external.d.ts

@@ -75,6 +75,7 @@ declare module 'react-native-document-scanner' {
       maxAnchorMisses?: number;
       maxCenterDelta?: number;
     };
+    useExternalScanner?: boolean;
     onPictureTaken?: (event: DocumentScannerResult) => void;
     onError?: (error: Error) => void;
     onRectangleDetect?: (event: RectangleEventPayload) => void;

package/vendor/react-native-document-scanner/index.d.ts

@@ -46,6 +46,7 @@ export interface DocumentScannerProps {
     maxAnchorMisses?: number;
     maxCenterDelta?: number;
   };
+  useExternalScanner?: boolean;
   onPictureTaken?: (event: DocumentScannerResult) => void;
   onError?: (error: Error) => void;
   onRectangleDetect?: (event: RectangleEventPayload) => void;