react-native-biometrics-face 0.1.0 → 0.1.2

package/FaceRecognition.podspec

@@ -16,5 +16,9 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
   s.private_header_files = "ios/**/*.h"
 
+  s.resources    = "ios/Resources/*.tflite" # Auto-bundle the model
+  s.dependency "GoogleMLKit/FaceDetection"
+  s.dependency "TensorFlowLiteSwift"
+
   install_modules_dependencies(s)
 end

package/README.md

@@ -1,37 +1,98 @@
-# react-native-face-recognition
+# react-native-biometrics-face
 
-Detect, Recognition face in offline
+A powerful, offline face recognition and verification library for React
+Native.
 
-## Installation
+It uses Google ML Kit for high-speed face detection and TensorFlow Lite
+(mobile_face_net) for accurate face recognition. It compares two face
+images and determines if they belong to the same person.
 
+## 🚀 Features
 
-```sh
-npm install react-native-face-recognition
+-   **100% Offline**: No internet connection required. Your data stays
+    on the device.
+-   **Fast & Accurate**: Uses mobile-optimized AI models.
+-   **Privacy First**: No images are sent to any cloud server.
+-   **Cross Platform**: Works on iOS (Swift) and Android (Kotlin).
+-   **New Architecture Support**: Fully compatible with React Native's
+    New Architecture (Fabric) and the Old Architecture.
+
+## 📦 Installation
+
+``` bash
+yarn add react-native-biometrics-face
+# or
+npm install react-native-biometrics-face
+```
+
+### iOS Setup
+
+``` bash
+cd ios
+pod install
 ```
 
+### Android Setup
 
-## Usage
+No additional setup is required. The library automatically links the
+necessary ML models.
 
+## 📸 Permissions
 
-```js
-import { multiply } from 'react-native-face-recognition';
+This library processes Base64 images. It does not access the camera
+directly.
 
-// ...
+### iOS (Info.plist)
 
-const result = multiply(3, 7);
+``` xml
+<key>NSCameraUsageDescription</key>
+<string>We need access to the camera to verify your identity.</string>
 ```
 
+### Android (AndroidManifest.xml)
 
-## Contributing
+``` xml
+<uses-permission android:name="android.permission.CAMERA" />
+```
 
