react-native-ble-nitro 1.0.0 → 1.2.0

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,11 +45,11 @@ export type DisconnectEventCallback = (
 export type OperationCallback = (success: boolean, error: string) => void;
 export type CharacteristicUpdateCallback = (
   characteristicId: string,
-  data: number[]
+  data: ByteArray
 ) => void;
 
 export type Subscription = {
-  remove: () => Promise<void>;
+  remove: () => void;
 };
 
 export enum BLEState {
@@ -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 {
@@ -117,85 +127,78 @@ export class BleNitro {
   public startScan(
     filter: ScanFilter = {},
     callback: ScanCallback
-  ): Promise<boolean> {
-    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: NativeScanFilter = {
-        serviceUUIDs: filter.serviceUUIDs || [],
-        rssiThreshold: filter.rssiThreshold ?? -100,
-        allowDuplicates: filter.allowDuplicates ?? false,
-      };
+  ): void {
+    if (this._isScanning) {
+      return;
+    }
 
-      // Create callback wrapper
-      const scanCallback = (device: NativeBLEDevice) => {
-        device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
-        callback(device);
+    // Create native scan filter with defaults
+    const nativeFilter: NativeScanFilter = {
+      serviceUUIDs: filter.serviceUUIDs || [],
+      rssiThreshold: filter.rssiThreshold ?? -100,
+      allowDuplicates: filter.allowDuplicates ?? false,
+    };
+
+    // Create callback wrapper
+    const scanCallback = (device: NativeBLEDevice) => {
+      // 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
-      BleNitroNative.startScan(nativeFilter, scanCallback);
-      this._isScanning = true;
-      resolve(true);
-    });
+    // Start scan
+    BleNitroNative.startScan(nativeFilter, scanCallback);
+    this._isScanning = true;
   }
 
   /**
    * Stop scanning for Bluetooth devices
    * @returns Promise resolving to success state
    */
-  public stopScan(): Promise<boolean> {
-    return new Promise((resolve, reject) => {
-      // Don't stop scanning if not scanning
-      if (!this._isScanning) {
-        resolve(true);
-        return;
-      }
+  public stopScan(): void {
+    if (!this._isScanning) {
+      return;
+    }
 
-      BleNitroNative.stopScan((success: boolean, error: string) => {
-        if (success) {
-          this._isScanning = false;
-          resolve(true);
-        } else {
-          reject(new Error(error));
-        }
-      });
-    });
+    BleNitroNative.stopScan();
   }
 
   /**
    * Check if currently scanning for devices
    * @returns Promise resolving to scanning state
    */
-  public isScanning(): Promise<boolean> {
-    return new Promise((resolve) => {
-      BleNitroNative.isScanning((scanning: boolean) => {
-        this._isScanning = scanning;
-        resolve(scanning);
-      });
-    });
+  public isScanning(): boolean {
+    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
    */
-  public getConnectedDevices(): Promise<BLEDevice[]> {
-    return new Promise((resolve) => {
-      BleNitroNative.getConnectedDevices((devices: BLEDevice[]) => {
-        // Normalize service UUIDs for connected devices
-        const normalizedDevices = devices.map(device => ({
-          ...device,
-          serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs)
-        }));
-        resolve(normalizedDevices);
-      });
-    });
+  public getConnectedDevices(services?: string[]): BLEDevice[] {
+    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)
+        }))
+      }
+    }));
   }
 
   /**
@@ -239,11 +242,11 @@ export class BleNitro {
    * @param deviceId ID of the device to disconnect from
    * @returns Promise resolving when disconnected
    */
