react-native-ble-nitro 1.0.0-beta.9 → 1.1.0

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,14 @@
 #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_std__string.hpp"
+#include "JFunc_void_std__string_bool_std__string.hpp"
+#include "JFunc_void_bool_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 +34,23 @@ 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_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_bool_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_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

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_bool_std__string_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, deviceId: String, error: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool_std__string_std__string: public jni::JavaClass<JFunc_void_bool_std__string_std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_std__string_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool_std__string_std__string` instance holds through JNI.
+     */
+    void invoke(bool success, const std::string& deviceId, const std::string& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* success */, jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* error */)>("invoke");
+      method(self(), success, jni::make_jstring(deviceId), jni::make_jstring(error));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool_std__string_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_bool_std__string_std__string_cxx final: public jni::HybridClass<JFunc_void_bool_std__string_std__string_cxx, JFunc_void_bool_std__string_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_bool_std__string_std__string::javaobject> fromCpp(const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& func) {
+      return JFunc_void_bool_std__string_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_std__string_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean success, jni::alias_ref<jni::JString> deviceId, jni::alias_ref<jni::JString> error) {
+      _func(static_cast<bool>(success), deviceId->toStdString(), error->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_std__string_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_std__string_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_std__string_std__string_cxx(const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,86 @@
+///
+/// JFunc_void_bool_std__vector_double__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 <vector>
+#include <string>
+#include <functional>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(success: Boolean, data: DoubleArray, error: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool_std__vector_double__std__string: public jni::JavaClass<JFunc_void_bool_std__vector_double__std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_std__vector_double__std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool_std__vector_double__std__string` instance holds through JNI.
+     */
+    void invoke(bool success, const std::vector<double>& data, const std::string& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* success */, jni::alias_ref<jni::JArrayDouble> /* data */, jni::alias_ref<jni::JString> /* error */)>("invoke");
+      method(self(), success, [&]() {
+        size_t __size = data.size();
+        jni::local_ref<jni::JArrayDouble> __array = jni::JArrayDouble::newArray(__size);
+        __array->setRegion(0, __size, data.data());
+        return __array;
+      }(), jni::make_jstring(error));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool_std__vector_double__std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_bool_std__vector_double__std__string_cxx final: public jni::HybridClass<JFunc_void_bool_std__vector_double__std__string_cxx, JFunc_void_bool_std__vector_double__std__string> {
+  public:
+    static jni::local_ref<JFunc_void_bool_std__vector_double__std__string::javaobject> fromCpp(const std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>& func) {
+      return JFunc_void_bool_std__vector_double__std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_std__vector_double__std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean success, jni::alias_ref<jni::JArrayDouble> data, jni::alias_ref<jni::JString> error) {
+      _func(static_cast<bool>(success), [&]() {
+              size_t __size = data->size();
+              std::vector<double> __vector(__size);
+              data->getRegion(0, __size, __vector.data());
+              return __vector;
+            }(), error->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_std__vector_double__std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_std__vector_double__std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_std__vector_double__std__string_cxx(const std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble