@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/android/src/main/java/com/trustchex/reactnativesdk/camera/TrustchexCameraView.kt

@@ -0,0 +1,871 @@
+package com.trustchex.reactnativesdk.camera
+
+import android.annotation.SuppressLint
+import android.graphics.BitmapFactory
+import android.graphics.ImageFormat
+import android.graphics.Matrix
+import android.graphics.Rect
+import android.graphics.YuvImage
+import android.util.Size
+import android.widget.FrameLayout
+import androidx.annotation.OptIn
+import androidx.camera.core.*
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.camera.video.*
+import androidx.camera.view.PreviewView
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.google.android.gms.tasks.Tasks
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions
+import com.google.mlkit.vision.barcode.common.Barcode
+import com.google.mlkit.vision.common.InputImage
+import com.trustchex.reactnativesdk.mrz.MRZValidator
+import com.google.mlkit.vision.face.FaceDetection
+import com.google.mlkit.vision.face.FaceDetectorOptions
+import com.google.mlkit.vision.text.TextRecognition
+import com.google.mlkit.vision.text.latin.TextRecognizerOptions
+import java.io.ByteArrayOutputStream
+import kotlin.math.max
+import java.io.File
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+
+@SuppressLint("ViewConstructor")
+class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
+
+    // ==================================================================================
+    // PORTRAIT-ONLY CAMERA VIEW
+    // All camera use cases are locked to ROTATION_0 (portrait) orientation.
+    // Preview: 720x1280 (Portrait HD)
+    // ImageAnalysis: 720x1280 (Portrait HD for ML Kit)
+    // ImageCapture: 720x1280 (Portrait HD for frame capture during recording)
+    // VideoCapture: Quality.HD (CameraX auto-selects portrait HD resolution)
+    // Activity must be locked to portrait in AndroidManifest.xml
+    // ==================================================================================
+
+    private val reactContext: ReactContext = context
+    private val previewView: PreviewView = PreviewView(context).apply {
+        implementationMode = PreviewView.ImplementationMode.COMPATIBLE
+        scaleType = PreviewView.ScaleType.FILL_CENTER
+    }
+    private var cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+    private var cameraProvider: ProcessCameraProvider? = null
+    private var camera: Camera? = null
+    private var preview: Preview? = null
+    private var imageAnalyzer: ImageAnalysis? = null
+    private var videoCapture: VideoCapture<Recorder>? = null
+    private var activeRecording: Recording? = null
+    private var currentRecordingFile: File? = null
+
+    private var cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
+    private var torchEnabled = false
+    private var frameProcessingEnabled = false
+    private var targetFps = 6
+    private var isCameraInitialized = false
+    private var isStoppingRecording = false // Track if stopRecording was called to prevent cancelRecording from deleting the file
+
+    // ML Kit detection modes — controlled via props from JS
+    private var faceDetectionEnabled = false
+    private var textRecognitionEnabled = false
+    private var barcodeScanningEnabled = false
+    private var mrzValidationEnabled = false
+    private var includeBase64 = false
+
+    // ML Kit detector instances (lazy, created once)
+    private val textRecognizer by lazy {
+        TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+    }
+    private val faceDetector by lazy {
+        FaceDetection.getClient(
+            FaceDetectorOptions.Builder()
+                .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
+                .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
+                .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
+                .setMinFaceSize(0.1f)  // 10% - small enough to detect faces reliably
+                .build()
+        )
+    }
+    private val barcodeScanner by lazy {
+        BarcodeScanning.getClient(
+            BarcodeScannerOptions.Builder()
+                .setBarcodeFormats(
+                    Barcode.FORMAT_PDF417,
+                    Barcode.FORMAT_QR_CODE,
+                    Barcode.FORMAT_CODE_128,
+                    Barcode.FORMAT_CODE_39,
+                    Barcode.FORMAT_EAN_13,
+                    Barcode.FORMAT_EAN_8,
+                    Barcode.FORMAT_AZTEC,
+                    Barcode.FORMAT_DATA_MATRIX
+                )
+                .build()
+        )
+    }
+
+    // Prevent concurrent ML Kit processing (drop frames while busy)
+    private val isProcessing = AtomicBoolean(false)
+
+    private var lastFrameTime = 0L
+    private val minFrameInterval get() = 1000L / targetFps
+
+    // React Native suppresses layout passes for custom views.
+    // Without this override, PreviewView's internal SurfaceView/TextureView
+    // stays at 0x0 dimensions and the preview is black.
+    private val measureAndLayout = Runnable {
+        measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+        )
+        layout(left, top, right, bottom)
+    }
+
+    override fun requestLayout() {
+        super.requestLayout()
+        // Post a forced layout pass so the PreviewView gets measured
+        post(measureAndLayout)
+    }
+
+    init {
+        addView(previewView, LayoutParams(
+            LayoutParams.MATCH_PARENT,
+            LayoutParams.MATCH_PARENT
+        ))
+
+        // Wait for view to be laid out before initializing camera
+        post {
+            initializeCamera()
+        }
+    }
+
+    fun setCameraType(type: String) {
+        val newSelector = selectBestCamera(type)
+        // Only reinitialize if the selector actually changed and camera is already running
+        if (newSelector != cameraSelector || !isCameraInitialized) {
+            cameraSelector = newSelector
+            if (isCameraInitialized) {
+                initializeCamera()
+            }
+        }
+    }
+
+    private fun selectBestCamera(type: String): CameraSelector {
+        if (type == "front") {
+            return CameraSelector.DEFAULT_FRONT_CAMERA
+        }
+
+        // For back camera, try to select Ultra Wide camera for document scanning
+        val cameraProvider = cameraProvider ?: return CameraSelector.DEFAULT_BACK_CAMERA
+
+        try {
+            // Check for Ultra Wide camera
+            val ultraWideSelector = CameraSelector.Builder()
+                .requireLensFacing(CameraSelector.LENS_FACING_BACK)
+                .build()
+
+            val cameras = cameraProvider.availableCameraInfos.filter {
+                ultraWideSelector.filter(listOf(it)).isNotEmpty()
+            }
+
+            // Heuristic: If we have 3+ back cameras, index 2 is often Ultra Wide
+            if (cameras.size >= 3) {
+                // Heuristic: If we have 3+ back cameras, index 2 is often Ultra Wide
+            }
+        } catch (e: Exception) {
+            android.util.Log.e("TrustchexCamera", "Failed to enumerate cameras: ${e.message}")
+        }
+
+        return CameraSelector.DEFAULT_BACK_CAMERA
+    }
+
+    fun setTorchEnabled(enabled: Boolean) {
+        torchEnabled = enabled
+        camera?.cameraControl?.enableTorch(enabled)
+    }
+
+    fun setFrameProcessingEnabled(enabled: Boolean) {
+        frameProcessingEnabled = enabled
+    }
+
+    fun setTargetFps(fps: Int) {
+        targetFps = fps.coerceIn(1, 30)
+    }
+
+    fun setFaceDetectionEnabled(enabled: Boolean) {
+        faceDetectionEnabled = enabled
+    }
+
+    fun setTextRecognitionEnabled(enabled: Boolean) {
+        textRecognitionEnabled = enabled
+    }
+
+    fun setBarcodeScanningEnabled(enabled: Boolean) {
+        barcodeScanningEnabled = enabled
+    }
+
+    fun setMrzValidationEnabled(enabled: Boolean) {
+        mrzValidationEnabled = enabled
+    }
+
+    fun setIncludeBase64(enabled: Boolean) {
+        includeBase64 = enabled
+    }
+
+    private fun initializeCamera() {
+        val cameraProviderFuture = ProcessCameraProvider.getInstance(context)
+
+        cameraProviderFuture.addListener({
+            try {
+                cameraProvider = cameraProviderFuture.get()
+                bindCamera()
+            } catch (e: Exception) {
+                sendErrorEvent("Camera initialization failed: ${e.message}")
+            }
+        }, ContextCompat.getMainExecutor(context))
+    }
+
+    private fun bindCamera() {
+        val provider = cameraProvider ?: return
+
+        // Unbind previous use cases
+        provider.unbindAll()
+
+        try {
+            // Determine resolution based on camera type
+            // Front camera (liveness): HD (720x1280) for optimal performance
+            // Back camera (documents): Full HD (1080x1920) for sharp document capture
+            val isFrontCamera = cameraSelector == CameraSelector.DEFAULT_FRONT_CAMERA
+            val targetResolution = if (isFrontCamera) {
+                Size(720, 1280) // Portrait HD for front camera
+            } else {
+                Size(1080, 1920) // Portrait Full HD for back camera
+            }
+
+            // Preview use case
+            preview = Preview.Builder()
+                .setTargetResolution(targetResolution)
+                .setTargetRotation(android.view.Surface.ROTATION_0) // Portrait
+                .build()
+                .also {
+                    it.setSurfaceProvider(previewView.surfaceProvider)
+                }
+
+            // Image analysis use case
+            imageAnalyzer = ImageAnalysis.Builder()
+                .setTargetResolution(targetResolution)
+                .setTargetRotation(android.view.Surface.ROTATION_0) // Portrait
+                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+                .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888)
+                .build()
+                .also {
+                    it.setAnalyzer(cameraExecutor, FrameAnalyzer())
+                }
+
+            // Image capture use case is NOT used in the current version of the SDK
+            // (Liveness detection uses ImageAnalyzer and VideoCapture)
+            // Removing it allows us to bind VideoCapture + Analyzer + Preview simultaneously
+            // within the 3-use-case limit of many Android devices.
+
+            // Video capture use case — PORTRAIT HD
+            val recorder = Recorder.Builder()
+                .setQualitySelector(QualitySelector.from(Quality.HD))
+                .build()
+            videoCapture = VideoCapture.withOutput(recorder)
+
+            // Bind all 3 essential use cases (Preview + Analyzer + Video)
+            // This ensures instant recording start without camera restart/jump
+            val useCases = mutableListOf<androidx.camera.core.UseCase>()
+            preview?.let { useCases.add(it) }
+            imageAnalyzer?.let { useCases.add(it) }
+            videoCapture?.let { useCases.add(it) }
+
+            val lifecycleOwner = (reactContext.currentActivity as? LifecycleOwner)
+                ?: run {
+                    sendErrorEvent("Activity not available")
+                    return
+                }
+
+            camera = provider.bindToLifecycle(
+                lifecycleOwner,
+                cameraSelector,
+                *useCases.toTypedArray()
+            )
+
+            isCameraInitialized = true
+
+            // Apply torch setting
+            if (torchEnabled) {
+                camera?.cameraControl?.enableTorch(true)
+            }
+
+            // Apply stable exposure and focus settings
+            applyCameraSettings()
+
+            // Force a layout pass so the preview surface gets sized correctly
+            post(measureAndLayout)
+
+            // Get exposure and focus capabilities
+            val cameraInfo = camera?.cameraInfo
+            val exposureState = cameraInfo?.exposureState
+            val minExposure = exposureState?.exposureCompensationRange?.lower ?: -2
+            val maxExposure = exposureState?.exposureCompensationRange?.upper ?: 2
+
+            sendReadyEvent(minExposure.toDouble(), maxExposure.toDouble())
+
+        } catch (e: Exception) {
+            sendErrorEvent("Camera binding failed: ${e.message}")
+        }
+    }
+
+    private inner class FrameAnalyzer : ImageAnalysis.Analyzer {
+
+        @OptIn(ExperimentalGetImage::class)
+        override fun analyze(imageProxy: ImageProxy) {
+            val currentTime = System.currentTimeMillis()
+
+            // Throttle to target FPS (6 frames per second = ~167ms per frame)
+            val timeSinceLastFrame = currentTime - lastFrameTime
+            if (timeSinceLastFrame < minFrameInterval) {
+                imageProxy.close()
+                return
+            }
+            lastFrameTime = currentTime
+
+            // Prevent concurrent ML Kit processing
+            val canProcess = isProcessing.compareAndSet(false, true)
+            if (!canProcess) {
+                imageProxy.close()
+                return
+            }
+
+            val mediaImage = imageProxy.image ?: run {
+                isProcessing.set(false)
+                imageProxy.close()
+                return
+            }
+
+            val hasAnyDetection = frameProcessingEnabled && (faceDetectionEnabled || textRecognitionEnabled || barcodeScanningEnabled)
+            if (!hasAnyDetection) {
+                isProcessing.set(false)
+                imageProxy.close()
+                return
+            }
+
+            // Create InputImage directly from camera frame — zero-copy, no base64 for ML Kit
+            val inputImage = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
+
+            val rotationDegrees = imageProxy.imageInfo.rotationDegrees
+
+            // Calculate portrait-oriented dimensions early (JPEG is already rotated)
+            val isRotated = rotationDegrees == 90 || rotationDegrees == 270
+            val reportedWidth = if (isRotated) imageProxy.height else imageProxy.width
+            val reportedHeight = if (isRotated) imageProxy.width else imageProxy.height
+
+            // Compute brightness natively from Y plane (no base64 or bitmap needed)
+            // Brightness calculation restricted to scanning frame area (between 36% from top and 36% from bottom, 5% margins on sides)
+            val averageBrightness = computeYPlaneBrightness(imageProxy, reportedWidth, reportedHeight)
+
+            // Generate JPEG base64 only when JS side explicitly needs the image
+            // NOTE: Do NOT auto-generate for face detection - too expensive, causes frame drops
+            val jpegBase64: String? = if (includeBase64) {
+                yuvImageProxyToJpegBase64(imageProxy, rotationDegrees)
+            } else null
+
+            // Launch all enabled detectors in parallel using Google Tasks API
+            val tasks = mutableListOf<com.google.android.gms.tasks.Task<*>>()
+
+            val faceTask = if (faceDetectionEnabled) {
+                faceDetector.process(inputImage).also { tasks.add(it) }
+            } else null
+
+            val textTask = if (textRecognitionEnabled) {
+                textRecognizer.process(inputImage).also { tasks.add(it) }
+            } else null
+
+            val barcodeTask = if (barcodeScanningEnabled) {
+                barcodeScanner.process(inputImage).also { tasks.add(it) }
+            } else null
+
+            // Wait for all detectors, then build + send a single event to JS
+            Tasks.whenAllComplete(tasks).addOnCompleteListener { _ ->
+                try {
+                    val frameData = Arguments.createMap()
+                    frameData.putInt("width", reportedWidth)
+                    frameData.putInt("height", reportedHeight)
+                    frameData.putInt("orientation", 0) // Already corrected
+                    frameData.putDouble("timestamp", currentTime.toDouble())
+                    frameData.putDouble("brightness", averageBrightness)
+
+                    if (jpegBase64 != null) {
+                        frameData.putString("base64Image", jpegBase64)
+                    }
+
+                    // Face detection results
+                    // ML Kit with InputImage.fromMediaImage(img, rotationDegrees) returns
+                    // coordinates in the rotated (portrait) coordinate space — no transform needed.
+                    if (faceTask != null) {
+                        val facesArray = Arguments.createArray()
+                        if (faceTask.isSuccessful) {
+                            for (face in faceTask.result) {
+                                val faceMap = Arguments.createMap()
+                                val bounds = Arguments.createMap()
+                                bounds.putInt("x", face.boundingBox.left)
+                                bounds.putInt("y", face.boundingBox.top)
+                                bounds.putInt("width", face.boundingBox.width())
+                                bounds.putInt("height", face.boundingBox.height())
+                                faceMap.putMap("bounds", bounds)
+                                faceMap.putDouble("yawAngle", face.headEulerAngleY.toDouble())
+                                faceMap.putDouble("pitchAngle", face.headEulerAngleX.toDouble())
+                                faceMap.putDouble("rollAngle", face.headEulerAngleZ.toDouble())
+                                if (face.trackingId != null) {
+                                    faceMap.putInt("trackingId", face.trackingId!!)
+                                }
+                                if (face.smilingProbability != null) {
+                                    faceMap.putDouble("smilingProbability", face.smilingProbability!!.toDouble())
+                                }
+                                if (face.leftEyeOpenProbability != null) {
+                                    faceMap.putDouble("leftEyeOpenProbability", face.leftEyeOpenProbability!!.toDouble())
+                                }
+                                if (face.rightEyeOpenProbability != null) {
+                                    faceMap.putDouble("rightEyeOpenProbability", face.rightEyeOpenProbability!!.toDouble())
+                                }
+                                facesArray.pushMap(faceMap)
+                            }
+                        }
+                        frameData.putArray("faces", facesArray)
+                    }
+
+                    // Text recognition results
+                    if (textTask != null) {
+                        if (textTask.isSuccessful) {
+                            val result = textTask.result
+                            frameData.putString("resultText", result.text)
+
+                            val blocksArray = Arguments.createArray()
+                            for (block in result.textBlocks) {
+                                val blockMap = Arguments.createMap()
+                                blockMap.putString("text", block.text)
+                                val bb = block.boundingBox
+                                if (bb != null) {
+                                    val boxMap = Arguments.createMap()
+                                    boxMap.putInt("x", bb.left)
+                                    boxMap.putInt("y", bb.top)
+                                    boxMap.putInt("width", bb.width())
+                                    boxMap.putInt("height", bb.height())
+                                    boxMap.putInt("boundingCenterX", bb.centerX())
+                                    boxMap.putInt("boundingCenterY", bb.centerY())
+                                    blockMap.putMap("blockFrame", boxMap)
+                                }
+                                blocksArray.pushMap(blockMap)
+                            }
+                            frameData.putArray("textBlocks", blocksArray)
+                        } else {
+                            frameData.putString("resultText", "")
+                            frameData.putArray("textBlocks", Arguments.createArray())
+                        }
+                    }
+
+                    // MRZ validation (if enabled and text was recognized)
+                    if (mrzValidationEnabled && textTask != null && textTask.isSuccessful) {
+                        val rawText = textTask.result.text
+                        val mrzResult = MRZValidator.validateWithCorrections(rawText)
+                        val mrzMap = Arguments.createMap()
+                        mrzMap.putBoolean("valid", mrzResult.valid)
+                        mrzMap.putString("format", mrzResult.format)
+                        mrzResult.error?.let { mrzMap.putString("error", it) }
+                        mrzResult.documentCode?.let { mrzMap.putString("documentCode", it) }
+                        mrzResult.issuingState?.let { mrzMap.putString("issuingState", it) }
+                        mrzResult.documentNumber?.let { mrzMap.putString("documentNumber", it) }
+                        mrzResult.lastName?.let { mrzMap.putString("lastName", it) }
+                        mrzResult.firstName?.let { mrzMap.putString("firstName", it) }
+                        mrzResult.birthDate?.let { mrzMap.putString("birthDate", it) }
+                        mrzResult.sex?.let { mrzMap.putString("sex", it) }
+                        mrzResult.expirationDate?.let { mrzMap.putString("expirationDate", it) }
+                        mrzResult.nationality?.let { mrzMap.putString("nationality", it) }
+                        mrzResult.optional1?.let { mrzMap.putString("optional1", it) }
+                        mrzResult.optional2?.let { mrzMap.putString("optional2", it) }
+                        mrzResult.rawLines?.let { mrzMap.putString("rawLines", it) }
+                        frameData.putMap("mrzResult", mrzMap)
+                    }
+
+                    // Barcode scanning results
+                    if (barcodeTask != null) {
+                        val barcodesArray = Arguments.createArray()
+                        if (barcodeTask.isSuccessful) {
+                            for (barcode in barcodeTask.result) {
+                                    val barcodeMap = Arguments.createMap()
+                                    barcodeMap.putString("rawValue", barcode.rawValue ?: "")
+                                    barcodeMap.putString("displayValue", barcode.displayValue ?: "")
+                                    barcodeMap.putInt("format", barcode.format)
+                                    val bb = barcode.boundingBox
+                                    if (bb != null) {
+                                        val boxMap = Arguments.createMap()
+                                        boxMap.putInt("left", bb.left)
+                                        boxMap.putInt("top", bb.top)
+                                        boxMap.putInt("right", bb.right)
+                                        boxMap.putInt("bottom", bb.bottom)
+                                        barcodeMap.putMap("boundingBox", boxMap)
+                                    }
+                                    val cornerPoints = Arguments.createArray()
+                                    barcode.cornerPoints?.forEach { point ->
+                                        val pointMap = Arguments.createMap()
+                                        pointMap.putInt("x", point.x)
+                                        pointMap.putInt("y", point.y)
+                                        cornerPoints.pushMap(pointMap)
+                                    }
+                                    barcodeMap.putArray("cornerPoints", cornerPoints)
+                                    barcodesArray.pushMap(barcodeMap)
+                            }
+                        }
+                        frameData.putArray("barcodes", barcodesArray)
+                    }
+
+                    sendFrameEvent(frameData)
+                } finally {
+                    imageProxy.close()
+                    isProcessing.set(false)
+                }
+            }
+        }
+
+    }
+
+    /**
+     * Fast brightness calculation directly from the Y plane — no allocation, no base64.
+     * Samples within the scanning frame area only (~100 points).
+     * Scanning frame: top 36%, bottom 36%, left 5%, right 5% of portrait dimensions.
+     * Returns average luma value (0-255).
+     */
+    private fun computeYPlaneBrightness(imageProxy: ImageProxy, portraitWidth: Int, portraitHeight: Int): Double {
+        val yPlane = imageProxy.planes[0]
+        val yBuffer = yPlane.buffer
+        val rowStride = yPlane.rowStride
+        val bufferWidth = imageProxy.width
+        val bufferHeight = imageProxy.height
+
+        // Define scanning frame area (from IdentityDocumentCamera.tsx styles)
+        // top: 36%, left: 5%, right: 5%, bottom: 36%
+        val scanTopPercent = 0.36
+        val scanBottomPercent = 0.36
+        val scanLeftPercent = 0.05
+        val scanRightPercent = 0.05
+
+        // Convert percentages to pixel coordinates in the portrait frame
+        val scanTop = (portraitHeight * scanTopPercent).toInt()
+        val scanBottom = (portraitHeight * (1.0 - scanBottomPercent)).toInt()
+        val scanLeft = (portraitWidth * scanLeftPercent).toInt()
+        val scanRight = (portraitWidth * (1.0 - scanRightPercent)).toInt()
+
+        // Map from portrait coordinates to buffer coordinates
+        // Portrait frame dimensions and buffer dimensions may differ in rotation
+        // Sample points proportionally within the scanning frame
+        val scanWidth = scanRight - scanLeft
+        val scanHeight = scanBottom - scanTop
+
+        var sum = 0L
+        var count = 0
+        val sampleCount = 100
+
+        for (i in 0..<sampleCount) {
+            // Distribute samples evenly within the scanning frame
+            val sampleOffsetX = (i * 17) % sampleCount
+            val sampleOffsetY = (i * 23) % sampleCount
+
+            val portraitX = scanLeft + (sampleOffsetX * scanWidth) / max(1, sampleCount - 1)
+            val portraitY = scanTop + (sampleOffsetY * scanHeight) / max(1, sampleCount - 1)
+
+            // Map portrait coordinates to buffer coordinates (accounting for rotation)
+            val bufferX = (portraitX * bufferWidth) / portraitWidth
+            val bufferY = (portraitY * bufferHeight) / portraitHeight
+
+            val clampedX = bufferX.coerceIn(0, bufferWidth - 1)
+            val clampedY = bufferY.coerceIn(0, bufferHeight - 1)
+
+            val bufferIndex = clampedY * rowStride + clampedX
+            if (bufferIndex < yBuffer.capacity()) {
+                sum += (yBuffer.get(bufferIndex).toInt() and 0xFF)
+                count++
+            }
+        }
+
+        return if (count > 0) sum.toDouble() / count else 0.0
+    }
+
+    private fun yuvImageProxyToJpegBase64(imageProxy: ImageProxy, rotationDegrees: Int): String? {
+        try {
+            val width = imageProxy.width
+            val height = imageProxy.height
+
+            // Check plane count
+            val planeCount = imageProxy.planes.size
+            if (planeCount < 3) {
+                android.util.Log.e("TrustchexCamera", "[yuvImageProxyToJpegBase64] ERROR: Expected 3 planes (YUV), got $planeCount")
+                return null
+            }
+
+            val yPlane = imageProxy.planes[0]
+            val uPlane = imageProxy.planes[1]
+            val vPlane = imageProxy.planes[2]
+
+            val yRowStride = yPlane.rowStride
+            val uvRowStride = uPlane.rowStride
+            val uvPixelStride = uPlane.pixelStride
+            val nv21 = ByteArray(width * height + width * (height / 2))
+
+            // Copy Y plane row-by-row, stripping any row padding
+            val yBuffer = yPlane.buffer
+            for (row in 0 until height) {
+                yBuffer.position(row * yRowStride)
+                yBuffer.get(nv21, row * width, width)
+            }
+
+            // Copy UV planes into interleaved VU (NV21) format
+            val uBuffer = uPlane.buffer
+            val vBuffer = vPlane.buffer
+            val uvHeight = height / 2
+            val uvWidth = width / 2
+            var nv21Offset = width * height
+
+            // Reset buffer positions to start
+            if (uvPixelStride == 2) {
+                val actualUvRowStride = if (uvRowStride >= uvWidth * 2) uvRowStride else uvWidth * 2
+                
+                for (row in 0 until uvHeight) {
+                    val rowOffset = row * actualUvRowStride
+                    for (col in 0 until uvWidth) {
+                        val uvIndex = rowOffset + col * uvPixelStride
+                        if (uvIndex < vBuffer.capacity() && uvIndex < uBuffer.capacity()) {
+                            nv21[nv21Offset++] = vBuffer.get(uvIndex)
+                            nv21[nv21Offset++] = uBuffer.get(uvIndex)
+                        } else {
+                            android.util.Log.w("TrustchexCamera", "UV index out of bounds: $uvIndex at row=$row, col=$col")
+                            nv21[nv21Offset++] = 128.toByte()
+                            nv21[nv21Offset++] = 128.toByte()
+                        }
+                    }
+                }
+            }
+
+            // Convert YUV to JPEG with optimized quality (75% for faster encoding)
+            val strides = intArrayOf(width, width)
+            val yuvImage = YuvImage(nv21, ImageFormat.NV21, width, height, strides)
+            val jpegStream = ByteArrayOutputStream()
+            yuvImage.compressToJpeg(Rect(0, 0, width, height), 75, jpegStream)
+
+            // Rotate to portrait if needed
+            if (rotationDegrees != 0) {
+                val jpegBytes = jpegStream.toByteArray()
+                val bitmap = BitmapFactory.decodeByteArray(jpegBytes, 0, jpegBytes.size)
+                val matrix = Matrix().apply { postRotate(rotationDegrees.toFloat()) }
+                val rotated = android.graphics.Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
+                bitmap.recycle()
+                val rotatedStream = ByteArrayOutputStream()
+                rotated.compress(android.graphics.Bitmap.CompressFormat.JPEG, 60, rotatedStream)
+                rotated.recycle()
+                return android.util.Base64.encodeToString(rotatedStream.toByteArray(), android.util.Base64.NO_WRAP)
+            }
+
+            return android.util.Base64.encodeToString(jpegStream.toByteArray(), android.util.Base64.NO_WRAP)
+        } catch (e: Exception) {
+            android.util.Log.e("TrustchexCamera", "[yuvImageProxyToJpegBase64] ERROR: ${e.message}", e)
+            return null
+        }
+    }
+
+    fun setFocusPoint(x: Double, y: Double) {
+        val factory = previewView.meteringPointFactory
+        val point = factory.createPoint(x.toFloat(), y.toFloat())
+        val action = FocusMeteringAction.Builder(
+            point,
+            FocusMeteringAction.FLAG_AF or FocusMeteringAction.FLAG_AE
+        ).build()
+
+        camera?.cameraControl?.startFocusAndMetering(action)
+    }
+
+    fun setExposureOffset(offset: Double) {
+        val exposureState = camera?.cameraInfo?.exposureState
+        val range = exposureState?.exposureCompensationRange
+        if (range != null) {
+            val index = offset.toInt().coerceIn(range.lower, range.upper)
+            camera?.cameraControl?.setExposureCompensationIndex(index)
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    fun startRecording() {
+        if (activeRecording != null) {
+            return
+        }
+
+        val videoCapture = videoCapture ?: run {
+            sendRecordingErrorEvent("VideoCapture not initialized")
+            return
+        }
+
+        try {
+            // Apply torch setting if needed
+            if (torchEnabled) {
+                camera?.cameraControl?.enableTorch(true)
+            }
+
+            // Apply stable camera settings
+            applyCameraSettings()
+
+            // Create output file in cache directory (not visible in gallery)
+            val fileName = "liveness_${System.currentTimeMillis()}.mp4"
+            val videoFile = File(context.cacheDir, fileName)
+            currentRecordingFile = videoFile
+            isStoppingRecording = false // Reset flag for new recording
+
+            val fileOutputOptions = FileOutputOptions.Builder(videoFile).build()
+
+            activeRecording = videoCapture.output
+                .prepareRecording(reactContext, fileOutputOptions)
+                .start(ContextCompat.getMainExecutor(reactContext)) { event ->
+                    when (event) {
+                        is VideoRecordEvent.Finalize -> {
+                            activeRecording = null
+
+                            if (event.hasError()) {
+                                currentRecordingFile?.delete()
+                                currentRecordingFile = null
+                                sendRecordingErrorEvent("Recording error: ${event.cause?.message}")
+                            } else {
+                                val filePath = videoFile.absolutePath
+                                sendRecordingFinishedEvent(filePath)
+                            }
+                        }
+                        else -> {}
+                    }
+                }
+        } catch (e: Exception) {
+            activeRecording = null
+            sendRecordingErrorEvent("Failed to start recording: ${e.message}")
+        }
+    }
+
+    fun stopRecording() {
+        isStoppingRecording = true // Mark that we're stopping normally
+        activeRecording?.stop()
+    }
+
+    fun cancelRecording() {
+        // Don't delete the file if stopRecording was already called - let it finalize normally
+        if (isStoppingRecording) {
+            return
+        }
+        
+        activeRecording?.close()
+        activeRecording = null
+
+        // Delete incomplete recording file
+        currentRecordingFile?.let { file ->
+            try {
+                if (file.exists()) {
+                    file.delete()
+                }
+            } catch (e: Exception) {
+                // Silently handle
+            }
+            currentRecordingFile = null
+        }
+    }
+
+    @OptIn(ExperimentalGetImage::class)
+    private fun applyCameraSettings() {
+        // CameraX manages continuous autofocus automatically
+        // We only need to set initial focus point at center
+        val camera = camera ?: return
+
+        try {
+            val centerPoint = previewView.meteringPointFactory.createPoint(0.5f, 0.5f)
+            val afAction = FocusMeteringAction.Builder(
+                centerPoint,
+                FocusMeteringAction.FLAG_AF or FocusMeteringAction.FLAG_AE
+            ).build()
+
+            camera.cameraControl.startFocusAndMetering(afAction)
+        } catch (e: Exception) {
+            // Silently handle - not critical
+        }
+    }
+    private fun sendFrameEvent(frameData: WritableMap) {
+        val event = Arguments.createMap()
+        event.putMap("frame", frameData)
+
+        reactContext
+            .getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(id, TrustchexCameraManager.EVENT_FRAME_AVAILABLE, event)
+    }
+
+    private fun sendReadyEvent(minExposure: Double, maxExposure: Double) {
+        val event = Arguments.createMap()
+        event.putDouble("minExposureOffset", minExposure)
+        event.putDouble("maxExposureOffset", maxExposure)
+
+        reactContext
+            .getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(id, TrustchexCameraManager.EVENT_CAMERA_READY, event)
+    }
+
+    private fun sendErrorEvent(error: String) {
+        val event = Arguments.createMap()
+        event.putString("error", error)
+
+        reactContext
+            .getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(id, TrustchexCameraManager.EVENT_CAMERA_ERROR, event)
+    }
+
+    private fun sendRecordingFinishedEvent(path: String) {
+        val event = Arguments.createMap()
+        event.putString("path", path)
+
+        try {
+            reactContext
+                .getJSModule(RCTEventEmitter::class.java)
+                .receiveEvent(id, TrustchexCameraManager.EVENT_RECORDING_FINISHED, event)
+        } catch (e: Exception) {
+            android.util.Log.e("TrustchexCamera", "Error sending recording finished event: ${e.message}", e)
+        }
+    }
+
+    private fun sendRecordingErrorEvent(error: String) {
+        val event = Arguments.createMap()
+        event.putString("error", error)
+
+        reactContext
+            .getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(id, TrustchexCameraManager.EVENT_RECORDING_ERROR, event)
+    }
+
+    fun deleteRecording(filePath: String) {
+        try {
+            val file = File(filePath)
+            if (file.exists()) {
+                file.delete()
+            }
+        } catch (e: Exception) {
+            // Silently handle
+        }
+    }
+
+    fun cleanup() {
+        // Cancel any active recording and delete file
+        if (activeRecording != null) {
+            activeRecording?.close()
+            currentRecordingFile?.delete()
+            currentRecordingFile = null
+        }
+
+        cameraProvider?.unbindAll()
+        cameraExecutor.shutdown()
+    }
+}