react-native-ble-nitro 1.1.0 → 1.2.0

package/lib/index.js

@@ -20,6 +20,12 @@ function mapNativeBLEStateToBLEState(nativeState) {
     };
     return map[nativeState];
 }
+function arrayBufferToByteArray(buffer) {
+    return Array.from(new Uint8Array(buffer));
+}
+function byteArrayToArrayBuffer(data) {
+    return new Uint8Array(data).buffer;
+}
 let _instance;
 export class BleNitro {
     constructor() {
@@ -70,8 +76,18 @@ export class BleNitro {
         };
         // Create callback wrapper
         const scanCallback = (device) => {
-            device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
-            callback(device);
+            // Convert manufacturer data to Uint8Arrays
+            const convertedDevice = {
+                ...device,
+                serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs),
+                manufacturerData: {
+                    companyIdentifiers: device.manufacturerData.companyIdentifiers.map(entry => ({
+                        id: entry.id,
+                        data: arrayBufferToByteArray(entry.data)
+                    }))
+                }
+            };
+            callback(convertedDevice);
         };
         // Start scan
         BleNitroNative.startScan(nativeFilter, scanCallback);
@@ -102,10 +118,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: arrayBufferToByteArray(entry.data)
+                }))
+            }
         }));
     }
     /**
@@ -167,6 +189,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 +261,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 ByteArray
      */
     readCharacteristic(deviceId, serviceId, characteristicId) {
         return new Promise((resolve, reject) => {
@@ -239,7 +272,7 @@ export class BleNitro {
             }
             BleNitroNative.readCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (success, data, error) => {
                 if (success) {
-                    resolve(data);
+                    resolve(arrayBufferToByteArray(data));
                 }
                 else {
                     reject(new Error(error));
@@ -252,7 +285,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
      */
@@ -263,7 +296,8 @@ export class BleNitro {
                 reject(new Error('Device not connected'));
                 return;
             }
-            BleNitroNative.writeCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), data, withResponse, (success, error) => {
+            const dataAsArrayBuffer = byteArrayToArrayBuffer(data);
+            BleNitroNative.writeCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), dataAsArrayBuffer, withResponse, (success, error) => {
                 if (success) {
                     resolve(true);
                 }
@@ -288,7 +322,7 @@ export class BleNitro {
         }
         let _success = false;
         BleNitroNative.subscribeToCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (charId, data) => {
-            callback(charId, data);
+            callback(charId, arrayBufferToByteArray(data));
         }, (success, error) => {
             _success = success;
             if (!success) {
@@ -336,8 +370,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[];
@@ -32,11 +33,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;
     error?: string;
@@ -56,11 +57,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/nitrogen/generated/android/BleNitroOnLoad.cpp

@@ -20,8 +20,8 @@
 #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>
 
@@ -39,8 +39,8 @@ int initialize(JavaVM* vm) {
     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++/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_BLEDevice.hpp

@@ -19,6 +19,9 @@
 #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 {
 

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__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

package/nitrogen/generated/android/c++/JHybridNativeBleNitroSpec.cpp

@@ -13,6 +13,8 @@ namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
 namespace margelo::nitro::co::zyke::ble { struct ManufacturerData; }
 // Forward declaration of `ManufacturerDataEntry` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct ManufacturerDataEntry; }
+// 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,9 @@ namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 #include "JManufacturerData.hpp"
 #include "ManufacturerDataEntry.hpp"
 #include "JManufacturerDataEntry.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
 #include "BLEState.hpp"
 #include "JBLEState.hpp"
 #include "OperationResult.hpp"
@@ -42,8 +47,8 @@ namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 #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"
 
 namespace margelo::nitro::co::zyke::ble {
@@ -121,6 +126,11 @@ namespace margelo::nitro::co::zyke::ble {
     auto __result = method(_javaPart, jni::make_jstring(deviceId));
     return static_cast<bool>(__result);
   }
+  double JHybridNativeBleNitroSpec::requestMTU(const std::string& deviceId, double mtu) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<jni::JString> /* deviceId */, double /* mtu */)>("requestMTU");
+    auto __result = method(_javaPart, jni::make_jstring(deviceId), mtu);
+    return __result;
+  }
   void JHybridNativeBleNitroSpec::discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("discoverServices_cxx");
     method(_javaPart, jni::make_jstring(deviceId), JFunc_void_bool_std__string_cxx::fromCpp(callback));
@@ -153,22 +163,17 @@ namespace margelo::nitro::co::zyke::ble {
       return __vector;
     }();
   }
-  void JHybridNativeBleNitroSpec::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) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<JFunc_void_bool_std__vector_double__std__string::javaobject> /* callback */)>("readCharacteristic_cxx");
-    method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), jni::make_jstring(characteristicId), JFunc_void_bool_std__vector_double__std__string_cxx::fromCpp(callback));
+  void JHybridNativeBleNitroSpec::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) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string::javaobject> /* callback */)>("readCharacteristic_cxx");
+    method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), jni::make_jstring(characteristicId), JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx::fromCpp(callback));
   }
