react-native-ble-nitro 1.0.0-beta.8 → 1.0.0

package/lib/specs/NativeBleNitro.nitro.d.ts

@@ -0,0 +1,68 @@
+import { HybridObject } from 'react-native-nitro-modules';
+export declare enum BLEState {
+    Unknown = 0,
+    Resetting = 1,
+    Unsupported = 2,
+    Unauthorized = 3,
+    PoweredOff = 4,
+    PoweredOn = 5
+}
+export interface ManufacturerDataEntry {
+    id: string;
+    data: number[];
+}
+export interface ManufacturerData {
+    companyIdentifiers: ManufacturerDataEntry[];
+}
+export interface BLEDevice {
+    id: string;
+    name: string;
+    rssi: number;
+    manufacturerData: ManufacturerData;
+    serviceUUIDs: string[];
+    isConnectable: boolean;
+}
+export interface ScanFilter {
+    serviceUUIDs: string[];
+    rssiThreshold: number;
+    allowDuplicates: boolean;
+}
+export type ScanCallback = (device: BLEDevice) => void;
+export type DevicesCallback = (devices: BLEDevice[]) => void;
+export type ConnectionCallback = (success: boolean, deviceId: string, error: string) => void;
+export type DisconnectionEventCallback = (deviceId: string, interrupted: boolean, error: string) => void;
+export type OperationCallback = (success: boolean, error: string) => void;
+export type CharacteristicCallback = (characteristicId: string, data: number[]) => void;
+export type StateCallback = (state: BLEState) => void;
+export type BooleanCallback = (result: boolean) => void;
+export type StringArrayCallback = (result: string[]) => void;
+export type ReadCharacteristicCallback = (success: boolean, data: number[], error: string) => void;
+/**
+ * Native BLE Nitro Module Specification
+ * Defines the interface between TypeScript and native implementations
+ */
+export interface NativeBleNitro extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    startScan(filter: ScanFilter, callback: ScanCallback): void;
+    stopScan(callback: OperationCallback): void;
+    isScanning(callback: BooleanCallback): void;
+    getConnectedDevices(callback: DevicesCallback): void;
+    connect(deviceId: string, callback: ConnectionCallback, disconnectCallback?: DisconnectionEventCallback): void;
+    disconnect(deviceId: string, callback: OperationCallback): void;
+    isConnected(deviceId: string, callback: BooleanCallback): void;
+    discoverServices(deviceId: string, callback: OperationCallback): void;
+    getServices(deviceId: string, callback: StringArrayCallback): void;
+    getCharacteristics(deviceId: string, serviceId: string, callback: StringArrayCallback): void;
+    readCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: ReadCharacteristicCallback): void;
+    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: number[], withResponse: boolean, callback: OperationCallback): void;
+    subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, updateCallback: CharacteristicCallback, resultCallback: OperationCallback): void;
+    unsubscribeFromCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: OperationCallback): void;
+    isBluetoothEnabled(callback: BooleanCallback): void;
+    requestBluetoothEnable(callback: OperationCallback): void;
+    state(callback: StateCallback): void;
+    subscribeToStateChange(stateCallback: StateCallback, resultCallback: OperationCallback): void;
+    unsubscribeFromStateChange(resultCallback: OperationCallback): void;
+    openSettings(): Promise<void>;
+}

package/lib/specs/NativeBleNitro.nitro.js

@@ -0,0 +1,10 @@
+// Nitro constraint: Use numeric enums instead of string unions
+export var BLEState;
+(function (BLEState) {
+    BLEState[BLEState["Unknown"] = 0] = "Unknown";
+    BLEState[BLEState["Resetting"] = 1] = "Resetting";
+    BLEState[BLEState["Unsupported"] = 2] = "Unsupported";
+    BLEState[BLEState["Unauthorized"] = 3] = "Unauthorized";
+    BLEState[BLEState["PoweredOff"] = 4] = "PoweredOff";
+    BLEState[BLEState["PoweredOn"] = 5] = "PoweredOn";
+})(BLEState || (BLEState = {}));

package/nitro.json

