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

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

package/ios/HybridSpoofDetectorOutput.swift

@@ -0,0 +1,164 @@
+import AVFoundation
+import CoreImage
+import Foundation
+import NitroModules
+import VisionCamera
+
+final class HybridSpoofDetectorOutput: HybridCameraOutputSpec, NativeCameraOutput {
+  private let queue = DispatchQueue(label: "com.faceantispoof.output", qos: .userInitiated)
+  private let options: SpoofDetectorOutputOptions
+  private let delegate: SpoofDetectorDelegate
+  private let ciContext = CIContext(options: nil)
+  private let stateLock = NSLock()
+  private let targetSize = 256
+  private var isBusy = false
+  private var isDisposed = false
+
+  let output = AVCaptureVideoDataOutput()
+  let requiresAudioInput = false
+  let requiresDepthFormat = false
+  let mediaType: MediaType = .video
+  var streamType: StreamType = .video
+  var outputOrientation: CameraOrientation = .up
+
+  var currentResolution: margelo.nitro.camera.Size? {
+    guard let connection = output.connection(with: .video) else { return nil }
+    return connection.inputStreamResolution
+  }
+
+  var targetResolution: ResolutionRule {
+    return .closestTo(margelo.nitro.camera.Size(width: 720.0, height: 1280.0))
+  }
+
+  init(options: SpoofDetectorOutputOptions) {
+    self.options = options
+    self.delegate = SpoofDetectorDelegate()
+    super.init()
+
+    delegate.onSampleBuffer = { [weak self] sampleBuffer in
+      self?.process(sampleBuffer)
+    }
+    output.setSampleBufferDelegate(delegate, queue: queue)
+    output.alwaysDiscardsLateVideoFrames = true
+  }
+
+  func configure(config: OutputConfiguration) {
+    guard let connection = output.connection(with: .video) else { return }
+    connection.preferredVideoStabilizationMode = .off
+  }
+
+  func dispose() {
+    stateLock.lock()
+    isDisposed = true
+    stateLock.unlock()
+    output.setSampleBufferDelegate(nil, queue: nil)
+  }
+
+  private func process(_ sampleBuffer: CMSampleBuffer) {
+    stateLock.lock()
+    guard !isDisposed, !isBusy else {
+      stateLock.unlock()
+      return
+    }
+    isBusy = true
+    stateLock.unlock()
+
+    guard let input = makeRGBInput(from: sampleBuffer) else {
+      stateLock.lock()
+      isBusy = false
+      stateLock.unlock()
+      options.onError?(RuntimeError.error(withMessage: "Failed to create RGB frame input."))
+      return
+    }
+
+    queue.async { [weak self] in
+      guard let self else { return }
+      defer {
+        self.stateLock.lock()
+        self.isBusy = false
+        self.stateLock.unlock()
+      }
+
+      do {
+        let result = try FaceAntiSpoofManager.process(input: input)
+        self.options.onResult(
+          AntiSpoofingResult(
+            isLive: result.isLive,
+            label: result.isLive ? "Live Face" : "Spoof Face",
+            neuralNetworkScore: result.neuralNetworkScore,
+            laplacianScore: result.laplacianScore,
+            combinedScore: result.combinedScore,
+            confidence: result.confidence
+          )
+        )
+      } catch {
+        self.options.onError?(error)
+      }
+    }
+  }
+
+  private func makeRGBInput(from sampleBuffer: CMSampleBuffer) -> [Float]? {
+    guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return nil }
+
+    let image = CIImage(cvPixelBuffer: pixelBuffer)
+    let oriented = image.oriented(forExifOrientation: outputOrientation.exifOrientation)
+    guard let cgImage = ciContext.createCGImage(oriented, from: oriented.extent) else {
+      return nil
+    }
+
+    let width = targetSize
+    let height = targetSize
+    let colorSpace = CGColorSpaceCreateDeviceRGB()
+    var bytes = [UInt8](repeating: 0, count: width * height * 4)
+    let rendered = bytes.withUnsafeMutableBytes { rawBuffer -> Bool in
+      guard let baseAddress = rawBuffer.baseAddress,
+            let context = CGContext(
+              data: baseAddress,
+              width: width,
+              height: height,
+              bitsPerComponent: 8,
+              bytesPerRow: width * 4,
+              space: colorSpace,
+              bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+            ) else { return false }
+      context.interpolationQuality = .high
+      context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
+      return true
+    }
+    guard rendered else { return nil }
+
+    var result = [Float](repeating: 0, count: width * height * 3)
+    for index in 0..<(width * height) {
+      let source = index * 4
+      let destination = index * 3
+      result[destination] = Float(bytes[source]) / 255.0
+      result[destination + 1] = Float(bytes[source + 1]) / 255.0
+      result[destination + 2] = Float(bytes[source + 2]) / 255.0
+    }
+    return result
+  }
+}
+
+private final class SpoofDetectorDelegate: NSObject, AVCaptureVideoDataOutputSampleBufferDelegate {
+  var onSampleBuffer: ((CMSampleBuffer) -> Void)?
+
+  func captureOutput(
+    _ output: AVCaptureOutput,
+    didOutput sampleBuffer: CMSampleBuffer,
+    from connection: AVCaptureConnection
+  ) {
+    onSampleBuffer?(sampleBuffer)
+  }
+}
+
+private extension CameraOrientation {
+  var exifOrientation: Int32 {
+    switch self {
+    case .up: return 1
+    case .right: return 6
+    case .down: return 3
+    case .left: return 8
+    @unknown default: return 1
+    }
+  }
+}

