@nitro-mlkit/pose-detection 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gonzalo Polo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NitroMLKitPose.podspec

@@ -0,0 +1,34 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroMLKitPose"
+  # Must match nitro.json's `ios.iosModuleName` — Nitrogen's generated bridge
+  # imports "NitroMLKitPose-Swift.h", so the compiled Swift module name has to be NitroMLKitPose.
+  s.module_name  = "NitroMLKitPose"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["repository"]["url"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+  s.source       = { :git => "https://github.com/pologonzalo/react-native-nitro-mlkit.git", :tag => s.version }
+
+  s.platforms    = { :ios => "15.5" }
+
+  s.source_files = [
+    "ios/**/*.{swift,h,m,mm,cpp}"
+  ]
+
+  s.dependency "GoogleMLKit/PoseDetection", "~> 7.0"
+
+  s.pod_target_xcconfig = {
+    "SWIFT_VERSION" => "5.9"
+  }
+
+  # Add all files generated by Nitrogen (generated sources + NitroModules dep +
+  # the C++/Swift-interop build flags — same setup as the working
+  # NitroMLKitFaceDetection podspec).
+  load 'nitrogen/generated/ios/NitroMLKitPose+autolinking.rb'
+  add_nitrogen_files(s)
+end

package/README.md

@@ -0,0 +1,57 @@
+# React Native ML Kit — Pose Detection
+
+**`@nitro-mlkit/pose-detection`** · on-device Google ML Kit via [Nitro Modules](https://github.com/mrousavy/nitro) — JSI, no bridge.
+
+> ⚠️ **Beta (`0.1.0-beta.x`).** Android verified on-device; iOS builds & links but
+> device runtime is pending — see [Platform status](#platform-status).
+
+High-performance, on-device **pose detection** for React Native, built with
+[Nitro Modules](https://github.com/mrousavy/nitro) (JSI, no bridge).
+
+Powered by **Google ML Kit**. Returns the **33 skeletal landmarks** of the
+primary body — each with a 3D position and an in-frame likelihood. **On-device.**
+
+## Installation
+
+```bash
+npm install @nitro-mlkit/pose-detection@beta react-native-nitro-modules
+```
+
+No config plugin (autolinked Expo module). Just install and `npx expo prebuild`.
+Not available in Expo Go.
+
+## Usage
+
+```ts
+import { NitroPose } from "@nitro-mlkit/pose-detection";
+
+const landmarks = await NitroPose.detect(imageUri);
+// → [{ type, x, y, z, inFrameLikelihood }, ...]  (33 landmarks, or [] if no body)
+// type is the ML Kit landmark index (0 = nose, 11/12 = shoulders, 23/24 = hips, …)
+
+// Native batch — one JSI call
+const results = await NitroPose.detectBatch(uris, 4 /* concurrency */);
+
+NitroPose.isAvailable(); // boolean
+```
+
+Runs in SINGLE_IMAGE_MODE. All 33 landmarks are returned whenever a body is
+found; joints outside the frame come back with a low `inFrameLikelihood`.
+
+## Platform status
+
+| Platform | Min | Status |
+| -------- | --- | ------ |
+| Android  | API 21+ | ✅ Verified on-device (Pixel 9, API 36): 33 landmarks in ~430 ms (nose 96%, shoulders ~73%, out-of-frame hips 0%) |
+| iOS      | 15.5+   | ⚠️ Swift impl written; on-device build & run pending¹ |
+| tvOS/macOS | — | 🔜 Planned |
+
+¹ ML Kit's iOS pods ship no `arm64` Simulator slice; validate on a physical device.
+
+## Part of `nitro-mlkit`
+
+The full ML Kit suite on Nitro — see the other `@nitro-mlkit/*` packages.
+
+## License
+
+MIT © Gonzalo Polo

package/android/CMakeLists.txt

@@ -0,0 +1,12 @@
+project(NitroMLKitPose)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(NitroMLKitPose SHARED
+  src/main/cpp/cpp-adapter.cpp
+)
+
+# Add all files generated by Nitrogen
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroMLKitPose+autolinking.cmake)

package/android/build.gradle

@@ -0,0 +1,77 @@
+buildscript {
+    ext.safeExtGet = { prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+}
+
+def reactNativeArchitectures() {
+    def value = rootProject.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+android {
+    namespace "com.nitromlkit.pose"
+    compileSdkVersion safeExtGet("compileSdkVersion", 35)
+    ndkVersion safeExtGet("ndkVersion", "27.1.12297006")
+
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 26)
+        targetSdkVersion safeExtGet("targetSdkVersion", 35)
+
+        externalNativeBuild {
+            cmake {
+                arguments "-DANDROID_STL=c++_shared"
+                abiFilters (*reactNativeArchitectures())
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
+    }
+
+    buildFeatures {
+        prefab true
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs += [
+                "src/main/kotlin",
+                "../nitrogen/generated/android/kotlin"
+            ]
+        }
+    }
+}
+
+dependencies {
+    // MLKit
+    implementation "com.google.mlkit:pose-detection:18.0.0-beta5"
+
+    // Nitro Modules
+    implementation project(":react-native-nitro-modules")
+
+    // Expo Modules (only used so autolinking calls our OnLoad at startup)
+    implementation project(":expo-modules-core")
+
+    // Kotlin coroutines
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.9.0"
+
+    // React Native
+    implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.nitromlkit.pose">
+</manifest>

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

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

package/android/src/main/kotlin/com/margelo/nitro/nitromlkit/pose/HybridPoseDetector.kt

@@ -0,0 +1,93 @@
+package com.margelo.nitro.nitromlkit.pose
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.pose.PoseDetection
+import com.google.mlkit.vision.pose.defaults.PoseDetectorOptions
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.tasks.await
+import java.net.URL
+import com.google.mlkit.vision.pose.PoseLandmark as MlkitLandmark
+
+/**
+ * Native Android implementation of PoseDetector (MLKit pose detection).
+ * Returns the 33 skeletal landmarks of the primary body in SINGLE_IMAGE_MODE.
+ */
+class HybridPoseDetector : HybridPoseDetectorSpec() {
+
+  private val detector by lazy {
+    PoseDetection.getClient(
+      PoseDetectorOptions.Builder()
+        .setDetectorMode(PoseDetectorOptions.SINGLE_IMAGE_MODE)
+        .build()
+    )
+  }
+
+  override fun detect(imageUri: String): Promise<Array<PoseLandmark>> {
+    return Promise.async { detectImage(imageUri) }
+  }
+
+  override fun detectBatch(imageUris: Array<String>, concurrency: Double): Promise<Array<BatchPoseResult>> {
+    return Promise.async {
+      val maxConcurrent = concurrency.toInt().coerceAtLeast(1)
+      val results = mutableListOf<BatchPoseResult>()
+      var start = 0
+      while (start < imageUris.size) {
+        val end = minOf(start + maxConcurrent, imageUris.size)
+        val chunk = coroutineScope {
+          (start until end).map { idx ->
+            async {
+              try {
+                BatchPoseResult(idx.toDouble(), detectImage(imageUris[idx]), true, null)
+              } catch (e: Exception) {
+                BatchPoseResult(idx.toDouble(), emptyArray(), false, e.message ?: "unknown error")
+              }
+            }
+          }.awaitAll()
+        }
+        results.addAll(chunk)
+        start = end
+      }
+      results.toTypedArray()
+    }
+  }
+
+  override fun isAvailable(): Boolean = true
+
+  private suspend fun detectImage(uri: String): Array<PoseLandmark> {
+    val bitmap = loadBitmap(uri) ?: throw Error("Failed to load image: $uri")
+    val image = InputImage.fromBitmap(bitmap, 0)
+    val pose = detector.process(image).await()
+    return pose.allPoseLandmarks.map { lm ->
+      PoseLandmark(
+        type = lm.landmarkType.toDouble(),
+        x = lm.position3D.x.toDouble(),
+        y = lm.position3D.y.toDouble(),
+        z = lm.position3D.z.toDouble(),
+        inFrameLikelihood = lm.inFrameLikelihood.toDouble(),
+      )
+    }.toTypedArray()
+  }
+
+  private fun loadBitmap(uri: String): Bitmap? {
+    return try {
+      when {
+        uri.startsWith("file://") -> BitmapFactory.decodeFile(uri.removePrefix("file://"))
+        uri.startsWith("/") -> BitmapFactory.decodeFile(uri)
+        uri.startsWith("content://") -> {
+          val context = NitroModules.applicationContext ?: return null
+          context.contentResolver.openInputStream(Uri.parse(uri))?.use { BitmapFactory.decodeStream(it) }
+        }
+        else -> URL(uri).openStream().use { BitmapFactory.decodeStream(it) }
+      }
+    } catch (e: Exception) {
+      null
+    }
+  }
+}

package/android/src/main/kotlin/com/nitromlkit/pose/NitroMLKitPosePackage.kt

@@ -0,0 +1,19 @@
+package com.nitromlkit.pose
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import com.margelo.nitro.nitromlkit.pose.NitroMLKitPoseOnLoad
+
+/**
+ * Loads the native library and registers the PoseDetector HybridObject at startup via
+ * Expo autolinking. Exposes no JS API of its own.
+ */
+class NitroMLKitPosePackage : Module() {
+  init {
+    NitroMLKitPoseOnLoad.initializeNative()
+  }
+
+  override fun definition() = ModuleDefinition {
+    Name("NitroMLKitPose")
+  }
+}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modules": []
+  },
+  "android": {
+    "modules": ["com.nitromlkit.pose.NitroMLKitPosePackage"]
+  }
+}

package/ios/HybridPoseDetector.swift

@@ -0,0 +1,146 @@
+import Foundation
+import UIKit
+import NitroModules
+import MLKitPoseDetection
+import MLKitPoseDetectionCommon
+import MLKitVision
+
+/**
+ * Native iOS implementation of PoseDetector (MLKit pose detection).
+ * Returns the 33 skeletal landmarks of the primary detected body (SINGLE_IMAGE mode).
+ * Conforms to the Nitrogen-generated HybridPoseDetectorSpec protocol.
+ */
+class HybridPoseDetector: HybridPoseDetectorSpec {
+
+    // MARK: - HybridObject boilerplate
+    var memorySize: Int { MemoryLayout<HybridPoseDetector>.size }
+
+    // MARK: - Lazy MLKit detector
+
+    private lazy var detector: PoseDetector = {
+        let opts = PoseDetectorOptions()
+        opts.detectorMode = .singleImage
+        return PoseDetector.poseDetector(options: opts)
+    }()
+
+    /// Maps each iOS `PoseLandmarkType` to the integer index the Kotlin/JS side expects.
+    /// This mirrors the Android ML Kit `PoseLandmark.landmarkType` int constants (0..32,
+    /// the standard BlazePose ordering). iOS ships string-based landmark types, so we map
+    /// them back to the same ordinal.
+    private static let landmarkIndexMap: [PoseLandmarkType: Int] = [
+        .nose: 0,
+        .leftEyeInner: 1,
+        .leftEye: 2,
+        .leftEyeOuter: 3,
+        .rightEyeInner: 4,
+        .rightEye: 5,
+        .rightEyeOuter: 6,
+        .leftEar: 7,
+        .rightEar: 8,
+        .mouthLeft: 9,
+        .mouthRight: 10,
+        .leftShoulder: 11,
+        .rightShoulder: 12,
+        .leftElbow: 13,
+        .rightElbow: 14,
+        .leftWrist: 15,
+        .rightWrist: 16,
+        .leftPinkyFinger: 17,
+        .rightPinkyFinger: 18,
+        .leftIndexFinger: 19,
+        .rightIndexFinger: 20,
+        .leftThumb: 21,
+        .rightThumb: 22,
+        .leftHip: 23,
+        .rightHip: 24,
+        .leftKnee: 25,
+        .rightKnee: 26,
+        .leftAnkle: 27,
+        .rightAnkle: 28,
+        .leftHeel: 29,
+        .rightHeel: 30,
+        .leftToe: 31,
+        .rightToe: 32,
+    ]
+
+    // MARK: - Protocol methods
+
+    func detect(imageUri: String) throws -> Promise<[PoseLandmark]> {
+        return Promise.async {
+            return try await self.detectImage(imageUri)
+        }
+    }
+
+    func detectBatch(imageUris: [String], concurrency: Double) throws -> Promise<[BatchPoseResult]> {
+        return Promise.async {
+            let maxConcurrent = max(1, Int(concurrency))
+            var results = [BatchPoseResult]()
+            results.reserveCapacity(imageUris.count)
+
+            for chunkStart in stride(from: 0, to: imageUris.count, by: maxConcurrent) {
+                let chunkEnd = min(chunkStart + maxConcurrent, imageUris.count)
+                let chunk = Array(imageUris[chunkStart..<chunkEnd])
+
+                let chunkResults = await withTaskGroup(of: (Int, BatchPoseResult).self) { group in
+                    for (i, uri) in chunk.enumerated() {
+                        let globalIdx = chunkStart + i
+                        group.addTask {
+                            do {
+                                let landmarks = try await self.detectImage(uri)
+                                return (globalIdx, BatchPoseResult(index: Double(globalIdx), landmarks: landmarks, success: true, error: nil))
+                            } catch {
+                                return (globalIdx, BatchPoseResult(index: Double(globalIdx), landmarks: [], success: false, error: error.localizedDescription))
+                            }
+                        }
+                    }
+
+                    var out = [(Int, BatchPoseResult)]()
+                    for await result in group { out.append(result) }
+                    return out.sorted(by: { $0.0 < $1.0 }).map(\.1)
+                }
+                results.append(contentsOf: chunkResults)
+            }
+            return results
+        }
+    }
+
+    func isAvailable() throws -> Bool {
+        return true
+    }
+
+    // MARK: - Private helpers
+
+    private func detectImage(_ uri: String) async throws -> [PoseLandmark] {
+        guard let image = self.loadImage(from: uri) else {
+            throw RuntimeError.error(withMessage: "Failed to load image: \(uri)")
+        }
+        let visionImage = VisionImage(image: image)
+        visionImage.orientation = image.imageOrientation
+
+        let poses = try await detector.process(visionImage)
+        guard let pose = poses.first else { return [] }
+
+        return pose.landmarks.map { lm in
+            PoseLandmark(
+                type: Double(HybridPoseDetector.landmarkIndexMap[lm.type] ?? -1),
+                x: Double(lm.position.x),
+                y: Double(lm.position.y),
+                z: Double(lm.position.z),
+                inFrameLikelihood: Double(lm.inFrameLikelihood)
+            )
+        }
+    }
+
+    private func loadImage(from uri: String) -> UIImage? {
+        let path: String
+        if uri.hasPrefix("file://") {
+            path = String(uri.dropFirst(7))
+        } else if uri.hasPrefix("/") {
+            path = uri
+        } else {
+            guard let url = URL(string: uri), let data = try? Data(contentsOf: url) else { return nil }
+            return UIImage(data: data)
+        }
+        return UIImage(contentsOfFile: path)
+    }
+}

package/nitro.json

@@ -0,0 +1,16 @@
+{
+  "cxxNamespace": ["mlkit", "pose"],
+  "ios": {
+    "iosModuleName": "NitroMLKitPose"
+  },
+  "android": {
+    "androidNamespace": ["nitromlkit", "pose"],
+    "androidCxxLibName": "NitroMLKitPose"
+  },
+  "autolinking": {
+    "PoseDetector": {
+      "ios": { "language": "swift", "implementationClassName": "HybridPoseDetector" },
+      "android": { "language": "kotlin", "implementationClassName": "HybridPoseDetector" }
+    }
+  }
+}

package/nitrogen/generated/.gitattributes

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

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

@@ -0,0 +1,81 @@
+#
+# NitroMLKitPose+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/NitroMLKitPose+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NITROMLKITPOSE_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)
+  NitroMLKitPose PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NitroMLKitPoseOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridPoseDetectorSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridPoseDetectorSpec.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(
+  NitroMLKitPose 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(
+        NitroMLKitPose
+        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(
+        NitroMLKitPose
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NitroMLKitPose
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/NitroMLKitPose+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// NitroMLKitPose+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/NitroMLKitPose+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NitroMLKitPose is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/NitroMLKitPoseOnLoad.cpp

@@ -0,0 +1,54 @@
+///
+/// NitroMLKitPoseOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_NITROMLKITPOSE_WITH_GENERATED_CMAKE_PROJECT
+#error NitroMLKitPoseOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "NitroMLKitPoseOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridPoseDetectorSpec.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::mlkit::pose {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::mlkit::pose::registerAllNatives();
+  });
+}
+
+struct JHybridPoseDetectorSpecImpl: public jni::JavaClass<JHybridPoseDetectorSpecImpl, JHybridPoseDetectorSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitromlkit/pose/HybridPoseDetector;";
+  static std::shared_ptr<JHybridPoseDetectorSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridPoseDetectorSpecImpl::javaobject()>();
+    jni::local_ref<JHybridPoseDetectorSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridPoseDetectorSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::mlkit::pose;
+
+  // Register native JNI methods
+  margelo::nitro::mlkit::pose::JHybridPoseDetectorSpec::CxxPart::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "PoseDetector",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridPoseDetectorSpecImpl::create();
+    }
+  );
+}
+
+} // namespace margelo::nitro::mlkit::pose