react-native-rectangle-doc-scanner 3.221.0 → 3.223.0

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

@@ -15,6 +15,8 @@ import androidx.camera.core.AspectRatio
 import androidx.camera.core.Camera
 import androidx.camera.core.CameraSelector
 import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageCapture
+import androidx.camera.core.ImageCaptureException
 import androidx.camera.core.Preview
 import androidx.camera.lifecycle.ProcessCameraProvider
 import androidx.camera.view.PreviewView
@@ -37,6 +39,7 @@ class CameraController(
     private var cameraProvider: ProcessCameraProvider? = null
     private var preview: Preview? = null
     private var imageAnalysis: ImageAnalysis? = null
+    private var imageCapture: ImageCapture? = null
     private var camera: Camera? = null
     private val cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
     private val lastFrame = AtomicReference<LastFrame?>()
@@ -45,6 +48,18 @@ class CameraController(
     private var useFrontCamera = false
     private var detectionEnabled = true
 
+    // For periodic frame capture
+    private var isAnalysisActive = false
+    private val analysisHandler = android.os.Handler(android.os.Looper.getMainLooper())
+    private val analysisRunnable = object : Runnable {
+        override fun run() {
+            if (isAnalysisActive && onFrameAnalyzed != null) {
+                captureFrameForAnalysis()
+                analysisHandler.postDelayed(this, 200) // Capture every 200ms
+            }
+        }
+    }
+
     var onFrameAnalyzed: ((Rectangle?, Int, Int) -> Unit)? = null
 
     companion object {
@@ -63,12 +78,12 @@ class CameraController(
         useFrontCam: Boolean = false,
         enableDetection: Boolean = true
     ) {
-        Log.d(TAG, "[CAMERAX] startCamera called")
+        Log.d(TAG, "[CAMERAX-V6] startCamera called")
         this.useFrontCamera = useFrontCam
         this.detectionEnabled = enableDetection
 
         if (!hasCameraPermission()) {
-            Log.e(TAG, "[CAMERAX] Camera permission not granted")
+            Log.e(TAG, "[CAMERAX-V6] Camera permission not granted")
             return
         }
 
@@ -81,13 +96,15 @@ class CameraController(
                 cameraProvider = cameraProviderFuture?.get()
                 bindCameraUseCases()
             } catch (e: Exception) {
-                Log.e(TAG, "[CAMERAX] Failed to get camera provider", e)
+                Log.e(TAG, "[CAMERAX-V6] Failed to get camera provider", e)
             }
         }, ContextCompat.getMainExecutor(context))
     }
 
     fun stopCamera() {
-        Log.d(TAG, "[CAMERAX] stopCamera called")
+        Log.d(TAG, "[CAMERAX-V6] stopCamera called")
+        isAnalysisActive = false
+        analysisHandler.removeCallbacks(analysisRunnable)
         cameraProvider?.unbindAll()
         analysisBound = false
     }
@@ -119,10 +136,10 @@ class CameraController(
                 }
                 bitmap.recycle()
 
-                Log.d(TAG, "[CAMERAX] Photo capture succeeded: ${photoFile.absolutePath}")
+                Log.d(TAG, "[CAMERAX-V6] Photo capture succeeded: ${photoFile.absolutePath}")
                 onImageCaptured(photoFile)
             } catch (e: Exception) {
-                Log.e(TAG, "[CAMERAX] Photo capture failed", e)
+                Log.e(TAG, "[CAMERAX-V6] Photo capture failed", e)
                 onError(e)
             }
         }
