react-native-biometrics-face 0.1.1 → 0.1.2

package/android/build.gradle

@@ -97,4 +97,10 @@ dependencies {
   
   // 4. GPU Delegate (Optional but recommended for performance)
   implementation 'org.tensorflow:tensorflow-lite-gpu:2.14.0'
+
+  def camerax_version = "1.3.0-alpha04" // or latest stable
+    implementation "androidx.camera:camera-core:${camerax_version}"
+    implementation "androidx.camera:camera-camera2:${camerax_version}"
+    implementation "androidx.camera:camera-lifecycle:${camerax_version}"
+    implementation "androidx.camera:camera-view:${camerax_version}"
 }

package/android/src/main/java/com/facerecognition/FaceRecognitionEngine.kt

@@ -3,39 +3,46 @@ package com.facerecognition
 import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
-import android.graphics.Rect
-import android.util.Base64
+import android.graphics.Matrix
+import android.graphics.RectF
+import android.net.Uri
 import com.google.mlkit.vision.common.InputImage
 import com.google.mlkit.vision.face.FaceDetection
 import com.google.mlkit.vision.face.FaceDetectorOptions
+import com.google.mlkit.vision.face.FaceLandmark
+import java.nio.ByteBuffer
+import java.util.concurrent.CountDownLatch
+import kotlin.math.abs
+import kotlin.math.atan2
+import kotlin.math.pow
+import kotlin.math.sqrt
 import org.tensorflow.lite.Interpreter
 import org.tensorflow.lite.support.common.FileUtil
 import org.tensorflow.lite.support.common.ops.NormalizeOp
 import org.tensorflow.lite.support.image.ImageProcessor
 import org.tensorflow.lite.support.image.TensorImage
 import org.tensorflow.lite.support.image.ops.ResizeOp
-import java.nio.ByteBuffer
-import java.util.concurrent.CountDownLatch
-import kotlin.math.pow
-import kotlin.math.sqrt
 
