react-native-vision-camera-spoof-detector 1.1.10 → 1.1.15

package/README.md

@@ -19,13 +19,11 @@ High-performance face anti-spoofing and liveness detection module for React Nati
 
 ## 📋 Requirements
 
-- React Native >= 0.60.0
-- React Native Vision Camera `^4.6.4` or `^5.0.0`
-- `react-native-reanimated` `^3.0.0`
-- `react-native-worklets` `^0.12.0`
+- React Native >= 0.76.0
+- React Native Vision Camera `^5.0.0`
 - `react-native-vision-camera-worklets` `^5.0.0`
 - iOS 11.0 or later
-- react-native-vision-camera-face-detector (optional, for enhanced features)
+- `react-native-vision-camera-face-detector` (required for the face-gated example below)
 
 ## 📦 Installation
 
@@ -40,9 +38,9 @@ yarn add react-native-vision-camera-spoof-detector
 ### Step 2: Install peer dependencies
 
 ```bash
-npm install react-native-vision-camera react-native-reanimated react-native-worklets react-native-vision-camera-worklets
+npm install react-native-vision-camera react-native-reanimated react-native-worklets react-native-vision-camera-worklets react-native-vision-camera-face-detector
 # or
-yarn add react-native-vision-camera react-native-reanimated react-native-worklets react-native-vision-camera-worklets
+yarn add react-native-vision-camera react-native-reanimated react-native-worklets react-native-vision-camera-worklets react-native-vision-camera-face-detector
 ```
 
 ### Step 3: Configure iOS
@@ -82,213 +80,144 @@ react-native link react-native-vision-camera-spoof-detector
 
 ## 🚀 Quick Start
 
