react-native-rectangle-doc-scanner 13.9.0 → 15.0.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(false)
+            .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/CropEditor.d.ts

@@ -6,6 +6,8 @@ interface CropEditorProps {
     overlayStrokeColor?: string;
     handlerColor?: string;
     enablePanStrict?: boolean;
+    enableEditor?: boolean;
+    autoCrop?: boolean;
     onCropChange?: (rectangle: Rectangle) => void;
 }
 /**

package/dist/CropEditor.js

@@ -32,10 +32,14 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CropEditor = void 0;
 const react_1 = __importStar(require("react"));
 const react_native_1 = require("react-native");
+const react_native_perspective_image_cropper_1 = __importDefault(require("react-native-perspective-image-cropper"));
 const coordinate_1 = require("./utils/coordinate");
 /**
  * CropEditor Component
@@ -50,7 +54,7 @@ const coordinate_1 = require("./utils/coordinate");
  * @param enablePanStrict - Enable strict panning behavior
  * @param onCropChange - Callback when user adjusts crop corners
  */
-const CropEditor = ({ document, overlayColor = 'rgba(0,0,0,0.5)', overlayStrokeColor = '#e7a649', handlerColor = '#e7a649', enablePanStrict = false, onCropChange, }) => {
+const CropEditor = ({ document, overlayColor = 'rgba(0,0,0,0.5)', overlayStrokeColor = '#e7a649', handlerColor = '#e7a649', enablePanStrict = false, enableEditor = false, autoCrop = true, onCropChange, }) => {
     const [imageSize, setImageSize] = (0, react_1.useState)(null);
     const [displaySize, setDisplaySize] = (0, react_1.useState)({
         width: react_native_1.Dimensions.get('window').width,
@@ -59,32 +63,6 @@ const CropEditor = ({ document, overlayColor = 'rgba(0,0,0,0.5)', overlayStrokeC
     const [isImageLoading, setIsImageLoading] = (0, react_1.useState)(true);
     const [loadError, setLoadError] = (0, react_1.useState)(null);
     const [croppedImageUri, setCroppedImageUri] = (0, react_1.useState)(null);
-    (0, react_1.useEffect)(() => {
-        console.log('[CropEditor] Document path:', document.path);
-        console.log('[CropEditor] Document dimensions:', document.width, 'x', document.height);
-        console.log('[CropEditor] Document quad:', document.quad);
-        console.log('[CropEditor] Document rectangle:', document.rectangle);
-        // Load image size using Image.getSize
-        const imageUri = document.path.startsWith('file://') ? document.path : `file://${document.path}`;
-        react_native_1.Image.getSize(imageUri, (width, height) => {
-            console.log('[CropEditor] Image.getSize success:', { width, height });
-            setImageSize({ width, height });
-            // If we have a rectangle (from auto-capture), crop the image
-            if (document.rectangle || document.quad) {
-                cropImageToRectangle(imageUri, width, height);
-            }
-            else {
-                setIsImageLoading(false);
-                setLoadError(null);
-            }
-        }, (error) => {
-            console.error('[CropEditor] Image.getSize error:', error);
-            // Fallback to document dimensions
-            console.log('[CropEditor] Using fallback dimensions:', document.width, 'x', document.height);
-            setImageSize({ width: document.width, height: document.height });
-            setIsImageLoading(false);
-        });
-    }, [document]);
     const cropImageToRectangle = (0, react_1.useCallback)((imageUri, width, height) => {
         const cropManager = react_native_1.NativeModules.CustomCropManager;
         if (!cropManager?.crop) {
@@ -127,6 +105,33 @@ const CropEditor = ({ document, overlayColor = 'rgba(0,0,0,0.5)', overlayStrokeC
             setLoadError(null);
         });
     }, [document]);
+    (0, react_1.useEffect)(() => {
+        console.log('[CropEditor] Document path:', document.path);
+        console.log('[CropEditor] Document dimensions:', document.width, 'x', document.height);
+        console.log('[CropEditor] Document quad:', document.quad);
+        console.log('[CropEditor] Document rectangle:', document.rectangle);
+        const shouldAutoCrop = autoCrop && !enableEditor;
+        // Load image size using Image.getSize
+        const imageUri = document.path.startsWith('file://') ? document.path : `file://${document.path}`;
+        react_native_1.Image.getSize(imageUri, (width, height) => {
+            console.log('[CropEditor] Image.getSize success:', { width, height });
+            setImageSize({ width, height });
+            // If we have a rectangle (from auto-capture), crop the image
+            if (shouldAutoCrop && (document.rectangle || document.quad)) {
+                cropImageToRectangle(imageUri, width, height);
+            }
+            else {
+                setIsImageLoading(false);
+                setLoadError(null);
+            }
+        }, (error) => {
+            console.error('[CropEditor] Image.getSize error:', error);
+            // Fallback to document dimensions
+            console.log('[CropEditor] Using fallback dimensions:', document.width, 'x', document.height);
+            setImageSize({ width: document.width, height: document.height });
+            setIsImageLoading(false);
+        });
+    }, [autoCrop, cropImageToRectangle, document, enableEditor]);
     // Get initial rectangle from detected quad or use default
     const getInitialRectangle = (0, react_1.useCallback)(() => {
         if (!imageSize) {
@@ -180,7 +185,7 @@ const CropEditor = ({ document, overlayColor = 'rgba(0,0,0,0.5)', overlayStrokeC
         react_1.default.createElement(react_native_1.Text, { style: styles.errorText }, "Failed to load image"),
         react_1.default.createElement(react_native_1.Text, { style: styles.errorPath }, imageUri))) : !imageSize || isImageLoading ? (react_1.default.createElement(react_native_1.View, { style: styles.loadingContainer },
         react_1.default.createElement(react_native_1.ActivityIndicator, { size: "large", color: handlerColor }),
-        react_1.default.createElement(react_native_1.Text, { style: styles.loadingText }, "Loading image..."))) : (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement(react_native_1.Text, { style: styles.loadingText }, "Loading image..."))) : enableEditor ? (react_1.default.createElement(react_native_perspective_image_cropper_1.default, { height: displaySize.height, width: displaySize.width, image: imageUri, rectangleCoordinates: initialRect, overlayColor: overlayColor, overlayStrokeColor: overlayStrokeColor, handlerColor: handlerColor, enablePanStrict: enablePanStrict, onDragEnd: handleDragEnd })) : (react_1.default.createElement(react_1.default.Fragment, null,
         react_1.default.createElement(react_native_1.Image, { source: { uri: croppedImageUri || imageUri }, style: styles.fullImage, resizeMode: "contain", onLoad: () => console.log('[CropEditor] Image loaded successfully', croppedImageUri ? 'cropped' : 'original'), onError: (e) => console.error('[CropEditor] Image load error:', e.nativeEvent.error) })))));
 };
 exports.CropEditor = CropEditor;

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

@@ -43,6 +43,7 @@ const react_native_image_picker_1 = require("react-native-image-picker");
 const react_native_image_crop_picker_1 = __importDefault(require("react-native-image-crop-picker"));
 const react_native_fs_1 = __importDefault(require("react-native-fs"));
 const DocScanner_1 = require("./DocScanner");
+const coordinate_1 = require("./utils/coordinate");
 // 회전은 항상 지원됨 (회전 각도를 반환하고 tdb 앱에서 처리)
 const isImageRotationSupported = () => true;
 const stripFileUri = (value) => value.replace(/^file:\/\//, '');
@@ -58,6 +59,17 @@ const ensureFileUri = (value) => {
     }
     return value;
 };
+const safeRequire = (moduleName) => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require(moduleName);
+    }
+    catch {
+        return null;
+    }
+};
+const CropEditorModule = safeRequire('./CropEditor');
+const CropEditor = CropEditorModule?.CropEditor;
 const CROPPER_TIMEOUT_MS = 8000;
 const CROPPER_TIMEOUT_CODE = 'cropper_timeout';
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -135,6 +147,8 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
     const [capturedPhotos, setCapturedPhotos] = (0, react_1.useState)([]);
     const [currentPhotoIndex, setCurrentPhotoIndex] = (0, react_1.useState)(0);
     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 resolvedGridColor = gridColor ?? overlayColor;
     const docScannerRef = (0, react_1.useRef)(null);
     const captureModeRef = (0, react_1.useRef)(null);
@@ -143,13 +157,18 @@ 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);
         setRotationDegrees(0);
         setRectangleDetected(false);
         setRectangleHint(false);
-        setCaptureReady(false);
+        setCaptureReady(usesAndroidScannerActivity ? true : false);
         captureModeRef.current = null;
         captureInProgressRef.current = false;
         if (rectangleCaptureTimeoutRef.current) {
@@ -170,7 +189,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,
@@ -186,7 +205,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 autoEnhancementEnabled = (0, react_1.useMemo)(() => typeof pdfScannerManager?.applyColorControls === 'function', [pdfScannerManager]);
     const ensureBase64ForImage = (0, react_1.useCallback)(async (image) => {
         if (image.base64) {
@@ -243,6 +261,17 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             react_native_1.Alert.alert('Document Scanner', fallbackMessage);
         }
     }, [onError]);
+    const openAndroidCropEditor = (0, react_1.useCallback)((document) => {
+        const rectangle = document.rectangle ??
+            (document.quad && document.quad.length === 4 ? (0, coordinate_1.quadToRectangle)(document.quad) : null);
+        const documentForEditor = rectangle ? { ...document, rectangle } : document;
+        setCropEditorDocument(documentForEditor);
+        setCropEditorRectangle(rectangle);
+    }, []);
+    const closeAndroidCropEditor = (0, react_1.useCallback)(() => {
+        setCropEditorDocument(null);
+        setCropEditorRectangle(null);
+    }, []);
     const openCropper = (0, react_1.useCallback)(async (imagePath, options) => {
         try {
             console.log('[FullDocScanner] openCropper called with path:', imagePath);
@@ -314,6 +343,64 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             }
         }
     }, [cropWidth, cropHeight, emitError, preparePreviewImage, resetScannerView]);
+    const handleCropEditorConfirm = (0, react_1.useCallback)(async () => {
+        if (!cropEditorDocument) {
+            return;
+        }
+        const documentPath = cropEditorDocument.path;
+        const rectangle = cropEditorRectangle ??
+            cropEditorDocument.rectangle ??
+            (cropEditorDocument.quad && cropEditorDocument.quad.length === 4
+                ? (0, coordinate_1.quadToRectangle)(cropEditorDocument.quad)
+                : null);
+        if (!rectangle || !pdfScannerManager?.processImage) {
+            closeAndroidCropEditor();
+            await openCropper(documentPath, { waitForPickerDismissal: false });
+            return;
+        }
+        setProcessing(true);
+        try {
+            const payload = await pdfScannerManager.processImage({
+                imagePath: documentPath,
+                rectangleCoordinates: rectangle,
+                rectangleWidth: cropEditorDocument.width ?? 0,
+                rectangleHeight: cropEditorDocument.height ?? 0,
+                useBase64: false,
+                quality: 90,
+                brightness: 0,
+                contrast: 1,
+                saturation: 1,
+                saveInAppDocument: false,
+            });
+            const croppedPath = typeof payload?.croppedImage === 'string' ? stripFileUri(payload.croppedImage) : null;
+            if (!croppedPath) {
+                throw new Error('missing_cropped_image');
+            }
+            const preview = await preparePreviewImage({ path: croppedPath });
+            setCroppedImageData(preview);
+        }
+        catch (error) {
+            console.error('[FullDocScanner] Crop editor processing failed:', error);
+            resetScannerView({ remount: true });
+            emitError(error instanceof Error ? error : new Error(String(error)), 'Failed to crop image. Please try again.');
+        }
+        finally {
+            setProcessing(false);
+            closeAndroidCropEditor();
+        }
+    }, [
+        closeAndroidCropEditor,
+        cropEditorDocument,
+        cropEditorRectangle,
+        emitError,
+        openCropper,
+        pdfScannerManager,
+        preparePreviewImage,
+        resetScannerView,
+    ]);
+    const handleCropEditorCancel = (0, react_1.useCallback)(() => {
+        resetScannerView({ remount: true });
+    }, [resetScannerView]);
     const handleCapture = (0, react_1.useCallback)(async (document) => {
         console.log('[FullDocScanner] handleCapture called:', {
             origin: document.origin,
@@ -332,6 +419,15 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             return;
         }
         const normalizedDoc = normalizeCapturedDocument(document);
+        const shouldOpenAndroidCropEditor = isAndroidCropEditorAvailable &&
+            captureMode === 'grid' &&
+            Boolean(normalizedDoc.rectangle ||
+                (normalizedDoc.quad && normalizedDoc.quad.length === 4));
+        if (shouldOpenAndroidCropEditor) {
+            console.log('[FullDocScanner] Opening Android crop editor with detected rectangle');
+            openAndroidCropEditor(normalizedDoc);
+            return;
+        }
         if (captureMode === 'no-grid') {
             console.log('[FullDocScanner] No grid at capture button press: opening cropper for manual selection');
             await openCropper(normalizedDoc.path, { waitForPickerDismissal: false });
@@ -358,7 +454,14 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
         }
         console.log('[FullDocScanner] Fallback to manual crop (no croppedPath available)');
         await openCropper(normalizedDoc.path, { waitForPickerDismissal: false });
-    }, [emitError, openCropper, preparePreviewImage, resetScannerView]);
+    }, [
+        emitError,
+        isAndroidCropEditorAvailable,
+        openAndroidCropEditor,
+        openCropper,
+        preparePreviewImage,
+        resetScannerView,
+    ]);
     const triggerManualCapture = (0, react_1.useCallback)(() => {
         const scannerInstance = docScannerRef.current;
         const hasScanner = !!scannerInstance;
@@ -371,7 +474,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;
         }
@@ -388,7 +491,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
@@ -420,7 +523,7 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
                 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) {
@@ -601,6 +704,11 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             clearTimeout(captureReadyTimeoutRef.current);
         }
     }, []);