-class FaceRecognitionEngine(context: Context) {
+class FaceRecognitionEngine(private val context: Context) {
 
     // Configuration
     private val MODEL_NAME = "mobile_face_net.tflite"
     private val INPUT_SIZE = 112
-    private val OUTPUT_SIZE = 192 // mobile_face_net output vector size
-    private val THRESHOLD = 1.0f  // Standard threshold for mobile_face_net (adjust as needed)
-
-    // ML Kit Detector
-    private val detectorOptions = FaceDetectorOptions.Builder()
-        .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
-        .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
-        .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
-        .build()
+    private val OUTPUT_SIZE = 192
+    private val THRESHOLD = 1.0f
+
+    // ML Kit Detector - NOW WITH CLASSIFICATION (for Smile/Eyes)
+    private val detectorOptions =
+            FaceDetectorOptions.Builder()
+                    .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
+                    .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
+                    .setClassificationMode(
+                            FaceDetectorOptions.CLASSIFICATION_MODE_ALL
+                    ) // Enabled for Liveness
+                    .build()
+
     private val faceDetector = FaceDetection.getClient(detectorOptions)
 
-    // TFLite Interpreter
     private var interpreter: Interpreter? = null
 
     init {
@@ -47,110 +54,207 @@ class FaceRecognitionEngine(context: Context) {
         }
     }
 
-    fun verifyFaces(base64Source: String, base64Target: String): ApiResponse {
-        if (interpreter == null) {
-            return ApiResponse(500, "Model failed to load", null)
-        }
+    fun verifyFaces(sourceUriStr: String, targetUriStr: String, livenessMode: String): ApiResponse {
+        if (interpreter == null) return ApiResponse(500, "Model failed to load", null)
+
+        val sourceBitmap = decodeUri(sourceUriStr)
+        val targetBitmap = decodeUri(targetUriStr)
 
-        // 1. Decode Images
-        val sourceBitmap = decodeBase64(base64Source)
-        val targetBitmap = decodeBase64(base64Target)
-        
         if (sourceBitmap == null || targetBitmap == null) {
-            return ApiResponse(400, "Invalid Base64 input", null)
+            return ApiResponse(400, "Failed to decode image from URI", null)
         }
 
-        // 2. Detect & Crop Faces (Blocking Call for simplicity in this example)
-        val sourceFace = detectAndCrop(sourceBitmap)
-        val targetFace = detectAndCrop(targetBitmap)
-
+        // 1. Process Source (Reference Image) - No liveness check needed
+        val sourceFace =
+                detectAlignAndCrop(sourceBitmap, checkLiveness = false, requiredMode = "NONE")
         if (sourceFace.error != null) return sourceFace.error
+
+        // 2. Process Target (Live Selfie) - ENFORCE Liveness here
+        val targetFace =
+                detectAlignAndCrop(targetBitmap, checkLiveness = true, requiredMode = livenessMode)
         if (targetFace.error != null) return targetFace.error
 
-        // 3. Generate Embeddings
+        // 3. Generate Embeddings & Compare
         val sourceEmbedding = getEmbedding(sourceFace.bitmap!!)
         val targetEmbedding = getEmbedding(targetFace.bitmap!!)
 
-        // 4. Calculate Distance (Euclidean)
         var distance = 0f
         for (i in sourceEmbedding.indices) {
             distance += (sourceEmbedding[i] - targetEmbedding[i]).pow(2)
         }
         distance = sqrt(distance)
 
-        // 5. Calculate Accuracy (Simple mapping from distance)
-        // Note: This is a heuristic. distance 0 = 100%, distance > 1.2 = 0%
         val accuracy = (1.0f - (distance / 2.0f)).coerceIn(0.0f, 1.0f) * 100
         val isMatch = distance < THRESHOLD
 
-        return ApiResponse(200, "Comparison successful", VerificationResult(isMatch, distance, accuracy))
+        return ApiResponse(200, "Success", VerificationResult(isMatch, distance, accuracy))
     }
 
     // --- Helper Classes & Methods ---
 
     data class FaceResult(val bitmap: Bitmap? = null, val error: ApiResponse? = null)
 
-    private fun detectAndCrop(bitmap: Bitmap): FaceResult {
+    private fun decodeUri(uriString: String): Bitmap? {
+        return try {
+            val uri = Uri.parse(uriString)
+            val inputStream = context.contentResolver.openInputStream(uri)
+            BitmapFactory.decodeStream(inputStream)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            null
+        }
+    }
+
+    /** Detects, Checks Liveness, Aligns, and Crops. */
+    private fun detectAlignAndCrop(
+            bitmap: Bitmap,
+            checkLiveness: Boolean,
+            requiredMode: String
+    ): FaceResult {
         val latch = CountDownLatch(1)
         var result = FaceResult(error = ApiResponse(500, "Detection timeout"))
         val inputImage = InputImage.fromBitmap(bitmap, 0)
 
-        faceDetector.process(inputImage)
-            .addOnSuccessListener { faces ->
-                if (faces.isEmpty()) {
-                    result = FaceResult(error = ApiResponse(400, "No face detected"))
-                } else if (faces.size > 1) {
-                    result = FaceResult(error = ApiResponse(400, "Multiple faces detected"))
-                } else {
-                    val face = faces[0]
-                    val bounds = face.boundingBox
-                    // Ensure bounds are within bitmap dimensions
-                    val left = bounds.left.coerceAtLeast(0)
-                    val top = bounds.top.coerceAtLeast(0)
-                    val width = bounds.width().coerceAtMost(bitmap.width - left)
-                    val height = bounds.height().coerceAtMost(bitmap.height - top)
-                    
-                    val cropped = Bitmap.createBitmap(bitmap, left, top, width, height)
-                    result = FaceResult(bitmap = cropped)
+        faceDetector
+                .process(inputImage)
+                .addOnSuccessListener { faces ->
+                    if (faces.isEmpty()) {
+                        result = FaceResult(error = ApiResponse(400, "No face detected"))
+                    } else {
+                        val face = faces[0]
+
+                        // --- LIVENESS CHECK START (Only for Target) ---
+                        if (checkLiveness) {
+                            // 1. Head Rotation Check (Must look at camera)
+                            // Euler Y is the left/right head turn. We want it close to 0.
+                            val rotY = face.headEulerAngleY
+                            if (abs(rotY) > 12) { // Allow +/- 12 degrees
+                                result =
+                                        FaceResult(
+                                                error =
+                                                        ApiResponse(
+                                                                400,
+                                                                "Liveness Failed: Please look directly at the camera."
+                                                        )
+                                        )
+                                latch.countDown()
+                                return@addOnSuccessListener
+                            }
+
+                            // 2. Smile Check
+                            if (requiredMode == "SMILE") {
+                                val smileProb = face.smilingProbability ?: 0f
+                                if (smileProb < 0.8f) { // 80% confidence
+                                    result =
+                                            FaceResult(
+                                                    error =
+                                                            ApiResponse(
+                                                                    400,
+                                                                    "Liveness Failed: You must smile to verify."
+                                                            )
+                                            )
+                                    latch.countDown()
+                                    return@addOnSuccessListener
+                                }
+                            }
+                        }
+                        // --- LIVENESS CHECK END ---
+
+                        // --- ALIGNMENT LOGIC ---
+                        var finalBitmap = bitmap
+                        var finalBounds = RectF(face.boundingBox)
+                        val leftEye = face.getLandmark(FaceLandmark.LEFT_EYE)
+                        val rightEye = face.getLandmark(FaceLandmark.RIGHT_EYE)
+
+                        if (leftEye != null && rightEye != null) {
+                            val deltaX = rightEye.position.x - leftEye.position.x
+                            val deltaY = rightEye.position.y - leftEye.position.y
+                            val angle = Math.toDegrees(atan2(deltaY.toDouble(), deltaX.toDouble()))
+
+                            if (abs(angle) > 1.0) {
+                                val matrix = Matrix()
+                                val centerX = finalBounds.centerX()
+                                val centerY = finalBounds.centerY()
+                                matrix.postRotate(angle.toFloat(), centerX, centerY)
+
+                                val rotatedBitmap =
+                                        Bitmap.createBitmap(
+                                                bitmap,
+                                                0,
+                                                0,
+                                                bitmap.width,
+                                                bitmap.height,
+                                                matrix,
+                                                true
+                                        )
+                                matrix.mapRect(finalBounds)
+                                finalBitmap = rotatedBitmap
+                            }
+                        }
+
+                        val left = finalBounds.left.toInt().coerceAtLeast(0)
+                        val top = finalBounds.top.toInt().coerceAtLeast(0)
+                        val width =
+                                finalBounds.width().toInt().coerceAtMost(finalBitmap.width - left)
+                        val height =
+                                finalBounds.height().toInt().coerceAtMost(finalBitmap.height - top)
+
+                        if (width > 0 && height > 0) {
+                            val cropped = Bitmap.createBitmap(finalBitmap, left, top, width, height)
+                            result = FaceResult(bitmap = cropped)
+                        } else {
+                            result = FaceResult(error = ApiResponse(400, "Invalid face crop area"))
+                        }
+                    }
+                    latch.countDown()
                 }
-                latch.countDown()
-            }
-            .addOnFailureListener {
-                result = FaceResult(error = ApiResponse(500, "Detection failed: ${it.message}"))
-                latch.countDown()
-            }
-        
-        try { latch.await() } catch (e: InterruptedException) { }
+                .addOnFailureListener {
+                    result = FaceResult(error = ApiResponse(500, "Detection failed: ${it.message}"))
+                    latch.countDown()
+                }
+
+        try {
+            latch.await()
+        } catch (e: InterruptedException) {}
         return result
     }
 
     private fun getEmbedding(bitmap: Bitmap): FloatArray {
-        // Pre-process: Resize -> Normalize ( -128 / 128 )
-        val imageProcessor = ImageProcessor.Builder()
-            .add(ResizeOp(INPUT_SIZE, INPUT_SIZE, ResizeOp.ResizeMethod.BILINEAR))
-            .add(NormalizeOp(127.5f, 127.5f)) // Normalize to [-1, 1] for mobile_face_net
-            .build()
+        val imageProcessor =
+                ImageProcessor.Builder()
+                        .add(ResizeOp(INPUT_SIZE, INPUT_SIZE, ResizeOp.ResizeMethod.BILINEAR))
+                        .add(NormalizeOp(127.5f, 127.5f)) // Normalize Input to [-1, 1]
+                        .build()
 
         var tensorImage = TensorImage.fromBitmap(bitmap)
         tensorImage = imageProcessor.process(tensorImage)
 
-        val outputBuffer = ByteBuffer.allocateDirect(OUTPUT_SIZE * 4) // Float (4 bytes)
+        val outputBuffer = ByteBuffer.allocateDirect(OUTPUT_SIZE * 4)
         outputBuffer.order(java.nio.ByteOrder.nativeOrder())
-        
+
         interpreter?.run(tensorImage.buffer, outputBuffer)
-        
+
         outputBuffer.rewind()
         val floatArray = FloatArray(OUTPUT_SIZE)
         outputBuffer.asFloatBuffer().get(floatArray)
-        return floatArray
-    }
 
-    private fun decodeBase64(base64Str: String): Bitmap? {
-        return try {
-            val decodedBytes = Base64.decode(base64Str, Base64.DEFAULT)
-            BitmapFactory.decodeByteArray(decodedBytes, 0, decodedBytes.size)
-        } catch (e: Exception) {
-            null
+        // ===============================================================
+        // 🚨 CRITICAL FIX: L2 NORMALIZE THE EMBEDDING VECTOR 🚨
+        // ===============================================================
+        var sumSq = 0f
+        for (f in floatArray) {
+            sumSq += f * f
         }
+        val norm = sqrt(sumSq)
+
+        // Divide every value by the vector's magnitude (norm)
+        if (norm > 0f) {
+            for (i in floatArray.indices) {
+                floatArray[i] = floatArray[i] / norm
+            }
+        }
+        // ===============================================================
+
+        return floatArray
     }
-}
+}

package/android/src/main/java/com/facerecognition/FaceRecognitionModule.kt

@@ -17,10 +17,10 @@ class FaceRecognitionModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    override fun verifyFaces(sourceImage: String, targetImage: String, promise: Promise) {
+    override fun verifyFaces(sourceUri: String, targetUri: String, livenessMode: String, promise: Promise) {
         CoroutineScope(Dispatchers.IO).launch {
             try {
-                val response = engine.verifyFaces(sourceImage, targetImage)
+                val response = engine.verifyFaces(sourceUri, targetUri, livenessMode)
                 promise.resolve(response.toWritableMap())
             } catch (e: Exception) {
                 val errorResponse = ApiResponse(500, "Native Module Error: ${e.message}")

package/android/src/main/java/com/facerecognition/FaceRecognitionPackage.kt

@@ -5,9 +5,12 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager // <--- Don't forget this import
 import java.util.HashMap
 
 class FaceRecognitionPackage : TurboReactPackage() {
+
+  // 1. Register Native Modules (Logic)
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
     return if (name == FaceRecognitionModule.NAME) {
       FaceRecognitionModule(reactContext)
@@ -16,12 +19,17 @@ class FaceRecognitionPackage : TurboReactPackage() {
     }
   }
 
+  // 2. Register Native Components (UI)
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    // Register the Camera Manager here so React Native can find <LivenessCameraView />
+    return listOf(LivenessCameraManager())
+  }
+
+  // 3. Register Package Info
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
     return ReactModuleInfoProvider {
       val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
       
-      // FIX: Set this to false. 
-      // This tells RN to load it via the standard Bridge, which matches our Java class.
       val isTurboModule = false 
       
       moduleInfos[FaceRecognitionModule.NAME] = ReactModuleInfo(

package/android/src/main/java/com/facerecognition/FaceRecognitionSpec.kt

@@ -7,5 +7,6 @@ import com.facebook.react.bridge.Promise
 abstract class FaceRecognitionSpec(reactContext: ReactApplicationContext) : 
   ReactContextBaseJavaModule(reactContext) {
 
-  abstract fun verifyFaces(sourceImage: String, targetImage: String, promise: Promise)
+  // Direct String argument
+  abstract fun verifyFaces(sourceUri: String, targetUri: String, livenessMode: String, promise: Promise)
 }

package/android/src/main/java/com/facerecognition/LivenessAnalyzer.kt

@@ -0,0 +1,75 @@
+package com.facerecognition
+
+import android.annotation.SuppressLint
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageProxy
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.face.FaceDetection
+import com.google.mlkit.vision.face.FaceDetectorOptions
+
+class LivenessAnalyzer(
+    private val livenessMode: String, // "BLINK" or "SMILE"
+    private val onLivenessDetected: () -> Unit
+) : ImageAnalysis.Analyzer {
+
+    private val detector = FaceDetection.getClient(
+        FaceDetectorOptions.Builder()
+            .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_FAST) // Fast for video stream
+            .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
+            .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL) // Needed for eyes/smile
+            .build()
+    )
+
+    private var isDetected = false
+    private var lastAnalysisTime = 0L
+
+    @SuppressLint("UnsafeOptInUsageError")
+    override fun analyze(imageProxy: ImageProxy) {
+        // Throttle analysis to ~5 FPS to save battery
+        val currentTime = System.currentTimeMillis()
+        if (currentTime - lastAnalysisTime < 200) { 
+            imageProxy.close()
+            return 
+        }
+        lastAnalysisTime = currentTime
+
+        val mediaImage = imageProxy.image
+        if (mediaImage != null && !isDetected) {
+            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
+
+            detector.process(image)
+                .addOnSuccessListener { faces ->
+                    if (faces.isNotEmpty()) {
+                        val face = faces[0]
+                        
+                        var passed = false
+                        
+                        if (livenessMode == "BLINK") {
+                            // Check if eyes are CLOSED
+                            val leftOpen = face.leftEyeOpenProbability ?: 1f
+                            val rightOpen = face.rightEyeOpenProbability ?: 1f
+                            if (leftOpen < 0.4f && rightOpen < 0.4f) {
+                                passed = true
+                            }
+                        } else if (livenessMode == "SMILE") {
+                            // Check if Smiling
+                            val smile = face.smilingProbability ?: 0f
+                            if (smile > 0.8f) {
+                                passed = true
+                            }
+                        }
+
+                        if (passed && !isDetected) {
+                            isDetected = true // Prevent double triggering
+                            onLivenessDetected()
+                        }
+                    }
+                }
+                .addOnCompleteListener {
+                    imageProxy.close()
+                }
+        } else {
+            imageProxy.close()
+        }
+    }
+}

package/android/src/main/java/com/facerecognition/LivenessCameraManager.kt

@@ -0,0 +1,34 @@
+package com.facerecognition
+
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class LivenessCameraManager : SimpleViewManager<LivenessCameraView>() {
+
+    override fun getName() = "LivenessCameraView"
+
+    override fun createViewInstance(reactContext: ThemedReactContext): LivenessCameraView {
+        return LivenessCameraView(reactContext) 
+        // REMOVED: view.post { view.startCamera() }
+        // The View now handles this itself in onAttachedToWindow
+    }
+
+    @ReactProp(name = "livenessMode")
+    fun setLivenessMode(view: LivenessCameraView, mode: String?) {
+        view.livenessMode = mode ?: "BLINK"
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+        return MapBuilder.of(
+            "onCapture",
+            MapBuilder.of("registrationName", "onCapture")
+        )
+    }
+    
+    override fun onDropViewInstance(view: LivenessCameraView) {
+        super.onDropViewInstance(view)
+        view.stopCamera()
+    }
+}

package/android/src/main/java/com/facerecognition/LivenessCameraView.kt

@@ -0,0 +1,199 @@
+package com.facerecognition
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import android.net.Uri
+import android.util.Log
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.Toast
+import androidx.camera.core.*
+import androidx.camera.lifecycle.ProcessCameraProvider
+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.uimanager.events.RCTEventEmitter
+import java.io.File
+import java.io.FileOutputStream
+import java.nio.ByteBuffer
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+class LivenessCameraView(context: Context) : FrameLayout(context) {
+
+    private val previewView: PreviewView = PreviewView(context)
+    private var cameraProvider: ProcessCameraProvider? = null
+    private var imageCapture: ImageCapture? = null
+    private val cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+    
+    var livenessMode: String = "BLINK" 
+    private var isCameraStarted = false
+
+    init {
+        layoutParams = LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            ViewGroup.LayoutParams.MATCH_PARENT
+        )
+        previewView.layoutParams = LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            ViewGroup.LayoutParams.MATCH_PARENT
+        )
+        previewView.implementationMode = PreviewView.ImplementationMode.COMPATIBLE
+        previewView.scaleType = PreviewView.ScaleType.FILL_CENTER
+        addView(previewView)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        if (!isCameraStarted) startCamera()
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        stopCamera()
+    }
+
+    override fun requestLayout() {
+        super.requestLayout()
+        post(measureAndLayout)
+    }
+
+    private val measureAndLayout = Runnable {
+        measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+        )
+        layout(left, top, right, bottom)
+    }
+
+    private fun startCamera() {
+        if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
+            Toast.makeText(context, "ERR: Camera Permission Missing!", Toast.LENGTH_LONG).show()
+            return
+        }
+
+        val cameraProviderFuture = ProcessCameraProvider.getInstance(context)
+        cameraProviderFuture.addListener({
+            try {
+                cameraProvider = cameraProviderFuture.get()
+                bindCameraUseCases()
+                isCameraStarted = true
+            } catch (e: Exception) {
+                Log.e("LivenessCamera", "Failed to get camera provider", e)
+            }
+        }, ContextCompat.getMainExecutor(context))
+    }
+
+    private fun bindCameraUseCases() {
+        val cameraProvider = cameraProvider ?: return
+        
+        val preview = Preview.Builder().build()
+        preview.setSurfaceProvider(previewView.surfaceProvider)
+
+        val imageAnalyzer = ImageAnalysis.Builder()
+            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+            .build()
+            
+        imageAnalyzer.setAnalyzer(cameraExecutor, LivenessAnalyzer(livenessMode) {
+            takePhoto()
+        })
+
+        imageCapture = ImageCapture.Builder().build()
+        val cameraSelector = CameraSelector.DEFAULT_FRONT_CAMERA
+
+        try {
+            cameraProvider.unbindAll()
+            val lifecycleOwner = getLifecycleOwner(context)
+            if (lifecycleOwner != null) {
+                cameraProvider.bindToLifecycle(
+                    lifecycleOwner, cameraSelector, preview, imageCapture, imageAnalyzer
+                )
+            }
+        } catch (exc: Exception) {
+            Log.e("LivenessCamera", "Use case binding failed", exc)
+        }
+    }
+
+    private fun getLifecycleOwner(context: Context): LifecycleOwner? {
+        if (context is LifecycleOwner) return context
+        if (context is ReactContext) {
+            return context.currentActivity as? LifecycleOwner
+        }
+        return null
+    }
+
+    // --- FIX: Manual Capture to Flip Image ---
+    private fun takePhoto() {
+        val imageCapture = imageCapture ?: return
+
+        // Use InMemory Capture to process the Bitmap before saving
+        imageCapture.takePicture(
+            ContextCompat.getMainExecutor(context),
+            object : ImageCapture.OnImageCapturedCallback() {
+                override fun onError(exc: ImageCaptureException) {
+                    Log.e("LivenessCamera", "Capture Failed", exc)
+                }
+
+                override fun onCaptureSuccess(image: ImageProxy) {
+                    try {
+                        // 1. Convert ImageProxy to Bitmap
+                        val bitmap = imageProxyToBitmap(image)
+                        
+                        // 2. Prepare Matrix for Rotation & Mirroring
+                        val matrix = Matrix()
+                        matrix.postRotate(image.imageInfo.rotationDegrees.toFloat())
+                        
+                        // *** THE FIX: FLIP HORIZONTALLY ***
+                        // This makes the saved file match the mirrored preview
+                        matrix.postScale(-1f, 1f) 
+
+                        // 3. Create new Transformed Bitmap
+                        val finalBitmap = Bitmap.createBitmap(
+                            bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true
+                        )
+
+                        // 4. Save to File
+                        val photoFile = File(context.externalCacheDir, "liveness_${System.currentTimeMillis()}.jpg")
+                        val out = FileOutputStream(photoFile)
+                        finalBitmap.compress(Bitmap.CompressFormat.JPEG, 90, out)
+                        out.flush()
+                        out.close()
+
+                        // 5. Send Result
+                        val savedUri = Uri.fromFile(photoFile)
+                        sendEvent(savedUri.toString())
+
+                    } catch (e: Exception) {
+                        Log.e("LivenessCamera", "Bitmap processing failed", e)
+                    } finally {
+                        image.close() // Always close the proxy
+                    }
+                }
+            }
+        )
+    }
+
+    private fun imageProxyToBitmap(image: ImageProxy): Bitmap {
+        val buffer: ByteBuffer = image.planes[0].buffer
+        val bytes = ByteArray(buffer.remaining())
+        buffer.get(bytes)
+        return BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+    }
+
+    private fun sendEvent(uri: String) {
+        val reactContext = context as ReactContext
+        val event = Arguments.createMap().apply { putString("uri", uri) }
+        reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, "onCapture", event)
+    }
+    
+    fun stopCamera() {
+        isCameraStarted = false
+        try { cameraProvider?.unbindAll() } catch(e: Exception) {}
+    }
+}

package/lib/module/index.js

@@ -1,16 +1,36 @@
 "use strict";
 
-import FaceRecognition from "./NativeFaceRecognition.js";
+import { NativeModules, Platform, requireNativeComponent } from 'react-native';
 
-// We export the types so your app can use them
+// --- 1. Define Types ---
+
+// Type for the Liveness Camera Props
+
+// --- 2. Safe Native Module Access ---
+const LINKING_ERROR = `The package 'react-native-face-recognition' doesn't seem to be linked. Make sure: \n\n` + Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
+const FaceRecognitionModule = NativeModules.FaceRecognition ? NativeModules.FaceRecognition : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+
+// --- 3. Export Public API ---
 
 /**
- * Verifies if two faces match.
- * * @param sourceImage Base64 string of the first image
- * @param targetImage Base64 string of the second image
- * @returns Promise resolving to the VerificationResponse object
+ * Verifies if two faces match using the Native Engine.
+ * * @param sourceUri - URI of the reference photo (gallery)
+ * @param targetUri - URI of the live selfie (camera)
+ * @param livenessMode - (Optional) "SMILE" or "BLINK" or "NONE"
  */
-export function verifyFaces(sourceImage, targetImage) {
-  return FaceRecognition.verifyFaces(sourceImage, targetImage);
-}
+export const verifyFaces = (sourceUri, targetUri, livenessMode = 'NONE') => {
+  return FaceRecognitionModule.verifyFaces(sourceUri, targetUri, livenessMode);
+};
+
+// --- 4. Export Native Camera Component ---
+// This allows you to import { LivenessCameraView } from 'your-package'
+export const LivenessCameraView = requireNativeComponent('LivenessCameraView');
+export default FaceRecognitionModule;
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["FaceRecognition","verifyFaces","sourceImage","targetImage"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,eAAe,MAAM,4BAAyB;;AAGrD;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,WAAWA,CACzBC,WAAmB,EACnBC,WAAmB,EACY;EAC/B,OAAOH,eAAe,CAACC,WAAW,CAACC,WAAW,EAAEC,WAAW,CAAC;AAC9D","ignoreList":[]}
+{"version":3,"names":["NativeModules","Platform","requireNativeComponent","LINKING_ERROR","select","ios","default","FaceRecognitionModule","FaceRecognition","Proxy","get","Error","verifyFaces","sourceUri","targetUri","livenessMode","LivenessCameraView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SACEA,aAAa,EACbC,QAAQ,EACRC,sBAAsB,QACjB,cAAc;;AAGrB;;AAaA;;AAMA;AACA,MAAMC,aAAa,GACjB,wFAAwF,GACxFF,QAAQ,CAACG,MAAM,CAAC;EAAEC,GAAG,EAAE,gCAAgC;EAAEC,OAAO,EAAE;AAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,+BAA+B;AAEjC,MAAMC,qBAAqB,GAAGP,aAAa,CAACQ,eAAe,GACvDR,aAAa,CAACQ,eAAe,GAC7B,IAAIC,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACR,aAAa,CAAC;EAChC;AACF,CACF,CAAC;;AAEL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMS,WAAW,GAAGA,CACzBC,SAAiB,EACjBC,SAAiB,EACjBC,YAAwC,GAAG,MAAM,KACf;EAClC,OAAOR,qBAAqB,CAACK,WAAW,CAACC,SAAS,EAAEC,SAAS,EAAEC,YAAY,CAAC;AAC9E,CAAC;;AAED;AACA;AACA,OAAO,MAAMC,kBAAkB,GAAGd,sBAAsB,CACtD,oBACF,CAAC;AAED,eAAeK,qBAAqB","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -1,10 +1,30 @@
-import type { VerificationResponse } from './NativeFaceRecognition';
-export type { VerificationResponse, FaceVerificationResult } from './NativeFaceRecognition';
+import type { ViewProps } from 'react-native';
+export interface FaceVerificationResult {
+    isMatch: boolean;
+    distance: number;
+    accuracy: number;
+}
+export interface VerificationResponse {
+    statusCode: number;
+    message: string;
+    result: FaceVerificationResult | null;
+}
+interface LivenessCameraProps extends ViewProps {
+    livenessMode?: 'BLINK' | 'SMILE';
+    onCapture?: (event: {
+        nativeEvent: {
+            uri: string;
+        };
+    }) => void;
+}
+declare const FaceRecognitionModule: any;
 /**
- * Verifies if two faces match.
- * * @param sourceImage Base64 string of the first image
- * @param targetImage Base64 string of the second image
- * @returns Promise resolving to the VerificationResponse object
+ * Verifies if two faces match using the Native Engine.
+ * * @param sourceUri - URI of the reference photo (gallery)
+ * @param targetUri - URI of the live selfie (camera)
+ * @param livenessMode - (Optional) "SMILE" or "BLINK" or "NONE"
  */
-export declare function verifyFaces(sourceImage: string, targetImage: string): Promise<VerificationResponse>;
+export declare const verifyFaces: (sourceUri: string, targetUri: string, livenessMode?: "SMILE" | "BLINK" | "NONE") => Promise<VerificationResponse>;
+export declare const LivenessCameraView: import("react-native").HostComponent<LivenessCameraProps>;
+export default FaceRecognitionModule;
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAGpE,YAAY,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAE5F;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,oBAAoB,CAAC,CAE/B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9C,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAAC;CACvC;AAGD,UAAU,mBAAoB,SAAQ,SAAS;IAC7C,YAAY,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,WAAW,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,KAAK,IAAI,CAAC;CAC/D;AASD,QAAA,MAAM,qBAAqB,KAStB,CAAC;AAIN;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACtB,WAAW,MAAM,EACjB,WAAW,MAAM,EACjB,eAAc,OAAO,GAAG,OAAO,GAAG,MAAe,KAChD,OAAO,CAAC,oBAAoB,CAE9B,CAAC;AAIF,eAAO,MAAM,kBAAkB,2DAE9B,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-biometrics-face",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Detect, Recognition face in offline",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/index.tsx

@@ -1,18 +1,67 @@
-import FaceRecognition from './NativeFaceRecognition';
-import type { VerificationResponse } from './NativeFaceRecognition';
+import { 
+  NativeModules, 
+  Platform, 
+  requireNativeComponent
+} from 'react-native';
+import type { ViewProps } from 'react-native';
 
-// We export the types so your app can use them
-export type { VerificationResponse, FaceVerificationResult } from './NativeFaceRecognition';
+// --- 1. Define Types ---
+export interface FaceVerificationResult {
+  isMatch: boolean;
+  distance: number;
+  accuracy: number;
+}
+
+export interface VerificationResponse {
+  statusCode: number;
+  message: string;
+  result: FaceVerificationResult | null;
+}
+
+// Type for the Liveness Camera Props
+interface LivenessCameraProps extends ViewProps {
+  livenessMode?: 'BLINK' | 'SMILE';
+  onCapture?: (event: { nativeEvent: { uri: string } }) => void;
+}
+
+// --- 2. Safe Native Module Access ---
+const LINKING_ERROR =
+  `The package 'react-native-face-recognition' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+const FaceRecognitionModule = NativeModules.FaceRecognition
+  ? NativeModules.FaceRecognition
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+// --- 3. Export Public API ---
 
 /**
- * Verifies if two faces match.
- * * @param sourceImage Base64 string of the first image
- * @param targetImage Base64 string of the second image
- * @returns Promise resolving to the VerificationResponse object
+ * Verifies if two faces match using the Native Engine.
+ * * @param sourceUri - URI of the reference photo (gallery)
+ * @param targetUri - URI of the live selfie (camera)
+ * @param livenessMode - (Optional) "SMILE" or "BLINK" or "NONE"
  */
-export function verifyFaces(
-  sourceImage: string,
-  targetImage: string
-): Promise<VerificationResponse> {
-  return FaceRecognition.verifyFaces(sourceImage, targetImage);
-}
+export const verifyFaces = (
+  sourceUri: string, 
+  targetUri: string, 
+  livenessMode: 'SMILE' | 'BLINK' | 'NONE' = 'NONE'
+): Promise<VerificationResponse> => {
+  return FaceRecognitionModule.verifyFaces(sourceUri, targetUri, livenessMode);
+};
+
+// --- 4. Export Native Camera Component ---
+// This allows you to import { LivenessCameraView } from 'your-package'
+export const LivenessCameraView = requireNativeComponent<LivenessCameraProps>(
+  'LivenessCameraView'
+);
+
+export default FaceRecognitionModule;