react-native-rectangle-doc-scanner 3.210.0 → 3.211.0

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

@@ -3,164 +3,79 @@ package com.reactnativerectangledocscanner
 import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.graphics.ImageFormat
-import android.graphics.Matrix
-import android.graphics.Rect
-import android.graphics.RectF
-import android.graphics.SurfaceTexture
-import android.graphics.YuvImage
-import android.hardware.camera2.CameraCaptureSession
-import android.hardware.camera2.CameraCharacteristics
-import android.hardware.camera2.CameraDevice
-import android.hardware.camera2.CameraManager
-import android.hardware.camera2.CaptureRequest
-import android.media.Image
-import android.media.ImageReader
-import android.os.Handler
-import android.os.HandlerThread
 import android.util.Log
 import android.util.Size
-import android.view.Gravity
 import android.view.Surface
-import android.view.TextureView
+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
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.LifecycleOwner
-import java.io.ByteArrayOutputStream
+import com.google.common.util.concurrent.ListenableFuture
 import java.io.File
-import java.io.FileOutputStream
-import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
 
 class CameraController(
     private val context: Context,
     private val lifecycleOwner: LifecycleOwner,
-    private val previewView: TextureView
+    private val previewView: PreviewView
 ) {
-    private val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
-    private var cameraDevice: CameraDevice? = null
-    private var captureSession: CameraCaptureSession? = null
-    private var previewRequestBuilder: CaptureRequest.Builder? = null
-    private var imageReader: ImageReader? = null
-    private var backgroundThread: HandlerThread? = null
-    private var backgroundHandler: Handler? = null
-    private var previewLayoutListener: android.view.View.OnLayoutChangeListener? = null
+    private var cameraProviderFuture: ListenableFuture<ProcessCameraProvider>? = null
+    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 var cameraId: String? = null
-    private var sensorOrientation: Int = 0
-    private var sensorAspectRatio: Float? = null
-    private var previewSize: Size? = null
-    private var analysisSize: Size? = null
-    private var previewChoices: Array<Size> = emptyArray()
-    private var analysisChoices: Array<Size> = emptyArray()
     private var useFrontCamera = false
-    private var torchEnabled = false
     private var detectionEnabled = true
-    private var hasStarted = false
-
-    private val isOpening = AtomicBoolean(false)
-    private val lastFrameLock = Any()
-    private var lastFrame: LastFrame? = null
 
     var onFrameAnalyzed: ((Rectangle?, Int, Int) -> Unit)? = null
 
     companion object {
         private const val TAG = "CameraController"
-        private const val MAX_ANALYSIS_WIDTH = 1280
-        private const val MAX_ANALYSIS_HEIGHT = 720
-    }
-
-    private data class LastFrame(
-        val nv21: ByteArray,
-        val width: Int,
-        val height: Int,
-        val rotationDegrees: Int,
-        val isFront: Boolean
-    )
-
-    private val textureListener = object : TextureView.SurfaceTextureListener {
-        override fun onSurfaceTextureAvailable(surface: SurfaceTexture, width: Int, height: Int) {
-            Log.d(TAG, "[CAMERA2] Texture available: ${width}x${height}")
-            createPreviewSession()
-        }
-
-        override fun onSurfaceTextureSizeChanged(surface: SurfaceTexture, width: Int, height: Int) {
-            Log.d(TAG, "[CAMERA2] Texture size changed: ${width}x${height}")
-            updatePreviewTransform()
-        }
-
-        override fun onSurfaceTextureDestroyed(surface: SurfaceTexture): Boolean {
-            Log.d(TAG, "[CAMERA2] Texture destroyed")
-            return true
-        }
-
-        override fun onSurfaceTextureUpdated(surface: SurfaceTexture) = Unit
+        private const val ANALYSIS_WIDTH = 1280
+        private const val ANALYSIS_HEIGHT = 720
     }
 
     fun startCamera(
         useFrontCam: Boolean = false,
         enableDetection: Boolean = true
     ) {
-        Log.d(TAG, "========================================")
-        Log.d(TAG, "[CAMERA2] startCamera called")
-        Log.d(TAG, "[CAMERA2] useFrontCam: $useFrontCam")
-        Log.d(TAG, "[CAMERA2] enableDetection: $enableDetection")
-        Log.d(TAG, "[CAMERA2] lifecycleOwner: $lifecycleOwner")
-        Log.d(TAG, "========================================")
-
+        Log.d(TAG, "[CAMERAX] startCamera called")
         this.useFrontCamera = useFrontCam
         this.detectionEnabled = enableDetection
 
-        if (hasStarted) {
-            Log.d(TAG, "[CAMERA2] Already started, skipping")
-            return
-        }
-        hasStarted = true
-
         if (!hasCameraPermission()) {
-            Log.e(TAG, "[CAMERA2] Camera permission not granted")
+            Log.e(TAG, "[CAMERAX] Camera permission not granted")
             return
         }
 
-        startBackgroundThread()
-        chooseCamera()
-
-        if (previewLayoutListener == null) {
-            previewLayoutListener = android.view.View.OnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
-                updatePreviewTransform()
-            }
-            previewView.addOnLayoutChangeListener(previewLayoutListener)
+        if (cameraProviderFuture == null) {
+            cameraProviderFuture = ProcessCameraProvider.getInstance(context)
         }
 
-        if (previewView.isAvailable) {
-            openCamera()
-        } else {
-            previewView.surfaceTextureListener = textureListener
-        }
+        cameraProviderFuture?.addListener({
+            try {
+                cameraProvider = cameraProviderFuture?.get()
+                bindCameraUseCases()
+            } catch (e: Exception) {
+                Log.e(TAG, "[CAMERAX] Failed to get camera provider", e)
+            }
+        }, ContextCompat.getMainExecutor(context))
     }
 
     fun stopCamera() {
-        Log.d(TAG, "[CAMERA2] stopCamera called")
-        previewLayoutListener?.let { listener ->
-            previewView.removeOnLayoutChangeListener(listener)
-        }
-        previewLayoutListener = null
-        try {
-            captureSession?.close()
-            captureSession = null
-        } catch (e: Exception) {
-            Log.w(TAG, "[CAMERA2] Failed to close session", e)
-        }
-        try {
-            cameraDevice?.close()
-            cameraDevice = null
-        } catch (e: Exception) {
-            Log.w(TAG, "[CAMERA2] Failed to close camera device", e)
-        }
-        imageReader?.close()
-        imageReader = null
-        stopBackgroundThread()
-        hasStarted = false
+        Log.d(TAG, "[CAMERAX] stopCamera called")
+        cameraProvider?.unbindAll()
     }
 
     fun capturePhoto(
@@ -168,556 +83,136 @@ class CameraController(
         onImageCaptured: (File) -> Unit,
         onError: (Exception) -> Unit
     ) {
-        val frame = synchronized(lastFrameLock) { lastFrame }
-        if (frame == null) {
-            onError(Exception("No frame available for capture"))
+        val capture = imageCapture
+        if (capture == null) {
+            onError(IllegalStateException("ImageCapture not initialized"))
             return
         }
 
-        backgroundHandler?.post {
-            try {
-                val photoFile = File(
-                    outputDirectory,
-                    "doc_scan_${System.currentTimeMillis()}.jpg"
-                )
+        val photoFile = File(outputDirectory, "doc_scan_${System.currentTimeMillis()}.jpg")
+        val outputOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()
 
-                val jpegBytes = nv21ToJpeg(frame.nv21, frame.width, frame.height, 95)
-                val bitmap = BitmapFactory.decodeByteArray(jpegBytes, 0, jpegBytes.size)
-                    ?: throw IllegalStateException("Failed to decode JPEG")
-
-                val rotated = rotateAndMirror(bitmap, frame.rotationDegrees, frame.isFront)
-                FileOutputStream(photoFile).use { out ->
-                    rotated.compress(Bitmap.CompressFormat.JPEG, 95, out)
-                }
-                if (rotated != bitmap) {
-                    rotated.recycle()
+        capture.takePicture(
+            outputOptions,
+            cameraExecutor,
+            object : ImageCapture.OnImageSavedCallback {
+                override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
+                    Log.d(TAG, "[CAMERAX] Photo capture succeeded: ${photoFile.absolutePath}")
+                    onImageCaptured(photoFile)
                 }
-                bitmap.recycle()
 
-                Log.d(TAG, "[CAMERA2] Photo capture succeeded: ${photoFile.absolutePath}")
-                onImageCaptured(photoFile)
-            } catch (e: Exception) {
-                Log.e(TAG, "[CAMERA2] Photo capture failed", e)
-                onError(e)
+                override fun onError(exception: ImageCaptureException) {
+                    Log.e(TAG, "[CAMERAX] Photo capture failed", exception)
+                    onError(exception)
+                }
             }
-        }
+        )
     }
 
     fun setTorchEnabled(enabled: Boolean) {
-        torchEnabled = enabled
-        val builder = previewRequestBuilder ?: return
-        builder.set(CaptureRequest.FLASH_MODE, if (enabled) CaptureRequest.FLASH_MODE_TORCH else CaptureRequest.FLASH_MODE_OFF)
-        try {
-            captureSession?.setRepeatingRequest(builder.build(), null, backgroundHandler)
-        } catch (e: Exception) {
-            Log.w(TAG, "[CAMERA2] Failed to update torch", e)
-        }
+        camera?.cameraControl?.enableTorch(enabled)
     }
 
     fun switchCamera() {
         useFrontCamera = !useFrontCamera
-        stopCamera()
-        startCamera(useFrontCamera, detectionEnabled)
+        bindCameraUseCases()
     }
 
     fun isTorchAvailable(): Boolean {
-        val id = cameraId ?: return false
-        val characteristics = cameraManager.getCameraCharacteristics(id)
-        return characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE) == true
+        return camera?.cameraInfo?.hasFlashUnit() == true
     }
 
     fun focusAt(x: Float, y: Float) {
-        // No-op for now. Camera2 focus metering can be added if needed.
+        // No-op for now.
     }
 
     fun shutdown() {
         stopCamera()
+        cameraExecutor.shutdown()
     }
 
-    private fun chooseCamera() {
-        val lensFacing = if (useFrontCamera) {
-            CameraCharacteristics.LENS_FACING_FRONT
-        } else {
-            CameraCharacteristics.LENS_FACING_BACK
-        }
-
-        val ids = cameraManager.cameraIdList
-        val selected = ids.firstOrNull { id ->
-            val characteristics = cameraManager.getCameraCharacteristics(id)
-            characteristics.get(CameraCharacteristics.LENS_FACING) == lensFacing
-        } ?: ids.firstOrNull()
+    private fun bindCameraUseCases() {
+        val provider = cameraProvider ?: return
+        provider.unbindAll()
 
-        if (selected == null) {
-            Log.e(TAG, "[CAMERA2] No camera available")
-            return
-        }
+        val rotation = previewView.display?.rotation ?: Surface.ROTATION_0
+        preview = Preview.Builder()
+            .setTargetRotation(rotation)
+            .build()
+            .also {
+                it.setSurfaceProvider(previewView.surfaceProvider)
+            }
 
-        cameraId = selected
-        val characteristics = cameraManager.getCameraCharacteristics(selected)
-        sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION) ?: 0
-        val activeArray = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE)
-        sensorAspectRatio = activeArray?.let { rect ->
-            if (rect.height() != 0) rect.width().toFloat() / rect.height().toFloat() else null
-        }
+        imageAnalysis = ImageAnalysis.Builder()
+            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+            .setTargetResolution(Size(ANALYSIS_WIDTH, ANALYSIS_HEIGHT))
+            .setTargetRotation(rotation)
+            .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888)
+            .build()
+            .also {
+                it.setAnalyzer(cameraExecutor, DocumentAnalyzer())
+            }
 
-        val streamConfig = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
-        previewChoices = streamConfig?.getOutputSizes(SurfaceTexture::class.java) ?: emptyArray()
-        analysisChoices = streamConfig?.getOutputSizes(ImageFormat.YUV_420_888) ?: emptyArray()
+        imageCapture = ImageCapture.Builder()
+            .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
+            .setTargetRotation(rotation)
+            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
+            .build()
 
-        val viewWidth = if (previewView.width > 0) previewView.width else context.resources.displayMetrics.widthPixels
-        val viewHeight = if (previewView.height > 0) previewView.height else context.resources.displayMetrics.heightPixels
-        val targetRatio = if (viewWidth > 0 && viewHeight > 0) {
-            viewWidth.toFloat() / viewHeight.toFloat()
+        val cameraSelector = if (useFrontCamera) {
+            CameraSelector.DEFAULT_FRONT_CAMERA
         } else {
-            null
-        }
-
-        logSizeCandidates("preview", previewChoices, targetRatio, sensorAspectRatio)
-        logSizeCandidates("analysis", analysisChoices, targetRatio, sensorAspectRatio)
-
-        previewSize = choosePreviewSize(previewChoices, targetRatio, sensorAspectRatio)
-        analysisSize = chooseAnalysisSize(analysisChoices, targetRatio, sensorAspectRatio)
-        Log.d(
-            TAG,
-            "[CAMERA2] chooseCamera view=${viewWidth}x${viewHeight} ratio=$targetRatio " +
-                "sensorOrientation=$sensorOrientation sensorRatio=$sensorAspectRatio " +
-                "preview=$previewSize analysis=$analysisSize"
-        )
-    }
-
-    private fun openCamera() {
-        val id = cameraId ?: run {
-            Log.e(TAG, "[CAMERA2] Camera id not set")
-            return
-        }
-        if (isOpening.getAndSet(true)) {
-            return
+            CameraSelector.DEFAULT_BACK_CAMERA
         }
 
         try {
-            cameraManager.openCamera(id, object : CameraDevice.StateCallback() {
-                override fun onOpened(device: CameraDevice) {
-                    Log.d(TAG, "[CAMERA2] Camera opened")
-                    isOpening.set(false)
-                    cameraDevice = device
-                    createPreviewSession()
-                }
-
-                override fun onDisconnected(device: CameraDevice) {
-                    Log.w(TAG, "[CAMERA2] Camera disconnected")
-                    isOpening.set(false)
-                    device.close()
-                    cameraDevice = null
-                }
-
-                override fun onError(device: CameraDevice, error: Int) {
-                    Log.e(TAG, "[CAMERA2] Camera error: $error")
-                    isOpening.set(false)
-                    device.close()
-                    cameraDevice = null
-                }
-            }, backgroundHandler)
-        } catch (e: SecurityException) {
-            isOpening.set(false)
-            Log.e(TAG, "[CAMERA2] Camera permission missing", e)
-        } catch (e: Exception) {
-            isOpening.set(false)
-            Log.e(TAG, "[CAMERA2] Failed to open camera", e)
-        }
-    }
-
-    private fun createPreviewSession() {
-        val device = cameraDevice ?: return
-        val texture = previewView.surfaceTexture ?: return
-        val sizes = ensurePreviewSizes()
-        val previewSize = sizes.first ?: return
-        val analysisSize = sizes.second ?: previewSize
-
-        Log.d(
-            TAG,
-            "[CAMERA2] createPreviewSession view=${previewView.width}x${previewView.height} " +
-                "preview=${previewSize.width}x${previewSize.height} analysis=${analysisSize.width}x${analysisSize.height}"
-        )
-
-        texture.setDefaultBufferSize(previewSize.width, previewSize.height)
-        val previewSurface = Surface(texture)
-
-        imageReader?.close()
-        imageReader = ImageReader.newInstance(
-            analysisSize.width,
-            analysisSize.height,
-            ImageFormat.YUV_420_888,
-            2
-        ).apply {
-            setOnImageAvailableListener({ reader ->
-                val image = reader.acquireLatestImage() ?: return@setOnImageAvailableListener
-                handleImage(image)
-            }, backgroundHandler)
-        }
-
-        val surfaces = listOf(previewSurface, imageReader!!.surface)
-        try {
-            device.createCaptureSession(
-                surfaces,
-                object : CameraCaptureSession.StateCallback() {
-                    override fun onConfigured(session: CameraCaptureSession) {
-                        if (cameraDevice == null) {
-                            return
-                        }
-                        captureSession = session
-                        previewRequestBuilder = device.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW).apply {
-                            addTarget(previewSurface)
-                            addTarget(imageReader!!.surface)
-                            set(CaptureRequest.CONTROL_MODE, CaptureRequest.CONTROL_MODE_AUTO)
-                            set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE)
-                            set(CaptureRequest.FLASH_MODE, if (torchEnabled) CaptureRequest.FLASH_MODE_TORCH else CaptureRequest.FLASH_MODE_OFF)
-                        }
-                        try {
-                            session.setRepeatingRequest(previewRequestBuilder!!.build(), null, backgroundHandler)
-                            Log.d(TAG, "[CAMERA2] Preview session started")
-                            updatePreviewTransform()
-                        } catch (e: Exception) {
-                            Log.e(TAG, "[CAMERA2] Failed to start preview", e)
-                        }
-                    }
-
-                    override fun onConfigureFailed(session: CameraCaptureSession) {
-                        Log.e(TAG, "[CAMERA2] Preview session configure failed")
-                    }
-                },
-                backgroundHandler
-            )
-        } catch (e: Exception) {
-            Log.e(TAG, "[CAMERA2] Failed to create preview session", e)
-        }
-    }
-
-    private fun ensurePreviewSizes(): Pair<Size?, Size?> {
-        if (previewChoices.isEmpty()) {
-            return Pair(previewSize, analysisSize)
-        }
-
-        val viewWidth = if (previewView.width > 0) previewView.width else context.resources.displayMetrics.widthPixels
-        val viewHeight = if (previewView.height > 0) previewView.height else context.resources.displayMetrics.heightPixels
-        val targetRatio = if (viewWidth > 0 && viewHeight > 0) {
-            viewWidth.toFloat() / viewHeight.toFloat()
-        } else {
-            null
-        }
-
-        val newPreview = choosePreviewSize(previewChoices, targetRatio, sensorAspectRatio)
-        val newAnalysis = chooseAnalysisSize(analysisChoices, targetRatio, sensorAspectRatio)
-
-        if (newPreview != null && newPreview != previewSize) {
-            previewSize = newPreview
-        }
-        if (newAnalysis != null && newAnalysis != analysisSize) {
-            analysisSize = newAnalysis
-        }
-
-        Log.d(
-            TAG,
-            "[CAMERA2] ensurePreviewSizes view=${viewWidth}x${viewHeight} ratio=$targetRatio " +
-                "preview=${previewSize?.width}x${previewSize?.height} analysis=${analysisSize?.width}x${analysisSize?.height}"
-        )
-        return Pair(previewSize, analysisSize)
-    }
-
-    private fun updatePreviewTransform() {
-        val previewSize = previewSize ?: return
-        ensureMatchParent()
-
-        val viewWidth = previewView.width
-        val viewHeight = previewView.height
-        if (viewWidth == 0 || viewHeight == 0) {
-            return
-        }
-
-        val rotationDegrees = getRotationDegrees()
-        val viewRect = RectF(0f, 0f, viewWidth.toFloat(), viewHeight.toFloat())
-        val bufferRect = if (rotationDegrees == 90 || rotationDegrees == 270) {
-            RectF(0f, 0f, previewSize.height.toFloat(), previewSize.width.toFloat())
-        } else {
-            RectF(0f, 0f, previewSize.width.toFloat(), previewSize.height.toFloat())
-        }
-        val centerX = viewRect.centerX()
-        val centerY = viewRect.centerY()
-
-        bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY())
-
-        val matrix = Matrix()
-        // Map buffer to view, then scale to fill and rotate around the center.
-        matrix.setRectToRect(bufferRect, viewRect, Matrix.ScaleToFit.FILL)
-        val scale = kotlin.math.max(
-            viewWidth.toFloat() / bufferRect.width(),
-            viewHeight.toFloat() / bufferRect.height()
-        )
-        matrix.postScale(scale, scale, centerX, centerY)
-        if (rotationDegrees != 0) {
-            matrix.postRotate(rotationDegrees.toFloat(), centerX, centerY)
-        }
-
-        previewView.setTransform(matrix)
-        Log.d(
-            TAG,
-            "[CAMERA2] transform view=${viewWidth}x${viewHeight} buffer=${previewSize.width}x${previewSize.height} " +
-                "rotation=$rotationDegrees scale=$scale"
-        )
-    }
-
-    private fun ensureMatchParent() {
-        val parentView = previewView.parent as? android.view.View ?: return
-        val parentWidth = parentView.width
-        val parentHeight = parentView.height
-        if (parentWidth == 0 || parentHeight == 0) {
-            return
-        }
-
-        val layoutParams = (previewView.layoutParams as? android.widget.FrameLayout.LayoutParams)
-            ?: android.widget.FrameLayout.LayoutParams(
-                android.widget.FrameLayout.LayoutParams.MATCH_PARENT,
-                android.widget.FrameLayout.LayoutParams.MATCH_PARENT
+            camera = provider.bindToLifecycle(
+                lifecycleOwner,
+                cameraSelector,
+                preview,
+                imageAnalysis,
+                imageCapture
             )
-        if (layoutParams.width != android.widget.FrameLayout.LayoutParams.MATCH_PARENT ||
-            layoutParams.height != android.widget.FrameLayout.LayoutParams.MATCH_PARENT
-        ) {
-            layoutParams.width = android.widget.FrameLayout.LayoutParams.MATCH_PARENT
-            layoutParams.height = android.widget.FrameLayout.LayoutParams.MATCH_PARENT
-            layoutParams.gravity = Gravity.CENTER
-            previewView.layoutParams = layoutParams
-        }
-        Log.d(TAG, "[CAMERA2] parent=${parentWidth}x${parentHeight} previewView=${previewView.width}x${previewView.height}")
-    }
-
-    private fun handleImage(image: Image) {
-        try {
-            val rotationDegrees = getRotationDegrees()
-            val width = image.width
-            val height = image.height
-            val nv21 = imageToNV21(image)
-
-            val frameWidth = if (rotationDegrees == 90 || rotationDegrees == 270) height else width
-            val frameHeight = if (rotationDegrees == 90 || rotationDegrees == 270) width else height
-
-            synchronized(lastFrameLock) {
-                lastFrame = LastFrame(nv21, width, height, rotationDegrees, useFrontCamera)
-            }
-
-            if (detectionEnabled) {
-                val rectangle = DocumentDetector.detectRectangleInYUV(
-                    nv21,
-                    width,
-                    height,
-                    rotationDegrees
-                )
-                onFrameAnalyzed?.invoke(rectangle, frameWidth, frameHeight)
-            } else {
-                onFrameAnalyzed?.invoke(null, frameWidth, frameHeight)
-            }
+            Log.d(TAG, "[CAMERAX] Camera bound successfully")
         } catch (e: Exception) {
-            Log.e(TAG, "[CAMERA2] Error analyzing frame", e)
-        } finally {
-            image.close()
-        }
-    }
-
-    private fun imageToNV21(image: Image): 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
-    }
-
-    private fun nv21ToJpeg(nv21: ByteArray, width: Int, height: Int, quality: Int): ByteArray {
-        val yuv = YuvImage(nv21, ImageFormat.NV21, width, height, null)
-        val out = ByteArrayOutputStream()
-        yuv.compressToJpeg(Rect(0, 0, width, height), quality, out)
-        return out.toByteArray()
-    }
-
-    private fun rotateAndMirror(bitmap: Bitmap, rotationDegrees: Int, mirror: Boolean): Bitmap {
-        if (rotationDegrees == 0 && !mirror) {
-            return bitmap
-        }
-        val matrix = Matrix()
-        if (mirror) {
-            matrix.postScale(-1f, 1f, bitmap.width / 2f, bitmap.height / 2f)
-        }
-        if (rotationDegrees != 0) {
-            matrix.postRotate(rotationDegrees.toFloat(), bitmap.width / 2f, bitmap.height / 2f)
+            Log.e(TAG, "[CAMERAX] Failed to bind camera", e)
         }
-        return Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
     }
 
