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

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

@@ -4,6 +4,8 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.module.annotations.ReactModule
 
 @ReactModule(name = FaceAntiSpoofModule.NAME)
@@ -11,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
@@ -33,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
@@ -126,6 +87,94 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
         }
     }
 
+    @ReactMethod
+    fun processFrame(
+        frameData: ReadableArray,
+        width: Int,
+        height: Int,
+        rowStrides: ReadableArray,
+        pixelStrides: ReadableArray,
+        promise: Promise
+    ) {
+        try {
+            if (frameData.size() < 3 || rowStrides.size() < 3 || pixelStrides.size() < 3) {
+                promise.reject("INVALID_FRAME", "Expected Y, U and V camera planes")
+                return
+            }
+
+            if (!isModuleInitialized || faceAntiSpoofing == null) {
+                promise.reject("NOT_INITIALIZED", "Face anti-spoofing is not initialized")
+                return
+            }
+
+            val planes = Array(3) { planeIndex ->
+                val plane = frameData.getArray(planeIndex)
+                    ?: throw IllegalArgumentException("Camera plane $planeIndex is null")
+                ByteArray(plane.size()) { index -> plane.getInt(index).toByte() }
+            }
+            val yuvRowStrides = IntArray(3) { rowStrides.getDouble(it).toInt() }
+            val yuvPixelStrides = IntArray(3) { pixelStrides.getDouble(it).toInt().coerceAtLeast(1) }
+            val result = faceAntiSpoofing!!.advancedAntiSpoofing(
+                planes,
+                width,
+                height,
+                yuvRowStrides,
+                yuvPixelStrides
+            )
+            val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
+                result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
+            promise.resolve(
+                Arguments.makeNativeMap(
+                    mapOf(
+                        "isLive" to isLive,
+                        "label" to if (isLive) "Live Face" else "Spoof Face",
+                        "neuralNetworkScore" to result.neuralNetworkScore.toDouble(),
+                        "laplacianScore" to result.laplacianScore,
+                        "combinedScore" to result.combinedScore.toDouble(),
+                        "confidence" to result.confidence.toDouble()
+                    )
+                )
+            )
+        } catch (e: Exception) {
+            promise.reject("PROCESS_ERROR", "Failed to process camera frame", e)
+        }
+    }
+
+    @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 {
@@ -163,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
@@ -237,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,37 +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.mrousavy.camera.frameprocessors.FrameProcessorPluginRegistry
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.faceantispoof.FaceAntiSpoofModule
 
-class FaceAntiSpoofPackage : ReactPackage {
+class FaceAntiSpoofPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+        if (name == FaceAntiSpoofModule.NAME) FaceAntiSpoofModule(reactContext) else null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+        HashMap()
+    }
 
     companion object {
         init {
-            try {
-                FrameProcessorPluginRegistry.addFrameProcessorPlugin("faceAntiSpoof") { proxy, options ->
-                    val plugin = FaceAntiSpoofFrameProcessor()
-                    try {
-                        plugin.initialize(proxy.context.assets)
-                    } catch (e: Exception) {
-                        android.util.Log.e("FaceAntiSpoof", "Failed to initialize plugin with assets", e)
-                    }
-                    plugin
-                }
-            } catch (e: Exception) {
-                android.util.Log.e("FaceAntiSpoof", "Plugin already registered or failed: ${e.message}", e)
-            }
+            VisionCameraSpoofDetectorOnLoad.initializeNative()
         }
     }
-
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        // Only return the module — DO NOT register plugin here.
-        return listOf(FaceAntiSpoofModule(reactContext))
-    }
-
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
-    }
 }

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

@@ -24,7 +24,7 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         const val BASE_THRESHOLD = 0.2f
         const val ROUTE_INDEX = 6
         const val LAPLACE_THRESHOLD = 50
-        const val LAPLACIAN_THRESHOLD = 4000  // Increased from 1000 - real faces have ~3500+ laplacian score
+        const val LAPLACIAN_THRESHOLD = 1000
         const val MODEL_FILE = "FaceAntiSpoofing.tflite"
         private const val TAG = "FaceAntiSpoofing"
         
