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

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/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
 )
 
 

package/android/src/main/cpp/FaceAntiSpoofJSI.cpp

@@ -1,6 +1,8 @@
 #include <jni.h>
 #include <jsi/jsi.h>
 #include <string>
+#include <vector>
+#include <algorithm>
 #include <android/log.h>
 
 using namespace facebook;
@@ -8,18 +10,90 @@ using namespace facebook;
 // Logging macro
 #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FaceAntiSpoofJSI", __VA_ARGS__))
 
-// Dummy frame processing function
+static JavaVM *javaVm = nullptr;
+
 jsi::Value faceAntiSpoof(jsi::Runtime &runtime, const jsi::Value &frame) {
-    LOGI("FaceAntiSpoofJSI: frame received");
+    if (!frame.isObject()) {
+        throw jsi::JSError(runtime, "FaceAntiSpoof expected a Frame object");
+    }
 
-    jsi::Object result(runtime);
-    result.setProperty(runtime, "isLive", true);
-    result.setProperty(runtime, "label", "Live");
-    result.setProperty(runtime, "confidence", 0.99);
+    auto frameObject = frame.asObject(runtime);
+    auto planesValue = frameObject.getProperty(runtime, "getPlanes").asObject(runtime)
+        .asFunction(runtime).call(runtime, frameObject);
+    auto planes = planesValue.asObject(runtime);
+    auto length = static_cast<size_t>(planes.getProperty(runtime, "length").asNumber());
+    if (length < 3) {
+        throw jsi::JSError(runtime, "FaceAntiSpoof expected Y, U and V planes");
+    }
 
+    std::vector<std::vector<uint8_t>> planeData(3);
+    jint rowStrides[3] = {};
+    jint pixelStrides[3] = {};
+    for (size_t index = 0; index < 3; index++) {
+        auto plane = planes.getProperty(runtime, jsi::Value(static_cast<double>(index))).asObject(runtime);
+        auto buffer = plane.getProperty(runtime, "getPixelBuffer").asObject(runtime)
+            .asFunction(runtime).call(runtime, plane).asObject(runtime);
+        auto arrayBuffer = std::move(buffer).getArrayBuffer(runtime);
+        auto *data = static_cast<const uint8_t *>(arrayBuffer.data(runtime));
+        planeData[index].assign(data, data + arrayBuffer.size(runtime));
+        rowStrides[index] = static_cast<jint>(plane.getProperty(runtime, "bytesPerRow").asNumber());
+        auto planeWidth = plane.getProperty(runtime, "width").asNumber();
+        pixelStrides[index] = std::max(1, static_cast<jint>(rowStrides[index] / planeWidth));
+    }
+
+    JNIEnv *env = nullptr;
+    bool attached = false;
+    if (javaVm == nullptr) {
+        throw jsi::JSError(runtime, "FaceAntiSpoof Android runtime is unavailable");
+    }
+    if (javaVm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) == JNI_EDETACHED) {
+        if (javaVm->AttachCurrentThread(&env, nullptr) != JNI_OK) {
+            throw jsi::JSError(runtime, "FaceAntiSpoof could not attach to Android runtime");
+        }
+        attached = true;
+    }
+    auto moduleClass = env->FindClass("com/faceantispoof/FaceAntiSpoofModule");
+    auto process = env->GetStaticMethodID(moduleClass, "processFrameFromJSI", "([[BII[I[I)[D");
+    auto javaPlanes = env->NewObjectArray(3, env->FindClass("[B"), nullptr);
+    auto javaRowStrides = env->NewIntArray(3);
+    auto javaPixelStrides = env->NewIntArray(3);
+    env->SetIntArrayRegion(javaRowStrides, 0, 3, rowStrides);
+    env->SetIntArrayRegion(javaPixelStrides, 0, 3, pixelStrides);
+    for (int index = 0; index < 3; index++) {
+        auto bytes = env->NewByteArray(static_cast<jsize>(planeData[index].size()));
+        env->SetByteArrayRegion(bytes, 0, static_cast<jsize>(planeData[index].size()),
+            reinterpret_cast<const jbyte *>(planeData[index].data()));
+        env->SetObjectArrayElement(javaPlanes, index, bytes);
+        env->DeleteLocalRef(bytes);
+    }
+    auto values = static_cast<jdoubleArray>(env->CallStaticObjectMethod(
+        moduleClass, process, javaPlanes, static_cast<jint>(frameObject.getProperty(runtime, "width").asNumber()),
+        static_cast<jint>(frameObject.getProperty(runtime, "height").asNumber()),
+        javaRowStrides, javaPixelStrides));
+    jdouble output[5] = {};
+    if (values != nullptr) env->GetDoubleArrayRegion(values, 0, 5, output);
+    env->DeleteLocalRef(values);
+    env->DeleteLocalRef(javaPixelStrides);
+    env->DeleteLocalRef(javaRowStrides);
+    env->DeleteLocalRef(javaPlanes);
+    env->DeleteLocalRef(moduleClass);
+    if (attached) javaVm->DetachCurrentThread();
+
+    jsi::Object result(runtime);
+    result.setProperty(runtime, "isLive", output[0] != 0.0);
+    result.setProperty(runtime, "label", output[0] != 0.0 ? "Live Face" : "Spoof Face");
+    result.setProperty(runtime, "neuralNetworkScore", output[1]);
+    result.setProperty(runtime, "laplacianScore", output[2]);
+    result.setProperty(runtime, "combinedScore", output[3]);
+    result.setProperty(runtime, "confidence", output[4]);
     return result;
 }
 
+extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *) {
+    javaVm = vm;
+    return JNI_VERSION_1_6;
+}
+
 // JSI registration function
 extern "C"
 JNIEXPORT void JNICALL

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,9 @@
+#include "VisionCameraSpoofDetectorOnLoad.hpp"
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::camera::spoofdetector::registerAllNatives();
+  });
+}

package/android/src/main/java/com/faceantispoof/FaceAntiSpoofModule.kt

@@ -13,17 +13,27 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
 
     companion object {
         const val NAME = "FaceAntiSpoof"
+        private var activeModule: FaceAntiSpoofModule? = null
+
+        @JvmStatic
+        fun processFrameFromJSI(
+            planes: Array<ByteArray>,
+            width: Int,
+            height: Int,
+            rowStrides: IntArray,
+            pixelStrides: IntArray
+        ): DoubleArray {
+            val module = activeModule
+                ?: return doubleArrayOf(0.0, 0.0, 0.0, 0.0, 0.0)
+            return module.processNativeFrame(planes, width, height, rowStrides, pixelStrides)
+        }
     }
 
     private var faceAntiSpoofing: FaceAntiSpoofingAdvanced? = null
     private var isModuleInitialized = false
 
     init {
-        try {
-            System.loadLibrary("faceantispoof")
-        } catch (e: Exception) {
-            android.util.Log.e("FaceAntiSpoof", "Error loading native library", e)
-        }
+        activeModule = this
 
         try {
             // Initialize face anti-spoofing with app assets
@@ -35,57 +45,6 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
             isModuleInitialized = false
         }
 
-        try {
-            tryRegisterJSI()
-        } catch (e: Exception) {
-            android.util.Log.e("FaceAntiSpoof", "Error starting JSI registration", e)
-        }
-    }
-
-    private fun tryRegisterJSI() {
-        try {
-            Thread {
-                try {
-                    Thread.sleep(500)
-                    val holder = reactApplicationContext.javaScriptContextHolder ?: return@Thread
-
-                    // Try nativePointer
-                    try {
-                        val field = holder.javaClass.getDeclaredField("nativePointer")
-                        field.isAccessible = true
-                        val jsContextPtr = field.getLong(holder)
-                        if (jsContextPtr != 0L) {
-                            try {
-                                registerJSIFunction(jsContextPtr)
-                            } catch (e: Exception) {
-                                android.util.Log.d("FaceAntiSpoof", "JSI registration not available: ${e.message}")
-                            }
-                            return@Thread
-                        }
-                    } catch (_: Exception) { }
-
-                    // Try mContext
-                    try {
-                        val field = holder.javaClass.getDeclaredField("mContext")
-                        field.isAccessible = true
-                        val jsContextPtr = field.getLong(holder)
-                        if (jsContextPtr != 0L) {
-                            try {
-                                registerJSIFunction(jsContextPtr)
-                            } catch (e: Exception) {
-                                android.util.Log.d("FaceAntiSpoof", "JSI registration not available: ${e.message}")
-                            }
-                            return@Thread
-                        }
-                    } catch (_: Exception) { }
-
-                } catch (e: Exception) {
-                    android.util.Log.d("FaceAntiSpoof", "Error in JSI registration thread: ${e.message}")
-                }
-            }.start()
-        } catch (e: Exception) {
-            android.util.Log.d("FaceAntiSpoof", "Failed to start thread for JSI registration: ${e.message}")
-        }
     }
 
     override fun getName(): String = NAME
@@ -181,6 +140,41 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
         }
     }
 
