react-native-ble-nitro 1.1.0 → 1.3.0

package/lib/commonjs/specs/NativeBleNitro.nitro.js.map

@@ -1 +1 @@
-{"version":3,"file":"NativeBleNitro.nitro.js","sourceRoot":"","sources":["../../../src/specs/NativeBleNitro.nitro.ts"],"names":[],"mappings":";;;AAEA,+DAA+D;AAC/D,IAAY,QAOX;AAPD,WAAY,QAAQ;IAClB,6CAAW,CAAA;IACX,iDAAa,CAAA;IACb,qDAAe,CAAA;IACf,uDAAgB,CAAA;IAChB,mDAAc,CAAA;IACd,iDAAa,CAAA;AACf,CAAC,EAPW,QAAQ,wBAAR,QAAQ,QAOnB"}
+{"version":3,"file":"NativeBleNitro.nitro.js","sourceRoot":"","sources":["../../../src/specs/NativeBleNitro.nitro.ts"],"names":[],"mappings":";;;AAKA,+DAA+D;AAC/D,IAAY,QAOX;AAPD,WAAY,QAAQ;IAClB,6CAAW,CAAA;IACX,iDAAa,CAAA;IACb,qDAAe,CAAA;IACf,uDAAgB,CAAA;IAChB,mDAAc,CAAA;IACd,iDAAa,CAAA;AACf,CAAC,EAPW,QAAQ,wBAAR,QAAQ,QAOnB;AAoBD,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,iEAAc,CAAA;IACd,6DAAY,CAAA;IACZ,6DAAY,CAAA;IACZ,uEAAiB,CAAA;AACnB,CAAC,EALW,eAAe,+BAAf,eAAe,QAK1B"}

package/lib/index.d.ts