-  void JHybridNativeBleNitroSpec::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) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<jni::JArrayDouble> /* data */, jboolean /* withResponse */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("writeCharacteristic_cxx");
-    method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), 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;
-    }(), withResponse, JFunc_void_bool_std__string_cxx::fromCpp(callback));
+  void JHybridNativeBleNitroSpec::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) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<JArrayBuffer::javaobject> /* data */, jboolean /* withResponse */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("writeCharacteristic_cxx");
+    method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), jni::make_jstring(characteristicId), JArrayBuffer::wrap(data), withResponse, JFunc_void_bool_std__string_cxx::fromCpp(callback));
   }
-  void JHybridNativeBleNitroSpec::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) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<JFunc_void_std__string_std__vector_double_::javaobject> /* updateCallback */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* resultCallback */)>("subscribeToCharacteristic_cxx");
-    method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), jni::make_jstring(characteristicId), JFunc_void_std__string_std__vector_double__cxx::fromCpp(updateCallback), JFunc_void_bool_std__string_cxx::fromCpp(resultCallback));
+  void JHybridNativeBleNitroSpec::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) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<JFunc_void_std__string_std__shared_ptr_ArrayBuffer_::javaobject> /* updateCallback */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* resultCallback */)>("subscribeToCharacteristic_cxx");
+    method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), jni::make_jstring(characteristicId), JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx::fromCpp(updateCallback), JFunc_void_bool_std__string_cxx::fromCpp(resultCallback));
   }
   void JHybridNativeBleNitroSpec::unsubscribeFromCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("unsubscribeFromCharacteristic_cxx");

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

@@ -60,12 +60,13 @@ namespace margelo::nitro::co::zyke::ble {
     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) override;
     void disconnect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
     bool isConnected(const std::string& deviceId) override;
+    double requestMTU(const std::string& deviceId, double mtu) override;
     void discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
     std::vector<std::string> getServices(const std::string& deviceId) override;
     std::vector<std::string> getCharacteristics(const std::string& deviceId, const std::string& serviceId) override;
-    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) override;
-    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) override;
-    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) override;
+    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) override;
+    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) override;
+    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) override;
     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) override;
     void requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
     BLEState state() override;

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

@@ -12,6 +12,9 @@
 
 #include "JManufacturerDataEntry.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++/JManufacturerDataEntry.hpp

@@ -10,8 +10,10 @@
 #include <fbjni/fbjni.h>
 #include "ManufacturerDataEntry.hpp"
 
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
 #include <string>
