react-native-biometrics-face 0.1.0 → 0.1.1

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/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/package.json

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