react-native-vision-camera-spoof-detector 1.0.23 → 1.0.25

package/index.js

@@ -3,7 +3,19 @@ import { VisionCameraProxy } from 'react-native-vision-camera';
 
 const { FaceAntiSpoof } = NativeModules;
 
-const _faceAntiSpoofPlugin = VisionCameraProxy.initFrameProcessorPlugin('faceAntiSpoof', {});
+// Lazily initialize the frame processor plugin after native initialize() succeeds.
+let _faceAntiSpoofPlugin = null;
+
+function ensurePluginInitialized() {
+  if (!_faceAntiSpoofPlugin) {
+    try {
+      _faceAntiSpoofPlugin = VisionCameraProxy.initFrameProcessorPlugin('faceAntiSpoof', {});
+    } catch (e) {
+      console.warn('[FaceAntiSpoof] Failed to init frame processor plugin:', e);
+      _faceAntiSpoofPlugin = null;
+    }
+  }
+}
 
 // Worklet called by VisionCamera
 export const faceAntiSpoofFrameProcessor = function (frame) {
@@ -67,6 +79,10 @@ export const initializeFaceAntiSpoof = async () => {
     }
 
     const isSuccess = result && status.pluginAvailable;
+    // If native initialization succeeded, register the frame processor plugin for worklets
+    if (isSuccess) {
+      ensurePluginInitialized();
+    }
     console.log('[FaceAntiSpoof] Initialization result:', isSuccess);
     return isSuccess;
   } catch (error) {

package/ios/FaceAntiSpoofFrameProcessor.swift

@@ -0,0 +1,283 @@
+import Foundation
+
+#if canImport(VisionCamera)
+import VisionCamera
+import AVFoundation
+import CoreImage
+import UIKit
+import Accelerate
+
+#if canImport(TensorFlowLite)
+import TensorFlowLite
+#endif
+
+typealias FaceAntiSpoofFrameType = Frame
+typealias FaceAntiSpoofProxyType = VisionCameraProxyHolder
+typealias FaceAntiSpoofPluginBase = FrameProcessorPlugin
+
+@objc(FaceAntiSpoofFrameProcessor)
+class FaceAntiSpoofFrameProcessor: FaceAntiSpoofPluginBase {
+    private weak var proxyHolder: FaceAntiSpoofProxyType?
+
+    // Processing state
+    private let processingQueue = DispatchQueue(label: "com.faceantispoof.processing", qos: .userInitiated)
+    private var isProcessing: Bool = false
+    private var latestResult: [String: Any] = ["error": "Not initialized", "isLive": false, "label": "Not Initialized"]
+    private static let INPUT_IMAGE_SIZE: Int = 256
+
+    #if canImport(TensorFlowLite)
+    // Interpreter is provided by FaceAntiSpoofManager.sharedInterpreter
+    #endif
+
+    override init(
+        proxy: FaceAntiSpoofProxyType,
+        options: [AnyHashable : Any]! = [:]
+    ) {
+        #if canImport(VisionCamera)
+        super.init(proxy: proxy, options: options)
+        #else
+        super.init(proxy: proxy, options: options as NSDictionary?)
+        #endif
+        self.proxyHolder = proxy
+
+        #if canImport(TensorFlowLite)
+        let managerInited = FaceAntiSpoofManager.initializeModel()
+        if managerInited {
+            NSLog("[FaceAntiSpoof] Manager initialized model")
+        } else {
+            NSLog("[FaceAntiSpoof] Manager failed to initialize model; running stub")
+        }
+        #else
+        NSLog("[FaceAntiSpoof] TensorFlowLite not available; running stub")
+        #endif
+    }
+
+    deinit {
+        NSLog("[FaceAntiSpoof] deinit - releasing resources")
+        self.proxyHolder = nil
+    }
+
+    override func callback(
+        _ frame: FaceAntiSpoofFrameType,
+        withArguments arguments: [AnyHashable : Any]?
+    ) -> Any {
+        #if canImport(TensorFlowLite)
+        guard FaceAntiSpoofManager.isModelLoaded() else {
+            return ["error": "Model not loaded", "isLive": false, "label": "stub"]
+        }
+
+        let sampleBuffer = frame.buffer
+        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
+            return ["error": "No pixel buffer", "isLive": false, "label": "stub"]
+        }
+
+        let width = CVPixelBufferGetWidth(pixelBuffer)
+        let height = CVPixelBufferGetHeight(pixelBuffer)
+
+        // If processing already in flight, return latest cached result immediately
+        var shouldReturnLatest = false
+        objc_sync_enter(self)
+        if isProcessing {
+            shouldReturnLatest = true
+        } else {
+            isProcessing = true
+        }
+        objc_sync_exit(self)
+
+        if shouldReturnLatest {
+            return latestResult
+        }
+
+        // Capture a small, resized RGB float snapshot synchronously while the pixel buffer is valid
+        let targetSize = CGSize(width: Self.INPUT_IMAGE_SIZE, height: Self.INPUT_IMAGE_SIZE)
+        guard let rgbInput = Self.rgbFloatData(from: pixelBuffer, size: targetSize) else {
+            objc_sync_enter(self)
+            isProcessing = false
+            objc_sync_exit(self)
+            latestResult = ["error": "Failed to create RGB snapshot", "isLive": false, "label": "error"]
+            return latestResult
+        }
+
+        // Offload heavy model work to a background queue
+        processingQueue.async { [weak self] in
+            guard let self = self else { return }
+            defer {
+                objc_sync_enter(self)
+                self.isProcessing = false
+                objc_sync_exit(self)
+            }
+
+            guard let interpreter = FaceAntiSpoofManager.sharedInterpreter else {
+                self.latestResult = ["error": "Interpreter not available", "isLive": false, "label": "error"]
+                return
+            }
+
+            do {
+                // Prepare input Data (Float32 little-endian)
+                var inputFloats = rgbInput
+                let inputData = Data(bytes: &inputFloats, count: inputFloats.count * MemoryLayout<Float>.size)
+
+                try interpreter.copy(inputData, toInputAt: 0)
+                try interpreter.invoke()
+
+                // Read outputs (assume indices 0 and 1 correspond to clssPred and leafNodeMask)
+                let out0 = try interpreter.output(at: 0)
+                let out1 = try interpreter.output(at: 1)
+
+                let clssPred: [Float] = out0.data.withUnsafeBytes { ptr in
+                    let floatPtr = ptr.bindMemory(to: Float.self)
+                    return Array(floatPtr)
+                }
+                let leafMask: [Float] = out1.data.withUnsafeBytes { ptr in
+                    let floatPtr = ptr.bindMemory(to: Float.self)
+                    return Array(floatPtr)
+                }
+
+                // Compute neural network score similar to Android leafScore1
+                let count = min(clssPred.count, leafMask.count)
+                var nnScore: Float = 0.0
+                for i in 0..<count {
+                    nnScore += abs(clssPred[i]) * leafMask[i]
+                }
+
+                // Laplacian score computed from the RGB snapshot (resized)
+                let lapScore = Self.calculateLaplacianScore(from: rgbInput, width: Self.INPUT_IMAGE_SIZE, height: Self.INPUT_IMAGE_SIZE)
+
+                let combined = Self.calculateCombinedScore(neuralScore: nnScore, laplacianScore: lapScore)
+                let confidence = Self.calculateConfidence(neuralScore: nnScore, laplacianScore: lapScore)
+
+                self.latestResult = [
+                    "neuralNetworkScore": Double(nnScore),
+                    "laplacianScore": lapScore,
+                    "combinedScore": Double(combined),
+                    "confidence": Double(confidence),
+                    "isLive": combined > 0.5,
+                    "label": combined > 0.5 ? "live" : "spoof",
+                    "width": width,
+                    "height": height
+                ]
+            } catch {
+                self.latestResult = ["error": "Processing error: \(error)", "isLive": false, "label": "error"]
+            }
+        }
+
+        // Return latest result immediately (may be previous or initial)
+        return latestResult
+        #else
+        return ["error": "TensorFlowLite not available", "isLive": false, "label": "stub"]
+        #endif
+    }
+
+    // MARK: - Helpers
+    #if canImport(TensorFlowLite)
+    private static func floatArray(from data: Data) -> [Float] {
+        let count = data.count / MemoryLayout<Float>.size
+        return data.withUnsafeBytes { buffer -> [Float] in
+            let ptr = buffer.bindMemory(to: Float.self)
+            return Array(UnsafeBufferPointer(start: ptr.baseAddress, count: count))
+        }
+    }
+
+    private static let sharedCIContext: CIContext = CIContext(options: nil)
+
+    private static func rgbFloatData(from pixelBuffer: CVPixelBuffer, size: CGSize) -> [Float]? {
+        CVPixelBufferLockBaseAddress(pixelBuffer, CVPixelBufferLockFlags.readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(pixelBuffer, CVPixelBufferLockFlags.readOnly) }
+
+        let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
+        let context = Self.sharedCIContext
+        guard let cgImage = context.createCGImage(ciImage, from: ciImage.extent) else { return nil }
+
+        let width = Int(size.width)
+        let height = Int(size.height)
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+        var rawData = [UInt8](repeating: 0, count: width * height * 4)
+        rawData.withUnsafeMutableBytes { ptr in
+            if let base = ptr.baseAddress {
+                let bytesPerRow = width * 4
+                if let ctx = CGContext(data: base,
+                                      width: width,
+                                      height: height,
+                                      bitsPerComponent: 8,
+                                      bytesPerRow: bytesPerRow,
+                                      space: colorSpace,
+                                      bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) {
+                    ctx.interpolationQuality = .high
+                    ctx.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
+                }
+            }
+        }
+
+        var floatData = [Float](repeating: 0, count: width * height * 3)
+        var idx = 0
+        for y in 0..<height {
+            for x in 0..<width {
+                let pixelIndex = (y * width + x) * 4
+                let r = Float(rawData[pixelIndex]) / 255.0
+                let g = Float(rawData[pixelIndex + 1]) / 255.0
+                let b = Float(rawData[pixelIndex + 2]) / 255.0
+                floatData[idx] = r
+                floatData[idx + 1] = g
+                floatData[idx + 2] = b
+                idx += 3
+            }
+        }
+        return floatData
+    }
+
+    private static func calculateLaplacianScore(from rgbData: [Float], width: Int, height: Int) -> Int {
+        var grey = [Int](repeating: 0, count: width * height)
+        var i = 0
+        for y in 0..<height {
+            for x in 0..<width {
+                let base = (y * width + x) * 3
+                let r = Int((rgbData[base] * 255).rounded())
+                let g = Int((rgbData[base + 1] * 255).rounded())
+                let b = Int((rgbData[base + 2] * 255).rounded())
+                let value = Int(0.299 * Float(r) + 0.587 * Float(g) + 0.114 * Float(b))
+                grey[i] = value
+                i += 1
+            }
+        }
+
+        let laplace = [[0,1,0],[1,-4,1],[0,1,0]]
+        let size = 3
+        var score = 0
+        let threshold = 50
+        for y in 0..<(height - size + 1) {
+            for x in 0..<(width - size + 1) {
+                var result = 0
+                for ky in 0..<size {
+                    for kx in 0..<size {
+                        result += grey[(y + ky) * width + (x + kx)] * laplace[ky][kx]
+                    }
+                }
+                if result > threshold {
+                    score += 1
+                }
+            }
+        }
+        return score
+    }
+
+    private static func calculateCombinedScore(neuralScore: Float, laplacianScore: Int) -> Float {
+        let normalizedNeural = min(max(neuralScore, 0), 1)
+        let normalizedLaplacian = min(max(Float(laplacianScore) / 4000.0, 0), 1)
+        let neuralWeight: Float = 0.6
+        let laplacianWeight: Float = 0.4
+        let invertedNeural = 1.0 - normalizedNeural
+        return (invertedNeural * neuralWeight) + (normalizedLaplacian * laplacianWeight)
+    }
+
+    private static func calculateConfidence(neuralScore: Float, laplacianScore: Int) -> Float {
+        let neuralConfidence = min(max(neuralScore, 0), 1)
+        let laplacianConfidence = min(max(Float(laplacianScore) / 4000.0, 0), 1)
+        let invertedNeural = 1.0 - neuralConfidence
+        return (invertedNeural * 0.6 + laplacianConfidence * 0.4)
+    }
+    #endif
+}
+
+#endif
+
+