-> **Important:** Request camera permission before rendering `Camera`, and call `initializeFaceAntiSpoof()` once before the frame processor starts. The frame processor returns `null` until native initialization or a result is available. Native inference is throttled and may return the most recent result while another frame is being processed.
-
-### Simple Usage
+Vision Camera 5 uses camera outputs for this package. The anti-spoof output can be combined with the face detector output and enabled only while a face is visible.
 
 ```javascript
 import React, { useEffect, useState } from 'react';
-import { StyleSheet, Text, View } from 'react-native';
-import { Camera, useCameraDevices, useCameraPermission, useFrameProcessor } from 'react-native-vision-camera';
-import { faceAntiSpoofFrameProcessor, initializeFaceAntiSpoof } from 'react-native-vision-camera-spoof-detector';
-import { runOnJS } from 'react-native-reanimated';
-
-export default function App() {
-  const devices = useCameraDevices();
-  const device = devices.front;
+import { StyleSheet, Text, useWindowDimensions, View } from 'react-native';
+import {
+  Camera,
+  useCameraDevice,
+  useCameraPermission,
+} from 'react-native-vision-camera';
+import { useFaceDetectorOutput } from 'react-native-vision-camera-face-detector';
+import { useFaceAntiSpoofFrameOutput } from 'react-native-vision-camera-spoof-detector';
+
+const CameraScreen = () => {
+  const device = useCameraDevice('front');
   const { hasPermission, requestPermission } = useCameraPermission();
+  const { width: windowWidth, height: windowHeight } = useWindowDimensions();
+  const [faces, setFaces] = useState([]);
+  const [detectionError, setDetectionError] = useState(null);
   const [spoofResult, setSpoofResult] = useState(null);
 
   useEffect(() => {
     if (!hasPermission) requestPermission();
   }, [hasPermission, requestPermission]);
 
-  useEffect(() => {
-    initializeFaceAntiSpoof()
-      .then((success) => console.log('FaceAntiSpoof initialized:', success))
-      .catch((error) => console.error('FaceAntiSpoof initialization failed:', error));
-  }, []);
+  const faceDetectorOutput = useFaceDetectorOutput({
+    cameraFacing: 'front',
+    autoMode: true,
+    windowWidth,
+    windowHeight,
+    performanceMode: 'fast',
+    trackingEnabled: true,
+    onFacesDetected(detectedFaces) {
+      setDetectionError(null);
+      setFaces(detectedFaces);
+      if (detectedFaces.length === 0) setSpoofResult(null);
+    },
+    onError(error) {
+      setDetectionError(error.message);
+    },
+  });
 
-  const frameProcessor = useFrameProcessor((frame) => {
-    'worklet';
-    const result = faceAntiSpoofFrameProcessor(frame);
-    if (result) {
-      runOnJS(setSpoofResult)(result);
-    }
-  }, []);
+  const antiSpoofOutput = useFaceAntiSpoofFrameOutput({
+    onResult(result) {
+      setSpoofResult(result);
+    },
+  });
 
-  if (!hasPermission || device == null) return <Text>Waiting for camera permission...</Text>;
+  const outputs = faces.length > 0
+    ? [faceDetectorOutput, antiSpoofOutput]
+    : [faceDetectorOutput];
+
+  if (!hasPermission) return <Message text="Camera permission is required." />;
+  if (!device) return <Message text="No front camera is available." />;
 
   return (
     <View style={styles.container}>
       <Camera
         style={StyleSheet.absoluteFill}
         device={device}
-        isActive={true}
-        frameProcessor={frameProcessor}
-        frameProcessorFps={5}
+        isActive
+        outputs={outputs}
       />
-      {spoofResult && (
-        <View style={styles.resultContainer}>
-          <Text style={styles.resultText}>
-            Is Live: {spoofResult.isLive ? 'Yes' : 'No'}
-          </Text>
-          <Text style={styles.resultText}>
-            Score: {spoofResult.neuralNetworkScore?.toFixed(2)}
-          </Text>
-          <Text style={styles.resultText}>
-            Label: {spoofResult.label}
-          </Text>
-        </View>
-      )}
+
+      <View style={styles.statusContainer}>
+        <Text style={styles.statusText}>
+          {detectionError ?? `${faces.length} face${faces.length === 1 ? '' : 's'} detected`}
+        </Text>
+        <Text style={styles.statusText}>
+          {faces.length === 0
+            ? 'Waiting for face...'
+            : spoofResult
+              ? JSON.stringify(spoofResult)
+              : 'Anti-spoof processing...'}
+        </Text>
+      </View>
     </View>
   );
-}
+};
+
+const Message = ({ text }) => (
+  <View style={styles.messageContainer}>
+    <Text style={styles.messageText}>{text}</Text>
+  </View>
+);
 
 const styles = StyleSheet.create({
   container: { flex: 1 },
-  resultContainer: {
-    position: 'absolute',
-    bottom: 50,
-    left: 0,
-    right: 0,
+  messageContainer: {
+    flex: 1,
     alignItems: 'center',
-    backgroundColor: 'rgba(0,0,0,0.5)',
-    padding: 10,
+    justifyContent: 'center',
+    paddingHorizontal: 24,
   },
-  resultText: {
-    color: 'white',
-    fontSize: 20,
-    fontWeight: 'bold',
+  messageText: { fontSize: 16, textAlign: 'center' },
+  statusContainer: {
+    position: 'absolute',
+    top: 56,
+    alignSelf: 'center',
+    paddingHorizontal: 14,
+    paddingVertical: 8,
+    borderRadius: 16,
+    backgroundColor: 'rgba(0, 0, 0, 0.65)',
   },
+  statusText: { color: '#ffffff', fontSize: 14, marginVertical: 2 },
 });
+
+export default CameraScreen;
 ```
 
-### Advanced Usage with Full Feature Set
+The anti-spoof output callback receives a result after native inference. No manual `runOnJS`, frame processor, or explicit initialization call is required for this output API. The output may be omitted until a face is detected, as shown above.
 
