react-native-ble-nitro 1.0.0 → 1.2.0

package/lib/index.d.ts

@@ -1,3 +1,4 @@
+export type ByteArray = number[];
 export interface ScanFilter {
     serviceUUIDs?: string[];
     rssiThreshold?: number;
@@ -5,7 +6,7 @@ export interface ScanFilter {
 }
 export interface ManufacturerDataEntry {
     id: string;
-    data: number[];
+    data: ByteArray;
 }
 export interface ManufacturerData {
     companyIdentifiers: ManufacturerDataEntry[];
@@ -22,9 +23,9 @@ 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: ByteArray) => void;
 export type Subscription = {
-    remove: () => Promise<void>;
+    remove: () => void;
 };
 export declare enum BLEState {
     Unknown = "Unknown",
@@ -52,22 +53,23 @@ 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): Promise<boolean>;
+    startScan(filter: ScanFilter | undefined, callback: ScanCallback): void;
     /**
      * Stop scanning for Bluetooth devices
      * @returns Promise resolving to success state
      */
-    stopScan(): Promise<boolean>;
+    stopScan(): void;
     /**
      * Check if currently scanning for devices
      * @returns Promise resolving to scanning state
      */
-    isScanning(): Promise<boolean>;
+    isScanning(): boolean;
     /**
      * Get all currently connected devices
-     * @returns Promise resolving to array of connected devices
+     * @param services Optional list of service UUIDs to filter by
+     * @returns Array of connected devices
      */
-    getConnectedDevices(): Promise<BLEDevice[]>;
+    getConnectedDevices(services?: string[]): BLEDevice[];
     /**
      * Connect to a Bluetooth device
      * @param deviceId ID of the device to connect to
@@ -80,13 +82,20 @@ export declare class BleNitro {
      * @param deviceId ID of the device to disconnect from
      * @returns Promise resolving when disconnected
      */
-    disconnect(deviceId: string): Promise<boolean>;
+    disconnect(deviceId: string): Promise<void>;
     /**
      * Check if connected to a device
      * @param deviceId ID of the device to check
      * @returns Promise resolving to connection state
      */
-    isConnected(deviceId: string): Promise<boolean>;
+    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
@@ -105,25 +114,25 @@ export declare class BleNitro {
      * @param serviceId ID of the service
      * @returns Promise resolving to array of characteristic UUIDs
      */
-    getCharacteristics(deviceId: string, serviceId: string): Promise<string[]>;
+    getCharacteristics(deviceId: string, serviceId: string): string[];
     /**
      * Read a characteristic value
      * @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: string, serviceId: string, characteristicId: string): Promise<number[]>;
+    readCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<ByteArray>;
     /**
      * 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 ByteArray(number[])
      * @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: ByteArray, withResponse?: boolean): Promise<boolean>;
     /**
      * Subscribe to characteristic notifications
      * @param deviceId ID of the device
@@ -132,7 +141,7 @@ export declare class BleNitro {
      * @param callback Callback function called when notification is received
      * @returns Promise resolving when subscription is complete
      */
-    subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: CharacteristicUpdateCallback): Promise<Subscription>;
+    subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: CharacteristicUpdateCallback): Subscription;
     /**
      * Unsubscribe from characteristic notifications
      * @param deviceId ID of the device
@@ -145,9 +154,9 @@ export declare class BleNitro {
      * Check if Bluetooth is enabled
      * @returns Promise resolving to Bluetooth state
      */
-    isBluetoothEnabled(): Promise<boolean>;
+    isBluetoothEnabled(): boolean;
     /**
-     * Request to enable Bluetooth
+     * Request to enable Bluetooth (Android only)
      * @returns Promise resolving when Bluetooth is enabled
      */
     requestBluetoothEnable(): Promise<boolean>;
