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

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/android/src/main/java/com/faceantispoof/FaceAntiSpoofingAdvanced.kt

@@ -184,6 +184,49 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    fun advancedAntiSpoofingRGBA(rgba: ByteArray, width: Int, height: Int): AntiSpoofingResult {
+        if (!isInitialized) {
+            return AntiSpoofingResult(
+                neuralNetworkScore = 0f,
+                laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = 0f,
+                confidence = 0f
+            )
+        }
+
+        return try {
+            val nnScore = neuralNetworkAntiSpoofingRGBA(rgba, width, height).getOrThrow()
+            val laplacianScore = laplacianFromRgba(rgba, width, height).getOrThrow()
+            val isLive = nnScore < BASE_THRESHOLD && laplacianScore > LAPLACIAN_THRESHOLD
+            val combinedScore = calculateCombinedScore(nnScore, laplacianScore)
+            val confidence = calculateConfidence(nnScore, laplacianScore)
+
+            AntiSpoofingResult(
+                neuralNetworkScore = nnScore,
+                laplacianScore = laplacianScore,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = combinedScore,
+                confidence = confidence
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in advancedAntiSpoofingRGBA", e)
+            AntiSpoofingResult(
+                neuralNetworkScore = 0f,
+                laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = 0f,
+                confidence = 0f
+            )
+        }
+    }
+
     // FROM WORKING VERSION: neuralNetworkAntiSpoofing with Bitmap
     private fun neuralNetworkAntiSpoofing(bitmap: Bitmap): Result<Float> {
         return try {
@@ -216,6 +259,29 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    private fun neuralNetworkAntiSpoofingRGBA(rgba: ByteArray, width: Int, height: Int): Result<Float> {
+        return try {
+            val img = normalizeRgbaImage(rgba, width, height, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
+            val input = arrayOf(img)
+
+            clssPred[0].fill(0f)
+            leafNodeMask[0].fill(0f)
+
+            outputs[outputIndex0] = clssPred
+            outputs[outputIndex1] = leafNodeMask
+
+            interpreter!!.runForMultipleInputsOutputs(arrayOf(input), outputs)
+
+            Log.i(TAG, "clss_pred: [${clssPred[0].joinToString()}]")
+            Log.i(TAG, "leaf_node_mask: [${leafNodeMask[0].joinToString()}]")
+
+            Result.success(leafScore1(clssPred, leafNodeMask))
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in neuralNetworkAntiSpoofingRGBA", e)
+            Result.failure(e)
+        }
+    }
+
     // FROM WORKING VERSION: leafScore1
     private fun leafScore1(clssPred: Array<FloatArray>, leafNodeMask: Array<FloatArray>): Float {
         var score = 0f
@@ -247,6 +313,33 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return floatValues
     }
 
+    private fun normalizeRgbaImage(
+        rgba: ByteArray,
+        srcWidth: Int,
+        srcHeight: Int,
+        targetWidth: Int,
+        targetHeight: Int
+    ): Array<Array<FloatArray>> {
+        val floatValues = Array(targetHeight) { Array(targetWidth) { FloatArray(3) } }
+        val scaleX = srcWidth.toFloat() / targetWidth
+        val scaleY = srcHeight.toFloat() / targetHeight
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * scaleY).toInt().coerceIn(0, srcHeight - 1)
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * scaleX).toInt().coerceIn(0, srcWidth - 1)
+                val srcIndex = (srcY * srcWidth + srcX) * 4
+
+                val r = (rgba[srcIndex].toInt() and 0xFF) / 255f
+                val g = (rgba[srcIndex + 1].toInt() and 0xFF) / 255f
+                val b = (rgba[srcIndex + 2].toInt() and 0xFF) / 255f
+                floatValues[targetY][targetX] = floatArrayOf(r, g, b)
+            }
+        }
+
+        return floatValues
+    }
+
     // FROM WORKING VERSION: laplacian with Bitmap
     private fun laplacian(bitmap: Bitmap): Result<Int> {
         return try {
@@ -264,6 +357,17 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    private fun laplacianFromRgba(rgba: ByteArray, width: Int, height: Int): Result<Int> {
+        return try {
+            val gray = rgbaToGrayscale(rgba, width, height, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
+            val score = calculateLaplacianFromGray(gray)
+            Result.success(score)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in laplacianFromRgba", e)
+            Result.failure(e)
+        }
+    }
+
     // FROM WORKING VERSION: calculateLaplacianScore
     private fun calculateLaplacianScore(bitmap: Bitmap): Int {
         val laplace = arrayOf(
@@ -315,6 +419,58 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return greyImg
     }
 
+    private fun rgbaToGrayscale(
+        rgba: ByteArray,
+        srcWidth: Int,
+        srcHeight: Int,
+        targetWidth: Int,
+        targetHeight: Int
+    ): Array<IntArray> {
+        val gray = Array(targetHeight) { IntArray(targetWidth) }
+        val scaleX = srcWidth.toFloat() / targetWidth
+        val scaleY = srcHeight.toFloat() / targetHeight
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * scaleY).toInt().coerceIn(0, srcHeight - 1)
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * scaleX).toInt().coerceIn(0, srcWidth - 1)
+                val srcIndex = (srcY * srcWidth + srcX) * 4
+                val r = rgba[srcIndex].toInt() and 0xFF
+                val g = rgba[srcIndex + 1].toInt() and 0xFF
+                val b = rgba[srcIndex + 2].toInt() and 0xFF
+                gray[targetY][targetX] = (0.299 * r + 0.587 * g + 0.114 * b).toInt()
+            }
+        }
+
+        return gray
+    }
+
+    private fun calculateLaplacianFromGray(img: Array<IntArray>): Int {
+        val laplace = arrayOf(
+            intArrayOf(0, 1, 0),
+            intArrayOf(1, -4, 1),
+            intArrayOf(0, 1, 0)
+        )
+
+        val height = img.size
+        val width = img[0].size
+        var score = 0
+        for (x in 0 until height - laplace.size + 1) {
+            for (y in 0 until width - laplace.size + 1) {
+                var result = 0
+                for (i in 0 until laplace.size) {
+                    for (j in 0 until laplace.size) {
+                        result += img[x + i][y + j] * laplace[i][j]
+                    }
+                }
+                if (result > LAPLACE_THRESHOLD) {
+                    score++
+                }
+            }
+        }
+        return score
+    }
+
     // FROM WORKING VERSION: calculateCombinedScore
     private fun calculateCombinedScore(neuralScore: Float, laplacianScore: Int): Float {
         // Normalize both scores to 0-1 range
@@ -422,6 +578,22 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
     }
 
+    private fun rgbaToBitmap(rgba: ByteArray, width: Int, height: Int): Bitmap {
+        val pixels = IntArray(width * height)
+        var index = 0
+        for (y in 0 until height) {
+            for (x in 0 until width) {
+                val r = rgba[index].toInt() and 0xFF
+                val g = rgba[index + 1].toInt() and 0xFF
+                val b = rgba[index + 2].toInt() and 0xFF
+                val a = rgba[index + 3].toInt() and 0xFF
+                pixels[y * width + x] = (a shl 24) or (r shl 16) or (g shl 8) or b
+                index += 4
+            }
+        }
+        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/HybridSpoofDetectorOutput.kt

@@ -53,7 +53,7 @@ class HybridSpoofDetectorOutput(
         .build()
     }
     val analysis = ImageAnalysis.Builder()
-      .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888)
+      .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_RGBA_8888)
       .setOutputImageRotationEnabled(false)
       .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
       .setAllowDroppingLateFrames(true)
@@ -71,16 +71,8 @@ class HybridSpoofDetectorOutput(
       return
     }
     try {
-      val sourcePlanes = image.planes
-      val planes = Array(3) { index ->
-        val buffer = sourcePlanes[index].buffer.duplicate()
-        ByteArray(buffer.remaining()).also(buffer::get)
-      }
-      val rowStrides = IntArray(3) { sourcePlanes[it].rowStride }
-      val pixelStrides = IntArray(3) { sourcePlanes[it].pixelStride.coerceAtLeast(1) }
-      val result = detector.advancedAntiSpoofing(
-        planes, image.width, image.height, rowStrides, pixelStrides
-      )
+      val rgba = extractRgbaBytes(image)
+      val result = detector.advancedAntiSpoofingRGBA(rgba, image.width, image.height)
       val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
         result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
       options.onResult.invoke(
@@ -101,6 +93,51 @@ class HybridSpoofDetectorOutput(
     }
   }
 
+  private fun extractRgbaBytes(image: ImageProxy): ByteArray {
+    val plane = image.planes.firstOrNull() ?: throw IllegalStateException("RGBA image has no planes")
+    val rowStride = plane.rowStride
+    val pixelStride = plane.pixelStride
+    val width = image.width
+    val height = image.height
+    val bytesPerPixel = 4
+    val rowBytes = width * bytesPerPixel
+    val rgba = ByteArray(rowBytes * height)
+    val buffer = plane.buffer.duplicate()
+    buffer.order(java.nio.ByteOrder.nativeOrder())
+
+    for (y in 0 until height) {
+      val srcOffset = y * rowStride
+      val dstOffset = y * rowBytes
+      val copyLength = rowBytes.coerceAtMost(rowStride)
+      buffer.position(srcOffset)
+      val slice = ByteArray(copyLength)
+      buffer.get(slice)
+      System.arraycopy(slice, 0, rgba, dstOffset, copyLength)
+    }
+
+    if (pixelStride != 4) {
+      val packed = ByteArray(width * height * bytesPerPixel)
+      var outputIndex = 0
+      for (y in 0 until height) {
+        val rowOffset = y * rowStride
+        for (x in 0 until width) {
+          val pixelOffset = rowOffset + x * pixelStride
+          val r = buffer.get(pixelOffset).toInt() and 0xFF
+          val g = buffer.get(pixelOffset + 1).toInt() and 0xFF
+          val b = buffer.get(pixelOffset + 2).toInt() and 0xFF
+          val a = buffer.get(pixelOffset + 3).toInt() and 0xFF
+          packed[outputIndex++] = r.toByte()
+          packed[outputIndex++] = g.toByte()
+          packed[outputIndex++] = b.toByte()
+          packed[outputIndex++] = a.toByte()
+        }
+      }
+      return packed
+    }
+
+    return rgba
+  }
+
   override fun dispose() {
     disposed.set(true)
     imageAnalysis?.clearAnalyzer()

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

package/ios/FaceAntiSpoofModule.m

@@ -13,8 +13,6 @@
 #import "RCTBridge.h"
 #endif
 
-extern void FaceAntiSpoofRegisterPlugin(void);
-
 @interface FaceAntiSpoofModule : NSObject <RCTBridgeModule>
 @end
 
@@ -35,9 +33,7 @@ RCT_REMAP_METHOD(initialize,
 								 initializeWithResolver:(RCTPromiseResolveBlock)resolve
 								 rejecter:(RCTPromiseRejectBlock)reject)
 {
-	FaceAntiSpoofRegisterPlugin();
-
-	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofFrameProcessor") != Nil);
+	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofManager") != Nil);
 
 	// Prefer the FaceAntiSpoofManager to initialize the model and create the interpreter
 	BOOL managerInitialized = NO;
@@ -52,12 +48,18 @@ RCT_REMAP_METHOD(initialize,
 	}
 
 	// As a fallback, check bundle resources
-	NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+	NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"FaceAntiSpoofing" ofType:@"tflite" inDirectory:@"lib/assets"];
+	if (!modelPath) {
+		modelPath = [[NSBundle mainBundle] pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+	}
 	if (!modelPath) {
-		Class fpsClass = NSClassFromString(@"FaceAntiSpoofFrameProcessor");
-		if (fpsClass != Nil) {
-			NSBundle *podBundle = [NSBundle bundleForClass:fpsClass];
-			modelPath = [podBundle pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+		Class managerClass = NSClassFromString(@"FaceAntiSpoofManager");
+		if (managerClass != Nil) {
+			NSBundle *podBundle = [NSBundle bundleForClass:managerClass];
+			modelPath = [podBundle pathForResource:@"FaceAntiSpoofing" ofType:@"tflite" inDirectory:@"lib/assets"];
+			if (!modelPath) {
+				modelPath = [podBundle pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+			}
 		}
 	}
 	BOOL modelLoaded = (modelPath != nil) || managerInitialized;
@@ -69,14 +71,19 @@ RCT_REMAP_METHOD(checkModelStatus,
 								 checkModelStatusWithResolver:(RCTPromiseResolveBlock)resolve
 								 rejecter:(RCTPromiseRejectBlock)reject)
 {
-	FaceAntiSpoofRegisterPlugin();
-	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofFrameProcessor") != Nil);
-	NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofManager") != Nil);
+	NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"FaceAntiSpoofing" ofType:@"tflite" inDirectory:@"lib/assets"];
 	if (!modelPath) {
-		Class fpsClass = NSClassFromString(@"FaceAntiSpoofFrameProcessor");
-		if (fpsClass != Nil) {
-			NSBundle *podBundle = [NSBundle bundleForClass:fpsClass];
-			modelPath = [podBundle pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+		modelPath = [[NSBundle mainBundle] pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+	}
+	if (!modelPath) {
+		Class managerClass = NSClassFromString(@"FaceAntiSpoofManager");
+		if (managerClass != Nil) {
+			NSBundle *podBundle = [NSBundle bundleForClass:managerClass];
+			modelPath = [podBundle pathForResource:@"FaceAntiSpoofing" ofType:@"tflite" inDirectory:@"lib/assets"];
+			if (!modelPath) {
+				modelPath = [podBundle pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+			}
 		}
 	}
 	BOOL modelLoaded = (modelPath != nil);
@@ -88,7 +95,7 @@ RCT_REMAP_METHOD(isAvailable,
 								 isAvailableWithResolver:(RCTPromiseResolveBlock)resolve
 								 rejecter:(RCTPromiseRejectBlock)reject)
 {
-	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofFrameProcessor") != Nil);
+	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofManager") != Nil);
 	resolve(@(pluginAvailable));
 }
 
@@ -96,7 +103,7 @@ RCT_REMAP_METHOD(testMethod,
 								 testMethodWithResolver:(RCTPromiseResolveBlock)resolve
 								 rejecter:(RCTPromiseRejectBlock)reject)
 {
-	resolve(@"iOS native module stub");
+	resolve(@"iOS native module is working!");
 }
 
 RCT_REMAP_METHOD(getModuleInfo,
@@ -111,7 +118,6 @@ RCT_REMAP_METHOD(install,
 								 installWithResolver:(RCTPromiseResolveBlock)resolve
 								 rejecter:(RCTPromiseRejectBlock)reject)
 {
-	FaceAntiSpoofRegisterPlugin();
 	// Attempt to initialize shared model resources via FaceAntiSpoofManager
 	BOOL managerInitialized = NO;
 	Class managerClass = NSClassFromString(@"FaceAntiSpoofManager");
@@ -123,41 +129,22 @@ RCT_REMAP_METHOD(install,
 		}
 	}
 
-	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofFrameProcessor") != Nil);
-	NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofManager") != Nil);
+	NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"FaceAntiSpoofing" ofType:@"tflite" inDirectory:@"lib/assets"];
 	if (!modelPath) {
-		Class fpsClass = NSClassFromString(@"FaceAntiSpoofFrameProcessor");
-		if (fpsClass != Nil) {
-			NSBundle *podBundle = [NSBundle bundleForClass:fpsClass];
-			modelPath = [podBundle pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
-		}
+		modelPath = [[NSBundle mainBundle] pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
 	}
-	BOOL modelLoaded = (modelPath != nil) || managerInitialized;
-	// Attempt to register JSI: try common bridge keys to obtain a runtime pointer
-	if (_faceAntiSpoofBridge != nil) {
-		id runtimePtr = nil;
-		@try {
-			runtimePtr = [_faceAntiSpoofBridge valueForKeyPath:@"jsContext"];
-		} @catch (NSException *_) {}
-		if (!runtimePtr) {
-			@try {
-				runtimePtr = [_faceAntiSpoofBridge valueForKeyPath:@"jsContextRef"];
-			} @catch (NSException *_) {}
-		}
-		if (!runtimePtr) {
-			@try {
-				runtimePtr = [_faceAntiSpoofBridge valueForKeyPath:@"javaScriptContextRef"];
-			} @catch (NSException *_) {}
-		}
-
-		if (runtimePtr) {
-			// Pass the pointer to the JSI install stub
-			void *ptr = (__bridge void *)(runtimePtr);
-			extern void FaceAntiSpoofJSI_install(void *runtimePtr);
-			FaceAntiSpoofJSI_install(ptr);
+	if (!modelPath) {
+		Class managerClass = NSClassFromString(@"FaceAntiSpoofManager");
+		if (managerClass != Nil) {
+			NSBundle *podBundle = [NSBundle bundleForClass:managerClass];
+			modelPath = [podBundle pathForResource:@"FaceAntiSpoofing" ofType:@"tflite" inDirectory:@"lib/assets"];
+			if (!modelPath) {
+				modelPath = [podBundle pathForResource:@"FaceAntiSpoofing" ofType:@"tflite"];
+			}
 		}
 	}
-
+	BOOL modelLoaded = (modelPath != nil) || managerInitialized;
 	resolve(@(pluginAvailable && modelLoaded));
 }
 

package/ios/HybridSpoofDetectorFactory.swift

@@ -0,0 +1,10 @@
+import NitroModules
+import VisionCamera
+
+final class HybridSpoofDetectorFactory: HybridSpoofDetectorFactorySpec {
+  func createSpoofDetectorOutput(options: SpoofDetectorOutputOptions) throws
+    -> any HybridCameraOutputSpec
+  {
+    return HybridSpoofDetectorOutput(options: options)
+  }
+}