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

package/android/src/main/cpp/FaceAntiSpoofJSI.cpp

@@ -1,6 +1,8 @@
 #include <jni.h>
 #include <jsi/jsi.h>
 #include <string>
+#include <vector>
+#include <algorithm>
 #include <android/log.h>
 
 using namespace facebook;
@@ -8,18 +10,90 @@ using namespace facebook;
 // Logging macro
 #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FaceAntiSpoofJSI", __VA_ARGS__))
 
-// Dummy frame processing function
+static JavaVM *javaVm = nullptr;
+
 jsi::Value faceAntiSpoof(jsi::Runtime &runtime, const jsi::Value &frame) {
-    LOGI("FaceAntiSpoofJSI: frame received");
+    if (!frame.isObject()) {
+        throw jsi::JSError(runtime, "FaceAntiSpoof expected a Frame object");
+    }
 
-    jsi::Object result(runtime);
-    result.setProperty(runtime, "isLive", true);
-    result.setProperty(runtime, "label", "Live");
-    result.setProperty(runtime, "confidence", 0.99);
+    auto frameObject = frame.asObject(runtime);
+    auto planesValue = frameObject.getProperty(runtime, "getPlanes").asObject(runtime)
+        .asFunction(runtime).call(runtime, frameObject);
+    auto planes = planesValue.asObject(runtime);
+    auto length = static_cast<size_t>(planes.getProperty(runtime, "length").asNumber());
+    if (length < 3) {
+        throw jsi::JSError(runtime, "FaceAntiSpoof expected Y, U and V planes");
+    }
 
+    std::vector<std::vector<uint8_t>> planeData(3);
+    jint rowStrides[3] = {};
+    jint pixelStrides[3] = {};
+    for (size_t index = 0; index < 3; index++) {
+        auto plane = planes.getProperty(runtime, jsi::Value(static_cast<double>(index))).asObject(runtime);
+        auto buffer = plane.getProperty(runtime, "getPixelBuffer").asObject(runtime)
+            .asFunction(runtime).call(runtime, plane).asObject(runtime);
+        auto arrayBuffer = std::move(buffer).getArrayBuffer(runtime);
+        auto *data = static_cast<const uint8_t *>(arrayBuffer.data(runtime));
+        planeData[index].assign(data, data + arrayBuffer.size(runtime));
+        rowStrides[index] = static_cast<jint>(plane.getProperty(runtime, "bytesPerRow").asNumber());
+        auto planeWidth = plane.getProperty(runtime, "width").asNumber();
+        pixelStrides[index] = std::max(1, static_cast<jint>(rowStrides[index] / planeWidth));
+    }
+
+    JNIEnv *env = nullptr;
+    bool attached = false;
+    if (javaVm == nullptr) {
+        throw jsi::JSError(runtime, "FaceAntiSpoof Android runtime is unavailable");
+    }
+    if (javaVm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) == JNI_EDETACHED) {
+        if (javaVm->AttachCurrentThread(&env, nullptr) != JNI_OK) {
+            throw jsi::JSError(runtime, "FaceAntiSpoof could not attach to Android runtime");
+        }
+        attached = true;
+    }
+    auto moduleClass = env->FindClass("com/faceantispoof/FaceAntiSpoofModule");
+    auto process = env->GetStaticMethodID(moduleClass, "processFrameFromJSI", "([[BII[I[I)[D");
+    auto javaPlanes = env->NewObjectArray(3, env->FindClass("[B"), nullptr);
+    auto javaRowStrides = env->NewIntArray(3);
+    auto javaPixelStrides = env->NewIntArray(3);
+    env->SetIntArrayRegion(javaRowStrides, 0, 3, rowStrides);
+    env->SetIntArrayRegion(javaPixelStrides, 0, 3, pixelStrides);
+    for (int index = 0; index < 3; index++) {
+        auto bytes = env->NewByteArray(static_cast<jsize>(planeData[index].size()));
+        env->SetByteArrayRegion(bytes, 0, static_cast<jsize>(planeData[index].size()),
+            reinterpret_cast<const jbyte *>(planeData[index].data()));
+        env->SetObjectArrayElement(javaPlanes, index, bytes);
+        env->DeleteLocalRef(bytes);
+    }
+    auto values = static_cast<jdoubleArray>(env->CallStaticObjectMethod(
+        moduleClass, process, javaPlanes, static_cast<jint>(frameObject.getProperty(runtime, "width").asNumber()),
+        static_cast<jint>(frameObject.getProperty(runtime, "height").asNumber()),
+        javaRowStrides, javaPixelStrides));
+    jdouble output[5] = {};
+    if (values != nullptr) env->GetDoubleArrayRegion(values, 0, 5, output);
+    env->DeleteLocalRef(values);
+    env->DeleteLocalRef(javaPixelStrides);
+    env->DeleteLocalRef(javaRowStrides);
+    env->DeleteLocalRef(javaPlanes);
+    env->DeleteLocalRef(moduleClass);
+    if (attached) javaVm->DetachCurrentThread();
+
+    jsi::Object result(runtime);
+    result.setProperty(runtime, "isLive", output[0] != 0.0);
+    result.setProperty(runtime, "label", output[0] != 0.0 ? "Live Face" : "Spoof Face");
+    result.setProperty(runtime, "neuralNetworkScore", output[1]);
+    result.setProperty(runtime, "laplacianScore", output[2]);
+    result.setProperty(runtime, "combinedScore", output[3]);
+    result.setProperty(runtime, "confidence", output[4]);
     return result;
 }
 
+extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *) {
+    javaVm = vm;
+    return JNI_VERSION_1_6;
+}
+
 // JSI registration function
 extern "C"
 JNIEXPORT void JNICALL

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,9 @@
+#include "VisionCameraSpoofDetectorOnLoad.hpp"
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::camera::spoofdetector::registerAllNatives();
+  });
+}

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

@@ -13,17 +13,27 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
 
     companion object {
         const val NAME = "FaceAntiSpoof"
+        private var activeModule: FaceAntiSpoofModule? = null
+
+        @JvmStatic
+        fun processFrameFromJSI(
+            planes: Array<ByteArray>,
+            width: Int,
+            height: Int,
+            rowStrides: IntArray,
+            pixelStrides: IntArray
+        ): DoubleArray {
+            val module = activeModule
+                ?: return doubleArrayOf(0.0, 0.0, 0.0, 0.0, 0.0)
+            return module.processNativeFrame(planes, width, height, rowStrides, pixelStrides)
+        }
     }
 
     private var faceAntiSpoofing: FaceAntiSpoofingAdvanced? = null
     private var isModuleInitialized = false
 
     init {
-        try {
-            System.loadLibrary("faceantispoof")
-        } catch (e: Exception) {
-            android.util.Log.e("FaceAntiSpoof", "Error loading native library", e)
-        }
+        activeModule = this
 
         try {
             // Initialize face anti-spoofing with app assets
@@ -35,57 +45,6 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
             isModuleInitialized = false
         }
 
-        try {
-            tryRegisterJSI()
-        } catch (e: Exception) {
-            android.util.Log.e("FaceAntiSpoof", "Error starting JSI registration", e)
-        }
-    }
-
-    private fun tryRegisterJSI() {
-        try {
-            Thread {
-                try {
-                    Thread.sleep(500)
-                    val holder = reactApplicationContext.javaScriptContextHolder ?: return@Thread
-
-                    // Try nativePointer
-                    try {
-                        val field = holder.javaClass.getDeclaredField("nativePointer")
-                        field.isAccessible = true
-                        val jsContextPtr = field.getLong(holder)
-                        if (jsContextPtr != 0L) {
-                            try {
-                                registerJSIFunction(jsContextPtr)
-                            } catch (e: Exception) {
-                                android.util.Log.d("FaceAntiSpoof", "JSI registration not available: ${e.message}")
-                            }
-                            return@Thread
-                        }
-                    } catch (_: Exception) { }
-
-                    // Try mContext
-                    try {
-                        val field = holder.javaClass.getDeclaredField("mContext")
-                        field.isAccessible = true
-                        val jsContextPtr = field.getLong(holder)
-                        if (jsContextPtr != 0L) {
-                            try {
-                                registerJSIFunction(jsContextPtr)
-                            } catch (e: Exception) {
-                                android.util.Log.d("FaceAntiSpoof", "JSI registration not available: ${e.message}")
-                            }
-                            return@Thread
-                        }
-                    } catch (_: Exception) { }
-
-                } catch (e: Exception) {
-                    android.util.Log.d("FaceAntiSpoof", "Error in JSI registration thread: ${e.message}")
-                }
-            }.start()
-        } catch (e: Exception) {
-            android.util.Log.d("FaceAntiSpoof", "Failed to start thread for JSI registration: ${e.message}")
-        }
     }
 
     override fun getName(): String = NAME
@@ -181,6 +140,41 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
         }
     }
 
+    @Synchronized
+    private fun processNativeFrame(
+        planes: Array<ByteArray>,
+        width: Int,
+        height: Int,
+        rowStrides: IntArray,
+        pixelStrides: IntArray
+    ): DoubleArray {
+        if (!isModuleInitialized || faceAntiSpoofing == null || planes.size < 3) {
+            return doubleArrayOf(0.0, 0.0, 0.0, 0.0, 0.0)
+        }
+
+        return try {
+            val result = faceAntiSpoofing!!.advancedAntiSpoofing(
+                planes,
+                width,
+                height,
+                rowStrides,
+                pixelStrides
+            )
+            val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
+                result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
+            doubleArrayOf(
+                if (isLive) 1.0 else 0.0,
+                result.neuralNetworkScore.toDouble(),
+                result.laplacianScore.toDouble(),
+                result.combinedScore.toDouble(),
+                result.confidence.toDouble()
+            )
+        } catch (error: Exception) {
+            android.util.Log.e("FaceAntiSpoof", "Native frame processing failed", error)
+            doubleArrayOf(0.0, 0.0, 0.0, 0.0, 0.0)
+        }
+    }
+
     @ReactMethod
     fun isAvailable(promise: Promise) {
         try {
@@ -218,51 +212,9 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
 
     @ReactMethod
     fun install(promise: Promise) {
-        try {
-            val holder = reactApplicationContext.javaScriptContextHolder
-
-            if (holder != null) {
-                // Try nativePointer
-                try {
-                    val f = holder.javaClass.getDeclaredField("nativePointer")
-                    f.isAccessible = true
-                    val ptr = f.getLong(holder)
-                    if (ptr != 0L) {
-                        try {
-                            registerJSIFunction(ptr)
-                            promise.resolve(true)
-                            return
-                        } catch (e: Exception) {
-                            android.util.Log.d("FaceAntiSpoof", "JSI not available: ${e.message}")
-                        }
-                    }
-                } catch (_: Exception) {}
-
-                // Try mContext
-                try {
-                    val f = holder.javaClass.getDeclaredField("mContext")
-                    f.isAccessible = true
-                    val ptr = f.getLong(holder)
-                    if (ptr != 0L) {
-                        try {
-                            registerJSIFunction(ptr)
-                            promise.resolve(true)
-                            return
-                        } catch (e: Exception) {
-                            android.util.Log.d("FaceAntiSpoof", "JSI not available: ${e.message}")
-                        }
-                    }
-                } catch (_: Exception) {}
-
-                promise.resolve(false)
-            } else {
-                promise.resolve(false)
-            }
-
-        } catch (e: Exception) {
-            android.util.Log.e("FaceAntiSpoof", "install() error", e)
-            promise.reject("INSTALL_ERROR", "Failed to install JSI function", e)
-        }
+        // VisionCamera 5 uses the Nitro CameraOutput. The old reflective JSI
+        // installer targets a native library that is no longer part of this module.
+        promise.resolve(false)
     }
 
     @ReactMethod
@@ -279,6 +231,8 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
         }
     }
 
+    @Suppress("DEPRECATION")
+    @Deprecated("React Native deprecated this lifecycle callback; retained for compatibility.")
     override fun onCatalystInstanceDestroy() {
         // Cleanup when React Native is shutting down
         try {
@@ -292,6 +246,4 @@ class FaceAntiSpoofModule(reactContext: ReactApplicationContext) : ReactContextB
         super.onCatalystInstanceDestroy()
     }
 
-    // Native JSI registration - optional, may not be available
-    private external fun registerJSIFunction(jsContext: Long)
 }

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

@@ -1,15 +1,22 @@
-package com.faceantispoof
+package com.margelo.nitro.camera.spoofdetector
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.faceantispoof.FaceAntiSpoofModule
 
-class FaceAntiSpoofPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
-        listOf(FaceAntiSpoofModule(reactContext))
+class FaceAntiSpoofPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+        if (name == FaceAntiSpoofModule.NAME) FaceAntiSpoofModule(reactContext) else null
 
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+        HashMap()
+    }
+
+    companion object {
+        init {
+            VisionCameraSpoofDetectorOnLoad.initializeNative()
+        }
     }
 }

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

@@ -0,0 +1,15 @@
+package com.margelo.nitro.camera.spoofdetector
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.camera.HybridCameraOutputSpec
+
+@DoNotStrip
+@Keep
+class HybridSpoofDetectorFactory : HybridSpoofDetectorFactorySpec() {
+  @DoNotStrip
+  @Keep
+  override fun createSpoofDetectorOutput(options: SpoofDetectorOutputOptions): HybridCameraOutputSpec {
+    return HybridSpoofDetectorOutput(options)
+  }
+}

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

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

package/index.js

@@ -1,50 +1,29 @@
-import { NativeModules } from 'react-native';
-import { useFrameOutput } from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
+import { useMemo, useRef } from 'react';
+import { NativeModules } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
 
 const { FaceAntiSpoof } = NativeModules;
 
-const processFrameOnRN = (frameData, width, height, onResult) => {
-  FaceAntiSpoof.processFrame(frameData.planes, width, height, frameData.rowStrides, frameData.pixelStrides)
-    .then(onResult)
-    .catch((error) => console.error('[FaceAntiSpoof] Frame processing failed:', error));
-};
-
 export const useFaceAntiSpoofFrameOutput = ({ onResult, ...options } = {}) => {
-  const onFrame = (frame) => {
-    'worklet';
-    try {
-      const planes = frame.getPlanes();
-      if (planes.length < 3) return;
-
-      const planeData = planes.map((plane) => Array.from(new Uint8Array(plane.getPixelBuffer())));
-      const rowStrides = planes.map((plane) => plane.bytesPerRow);
-      const pixelStrides = planes.map((plane) => plane.bytesPerRow / plane.width);
-      scheduleOnRN(
-        processFrameOnRN,
-        { planes: planeData, rowStrides, pixelStrides },
-        frame.width,
-        frame.height,
-        onResult,
-      );
-    } finally {
-      frame.dispose();
-    }
-  };
-
-  return useFrameOutput({
-    ...options,
-    pixelFormat: 'yuv',
-    targetResolution: { width: 256, height: 256 },
-    onFrame,
-  });
-};
-
-// Kept as a named export for source compatibility. VisionCamera 5 applications
-// must use useFaceAntiSpoofFrameOutput because the old plugin API was removed.
-export const faceAntiSpoofFrameProcessor = function () {
-  'worklet';
-  return null;
+  const resultRef = useRef(onResult);
+  resultRef.current = onResult;
+  const errorRef = useRef(options.onError);
+  errorRef.current = options.onError;
+  const factory = useMemo(
+    () => NitroModules.createHybridObject('SpoofDetectorFactory'),
+    [],
+  );
+  return useMemo(
+    () => factory.createSpoofDetectorOutput({
+      onResult(result) {
+        resultRef.current?.(result);
+      },
+      onError(error) {
+        errorRef.current?.(error);
+      },
+    }),
+    [factory],
+  );
 };
 
 export default FaceAntiSpoof;

package/nitro.json

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

package/nitrogen/generated/.gitattributes

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

package/nitrogen/generated/android/VisionCameraSpoofDetector+autolinking.cmake

@@ -0,0 +1,81 @@
+#
+# VisionCameraSpoofDetector+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/VisionCameraSpoofDetector+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_VISIONCAMERASPOOFDETECTOR_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  VisionCameraSpoofDetector PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/VisionCameraSpoofDetectorOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridSpoofDetectorFactorySpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridSpoofDetectorFactorySpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  VisionCameraSpoofDetector PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        VisionCameraSpoofDetector
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        VisionCameraSpoofDetector
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        VisionCameraSpoofDetector
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()