react-native-ble-nitro 1.1.0 → 1.3.0

package/src/__tests__/index.test.ts

@@ -8,6 +8,7 @@ jest.mock('../specs/NativeBleNitro', () => ({
     connect: jest.fn(),
     disconnect: jest.fn(),
     isConnected: jest.fn(),
+    requestMTU: jest.fn(),
     discoverServices: jest.fn(),
     getServices: jest.fn(),
     getCharacteristics: jest.fn(),
@@ -15,12 +16,27 @@ jest.mock('../specs/NativeBleNitro', () => ({
     writeCharacteristic: jest.fn(),
     subscribeToCharacteristic: jest.fn(),
     unsubscribeFromCharacteristic: jest.fn(),
-    isBluetoothEnabled: jest.fn(),
+    getConnectedDevices: jest.fn(),
     requestBluetoothEnable: jest.fn(),
     state: jest.fn(),
     subscribeToStateChange: jest.fn(),
+    unsubscribeFromStateChange: jest.fn(),
+    openSettings: jest.fn(),
+  },
+  BLEState: { 
+    Unknown: 0,
+    Resetting: 1,
+    Unsupported: 2,
+    Unauthorized: 3,
+    PoweredOff: 4,
+    PoweredOn: 5
+  },
+  AndroidScanMode: {
+    LowLatency: 0,
+    Balanced: 1,
+    LowPower: 2,
+    Opportunistic: 3
   },
-  BLEState: { PoweredOn: 5, PoweredOff: 4 },
 }));
 
 import { ble as BleNitro } from '../index';
@@ -46,15 +62,23 @@ describe('BleNitro', () => {
         serviceUUIDs: ['test'],
         rssiThreshold: -100,
         allowDuplicates: false,
+        androidScanMode: 1, // AndroidScanMode.Balanced (default)
       },
       expect.any(Function)
     );
   });
 
-  test('stopScan calls native and resolves', () => {
-    mockNative.stopScan.mockImplementation(() => {
-      // stopScan is void, no callback needed
+  test('stopScan calls native and resolves', async () => {
+    // First start a scan to set _isScanning to true
+    mockNative.startScan.mockImplementation((filter, callback) => { // eslint-disable-line @typescript-eslint/no-unused-vars
+      // Just start scanning
     });
+    
+    const scanCallback = jest.fn();
+    await BleNitro.startScan({ serviceUUIDs: ['test'] }, scanCallback);
+
+    // Now stop the scan
+    mockNative.stopScan.mockImplementation(() => true);
 
     BleNitro.stopScan();
     
@@ -91,8 +115,9 @@ describe('BleNitro', () => {
   });
 
   test('writeCharacteristic requires connected device', async () => {
+    const data = new Uint8Array([1, 2, 3]);
     await expect(
-      BleNitro.writeCharacteristic('device', 'service', 'char', [1, 2, 3])
+      BleNitro.writeCharacteristic('device', 'service', 'char', data.buffer)
     ).rejects.toThrow('Device not connected');
   });
 
@@ -104,8 +129,9 @@ describe('BleNitro', () => {
     await BleNitro.connect('device');
 
     // Then read
-    mockNative.readCharacteristic.mockImplementation((_device: string, _service: string, _char: string, callback: (success: boolean, data: number[], error: string) => void) => {
-      callback(true, [85], ''); // Battery level 85%
+    mockNative.readCharacteristic.mockImplementation((_device: string, _service: string, _char: string, callback: (success: boolean, data: ArrayBuffer, error: string) => void) => {
+      const testData = new Uint8Array([85]);
+      callback(true, testData.buffer, ''); // Battery level 85%
     });
 
     const result = await BleNitro.readCharacteristic('device', 'service', 'char');
@@ -117,7 +143,11 @@ describe('BleNitro', () => {
       '0000char-0000-1000-8000-00805f9b34fb',  // 'char' padded to 8 chars
       expect.any(Function)
     );
-    expect(result).toEqual([85]);
+    
+    // Result should be ArrayBuffer
+    expect(result).toBeInstanceOf(ArrayBuffer);
+    const resultArray = new Uint8Array(result);
+    expect(resultArray[0]).toBe(85);
   });
 
   test('disconnect calls native', async () => {
@@ -146,17 +176,22 @@ describe('BleNitro', () => {
     await BleNitro.connect('device');
 
     // Mock subscription
-    mockNative.subscribeToCharacteristic.mockImplementation((_device: string, _service: string, _char: string, updateCallback: (charId: string, data: number[]) => void, resultCallback: (success: boolean, error: string) => void) => {
+    mockNative.subscribeToCharacteristic.mockImplementation((_device: string, _service: string, _char: string, updateCallback: (charId: string, data: ArrayBuffer) => void, resultCallback: (success: boolean, error: string) => void) => {
       resultCallback(true, '');
       // Simulate notification
-      updateCallback('char-id', [1, 2, 3]);
+      const testData = new Uint8Array([1, 2, 3]);
+      updateCallback('char-id', testData.buffer);
     });
 
     const notificationCallback = jest.fn();
-    BleNitro.subscribeToCharacteristic('device', 'service', 'char', notificationCallback);
+    const subscription = BleNitro.subscribeToCharacteristic('device', 'service', 'char', notificationCallback);
     
     expect(mockNative.subscribeToCharacteristic).toHaveBeenCalled();
-    expect(notificationCallback).toHaveBeenCalledWith('char-id', [1, 2, 3]);
+    expect(notificationCallback).toHaveBeenCalledWith('char-id', expect.any(ArrayBuffer));
+    
+    // Verify subscription object
+    expect(subscription).toHaveProperty('remove');
+    expect(typeof subscription.remove).toBe('function');
   });
 
   test('connect with disconnect event callback', async () => {

package/src/index.ts

@@ -3,17 +3,21 @@ import {
   ScanFilter as NativeScanFilter,
   BLEDevice as NativeBLEDevice,
   BLEState as NativeBLEState,
+  ScanCallback as NativeScanCallback,
+  AndroidScanMode as NativeAndroidScanMode,
 } from './specs/NativeBleNitro';
 
+
 export interface ScanFilter {
   serviceUUIDs?: string[];
   rssiThreshold?: number;
   allowDuplicates?: boolean;
+  androidScanMode?: AndroidScanMode;
 }
 
 export interface ManufacturerDataEntry {
   id: string;
-  data: number[];
+  data: ArrayBuffer;
 }
 
 export interface ManufacturerData {
@@ -43,7 +47,7 @@ export type DisconnectEventCallback = (
 export type OperationCallback = (success: boolean, error: string) => void;
 export type CharacteristicUpdateCallback = (
   characteristicId: string,
-  data: number[]
+  data: ArrayBuffer
 ) => void;
 
 export type Subscription = {
@@ -59,6 +63,13 @@ export enum BLEState {
   PoweredOn = 'PoweredOn',
 };
 
+export enum AndroidScanMode {
+  LowLatency = 'LowLatency',
+  Balanced = 'Balanced',
+  LowPower = 'LowPower',
+  Opportunistic = 'Opportunistic',
+}
+
 function mapNativeBLEStateToBLEState(nativeState: NativeBLEState): BLEState {
   const map = {
     0: BLEState.Unknown,
@@ -71,6 +82,17 @@ function mapNativeBLEStateToBLEState(nativeState: NativeBLEState): BLEState {
   return map[nativeState];
 }
 
+function mapAndroidScanModeToNativeAndroidScanMode(scanMode: AndroidScanMode): NativeAndroidScanMode {
+  const map = {
+    LowLatency: NativeAndroidScanMode.LowLatency,
+    Balanced: NativeAndroidScanMode.Balanced,
+    LowPower: NativeAndroidScanMode.LowPower,
+    Opportunistic: NativeAndroidScanMode.Opportunistic,
+  }
+  return map[scanMode];
+}
+
+
 let _instance: BleNitro;
 
 export class BleNitro {
@@ -116,7 +138,8 @@ export class BleNitro {
    */
   public startScan(
     filter: ScanFilter = {},
-    callback: ScanCallback
+    callback: ScanCallback,
+    onError?: (error: string) => void,
   ): void {
     if (this._isScanning) {
       return;
@@ -127,12 +150,29 @@ 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: NativeBLEDevice) => {
-      device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
-      callback(device);
+    const scanCallback: NativeScanCallback = (device: NativeBLEDevice | null, error: string | null) => {
+      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: BLEDevice = {
+        ...device,
+        serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs),
+        manufacturerData: {
+          companyIdentifiers: device.manufacturerData.companyIdentifiers.map(entry => ({
+            id: entry.id,
+            data: entry.data
+          }))
+        }
+      };
+      callback(convertedDevice);
     };
 
     // Start scan
@@ -150,6 +190,7 @@ export class BleNitro {
     }
 
     BleNitroNative.stopScan();
+    this._isScanning = false;
   }
 
   /**
@@ -168,10 +209,16 @@ export class BleNitro {
    */
   public getConnectedDevices(services?: string[]): BLEDevice[] {
     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
+        }))
+      }
     }));
   }
 
@@ -247,6 +294,18 @@ export class BleNitro {
     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
+   */
+  public requestMTU(deviceId: string, mtu: number): number {
+    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
@@ -322,13 +381,13 @@ 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
    */
   public readCharacteristic(
     deviceId: string,
     serviceId: string,
     characteristicId: string
-  ): Promise<number[]> {
+  ): Promise<ArrayBuffer> {
     return new Promise((resolve, reject) => {
       // Check if connected first
       if (!this._connectedDevices[deviceId]) {
@@ -340,7 +399,7 @@ export class BleNitro {
         deviceId,
         BleNitro.normalizeGattUUID(serviceId),
         BleNitro.normalizeGattUUID(characteristicId),
-        (success: boolean, data: number[], error: string) => {
+        (success: boolean, data: ArrayBuffer, error: string) => {
           if (success) {
             resolve(data);
           } else {
@@ -356,7 +415,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
    */
@@ -364,7 +423,7 @@ export class BleNitro {
     deviceId: string,
     serviceId: string,
     characteristicId: string,
-    data: number[],
+    data: ArrayBuffer,
     withResponse: boolean = true
   ): Promise<boolean> {
     return new Promise((resolve, reject) => {
@@ -416,7 +475,7 @@ export class BleNitro {
       deviceId,
       BleNitro.normalizeGattUUID(serviceId),
       BleNitro.normalizeGattUUID(characteristicId),
-      (charId: string, data: number[]) => {
+      (charId: string, data: ArrayBuffer) => {
         callback(charId, data);
       },
       (success, error) => {
@@ -484,8 +543,7 @@ export class BleNitro {
   }
 
   /**
-   * Request to enable Bluetooth
-   * Only works on Android
+   * Request to enable Bluetooth (Android only)
    * @returns Promise resolving when Bluetooth is enabled
    */
   public requestBluetoothEnable(): Promise<boolean> {

package/src/specs/NativeBleNitro.nitro.ts

@@ -1,5 +1,8 @@
 import { HybridObject } from 'react-native-nitro-modules';
 
+// Type alias for BLE data - ArrayBuffers for efficient binary data handling
+export type BLEValue = ArrayBuffer;
+
 // Nitro constraint: Use numeric enums instead of string unions
 export enum BLEState {
   Unknown = 0,
@@ -12,7 +15,7 @@ export enum BLEState {
 
 export interface ManufacturerDataEntry {
   id: string;
-  data: number[];
+  data: BLEValue;
 }
 
 export interface ManufacturerData {
@@ -28,22 +31,30 @@ export interface BLEDevice {
   isConnectable: boolean;
 }
 
+export 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;
@@ -67,6 +78,7 @@ export interface NativeBleNitro extends HybridObject<{ ios: 'swift'; android: 'k
   connect(deviceId: string, callback: ConnectionCallback, disconnectCallback?: DisconnectionEventCallback): void;
   disconnect(deviceId: string, callback: OperationCallback): void;
   isConnected(deviceId: string): boolean;
+  requestMTU(deviceId: string, mtu: number): number;
 
   // Service discovery
   discoverServices(deviceId: string, callback: OperationCallback): void;
@@ -75,7 +87,7 @@ export interface NativeBleNitro extends HybridObject<{ ios: 'swift'; android: 'k
 
   // Characteristic operations
   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;
 

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

@@ -1,82 +0,0 @@
-///
-/// 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_bool_std__vector_double__std__string.hpp

@@ -1,86 +0,0 @@
-///
-/// 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

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

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