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

package/android/build.gradle

@@ -86,7 +86,6 @@ 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

@@ -123,6 +123,7 @@ class CameraController(
         Log.d(TAG, "[CAMERAX] Setting target rotation to ROTATION_0 (portrait-only app)")
 
         preview = Preview.Builder()
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Force portrait
             .build()
             .also { previewUseCase ->
@@ -185,7 +186,8 @@ class CameraController(
         // ImageAnalysis UseCase for document detection
         imageAnalyzer = ImageAnalysis.Builder()
             .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
-            .setTargetResolution(android.util.Size(1920, 1440))  // Higher resolution for better small-edge detection
+            // Match preview aspect ratio to avoid square analysis frames on some devices.
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Match preview rotation
             .build()
             .also {
@@ -201,6 +203,7 @@ class CameraController(
         // ImageCapture UseCase
         imageCapture = ImageCapture.Builder()
             .setCaptureMode(ImageCapture.CAPTURE_MODE_MAXIMIZE_QUALITY)
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
             .setTargetRotation(targetRotation)  // Match preview rotation
             .build()
 
@@ -265,10 +268,11 @@ class CameraController(
             return
         }
 
-        val rotationDegrees = imageProxy.imageInfo.rotationDegrees
         val imageWidth = imageProxy.width
         val imageHeight = imageProxy.height
 
+        val rotationDegrees = imageProxy.imageInfo.rotationDegrees
+
         // Calculate rotation using the same logic as TextureView transform
         val sensorOrientation = getCameraSensorOrientation()
         val displayRotationDegrees = when (textureView.display?.rotation ?: Surface.ROTATION_0) {
@@ -281,16 +285,16 @@ 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 + tabletUpsideDownFix) % 360
-        } else {
-            sensorOrientation
-        }
+        val effectiveRotation = (displayRotationDegrees + tabletUpsideDownFix) % 360
 
-        Log.d(TAG, "[ANALYZE] Sensor: $sensorOrientation°, Display: $displayRotationDegrees°, Effective: $effectiveRotation°")
+        Log.d(
+            TAG,
+            "[ANALYZE] Sensor: $sensorOrientation°, Display: $displayRotationDegrees°, " +
+                "ImageProxy: $rotationDegrees°, Effective: $effectiveRotation°"
+        )
 
-        // Try ML Kit first
-        val inputImage = InputImage.fromMediaImage(mediaImage, rotationDegrees)
+        // Try ML Kit first (use the same rotation as preview/OpenCV)
+        val inputImage = InputImage.fromMediaImage(mediaImage, effectiveRotation)
 
         objectDetector.process(inputImage)
             .addOnSuccessListener { objects ->
@@ -486,32 +490,11 @@ class CameraController(
 
         if (viewWidth <= 0 || viewHeight <= 0) return null
 
-        // The image coordinates are in camera sensor space. We need to transform them
-        // to match how the TextureView displays the image (after rotation/scaling).
-        val sensorOrientation = getCameraSensorOrientation()
-        val displayRotationDegrees = when (textureView.display?.rotation ?: Surface.ROTATION_0) {
-            Surface.ROTATION_0 -> 0
-            Surface.ROTATION_90 -> 90
-            Surface.ROTATION_180 -> 180
-            Surface.ROTATION_270 -> 270
-            else -> 0
-        }
-
-        fun rotatePoint(point: org.opencv.core.Point): org.opencv.core.Point {
-            return if (sensorOrientation == 90) {
-                org.opencv.core.Point(
-                    point.y,
-                    imageWidth - point.x
-                )
-            } else {
-                point
-            }
-        }
-
-        val finalWidth = if (sensorOrientation == 90) imageHeight else imageWidth
-        val finalHeight = if (sensorOrientation == 90) imageWidth else imageHeight
+        // Rectangle coordinates are already in the rotated image space (effective rotation applied).
+        val finalWidth = imageWidth
+        val finalHeight = imageHeight
 
-        // Then apply fit-center scaling
+        // Apply fit-center scaling to match TextureView display.
         val scaleX = viewWidth / finalWidth.toFloat()
         val scaleY = viewHeight / finalHeight.toFloat()
         val scale = scaleX.coerceAtMost(scaleY)
@@ -522,10 +505,9 @@ class CameraController(
         val offsetY = (viewHeight - scaledHeight) / 2f
 
         fun transformPoint(point: org.opencv.core.Point): org.opencv.core.Point {
-            val rotated = rotatePoint(point)
             return org.opencv.core.Point(
-                rotated.x * scale + offsetX,
-                rotated.y * scale + offsetY
+                point.x * scale + offsetX,
+                point.y * scale + offsetY
             )
         }
 
@@ -536,10 +518,9 @@ class CameraController(
             transformPoint(rectangle.bottomRight)
         )
 
-        Log.d(TAG, "[MAPPING] Sensor: ${sensorOrientation}°, Image: ${imageWidth}x${imageHeight} → Final: ${finalWidth}x${finalHeight}")
+        Log.d(TAG, "[MAPPING] Image: ${imageWidth}x${imageHeight} → Final: ${finalWidth}x${finalHeight}")
         Log.d(TAG, "[MAPPING] View: ${viewWidth.toInt()}x${viewHeight.toInt()}, Scale: $scale, Offset: ($offsetX, $offsetY)")
         Log.d(TAG, "[MAPPING] TL: (${rectangle.topLeft.x}, ${rectangle.topLeft.y}) → " +
-            "Rotated: (${rotatePoint(rectangle.topLeft).x}, ${rotatePoint(rectangle.topLeft).y}) → " +
             "Final: (${result.topLeft.x}, ${result.topLeft.y})")
 
         return result

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

@@ -49,7 +49,6 @@ 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
@@ -61,12 +60,14 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     private var lastDetectedImageHeight = 0
     private var lastRectangleOnScreen: Rectangle? = null
     private var lastSmoothedRectangleOnScreen: Rectangle? = null
+    private val iouHistory = ArrayDeque<Rectangle>()
 
     // Coroutine scope for async operations
     private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
 
     companion object {
         private const val TAG = "DocumentScannerView"
+        private const val PREVIEW_ASPECT_RATIO = 3f / 4f // width:height (matches 3:4)
     }
 
     override val lifecycle: Lifecycle
@@ -111,6 +112,9 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         addView(overlayView, 1)  // Add at index 1 (front)
         Log.d(TAG, "[INIT] OverlayView added, childCount: $childCount")
 
+        // Match camera UI look with letterboxing when preview doesn't fill the view.
+        setBackgroundColor(android.graphics.Color.BLACK)
+
         Log.d(TAG, "╔════════════════════════════════════════╗")
         Log.d(TAG, "║  DocumentScannerView INIT COMPLETE     ║")
         Log.d(TAG, "╚════════════════════════════════════════╝")
@@ -137,16 +141,36 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
         super.onLayout(changed, left, top, right, bottom)
         if (changed) {
+            layoutPreviewAndOverlay(right - left, bottom - top)
             Log.d(TAG, "[LAYOUT] View size: ${right - left}x${bottom - top}, PreviewView: ${previewView.width}x${previewView.height}")
             cameraController?.refreshTransform()
         }
     }
 
-    private fun initializeCameraWhenReady() {
-        if (useExternalScanner) {
-            Log.d(TAG, "[INIT] External scanner enabled - skipping camera startup")
-            return
+    private fun layoutPreviewAndOverlay(viewWidth: Int, viewHeight: Int) {
+        if (viewWidth <= 0 || viewHeight <= 0) return
+
+        val targetWidth: Int
+        val targetHeight: Int
+        val aspectHeight = (viewWidth / PREVIEW_ASPECT_RATIO).toInt()
+        if (aspectHeight <= viewHeight) {
+            targetWidth = viewWidth
+            targetHeight = aspectHeight
+        } else {
+            targetWidth = (viewHeight * PREVIEW_ASPECT_RATIO).toInt()
+            targetHeight = viewHeight
         }
+
+        val left = (viewWidth - targetWidth) / 2
+        val top = if (targetHeight < viewHeight) 0 else (viewHeight - targetHeight) / 2
+        val right = left + targetWidth
+        val bottom = top + targetHeight
+
+        previewView.layout(left, top, right, bottom)
+        overlayView.layout(left, top, right, bottom)
+    }
+
+    private fun initializeCameraWhenReady() {
         // 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")
@@ -180,20 +204,6 @@ 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 {
@@ -231,17 +241,26 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
             lastDetectedImageHeight = imageHeight
         }
 
-        val rectangleOnScreen = if (rectangle != null && width > 0 && height > 0) {
+        val previewWidth = previewView.width
+        val previewHeight = previewView.height
+
+        val rectangleOnScreen = if (rectangle != null && previewWidth > 0 && previewHeight > 0) {
             cameraController?.mapRectangleToView(rectangle, imageWidth, imageHeight)
-                ?: DocumentDetector.transformRectangleToViewCoordinates(rectangle, imageWidth, imageHeight, width, height)
+                ?: DocumentDetector.transformRectangleToViewCoordinates(
+                    rectangle,
+                    imageWidth,
+                    imageHeight,
+                    previewWidth,
+                    previewHeight
+                )
         } else {
             null
         }
-        val smoothedRectangleOnScreen = smoothRectangle(rectangleOnScreen, width, height)
+        val smoothedRectangleOnScreen = smoothRectangle(rectangleOnScreen, previewWidth, previewHeight)
         lastRectangleOnScreen = smoothedRectangleOnScreen
         val quality = when {
-            smoothedRectangleOnScreen != null && width > 0 && height > 0 ->
-                DocumentDetector.evaluateRectangleQualityInView(smoothedRectangleOnScreen, width, height)
+            smoothedRectangleOnScreen != null && previewWidth > 0 && previewHeight > 0 ->
+                DocumentDetector.evaluateRectangleQualityInView(smoothedRectangleOnScreen, previewWidth, previewHeight)
             rectangle != null -> DocumentDetector.evaluateRectangleQuality(rectangle, imageWidth, imageHeight)
             else -> RectangleQuality.TOO_FAR
         }
@@ -325,23 +344,33 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
             overlayView.setRectangle(rectangleOnScreen, overlayColor)
         }
 
-        // Update stable counter based on quality
+        // Update stable counter based on quality + IOU stability
         if (rectangleCoordinates == null) {
             if (stableCounter != 0) {
                 Log.d(TAG, "Rectangle lost, resetting stableCounter")
             }
             stableCounter = 0
+            clearIouHistory()
         } else {
             when (quality) {
                 RectangleQuality.GOOD -> {
-                    stableCounter = min(stableCounter + 1, detectionCountBeforeCapture)
-                    Log.d(TAG, "Good rectangle detected, stableCounter: $stableCounter/$detectionCountBeforeCapture")
+                    val isStable = rectangleOnScreen?.let { updateIouHistory(it) } ?: false
+                    if (isStable) {
+                        stableCounter = min(stableCounter + 1, detectionCountBeforeCapture)
+                        Log.d(TAG, "Good rectangle detected, stableCounter: $stableCounter/$detectionCountBeforeCapture")
+                    } else {
+                        if (stableCounter > 0) {
+                            stableCounter--
+                        }
+                        Log.d(TAG, "Rectangle unstable (IOU), stableCounter: $stableCounter")
+                    }
                 }
                 RectangleQuality.BAD_ANGLE, RectangleQuality.TOO_FAR -> {
                     if (stableCounter > 0) {
                         stableCounter--
                     }
                     Log.d(TAG, "Bad rectangle detected (type: $quality), stableCounter: $stableCounter")
+                    clearIouHistory()
                 }
             }
         }
@@ -357,6 +386,52 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         }
     }
 
+    private fun updateIouHistory(rectangle: Rectangle): Boolean {
+        if (iouHistory.size >= 3) {
+            iouHistory.removeFirst()
+        }
+        iouHistory.addLast(rectangle)
+        if (iouHistory.size < 3) {
+            return false
+        }
+        val r0 = iouHistory.elementAt(0)
+        val r1 = iouHistory.elementAt(1)
+        val r2 = iouHistory.elementAt(2)
+        val iou01 = rectangleIou(r0, r1)
+        val iou12 = rectangleIou(r1, r2)
+        val iou02 = rectangleIou(r0, r2)
+        return iou01 >= 0.85 && iou12 >= 0.85 && iou02 >= 0.85
+    }
+
+    private fun clearIouHistory() {
+        iouHistory.clear()
+    }
+
+    private fun rectangleIou(a: Rectangle, b: Rectangle): Double {
+        fun bounds(r: Rectangle): DoubleArray {
+            val minX = min(min(r.topLeft.x, r.topRight.x), min(r.bottomLeft.x, r.bottomRight.x))
+            val maxX = max(max(r.topLeft.x, r.topRight.x), max(r.bottomLeft.x, r.bottomRight.x))
+            val minY = min(min(r.topLeft.y, r.topRight.y), min(r.bottomLeft.y, r.bottomRight.y))
+            val maxY = max(max(r.topLeft.y, r.topRight.y), max(r.bottomLeft.y, r.bottomRight.y))
+            return doubleArrayOf(minX, minY, maxX, maxY)
+        }
+
+        val ab = bounds(a)
+        val bb = bounds(b)
+        val interLeft = max(ab[0], bb[0])
+        val interTop = max(ab[1], bb[1])
+        val interRight = min(ab[2], bb[2])
+        val interBottom = min(ab[3], bb[3])
+        val interW = max(0.0, interRight - interLeft)
+        val interH = max(0.0, interBottom - interTop)
+        val interArea = interW * interH
+        val areaA = max(0.0, (ab[2] - ab[0])) * max(0.0, (ab[3] - ab[1]))
+        val areaB = max(0.0, (bb[2] - bb[0])) * max(0.0, (bb[3] - bb[1]))
+        val union = areaA + areaB - interArea
+        if (union <= 0.0) return 0.0
+        return interArea / union
+    }
+
     fun capture() {
         captureWithPromise(null)
     }

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

@@ -94,11 +94,6 @@ 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/main/kotlin/com/reactnativerectangledocscanner/DocumentScannerModule.kt

@@ -1,49 +1,24 @@
 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), ActivityEventListener {
+    ReactContextBaseJavaModule(reactContext) {
 
     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)
@@ -71,13 +46,9 @@ class DocumentScannerModule(reactContext: ReactApplicationContext) :
                     if (view is DocumentScannerView) {
                         Log.d(TAG, "Found DocumentScannerView, triggering capture with 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)
-                        }
+                        // 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")
@@ -93,160 +64,6 @@ 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,28 +715,19 @@ 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: react_native_1.Platform.OS === 'android', detectionConfig: detectionConfig, useExternalScanner: react_native_1.Platform.OS === 'android', 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, 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' || useExternalScanner) {
+        if (react_native_1.Platform.OS !== 'android') {
             return;
         }
-        if (hasVisionCamera) {
-            console.log('[DocScanner] Using VisionCamera pipeline');
-        }
-        else {
-            console.warn('[DocScanner] VisionCamera pipeline unavailable, falling back to native view.', {
-                hasVisionCameraModule: Boolean(visionCameraModule),
-                hasReanimated: Boolean(reanimatedModule),
-            });
-        }
+        console.log('[DocScanner] Using native CameraX pipeline on Android');
     }, []);
-    if (useExternalScanner) {
+    if (react_native_1.Platform.OS === 'android') {
         return react_1.default.createElement(NativeScanner, { ref: ref, ...props });
     }
     if (hasVisionCamera) {

package/dist/FullDocScanner.js

@@ -124,7 +124,6 @@ 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);
@@ -144,11 +143,6 @@ 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);
@@ -394,7 +388,7 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             return;
         }
         console.log('[FullDocScanner] Starting manual capture, grid detected:', rectangleDetected);
-        const captureMode = useExternalScanner ? 'grid' : (rectangleDetected ? 'grid' : 'no-grid');
+        const captureMode = rectangleDetected ? 'grid' : 'no-grid';
         captureModeRef.current = captureMode;
         captureInProgressRef.current = true;
         // Add timeout to reset state if capture hangs
@@ -542,9 +536,6 @@ 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);
@@ -598,7 +589,7 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             }
             setRectangleDetected(false);
         }
-    }, [rectangleDetected, useExternalScanner]);
+    }, [rectangleDetected]);
     (0, react_1.useEffect)(() => () => {
         if (rectangleCaptureTimeoutRef.current) {
             clearTimeout(rectangleCaptureTimeoutRef.current);

package/package.json

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

package/src/DocScanner.tsx

@@ -1008,7 +1008,6 @@ const NativeScanner = forwardRef<DocScannerHandle, Props>(
           useBase64={useBase64}
           manualOnly={Platform.OS === 'android'}
           detectionConfig={detectionConfig}
-          useExternalScanner={Platform.OS === 'android'}
           onPictureTaken={handlePictureTaken}
           onError={handleError}
           onRectangleDetect={handleRectangleDetect}
@@ -1032,23 +1031,14 @@ const NativeScanner = forwardRef<DocScannerHandle, Props>(
 );
 
 export const DocScanner = forwardRef<DocScannerHandle, Props>((props, ref) => {
-  const useExternalScanner = Platform.OS === 'android';
-
   useEffect(() => {
-    if (Platform.OS !== 'android' || useExternalScanner) {
+    if (Platform.OS !== 'android') {
       return;
     }
-    if (hasVisionCamera) {
-      console.log('[DocScanner] Using VisionCamera pipeline');
-    } else {
-      console.warn('[DocScanner] VisionCamera pipeline unavailable, falling back to native view.', {
-        hasVisionCameraModule: Boolean(visionCameraModule),
-        hasReanimated: Boolean(reanimatedModule),
-      });
-    }
+    console.log('[DocScanner] Using native CameraX pipeline on Android');
   }, []);
 
-  if (useExternalScanner) {
+  if (Platform.OS === 'android') {
     return <NativeScanner ref={ref} {...props} />;
   }
 

package/src/FullDocScanner.tsx

@@ -187,7 +187,6 @@ 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);
@@ -209,12 +208,6 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
 
   const isBusinessMode = type === 'business';
 
-  useEffect(() => {
-    if (useExternalScanner) {
-      setCaptureReady(true);
-    }
-  }, [useExternalScanner]);
-
   const resetScannerView = useCallback(
     (options?: { remount?: boolean }) => {
       setProcessing(false);
@@ -546,7 +539,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
 
     console.log('[FullDocScanner] Starting manual capture, grid detected:', rectangleDetected);
 
-    const captureMode = useExternalScanner ? 'grid' : (rectangleDetected ? 'grid' : 'no-grid');
+    const captureMode = rectangleDetected ? 'grid' : 'no-grid';
     captureModeRef.current = captureMode;
     captureInProgressRef.current = true;
 
@@ -736,9 +729,6 @@ 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);
@@ -797,7 +787,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
       }
       setRectangleDetected(false);
     }
-  }, [rectangleDetected, useExternalScanner]);
+  }, [rectangleDetected]);
 
   useEffect(
     () => () => {

package/src/external.d.ts

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