@@ -156,7 +165,7 @@ export declare class BleNitro {
      * @returns Promise resolving to Bluetooth state
      * @see BLEState
      */
-    state(): Promise<BLEState>;
+    state(): BLEState;
     /**
      * Subscribe to Bluetooth state changes
      * @param callback Callback function called when state changes
@@ -164,7 +173,7 @@ export declare class BleNitro {
      * @returns Promise resolving when subscription is complete
      * @see BLEState
      */
-    subscribeToStateChange(callback: (state: BLEState) => void, emitInitial?: boolean): Promise<Subscription>;
+    subscribeToStateChange(callback: (state: BLEState) => void, emitInitial?: boolean): Subscription;
     /**
      * Open Bluetooth settings
      * @returns Promise resolving when settings are opened

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() {
@@ -59,78 +65,70 @@ export class BleNitro {
      * @returns Promise resolving to success state
      */
     startScan(filter = {}, callback) {
-        return new Promise((resolve) => {
-            // Don't start scanning if already scanning
-            if (this._isScanning) {
-                resolve(true);
-                return;
-            }
-            // Create native scan filter with defaults
-            const nativeFilter = {
-                serviceUUIDs: filter.serviceUUIDs || [],
-                rssiThreshold: filter.rssiThreshold ?? -100,
-                allowDuplicates: filter.allowDuplicates ?? false,
-            };
-            // Create callback wrapper
-            const scanCallback = (device) => {
-                device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
-                callback(device);
+        if (this._isScanning) {
+            return;
+        }
+        // Create native scan filter with defaults
+        const nativeFilter = {
+            serviceUUIDs: filter.serviceUUIDs || [],
+            rssiThreshold: filter.rssiThreshold ?? -100,
+            allowDuplicates: filter.allowDuplicates ?? false,
+        };
+        // Create callback wrapper
+        const scanCallback = (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)
+                    }))
+                }
             };
-            // Start scan
-            BleNitroNative.startScan(nativeFilter, scanCallback);
-            this._isScanning = true;
-            resolve(true);
-        });
+            callback(convertedDevice);
+        };
+        // Start scan
+        BleNitroNative.startScan(nativeFilter, scanCallback);
+        this._isScanning = true;
     }
     /**
      * Stop scanning for Bluetooth devices
      * @returns Promise resolving to success state
      */
     stopScan() {
-        return new Promise((resolve, reject) => {
-            // Don't stop scanning if not scanning
-            if (!this._isScanning) {
-                resolve(true);
-                return;
-            }
-            BleNitroNative.stopScan((success, error) => {
-                if (success) {
-                    this._isScanning = false;
-                    resolve(true);
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
-        });
+        if (!this._isScanning) {
+            return;
+        }
+        BleNitroNative.stopScan();
     }
     /**
      * Check if currently scanning for devices
      * @returns Promise resolving to scanning state
      */
     isScanning() {
-        return new Promise((resolve) => {
-            BleNitroNative.isScanning((scanning) => {
-                this._isScanning = scanning;
-                resolve(scanning);
-            });
-        });
+        this._isScanning = BleNitroNative.isScanning();
+        return this._isScanning;
     }
     /**
      * Get all currently connected devices
-     * @returns Promise resolving to array of connected devices
+     * @param services Optional list of service UUIDs to filter by
+     * @returns Array of connected devices
      */
-    getConnectedDevices() {
-        return new Promise((resolve) => {
-            BleNitroNative.getConnectedDevices((devices) => {
-                // Normalize service UUIDs for connected devices
-                const normalizedDevices = devices.map(device => ({
-                    ...device,
-                    serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs)
-                }));
-                resolve(normalizedDevices);
-            });
-        });
+    getConnectedDevices(services) {
+        const devices = BleNitroNative.getConnectedDevices(services || []);
+        // Normalize service UUIDs - manufacturer data already comes as ArrayBuffers
+        return devices.map(device => ({
+            ...device,
+            serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs),
+            manufacturerData: {
+                companyIdentifiers: device.manufacturerData.companyIdentifiers.map(entry => ({
+                    id: entry.id,
+                    data: arrayBufferToByteArray(entry.data)
+                }))
+            }
+        }));
     }
     /**
      * Connect to a Bluetooth device
@@ -169,13 +167,13 @@ export class BleNitro {
         return new Promise((resolve, reject) => {
             // Check if already disconnected
             if (!this._connectedDevices[deviceId]) {
-                resolve(true);
+                resolve();
                 return;
             }
             BleNitroNative.disconnect(deviceId, (success, error) => {
                 if (success) {
                     delete this._connectedDevices[deviceId];
-                    resolve(true);
+                    resolve();
                 }
                 else {
                     reject(new Error(error));
@@ -189,12 +187,18 @@ export class BleNitro {
      * @returns Promise resolving to connection state
      */
     isConnected(deviceId) {
-        return new Promise((resolve) => {
-            BleNitroNative.isConnected(deviceId, (connected) => {
-                this._connectedDevices[deviceId] = connected;
-                resolve(connected);
-            });
-        });
+        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
@@ -235,9 +239,8 @@ export class BleNitro {
                 reject(new Error('Failed to discover services'));
                 return;
             }
-            BleNitroNative.getServices(deviceId, (services) => {
-                resolve(BleNitro.normalizeGattUUIDs(services));
-            });
+            const services = BleNitroNative.getServices(deviceId);
+            resolve(BleNitro.normalizeGattUUIDs(services));
         });
     }
     /**
@@ -247,23 +250,18 @@ export class BleNitro {
      * @returns Promise resolving to array of characteristic UUIDs
      */
     getCharacteristics(deviceId, serviceId) {
-        return new Promise((resolve, reject) => {
-            // Check if connected first
-            if (!this._connectedDevices[deviceId]) {
-                reject(new Error('Device not connected'));
-                return;
-            }
-            BleNitroNative.getCharacteristics(deviceId, BleNitro.normalizeGattUUID(serviceId), (characteristics) => {
-                resolve(BleNitro.normalizeGattUUIDs(characteristics));
-            });
-        });
+        if (!this._connectedDevices[deviceId]) {
+            throw new Error('Device not connected');
+        }
+        const characteristics = BleNitroNative.getCharacteristics(deviceId, BleNitro.normalizeGattUUID(serviceId));
+        return BleNitro.normalizeGattUUIDs(characteristics);
     }
     /**
      * Read a characteristic value
      * @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) => {
@@ -274,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));
@@ -287,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
      */