-- [Development workflow](CONTRIBUTING.md#development-workflow)
-- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
-- [Code of conduct](CODE_OF_CONDUCT.md)
+## 💻 Usage
 
-## License
+``` ts
+import { verifyFaces } from 'react-native-biometrics-face';
 
-MIT
+const compareFaces = async (sourceImageBase64: string, targetImageBase64: string) => {
+  const response = await verifyFaces(sourceImageBase64, targetImageBase64);
 
----
+  if (response.result?.isMatch) {
+    console.log("Faces Match!", response.result.accuracy);
+  } else {
+    console.log("Faces Do Not Match");
+  }
+};
+```
+
+## 📄 Response Format
+
+``` ts
+{
+  statusCode: number;
+  message: string;
+  result: {
+    isMatch: boolean;
+    distance: number;
+    accuracy: number;
+  } | null;
+}
+```
+
+## 🔧 Troubleshooting
+
+-   **Model file not found (Android)**: Ensure assets are not stripped.
+-   **iOS linker issues**: Run `pod install` again.
+-   **Multiple faces detected**: Ensure only one face is visible.
+
+## 📜 License
+
+MIT
 
-Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+Developed with ❤️ by Vasanth

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/ios/FaceRecognition.m

@@ -0,0 +1,15 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(FaceRecognition, NSObject)
+
+RCT_EXTERN_METHOD(verifyFaces:(NSString *)sourceBase64
+                  targetImage:(NSString *)targetBase64
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/FaceRecognition.swift

@@ -0,0 +1,241 @@
+import Foundation
+import React
+import MLKitFaceDetection
+import MLKitVision
+import TensorFlowLite
+import Accelerate
+
+@objc(FaceRecognition)
+class FaceRecognition: NSObject {
+    
+    // Configuration matching Android
+    let MODEL_NAME = "mobile_face_net"
+    let MODEL_EXTENSION = "tflite"
+    let INPUT_SIZE = 112
+    let OUTPUT_SIZE = 192
+    let THRESHOLD: Float = 1.0
+
+    // Lazy load TFLite Interpreter
+    lazy var interpreter: Interpreter? = {
+        do {
+            // Find the model in the generic bundle or the main bundle
+            let frameworkBundle = Bundle(for: type(of: self))
+            guard let modelPath = frameworkBundle.path(forResource: MODEL_NAME, ofType: MODEL_EXTENSION) else {
+                print("❌ Failed to find model file: \(MODEL_NAME).\(MODEL_EXTENSION)")
+                return nil
+            }
+            let interpreter = try Interpreter(modelPath: modelPath)
+            try interpreter.allocateTensors()
+            return interpreter
+        } catch {
+            print("❌ TFLite Init Error: \(error)")
+            return nil
+        }
+    }()
+    
+    // --- EXPOSED METHOD ---
+    @objc(verifyFaces:targetImage:resolve:reject:)
+    func verifyFaces(_ sourceBase64: String, targetImage targetBase64: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        
+        // 1. Decode Images
+        guard let sourceImg = decodeBase64(sourceBase64),
+              let targetImg = decodeBase64(targetBase64) else {
+            resolve(formatResponse(400, "Invalid Base64 input", nil))
+            return
+        }
+        
+        // Use DispatchGroup to process both images in parallel
+        let group = DispatchGroup()
+        var sourceFace: UIImage?
+        var targetFace: UIImage?
+        var errorMsg: String?
+        
+        // 2. Process Source
+        group.enter()
+        detectAndCrop(image: sourceImg) { cropped, error in
+            if let err = error { errorMsg = "Source: \(err)" }
+            sourceFace = cropped
+            group.leave()
+        }
+        
+        // 3. Process Target
+        group.enter()
+        detectAndCrop(image: targetImg) { cropped, error in
+            if let err = error { errorMsg = "Target: \(err)" }
+            targetFace = cropped
+            group.leave()
+        }
+        
+        // 4. Final Verification
+        group.notify(queue: .global(qos: .userInitiated)) {
+            if let err = errorMsg {
+                resolve(self.formatResponse(400, err, nil))
+                return
+            }
+            
+            guard let sFace = sourceFace, let tFace = targetFace else {
+                resolve(self.formatResponse(500, "Processing failed", nil))
+                return
+            }
+            
+            // 5. Get Embeddings
+            guard let sourceEmb = self.getEmbedding(image: sFace),
+                  let targetEmb = self.getEmbedding(image: tFace) else {
+                resolve(self.formatResponse(500, "Model inference failed", nil))
+                return
+            }
+            
+            // 6. Euclidean Distance
+            var sum: Float = 0
+            for i in 0..<self.OUTPUT_SIZE {
+                let diff = sourceEmb[i] - targetEmb[i]
+                sum += diff * diff
+            }
+            let distance = sqrt(sum)
+            
+            // 7. Accuracy Calculation
+            // Map distance 0 -> 100%, 1.2 -> 40%, >2.0 -> 0%
+            let accuracy = max(0, min(100, (1.0 - (distance / 2.0)) * 100))
+            let isMatch = distance < self.THRESHOLD
+            
+            let result: [String: Any] = [
+                "isMatch": isMatch,
+                "distance": distance,
+                "accuracy": accuracy
+            ]
+            
+            resolve(self.formatResponse(200, "Success", result))
+        }
+    }
+    
+    // --- HELPERS ---
+    
+    func detectAndCrop(image: UIImage, completion: @escaping (UIImage?, String?) -> Void) {
+        let options = FaceDetectorOptions()
+        options.performanceMode = .accurate
+        options.landmarkMode = .none
+        options.classificationMode = .none
+        
+        let detector = FaceDetector.faceDetector(options: options)
+        let visionImage = VisionImage(image: image)
+        visionImage.orientation = image.imageOrientation
+        
+        detector.process(visionImage) { faces, error in
+            guard error == nil, let faces = faces, !faces.isEmpty else {
+                completion(nil, "No face detected")
+                return
+            }
+            
+            if faces.count > 1 {
+                completion(nil, "Multiple faces detected")
+                return
+            }
+            
+            let face = faces[0]
+            let frame = face.frame
+            
+            // Crop Logic (Handle Retina scaling)
+            let scale = image.scale
+            let rect = CGRect(
+                x: frame.origin.x * scale,
+                y: frame.origin.y * scale, 
+                width: frame.size.width * scale,
+                height: frame.size.height * scale
+            )
+            
+            guard let cgImage = image.cgImage?.cropping(to: rect) else {
+                completion(nil, "Failed to crop")
+                return
+            }
+            
+            completion(UIImage(cgImage: cgImage), nil)
+        }
+    }
+    
+    func getEmbedding(image: UIImage) -> [Float]? {
+        guard let interpreter = self.interpreter else { return nil }
+        
+        // Pre-process: Resize to 112x112 and Normalize [-1, 1]
+        guard let inputData = image.resizedAndNormalizedData(width: INPUT_SIZE, height: INPUT_SIZE) else {
+            return nil
+        }
+        
+        do {
+            try interpreter.copy(inputData, toInputAt: 0)
+            try interpreter.invoke()
+            let outputTensor = try interpreter.output(at: 0)
+            let outputData = outputTensor.data
+            
+            // Convert byte data to Float array
+            let floatArray = outputData.withUnsafeBytes {
+                Array($0.bindMemory(to: Float.self))
+            }
+            return floatArray
+        } catch {
+            print("Inference Error: \(error)")
+            return nil
+        }
+    }
+
+    func decodeBase64(_ str: String) -> UIImage? {
+        guard let data = Data(base64Encoded: str, options: .ignoreUnknownCharacters) else { return nil }
+        return UIImage(data: data)
+    }
+    
+    func formatResponse(_ code: Int, _ msg: String, _ result: [String: Any]?) -> [String: Any] {
+        var resp: [String: Any] = ["statusCode": code, "message": msg]
+        if let res = result { resp["result"] = res }
+        else { resp["result"] = NSNull() }
+        return resp
+    }
+}
+
+// --- IMAGE EXTENSION FOR TFLITE ---
+extension UIImage {
+    func resizedAndNormalizedData(width: Int, height: Int) -> Data? {
+        // 1. Resize Image Context
+        UIGraphicsBeginImageContextWithOptions(CGSize(width: width, height: height), true, 1.0)
+        self.draw(in: CGRect(x: 0, y: 0, width: width, height: height))
+        let newImage = UIGraphicsGetImageFromCurrentImageContext()
+        UIGraphicsEndImageContext()
+        
+        guard let cgImage = newImage?.cgImage else { return nil }
+        
+        // 2. Extract Pixels & Normalize
+        let size = width * height
+        var inputData = Data(capacity: size * 3 * 4) // 3 channels * 4 bytes (Float)
+        
+        let context = CGContext(
+            data: nil,
+            width: width,
+            height: height,
+            bitsPerComponent: 8,
+            bytesPerRow: width * 4,
+            space: CGColorSpaceCreateDeviceRGB(),
+            bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue
+        )
+        
+        context?.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
+        
+        guard let buffer = context?.data else { return nil }
+        
+        let pixelData = buffer.bindMemory(to: UInt8.self, capacity: width * height * 4)
+        
+        for i in 0..<size {
+            let offset = i * 4
+            let r = Float(pixelData[offset])
+            let g = Float(pixelData[offset + 1])
+            let b = Float(pixelData[offset + 2])
+            
+            // Normalize (val - 127.5) / 127.5  --> Range [-1.0, 1.0]
+            var normR = (r - 127.5) / 127.5
+            var normG = (g - 127.5) / 127.5
+            var normB = (b - 127.5) / 127.5
+            
+            inputData.append(Data(bytes: &normR, count: 4))
+            inputData.append(Data(bytes: &normG, count: 4))
+            inputData.append(Data(bytes: &normB, count: 4))
+        }
+        return inputData
+    }
+}

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.0",
+  "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;