+    (0, react_1.useEffect)(() => {
+        if (usesAndroidScannerActivity) {
+            setCaptureReady(true);
+        }
+    }, [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" })),
@@ -649,6 +757,12 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
                 react_1.default.createElement(react_native_1.TouchableOpacity, { style: [styles.confirmButton, styles.retakeButton], onPress: handleRetake, accessibilityLabel: mergedStrings.retake, accessibilityRole: "button" },
                     react_1.default.createElement(react_native_1.Text, { style: styles.confirmButtonText }, mergedStrings.retake)),
                 react_1.default.createElement(react_native_1.TouchableOpacity, { style: [styles.confirmButton, styles.confirmButtonPrimary], onPress: handleConfirm, accessibilityLabel: mergedStrings.confirm, accessibilityRole: "button" },
+                    react_1.default.createElement(react_native_1.Text, { style: styles.confirmButtonText }, mergedStrings.confirm))))) : cropEditorDocument && CropEditor ? (react_1.default.createElement(react_native_1.View, { style: styles.flex },
+            react_1.default.createElement(CropEditor, { document: cropEditorDocument, enableEditor: true, autoCrop: false, onCropChange: setCropEditorRectangle }),
+            react_1.default.createElement(react_native_1.View, { style: styles.confirmationButtons },
+                react_1.default.createElement(react_native_1.TouchableOpacity, { style: [styles.confirmButton, styles.retakeButton], onPress: handleCropEditorCancel, accessibilityLabel: mergedStrings.retake, accessibilityRole: "button", disabled: processing },
+                    react_1.default.createElement(react_native_1.Text, { style: styles.confirmButtonText }, mergedStrings.retake)),
+                react_1.default.createElement(react_native_1.TouchableOpacity, { style: [styles.confirmButton, styles.confirmButtonPrimary], onPress: handleCropEditorConfirm, accessibilityLabel: mergedStrings.confirm, accessibilityRole: "button", disabled: processing },
                     react_1.default.createElement(react_native_1.Text, { style: styles.confirmButtonText }, mergedStrings.confirm))))) : (react_1.default.createElement(react_native_1.View, { style: styles.flex },
             react_1.default.createElement(DocScanner_1.DocScanner, { key: scannerSession, ref: docScannerRef, autoCapture: false, overlayColor: overlayColor, showGrid: showGrid, gridColor: resolvedGridColor, gridLineWidth: gridLineWidth, minStableFrames: minStableFrames ?? 6, detectionConfig: detectionConfig, onCapture: handleCapture, onRectangleDetect: handleRectangleDetect, showManualCaptureButton: false, enableTorch: flashEnabled },
                 react_1.default.createElement(react_native_1.View, { style: styles.overlayTop, pointerEvents: "box-none" },
@@ -675,11 +789,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.9.0",
+  "version": "15.0.0",
   "description": "Native-backed document scanner for React Native with customizable overlays.",
   "license": "MIT",
   "main": "dist/index.js",

package/src/CropEditor.tsx

@@ -26,6 +26,8 @@ interface CropEditorProps {
   overlayStrokeColor?: string;
   handlerColor?: string;
   enablePanStrict?: boolean;
+  enableEditor?: boolean;
+  autoCrop?: boolean;
   onCropChange?: (rectangle: Rectangle) => void;
 }
 
@@ -48,6 +50,8 @@ export const CropEditor: React.FC<CropEditorProps> = ({
   overlayStrokeColor = '#e7a649',
   handlerColor = '#e7a649',
   enablePanStrict = false,
+  enableEditor = false,
+  autoCrop = true,
   onCropChange,
 }) => {
   const [imageSize, setImageSize] = useState<{ width: number; height: number } | null>(null);
@@ -59,38 +63,6 @@ export const CropEditor: React.FC<CropEditorProps> = ({
   const [loadError, setLoadError] = useState<string | null>(null);
   const [croppedImageUri, setCroppedImageUri] = useState<string | null>(null);
 
-  useEffect(() => {
-    console.log('[CropEditor] Document path:', document.path);
-    console.log('[CropEditor] Document dimensions:', document.width, 'x', document.height);
-    console.log('[CropEditor] Document quad:', document.quad);
-    console.log('[CropEditor] Document rectangle:', document.rectangle);
-
-    // Load image size using Image.getSize
-    const imageUri = document.path.startsWith('file://') ? document.path : `file://${document.path}`;
-    Image.getSize(
-      imageUri,
-      (width, height) => {
-        console.log('[CropEditor] Image.getSize success:', { width, height });
-        setImageSize({ width, height });
-
-        // If we have a rectangle (from auto-capture), crop the image
-        if (document.rectangle || document.quad) {
-          cropImageToRectangle(imageUri, width, height);
-        } else {
-          setIsImageLoading(false);
-          setLoadError(null);
-        }
-      },
-      (error) => {
-        console.error('[CropEditor] Image.getSize error:', error);
-        // Fallback to document dimensions
-        console.log('[CropEditor] Using fallback dimensions:', document.width, 'x', document.height);
-        setImageSize({ width: document.width, height: document.height });
-        setIsImageLoading(false);
-      }
-    );
-  }, [document]);
-
   const cropImageToRectangle = useCallback((imageUri: string, width: number, height: number) => {
     const cropManager = NativeModules.CustomCropManager as CustomCropManagerType | undefined;
 
@@ -145,6 +117,40 @@ export const CropEditor: React.FC<CropEditorProps> = ({
     );
   }, [document]);
 
+  useEffect(() => {
+    console.log('[CropEditor] Document path:', document.path);
+    console.log('[CropEditor] Document dimensions:', document.width, 'x', document.height);
+    console.log('[CropEditor] Document quad:', document.quad);
+    console.log('[CropEditor] Document rectangle:', document.rectangle);
+
+    const shouldAutoCrop = autoCrop && !enableEditor;
+
+    // Load image size using Image.getSize
+    const imageUri = document.path.startsWith('file://') ? document.path : `file://${document.path}`;
+    Image.getSize(
+      imageUri,
+      (width, height) => {
+        console.log('[CropEditor] Image.getSize success:', { width, height });
+        setImageSize({ width, height });
+
+        // If we have a rectangle (from auto-capture), crop the image
+        if (shouldAutoCrop && (document.rectangle || document.quad)) {
+          cropImageToRectangle(imageUri, width, height);
+        } else {
+          setIsImageLoading(false);
+          setLoadError(null);
+        }
+      },
+      (error) => {
+        console.error('[CropEditor] Image.getSize error:', error);
+        // Fallback to document dimensions
+        console.log('[CropEditor] Using fallback dimensions:', document.width, 'x', document.height);
+        setImageSize({ width: document.width, height: document.height });
+        setIsImageLoading(false);
+      }
+    );
+  }, [autoCrop, cropImageToRectangle, document, enableEditor]);
+
   // Get initial rectangle from detected quad or use default
   const getInitialRectangle = useCallback((): CropperRectangle | undefined => {
     if (!imageSize) {
@@ -226,6 +232,18 @@ export const CropEditor: React.FC<CropEditorProps> = ({
           <ActivityIndicator size="large" color={handlerColor} />
           <Text style={styles.loadingText}>Loading image...</Text>
         </View>
+      ) : enableEditor ? (
+        <CustomImageCropper
+          height={displaySize.height}
+          width={displaySize.width}
+          image={imageUri}
+          rectangleCoordinates={initialRect}
+          overlayColor={overlayColor}
+          overlayStrokeColor={overlayStrokeColor}
+          handlerColor={handlerColor}
+          enablePanStrict={enablePanStrict}
+          onDragEnd={handleDragEnd}
+        />
       ) : (
         <>
           {/* Show cropped image if available, otherwise show original */}
@@ -236,18 +254,6 @@ export const CropEditor: React.FC<CropEditorProps> = ({
             onLoad={() => console.log('[CropEditor] Image loaded successfully', croppedImageUri ? 'cropped' : 'original')}
             onError={(e) => console.error('[CropEditor] Image load error:', e.nativeEvent.error)}
           />
-          {/* Temporarily disabled CustomImageCropper - showing image only */}
-          {/* <CustomImageCropper
-            height={displaySize.height}
-            width={displaySize.width}
-            image={imageUri}
-            rectangleCoordinates={initialRect}
-            overlayColor={overlayColor}
-            overlayStrokeColor={overlayStrokeColor}
-            handlerColor={handlerColor}
-            enablePanStrict={enablePanStrict}
-            onDragEnd={handleDragEnd}
-          /> */}
         </>
       )}
     </View>

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

@@ -16,7 +16,8 @@ import { launchImageLibrary } from 'react-native-image-picker';
 import ImageCropPicker from 'react-native-image-crop-picker';
 import RNFS from 'react-native-fs';
 import { DocScanner } from './DocScanner';
-import type { CapturedDocument } from './types';
+import type { CapturedDocument, Rectangle } from './types';
+import { quadToRectangle } from './utils/coordinate';
 import type {
   DetectionConfig,
   DocScannerHandle,
@@ -41,6 +42,25 @@ const ensureFileUri = (value?: string | null) => {
   return value;
 };
 
+const safeRequire = (moduleName: string) => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(moduleName);
+  } catch {
+    return null;
+  }
+};
+
+const CropEditorModule = safeRequire('./CropEditor');
+const CropEditor = CropEditorModule?.CropEditor as
+  | React.ComponentType<{
+      document: CapturedDocument;
+      enableEditor?: boolean;
+      autoCrop?: boolean;
+      onCropChange?: (rectangle: Rectangle) => void;
+    }>
+  | undefined;
+
 const CROPPER_TIMEOUT_MS = 8000;
 const CROPPER_TIMEOUT_CODE = 'cropper_timeout';
 
@@ -198,6 +218,8 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
   const [capturedPhotos, setCapturedPhotos] = useState<FullDocScannerResult[]>([]);
   const [currentPhotoIndex, setCurrentPhotoIndex] = useState(0);
   const [scannerSession, setScannerSession] = useState(0);
+  const [cropEditorDocument, setCropEditorDocument] = useState<CapturedDocument | null>(null);
+  const [cropEditorRectangle, setCropEditorRectangle] = useState<Rectangle | null>(null);
   const resolvedGridColor = gridColor ?? overlayColor;
   const docScannerRef = useRef<DocScannerHandle | null>(null);
   const captureModeRef = useRef<'grid' | 'no-grid' | null>(null);
@@ -207,15 +229,21 @@ 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 }) => {
       setProcessing(false);
       setCroppedImageData(null);
+      setCropEditorDocument(null);
+      setCropEditorRectangle(null);
       setRotationDegrees(0);
       setRectangleDetected(false);
       setRectangleHint(false);
-      setCaptureReady(false);
+      setCaptureReady(usesAndroidScannerActivity ? true : false);
       captureModeRef.current = null;
       captureInProgressRef.current = false;
 
@@ -241,7 +269,7 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
         setScannerSession((prev) => prev + 1);
       }
     },
-    [],
+    [usesAndroidScannerActivity],
   );
 
   const mergedStrings = useMemo(
@@ -263,8 +291,6 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
     [strings],
   );
 
-  const pdfScannerManager = (NativeModules as any)?.RNPdfScannerManager;
-
   const autoEnhancementEnabled = useMemo(
     () => typeof pdfScannerManager?.applyColorControls === 'function',
     [pdfScannerManager],
@@ -353,6 +379,20 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
     [onError],
   );
 
+  const openAndroidCropEditor = useCallback((document: CapturedDocument) => {
+    const rectangle =
+      document.rectangle ??
+      (document.quad && document.quad.length === 4 ? quadToRectangle(document.quad) : null);
+    const documentForEditor = rectangle ? { ...document, rectangle } : document;
+    setCropEditorDocument(documentForEditor);
+    setCropEditorRectangle(rectangle);
+  }, []);
+
+  const closeAndroidCropEditor = useCallback(() => {
+    setCropEditorDocument(null);
+    setCropEditorRectangle(null);
+  }, []);
+
   const openCropper = useCallback(
     async (imagePath: string, options?: OpenCropperOptions) => {
       try {
@@ -446,6 +486,76 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
     [cropWidth, cropHeight, emitError, preparePreviewImage, resetScannerView],
   );
 
+  const handleCropEditorConfirm = useCallback(async () => {
+    if (!cropEditorDocument) {
+      return;
+    }
+
+    const documentPath = cropEditorDocument.path;
+
+    const rectangle =
+      cropEditorRectangle ??
+      cropEditorDocument.rectangle ??
+      (cropEditorDocument.quad && cropEditorDocument.quad.length === 4
+        ? quadToRectangle(cropEditorDocument.quad)
+        : null);
+
+    if (!rectangle || !pdfScannerManager?.processImage) {
+      closeAndroidCropEditor();
+      await openCropper(documentPath, { waitForPickerDismissal: false });
+      return;
+    }
+
+    setProcessing(true);
+    try {
+      const payload = await pdfScannerManager.processImage({
+        imagePath: documentPath,
+        rectangleCoordinates: rectangle,
+        rectangleWidth: cropEditorDocument.width ?? 0,
+        rectangleHeight: cropEditorDocument.height ?? 0,
+        useBase64: false,
+        quality: 90,
+        brightness: 0,
+        contrast: 1,
+        saturation: 1,
+        saveInAppDocument: false,
+      });
+
+      const croppedPath =
+        typeof payload?.croppedImage === 'string' ? stripFileUri(payload.croppedImage) : null;
+
+      if (!croppedPath) {
+        throw new Error('missing_cropped_image');
+      }
+
+      const preview = await preparePreviewImage({ path: croppedPath });
+      setCroppedImageData(preview);
+    } catch (error) {
+      console.error('[FullDocScanner] Crop editor processing failed:', error);
+      resetScannerView({ remount: true });
+      emitError(
+        error instanceof Error ? error : new Error(String(error)),
+        'Failed to crop image. Please try again.',
+      );
+    } finally {
+      setProcessing(false);
+      closeAndroidCropEditor();
+    }
+  }, [
+    closeAndroidCropEditor,
+    cropEditorDocument,
+    cropEditorRectangle,
+    emitError,
+    openCropper,
+    pdfScannerManager,
+    preparePreviewImage,
+    resetScannerView,
+  ]);
+
+  const handleCropEditorCancel = useCallback(() => {
+    resetScannerView({ remount: true });
+  }, [resetScannerView]);
+
   const handleCapture = useCallback(
     async (document: DocScannerCapture) => {
       console.log('[FullDocScanner] handleCapture called:', {
@@ -470,6 +580,20 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
 
       const normalizedDoc = normalizeCapturedDocument(document);
 
+      const shouldOpenAndroidCropEditor =
+        isAndroidCropEditorAvailable &&
+        captureMode === 'grid' &&
+        Boolean(
+          normalizedDoc.rectangle ||
+            (normalizedDoc.quad && normalizedDoc.quad.length === 4),
+        );
+
+      if (shouldOpenAndroidCropEditor) {
+        console.log('[FullDocScanner] Opening Android crop editor with detected rectangle');
+        openAndroidCropEditor(normalizedDoc);
+        return;
+      }
+
       if (captureMode === 'no-grid') {
         console.log('[FullDocScanner] No grid at capture button press: opening cropper for manual selection');
         await openCropper(normalizedDoc.path, { waitForPickerDismissal: false });
@@ -501,7 +625,14 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
       console.log('[FullDocScanner] Fallback to manual crop (no croppedPath available)');
       await openCropper(normalizedDoc.path, { waitForPickerDismissal: false });
     },
-    [emitError, openCropper, preparePreviewImage, resetScannerView],
+    [
+      emitError,
+      isAndroidCropEditorAvailable,
+      openAndroidCropEditor,
+      openCropper,
+      preparePreviewImage,
+      resetScannerView,
+    ],
   );
 
   const triggerManualCapture = useCallback(() => {
@@ -517,7 +648,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;
     }
@@ -539,7 +670,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;
 
@@ -580,7 +711,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');
@@ -804,6 +935,12 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
     [],
   );
 
+  useEffect(() => {
+    if (usesAndroidScannerActivity) {
+      setCaptureReady(true);
+    }
+  }, [usesAndroidScannerActivity]);
+
   const activePreviewImage = croppedImageData ? getActivePreviewImage(croppedImageData) : null;
 
   return (
@@ -949,6 +1086,36 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
             </TouchableOpacity>
           </View>
         </View>
+      ) : cropEditorDocument && CropEditor ? (
+        <View style={styles.flex}>
+          <CropEditor
+            document={cropEditorDocument}
+            enableEditor
+            autoCrop={false}
+            onCropChange={setCropEditorRectangle}
+          />
+          <View style={styles.confirmationButtons}>
+            <TouchableOpacity
+              style={[styles.confirmButton, styles.retakeButton]}
+              onPress={handleCropEditorCancel}
+              accessibilityLabel={mergedStrings.retake}
+              accessibilityRole="button"
+              disabled={processing}
+            >
+              <Text style={styles.confirmButtonText}>{mergedStrings.retake}</Text>
+            </TouchableOpacity>
+
+            <TouchableOpacity
+              style={[styles.confirmButton, styles.confirmButtonPrimary]}
+              onPress={handleCropEditorConfirm}
+              accessibilityLabel={mergedStrings.confirm}
+              accessibilityRole="button"
+              disabled={processing}
+            >
+              <Text style={styles.confirmButtonText}>{mergedStrings.confirm}</Text>
+            </TouchableOpacity>
+          </View>
+        </View>
       ) : (
         <View style={styles.flex}>
           <DocScanner
@@ -1035,16 +1202,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} />