react-native-vision-camera-spoof-detector 1.1.0 → 1.1.11

package/.npmignore

@@ -0,0 +1,16 @@
+**/build/
+**/.cxx/
+**/.gradle/
+**/node_modules/
+**/Pods/
+**/.swiftpm/
+**/DerivedData/
+**/xcuserdata/
+**/.idea/
+**/coverage/
+**/dist/
+**/tmp/
+**/.DS_Store
+**/local.properties
+**/*.iml
+*.log

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/android/CMakeLists.txt

@@ -0,0 +1,29 @@
+project(VisionCameraSpoofDetector)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME VisionCameraSpoofDetector)
+set(CMAKE_SUPPRESS_REGENERATION ON)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_ANDROID_STL_TYPE c++_shared)
+
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+)
+
+# Nitrogen-generated specs: this path is valid because the project root is android/
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/VisionCameraSpoofDetector+autolinking.cmake)
+
+find_library(LOG_LIB log)
+find_package(react-native-vision-camera REQUIRED)
+
+target_link_options(${PACKAGE_NAME} PRIVATE "-Wl,-z,max-page-size=16384")
+
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android
+        react-native-vision-camera::VisionCamera
+)

package/android/build.gradle

@@ -19,8 +19,15 @@ buildscript {
 
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
+apply from: '../nitrogen/generated/android/VisionCameraSpoofDetector+autolinking.gradle'
+
+def reactNativeArchitectures() {
+    def value = rootProject.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
 
 android {
+    namespace "com.margelo.nitro.camera.spoofdetector"
     compileSdkVersion rootProject.ext.compileSdkVersion
 
     defaultConfig {
@@ -35,7 +42,9 @@ android {
         // Needed for JSI / C++ build
         externalNativeBuild {
             cmake {
-                cppFlags "-std=c++17"
+                cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+                arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+                abiFilters (*reactNativeArchitectures())
             }
         }
     }
@@ -61,7 +70,7 @@ android {
 
     sourceSets {
         main {
-            assets.srcDirs = ['src/main/assets']
+            assets.srcDirs = ['../lib/assets']
         }
     }
 
@@ -91,10 +100,14 @@ android {
 
     externalNativeBuild {
         cmake {
-            path "src/main/cpp/CMakeLists.txt"
-            version "3.22.1"  // Optional: matches your installed CMake
+            path "CMakeLists.txt"
+            version "3.22.1"
         }
     }
+
+    buildFeatures {
+        prefab true
+    }
 }
 
 def isNewArchitectureEnabled() {
@@ -109,8 +122,10 @@ repositories {
 }
 
 dependencies {
-    // React Native
-    implementation "com.facebook.react:react-native:+"
+    implementation "androidx.camera:camera-core:1.7.0-alpha03"
+
+    // React Native and VisionCamera provide their native Prefab libraries.
+    compileOnly "com.facebook.react:react-android"
 
     // Kotlin
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
@@ -130,8 +145,9 @@ dependencies {
     // AndroidX - EXIF Support for image orientation
     implementation "androidx.exifinterface:exifinterface:1.3.6"
 
-    // VisionCamera 5 uses Nitro frame outputs backed by react-native-worklets.
-    implementation project(':react-native-vision-camera')
-    implementation project(':react-native-vision-camera-worklets')
-    implementation project(':react-native-worklets')
+    // VisionCamera 5 and Nitro provide these native libraries to the consuming app.
+    compileOnly project(':react-native-vision-camera')
+    compileOnly project(':react-native-vision-camera-worklets')
+    compileOnly project(':react-native-worklets')
+    compileOnly project(':react-native-nitro-modules')
 }

package/android/fix-prefab.gradle

@@ -0,0 +1,4 @@
+// This package does not need the forced prefab reconfigure workaround.
+// Leaving the task outputs as a normal Gradle up-to-date state prevents the
+// infinite CMake regeneration loop that was triggering
+// "ninja: error: manifest 'build.ninja' still dirty after 100 tries".

package/android/src/main/AndroidManifest.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.faceantispoof">
+    >
     <application>
         <meta-data
             android:name="com.google.mlkit.vision.DEPENDENCIES"

package/android/src/main/cpp/CMakeLists.txt

@@ -1,101 +1,33 @@
-cmake_minimum_required(VERSION 3.4.1)
-
-project(fastyuv)
-
-set(SOURCE_FILES
-    FastYuvJni.cpp
-    fast_yuv.cpp
-)
-
-add_library(fastyuv SHARED ${SOURCE_FILES})
-
-# Enable NEON SIMD optimizations for ARM architectures
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "armv7" OR CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-    # ARM NEON optimization flags
-    target_compile_options(fastyuv PRIVATE
-        -fPIC
-        -O3
-    )
-    
-    # ARM-specific NEON enablement (clang doesn't support -march=native for cross-compilation)
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "armv7")
-        # ARMv7 with NEON (32-bit ARM)
-        target_compile_options(fastyuv PRIVATE -march=armv7-a -mfpu=neon -mfloat-abi=softfp)
-    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-        # ARMv8 with full SIMD support (64-bit ARM)
-        target_compile_options(fastyuv PRIVATE -march=armv8-a)
-    endif()
-endif()
-
-# Always add libyuv include dir so headers like libyuv/convert.h are found.
-target_include_directories(fastyuv PRIVATE ${CMAKE_SOURCE_DIR}/libyuv/include)
-
-# Prefer using libyuv subproject if available.
-if (EXISTS ${CMAKE_SOURCE_DIR}/libyuv/CMakeLists.txt)
-    add_subdirectory(libyuv)
-    # Link against the libyuv target produced by that CMake. The lib creates
-    # targets named 'yuv' (static) and 'yuv_shared' (shared) whose output
-    # library name is 'libyuv'. Prefer the shared target when available.
-    if (TARGET yuv_shared)
-        target_link_libraries(fastyuv PRIVATE yuv_shared)
-    elseif (TARGET yuv)
-        target_link_libraries(fastyuv PRIVATE yuv)
-    endif()
-endif()
-
-# 支持 Android 15+ 的 16KB 页面大小
-# https://developer.android.com/guide/practices/page-sizes
-target_link_options(fastyuv PRIVATE "-Wl,-z,max-page-size=16384")
-
-# Android log
-find_library(log-lib log)
-target_link_libraries(fastyuv PRIVATE ${log-lib})
 cmake_minimum_required(VERSION 3.18)
-project(faceantispoof)
+project(VisionCameraSpoofDetector)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_SUPPRESS_REGENERATION ON)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_ANDROID_STL_TYPE c++_shared)
 
-get_filename_component(CMAKE_SOURCE_ABS "${CMAKE_SOURCE_DIR}" ABSOLUTE)
-# .../react-native-vision-camera-spoof-detector/android/src/main/cpp -> ../../../.. = .../node_modules
-get_filename_component(PARENT_1 "${CMAKE_SOURCE_ABS}/.." ABSOLUTE)  # main
-get_filename_component(PARENT_2 "${PARENT_1}/.." ABSOLUTE)  # src
-get_filename_component(PARENT_3 "${PARENT_2}/.." ABSOLUTE)  # android
-get_filename_component(PARENT_4 "${PARENT_3}/.." ABSOLUTE)  # react-native-vision-camera-spoof-detector
-get_filename_component(NODE_MODULES_ABS "${PARENT_4}/.." ABSOLUTE)  # node_modules
-
-set(REACT_NATIVE_DIR "${NODE_MODULES_ABS}/react-native")
-set(REACT_COMMON_DIR "${REACT_NATIVE_DIR}/ReactCommon")
-
-message(STATUS "NODE_MODULES_ABS: ${NODE_MODULES_ABS}")
-message(STATUS "REACT_NATIVE_DIR: ${REACT_NATIVE_DIR}")
-message(STATUS "REACT_COMMON_DIR: ${REACT_COMMON_DIR}")
+set(PACKAGE_NAME VisionCameraSpoofDetector)
+set(CMAKE_VERBOSE_MAKEFILE ON)
 
-# Compile JSI implementation
-file(GLOB JSI_CPP "${REACT_COMMON_DIR}/jsi/jsi/jsi.cpp")
-
-add_library(faceantispoof SHARED FaceAntiSpoofJSI.cpp ${JSI_CPP})
-
-target_include_directories(faceantispoof PRIVATE
-    "${REACT_COMMON_DIR}/jsi"
-    "${REACT_COMMON_DIR}/cxxreact"
-    "${REACT_COMMON_DIR}/callinvoker/ReactCommon"
-    "${REACT_COMMON_DIR}/runtimeexecutor/ReactCommon"
-    "${REACT_COMMON_DIR}"
+add_library(${PACKAGE_NAME} SHARED
+    cpp-adapter.cpp
 )
 
-find_library(log-lib log)
+# Nitrogen-generated hybrid bindings
+include(${CMAKE_SOURCE_DIR}/../../../../nitrogen/generated/android/VisionCameraSpoofDetector+autolinking.cmake)
+
+find_library(LOG_LIB log)
+find_package(react-native-vision-camera REQUIRED)
 
-# 支持 Android 15+ 的 16KB 页面大小
-target_link_options(faceantispoof PRIVATE "-Wl,-z,max-page-size=16384")
+# Android 15+ 16KB page support
+target_link_options(${PACKAGE_NAME} PRIVATE "-Wl,-z,max-page-size=16384")
 
 target_link_libraries(
-    faceantispoof
-    "${log-lib}"
-    c++_shared
-    atomic
-    m
+    ${PACKAGE_NAME}
+    ${LOG_LIB}
+    android
+    react-native-vision-camera::VisionCamera
 )