@@ -9,7 +9,7 @@
     "androidCxxLibName": "BleNitro"
   },
   "autolinking": {
-    "BleManager": {
+    "NativeBleNitro": {
       "swift": "BleNitroBleManager",
       "kotlin": "BleNitroBleManager"
     }

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

@@ -27,17 +27,9 @@ target_sources(
   # Autolinking Setup
   ../nitrogen/generated/android/BleNitroOnLoad.cpp
   # Shared Nitrogen C++ sources
-  ../nitrogen/generated/shared/c++/HybridBleManagerSpec.cpp
-  ../nitrogen/generated/shared/c++/HybridCharacteristicSpec.cpp
-  ../nitrogen/generated/shared/c++/HybridDescriptorSpec.cpp
-  ../nitrogen/generated/shared/c++/HybridDeviceSpec.cpp
-  ../nitrogen/generated/shared/c++/HybridServiceSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.cpp
   # Android-specific Nitrogen C++ sources
-  ../nitrogen/generated/android/c++/JHybridBleManagerSpec.cpp
-  ../nitrogen/generated/android/c++/JHybridCharacteristicSpec.cpp
-  ../nitrogen/generated/android/c++/JHybridDescriptorSpec.cpp
-  ../nitrogen/generated/android/c++/JHybridDeviceSpec.cpp
-  ../nitrogen/generated/android/c++/JHybridServiceSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridNativeBleNitroSpec.cpp
 )
 
 # Define a flag to check if we are building properly

package/nitrogen/generated/android/BleNitroOnLoad.cpp

@@ -15,16 +15,17 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
-#include "JHybridBleManagerSpec.hpp"
-#include "JFunc_void.hpp"
-#include "JFunc_void_State.hpp"
-#include "JFunc_void_std__optional_NativeBleError__std__optional_NativeDevice_.hpp"
-#include "JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_.hpp"
-#include "JHybridCharacteristicSpec.hpp"
-#include "JHybridDescriptorSpec.hpp"
-#include "JHybridDeviceSpec.hpp"
-#include "JHybridServiceSpec.hpp"
-#include <NitroModules/JNISharedPtr.hpp>
+#include "JHybridNativeBleNitroSpec.hpp"
+#include "JFunc_void_BLEDevice.hpp"
+#include "JFunc_void_bool_std__string.hpp"
+#include "JFunc_void_bool.hpp"
+#include "JFunc_void_std__vector_BLEDevice_.hpp"
+#include "JFunc_void_bool_std__string_std__string.hpp"
+#include "JFunc_void_std__string_bool_std__string.hpp"
+#include "JFunc_void_std__vector_std__string_.hpp"
+#include "JFunc_void_bool_std__vector_double__std__string.hpp"
+#include "JFunc_void_std__string_std__vector_double_.hpp"
+#include "JFunc_void_BLEState.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::co::zyke::ble {
@@ -36,24 +37,26 @@ int initialize(JavaVM* vm) {
 
   return facebook::jni::initialize(vm, [] {
     // Register native JNI methods
-    margelo::nitro::co::zyke::ble::JHybridBleManagerSpec::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_State_cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_std__optional_NativeBleError__std__optional_NativeDevice__cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JHybridCharacteristicSpec::registerNatives();
-    margelo::nitro::co::zyke::ble::JHybridDescriptorSpec::registerNatives();
-    margelo::nitro::co::zyke::ble::JHybridDeviceSpec::registerNatives();
-    margelo::nitro::co::zyke::ble::JHybridServiceSpec::registerNatives();
+    margelo::nitro::co::zyke::ble::JHybridNativeBleNitroSpec::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_BLEDevice_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_bool_std__string_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_bool_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_std__vector_BLEDevice__cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_bool_std__string_std__string_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_std__string_bool_std__string_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_std__vector_std__string__cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_bool_std__vector_double__std__string_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_std__string_std__vector_double__cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_BLEState_cxx::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(
-      "BleManager",
+      "NativeBleNitro",
       []() -> std::shared_ptr<HybridObject> {
-        static DefaultConstructableObject<JHybridBleManagerSpec::javaobject> object("com/margelo/nitro/co/zyke/ble/BleNitroBleManager");
+        static DefaultConstructableObject<JHybridNativeBleNitroSpec::javaobject> object("com/margelo/nitro/co/zyke/ble/BleNitroBleManager");
         auto instance = object.create();
         auto globalRef = jni::make_global(instance);
-        return JNISharedPtr::make_shared_from_jni<JHybridBleManagerSpec>(globalRef);
+        return globalRef->cthis()->shared();
       }
     );
   });

package/nitrogen/generated/android/c++/JBLEDevice.hpp

@@ -0,0 +1,95 @@
+///
+/// JBLEDevice.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "BLEDevice.hpp"
+
+#include "JManufacturerData.hpp"
+#include "JManufacturerDataEntry.hpp"
+#include "ManufacturerData.hpp"
+#include "ManufacturerDataEntry.hpp"
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BLEDevice" and the the Kotlin data class "BLEDevice".
+   */
+  struct JBLEDevice final: public jni::JavaClass<JBLEDevice> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/BLEDevice;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BLEDevice by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BLEDevice toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldRssi = clazz->getField<double>("rssi");
+      double rssi = this->getFieldValue(fieldRssi);
+      static const auto fieldManufacturerData = clazz->getField<JManufacturerData>("manufacturerData");
+      jni::local_ref<JManufacturerData> manufacturerData = this->getFieldValue(fieldManufacturerData);
+      static const auto fieldServiceUUIDs = clazz->getField<jni::JArrayClass<jni::JString>>("serviceUUIDs");
+      jni::local_ref<jni::JArrayClass<jni::JString>> serviceUUIDs = this->getFieldValue(fieldServiceUUIDs);
+      static const auto fieldIsConnectable = clazz->getField<jboolean>("isConnectable");
+      jboolean isConnectable = this->getFieldValue(fieldIsConnectable);
+      return BLEDevice(
+        id->toStdString(),
+        name->toStdString(),
+        rssi,
+        manufacturerData->toCpp(),
+        [&]() {
+          size_t __size = serviceUUIDs->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = serviceUUIDs->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }(),
+        static_cast<bool>(isConnectable)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JBLEDevice::javaobject> fromCpp(const BLEDevice& value) {
+      return newInstance(
+        jni::make_jstring(value.id),
+        jni::make_jstring(value.name),
+        value.rssi,
+        JManufacturerData::fromCpp(value.manufacturerData),
+        [&]() {
+          size_t __size = value.serviceUUIDs.size();
+          jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.serviceUUIDs[__i];
+            __array->setElement(__i, *jni::make_jstring(__element));
+          }
+          return __array;
+        }(),
+        value.isConnectable
+      );
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/{JState.hpp → JBLEState.hpp}

@@ -1,5 +1,5 @@
 ///
-/// JState.hpp
+/// JBLEState.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -8,30 +8,30 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
-#include "State.hpp"
+#include "BLEState.hpp"
 
 namespace margelo::nitro::co::zyke::ble {
 
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ enum "State" and the the Kotlin enum "State".
+   * The C++ JNI bridge between the C++ enum "BLEState" and the the Kotlin enum "BLEState".
    */
-  struct JState final: public jni::JavaClass<JState> {
+  struct JBLEState final: public jni::JavaClass<JBLEState> {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/State;";
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/BLEState;";
 
   public:
     /**
-     * Convert this Java/Kotlin-based enum to the C++ enum State.
+     * Convert this Java/Kotlin-based enum to the C++ enum BLEState.
      */
     [[maybe_unused]]
     [[nodiscard]]
-    State toCpp() const {
+    BLEState toCpp() const {
       static const auto clazz = javaClassStatic();
-      static const auto fieldOrdinal = clazz->getField<int>("_ordinal");
+      static const auto fieldOrdinal = clazz->getField<int>("value");
       int ordinal = this->getFieldValue(fieldOrdinal);
-      return static_cast<State>(ordinal);
+      return static_cast<BLEState>(ordinal);
     }
 
   public:
@@ -39,27 +39,27 @@ namespace margelo::nitro::co::zyke::ble {
      * Create a Java/Kotlin-based enum with the given C++ enum's value.
      */
     [[maybe_unused]]
-    static jni::alias_ref<JState> fromCpp(State value) {
+    static jni::alias_ref<JBLEState> fromCpp(BLEState value) {
       static const auto clazz = javaClassStatic();
-      static const auto fieldUNKNOWN = clazz->getStaticField<JState>("UNKNOWN");
-      static const auto fieldRESETTING = clazz->getStaticField<JState>("RESETTING");
-      static const auto fieldUNSUPPORTED = clazz->getStaticField<JState>("UNSUPPORTED");
-      static const auto fieldUNAUTHORIZED = clazz->getStaticField<JState>("UNAUTHORIZED");
-      static const auto fieldPOWEREDOFF = clazz->getStaticField<JState>("POWEREDOFF");
-      static const auto fieldPOWEREDON = clazz->getStaticField<JState>("POWEREDON");
+      static const auto fieldUNKNOWN = clazz->getStaticField<JBLEState>("UNKNOWN");
+      static const auto fieldRESETTING = clazz->getStaticField<JBLEState>("RESETTING");
+      static const auto fieldUNSUPPORTED = clazz->getStaticField<JBLEState>("UNSUPPORTED");
+      static const auto fieldUNAUTHORIZED = clazz->getStaticField<JBLEState>("UNAUTHORIZED");
+      static const auto fieldPOWEREDOFF = clazz->getStaticField<JBLEState>("POWEREDOFF");
+      static const auto fieldPOWEREDON = clazz->getStaticField<JBLEState>("POWEREDON");
       
       switch (value) {
-        case State::UNKNOWN:
+        case BLEState::UNKNOWN:
           return clazz->getStaticFieldValue(fieldUNKNOWN);
-        case State::RESETTING:
+        case BLEState::RESETTING:
           return clazz->getStaticFieldValue(fieldRESETTING);
-        case State::UNSUPPORTED:
+        case BLEState::UNSUPPORTED:
           return clazz->getStaticFieldValue(fieldUNSUPPORTED);
-        case State::UNAUTHORIZED:
+        case BLEState::UNAUTHORIZED:
           return clazz->getStaticFieldValue(fieldUNAUTHORIZED);
-        case State::POWEREDOFF:
+        case BLEState::POWEREDOFF:
           return clazz->getStaticFieldValue(fieldPOWEREDOFF);
-        case State::POWEREDON:
+        case BLEState::POWEREDON:
           return clazz->getStaticFieldValue(fieldPOWEREDON);
         default:
           std::string stringValue = std::to_string(static_cast<int>(value));

package/nitrogen/generated/android/c++/JFunc_void_BLEDevice.hpp

@@ -0,0 +1,82 @@
+///
+/// JFunc_void_BLEDevice.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "BLEDevice.hpp"
+#include <functional>
+#include "JBLEDevice.hpp"
+#include <string>
+#include "ManufacturerData.hpp"
+#include "JManufacturerData.hpp"
+#include "ManufacturerDataEntry.hpp"
+#include <vector>
+#include "JManufacturerDataEntry.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(device: BLEDevice) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_BLEDevice: public jni::JavaClass<JFunc_void_BLEDevice> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_BLEDevice;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_BLEDevice` instance holds through JNI.
+     */
+    void invoke(const BLEDevice& device) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JBLEDevice> /* device */)>("invoke");
+      method(self(), JBLEDevice::fromCpp(device));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_BLEDevice that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_BLEDevice_cxx final: public jni::HybridClass<JFunc_void_BLEDevice_cxx, JFunc_void_BLEDevice> {
+  public:
+    static jni::local_ref<JFunc_void_BLEDevice::javaobject> fromCpp(const std::function<void(const BLEDevice& /* device */)>& func) {
+      return JFunc_void_BLEDevice_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_BLEDevice_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JBLEDevice> device) {
+      _func(device->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const BLEDevice& /* device */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_BLEDevice_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_BLEDevice_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_BLEDevice_cxx(const std::function<void(const BLEDevice& /* device */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const BLEDevice& /* device */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JFunc_void_BLEState.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_BLEState.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "BLEState.hpp"
+#include <functional>
+#include "JBLEState.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(state: BLEState) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_BLEState: public jni::JavaClass<JFunc_void_BLEState> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_BLEState;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_BLEState` instance holds through JNI.
+     */
+    void invoke(BLEState state) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JBLEState> /* state */)>("invoke");
+      method(self(), JBLEState::fromCpp(state));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_BLEState that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_BLEState_cxx final: public jni::HybridClass<JFunc_void_BLEState_cxx, JFunc_void_BLEState> {
+  public:
+    static jni::local_ref<JFunc_void_BLEState::javaobject> fromCpp(const std::function<void(BLEState /* state */)>& func) {
+      return JFunc_void_BLEState_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_BLEState_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JBLEState> state) {
+      _func(state->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(BLEState /* state */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_BLEState_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_BLEState_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_BLEState_cxx(const std::function<void(BLEState /* state */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(BLEState /* state */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JFunc_void_bool.hpp

@@ -0,0 +1,74 @@
+///
+/// JFunc_void_bool.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(result: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool result) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* result */)>("invoke");
+      method(self(), result);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  public:
+    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* result */)>& func) {
+      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean result) {
+      _func(static_cast<bool>(result));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* result */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_cxx(const std::function<void(bool /* result */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* result */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JFunc_void_bool_std__string.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_bool_std__string.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <functional>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(success: Boolean, error: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool_std__string: public jni::JavaClass<JFunc_void_bool_std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool_std__string` instance holds through JNI.
+     */
+    void invoke(bool success, const std::string& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* success */, jni::alias_ref<jni::JString> /* error */)>("invoke");
+      method(self(), success, jni::make_jstring(error));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_bool_std__string_cxx final: public jni::HybridClass<JFunc_void_bool_std__string_cxx, JFunc_void_bool_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_bool_std__string::javaobject> fromCpp(const std::function<void(bool /* success */, const std::string& /* error */)>& func) {
+      return JFunc_void_bool_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean success, jni::alias_ref<jni::JString> error) {
+      _func(static_cast<bool>(success), error->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* success */, const std::string& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_std__string_cxx(const std::function<void(bool /* success */, const std::string& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* success */, const std::string& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble