react-native-ble-nitro 1.1.0 → 1.2.0

package/nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.cpp

@@ -21,6 +21,7 @@ namespace margelo::nitro::co::zyke::ble {
       prototype.registerHybridMethod("connect", &HybridNativeBleNitroSpec::connect);
       prototype.registerHybridMethod("disconnect", &HybridNativeBleNitroSpec::disconnect);
       prototype.registerHybridMethod("isConnected", &HybridNativeBleNitroSpec::isConnected);
+      prototype.registerHybridMethod("requestMTU", &HybridNativeBleNitroSpec::requestMTU);
       prototype.registerHybridMethod("discoverServices", &HybridNativeBleNitroSpec::discoverServices);
       prototype.registerHybridMethod("getServices", &HybridNativeBleNitroSpec::getServices);
       prototype.registerHybridMethod("getCharacteristics", &HybridNativeBleNitroSpec::getCharacteristics);

package/nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.hpp

@@ -17,6 +17,8 @@
 namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 // Forward declaration of `BLEDevice` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
 // Forward declaration of `BLEState` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
 // Forward declaration of `OperationResult` to properly resolve imports.
@@ -28,6 +30,7 @@ namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 #include <vector>
 #include <string>
 #include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
 #include <NitroModules/Promise.hpp>
@@ -70,12 +73,13 @@ namespace margelo::nitro::co::zyke::ble {
       virtual void connect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& callback, const std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>& disconnectCallback) = 0;
       virtual void disconnect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual bool isConnected(const std::string& deviceId) = 0;
+      virtual double requestMTU(const std::string& deviceId, double mtu) = 0;
       virtual void discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual std::vector<std::string> getServices(const std::string& deviceId) = 0;
       virtual std::vector<std::string> getCharacteristics(const std::string& deviceId, const std::string& serviceId) = 0;
-      virtual void readCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>& callback) = 0;
-      virtual void writeCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::vector<double>& data, bool withResponse, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
-      virtual void subscribeToCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(const std::string& /* characteristicId */, const std::vector<double>& /* data */)>& updateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) = 0;
+      virtual void readCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>& callback) = 0;
+      virtual void writeCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::shared_ptr<ArrayBuffer>& data, bool withResponse, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
+      virtual void subscribeToCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>& updateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) = 0;
       virtual void unsubscribeFromCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual void requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual BLEState state() = 0;

package/nitrogen/generated/shared/c++/ManufacturerDataEntry.hpp

@@ -18,10 +18,11 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
 
 #include <string>
-#include <vector>
+#include <NitroModules/ArrayBuffer.hpp>
 
 namespace margelo::nitro::co::zyke::ble {
 
@@ -31,11 +32,11 @@ namespace margelo::nitro::co::zyke::ble {
   struct ManufacturerDataEntry {
   public:
     std::string id     SWIFT_PRIVATE;
-    std::vector<double> data     SWIFT_PRIVATE;
+    std::shared_ptr<ArrayBuffer> data     SWIFT_PRIVATE;
 
   public:
     ManufacturerDataEntry() = default;
-    explicit ManufacturerDataEntry(std::string id, std::vector<double> data): id(id), data(data) {}
+    explicit ManufacturerDataEntry(std::string id, std::shared_ptr<ArrayBuffer> data): id(id), data(data) {}
   };
 
 } // namespace margelo::nitro::co::zyke::ble
@@ -49,13 +50,13 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::co::zyke::ble::ManufacturerDataEntry(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "id")),
-        JSIConverter<std::vector<double>>::fromJSI(runtime, obj.getProperty(runtime, "data"))
+        JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(runtime, obj.getProperty(runtime, "data"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::co::zyke::ble::ManufacturerDataEntry& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "id", JSIConverter<std::string>::toJSI(runtime, arg.id));
-      obj.setProperty(runtime, "data", JSIConverter<std::vector<double>>::toJSI(runtime, arg.data));
+      obj.setProperty(runtime, "data", JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, arg.data));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -64,7 +65,7 @@ namespace margelo::nitro {
       }
       jsi::Object obj = value.getObject(runtime);
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "id"))) return false;
-      if (!JSIConverter<std::vector<double>>::canConvert(runtime, obj.getProperty(runtime, "data"))) return false;
+      if (!JSIConverter<std::shared_ptr<ArrayBuffer>>::canConvert(runtime, obj.getProperty(runtime, "data"))) return false;
       return true;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "High-performance React Native BLE library built on Nitro Modules",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/react-native.config.js