+    @Synchronized
+    private fun processNativeFrame(
+        planes: Array<ByteArray>,
+        width: Int,
+        height: Int,
+        rowStrides: IntArray,
+        pixelStrides: IntArray
+    ): DoubleArray {
+        if (!isModuleInitialized || faceAntiSpoofing == null || planes.size < 3) {
+            return doubleArrayOf(0.0, 0.0, 0.0, 0.0, 0.0)
+        }
+
+        return try {
+            val result = faceAntiSpoofing!!.advancedAntiSpoofing(
+                planes,
+                width,
+                height,
+                rowStrides,
+                pixelStrides
+            )
+            val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
+                result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
+            doubleArrayOf(
+                if (isLive) 1.0 else 0.0,
+                result.neuralNetworkScore.toDouble(),
+                result.laplacianScore.toDouble(),
+                result.combinedScore.toDouble(),
+                result.confidence.toDouble()
+            )
+        } catch (error: Exception) {
+            android.util.Log.e("FaceAntiSpoof", "Native frame processing failed", error)
+            doubleArrayOf(0.0, 0.0, 0.0, 0.0, 0.0)
+        }
+    }
+
     @ReactMethod
     fun isAvailable(promise: Promise) {
         try {
@@ -218,51 +212,9 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
 
     @ReactMethod
     fun install(promise: Promise) {
-        try {
-            val holder = reactApplicationContext.javaScriptContextHolder
-
-            if (holder != null) {
-                // Try nativePointer
-                try {
-                    val f = holder.javaClass.getDeclaredField("nativePointer")
-                    f.isAccessible = true
-                    val ptr = f.getLong(holder)
-                    if (ptr != 0L) {
-                        try {
-                            registerJSIFunction(ptr)
-                            promise.resolve(true)
-                            return
-                        } catch (e: Exception) {
-                            android.util.Log.d("FaceAntiSpoof", "JSI not available: ${e.message}")
-                        }
-                    }
-                } catch (_: Exception) {}
-
-                // Try mContext
-                try {
-                    val f = holder.javaClass.getDeclaredField("mContext")
-                    f.isAccessible = true
-                    val ptr = f.getLong(holder)
-                    if (ptr != 0L) {
-                        try {
-                            registerJSIFunction(ptr)
-                            promise.resolve(true)
-                            return
-                        } catch (e: Exception) {
-                            android.util.Log.d("FaceAntiSpoof", "JSI not available: ${e.message}")
-                        }
-                    }
-                } catch (_: Exception) {}
-
-                promise.resolve(false)
-            } else {
-                promise.resolve(false)
-            }
-
-        } catch (e: Exception) {
-            android.util.Log.e("FaceAntiSpoof", "install() error", e)
-            promise.reject("INSTALL_ERROR", "Failed to install JSI function", e)
-        }
+        // VisionCamera 5 uses the Nitro CameraOutput. The old reflective JSI
+        // installer targets a native library that is no longer part of this module.
+        promise.resolve(false)
     }
 
     @ReactMethod
@@ -292,6 +244,4 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
         super.onCatalystInstanceDestroy()
     }
 
-    // Native JSI registration - optional, may not be available
-    private external fun registerJSIFunction(jsContext: Long)
 }

package/android/src/main/java/com/faceantispoof/FaceAntiSpoofPackage.kt

@@ -1,15 +1,22 @@
-package com.faceantispoof
+package com.margelo.nitro.camera.spoofdetector
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.faceantispoof.FaceAntiSpoofModule
 
-class FaceAntiSpoofPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
-        listOf(FaceAntiSpoofModule(reactContext))
+class FaceAntiSpoofPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+        if (name == FaceAntiSpoofModule.NAME) FaceAntiSpoofModule(reactContext) else null
 
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+        HashMap()
+    }
+
+    companion object {
+        init {
+            VisionCameraSpoofDetectorOnLoad.initializeNative()
+        }
     }
 }

package/android/src/main/java/com/margelo/nitro/camera/spoofdetector/HybridSpoofDetectorFactory.kt

@@ -0,0 +1,15 @@
+package com.margelo.nitro.camera.spoofdetector
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.camera.HybridCameraOutputSpec
+
+@DoNotStrip
+@Keep
+class HybridSpoofDetectorFactory : HybridSpoofDetectorFactorySpec() {
+  @DoNotStrip
+  @Keep
+  override fun createSpoofDetectorOutput(options: SpoofDetectorOutputOptions): HybridCameraOutputSpec {
+    return HybridSpoofDetectorOutput(options)
+  }
+}