-```javascript
-import { useCallback, useMemo, useEffect, useRef } from 'react';
-import { scheduleOnRN } from 'react-native-worklets';
-import { useFrameProcessor } from 'react-native-vision-camera';
-import { useFaceDetector } from 'react-native-vision-camera-face-detector';
-import {
-  faceAntiSpoofFrameProcessor,
-  initializeFaceAntiSpoof,
-  isFaceAntiSpoofAvailable,
-} from 'react-native-vision-camera-spoof-detector';
-
-const useFaceDetectionFrameProcessor = ({
-  onStableFaceDetected = () => { },
-  onFacesUpdate = () => { },
-  onLivenessUpdate = () => { },
-  onAntiSpoofUpdate = () => { },
-  showCodeScanner = false,
-  isLoading = false,
-  isActive = true,
-  livenessLevel = 0,
-  antispooflevel = 0.35,
-}) => {
-  const { detectFaces } = useFaceDetector({
-    performanceMode: 'fast',
-    landmarkMode: 'none',
-    contourMode: 'none',
-    classificationMode: livenessLevel === 1 ? 'all' : 'none',
-    minFaceSize: 0.2,
-  });
+## 📚 API Reference
 
-  const isMounted = useRef(true);
-  const antiSpoofInitialized = useRef(false);
-
-  const initializeAntiSpoof = useCallback(async () => {
-    if (antiSpoofInitialized.current) return true;
-    try {
-      const available = isFaceAntiSpoofAvailable?.();
-      if (!available) return false;
-      await initializeFaceAntiSpoof();
-      antiSpoofInitialized.current = true;
-      return true;
-    } catch (err) {
-      console.error('Anti-spoof initialization error:', err);
-      return false;
-    }
-  }, []);
+### `useFaceAntiSpoofFrameOutput(options?)`
 
-  useEffect(() => {
-    initializeAntiSpoof();
-  }, [initializeAntiSpoof]);
-
-  // Shared state for face tracking
-  const sharedState = useMemo(
-    () =>
-      Worklets.createSharedValue({
-        flags: {
-          captured: false,
-          showCodeScanner: showCodeScanner,
-          isActive: isActive,
-          hasSingleFace: false,
-          isFaceCentered: false,
-        },
-        antiSpoof: {
-          isLive: false,
-          confidence: 0,
-          consecutiveLiveFrames: 0,
-        },
-      }),
-    []
-  );
+Creates a Vision Camera 5 camera output for native anti-spoofing inference.
 
-  const frameProcessor = useFrameProcessor(
-    (frame) => {
-      'worklet';
-      
-      try {
-        const detected = detectFaces?.(frame);
-        
-        if (!detected || detected.length === 0) {
-          onFacesUpdate?.({ count: 0, progress: 0 });
-          return;
-        }
-
-        if (detected.length === 1 && !sharedState.value.flags.captured) {
-          const antiSpoofResult = faceAntiSpoofFrameProcessor?.(frame);
-          
-          if (antiSpoofResult?.isLive) {
-            sharedState.value.antiSpoof.isLive = true;
-            sharedState.value.antiSpoof.confidence = antiSpoofResult.combinedScore;
-            onAntiSpoofUpdate?.({
-              isLive: true,
-              confidence: antiSpoofResult.combinedScore,
-            });
-          }
-          
-          onFacesUpdate?.({ count: 1, progress: 50 });
-        } else {
-          onFacesUpdate?.({ count: detected.length, progress: 0 });
-        }
-      } catch (err) {
-        console.error('Frame processing error:', err);
-      } finally {
-        frame.release?.();
-      }
-    },
-    [detectFaces, isLoading]
-  );
+```javascript
+const antiSpoofOutput = useFaceAntiSpoofFrameOutput({
+  onResult(result) {
+    console.log(result);
+  },
+  onError(error) {
+    console.error(error);
+  },
+});
+```
 
-  return {
-    frameProcessor,
-    sharedState,
-    initializeAntiSpoof,
-  };
-};
+Pass the returned output in the `Camera` component's `outputs` array. The callback runs on the React Native runtime after native inference.
 
-export default useFaceDetectionFrameProcessor;
-```
+**Options**: `onResult(result)` and optional `onError(error)`.
 
-## 📚 API Reference
+---
 
 ### `initializeFaceAntiSpoof()`
 