@@ -1,8 +1,16 @@
+// https://github.com/react-native-community/cli/blob/main/docs/dependencies.md
+
 module.exports = {
   dependency: {
     platforms: {
-      android: {},
+      /**
+       * @type {import('@react-native-community/cli-types').IOSDependencyParams}
+       */
       ios: {},
+      /**
+       * @type {import('@react-native-community/cli-types').AndroidDependencyParams}
+       */
+      android: {},
     },
   },
-};
+}

package/src/index.ts

@@ -5,6 +5,8 @@ import {
   BLEState as NativeBLEState,
 } from './specs/NativeBleNitro';
 
+export type ByteArray = number[];
+
 export interface ScanFilter {
   serviceUUIDs?: string[];
   rssiThreshold?: number;
@@ -13,7 +15,7 @@ export interface ScanFilter {
 
 export interface ManufacturerDataEntry {
   id: string;
-  data: number[];
+  data: ByteArray;
 }
 
 export interface ManufacturerData {
@@ -43,7 +45,7 @@ export type DisconnectEventCallback = (
 export type OperationCallback = (success: boolean, error: string) => void;
 export type CharacteristicUpdateCallback = (
   characteristicId: string,
-  data: number[]
+  data: ByteArray
 ) => void;
 
 export type Subscription = {
@@ -71,6 +73,14 @@ function mapNativeBLEStateToBLEState(nativeState: NativeBLEState): BLEState {
   return map[nativeState];
 }
 
+function arrayBufferToByteArray(buffer: ArrayBuffer): ByteArray {
+  return Array.from(new Uint8Array(buffer));
+}
+
+function byteArrayToArrayBuffer(data: ByteArray): ArrayBuffer {
+  return new Uint8Array(data).buffer;
+}
+
 let _instance: BleNitro;
 
 export class BleNitro {
@@ -131,8 +141,18 @@ export class BleNitro {
 
     // Create callback wrapper
     const scanCallback = (device: NativeBLEDevice) => {
-      device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
-      callback(device);
+      // 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: arrayBufferToByteArray(entry.data)
+          }))
+        }
+      };
+      callback(convertedDevice);
     };
 
     // Start scan
@@ -168,10 +188,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: arrayBufferToByteArray(entry.data)
+        }))
+      }
     }));
   }
 
@@ -247,6 +273,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 +360,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 ByteArray
    */
   public readCharacteristic(
     deviceId: string,
     serviceId: string,
     characteristicId: string
-  ): Promise<number[]> {
+  ): Promise<ByteArray> {
     return new Promise((resolve, reject) => {
       // Check if connected first
       if (!this._connectedDevices[deviceId]) {
@@ -340,9 +378,9 @@ 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);
+            resolve(arrayBufferToByteArray(data));
           } else {
             reject(new Error(error));
           }
@@ -356,7 +394,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 ByteArray(number[])
    * @param withResponse Whether to wait for response
    * @returns Promise resolving when write is complete
    */
@@ -364,7 +402,7 @@ export class BleNitro {
     deviceId: string,
     serviceId: string,
     characteristicId: string,
-    data: number[],
+    data: ByteArray,
     withResponse: boolean = true
   ): Promise<boolean> {
     return new Promise((resolve, reject) => {
@@ -374,11 +412,13 @@ export class BleNitro {
         return;
       }
 
+      const dataAsArrayBuffer = byteArrayToArrayBuffer(data);
+
       BleNitroNative.writeCharacteristic(
         deviceId,
         BleNitro.normalizeGattUUID(serviceId),
         BleNitro.normalizeGattUUID(characteristicId),
-        data,
+        dataAsArrayBuffer,
         withResponse,
         (success: boolean, error: string) => {
           if (success) {
@@ -416,8 +456,8 @@ export class BleNitro {
       deviceId,
       BleNitro.normalizeGattUUID(serviceId),
       BleNitro.normalizeGattUUID(characteristicId),
-      (charId: string, data: number[]) => {
-        callback(charId, data);
+      (charId: string, data: ArrayBuffer) => {
+        callback(charId, arrayBufferToByteArray(data));
       },
       (success, error) => {
         _success = success;
@@ -484,8 +524,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 {
@@ -39,11 +42,11 @@ 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 +70,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 +79,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_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