package/ios/FaceAntiSpoofJSI.h

@@ -0,0 +1,12 @@
+// Simple header for JSI install stub
+#import <Foundation/Foundation.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void FaceAntiSpoofJSI_install(void *runtimePtr);
+
+#ifdef __cplusplus
+}
+#endif

package/ios/FaceAntiSpoofJSI.mm

@@ -0,0 +1,92 @@
+// Objective-C++ JSI registration for FaceAntiSpoof
+#import "FaceAntiSpoofJSI.h"
+#import <Foundation/Foundation.h>
+#import <objc/runtime.h>
+#import <objc/message.h>
+
+#ifdef __cplusplus
+#include <jsi/jsi.h>
+using namespace facebook;
+#endif
+
+// Helper to call +[FaceAntiSpoofManager isModelLoaded]
+static bool FaceAntiSpoofManager_isModelLoaded() {
+    Class managerClass = objc_getClass("FaceAntiSpoofManager");
+    if (!managerClass) return false;
+    SEL sel = sel_getUid("isModelLoaded");
+    if (!sel) return false;
+    BOOL (*msgSendBool)(id, SEL) = (BOOL (*)(id, SEL))objc_msgSend;
+    return msgSendBool((id)managerClass, sel);
+}
+
+// Helper to call +[FaceAntiSpoofManager initializeModel]
+static bool FaceAntiSpoofManager_initialize() {
+    Class managerClass = objc_getClass("FaceAntiSpoofManager");
+    if (!managerClass) return false;
+    SEL sel = sel_getUid("initializeModel");
+    if (!sel) return false;
+    BOOL (*msgSendBool)(id, SEL) = (BOOL (*)(id, SEL))objc_msgSend;
+    return msgSendBool((id)managerClass, sel);
+}
+
+extern "C" void FaceAntiSpoofJSI_install(void *runtimePtr) {
+#ifdef __cplusplus
+    if (!runtimePtr) {
+        NSLog(@"[FaceAntiSpoof] JSI install called with NULL runtime pointer");
+        return;
+    }
+
+    jsi::Runtime *rt = reinterpret_cast<jsi::Runtime*>(runtimePtr);
+    if (!rt) {
+        NSLog(@"[FaceAntiSpoof] JSI install: invalid runtime pointer");
+        return;
+    }
+
+    try {
+        // Register faceAntiSpoof_isModelLoaded()
+        auto isLoadedFunc = jsi::Function::createFromHostFunction(*rt,
+            jsi::PropNameID::forAscii(*rt, "faceAntiSpoof_isModelLoaded"), 0,
+            [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+                bool loaded = FaceAntiSpoofManager_isModelLoaded();
+                return jsi::Value(loaded);
+            }
+        );
+        rt->global().setProperty(*rt, "faceAntiSpoof_isModelLoaded", isLoadedFunc);
+
+        // Register faceAntiSpoof_initialize()
+        auto initFunc = jsi::Function::createFromHostFunction(*rt,
+            jsi::PropNameID::forAscii(*rt, "faceAntiSpoof_initialize"), 0,
+            [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+                bool ok = FaceAntiSpoofManager_initialize();
+                return jsi::Value(ok);
+            }
+        );
+        rt->global().setProperty(*rt, "faceAntiSpoof_initialize", initFunc);
+
+        // Register faceAntiSpoof_getModuleInfo()
+        auto infoFunc = jsi::Function::createFromHostFunction(*rt,
+            jsi::PropNameID::forAscii(*rt, "faceAntiSpoof_getModuleInfo"), 0,
+            [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+                jsi::Object obj(rt);
+                obj.setProperty(rt, "name", jsi::String::createFromUtf8(rt, "FaceAntiSpoof"));
+                jsi::Array methods(rt, 4);
+                methods.setValueAtIndex(rt, 0, jsi::String::createFromUtf8(rt, "initialize"));
+                methods.setValueAtIndex(rt, 1, jsi::String::createFromUtf8(rt, "checkModelStatus"));
+                methods.setValueAtIndex(rt, 2, jsi::String::createFromUtf8(rt, "isAvailable"));
+                methods.setValueAtIndex(rt, 3, jsi::String::createFromUtf8(rt, "cleanup"));
+                obj.setProperty(rt, "methods", methods);
+                return obj;
+            }
+        );
+        rt->global().setProperty(*rt, "faceAntiSpoof_getModuleInfo", infoFunc);
+
+        NSLog(@"[FaceAntiSpoof] JSI functions registered");
+    } catch (const std::exception &ex) {
+        NSLog(@"[FaceAntiSpoof] JSI registration exception: %s", ex.what());
+    } catch (...) {
+        NSLog(@"[FaceAntiSpoof] JSI registration unknown exception");
+    }
+#else
+    NSLog(@"[FaceAntiSpoof] JSI install compiled without C++ support");
+#endif
+}

package/ios/FaceAntiSpoofManager.swift

@@ -0,0 +1,63 @@
+import Foundation
+
+#if canImport(TensorFlowLite)
+import TensorFlowLite
+#endif
+
+@objcMembers
+public class FaceAntiSpoofManager: NSObject {
+    #if canImport(TensorFlowLite)
+    public static var sharedInterpreter: Interpreter?
+    #endif
+
+    @objc public class func initializeModel() -> Bool {
+        #if canImport(TensorFlowLite)
+        if sharedInterpreter != nil { return true }
+
+        // Look in main bundle then plugin bundle
+        var modelPath = 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")
+            }
+        }
+
+        guard let path = modelPath else {
+            NSLog("[FaceAntiSpoof] Manager: model not found")
+            return false
+        }
+
+        do {
+            var options = Interpreter.Options()
+            options.threadCount = 2
+            sharedInterpreter = try Interpreter(modelPath: path, options: options)
+            try sharedInterpreter?.allocateTensors()
+            NSLog("[FaceAntiSpoof] Manager: Loaded model at \(path)")
+            return true
+        } catch {
+            NSLog("[FaceAntiSpoof] Manager: Failed to create interpreter: \(error)")
+            sharedInterpreter = nil
+            return false
+        }
+        #else
+        NSLog("[FaceAntiSpoof] Manager: TensorFlowLite not available")
+        return false
+        #endif
+    }
+
+    @objc public class func isModelLoaded() -> Bool {
+        #if canImport(TensorFlowLite)
+        return sharedInterpreter != nil
+        #else
+        return false
+        #endif
+    }
+
+    @objc public class func cleanupModel() {
+        #if canImport(TensorFlowLite)
+        sharedInterpreter = nil
+        #endif
+        NSLog("[FaceAntiSpoof] Manager: cleaned up model")
+    }
+}