-Initializes the face anti-spoofing module. Must be called before using the frame processor.
+Initializes the native module when an application needs an explicit startup check or model-loading diagnostics. It is not required when using `useFaceAntiSpoofFrameOutput()`.
 
 ```javascript
 const success = await initializeFaceAntiSpoof();
@@ -310,18 +239,6 @@ const available = isFaceAntiSpoofAvailable();
 
 ---
 
-### `faceAntiSpoofFrameProcessor(frame)`
-
-Process frame and get anti-spoofing result.
-
-```javascript
-const result = faceAntiSpoofFrameProcessor(frame);
-```
-
-**Parameters**: `frame` (Vision Camera Frame)
-
-**Returns**: `FaceAntiSpoofingResult | null`. On iOS, inference runs off the frame callback and the returned object can be the latest completed result.
-
 ### `FaceAntiSpoofingResult`
 
 ```typescript

package/VisionCameraSpoofDetector.podspec

@@ -0,0 +1,41 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name             = 'VisionCameraSpoofDetector'
+  s.version          = package['version']
+  s.summary          = package['description']
+  s.homepage         = package['homepage']
+  s.license          = package['license']
+  s.authors          = package['author']
+  s.platform         = :ios, '15.5'
+  s.source           = { :path => '.' }
+  s.swift_version    = '5.0'
+  s.pod_target_xcconfig = {
+    'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => 'arm64',
+    'HEADER_SEARCH_PATHS' => '$(inherited) ${PODS_TARGET_SRCROOT}/nitrogen/generated/shared/c++ ${PODS_TARGET_SRCROOT}/nitrogen/generated/ios ${PODS_TARGET_SRCROOT}/nitrogen/generated/ios/c++'
+  }
+
+  load 'nitrogen/generated/ios/VisionCameraSpoofDetector+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.source_files = [
+    'ios/**/*.{h,m,mm,swift,cpp,c,cc}',
+    'nitrogen/generated/shared/**/*.cpp',
+    'nitrogen/generated/ios/**/*.{cpp,mm,swift}',
+    'nitrogen/generated/ios/VisionCameraSpoofDetector-Swift-Cxx-Bridge.hpp',
+  ]
+  s.public_header_files = 'nitrogen/generated/ios/VisionCameraSpoofDetector-Swift-Cxx-Bridge.hpp'
+  s.private_header_files = [
+    'nitrogen/generated/shared/**/*.hpp',
+    'nitrogen/generated/ios/c++/**/*.{h,hpp}',
+  ]
+  s.resources = ['lib/assets/*']
+
+  s.dependency 'TensorFlowLiteSwift'
+  s.dependency 'VisionCamera'
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/ios/FaceAntiSpoofManager.swift