@@ -165,6 +165,25 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    fun advancedAntiSpoofing(
+        planes: Array<ByteArray>,
+        width: Int,
+        height: Int,
+        rowStrides: IntArray,
+        pixelStrides: IntArray
+    ): AntiSpoofingResult {
+        if (planes.size < 3) {
+            throw IllegalArgumentException("Expected Y, U and V planes")
+        }
+
+        val bitmap = yuv420ToBitmap(planes, width, height, rowStrides, pixelStrides)
+        return try {
+            runBlocking { advancedAntiSpoofing(bitmap).getOrThrow() }
+        } finally {
+            bitmap.recycle()
+        }
+    }
+
     // FROM WORKING VERSION: neuralNetworkAntiSpoofing with Bitmap
     private fun neuralNetworkAntiSpoofing(bitmap: Bitmap): Result<Float> {
         return try {
@@ -365,6 +384,44 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return bitmap
     }
 
+    private fun yuv420ToBitmap(
+        planes: Array<ByteArray>,
+        width: Int,
+        height: Int,
+        rowStrides: IntArray,
+        pixelStrides: IntArray
+    ): Bitmap {
+        val pixels = IntArray(width * height)
+        val yPlane = planes[0]
+        val uPlane = planes[1]
+        val vPlane = planes[2]
+
+        fun sample(plane: ByteArray, row: Int, column: Int, rowStride: Int, pixelStride: Int): Int {
+            val index = row * rowStride + column * pixelStride
+            return if (index in plane.indices) plane[index].toInt() and 0xFF else 128
+        }
+
+        for (y in 0 until height) {
+            for (x in 0 until width) {
+                val yValue = sample(yPlane, y, x, rowStrides[0], pixelStrides[0])
+                val chromaRow = y / 2
+                val chromaColumn = x / 2
+                val uValue = sample(uPlane, chromaRow, chromaColumn, rowStrides[1], pixelStrides[1]) - 128
+                val vValue = sample(vPlane, chromaRow, chromaColumn, rowStrides[2], pixelStrides[2]) - 128
+
+                val red = (yValue + 1.402f * vValue).coerceIn(0f, 255f).toInt()
+                val green = (yValue - 0.344f * uValue - 0.714f * vValue).coerceIn(0f, 255f).toInt()
+                val blue = (yValue + 1.772f * uValue).coerceIn(0f, 255f).toInt()
+                pixels[y * width + x] = (0xFF shl 24) or
+                    (red shl 16) or
+                    (green shl 8) or
+                    blue
+            }
+        }
+
+        return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
+    }
+
     @Throws(IOException::class)
     private fun loadModelFile(assetManager: AssetManager, modelName: String): MappedByteBuffer {
         return try {

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)
+  }
+}

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

@@ -0,0 +1,107 @@
+package com.margelo.nitro.camera.spoofdetector
+
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageProxy
+import androidx.camera.core.resolutionselector.ResolutionSelector
+import androidx.camera.core.resolutionselector.ResolutionStrategy
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.camera.CameraOrientation
+import com.margelo.nitro.camera.HybridCameraOutputSpec
+import com.margelo.nitro.camera.MediaType
+import com.margelo.nitro.camera.MirrorMode
+import com.margelo.nitro.camera.extensions.setAllowDroppingLateFrames
+import com.margelo.nitro.camera.extensions.surfaceRotation
+import com.margelo.nitro.camera.public.NativeCameraOutput
+import com.faceantispoof.FaceAntiSpoofingAdvanced
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+
+class HybridSpoofDetectorOutput(
+  private val options: SpoofDetectorOutputOptions,
+) : HybridCameraOutputSpec(), ImageAnalysis.Analyzer, NativeCameraOutput {
+  override val mediaType: MediaType = MediaType.VIDEO
+  override val mirrorMode: MirrorMode = MirrorMode.AUTO
+  override var outputOrientation: CameraOrientation = CameraOrientation.UP
+    set(value) {
+      field = value
+      imageAnalysis?.targetRotation = value.surfaceRotation
+    }
+  override val currentResolution: com.margelo.nitro.camera.Size?
+    get() = null
+
+  private val executor = Executors.newSingleThreadExecutor()
+  private val busy = AtomicBoolean(false)
+  private val detector = FaceAntiSpoofingAdvanced(
+    NitroModules.applicationContext?.assets ?: error("FaceAntiSpoof: no application context")
+  )
+  private var imageAnalysis: ImageAnalysis? = null
+
+  override fun createUseCase(
+    mirrorMode: MirrorMode,
+    config: NativeCameraOutput.Config,
+  ): NativeCameraOutput.PreparedUseCase {
+    val target = options.targetResolution
+    val selector = target?.let {
+      ResolutionSelector.Builder()
+        .setResolutionStrategy(
+          ResolutionStrategy(
+            android.util.Size(it.width.toInt(), it.height.toInt()),
+            ResolutionStrategy.FALLBACK_RULE_CLOSEST_HIGHER_THEN_LOWER,
+          )
+        )
+        .build()
+    }
+    val analysis = ImageAnalysis.Builder()
+      .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888)
+      .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+      .setAllowDroppingLateFrames(true)
+      .apply { if (selector != null) setResolutionSelector(selector) }
+      .build()
+    return NativeCameraOutput.PreparedUseCase(analysis) {
+      imageAnalysis = analysis
+      analysis.setAnalyzer(executor, this)
+    }
+  }
+
+  override fun analyze(image: ImageProxy) {
+    if (!busy.compareAndSet(false, true)) {
+      image.close()
+      return
+    }
+    try {
+      val planes = image.planes.take(3).map { plane ->
+        val buffer = plane.buffer.duplicate()
+        ByteArray(buffer.remaining()).also(buffer::get)
+      }.toTypedArray()
+      val rowStrides = image.planes.take(3).map { it.rowStride }.toIntArray()
+      val pixelStrides = image.planes.take(3).map { it.pixelStride.coerceAtLeast(1) }.toIntArray()
+      val result = detector.advancedAntiSpoofing(
+        planes, image.width, image.height, rowStrides, pixelStrides
+      )
+      val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
+        result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
+      options.onResult.invoke(
+        AntiSpoofingResult(
+          isLive,
+          if (isLive) "Live Face" else "Spoof Face",
+          result.neuralNetworkScore.toDouble(),
+          result.laplacianScore.toDouble(),
+          result.combinedScore.toDouble(),
+          result.confidence.toDouble(),
+        )
+      )
+    } catch (error: Throwable) {
+      options.onError?.invoke(error)
+    } finally {
+      image.close()
+      busy.set(false)
+    }
+  }
+
+  override fun dispose() {
+    imageAnalysis?.clearAnalyzer()
+    detector.close()
+    executor.shutdown()
+    super.dispose()
+  }
+}

package/index.d.ts

@@ -4,7 +4,7 @@
  * TypeScript type definitions
  */
 
-import type { Frame, FrameProcessor } from 'react-native-vision-camera';
+import type { CameraFrameOutput, Frame, FrameOutputOptions, FrameProcessor } from 'react-native-vision-camera';
 import type { SharedValue } from 'react-native-reanimated';
 
 // ============================================================================
@@ -281,6 +281,19 @@ export interface UseFaceDetectionFrameProcessorReturn {
   antiSpoofState: AntiSpoofState;
 }
 
+/**
+ * VisionCamera 5 frame-output options for spoof detection.
+ * The callback runs on the React Native runtime after native inference.
+ */
+export interface UseFaceAntiSpoofFrameOutputOptions extends Partial<FrameOutputOptions> {
+  onResult?: (result: FaceAntiSpoofingResult) => void;
+}
+
+/** Create a VisionCamera 5 frame output backed by the native detector. */
+export function useFaceAntiSpoofFrameOutput(
+  options?: UseFaceAntiSpoofFrameOutputOptions,
+): CameraFrameOutput;
+
 // ============================================================================
 // Module Functions
 // ============================================================================