package/ios/FaceAntiSpoofModule.m

@@ -0,0 +1,191 @@
+#if __has_include(<React/RCTBridgeModule.h>)
+#import <React/RCTBridgeModule.h>
+#elif __has_include("RCTBridgeModule.h")
+#import "RCTBridgeModule.h"
+#else
+#warning "React headers not found - FaceAntiSpoofModule will expose stub implementation"
+#endif
+
+#import <objc/message.h>
+#if __has_include(<React/RCTBridge.h>)
+#import <React/RCTBridge.h>
+#elif __has_include("RCTBridge.h")
+#import "RCTBridge.h"
+#endif
+
+@interface FaceAntiSpoofModule : NSObject <RCTBridgeModule>
+@end
+
+@implementation FaceAntiSpoofModule
+
+RCT_EXPORT_MODULE(FaceAntiSpoof);
+
+// Indicate whether this module requires main thread initialization
++(BOOL)requiresMainQueueSetup
+{
+	return NO;
+}
+
+// Keep a reference to the bridge for lifecycle hooks
+static RCTBridge *_faceAntiSpoofBridge = nil;
+
+RCT_REMAP_METHOD(initialize,
+								 initializeWithResolver:(RCTPromiseResolveBlock)resolve
+								 rejecter:(RCTPromiseRejectBlock)reject)
+{
+
+	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofFrameProcessor") != Nil);
+
+	// Prefer the FaceAntiSpoofManager to initialize the model and create the interpreter
+	BOOL managerInitialized = NO;
+	Class managerClass = NSClassFromString(@"FaceAntiSpoofManager");
+	if (managerClass != Nil) {
+		SEL sel = NSSelectorFromString(@"initializeModel");
+		if ([managerClass respondsToSelector:sel]) {
+			// Call +initializeModel and capture BOOL result
+			BOOL (*msgSendBool)(id, SEL) = (BOOL (*)(id, SEL))objc_msgSend;
+			managerInitialized = msgSendBool((id)managerClass, sel);
+		}
+	}
+
+	// As a fallback, check bundle resources
+	NSString *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"];
+		}
+	}
+	BOOL modelLoaded = (modelPath != nil) || managerInitialized;
+	BOOL success = pluginAvailable && modelLoaded;
+	resolve(@(success));
+}
+
+RCT_REMAP_METHOD(checkModelStatus,
+								 checkModelStatusWithResolver:(RCTPromiseResolveBlock)resolve
+								 rejecter:(RCTPromiseRejectBlock)reject)
+{
+	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofFrameProcessor") != Nil);
+	NSString *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"];
+		}
+	}
+	BOOL modelLoaded = (modelPath != nil);
+	NSDictionary *result = @{@"pluginAvailable": @(pluginAvailable), @"modelLoaded": @(modelLoaded), @"moduleInitialized": @(YES)};
+	resolve(result);
+}
+
+RCT_REMAP_METHOD(isAvailable,
+								 isAvailableWithResolver:(RCTPromiseResolveBlock)resolve
+								 rejecter:(RCTPromiseRejectBlock)reject)
+{
+	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofFrameProcessor") != Nil);
+	resolve(@(pluginAvailable));
+}
+
+RCT_REMAP_METHOD(testMethod,
+								 testMethodWithResolver:(RCTPromiseResolveBlock)resolve
+								 rejecter:(RCTPromiseRejectBlock)reject)
+{
+	resolve(@"iOS native module stub");
+}
+
+RCT_REMAP_METHOD(getModuleInfo,
+								 getModuleInfoWithResolver:(RCTPromiseResolveBlock)resolve
+								 rejecter:(RCTPromiseRejectBlock)reject)
+{
+	NSDictionary *info = @{@"name": @"FaceAntiSpoof", @"methods": @[@"initialize", @"checkModelStatus", @"isAvailable", @"testMethod", @"getModuleInfo", @"install", @"cleanup"]};
+	resolve(info);
+}
+
+RCT_REMAP_METHOD(install,
+								 installWithResolver:(RCTPromiseResolveBlock)resolve
+								 rejecter:(RCTPromiseRejectBlock)reject)
+{
+	// Attempt to initialize shared model resources via FaceAntiSpoofManager
+	BOOL managerInitialized = NO;
+	Class managerClass = NSClassFromString(@"FaceAntiSpoofManager");
+	if (managerClass != Nil) {
+		SEL sel = NSSelectorFromString(@"initializeModel");
+		if ([managerClass respondsToSelector:sel]) {
+			BOOL (*msgSendBool)(id, SEL) = (BOOL (*)(id, SEL))objc_msgSend;
+			managerInitialized = msgSendBool((id)managerClass, sel);
+		}
+	}
+
+	BOOL pluginAvailable = (NSClassFromString(@"FaceAntiSpoofFrameProcessor") != Nil);
+	NSString *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"];
+		}
+	}
+	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);
+		}
+	}
+
+	resolve(@(pluginAvailable && modelLoaded));
+}
+
+RCT_REMAP_METHOD(cleanup,
+								 cleanupWithResolver:(RCTPromiseResolveBlock)resolve
+								 rejecter:(RCTPromiseRejectBlock)reject)
+{
+	// Ask manager to cleanup interpreter
+	Class managerClass = NSClassFromString(@"FaceAntiSpoofManager");
+	if (managerClass != Nil) {
+		SEL sel = NSSelectorFromString(@"cleanupModel");
+		if ([managerClass respondsToSelector:sel]) {
+			void (*msgSendVoid)(id, SEL) = (void (*)(id, SEL))objc_msgSend;
+			msgSendVoid((id)managerClass, sel);
+		}
+	}
+	resolve(@(YES));
+}
+
+- (void)setBridge:(RCTBridge *)bridge {
+	_faceAntiSpoofBridge = bridge;
+}
+
+- (void)invalidate {
+	Class managerClass = NSClassFromString(@"FaceAntiSpoofManager");
+	if (managerClass != Nil) {
+		SEL sel = NSSelectorFromString(@"cleanupModel");
+		if ([managerClass respondsToSelector:sel]) {
+			void (*msgSendVoid)(id, SEL) = (void (*)(id, SEL))objc_msgSend;
+			msgSendVoid((id)managerClass, sel);
+		}
+	}
+	_faceAntiSpoofBridge = nil;
+}
+
+@end