@@ -298,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);
                 }
@@ -317,29 +316,27 @@ export class BleNitro {
      * @returns Promise resolving when subscription is complete
      */
     subscribeToCharacteristic(deviceId, serviceId, characteristicId, callback) {
-        return new Promise((resolve, reject) => {
-            // Check if connected first
-            if (!this._connectedDevices[deviceId]) {
-                reject(new Error('Device not connected'));
-                return;
+        // Check if connected first
+        if (!this._connectedDevices[deviceId]) {
+            throw new Error('Device not connected');
+        }
+        let _success = false;
+        BleNitroNative.subscribeToCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (charId, data) => {
+            callback(charId, arrayBufferToByteArray(data));
+        }, (success, error) => {
+            _success = success;
+            if (!success) {
+                throw new Error(error);
             }
-            BleNitroNative.subscribeToCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (charId, data) => {
-                callback(charId, data);
-            }, (success, error) => {
-                if (success) {
-                    resolve({
-                        remove: () => {
-                            return new Promise((resolve, reject) => {
-                                this.unsubscribeFromCharacteristic(deviceId, serviceId, characteristicId).then(resolve).catch(reject);
-                            });
-                        },
-                    });
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
         });
+        return {
+            remove: () => {
+                if (!_success) {
+                    return;
+                }
+                this.unsubscribeFromCharacteristic(deviceId, serviceId, characteristicId).catch(() => { });
+            }
+        };
     }
     /**
      * Unsubscribe from characteristic notifications
@@ -370,14 +367,10 @@ export class BleNitro {
      * @returns Promise resolving to Bluetooth state
      */
     isBluetoothEnabled() {
-        return new Promise((resolve) => {
-            BleNitroNative.isBluetoothEnabled((enabled) => {
-                resolve(enabled);
-            });
-        });
+        return this.state() === BLEState.PoweredOn;
     }
     /**
-     * Request to enable Bluetooth
+     * Request to enable Bluetooth (Android only)
      * @returns Promise resolving when Bluetooth is enabled
      */
     requestBluetoothEnable() {
@@ -398,11 +391,7 @@ export class BleNitro {
      * @see BLEState
      */
     state() {
-        return new Promise((resolve) => {
-            BleNitroNative.state((state) => {
-                resolve(mapNativeBLEStateToBLEState(state));
-            });
-        });
+        return mapNativeBLEStateToBLEState(BleNitroNative.state());
     }
     /**
      * Subscribe to Bluetooth state changes
@@ -412,37 +401,18 @@ export class BleNitro {
      * @see BLEState
      */
     subscribeToStateChange(callback, emitInitial = false) {
-        return new Promise(async (resolve, reject) => {
-            if (emitInitial) {
-                const state = await this.state().catch(() => {
-                    return BLEState.Unknown;
-                });
-                callback(state);
-            }
-            BleNitroNative.subscribeToStateChange((nativeState) => {
-                callback(mapNativeBLEStateToBLEState(nativeState));
-            }, (success, error) => {
-                if (success) {
-                    resolve({
-                        remove: () => {
-                            return new Promise((resolve, reject) => {
-                                BleNitroNative.unsubscribeFromStateChange((success, error) => {
-                                    if (success) {
-                                        resolve();
-                                    }
-                                    else {
-                                        reject(new Error(error));
-                                    }
-                                });
-                            });
-                        },
-                    });
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
+        if (emitInitial) {
+            const state = this.state();
+            callback(state);
+        }
+        BleNitroNative.subscribeToStateChange((nativeState) => {
+            callback(mapNativeBLEStateToBLEState(nativeState));
         });
+        return {
+            remove: () => {
+                BleNitroNative.unsubscribeFromStateChange();
+            },
+        };
     }
     /**
      * Open Bluetooth settings

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,15 @@ 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;
+};
 /**
  * Native BLE Nitro Module Specification
  * Defines the interface between TypeScript and native implementations
@@ -46,23 +51,23 @@ export interface NativeBleNitro extends HybridObject<{
     android: 'kotlin';
 }> {
     startScan(filter: ScanFilter, callback: ScanCallback): void;
-    stopScan(callback: OperationCallback): void;
-    isScanning(callback: BooleanCallback): void;
-    getConnectedDevices(callback: DevicesCallback): void;
+    stopScan(): boolean;
+    isScanning(): boolean;
+    getConnectedDevices(services: string[]): BLEDevice[];
     connect(deviceId: string, callback: ConnectionCallback, disconnectCallback?: DisconnectionEventCallback): void;
     disconnect(deviceId: string, callback: OperationCallback): void;
-    isConnected(deviceId: string, callback: BooleanCallback): void;
+    isConnected(deviceId: string): boolean;
+    requestMTU(deviceId: string, mtu: number): number;
     discoverServices(deviceId: string, callback: OperationCallback): void;
-    getServices(deviceId: string, callback: StringArrayCallback): void;
-    getCharacteristics(deviceId: string, serviceId: string, callback: StringArrayCallback): 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;
-    isBluetoothEnabled(callback: BooleanCallback): void;
     requestBluetoothEnable(callback: OperationCallback): void;
-    state(callback: StateCallback): void;
-    subscribeToStateChange(stateCallback: StateCallback, resultCallback: OperationCallback): void;
-    unsubscribeFromStateChange(resultCallback: OperationCallback): void;
+    state(): BLEState;
+    subscribeToStateChange(stateCallback: StateCallback): OperationResult;
+    unsubscribeFromStateChange(): OperationResult;
     openSettings(): Promise<void>;
 }

package/nitrogen/generated/android/BleNitroOnLoad.cpp

@@ -17,14 +17,11 @@
 
 #include "JHybridNativeBleNitroSpec.hpp"
 #include "JFunc_void_BLEDevice.hpp"
-#include "JFunc_void_bool_std__string.hpp"
-#include "JFunc_void_bool.hpp"
-#include "JFunc_void_std__vector_BLEDevice_.hpp"
 #include "JFunc_void_bool_std__string_std__string.hpp"
 #include "JFunc_void_std__string_bool_std__string.hpp"
-#include "JFunc_void_std__vector_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__string.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,14 +36,11 @@ int initialize(JavaVM* 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_bool_std__string_cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_bool_cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_std__vector_BLEDevice__cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_bool_std__string_std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_std__string_bool_std__string_cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_std__vector_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__string_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 {