react-native-rectangle-doc-scanner 13.11.0 → 15.1.0

package/android/build.gradle

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

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

@@ -1,16 +1,32 @@
 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
+import java.io.InputStream
 
 class DocumentScannerModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
+    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
 
     private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    private var pendingScanPromise: Promise? = null
+
+    private val scanRequestCode = 39201
+
+    init {
+        reactContext.addActivityEventListener(this)
+    }
 
     companion object {
         const val NAME = "RNPdfScannerManager"
@@ -19,6 +35,55 @@ class DocumentScannerModule(reactContext: ReactApplicationContext) :
 
     override fun getName() = NAME
 
+    @ReactMethod
+    fun startDocumentScanner(options: ReadableMap?, promise: Promise) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("NO_ACTIVITY", "Activity doesn't exist")
+            return
+        }
+
+        if (pendingScanPromise != null) {
+            promise.reject("SCAN_IN_PROGRESS", "Document scanner already in progress")
+            return
+        }
+
+        val pageLimit = options?.takeIf { it.hasKey("pageLimit") }?.getInt("pageLimit") ?: 2
+
+        val scannerOptions = GmsDocumentScannerOptions.Builder()
+            .setScannerMode(GmsDocumentScannerOptions.SCANNER_MODE_FULL)
+            .setResultFormats(GmsDocumentScannerOptions.RESULT_FORMAT_JPEG)
+            .setPageLimit(pageLimit.coerceAtMost(2))
+            .setGalleryImportAllowed(true)
+            .build()
+
+        val scanner = GmsDocumentScanning.getClient(scannerOptions)
+        pendingScanPromise = promise
+
+        scanner.getStartScanIntent(activity)
+            .addOnSuccessListener { intentSender ->
+                try {
+                    activity.startIntentSenderForResult(
+                        intentSender,
+                        scanRequestCode,
+                        null,
+                        0,
+                        0,
+                        0
+                    )
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to launch document scanner", e)
+                    pendingScanPromise = null
+                    promise.reject("SCAN_LAUNCH_FAILED", "Failed to launch scanner: ${e.message}", e)
+                }
+            }
+            .addOnFailureListener { e ->
+                Log.e(TAG, "Failed to get document scanner intent", e)
+                pendingScanPromise = null
+                promise.reject("SCAN_INIT_FAILED", "Failed to initialize scanner: ${e.message}", e)
+            }
+    }
+
     /**
      * Capture image from the document scanner view
      * Matches iOS signature: capture(reactTag, resolver, rejecter)
@@ -238,6 +303,101 @@ class DocumentScannerModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    override fun onActivityResult(activity: Activity?, requestCode: Int, resultCode: Int, data: Intent?) {
+        if (requestCode != scanRequestCode) {
+            return
+        }
+
+        val promise = pendingScanPromise
+        pendingScanPromise = null
+
+        if (promise == null) {
+            return
+        }
+
+        if (resultCode != Activity.RESULT_OK) {
+            promise.reject("SCAN_CANCELLED", "Document scan cancelled")
+            return
+        }
+
+        val result = GmsDocumentScanningResult.fromActivityResultIntent(data)
+        if (result == null) {
+            promise.reject("SCAN_NO_RESULT", "No scan result returned")
+            return
+        }
+
+        val pages = result.pages
+        if (pages.isNullOrEmpty()) {
+            promise.reject("SCAN_NO_PAGES", "No pages returned from scanner")
+            return
+        }
+
+        try {
+            val outputPages = Arguments.createArray()
+            var firstPath: String? = null
+            var firstWidth = 0
+            var firstHeight = 0
+
+            pages.forEachIndexed { index, page ->
+                val imageUri = page.imageUri
+                val outputFile = copyUriToCache(imageUri, index)
+                val (width, height) = readImageSize(outputFile.absolutePath)
+
+                if (index == 0) {
+                    firstPath = outputFile.absolutePath
+                    firstWidth = width
+                    firstHeight = height
+                }
+
+                val pageMap = Arguments.createMap().apply {
+                    putString("path", outputFile.absolutePath)
+                    putInt("width", width)
+                    putInt("height", height)
+                }
+                outputPages.pushMap(pageMap)
+            }
+
+            val response = Arguments.createMap().apply {
+                putString("croppedImage", firstPath)
+                putString("initialImage", firstPath)
+                putInt("width", firstWidth)
+                putInt("height", firstHeight)
+                putArray("pages", outputPages)
+            }
+
+            promise.resolve(response)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to handle scan result", e)
+            promise.reject("SCAN_PROCESS_FAILED", "Failed to handle scan result: ${e.message}", e)
+        }
+    }
+
+    override fun onNewIntent(intent: Intent?) {
+        // No-op
+    }
+
+    private fun copyUriToCache(uri: Uri, index: Int): File {
+        val filename = "docscanner_page_${System.currentTimeMillis()}_$index.jpg"
+        val outputFile = File(reactApplicationContext.cacheDir, filename)
+        val resolver = reactApplicationContext.contentResolver
+        val inputStream: InputStream = resolver.openInputStream(uri)
+            ?: throw IllegalStateException("Failed to open input stream for $uri")
+
+        inputStream.use { input ->
+            FileOutputStream(outputFile).use { output ->
+                input.copyTo(output)
+            }
+        }
+
+        return outputFile
+    }
+
+    private fun readImageSize(path: String): Pair<Int, Int> {
+        val options = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        BitmapFactory.decodeFile(path, options)
+        return options.outWidth to options.outHeight
+    }
+
     override fun onCatalystInstanceDestroy() {
         super.onCatalystInstanceDestroy()
         scope.cancel()

package/dist/DocScanner.d.ts

@@ -8,6 +8,11 @@ type PictureEvent = {
     height?: number;
     rectangleCoordinates?: NativeRectangle | null;
     rectangleOnScreen?: NativeRectangle | null;
+    pages?: Array<{
+        path: string;
+        width: number;
+        height: number;
+    }> | null;
 };
 export type RectangleDetectEvent = Omit<RectangleEventPayload, 'rectangleCoordinates' | 'rectangleOnScreen'> & {
     rectangleCoordinates?: Rectangle | null;

package/dist/DocScanner.js

@@ -44,6 +44,7 @@ const coordinate_1 = require("./utils/coordinate");
 const overlay_1 = require("./utils/overlay");
 const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
 const { RNPdfScannerManager } = react_native_1.NativeModules;
+const isAndroidDocumentScanner = react_native_1.Platform.OS === 'android' && typeof RNPdfScannerManager?.startDocumentScanner === 'function';
 const safeRequire = (moduleName) => {
     try {
         // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -87,6 +88,89 @@ const RectangleQuality = {
     BAD_ANGLE: 1,
     TOO_FAR: 2,
 };
+const DEFAULT_PAGE_LIMIT = 2;
+const ActivityScanner = (0, react_1.forwardRef)(({ onCapture, children, showManualCaptureButton = false, }, ref) => {
+    const captureOriginRef = (0, react_1.useRef)('auto');
+    const captureResolvers = (0, react_1.useRef)(null);
+    const handlePictureTaken = (0, react_1.useCallback)((event) => {
+        const captureError = event?.error;
+        if (captureError) {
+            captureOriginRef.current = 'auto';
+            if (captureResolvers.current) {
+                captureResolvers.current.reject(new Error(String(captureError)));
+                captureResolvers.current = null;
+            }
+            return;
+        }
+        const normalizedRectangle = normalizeRectangle(event.rectangleCoordinates ?? null) ??
+            normalizeRectangle(event.rectangleOnScreen ?? null) ??
+            null;
+        const quad = normalizedRectangle ? (0, coordinate_1.rectangleToQuad)(normalizedRectangle) : null;
+        const origin = captureOriginRef.current;
+        captureOriginRef.current = 'auto';
+        const initialPath = event.initialImage ?? null;
+        const croppedPath = event.croppedImage ?? null;
+        const editablePath = initialPath ?? croppedPath;
+        if (editablePath) {
+            onCapture?.({
+                path: editablePath,
+                initialPath,
+                croppedPath,
+                quad,
+                rectangle: normalizedRectangle,
+                width: event.width ?? 0,
+                height: event.height ?? 0,
+                origin,
+            });
+        }
+        if (captureResolvers.current) {
+            captureResolvers.current.resolve(event);
+            captureResolvers.current = null;
+        }
+    }, [onCapture]);
+    const handleError = (0, react_1.useCallback)((error) => {
+        if (captureResolvers.current) {
+            captureResolvers.current.reject(error);
+            captureResolvers.current = null;
+        }
+    }, []);
+    const capture = (0, react_1.useCallback)(() => {
+        captureOriginRef.current = 'manual';
+        if (!RNPdfScannerManager?.startDocumentScanner) {
+            captureOriginRef.current = 'auto';
+            return Promise.reject(new Error('document_scanner_not_available'));
+        }
+        if (captureResolvers.current) {
+            captureOriginRef.current = 'auto';
+            return Promise.reject(new Error('capture_in_progress'));
+        }
+        return new Promise((resolve, reject) => {
+            captureResolvers.current = { resolve, reject };
+            RNPdfScannerManager.startDocumentScanner({ pageLimit: DEFAULT_PAGE_LIMIT })
+                .then(handlePictureTaken)
+                .catch((error) => {
+                captureOriginRef.current = 'auto';
+                handleError(error);
+            });
+        });
+    }, [handleError, handlePictureTaken]);
+    (0, react_1.useImperativeHandle)(ref, () => ({
+        capture,
+        reset: () => {
+            if (captureResolvers.current) {
+                captureResolvers.current.reject(new Error('reset'));
+                captureResolvers.current = null;
+            }
+            captureOriginRef.current = 'auto';
+        },
+    }), [capture]);
+    const handleManualCapture = (0, react_1.useCallback)(() => {
+        capture().catch(() => null);
+    }, [capture]);
+    return (react_1.default.createElement(react_native_1.View, { style: styles.container },
+        showManualCaptureButton && (react_1.default.createElement(react_native_1.TouchableOpacity, { style: styles.button, onPress: handleManualCapture })),
+        children));
+});
 const evaluateRectangleQualityInView = (rectangle, viewWidth, viewHeight) => {
     if (!viewWidth || !viewHeight) {
         return RectangleQuality.TOO_FAR;
@@ -725,9 +809,17 @@ exports.DocScanner = (0, react_1.forwardRef)((props, ref) => {
         if (react_native_1.Platform.OS !== 'android') {
             return;
         }
-        console.log('[DocScanner] Using native CameraX pipeline on Android');
+        if (isAndroidDocumentScanner) {
+            console.log('[DocScanner] Using ML Kit document scanner activity on Android');
+        }
+        else {
+            console.log('[DocScanner] Using native CameraX pipeline on Android');
+        }
     }, []);
     if (react_native_1.Platform.OS === 'android') {
+        if (isAndroidDocumentScanner) {
+            return react_1.default.createElement(ActivityScanner, { ref: ref, ...props });
+        }
         return react_1.default.createElement(NativeScanner, { ref: ref, ...props });
     }
     if (hasVisionCamera) {

package/dist/FullDocScanner.js

@@ -149,6 +149,7 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
     const [scannerSession, setScannerSession] = (0, react_1.useState)(0);
     const [cropEditorDocument, setCropEditorDocument] = (0, react_1.useState)(null);
     const [cropEditorRectangle, setCropEditorRectangle] = (0, react_1.useState)(null);
+    const [androidScanAutoRequested, setAndroidScanAutoRequested] = (0, react_1.useState)(false);
     const resolvedGridColor = gridColor ?? overlayColor;
     const docScannerRef = (0, react_1.useRef)(null);
     const captureModeRef = (0, react_1.useRef)(null);
@@ -157,15 +158,19 @@ 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';
+    const pdfScannerManager = react_native_1.NativeModules?.RNPdfScannerManager;
+    const isAndroidCropEditorAvailable = react_native_1.Platform.OS === 'android' && Boolean(CropEditor);
+    const usesAndroidScannerActivity = react_native_1.Platform.OS === 'android' && typeof pdfScannerManager?.startDocumentScanner === 'function';
     const resetScannerView = (0, react_1.useCallback)((options) => {
         setProcessing(false);
         setCroppedImageData(null);
         setCropEditorDocument(null);
         setCropEditorRectangle(null);
+        setAndroidScanAutoRequested(false);
         setRotationDegrees(0);
         setRectangleDetected(false);
         setRectangleHint(false);
-        setCaptureReady(false);
+        setCaptureReady(usesAndroidScannerActivity ? true : false);
         captureModeRef.current = null;
         captureInProgressRef.current = false;
         if (rectangleCaptureTimeoutRef.current) {
@@ -186,7 +191,7 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
         if (options?.remount) {
             setScannerSession((prev) => prev + 1);
         }
-    }, []);
+    }, [usesAndroidScannerActivity]);
     const mergedStrings = (0, react_1.useMemo)(() => ({
         captureHint: strings?.captureHint,
         manualHint: strings?.manualHint,
@@ -202,8 +207,6 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
         secondPrompt: strings?.secondPrompt ?? strings?.secondBtn ?? 'Capture Back Side?',
         originalBtn: strings?.originalBtn ?? 'Use Original',
     }), [strings]);
-    const pdfScannerManager = react_native_1.NativeModules?.RNPdfScannerManager;
-    const isAndroidCropEditorAvailable = react_native_1.Platform.OS === 'android' && Boolean(CropEditor);
     const autoEnhancementEnabled = (0, react_1.useMemo)(() => typeof pdfScannerManager?.applyColorControls === 'function', [pdfScannerManager]);
     const ensureBase64ForImage = (0, react_1.useCallback)(async (image) => {
         if (image.base64) {
@@ -473,7 +476,7 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             currentCaptureMode: captureModeRef.current,
             captureInProgress: captureInProgressRef.current,
         });
-        if (react_native_1.Platform.OS === 'android' && !captureReady) {
+        if (react_native_1.Platform.OS === 'android' && !captureReady && !usesAndroidScannerActivity) {
             console.log('[FullDocScanner] Capture not ready yet, skipping');
             return;
         }
@@ -490,7 +493,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 = usesAndroidScannerActivity ? 'grid' : rectangleDetected ? 'grid' : 'no-grid';
         captureModeRef.current = captureMode;
         captureInProgressRef.current = true;
         // Add timeout to reset state if capture hangs
@@ -518,11 +521,14 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             console.error('[FullDocScanner] Manual capture failed:', errorMessage, error);
             captureModeRef.current = null;
             captureInProgressRef.current = false;
+            if (errorMessage.includes('SCAN_CANCELLED')) {
+                return;
+            }
             if (error instanceof Error && error.message !== 'capture_in_progress') {
                 emitError(error, 'Failed to capture image. Please try again.');
             }
         });
-    }, [processing, rectangleDetected, rectangleHint, captureReady, emitError]);
+    }, [processing, rectangleDetected, rectangleHint, captureReady, emitError, usesAndroidScannerActivity]);
     const handleGalleryPick = (0, react_1.useCallback)(async () => {
         console.log('[FullDocScanner] handleGalleryPick called');
         if (processing || isGalleryOpen) {
@@ -703,6 +709,28 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             clearTimeout(captureReadyTimeoutRef.current);
         }
     }, []);
+    (0, react_1.useEffect)(() => {
+        if (usesAndroidScannerActivity) {
+            setCaptureReady(true);
+        }
+    }, [usesAndroidScannerActivity]);
+    (0, react_1.useEffect)(() => {
+        if (!usesAndroidScannerActivity) {
+            return;
+        }
+        if (androidScanAutoRequested || croppedImageData || cropEditorDocument || processing) {
+            return;
+        }
+        setAndroidScanAutoRequested(true);
+        triggerManualCapture();
+    }, [
+        androidScanAutoRequested,
+        cropEditorDocument,
+        croppedImageData,
+        processing,
+        triggerManualCapture,
+        usesAndroidScannerActivity,
+    ]);
     const activePreviewImage = croppedImageData ? getActivePreviewImage(croppedImageData) : null;
     return (react_1.default.createElement(react_native_1.View, { style: styles.container },
         react_native_1.Platform.OS === 'android' && (react_1.default.createElement(react_native_1.StatusBar, { translucent: true, backgroundColor: "transparent" })),
@@ -783,11 +811,12 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
                     react_1.default.createElement(react_native_1.TouchableOpacity, { style: [
                             styles.shutterButton,
                             processing && styles.buttonDisabled,
-                            react_native_1.Platform.OS === 'android' && !captureReady && styles.buttonDisabled,
-                        ], onPress: triggerManualCapture, disabled: processing || (react_native_1.Platform.OS === 'android' && !captureReady), accessibilityLabel: mergedStrings.manualHint, accessibilityRole: "button" },
+                            react_native_1.Platform.OS === 'android' && !captureReady && !usesAndroidScannerActivity && styles.buttonDisabled,
+                        ], onPress: triggerManualCapture, disabled: processing || (react_native_1.Platform.OS === 'android' && !captureReady && !usesAndroidScannerActivity), accessibilityLabel: mergedStrings.manualHint, accessibilityRole: "button" },
                         react_1.default.createElement(react_native_1.View, { style: [
                                 styles.shutterInner,
-                                (react_native_1.Platform.OS === 'android' ? captureReady : rectangleHint) && { backgroundColor: overlayColor }
+                                (react_native_1.Platform.OS === 'android' ? captureReady || usesAndroidScannerActivity : rectangleHint) &&
+                                    { backgroundColor: overlayColor }
                             ] })),
                     react_1.default.createElement(react_native_1.View, { style: styles.rightButtonsPlaceholder }))))),
         processing && (react_1.default.createElement(react_native_1.View, { style: styles.processingOverlay },

package/package.json

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

package/src/DocScanner.tsx

@@ -30,6 +30,7 @@ type PictureEvent = {
   height?: number;
   rectangleCoordinates?: NativeRectangle | null;
   rectangleOnScreen?: NativeRectangle | null;
+  pages?: Array<{ path: string; width: number; height: number }> | null;
 };
 
 export type RectangleDetectEvent = Omit<RectangleEventPayload, 'rectangleCoordinates' | 'rectangleOnScreen'> & {
@@ -53,6 +54,8 @@ const isFiniteNumber = (value: unknown): value is number =>
   typeof value === 'number' && Number.isFinite(value);
 
 const { RNPdfScannerManager } = NativeModules;
+const isAndroidDocumentScanner =
+  Platform.OS === 'android' && typeof RNPdfScannerManager?.startDocumentScanner === 'function';
 
 const safeRequire = (moduleName: string) => {
   try {
@@ -137,6 +140,130 @@ const RectangleQuality = {
   TOO_FAR: 2,
 } as const;
 
+const DEFAULT_PAGE_LIMIT = 2;
+
+const ActivityScanner = forwardRef<DocScannerHandle, Props>(
+  (
+    {
+      onCapture,
+      children,
+      showManualCaptureButton = false,
+    },
+    ref,
+  ) => {
+    const captureOriginRef = useRef<'auto' | 'manual'>('auto');
+    const captureResolvers = useRef<{
+      resolve: (value: PictureEvent) => void;
+      reject: (error: Error) => void;
+    } | null>(null);
+
+    const handlePictureTaken = useCallback(
+      (event: PictureEvent) => {
+        const captureError = (event as any)?.error;
+        if (captureError) {
+          captureOriginRef.current = 'auto';
+
+          if (captureResolvers.current) {
+            captureResolvers.current.reject(new Error(String(captureError)));
+            captureResolvers.current = null;
+          }
+          return;
+        }
+
+        const normalizedRectangle =
+          normalizeRectangle(event.rectangleCoordinates ?? null) ??
+          normalizeRectangle(event.rectangleOnScreen ?? null) ??
+          null;
+        const quad = normalizedRectangle ? rectangleToQuad(normalizedRectangle) : null;
+        const origin = captureOriginRef.current;
+        captureOriginRef.current = 'auto';
+
+        const initialPath = event.initialImage ?? null;
+        const croppedPath = event.croppedImage ?? null;
+        const editablePath = initialPath ?? croppedPath;
+
+        if (editablePath) {
+          onCapture?.({
+            path: editablePath,
+            initialPath,
+            croppedPath,
+            quad,
+            rectangle: normalizedRectangle,
+            width: event.width ?? 0,
+            height: event.height ?? 0,
+            origin,
+          });
+        }
+
+        if (captureResolvers.current) {
+          captureResolvers.current.resolve(event);
+          captureResolvers.current = null;
+        }
+      },
+      [onCapture],
+    );
+
+    const handleError = useCallback((error: Error) => {
+      if (captureResolvers.current) {
+        captureResolvers.current.reject(error);
+        captureResolvers.current = null;
+      }
+    }, []);
+
+    const capture = useCallback((): Promise<PictureEvent> => {
+      captureOriginRef.current = 'manual';
+
+      if (!RNPdfScannerManager?.startDocumentScanner) {
+        captureOriginRef.current = 'auto';
+        return Promise.reject(new Error('document_scanner_not_available'));
+      }
+
+      if (captureResolvers.current) {
+        captureOriginRef.current = 'auto';
+        return Promise.reject(new Error('capture_in_progress'));
+      }
+
+      return new Promise<PictureEvent>((resolve, reject) => {
+        captureResolvers.current = { resolve, reject };
+        RNPdfScannerManager.startDocumentScanner({ pageLimit: DEFAULT_PAGE_LIMIT })
+          .then(handlePictureTaken)
+          .catch((error: unknown) => {
+            captureOriginRef.current = 'auto';
+            handleError(error as Error);
+          });
+      });
+    }, [handleError, handlePictureTaken]);
+
+    useImperativeHandle(
+      ref,
+      () => ({
+        capture,
+        reset: () => {
+          if (captureResolvers.current) {
+            captureResolvers.current.reject(new Error('reset'));
+            captureResolvers.current = null;
+          }
+          captureOriginRef.current = 'auto';
+        },
+      }),
+      [capture],
+    );
+
+    const handleManualCapture = useCallback(() => {
+      capture().catch(() => null);
+    }, [capture]);
+
+    return (
+      <View style={styles.container}>
+        {showManualCaptureButton && (
+          <TouchableOpacity style={styles.button} onPress={handleManualCapture} />
+        )}
+        {children}
+      </View>
+    );
+  },
+);
+
 const evaluateRectangleQualityInView = (rectangle: Rectangle, viewWidth: number, viewHeight: number) => {
   if (!viewWidth || !viewHeight) {
     return RectangleQuality.TOO_FAR;
@@ -1035,10 +1162,17 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>((props, ref) => {
     if (Platform.OS !== 'android') {
       return;
     }
-    console.log('[DocScanner] Using native CameraX pipeline on Android');
+    if (isAndroidDocumentScanner) {
+      console.log('[DocScanner] Using ML Kit document scanner activity on Android');
+    } else {
+      console.log('[DocScanner] Using native CameraX pipeline on Android');
+    }
   }, []);
 
   if (Platform.OS === 'android') {
+    if (isAndroidDocumentScanner) {
+      return <ActivityScanner ref={ref} {...props} />;
+    }
     return <NativeScanner ref={ref} {...props} />;
   }
 

package/src/FullDocScanner.tsx

@@ -220,6 +220,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
   const [scannerSession, setScannerSession] = useState(0);
   const [cropEditorDocument, setCropEditorDocument] = useState<CapturedDocument | null>(null);
   const [cropEditorRectangle, setCropEditorRectangle] = useState<Rectangle | null>(null);
+  const [androidScanAutoRequested, setAndroidScanAutoRequested] = useState(false);
   const resolvedGridColor = gridColor ?? overlayColor;
   const docScannerRef = useRef<DocScannerHandle | null>(null);
   const captureModeRef = useRef<'grid' | 'no-grid' | null>(null);
@@ -229,6 +230,10 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
   const captureReadyTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
   const isBusinessMode = type === 'business';
+  const pdfScannerManager = (NativeModules as any)?.RNPdfScannerManager;
+  const isAndroidCropEditorAvailable = Platform.OS === 'android' && Boolean(CropEditor);
+  const usesAndroidScannerActivity =
+    Platform.OS === 'android' && typeof pdfScannerManager?.startDocumentScanner === 'function';
 
   const resetScannerView = useCallback(
     (options?: { remount?: boolean }) => {
@@ -236,10 +241,11 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
       setCroppedImageData(null);
       setCropEditorDocument(null);
       setCropEditorRectangle(null);
+      setAndroidScanAutoRequested(false);
       setRotationDegrees(0);
       setRectangleDetected(false);
       setRectangleHint(false);
-      setCaptureReady(false);
+      setCaptureReady(usesAndroidScannerActivity ? true : false);
       captureModeRef.current = null;
       captureInProgressRef.current = false;
 
@@ -265,7 +271,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
         setScannerSession((prev) => prev + 1);
       }
     },
-    [],
+    [usesAndroidScannerActivity],
   );
 
   const mergedStrings = useMemo(
@@ -287,9 +293,6 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
     [strings],
   );
 
-  const pdfScannerManager = (NativeModules as any)?.RNPdfScannerManager;
-  const isAndroidCropEditorAvailable = Platform.OS === 'android' && Boolean(CropEditor);
-
   const autoEnhancementEnabled = useMemo(
     () => typeof pdfScannerManager?.applyColorControls === 'function',
     [pdfScannerManager],
@@ -647,7 +650,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
       captureInProgress: captureInProgressRef.current,
     });
 
-    if (Platform.OS === 'android' && !captureReady) {
+    if (Platform.OS === 'android' && !captureReady && !usesAndroidScannerActivity) {
       console.log('[FullDocScanner] Capture not ready yet, skipping');
       return;
     }
@@ -669,7 +672,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
 
     console.log('[FullDocScanner] Starting manual capture, grid detected:', rectangleDetected);
 
-    const captureMode = rectangleDetected ? 'grid' : 'no-grid';
+    const captureMode = usesAndroidScannerActivity ? 'grid' : rectangleDetected ? 'grid' : 'no-grid';
     captureModeRef.current = captureMode;
     captureInProgressRef.current = true;
 
@@ -703,6 +706,10 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
         captureModeRef.current = null;
         captureInProgressRef.current = false;
 
+        if (errorMessage.includes('SCAN_CANCELLED')) {
+          return;
+        }
+
         if (error instanceof Error && error.message !== 'capture_in_progress') {
           emitError(
             error,
@@ -710,7 +717,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
           );
         }
       });
-  }, [processing, rectangleDetected, rectangleHint, captureReady, emitError]);
+  }, [processing, rectangleDetected, rectangleHint, captureReady, emitError, usesAndroidScannerActivity]);
 
   const handleGalleryPick = useCallback(async () => {
     console.log('[FullDocScanner] handleGalleryPick called');
@@ -934,6 +941,32 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
     [],
   );
 
+  useEffect(() => {
+    if (usesAndroidScannerActivity) {
+      setCaptureReady(true);
+    }
+  }, [usesAndroidScannerActivity]);
+
+  useEffect(() => {
+    if (!usesAndroidScannerActivity) {
+      return;
+    }
+
+    if (androidScanAutoRequested || croppedImageData || cropEditorDocument || processing) {
+      return;
+    }
+
+    setAndroidScanAutoRequested(true);
+    triggerManualCapture();
+  }, [
+    androidScanAutoRequested,
+    cropEditorDocument,
+    croppedImageData,
+    processing,
+    triggerManualCapture,
+    usesAndroidScannerActivity,
+  ]);
+
   const activePreviewImage = croppedImageData ? getActivePreviewImage(croppedImageData) : null;
 
   return (
@@ -1195,16 +1228,17 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
               style={[
                 styles.shutterButton,
                 processing && styles.buttonDisabled,
-                Platform.OS === 'android' && !captureReady && styles.buttonDisabled,
+                Platform.OS === 'android' && !captureReady && !usesAndroidScannerActivity && styles.buttonDisabled,
               ]}
               onPress={triggerManualCapture}
-              disabled={processing || (Platform.OS === 'android' && !captureReady)}
+              disabled={processing || (Platform.OS === 'android' && !captureReady && !usesAndroidScannerActivity)}
               accessibilityLabel={mergedStrings.manualHint}
               accessibilityRole="button"
             >
               <View style={[
                 styles.shutterInner,
-                (Platform.OS === 'android' ? captureReady : rectangleHint) && { backgroundColor: overlayColor }
+                (Platform.OS === 'android' ? captureReady || usesAndroidScannerActivity : rectangleHint) &&
+                  { backgroundColor: overlayColor }
               ]} />
             </TouchableOpacity>
             <View style={styles.rightButtonsPlaceholder} />