react-native-rectangle-doc-scanner 3.136.0 → 3.138.0

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

@@ -1,6 +1,7 @@
 package com.reactnativerectangledocscanner
 
 import android.content.Context
+import android.graphics.ImageFormat
 import android.util.Log
 import android.util.Size
 import androidx.camera.core.*
@@ -26,7 +27,7 @@ class CameraController(
     private var useFrontCamera = false
     private var torchEnabled = false
 
-    var onFrameAnalyzed: ((Rectangle?) -> Unit)? = null
+    var onFrameAnalyzed: ((Rectangle?, Int, Int) -> Unit)? = null
 
     companion object {
         private const val TAG = "CameraController"
@@ -93,6 +94,7 @@ class CameraController(
             ImageAnalysis.Builder()
                 .setTargetResolution(Size(720, 1280))
                 .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+                .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888)
                 .build()
                 .also { analysis ->
                     analysis.setAnalyzer(cameraExecutor) { imageProxy ->
@@ -135,20 +137,98 @@ class CameraController(
      */
     private fun analyzeFrame(imageProxy: ImageProxy) {
         try {
-            val buffer = imageProxy.planes[0].buffer
-            val bytes = ByteArray(buffer.remaining())
-            buffer.get(bytes)
+            val rotationDegrees = imageProxy.imageInfo.rotationDegrees
+            val frameWidth = if (rotationDegrees == 90 || rotationDegrees == 270) {
+                imageProxy.height
+            } else {
+                imageProxy.width
+            }
+            val frameHeight = if (rotationDegrees == 90 || rotationDegrees == 270) {
+                imageProxy.width
+            } else {
+                imageProxy.height
+            }
+
+            if (imageProxy.format != ImageFormat.YUV_420_888 || imageProxy.planes.size < 3) {
+                onFrameAnalyzed?.invoke(null, frameWidth, frameHeight)
+                return
+            }
+
+            val nv21 = imageProxyToNV21(imageProxy)
+            val rectangle = DocumentDetector.detectRectangleInYUV(
+                nv21,
+                imageProxy.width,
+                imageProxy.height,
+                rotationDegrees
+            )
 
-            // Note: Simplified - in production you'd convert ImageProxy to proper format
-            // For now, we'll skip real-time detection in the analyzer and do it on capture
-            onFrameAnalyzed?.invoke(null)
+            onFrameAnalyzed?.invoke(rectangle, frameWidth, frameHeight)
         } catch (e: Exception) {
             Log.e(TAG, "Error analyzing frame", e)
+            val rotationDegrees = imageProxy.imageInfo.rotationDegrees
+            val frameWidth = if (rotationDegrees == 90 || rotationDegrees == 270) {
+                imageProxy.height
+            } else {
+                imageProxy.width
+            }
+            val frameHeight = if (rotationDegrees == 90 || rotationDegrees == 270) {
+                imageProxy.width
+            } else {
+                imageProxy.height
+            }
+            onFrameAnalyzed?.invoke(null, frameWidth, frameHeight)
         } finally {
             imageProxy.close()
         }
     }
 
+    /**
+     * Convert ImageProxy (YUV_420_888) to NV21 byte array
+     */
+    private fun imageProxyToNV21(image: ImageProxy): ByteArray {
+        val width = image.width
+        val height = image.height
+
+        val ySize = width * height
+        val uvSize = width * height / 2
+        val nv21 = ByteArray(ySize + uvSize)
+
+        val yBuffer = image.planes[0].buffer
+        val uBuffer = image.planes[1].buffer
+        val vBuffer = image.planes[2].buffer
+
+        val yRowStride = image.planes[0].rowStride
+        val yPixelStride = image.planes[0].pixelStride
+        var outputOffset = 0
+        for (row in 0 until height) {
+            var inputOffset = row * yRowStride
+            for (col in 0 until width) {
+                nv21[outputOffset++] = yBuffer.get(inputOffset)
+                inputOffset += yPixelStride
+            }
+        }
+
+        val uvRowStride = image.planes[1].rowStride
+        val uvPixelStride = image.planes[1].pixelStride
+        val vRowStride = image.planes[2].rowStride
+        val vPixelStride = image.planes[2].pixelStride
+
+        val uvHeight = height / 2
+        val uvWidth = width / 2
+        for (row in 0 until uvHeight) {
+            var uInputOffset = row * uvRowStride
+            var vInputOffset = row * vRowStride
+            for (col in 0 until uvWidth) {
+                nv21[outputOffset++] = vBuffer.get(vInputOffset)
+                nv21[outputOffset++] = uBuffer.get(uInputOffset)
+                uInputOffset += uvPixelStride
+                vInputOffset += vPixelStride
+            }
+        }
+
+        return nv21
+    }
+
     /**
      * Capture photo
      */

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

@@ -7,9 +7,6 @@ import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.PorterDuff
 import android.graphics.PorterDuffXfermode
-import android.os.Handler
-import android.os.Looper
-import android.util.Base64
 import android.util.Log
 import android.view.View
 import android.widget.FrameLayout
@@ -21,7 +18,7 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import kotlinx.coroutines.*
 import java.io.File
-import kotlin.math.max
+import kotlin.math.min
 
 class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context) {
     private val themedContext = context
@@ -46,10 +43,7 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context) {
 
     // State
     private var stableCounter = 0
-    private var lastDetectedRectangle: Rectangle? = null
-    private var lastDetectionQuality: RectangleQuality = RectangleQuality.TOO_FAR
-    private val detectionHandler = Handler(Looper.getMainLooper())
-    private var detectionRunnable: Runnable? = null
+    private var lastDetectionTimestamp: Long = 0L
     private var isCapturing = false
 
     // Coroutine scope for async operations
@@ -85,10 +79,11 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context) {
             }
 
             cameraController = CameraController(context, lifecycleOwner, previewView)
-            cameraController?.startCamera(useFrontCam, !manualOnly)
-
-            // Start detection loop
-            startDetectionLoop()
+            cameraController?.onFrameAnalyzed = { rectangle, imageWidth, imageHeight ->
+                handleDetectionResult(rectangle, imageWidth, imageHeight)
+            }
+            lastDetectionTimestamp = 0L
+            cameraController?.startCamera(useFrontCam, true)
 
             Log.d(TAG, "Camera setup completed")
         } catch (e: Exception) {
@@ -96,56 +91,66 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context) {
         }
     }
 
-    private fun startDetectionLoop() {
-        detectionRunnable?.let { detectionHandler.removeCallbacks(it) }
-
-        detectionRunnable = object : Runnable {
-            override fun run() {
-                // Perform detection
-                performDetection()
+    private fun handleDetectionResult(rectangle: Rectangle?, imageWidth: Int, imageHeight: Int) {
+        val now = System.currentTimeMillis()
+        if (now - lastDetectionTimestamp < detectionRefreshRateInMS) {
+            return
+        }
+        lastDetectionTimestamp = now
 
-                // Schedule next detection
-                detectionHandler.postDelayed(this, detectionRefreshRateInMS.toLong())
-            }
+        val quality = if (rectangle != null) {
+            DocumentDetector.evaluateRectangleQuality(rectangle, imageWidth, imageHeight)
+        } else {
+            RectangleQuality.TOO_FAR
         }
 
-        detectionHandler.post(detectionRunnable!!)
-    }
+        val rectangleOnScreen = if (rectangle != null && width > 0 && height > 0) {
+            DocumentDetector.transformRectangleToViewCoordinates(rectangle, imageWidth, imageHeight, width, height)
+        } else {
+            null
+        }
 
-    private fun performDetection() {
-        // In a real implementation, we'd analyze the camera frames
-        // For now, we'll simulate detection based on capture
-        // The actual detection happens during capture in this simplified version
+        post {
+            onRectangleDetected(rectangleOnScreen, rectangle, quality, imageWidth, imageHeight)
+        }
     }
 
-    private fun onRectangleDetected(rectangle: Rectangle?, quality: RectangleQuality) {
-        lastDetectedRectangle = rectangle
-        lastDetectionQuality = quality
-
+    private fun onRectangleDetected(
+        rectangleOnScreen: Rectangle?,
+        rectangleCoordinates: Rectangle?,
+        quality: RectangleQuality,
+        imageWidth: Int,
+        imageHeight: Int
+    ) {
         // Update overlay
-        overlayView.setRectangle(rectangle, overlayColor)
+        overlayView.setRectangle(rectangleOnScreen, overlayColor)
 
         // Update stable counter based on quality
-        when (quality) {
-            RectangleQuality.GOOD -> {
-                if (rectangle != null) {
-                    stableCounter++
+        if (rectangleCoordinates == null) {
+            if (stableCounter != 0) {
+                Log.d(TAG, "Rectangle lost, resetting stableCounter")
+            }
+            stableCounter = 0
+        } else {
+            when (quality) {
+                RectangleQuality.GOOD -> {
+                    stableCounter = min(stableCounter + 1, detectionCountBeforeCapture)
                     Log.d(TAG, "Good rectangle detected, stableCounter: $stableCounter/$detectionCountBeforeCapture")
                 }
-            }
-            RectangleQuality.BAD_ANGLE, RectangleQuality.TOO_FAR -> {
-                if (stableCounter > 0) {
-                    stableCounter--
+                RectangleQuality.BAD_ANGLE, RectangleQuality.TOO_FAR -> {
+                    if (stableCounter > 0) {
+                        stableCounter--
+                    }
+                    Log.d(TAG, "Bad rectangle detected (type: $quality), stableCounter: $stableCounter")
                 }
-                Log.d(TAG, "Bad rectangle detected (type: $quality), stableCounter: $stableCounter")
             }
         }
 
         // Send event to JavaScript
-        sendRectangleDetectEvent(rectangle, quality)
+        sendRectangleDetectEvent(rectangleOnScreen, rectangleCoordinates, quality, imageWidth, imageHeight)
 
         // Auto-capture if threshold reached
-        if (!manualOnly && stableCounter >= detectionCountBeforeCapture && rectangle != null) {
+        if (!manualOnly && rectangleCoordinates != null && stableCounter >= detectionCountBeforeCapture) {
             Log.d(TAG, "Auto-capture triggered! stableCounter: $stableCounter >= threshold: $detectionCountBeforeCapture")
             stableCounter = 0
             capture()
@@ -278,15 +283,26 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context) {
             .receiveEvent(id, "onPictureTaken", event)
     }
 
-    private fun sendRectangleDetectEvent(rectangle: Rectangle?, quality: RectangleQuality) {
+    private fun sendRectangleDetectEvent(
+        rectangleOnScreen: Rectangle?,
+        rectangleCoordinates: Rectangle?,
+        quality: RectangleQuality,
+        imageWidth: Int,
+        imageHeight: Int
+    ) {
         val event = Arguments.createMap().apply {
             putInt("stableCounter", stableCounter)
             putInt("lastDetectionType", quality.ordinal)
-            putMap("rectangleCoordinates", rectangle?.toMap()?.toWritableMap())
+            putMap("rectangleCoordinates", rectangleCoordinates?.toMap()?.toWritableMap())
+            putMap("rectangleOnScreen", rectangleOnScreen?.toMap()?.toWritableMap())
             putMap("previewSize", Arguments.createMap().apply {
                 putInt("width", width)
                 putInt("height", height)
             })
+            putMap("imageSize", Arguments.createMap().apply {
+                putInt("width", imageWidth)
+                putInt("height", imageHeight)
+            })
         }
         themedContext.getJSModule(RCTEventEmitter::class.java)
             .receiveEvent(id, "onRectangleDetect", event)
@@ -314,13 +330,17 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context) {
     }
 
     fun startCamera() {
-        cameraController?.startCamera(useFrontCam, !manualOnly)
-        startDetectionLoop()
+        lastDetectionTimestamp = 0L
+        cameraController?.onFrameAnalyzed = { rectangle, imageWidth, imageHeight ->
+            handleDetectionResult(rectangle, imageWidth, imageHeight)
+        }
+        cameraController?.startCamera(useFrontCam, true)
     }
 
     fun stopCamera() {
-        detectionRunnable?.let { detectionHandler.removeCallbacks(it) }
         cameraController?.stopCamera()
+        overlayView.setRectangle(null, overlayColor)
+        stableCounter = 0
     }
 
     override fun onDetachedFromWindow() {

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

@@ -125,7 +125,8 @@ object ImageProcessor {
         val dstMat = Mat()
         srcMat.convertTo(dstMat, -1, contrast.toDouble(), brightness * 255.0)
 
-        val resultBitmap = Bitmap.createBitmap(bitmap.width, bitmap.height, bitmap.config)
+        val safeConfig = bitmap.config ?: Bitmap.Config.ARGB_8888
+        val resultBitmap = Bitmap.createBitmap(bitmap.width, bitmap.height, safeConfig)
         Utils.matToBitmap(dstMat, resultBitmap)
 
         srcMat.release()

package/package.json

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