-#include <vector>
 
 namespace margelo::nitro::co::zyke::ble {
 
@@ -34,16 +36,11 @@ namespace margelo::nitro::co::zyke::ble {
       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 fieldData = clazz->getField<jni::JArrayDouble>("data");
-      jni::local_ref<jni::JArrayDouble> data = this->getFieldValue(fieldData);
+      static const auto fieldData = clazz->getField<JArrayBuffer::javaobject>("data");
+      jni::local_ref<JArrayBuffer::javaobject> data = this->getFieldValue(fieldData);
       return ManufacturerDataEntry(
         id->toStdString(),
-        [&]() {
-          size_t __size = data->size();
-          std::vector<double> __vector(__size);
-          data->getRegion(0, __size, __vector.data());
-          return __vector;
-        }()
+        data->cthis()->getArrayBuffer()
       );
     }
 
@@ -55,12 +52,7 @@ namespace margelo::nitro::co::zyke::ble {
     static jni::local_ref<JManufacturerDataEntry::javaobject> fromCpp(const ManufacturerDataEntry& value) {
       return newInstance(
         jni::make_jstring(value.id),
-        [&]() {
-          size_t __size = value.data.size();
-          jni::local_ref<jni::JArrayDouble> __array = jni::JArrayDouble::newArray(__size);
-          __array->setRegion(0, __size, value.data.data());
-          return __array;
-        }()
+        JArrayBuffer::wrap(value.data)
       );
     }
   };

package/nitrogen/generated/android/kotlin/com/margelo/nitro/co/zyke/ble/{Func_void_bool_std__vector_double__std__string.kt → Func_void_bool_std__shared_ptr_ArrayBuffer__std__string.kt}

@@ -1,5 +1,5 @@
 ///
-/// Func_void_bool_std__vector_double__std__string.kt
+/// Func_void_bool_std__shared_ptr_ArrayBuffer__std__string.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -15,25 +15,25 @@ import dalvik.annotation.optimization.FastNative
 
 
 /**
- * Represents the JavaScript callback `(success: boolean, data: array, error: string) => void`.
+ * Represents the JavaScript callback `(success: boolean, data: array-buffer, error: string) => void`.
  * This can be either implemented in C++ (in which case it might be a callback coming from JS),
  * or in Kotlin/Java (in which case it is a native callback).
  */
 @DoNotStrip
 @Keep
 @Suppress("ClassName", "RedundantUnitReturnType")
-fun interface Func_void_bool_std__vector_double__std__string: (Boolean, DoubleArray, String) -> Unit {
+fun interface Func_void_bool_std__shared_ptr_ArrayBuffer__std__string: (Boolean, ArrayBuffer, String) -> Unit {
   /**
    * Call the given JS callback.
    * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
    */
   @DoNotStrip
   @Keep
-  override fun invoke(success: Boolean, data: DoubleArray, error: String): Unit
+  override fun invoke(success: Boolean, data: ArrayBuffer, error: String): Unit
 }
 
 /**
- * Represents the JavaScript callback `(success: boolean, data: array, error: string) => void`.
+ * Represents the JavaScript callback `(success: boolean, data: array-buffer, error: string) => void`.
  * This is implemented in C++, via a `std::function<...>`.
  * The callback might be coming from JS.
  */
@@ -44,7 +44,7 @@ fun interface Func_void_bool_std__vector_double__std__string: (Boolean, DoubleAr
   "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
   "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
 )
-class Func_void_bool_std__vector_double__std__string_cxx: Func_void_bool_std__vector_double__std__string {
+class Func_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx: Func_void_bool_std__shared_ptr_ArrayBuffer__std__string {
   @DoNotStrip
   @Keep
   private val mHybridData: HybridData
@@ -57,25 +57,25 @@ class Func_void_bool_std__vector_double__std__string_cxx: Func_void_bool_std__ve
 
   @DoNotStrip
   @Keep
-  override fun invoke(success: Boolean, data: DoubleArray, error: String): Unit
+  override fun invoke(success: Boolean, data: ArrayBuffer, error: String): Unit
     = invoke_cxx(success,data,error)
 
   @FastNative
-  private external fun invoke_cxx(success: Boolean, data: DoubleArray, error: String): Unit
+  private external fun invoke_cxx(success: Boolean, data: ArrayBuffer, error: String): Unit
 }
 
 /**
- * Represents the JavaScript callback `(success: boolean, data: array, error: string) => void`.
- * This is implemented in Java/Kotlin, via a `(Boolean, DoubleArray, String) -> Unit`.
+ * Represents the JavaScript callback `(success: boolean, data: array-buffer, error: string) => void`.
+ * This is implemented in Java/Kotlin, via a `(Boolean, ArrayBuffer, String) -> Unit`.
  * The callback is always coming from native.
  */
 @DoNotStrip
 @Keep
 @Suppress("ClassName", "RedundantUnitReturnType", "unused")
-class Func_void_bool_std__vector_double__std__string_java(private val function: (Boolean, DoubleArray, String) -> Unit): Func_void_bool_std__vector_double__std__string {
+class Func_void_bool_std__shared_ptr_ArrayBuffer__std__string_java(private val function: (Boolean, ArrayBuffer, String) -> Unit): Func_void_bool_std__shared_ptr_ArrayBuffer__std__string {
   @DoNotStrip
   @Keep
-  override fun invoke(success: Boolean, data: DoubleArray, error: String): Unit {
+  override fun invoke(success: Boolean, data: ArrayBuffer, error: String): Unit {
     return this.function(success, data, error)
   }
 }