@@ -2,10 +2,11 @@ export interface ScanFilter {
     serviceUUIDs?: string[];
     rssiThreshold?: number;
     allowDuplicates?: boolean;
+    androidScanMode?: AndroidScanMode;
 }
 export interface ManufacturerDataEntry {
     id: string;
-    data: number[];
+    data: ArrayBuffer;
 }
 export interface ManufacturerData {
     companyIdentifiers: ManufacturerDataEntry[];
@@ -22,7 +23,7 @@ export type ScanCallback = (device: BLEDevice) => void;
 export type ConnectionCallback = (success: boolean, deviceId: string, error: string) => void;
 export type DisconnectEventCallback = (deviceId: string, interrupted: boolean, error: string) => void;
 export type OperationCallback = (success: boolean, error: string) => void;
-export type CharacteristicUpdateCallback = (characteristicId: string, data: number[]) => void;
+export type CharacteristicUpdateCallback = (characteristicId: string, data: ArrayBuffer) => void;
 export type Subscription = {
     remove: () => void;
 };
@@ -34,6 +35,12 @@ export declare enum BLEState {
     PoweredOff = "PoweredOff",
     PoweredOn = "PoweredOn"
 }
+export declare enum AndroidScanMode {
+    LowLatency = "LowLatency",
+    Balanced = "Balanced",
+    LowPower = "LowPower",
+    Opportunistic = "Opportunistic"
+}
 export declare class BleNitro {
     private _isScanning;
     private _connectedDevices;
@@ -52,7 +59,7 @@ export declare class BleNitro {
      * @param callback Callback function called when a device is found
      * @returns Promise resolving to success state
      */
-    startScan(filter: ScanFilter | undefined, callback: ScanCallback): void;
+    startScan(filter: ScanFilter | undefined, callback: ScanCallback, onError?: (error: string) => void): void;
     /**
      * Stop scanning for Bluetooth devices
      * @returns Promise resolving to success state
@@ -88,6 +95,13 @@ export declare class BleNitro {
      * @returns Promise resolving to connection state
      */
     isConnected(deviceId: string): boolean;
+    /**
+     * Request a new MTU size
+     * @param deviceId ID of the device
+     * @param mtu New MTU size, min is 23, max is 517
+     * @returns On Android: new MTU size; on iOS: current MTU size as it is handled by iOS itself; on error: -1
+     */
+    requestMTU(deviceId: string, mtu: number): number;
     /**
      * Discover services for a connected device
      * @param deviceId ID of the device
@@ -112,19 +126,19 @@ export declare class BleNitro {
      * @param deviceId ID of the device
      * @param serviceId ID of the service
      * @param characteristicId ID of the characteristic
-     * @returns Promise resolving to the characteristic data as byte array
+     * @returns Promise resolving to the characteristic data as ArrayBuffer
      */
-    readCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<number[]>;
+    readCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<ArrayBuffer>;
     /**
      * Write a value to a characteristic
      * @param deviceId ID of the device
      * @param serviceId ID of the service
      * @param characteristicId ID of the characteristic
-     * @param data Data to write as an array of bytes
+     * @param data Data to write as ArrayBuffer
      * @param withResponse Whether to wait for response
      * @returns Promise resolving when write is complete
      */
-    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: number[], withResponse?: boolean): Promise<boolean>;
+    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: ArrayBuffer, withResponse?: boolean): Promise<boolean>;
     /**
      * Subscribe to characteristic notifications
      * @param deviceId ID of the device
@@ -148,8 +162,7 @@ export declare class BleNitro {
      */
     isBluetoothEnabled(): boolean;
     /**
-     * Request to enable Bluetooth
-     * Only works on Android
+     * Request to enable Bluetooth (Android only)
      * @returns Promise resolving when Bluetooth is enabled
      */
     requestBluetoothEnable(): Promise<boolean>;

package/lib/index.js

@@ -1,4 +1,5 @@
 import BleNitroNative from './specs/NativeBleNitro';
+import { AndroidScanMode as NativeAndroidScanMode, } from './specs/NativeBleNitro';
 export var BLEState;
 (function (BLEState) {
     BLEState["Unknown"] = "Unknown";
@@ -9,6 +10,13 @@ export var BLEState;
     BLEState["PoweredOn"] = "PoweredOn";
 })(BLEState || (BLEState = {}));
 ;
+export var AndroidScanMode;
+(function (AndroidScanMode) {
+    AndroidScanMode["LowLatency"] = "LowLatency";
+    AndroidScanMode["Balanced"] = "Balanced";
+    AndroidScanMode["LowPower"] = "LowPower";
+    AndroidScanMode["Opportunistic"] = "Opportunistic";
+})(AndroidScanMode || (AndroidScanMode = {}));
 function mapNativeBLEStateToBLEState(nativeState) {
     const map = {
         0: BLEState.Unknown,
@@ -20,6 +28,15 @@ function mapNativeBLEStateToBLEState(nativeState) {
     };
     return map[nativeState];
 }
+function mapAndroidScanModeToNativeAndroidScanMode(scanMode) {
+    const map = {
+        LowLatency: NativeAndroidScanMode.LowLatency,
+        Balanced: NativeAndroidScanMode.Balanced,
+        LowPower: NativeAndroidScanMode.LowPower,
+        Opportunistic: NativeAndroidScanMode.Opportunistic,
+    };
+    return map[scanMode];
+}
 let _instance;
 export class BleNitro {
     constructor() {
@@ -58,7 +75,7 @@ export class BleNitro {
      * @param callback Callback function called when a device is found
      * @returns Promise resolving to success state
      */
-    startScan(filter = {}, callback) {
+    startScan(filter = {}, callback, onError) {
         if (this._isScanning) {
             return;
         }
@@ -67,11 +84,28 @@ export class BleNitro {
             serviceUUIDs: filter.serviceUUIDs || [],
             rssiThreshold: filter.rssiThreshold ?? -100,
             allowDuplicates: filter.allowDuplicates ?? false,
+            androidScanMode: mapAndroidScanModeToNativeAndroidScanMode(filter.androidScanMode ?? AndroidScanMode.Balanced),
         };
         // Create callback wrapper
-        const scanCallback = (device) => {
-            device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
-            callback(device);
+        const scanCallback = (device, error) => {
+            if (error && !device) {
+                this._isScanning = false;
+                onError?.(error);
+                return;
+            }
+            device = device; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            // Convert manufacturer data to Uint8Arrays
+            const convertedDevice = {
+                ...device,
+                serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs),
+                manufacturerData: {
+                    companyIdentifiers: device.manufacturerData.companyIdentifiers.map(entry => ({
+                        id: entry.id,
+                        data: entry.data
+                    }))
+                }
+            };
+            callback(convertedDevice);
         };
         // Start scan
         BleNitroNative.startScan(nativeFilter, scanCallback);
@@ -86,6 +120,7 @@ export class BleNitro {
             return;
         }
         BleNitroNative.stopScan();
+        this._isScanning = false;
     }
     /**
      * Check if currently scanning for devices
@@ -102,10 +137,16 @@ export class BleNitro {
      */
     getConnectedDevices(services) {
         const devices = BleNitroNative.getConnectedDevices(services || []);
-        // Normalize service UUIDs for connected devices
+        // Normalize service UUIDs - manufacturer data already comes as ArrayBuffers
         return devices.map(device => ({
             ...device,
-            serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs)
+            serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs),
+            manufacturerData: {
+                companyIdentifiers: device.manufacturerData.companyIdentifiers.map(entry => ({
+                    id: entry.id,
+                    data: entry.data
+                }))
+            }
         }));
     }
     /**
@@ -167,6 +208,17 @@ export class BleNitro {
     isConnected(deviceId) {
         return BleNitroNative.isConnected(deviceId);
     }
+    /**
+     * Request a new MTU size
+     * @param deviceId ID of the device
+     * @param mtu New MTU size, min is 23, max is 517
+     * @returns On Android: new MTU size; on iOS: current MTU size as it is handled by iOS itself; on error: -1
+     */
+    requestMTU(deviceId, mtu) {
+        mtu = parseInt(mtu.toString(), 10);
+        const deviceMtu = BleNitroNative.requestMTU(deviceId, mtu);
+        return deviceMtu;
+    }
     /**
      * Discover services for a connected device
      * @param deviceId ID of the device
@@ -228,7 +280,7 @@ export class BleNitro {
      * @param deviceId ID of the device
      * @param serviceId ID of the service
      * @param characteristicId ID of the characteristic
-     * @returns Promise resolving to the characteristic data as byte array
+     * @returns Promise resolving to the characteristic data as ArrayBuffer
      */
     readCharacteristic(deviceId, serviceId, characteristicId) {
         return new Promise((resolve, reject) => {
@@ -252,7 +304,7 @@ export class BleNitro {
      * @param deviceId ID of the device
      * @param serviceId ID of the service
      * @param characteristicId ID of the characteristic
-     * @param data Data to write as an array of bytes
+     * @param data Data to write as ArrayBuffer
      * @param withResponse Whether to wait for response
      * @returns Promise resolving when write is complete
      */
@@ -336,8 +388,7 @@ export class BleNitro {
         return this.state() === BLEState.PoweredOn;
     }
     /**
-     * Request to enable Bluetooth
-     * Only works on Android
+     * Request to enable Bluetooth (Android only)
      * @returns Promise resolving when Bluetooth is enabled
      */
     requestBluetoothEnable() {

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

@@ -1,4 +1,5 @@
 import { HybridObject } from 'react-native-nitro-modules';
+export type BLEValue = ArrayBuffer;
 export declare enum BLEState {
     Unknown = 0,
     Resetting = 1,
@@ -9,7 +10,7 @@ export declare enum BLEState {
 }
 export interface ManufacturerDataEntry {
     id: string;
-    data: number[];
+    data: BLEValue;
 }
 export interface ManufacturerData {
     companyIdentifiers: ManufacturerDataEntry[];
@@ -22,21 +23,28 @@ export interface BLEDevice {
     serviceUUIDs: string[];
     isConnectable: boolean;
 }
+export declare enum AndroidScanMode {
+    LowLatency = 0,
+    Balanced = 1,
+    LowPower = 2,
+    Opportunistic = 3
+}
 export interface ScanFilter {
     serviceUUIDs: string[];
     rssiThreshold: number;
     allowDuplicates: boolean;
+    androidScanMode: AndroidScanMode;
 }
-export type ScanCallback = (device: BLEDevice) => void;
+export type ScanCallback = (device: BLEDevice | null, error: string | null) => 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 CharacteristicCallback = (characteristicId: string, data: BLEValue) => 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;
+export type ReadCharacteristicCallback = (success: boolean, data: BLEValue, error: string) => void;
 export type OperationResult = {
     success: boolean;
     error?: string;
@@ -56,11 +64,12 @@ export interface NativeBleNitro extends HybridObject<{
     connect(deviceId: string, callback: ConnectionCallback, disconnectCallback?: DisconnectionEventCallback): void;
     disconnect(deviceId: string, callback: OperationCallback): void;
     isConnected(deviceId: string): boolean;
+    requestMTU(deviceId: string, mtu: number): number;
     discoverServices(deviceId: string, callback: OperationCallback): void;
     getServices(deviceId: string): string[];
     getCharacteristics(deviceId: string, serviceId: string): string[];
     readCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: ReadCharacteristicCallback): void;
-    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: number[], withResponse: boolean, callback: OperationCallback): void;
+    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: BLEValue, 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;
     requestBluetoothEnable(callback: OperationCallback): void;

package/lib/specs/NativeBleNitro.nitro.js

@@ -8,3 +8,10 @@ export var BLEState;
     BLEState[BLEState["PoweredOff"] = 4] = "PoweredOff";
     BLEState[BLEState["PoweredOn"] = 5] = "PoweredOn";
 })(BLEState || (BLEState = {}));
+export var AndroidScanMode;
+(function (AndroidScanMode) {
+    AndroidScanMode[AndroidScanMode["LowLatency"] = 0] = "LowLatency";
+    AndroidScanMode[AndroidScanMode["Balanced"] = 1] = "Balanced";
+    AndroidScanMode[AndroidScanMode["LowPower"] = 2] = "LowPower";
+    AndroidScanMode[AndroidScanMode["Opportunistic"] = 3] = "Opportunistic";
+})(AndroidScanMode || (AndroidScanMode = {}));

package/nitrogen/generated/android/BleNitroOnLoad.cpp

@@ -16,12 +16,12 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridNativeBleNitroSpec.hpp"
-#include "JFunc_void_BLEDevice.hpp"
+#include "JFunc_void_std__optional_BLEDevice__std__optional_std__string_.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_bool_std__shared_ptr_ArrayBuffer__std__string.hpp"
+#include "JFunc_void_std__string_std__shared_ptr_ArrayBuffer_.hpp"
 #include "JFunc_void_BLEState.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
@@ -35,12 +35,12 @@ int initialize(JavaVM* vm) {
   return facebook::jni::initialize(vm, [] {
     // Register native JNI methods
     margelo::nitro::co::zyke::ble::JHybridNativeBleNitroSpec::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_BLEDevice_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_std__optional_BLEDevice__std__optional_std__string__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_bool_std__shared_ptr_ArrayBuffer__std__string_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_BLEState_cxx::registerNatives();
 
     // Register Nitro Hybrid Objects

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

@@ -0,0 +1,65 @@
+///
+/// JAndroidScanMode.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 "AndroidScanMode.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AndroidScanMode" and the the Kotlin enum "AndroidScanMode".
+   */
+  struct JAndroidScanMode final: public jni::JavaClass<JAndroidScanMode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/AndroidScanMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AndroidScanMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidScanMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AndroidScanMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAndroidScanMode> fromCpp(AndroidScanMode value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLOWLATENCY = clazz->getStaticField<JAndroidScanMode>("LOWLATENCY");
+      static const auto fieldBALANCED = clazz->getStaticField<JAndroidScanMode>("BALANCED");
+      static const auto fieldLOWPOWER = clazz->getStaticField<JAndroidScanMode>("LOWPOWER");
+      static const auto fieldOPPORTUNISTIC = clazz->getStaticField<JAndroidScanMode>("OPPORTUNISTIC");
+      
+      switch (value) {
+        case AndroidScanMode::LOWLATENCY:
+          return clazz->getStaticFieldValue(fieldLOWLATENCY);
+        case AndroidScanMode::BALANCED:
+          return clazz->getStaticFieldValue(fieldBALANCED);
+        case AndroidScanMode::LOWPOWER:
+          return clazz->getStaticFieldValue(fieldLOWPOWER);
+        case AndroidScanMode::OPPORTUNISTIC:
+          return clazz->getStaticFieldValue(fieldOPPORTUNISTIC);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -14,6 +14,9 @@
 #include "JManufacturerDataEntry.hpp"
 #include "ManufacturerData.hpp"
 #include "ManufacturerDataEntry.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
 #include <string>
 #include <vector>
 

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

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_bool_std__shared_ptr_ArrayBuffer__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 <NitroModules/ArrayBuffer.hpp>
+#include <string>
+#include <functional>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(success: Boolean, data: ArrayBuffer, error: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string: public jni::JavaClass<JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_std__shared_ptr_ArrayBuffer__std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string` instance holds through JNI.
+     */
+    void invoke(bool success, const std::shared_ptr<ArrayBuffer>& data, const std::string& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* success */, jni::alias_ref<JArrayBuffer::javaobject> /* data */, jni::alias_ref<jni::JString> /* error */)>("invoke");
+      method(self(), success, JArrayBuffer::wrap(data), jni::make_jstring(error));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool_std__shared_ptr_ArrayBuffer__std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx final: public jni::HybridClass<JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx, JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string> {
+  public:
+    static jni::local_ref<JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string::javaobject> fromCpp(const std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>& func) {
+      return JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean success, jni::alias_ref<JArrayBuffer::javaobject> data, jni::alias_ref<jni::JString> error) {
+      _func(static_cast<bool>(success), data->cthis()->getArrayBuffer(), error->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx(const std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,86 @@
+///
+/// JFunc_void_std__optional_BLEDevice__std__optional_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 "BLEDevice.hpp"
+#include <optional>
+#include <string>
+#include <functional>
+#include "JBLEDevice.hpp"
+#include "ManufacturerData.hpp"
+#include "JManufacturerData.hpp"
+#include "ManufacturerDataEntry.hpp"
+#include <vector>
+#include "JManufacturerDataEntry.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(device: BLEDevice?, error: String?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__optional_BLEDevice__std__optional_std__string_: public jni::JavaClass<JFunc_void_std__optional_BLEDevice__std__optional_std__string_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__optional_BLEDevice__std__optional_std__string_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__optional_BLEDevice__std__optional_std__string_` instance holds through JNI.
+     */
+    void invoke(const std::optional<BLEDevice>& device, const std::optional<std::string>& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JBLEDevice> /* device */, jni::alias_ref<jni::JString> /* error */)>("invoke");
+      method(self(), device.has_value() ? JBLEDevice::fromCpp(device.value()) : nullptr, error.has_value() ? jni::make_jstring(error.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__optional_BLEDevice__std__optional_std__string_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx final: public jni::HybridClass<JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx, JFunc_void_std__optional_BLEDevice__std__optional_std__string_> {
+  public:
+    static jni::local_ref<JFunc_void_std__optional_BLEDevice__std__optional_std__string_::javaobject> fromCpp(const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& func) {
+      return JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JBLEDevice> device, jni::alias_ref<jni::JString> error) {
+      _func(device != nullptr ? std::make_optional(device->toCpp()) : std::nullopt, error != nullptr ? std::make_optional(error->toStdString()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__optional_BLEDevice__std__optional_std__string__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx(const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_std__string_std__shared_ptr_ArrayBuffer_.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 <NitroModules/ArrayBuffer.hpp>
+#include <functional>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(characteristicId: String, data: ArrayBuffer) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string_std__shared_ptr_ArrayBuffer_: public jni::JavaClass<JFunc_void_std__string_std__shared_ptr_ArrayBuffer_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__string_std__shared_ptr_ArrayBuffer_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string_std__shared_ptr_ArrayBuffer_` instance holds through JNI.
+     */
+    void invoke(const std::string& characteristicId, const std::shared_ptr<ArrayBuffer>& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<JArrayBuffer::javaobject> /* data */)>("invoke");
+      method(self(), jni::make_jstring(characteristicId), JArrayBuffer::wrap(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string_std__shared_ptr_ArrayBuffer_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx final: public jni::HybridClass<JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx, JFunc_void_std__string_std__shared_ptr_ArrayBuffer_> {
+  public:
+    static jni::local_ref<JFunc_void_std__string_std__shared_ptr_ArrayBuffer_::javaobject> fromCpp(const std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>& func) {
+      return JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> characteristicId, jni::alias_ref<JArrayBuffer::javaobject> data) {
+      _func(characteristicId->toStdString(), data->cthis()->getArrayBuffer());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__string_std__shared_ptr_ArrayBuffer__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx(const std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble