@nitro-mlkit/object-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/NitroMLKitObjects.podspec

@@ -0,0 +1,34 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroMLKitObjects"
+  # Must match nitro.json's `ios.iosModuleName` — Nitrogen's generated bridge
+  # imports "NitroMLKitObjects-Swift.h", so the compiled Swift module name has to be NitroMLKitObjects.
+  s.module_name  = "NitroMLKitObjects"
+  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/ObjectDetection", "~> 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/NitroMLKitObjects+autolinking.rb'
+  add_nitrogen_files(s)
+end

package/README.md

@@ -0,0 +1,57 @@
+# React Native ML Kit — Object Detection
+
+**`@nitro-mlkit/object-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 **object detection & tracking** for React Native,
+built with [Nitro Modules](https://github.com/mrousavy/nitro) (JSI, no bridge).
+
+Powered by **Google ML Kit**. Detects prominent objects in an image with
+bounding boxes and coarse category labels. **All on-device.**
+
+## Installation
+
+```bash
+npm install @nitro-mlkit/object-detection@beta react-native-nitro-modules
+```
+
+No config plugin (it's an autolinked Expo module). Just install and
+`npx expo prebuild`. Not available in Expo Go.
+
+## Usage
+
+```ts
+import { NitroObjects } from "@nitro-mlkit/object-detection";
+
+const objects = await NitroObjects.detect(imageUri);
+// → [{ bounds:{x,y,width,height}, trackingId, labels:[{text,confidence,index}] }]
+
+// Native batch — one JSI call
+const results = await NitroObjects.detectBatch(uris, 4 /* concurrency */);
+
+NitroObjects.isAvailable(); // boolean
+```
+
+Uses SINGLE_IMAGE_MODE with multiple objects + coarse classification. ML Kit's
+default classifier covers broad categories (Fashion good, Home good, Food,
+Place, Plant); it targets prominent *objects*, not faces/people.
+
+## Platform status
+
+| Platform | Min | Status |
+| -------- | --- | ------ |
+| Android  | API 21+ | ✅ Verified on-device (Pixel 9, API 36): `detect` runs in ~200 ms |
+| 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(NitroMLKitObjects)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(NitroMLKitObjects SHARED
+  src/main/cpp/cpp-adapter.cpp
+)
+
+# Add all files generated by Nitrogen
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroMLKitObjects+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.objects"
+    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:object-detection:17.0.2"
+
+    // 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.objects">
+</manifest>

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

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

package/android/src/main/kotlin/com/margelo/nitro/nitromlkit/objects/HybridObjectDetector.kt

@@ -0,0 +1,102 @@
+package com.margelo.nitro.nitromlkit.objects
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.objects.ObjectDetection
+import com.google.mlkit.vision.objects.defaults.ObjectDetectorOptions
+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.objects.DetectedObject as MlkitObject
+
+/**
+ * Native Android implementation of ObjectDetector (MLKit object detection).
+ * SINGLE_IMAGE_MODE with multiple objects + coarse classification.
+ */
+class HybridObjectDetector : HybridObjectDetectorSpec() {
+
+  private val detector by lazy {
+    ObjectDetection.getClient(
+      ObjectDetectorOptions.Builder()
+        .setDetectorMode(ObjectDetectorOptions.SINGLE_IMAGE_MODE)
+        .enableMultipleObjects()
+        .enableClassification()
+        .build()
+    )
+  }
+
+  override fun detect(imageUri: String): Promise<Array<DetectedObject>> {
+    return Promise.async { detectImage(imageUri) }
+  }
+
+  override fun detectBatch(imageUris: Array<String>, concurrency: Double): Promise<Array<BatchObjectResult>> {
+    return Promise.async {
+      val maxConcurrent = concurrency.toInt().coerceAtLeast(1)
+      val results = mutableListOf<BatchObjectResult>()
+      var start = 0
+      while (start < imageUris.size) {
+        val end = minOf(start + maxConcurrent, imageUris.size)
+        val chunk = coroutineScope {
+          (start until end).map { idx ->
+            async {
+              try {
+                BatchObjectResult(idx.toDouble(), detectImage(imageUris[idx]), true, null)
+              } catch (e: Exception) {
+                BatchObjectResult(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<DetectedObject> {
+    val bitmap = loadBitmap(uri) ?: throw Error("Failed to load image: $uri")
+    val image = InputImage.fromBitmap(bitmap, 0)
+    val objects = detector.process(image).await()
+    return objects.map { mapObject(it) }.toTypedArray()
+  }
+
+  private fun mapObject(o: MlkitObject): DetectedObject {
+    val box = o.boundingBox
+    val labels = o.labels.map { ObjectLabel(it.text, it.confidence.toDouble(), it.index.toDouble()) }.toTypedArray()
+    return DetectedObject(
+      bounds = ObjectRect(
+        x = box.left.toDouble(),
+        y = box.top.toDouble(),
+        width = box.width().toDouble(),
+        height = box.height().toDouble(),
+      ),
+      trackingId = (o.trackingId ?: -1).toDouble(),
+      labels = labels,
+    )
+  }
+
+  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/objects/NitroMLKitObjectsPackage.kt

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

package/expo-module.config.json

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

package/ios/HybridObjectDetector.swift

@@ -0,0 +1,125 @@
+import Foundation
+import UIKit
+import NitroModules
+import MLKitObjectDetection
+import MLKitObjectDetectionCommon
+import MLKitVision
+
+/**
+ * Native iOS implementation of ObjectDetector (MLKit object detection).
+ * Conforms to the Nitrogen-generated HybridObjectDetectorSpec protocol.
+ * SINGLE_IMAGE mode with multiple objects + coarse classification.
+ */
+class HybridObjectDetector: HybridObjectDetectorSpec {
+
+    // MARK: - HybridObject boilerplate
+    var memorySize: Int { MemoryLayout<HybridObjectDetector>.size }
+
+    // MARK: - Lazy MLKit detector
+
+    private lazy var detector: ObjectDetector = {
+        let opts = ObjectDetectorOptions()
+        opts.detectorMode = .singleImage
+        opts.shouldEnableClassification = true
+        opts.shouldEnableMultipleObjects = true
+        return ObjectDetector.objectDetector(options: opts)
+    }()
+
+    // MARK: - Protocol methods
+
+    func detect(imageUri: String) throws -> Promise<[DetectedObject]> {
+        return Promise.async {
+            return try await self.detectImage(imageUri)
+        }
+    }
+
+    func detectBatch(imageUris: [String], concurrency: Double) throws -> Promise<[BatchObjectResult]> {
+        return Promise.async {
+            let maxConcurrent = max(1, Int(concurrency))
+            var results = [BatchObjectResult]()
+            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, BatchObjectResult).self) { group in
+                    for (i, uri) in chunk.enumerated() {
+                        let globalIdx = chunkStart + i
+                        group.addTask {
+                            do {
+                                let objects = try await self.detectImage(uri)
+                                return (globalIdx, BatchObjectResult(index: Double(globalIdx), objects: objects, success: true, error: nil))
+                            } catch {
+                                return (globalIdx, BatchObjectResult(index: Double(globalIdx), objects: [], success: false, error: error.localizedDescription))
+                            }
+                        }
+                    }
+
+                    var out = [(Int, BatchObjectResult)]()
+                    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 -> [DetectedObject] {
+        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 mlObjects = try await detector.process(visionImage)
+        return mlObjects.map { self.mapObject($0) }
+    }
+
+    private func mapObject(_ obj: Object) -> DetectedObject {
+        let frame = obj.frame
+        // `obj.labels` are MLKit ObjectLabel values; the unqualified `ObjectLabel`
+        // initializer below resolves to the Nitrogen-generated struct (same module).
+        var labels = [ObjectLabel]()
+        for label in obj.labels {
+            labels.append(ObjectLabel(
+                text: label.text,
+                confidence: Double(label.confidence),
+                index: Double(label.index)
+            ))
+        }
+
+        let trackingId = obj.trackingID?.doubleValue ?? -1
+
+        return DetectedObject(
+            bounds: ObjectRect(
+                x: Double(frame.origin.x),
+                y: Double(frame.origin.y),
+                width: Double(frame.width),
+                height: Double(frame.height)
+            ),
+            trackingId: trackingId,
+            labels: labels
+        )
+    }
+
+    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", "objects"],
+  "ios": {
+    "iosModuleName": "NitroMLKitObjects"
+  },
+  "android": {
+    "androidNamespace": ["nitromlkit", "objects"],
+    "androidCxxLibName": "NitroMLKitObjects"
+  },
+  "autolinking": {
+    "ObjectDetector": {
+      "ios": { "language": "swift", "implementationClassName": "HybridObjectDetector" },
+      "android": { "language": "kotlin", "implementationClassName": "HybridObjectDetector" }
+    }
+  }
+}

package/nitrogen/generated/.gitattributes

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

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

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

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

@@ -0,0 +1,27 @@
+///
+/// NitroMLKitObjects+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/NitroMLKitObjects+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NitroMLKitObjects is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/NitroMLKitObjectsOnLoad.cpp

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