package/nitro.json

@@ -10,6 +10,10 @@
   },
   "autolinking": {
     "SpoofDetectorFactory": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridSpoofDetectorFactory"
+      },
       "android": {
         "language": "kotlin",
         "implementationClassName": "HybridSpoofDetectorFactory"

package/nitrogen/generated/ios/VisionCameraSpoofDetector+autolinking.rb

@@ -0,0 +1,62 @@
+#
+# VisionCameraSpoofDetector+autolinking.rb
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# ```ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/VisionCameraSpoofDetector+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# ```
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 VisionCameraSpoofDetector is boosted by nitro!"
+
+  spec.dependency "NitroModules"
+
+  current_source_files = Array(spec.attributes_hash['source_files'])
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}",
+  ]
+
+  current_public_header_files = Array(spec.attributes_hash['public_header_files'])
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/VisionCameraSpoofDetector-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = Array(spec.attributes_hash['private_header_files'])
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+    # Views are framework-specific and should be private
+    "nitrogen/generated/shared/**/views/**/*"
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
+  })
+end

package/nitrogen/generated/ios/VisionCameraSpoofDetector-Swift-Cxx-Bridge.cpp

@@ -0,0 +1,60 @@
+///
+/// VisionCameraSpoofDetector-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "VisionCameraSpoofDetector-Swift-Cxx-Bridge.hpp"
+
+// Include C++ implementation defined types
+#include "HybridSpoofDetectorFactorySpecSwift.hpp"
+#include "VisionCameraSpoofDetector-Swift-Cxx-Umbrella.hpp"
+#include <NitroModules/NitroDefines.hpp>
+#include <VisionCamera/VisionCamera-Swift-Cxx-Bridge.hpp>
+
+namespace margelo::nitro::camera::spoofdetector::bridge::swift {
+
+  // pragma MARK: std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>
+  std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec> create_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    // Implemented in VisionCamera
+    return margelo::nitro::camera::bridge::swift::create_std__shared_ptr_HybridCameraOutputSpec_(swiftUnsafePointer);
+  }
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_(std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_ cppType) {
+    // Implemented in VisionCamera
+    return margelo::nitro::camera::bridge::swift::get_std__shared_ptr_HybridCameraOutputSpec_(cppType);
+  }
+  
+  // pragma MARK: std::function<void(const AntiSpoofingResult& /* result */)>
+  Func_void_AntiSpoofingResult create_Func_void_AntiSpoofingResult(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = VisionCameraSpoofDetector::Func_void_AntiSpoofingResult::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const AntiSpoofingResult& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = VisionCameraSpoofDetector::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
+      swiftClosure.call(error);
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridSpoofDetectorFactorySpec>
+  std::shared_ptr<HybridSpoofDetectorFactorySpec> create_std__shared_ptr_HybridSpoofDetectorFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    VisionCameraSpoofDetector::HybridSpoofDetectorFactorySpec_cxx swiftPart = VisionCameraSpoofDetector::HybridSpoofDetectorFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::camera::spoofdetector::HybridSpoofDetectorFactorySpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridSpoofDetectorFactorySpec_(std__shared_ptr_HybridSpoofDetectorFactorySpec_ cppType) {
+    std::shared_ptr<margelo::nitro::camera::spoofdetector::HybridSpoofDetectorFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::camera::spoofdetector::HybridSpoofDetectorFactorySpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridSpoofDetectorFactorySpec\" is not implemented in Swift!");
+    }
+    #endif
+    VisionCameraSpoofDetector::HybridSpoofDetectorFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+
+} // namespace margelo::nitro::camera::spoofdetector::bridge::swift