package/index.js

@@ -1,60 +1,31 @@
-import { NativeModules } from 'react-native';
-import { VisionCameraProxy } from 'react-native-vision-camera';
+import { useMemo, useRef } from 'react';
+import { NativeModules } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+import { scheduleOnRN } from 'react-native-worklets';
 
 const { FaceAntiSpoof } = NativeModules;
 
-// Initialize the plugin before any worklet captures this module.
-let _faceAntiSpoofPlugin = null;
-
-try {
-  _faceAntiSpoofPlugin = VisionCameraProxy.initFrameProcessorPlugin('faceAntiSpoof', {});
-} catch (e) {
-  console.warn('[FaceAntiSpoof] Failed to init frame processor plugin:', e);
-}
-
-function ensurePluginInitialized() {
-  if (!_faceAntiSpoofPlugin) {
-    try {
-      _faceAntiSpoofPlugin = VisionCameraProxy.initFrameProcessorPlugin('faceAntiSpoof', {});
-    } catch (e) {
-      console.warn('[FaceAntiSpoof] Failed to init frame processor plugin:', e);
-      _faceAntiSpoofPlugin = null;
-    }
-  }
-  return !!_faceAntiSpoofPlugin;
-}
-
-// Worklet called by VisionCamera
-export const faceAntiSpoofFrameProcessor = function (frame) {
-  'worklet';
-  try {
-    if (!_faceAntiSpoofPlugin) {
-      console.warn('[FaceAntiSpoof] Plugin not initialized');
-      return null;
-    }
-    
-    if (typeof _faceAntiSpoofPlugin.call !== 'function') {
-      console.warn('[FaceAntiSpoof] Plugin call method not available');
-      return null;
-    }
-    
-    if (!frame) {
-      console.warn('[FaceAntiSpoof] Frame is null or undefined');
-      return null;
-    }
-    
-    const result = _faceAntiSpoofPlugin.call(frame);
-    
-    // Validate result structure
-    if (result && typeof result === 'object') {
-      return result;
-    }
-    
-    return null;
-  } catch (err) {
-    console.error('[FaceAntiSpoof] Error in frame processor:', err);
-    return null;
-  }
+export const useFaceAntiSpoofFrameOutput = ({ onResult, ...options } = {}) => {
+  const resultRef = useRef(onResult);
+  resultRef.current = onResult;
+  const errorRef = useRef(options.onError);
+  errorRef.current = options.onError;
+  const factory = useMemo(
+    () => NitroModules.createHybridObject('SpoofDetectorFactory'),
+    [],
+  );
+  return useMemo(
+    () => factory.createSpoofDetectorOutput({
+      targetResolution: options.targetResolution ?? { width: 256, height: 256 },
+      onResult(result) {
+        resultRef.current?.(result);
+      },
+      onError(error) {
+        errorRef.current?.(error);
+      },
+    }),
+    [factory, options.targetResolution],
+  );
 };
 
 export default FaceAntiSpoof;
@@ -86,9 +57,7 @@ export const initializeFaceAntiSpoof = async () => {
     }
 
     const isSuccess = result && status.pluginAvailable;
-    // If native initialization succeeded, register the frame processor plugin for worklets
-    const pluginInitialized = isSuccess ? ensurePluginInitialized() : false;
-    const initialized = isSuccess && pluginInitialized;
+    const initialized = isSuccess;
     console.log('[FaceAntiSpoof] Initialization result:', initialized);
     return initialized;
   } catch (error) {

package/nitro.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["camera", "spoofdetector"],
+  "ios": {
+    "iosModuleName": "VisionCameraSpoofDetector"
+  },
+  "android": {
+    "androidNamespace": ["camera", "spoofdetector"],
+    "androidCxxLibName": "VisionCameraSpoofDetector"
+  },
+  "autolinking": {
+    "SpoofDetectorFactory": {
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridSpoofDetectorFactory"
+      }
+    }
+  },
+  "ignorePaths": ["**/node_modules"]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true