@@ -154,17 +171,15 @@ class CameraController(
         val provider = cameraProvider ?: return
         provider.unbindAll()
         analysisBound = false
+        isAnalysisActive = false
 
         val rotation = previewView.display?.rotation ?: Surface.ROTATION_0
 
-        // Build Preview ONLY first
+        // Build Preview ONLY - this device cannot handle 2 simultaneous surfaces
         preview = Preview.Builder()
             .setTargetResolution(Size(1280, 720))
             .setTargetRotation(rotation)
             .build()
-            .also {
-                it.setSurfaceProvider(previewView.surfaceProvider)
-            }
 
         val cameraSelector = if (useFrontCamera) {
             CameraSelector.DEFAULT_FRONT_CAMERA
@@ -172,119 +187,128 @@ class CameraController(
             CameraSelector.DEFAULT_BACK_CAMERA
         }
 
-        // TEMPORARY: Bind Preview ONLY to test if Preview works without ImageAnalysis
+        // Bind Preview ONLY first
         try {
             camera = provider.bindToLifecycle(
                 lifecycleOwner,
                 cameraSelector,
                 preview
             )
-            Log.d(TAG, "[CAMERAX-DEBUG] Preview ONLY bound successfully - NO ImageAnalysis")
-            analysisBound = false
 
-            // TODO: If Preview works, we need to find alternative for document detection
-            // Options:
-            // 1. Use ImageCapture instead of ImageAnalysis
-            // 2. Use lower resolution for ImageAnalysis (already tried)
-            // 3. Use Camera2 API directly instead of CameraX
+            // Set surface provider AFTER binding
+            preview?.setSurfaceProvider(previewView.surfaceProvider)
+
+            Log.d(TAG, "[CAMERAX-V7] Preview ONLY bound successfully")
+
+            // Wait for preview to stabilize, then try adding ImageCapture
+            android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+                tryAddImageCapture(provider, cameraSelector, rotation)
+            }, 3000)
 
         } catch (e: Exception) {
-            Log.e(TAG, "[CAMERAX-DEBUG] Failed to bind preview", e)
-            analysisBound = false
+            Log.e(TAG, "[CAMERAX-V7] Failed to bind preview", e)
         }
     }
 
-    private fun bindImageAnalysis(provider: ProcessCameraProvider, cameraSelector: CameraSelector, rotation: Int) {
-        if (analysisBound) return
+    private fun tryAddImageCapture(provider: ProcessCameraProvider, cameraSelector: CameraSelector, rotation: Int) {
+        Log.d(TAG, "[CAMERAX-V7] Attempting to add ImageCapture...")
 
-        Log.d(TAG, "[CAMERAX-FIX-V5] Starting to add ImageAnalysis...")
+        // Build ImageCapture with minimal resolution
+        imageCapture = ImageCapture.Builder()
+            .setTargetResolution(Size(320, 240))
+            .setTargetRotation(rotation)
+            .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
+            .build()
 
         try {
-            // Build ImageAnalysis with very low resolution
-            imageAnalysis = ImageAnalysis.Builder()
-                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
-                .setTargetRotation(rotation)
-                .setTargetResolution(Size(480, 360))
-                .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888)
-                .build()
-                .also {
-                    it.setAnalyzer(cameraExecutor, DocumentAnalyzer())
-                }
-
-            // IMPORTANT: Unbind all first, then rebind together to avoid session reconfiguration timeout
+            // Unbind and rebind with both
             provider.unbindAll()
 
-            // Rebind BOTH at the same time
             camera = provider.bindToLifecycle(
                 lifecycleOwner,
                 cameraSelector,
                 preview,
-                imageAnalysis
+                imageCapture
             )
-            analysisBound = true
-            Log.d(TAG, "[CAMERAX-FIX-V5] ImageAnalysis added successfully after unbind/rebind")
+
+            preview?.setSurfaceProvider(previewView.surfaceProvider)
+
+            Log.d(TAG, "[CAMERAX-V7] ImageCapture added successfully")
+
+            // Start periodic frame capture
+            if (detectionEnabled) {
+                isAnalysisActive = true
+                analysisHandler.postDelayed(analysisRunnable, 500)
+                Log.d(TAG, "[CAMERAX-V7] Started periodic frame capture")
+            }
+
         } catch (e: Exception) {
-            Log.e(TAG, "[CAMERAX-FIX-V5] Failed to add ImageAnalysis", e)
-            analysisBound = false
+            Log.e(TAG, "[CAMERAX-V7] Failed to add ImageCapture, keeping Preview only", e)
 
-            // Fallback: rebind preview only
+            // Fallback: Keep preview only and disable detection
             try {
                 camera = provider.bindToLifecycle(
                     lifecycleOwner,
                     cameraSelector,
                     preview
                 )
-                Log.d(TAG, "[CAMERAX-FIX-V5] Fallback: Preview only")
+                preview?.setSurfaceProvider(previewView.surfaceProvider)
+                Log.d(TAG, "[CAMERAX-V7] Fallback: Preview only mode (detection disabled)")
             } catch (fallbackException: Exception) {
-                Log.e(TAG, "[CAMERAX-FIX-V5] Fallback also failed", fallbackException)
+                Log.e(TAG, "[CAMERAX-V7] Fallback failed", fallbackException)
             }
         }
     }
 
-    private inner class DocumentAnalyzer : ImageAnalysis.Analyzer {
-        override fun analyze(imageProxy: androidx.camera.core.ImageProxy) {
-            try {
-                val rotationDegrees = imageProxy.imageInfo.rotationDegrees
-                val nv21 = imageProxy.toNv21()
-                lastFrame.set(
-                    LastFrame(
-                        nv21,
-                        imageProxy.width,
-                        imageProxy.height,
-                        rotationDegrees,
-                        useFrontCamera
+    private fun captureFrameForAnalysis() {
+        val capture = imageCapture ?: return
+
+        capture.takePicture(cameraExecutor, object : ImageCapture.OnImageCapturedCallback() {
+            override fun onCaptureSuccess(image: androidx.camera.core.ImageProxy) {
+                try {
+                    val rotationDegrees = image.imageInfo.rotationDegrees
+                    val nv21 = image.toNv21()
+
+                    lastFrame.set(
+                        LastFrame(
+                            nv21,
+                            image.width,
+                            image.height,
+                            rotationDegrees,
+                            useFrontCamera
+                        )
                     )
-                )
 
-                val frameWidth = if (rotationDegrees == 90 || rotationDegrees == 270) {
-                    imageProxy.height
-                } else {
-                    imageProxy.width
-                }
+                    val frameWidth = if (rotationDegrees == 90 || rotationDegrees == 270) {
+                        image.height
+                    } else {
+                        image.width
+                    }
 
-                val frameHeight = if (rotationDegrees == 90 || rotationDegrees == 270) {
-                    imageProxy.width
-                } else {
-                    imageProxy.height
-                }
+                    val frameHeight = if (rotationDegrees == 90 || rotationDegrees == 270) {
+                        image.width
+                    } else {
+                        image.height
+                    }
 
-                if (detectionEnabled) {
                     val rectangle = DocumentDetector.detectRectangleInYUV(
                         nv21,
-                        imageProxy.width,
-                        imageProxy.height,
+                        image.width,
+                        image.height,
                         rotationDegrees
                     )
                     onFrameAnalyzed?.invoke(rectangle, frameWidth, frameHeight)
-                } else {
-                    onFrameAnalyzed?.invoke(null, frameWidth, frameHeight)
+                } catch (e: Exception) {
+                    Log.e(TAG, "[CAMERAX-V6] Error analyzing frame", e)
+                } finally {
+                    image.close()
                 }
-            } catch (e: Exception) {
-                Log.e(TAG, "[CAMERAX] Error analyzing frame", e)
-            } finally {
-                imageProxy.close()
             }
-        }
+
+            override fun onError(exception: ImageCaptureException) {
+                Log.e(TAG, "[CAMERAX-V6] Frame capture for analysis failed", exception)
+            }
+        })
     }
 
     private fun nv21ToJpeg(nv21: ByteArray, width: Int, height: Int, quality: Int): ByteArray {

package/package.json

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