-    private fun getRotationDegrees(): Int {
-        val displayRotation = previewView.display?.rotation ?: Surface.ROTATION_0
-        val displayDegrees = when (displayRotation) {
-            Surface.ROTATION_0 -> 0
-            Surface.ROTATION_90 -> 90
-            Surface.ROTATION_180 -> 180
-            Surface.ROTATION_270 -> 270
-            else -> 0
-        }
-
-        return if (useFrontCamera) {
-            (sensorOrientation + displayDegrees) % 360
-        } else {
-            (sensorOrientation - displayDegrees + 360) % 360
-        }
-    }
-
-    private fun choosePreviewSize(
-        choices: Array<Size>,
-        targetRatio: Float?,
-        sensorRatio: Float?
-    ): Size? {
-        if (choices.isEmpty()) {
-            return null
-        }
-        val candidates = choices.toList()
-
-        val ratioBase = sensorRatio ?: targetRatio
-        if (ratioBase == null) {
-            return candidates.maxByOrNull { it.width * it.height }
-        }
-
-        val normalizedTarget = ratioBase
-        val sorted = candidates.sortedWith(
-            compareBy<Size> { size ->
-                val ratio = size.width.toFloat() / size.height.toFloat()
-                kotlin.math.abs(ratio - normalizedTarget)
-            }.thenByDescending { size ->
-                size.width * size.height
-            }
-        )
-        return sorted.first()
-    }
-
-    private fun chooseAnalysisSize(
-        choices: Array<Size>,
-        targetRatio: Float?,
-        sensorRatio: Float?
-    ): Size? {
-        if (choices.isEmpty()) {
-            return null
-        }
-
-        val capped = choices.filter { it.width <= MAX_ANALYSIS_WIDTH && it.height <= MAX_ANALYSIS_HEIGHT }
-        val candidates = if (capped.isNotEmpty()) capped else choices.toList()
-
-        val ratioBase = sensorRatio ?: targetRatio
-        if (ratioBase == null) {
-            return candidates.maxByOrNull { it.width * it.height }
-        }
-
-        val normalizedTarget = ratioBase
-        val sorted = candidates.sortedWith(
-            compareBy<Size> { size ->
-                val ratio = size.width.toFloat() / size.height.toFloat()
-                kotlin.math.abs(ratio - normalizedTarget)
-            }.thenByDescending { size ->
-                size.width * size.height
-            }
-        )
-        return sorted.first()
-    }
+    private inner class DocumentAnalyzer : ImageAnalysis.Analyzer {
+        override fun analyze(imageProxy: androidx.camera.core.ImageProxy) {
+            try {
+                val rotationDegrees = imageProxy.imageInfo.rotationDegrees
+                val nv21 = imageProxy.toNv21()
 
-    private fun logSizeCandidates(
-        label: String,
-        choices: Array<Size>,
-        targetRatio: Float?,
-        sensorRatio: Float?
-    ) {
-        if (choices.isEmpty()) {
-            Log.d(TAG, "[CAMERA2] $label sizes: none")
-            return
-        }
+                val frameWidth = if (rotationDegrees == 90 || rotationDegrees == 270) {
+                    imageProxy.height
+                } else {
+                    imageProxy.width
+                }
 
-        val ratioBase = sensorRatio ?: targetRatio
-        if (ratioBase == null) {
-            Log.d(TAG, "[CAMERA2] $label sizes: ${choices.size}, ratioBase=null")
-            return
-        }
+                val frameHeight = if (rotationDegrees == 90 || rotationDegrees == 270) {
+                    imageProxy.width
+                } else {
+                    imageProxy.height
+                }
 
-        val normalizedTarget = ratioBase
-        val sorted = choices.sortedWith(
-            compareBy<Size> { size ->
-                val ratio = size.width.toFloat() / size.height.toFloat()
-                kotlin.math.abs(ratio - normalizedTarget)
-            }.thenByDescending { size ->
-                size.width * size.height
+                if (detectionEnabled) {
+                    val rectangle = DocumentDetector.detectRectangleInYUV(
+                        nv21,
+                        imageProxy.width,
+                        imageProxy.height,
+                        rotationDegrees
+                    )
+                    onFrameAnalyzed?.invoke(rectangle, frameWidth, frameHeight)
+                } else {
+                    onFrameAnalyzed?.invoke(null, frameWidth, frameHeight)
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "[CAMERAX] Error analyzing frame", e)
+            } finally {
+                imageProxy.close()
             }
-        )
-
-        val top = sorted.take(5).joinToString { size ->
-            val ratio = size.width.toFloat() / size.height.toFloat()
-            val diff = kotlin.math.abs(ratio - normalizedTarget)
-            "${size.width}x${size.height}(r=${"%.3f".format(ratio)},d=${"%.3f".format(diff)})"
-        }
-
-        Log.d(
-            TAG,
-            "[CAMERA2] $label sizes: ${choices.size}, ratioBase=${"%.3f".format(normalizedTarget)} " +
-                "sensor=${sensorRatio?.let { "%.3f".format(it) }} target=${targetRatio?.let { "%.3f".format(it) }} top=$top"
-        )
-    }
-
-    private fun startBackgroundThread() {
-        if (backgroundThread != null) {
-            return
-        }
-        backgroundThread = HandlerThread("Camera2Background").also {
-            it.start()
-            backgroundHandler = Handler(it.looper)
-        }
-    }
-
-    private fun stopBackgroundThread() {
-        try {
-            backgroundThread?.quitSafely()
-            backgroundThread?.join()
-        } catch (e: InterruptedException) {
-            Log.w(TAG, "[CAMERA2] Background thread shutdown interrupted", e)
-        } finally {
-            backgroundThread = null
-            backgroundHandler = null
         }
     }
 

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

@@ -8,9 +8,9 @@ import android.graphics.Paint
 import android.graphics.PorterDuff
 import android.graphics.PorterDuffXfermode
 import android.util.Log
-import android.view.TextureView
 import android.view.View
 import android.widget.FrameLayout
+import androidx.camera.view.PreviewView
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.LifecycleRegistry
@@ -25,7 +25,7 @@ import kotlin.math.min
 
 class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), LifecycleOwner {
     private val themedContext = context
-    private val previewView: TextureView
+    private val previewView: PreviewView
     private val overlayView: OverlayView
     private var cameraController: CameraController? = null
     private val lifecycleRegistry = LifecycleRegistry(this)
@@ -73,23 +73,20 @@ class DocumentScannerView(context: ThemedReactContext) : FrameLayout(context), L
         Log.d(TAG, "[INIT] Lifecycle state: ${lifecycleRegistry.currentState}")
 
         // Create preview view
-        Log.d(TAG, "[INIT] Creating TextureView...")
-        previewView = TextureView(context).apply {
+        Log.d(TAG, "[INIT] Creating PreviewView...")
+        previewView = PreviewView(context).apply {
             layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
             visibility = View.VISIBLE
             keepScreenOn = true
-            // Force view to be drawn
-            setWillNotDraw(false)
-            // Ensure the view is on top
-            bringToFront()
-            requestLayout()
+            implementationMode = PreviewView.ImplementationMode.COMPATIBLE
+            scaleType = PreviewView.ScaleType.FILL_CENTER
         }
-        Log.d(TAG, "[INIT] TextureView created: $previewView")
-        Log.d(TAG, "[INIT] TextureView visibility: ${previewView.visibility}")
+        Log.d(TAG, "[INIT] PreviewView created: $previewView")
+        Log.d(TAG, "[INIT] PreviewView visibility: ${previewView.visibility}")
 
-        Log.d(TAG, "[INIT] Adding TextureView to parent...")
+        Log.d(TAG, "[INIT] Adding PreviewView to parent...")
         addView(previewView)
-        Log.d(TAG, "[INIT] TextureView added, childCount: $childCount")
+        Log.d(TAG, "[INIT] PreviewView added, childCount: $childCount")
 
         // Create overlay view for drawing rectangle
         Log.d(TAG, "[INIT] Creating OverlayView...")

package/package.json

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