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

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

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

@@ -0,0 +1,151 @@
+///
+/// VisionCameraSpoofDetector-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `AntiSpoofingResult` to properly resolve imports.
+namespace margelo::nitro::camera::spoofdetector { struct AntiSpoofingResult; }
+// Forward declaration of `HybridCameraOutputSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridCameraOutputSpec; }
+// Forward declaration of `HybridSpoofDetectorFactorySpec` to properly resolve imports.
+namespace margelo::nitro::camera::spoofdetector { class HybridSpoofDetectorFactorySpec; }
+// Forward declaration of `Size` to properly resolve imports.
+namespace margelo::nitro::camera::spoofdetector { struct Size; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridCameraOutputSpec_cxx` to properly resolve imports.
+namespace VisionCamera { class HybridCameraOutputSpec_cxx; }
+// Forward declaration of `HybridSpoofDetectorFactorySpec_cxx` to properly resolve imports.
+namespace VisionCameraSpoofDetector { class HybridSpoofDetectorFactorySpec_cxx; }
+
+// Include C++ defined types
+#include "AntiSpoofingResult.hpp"
+#include "HybridSpoofDetectorFactorySpec.hpp"
+#include "Size.hpp"
+#include <NitroModules/Result.hpp>
+#include <VisionCamera/HybridCameraOutputSpec.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::camera::spoofdetector::bridge::swift {
+
+  // pragma MARK: std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_ = 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;
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_(std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::camera::HybridCameraOutputSpec>
+  using std__weak_ptr_margelo__nitro__camera__HybridCameraOutputSpec_ = std::weak_ptr<margelo::nitro::camera::HybridCameraOutputSpec>;
+  inline std__weak_ptr_margelo__nitro__camera__HybridCameraOutputSpec_ weakify_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec_(const std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<Size>
+  /**
+   * Specialized version of `std::optional<Size>`.
+   */
+  using std__optional_Size_ = std::optional<Size>;
+  inline std::optional<Size> create_std__optional_Size_(const Size& value) noexcept {
+    return std::optional<Size>(value);
+  }
+  inline bool has_value_std__optional_Size_(const std::optional<Size>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Size get_std__optional_Size_(const std::optional<Size>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::function<void(const AntiSpoofingResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const AntiSpoofingResult&)>`.
+   */
+  using Func_void_AntiSpoofingResult = std::function<void(const AntiSpoofingResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const AntiSpoofingResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_AntiSpoofingResult_Wrapper final {
+  public:
+    explicit Func_void_AntiSpoofingResult_Wrapper(std::function<void(const AntiSpoofingResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const AntiSpoofingResult& /* result */)>>(std::move(func))) {}
+    inline void call(AntiSpoofingResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const AntiSpoofingResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_AntiSpoofingResult create_Func_void_AntiSpoofingResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_AntiSpoofingResult_Wrapper wrap_Func_void_AntiSpoofingResult(Func_void_AntiSpoofingResult value) noexcept {
+    return Func_void_AntiSpoofingResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__exception_ptr_Wrapper final {
+  public:
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const std::exception_ptr& /* error */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const std::exception_ptr& / * error * /)>>`.
+   */
+  using std__optional_std__function_void_const_std__exception_ptr_____error______ = std::optional<std::function<void(const std::exception_ptr& /* error */)>>;
+  inline std::optional<std::function<void(const std::exception_ptr& /* error */)>> create_std__optional_std__function_void_const_std__exception_ptr_____error______(const std::function<void(const std::exception_ptr& /* error */)>& value) noexcept {
+    return std::optional<std::function<void(const std::exception_ptr& /* error */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_std__exception_ptr_____error______(const std::optional<std::function<void(const std::exception_ptr& /* error */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const std::exception_ptr& /* error */)> get_std__optional_std__function_void_const_std__exception_ptr_____error______(const std::optional<std::function<void(const std::exception_ptr& /* error */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridSpoofDetectorFactorySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridSpoofDetectorFactorySpec>`.
+   */
+  using std__shared_ptr_HybridSpoofDetectorFactorySpec_ = std::shared_ptr<HybridSpoofDetectorFactorySpec>;
+  std::shared_ptr<HybridSpoofDetectorFactorySpec> create_std__shared_ptr_HybridSpoofDetectorFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridSpoofDetectorFactorySpec_(std__shared_ptr_HybridSpoofDetectorFactorySpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridSpoofDetectorFactorySpec>
+  using std__weak_ptr_HybridSpoofDetectorFactorySpec_ = std::weak_ptr<HybridSpoofDetectorFactorySpec>;
+  inline std__weak_ptr_HybridSpoofDetectorFactorySpec_ weakify_std__shared_ptr_HybridSpoofDetectorFactorySpec_(const std::shared_ptr<HybridSpoofDetectorFactorySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>>
+  using Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__ = Result<std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>>;
+  inline Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__ create_Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__(const std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>& value) noexcept {
+    return Result<std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__ create_Result_std__shared_ptr_margelo__nitro__camera__HybridCameraOutputSpec__(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<margelo::nitro::camera::HybridCameraOutputSpec>>::withError(error);
+  }
+
+} // namespace margelo::nitro::camera::spoofdetector::bridge::swift

package/nitrogen/generated/ios/VisionCameraSpoofDetector-Swift-Cxx-Umbrella.hpp

@@ -0,0 +1,60 @@
+///
+/// VisionCameraSpoofDetector-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `AntiSpoofingResult` to properly resolve imports.
+namespace margelo::nitro::camera::spoofdetector { struct AntiSpoofingResult; }
+// Forward declaration of `HybridCameraOutputSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridCameraOutputSpec; }
+// Forward declaration of `HybridSpoofDetectorFactorySpec` to properly resolve imports.
+namespace margelo::nitro::camera::spoofdetector { class HybridSpoofDetectorFactorySpec; }
+// Forward declaration of `Size` to properly resolve imports.
+namespace margelo::nitro::camera::spoofdetector { struct Size; }
+// Forward declaration of `SpoofDetectorOutputOptions` to properly resolve imports.
+namespace margelo::nitro::camera::spoofdetector { struct SpoofDetectorOutputOptions; }
+
+// Include C++ defined types
+#include "AntiSpoofingResult.hpp"
+#include "HybridSpoofDetectorFactorySpec.hpp"
+#include "Size.hpp"
+#include "SpoofDetectorOutputOptions.hpp"
+#include <NitroModules/Result.hpp>
+#include <VisionCamera/HybridCameraOutputSpec.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+// C++ helpers for Swift
+#include "VisionCameraSpoofDetector-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridCameraOutputSpec_cxx` to properly resolve imports.
+namespace VisionCamera { class HybridCameraOutputSpec_cxx; }
+// Forward declaration of `HybridSpoofDetectorFactorySpec_cxx` to properly resolve imports.
+namespace VisionCameraSpoofDetector { class HybridSpoofDetectorFactorySpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("VisionCameraSpoofDetector-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "VisionCameraSpoofDetector".
+#include "VisionCameraSpoofDetector-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<VisionCameraSpoofDetector/VisionCameraSpoofDetector-Swift.h>)
+#include <VisionCameraSpoofDetector/VisionCameraSpoofDetector-Swift.h>
+#else
+#error VisionCameraSpoofDetector's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "VisionCameraSpoofDetector", and try building the app first.
+#endif