-  public disconnect(deviceId: string): Promise<boolean> {
+  public disconnect(deviceId: string): Promise<void> {
     return new Promise((resolve, reject) => {
       // Check if already disconnected
       if (!this._connectedDevices[deviceId]) {
-        resolve(true);
+        resolve();
         return;
       }
 
@@ -252,7 +255,7 @@ export class BleNitro {
         (success: boolean, error: string) => {
           if (success) {
             delete this._connectedDevices[deviceId];
-            resolve(true);
+            resolve();
           } else {
             reject(new Error(error));
           }
@@ -266,13 +269,20 @@ export class BleNitro {
    * @param deviceId ID of the device to check
    * @returns Promise resolving to connection state
    */
-  public isConnected(deviceId: string): Promise<boolean> {
-    return new Promise((resolve) => {
-      BleNitroNative.isConnected(deviceId, (connected: boolean) => {
-        this._connectedDevices[deviceId] = connected;
-        resolve(connected);
-      });
-    });
+  public isConnected(deviceId: string): boolean {
+    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;
   }
 
   /**
@@ -319,9 +329,8 @@ export class BleNitro {
         reject(new Error('Failed to discover services'));
         return;
       }
-      BleNitroNative.getServices(deviceId, (services: string[]) => {
-        resolve(BleNitro.normalizeGattUUIDs(services));
-      });
+      const services = BleNitroNative.getServices(deviceId);
+      resolve(BleNitro.normalizeGattUUIDs(services));
     });
   }
 
@@ -334,22 +343,16 @@ export class BleNitro {
   public getCharacteristics(
     deviceId: string,
     serviceId: string
-  ): Promise<string[]> {
-    return new Promise((resolve, reject) => {
-      // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
-        reject(new Error('Device not connected'));
-        return;
-      }
+  ): string[] {
+    if (!this._connectedDevices[deviceId]) {
+      throw new Error('Device not connected');
+    }
 
-      BleNitroNative.getCharacteristics(
-        deviceId,
-        BleNitro.normalizeGattUUID(serviceId),
-        (characteristics: string[]) => {
-          resolve(BleNitro.normalizeGattUUIDs(characteristics));
-        }
-      );
-    });
+    const characteristics = BleNitroNative.getCharacteristics(
+      deviceId,
+      BleNitro.normalizeGattUUID(serviceId),
+    );
+    return BleNitro.normalizeGattUUIDs(characteristics);
   }
 
   /**
@@ -357,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]) {
@@ -375,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));
           }
@@ -391,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
    */
@@ -399,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) => {
@@ -409,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) {
@@ -439,40 +444,41 @@ export class BleNitro {
     serviceId: string,
     characteristicId: string,
     callback: CharacteristicUpdateCallback
-  ): Promise<Subscription> {
-    return new Promise((resolve, reject) => {
-      // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
-        reject(new Error('Device not connected'));
-        return;
+  ): Subscription {
+    // 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: string, data: ArrayBuffer) => {
+        callback(charId, arrayBufferToByteArray(data));
+      },
+      (success, error) => {
+        _success = success;
+        if (!success) {
+          throw new Error(error);
+        }
       }
+    );
 
-      BleNitroNative.subscribeToCharacteristic(
-        deviceId,
-        BleNitro.normalizeGattUUID(serviceId),
-        BleNitro.normalizeGattUUID(characteristicId),
-        (charId: string, data: number[]) => {
-          callback(charId, data);
-        },
-        (success: boolean, error: string) => {
-          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(() => {});
+      }
+    };
   }
 
   /**
@@ -513,16 +519,12 @@ export class BleNitro {
    * Check if Bluetooth is enabled
    * @returns Promise resolving to Bluetooth state
    */
-  public isBluetoothEnabled(): Promise<boolean> {
-    return new Promise((resolve) => {
-      BleNitroNative.isBluetoothEnabled((enabled: boolean) => {
-        resolve(enabled);
-      });
-    });
+  public isBluetoothEnabled(): boolean {
+    return this.state() === BLEState.PoweredOn;
   }
 
   /**
-   * Request to enable Bluetooth
+   * Request to enable Bluetooth (Android only)
    * @returns Promise resolving when Bluetooth is enabled
    */
   public requestBluetoothEnable(): Promise<boolean> {
@@ -544,12 +546,8 @@ export class BleNitro {
    * @returns Promise resolving to Bluetooth state
    * @see BLEState
    */
-  public state(): Promise<BLEState> {
-    return new Promise((resolve) => {
-      BleNitroNative.state((state: NativeBLEState) => {
-        resolve(mapNativeBLEStateToBLEState(state));
-      });
-    });
+  public state(): BLEState {
+    return mapNativeBLEStateToBLEState(BleNitroNative.state());
   }
 
   /**
@@ -559,36 +557,21 @@ export class BleNitro {
    * @returns Promise resolving when subscription is complete
    * @see BLEState
    */
-  public subscribeToStateChange(callback: (state: BLEState) => void, emitInitial = false): Promise<Subscription> {
-    return new Promise(async (resolve, reject) => {
+  public subscribeToStateChange(callback: (state: BLEState) => void, emitInitial = false): Subscription {
       if (emitInitial) {
-        const state = await this.state().catch(() => {
-          return BLEState.Unknown;
-        });
+        const state = this.state();
         callback(state);
       }
+
       BleNitroNative.subscribeToStateChange((nativeState: NativeBLEState) => {
         callback(mapNativeBLEStateToBLEState(nativeState));
-      }, (success: boolean, error: string) => {
-        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));
-        }
       });
-    })
+
+      return {
+        remove: () => {
+          BleNitroNative.unsubscribeFromStateChange();
+        },
+      };
   }
 
   /**

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,16 @@ 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
@@ -52,33 +60,33 @@ export type ReadCharacteristicCallback = (success: boolean, data: number[], erro
 export interface NativeBleNitro extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
   // Scanning operations
   startScan(filter: ScanFilter, callback: ScanCallback): void;
-  stopScan(callback: OperationCallback): void;
-  isScanning(callback: BooleanCallback): void;
+  stopScan(): boolean;
+  isScanning(): boolean;
 
   // Device discovery
-  getConnectedDevices(callback: DevicesCallback): void;
+  getConnectedDevices(services: string[]): BLEDevice[];
 
   // Connection management
   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;
 
   // Service discovery
   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[];
 
   // 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;
 
   // Bluetooth state management
-  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/c++/JFunc_void_bool.hpp

@@ -1,74 +0,0 @@
-///
-/// JFunc_void_bool.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 <functional>
-
-namespace margelo::nitro::co::zyke::ble {
-
-  using namespace facebook;
-
-  /**
-   * Represents the Java/Kotlin callback `(result: Boolean) -> Unit`.
-   * This can be passed around between C++ and Java/Kotlin.
-   */
-  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool;";
-
-  public:
-    /**
-     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
-     */
-    void invoke(bool result) const {
-      static const auto method = javaClassStatic()->getMethod<void(jboolean /* result */)>("invoke");
-      method(self(), result);
-    }
-  };
-
-  /**
-   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
-   */
-  struct JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
-  public:
-    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* result */)>& func) {
-      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
-    }
-
-  public:
-    /**
-     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
-     */
-    void invoke_cxx(jboolean result) {
-      _func(static_cast<bool>(result));
-    }
-
-  public:
-    [[nodiscard]]
-    inline const std::function<void(bool /* result */)>& getFunction() const {
-      return _func;
-    }
-
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_cxx;";
-    static void registerNatives() {
-      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
-    }
-
-  private:
-    explicit JFunc_void_bool_cxx(const std::function<void(bool /* result */)>& func): _func(func) { }
-
-  private:
-    friend HybridBase;
-    std::function<void(bool /* result */)> _func;
-  };
-
-} // namespace margelo::nitro::co::zyke::ble