@@ -6,8 +6,17 @@ import TensorFlowLite
 
 @objcMembers
 public class FaceAntiSpoofManager: NSObject {
+    public struct DetectionResult {
+        let isLive: Bool
+        let neuralNetworkScore: Double
+        let laplacianScore: Double
+        let combinedScore: Double
+        let confidence: Double
+    }
+
     #if canImport(TensorFlowLite)
     public static var sharedInterpreter: Interpreter?
+    private static let interpreterLock = NSLock()
     #endif
 
     @objc public class func initializeModel() -> Bool {
@@ -15,11 +24,19 @@ public class FaceAntiSpoofManager: NSObject {
         if sharedInterpreter != nil { return true }
 
         // Look in main bundle then plugin bundle
-        var modelPath = Bundle.main.path(forResource: "FaceAntiSpoofing", ofType: "tflite")
+        var modelPath = Bundle.main.path(
+            forResource: "FaceAntiSpoofing",
+            ofType: "tflite",
+            inDirectory: "lib/assets"
+        ) ?? Bundle.main.path(forResource: "FaceAntiSpoofing", ofType: "tflite")
         if modelPath == nil {
-            if let fpsClass = NSClassFromString("FaceAntiSpoofFrameProcessor") as? AnyClass {
-                let podBundle = Bundle(for: fpsClass)
-                modelPath = podBundle.path(forResource: "FaceAntiSpoofing", ofType: "tflite")
+            if let managerClass = NSClassFromString("FaceAntiSpoofManager") {
+                let podBundle = Bundle(for: managerClass)
+                modelPath = podBundle.path(
+                    forResource: "FaceAntiSpoofing",
+                    ofType: "tflite",
+                    inDirectory: "lib/assets"
+                ) ?? podBundle.path(forResource: "FaceAntiSpoofing", ofType: "tflite")
             }
         }
 
@@ -54,6 +71,91 @@ public class FaceAntiSpoofManager: NSObject {
         #endif
     }
 
+    public class func process(input: [Float]) throws -> DetectionResult {
+        #if canImport(TensorFlowLite)
+        if sharedInterpreter == nil && !initializeModel() {
+            throw NSError(domain: "FaceAntiSpoof", code: 3, userInfo: [
+                NSLocalizedDescriptionKey: "Unable to initialize the TensorFlow Lite interpreter"
+            ])
+        }
+
+        interpreterLock.lock()
+        defer { interpreterLock.unlock() }
+
+        guard let interpreter = sharedInterpreter else {
+            throw NSError(domain: "FaceAntiSpoof", code: 1, userInfo: [
+                NSLocalizedDescriptionKey: "Interpreter not available"
+            ])
+        }
+
+        let inputData = input.withUnsafeBufferPointer { buffer in
+            Data(buffer: buffer)
+        }
+        try interpreter.copy(inputData, toInputAt: 0)
+        try interpreter.invoke()
+
+        let classOutput = try interpreter.output(at: 0).data.withUnsafeBytes { buffer in
+            Array(buffer.bindMemory(to: Float.self))
+        }
+        let maskOutput = try interpreter.output(at: 1).data.withUnsafeBytes { buffer in
+            Array(buffer.bindMemory(to: Float.self))
+        }
+        let count = min(classOutput.count, maskOutput.count)
+        let neuralScore = (0..<count).reduce(Float.zero) { total, index in
+            total + abs(classOutput[index]) * maskOutput[index]
+        }
+        let laplacianScore = calculateLaplacianScore(input)
+        let combinedScore = calculateCombinedScore(neuralScore, laplacianScore)
+        let confidence = combinedScore
+        let isLive = neuralScore < 0.2 && laplacianScore > 1000
+
+        return DetectionResult(
+            isLive: isLive,
+            neuralNetworkScore: Double(neuralScore),
+            laplacianScore: Double(laplacianScore),
+            combinedScore: Double(combinedScore),
+            confidence: Double(confidence)
+        )
+        #else
+        throw NSError(domain: "FaceAntiSpoof", code: 2, userInfo: [
+            NSLocalizedDescriptionKey: "TensorFlowLite is not available"
+        ])
+        #endif
+    }
+
+    private class func calculateLaplacianScore(_ input: [Float]) -> Int {
+        let width = 256
+        let height = 256
+        var grey = [Int](repeating: 0, count: width * height)
+        for index in 0..<(width * height) {
+            let offset = index * 3
+            grey[index] = Int(
+                (0.299 * input[offset] + 0.587 * input[offset + 1] + 0.114 * input[offset + 2]) * 255
+            )
+        }
+
+        let kernel = [[0, 1, 0], [1, -4, 1], [0, 1, 0]]
+        var score = 0
+        for y in 0..<(height - 2) {
+            for x in 0..<(width - 2) {
+                var result = 0
+                for ky in 0..<3 {
+                    for kx in 0..<3 {
+                        result += grey[(y + ky) * width + x + kx] * kernel[ky][kx]
+                    }
+                }
+                if result > 50 { score += 1 }
+            }
+        }
+        return score
+    }
+
+    private class func calculateCombinedScore(_ neuralScore: Float, _ laplacianScore: Int) -> Float {
+        let neural = min(max(neuralScore, 0), 1)
+        let laplacian = min(max(Float(laplacianScore) / 1000, 0), 1)
+        return ((1 - neural) * 0.6) + (laplacian * 0.4)
+    }
+
     @objc public class func cleanupModel() {
         #if canImport(TensorFlowLite)
         sharedInterpreter = nil