react-native-ble-nitro 1.10.3 → 1.12.0

package/src/manager.ts

@@ -7,6 +7,25 @@ import {
   AndroidScanMode as NativeAndroidScanMode,
 } from './specs/NativeBleNitro';
 
+export class BleTimeoutError extends Error {
+  constructor(operation: string, ms: number) {
+    super(`${operation} timed out after ${ms}ms`);
+    this.name = 'BleTimeoutError';
+  }
+}
+
+function withTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+  operation: string
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout>;
+  const timeout = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => reject(new BleTimeoutError(operation, ms)), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
 export type ByteArray = number[];
 
 export interface ScanFilter {
@@ -127,7 +146,6 @@ export function byteArrayToArrayBuffer(data: ByteArray): ArrayBuffer {
 
 export class BleNitroManager {
   private _isScanning: boolean = false;
-  private _connectedDevices: { [deviceId: string]: boolean } = {};
 
   private _restoredStateCallback: RestoreStateCallback | null;
   private _restoredState: BLEDevice[] | null = null;
@@ -144,9 +162,6 @@ export class BleNitroManager {
   private onNativeRestoreStateCallback(peripherals: NativeBLEDevice[]) {
     if (!this._restoreStateIdentifier) return;
     const bleDevices = peripherals.map((peripheral) => convertNativeBleDeviceToBleDevice(peripheral));
-    bleDevices.forEach((device) => {
-      this._connectedDevices[device.id] = device.isConnected;
-    });
     if (this._restoredStateCallback) {
       this._restoredStateCallback(bleDevices);
     } else {
@@ -289,7 +304,7 @@ export class BleNitroManager {
   ): Promise<string> {
     return new Promise((resolve, reject) => {
       // Check if already connected
-      if (this._connectedDevices[deviceId]) {
+      if (this.isConnected(deviceId)) {
         resolve(deviceId);
         return;
       }
@@ -298,15 +313,12 @@ export class BleNitroManager {
         deviceId,
         (success: boolean, connectedDeviceId: string, error: string) => {
           if (success) {
-            this._connectedDevices[deviceId] = true;
             resolve(connectedDeviceId);
           } else {
             reject(new Error(error));
           }
         },
         onDisconnect ? (deviceId: string, interrupted: boolean, error: string) => {
-          // Remove from connected devices when disconnected
-          delete this._connectedDevices[deviceId];
           onDisconnect(deviceId, interrupted, error);
         } : undefined,
         autoConnectAndroid ?? false,
@@ -321,8 +333,7 @@ export class BleNitroManager {
    * @returns Promise resolving deviceId when connected
    */
   public findAndConnect(deviceId: string, options?: { scanTimeout?: number, autoConnectAndroid?: boolean, onDisconnect?: DisconnectEventCallback, onFound?: (device: BLEDevice) => void }): Promise<string> {
-    const isConnected = this.isConnected(deviceId);
-    if (isConnected) {
+    if (this.isConnected(deviceId)) {
       return Promise.resolve(deviceId);
     }
     if (this._isScanning) {
@@ -351,14 +362,13 @@ export class BleNitroManager {
   /**
    * Disconnect from a Bluetooth device
    * @param deviceId ID of the device to disconnect from
-   * @returns Promise resolving when disconnected
+   * @returns Promise resolving with devices uuid or mac address when disconnected
    */
-  public disconnect(deviceId: string): Promise<void> {
+  public disconnect(deviceId: string): Promise<string> {
     return new Promise((resolve, reject) => {
       // Check if already disconnected
-      if (!this._connectedDevices[deviceId] || !this.isConnected(deviceId)) {
-        delete this._connectedDevices[deviceId];
-        resolve();
+      if (!this.isConnected(deviceId)) {
+        resolve(deviceId);
         return;
       }
 
@@ -366,8 +376,7 @@ export class BleNitroManager {
         deviceId,
         (success: boolean, error: string) => {
           if (success) {
-            delete this._connectedDevices[deviceId];
-            resolve();
+            resolve(deviceId);
           } else {
             reject(new Error(error));
           }
@@ -405,7 +414,7 @@ export class BleNitroManager {
   public readRSSI(deviceId: string): Promise<number> {
     return new Promise((resolve, reject) => {
       // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
+      if (!this.isConnected(deviceId)) {
         reject(new Error('Device not connected'));
         return;
       }
@@ -431,7 +440,7 @@ export class BleNitroManager {
   public discoverServices(deviceId: string): Promise<boolean> {
     return new Promise((resolve, reject) => {
       // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
+      if (!this.isConnected(deviceId)) {
         reject(new Error('Device not connected'));
         return;
       }
@@ -457,7 +466,7 @@ export class BleNitroManager {
   public getServices(deviceId: string): Promise<string[]> {
     return new Promise(async (resolve, reject) => {
       // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
+      if (!this.isConnected(deviceId)) {
         reject(new Error('Device not connected'));
         return;
       }
@@ -482,7 +491,7 @@ export class BleNitroManager {
     deviceId: string,
     serviceId: string
   ): string[] {
-    if (!this._connectedDevices[deviceId]) {
+    if (!this.isConnected(deviceId)) {
       throw new Error('Device not connected');
     }
 
@@ -494,21 +503,53 @@ export class BleNitroManager {
   }
 
   /**
-   * Get services and characteristics for a connected device
+   * Get services and characteristics for a connected device.
+   * Uses a native method that waits for both service and characteristic
+   * discovery to complete before reading, avoiding the CoreBluetooth race
+   * where didDiscoverServices may not re-fire for cached services.
    * @param deviceId ID of the device
    * @returns Promise resolving to array of service and characteristic UUIDs
    * @see getServices
    * @see getCharacteristics
    */
-  public async getServicesWithCharacteristics(deviceId: string): Promise<{ uuid: string; characteristics: string[] }[]> {
-    await this.discoverServices(deviceId);
-    const services = await this.getServices(deviceId);
-    return services.map((service) => {
-      return {
-        uuid: service,
-        characteristics: this.getCharacteristics(deviceId, service),
-      };
+  public async getServicesWithCharacteristics(
+    deviceId: string
+  ): Promise<{ uuid: string; characteristics: string[] }[]> {
+    await this._discoverServicesWithCharacteristics(deviceId);
+
+    const services = this.Instance.getServices(deviceId);
+    return BleNitroManager.normalizeGattUUIDs(services).map((service) => ({
+      uuid: service,
+      characteristics: this.getCharacteristics(deviceId, service),
+    }));
+  }
+
+  private static readonly DISCOVERY_TIMEOUT_MS = 30_000;
+
+  private _discoverServicesWithCharacteristics(
+    deviceId: string
+  ): Promise<void> {
+    const inner = new Promise<void>((resolve, reject) => {
+      if (!this.isConnected(deviceId)) {
+        reject(new Error('Device not connected'));
+        return;
+      }
+      this.Instance.discoverServicesWithCharacteristics(
+        deviceId,
+        (success: boolean, error: string) => {
+          if (success) {
+            resolve();
+          } else {
+            reject(new Error(error));
+          }
+        }
+      );
     });
+    return withTimeout(
+      inner,
+      BleNitroManager.DISCOVERY_TIMEOUT_MS,
+      'discoverServicesWithCharacteristics'
+    );
   }
 
   /**
@@ -525,7 +566,7 @@ export class BleNitroManager {
   ): Promise<ByteArray> {
     return new Promise((resolve, reject) => {
       // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
+      if (!this.isConnected(deviceId)) {
         reject(new Error('Device not connected'));
         return;
       }
@@ -563,7 +604,7 @@ export class BleNitroManager {
   ): Promise<ByteArray> {
     return new Promise((resolve, reject) => {
       // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
+      if (!this.isConnected(deviceId)) {
         reject(new Error('Device not connected'));
         return;
       }
@@ -603,7 +644,7 @@ export class BleNitroManager {
   ): Promise<AsyncSubscription> {
     return new Promise((resolve, reject) => {
       // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
+      if (!this.isConnected(deviceId)) {
         reject(new Error('Device not connected'));
         return;
       }
@@ -651,7 +692,7 @@ export class BleNitroManager {
   ): Promise<void> {
     return new Promise((resolve, reject) => {
       // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
+      if (!this.isConnected(deviceId)) {
         reject(new Error('Device not connected'));
         return;
       }
@@ -671,6 +712,27 @@ export class BleNitroManager {
     });
   }
 
+  /**
+   * Check if currently subscribed to a characteristic's notifications
+   * @param deviceId ID of the device
+   * @param serviceId ID of the service
+   * @param characteristicId ID of the characteristic
+   * @returns Boolean indicating if subscribed to notifications
+   */
+  public isSubscribedToCharacteristic(
+    deviceId: string,
+    serviceId: string,
+    characteristicId: string
+  ): boolean {
+    // No isConnected guard — both native implementations already return false
+    // for disconnected devices, and an extra check would introduce a TOCTOU race.
+    return this.Instance.isSubscribedToCharacteristic(
+      deviceId,
+      BleNitroManager.normalizeGattUUID(serviceId),
+      BleNitroManager.normalizeGattUUID(characteristicId)
+    );
+  }
+
   /**
    * Check if Bluetooth is enabled
    * @returns returns Boolean according to Bluetooth state

package/src/specs/NativeBleNitro.nitro.ts

@@ -92,6 +92,8 @@ export interface NativeBleNitro extends HybridObject<{ ios: 'swift'; android: 'k
 
   // Service discovery
   discoverServices(deviceId: string, callback: OperationCallback): void;
+  /** Discover services and wait for all characteristic discovery to complete before resolving. */
+  discoverServicesWithCharacteristics(deviceId: string, callback: OperationCallback): void;
   getServices(deviceId: string): string[];
   getCharacteristics(deviceId: string, serviceId: string): string[];
 
@@ -100,6 +102,7 @@ export interface NativeBleNitro extends HybridObject<{ ios: 'swift'; android: 'k
   writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: BLEValue, withResponse: boolean, callback: WriteCharacteristicCallback): void;
   subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, updateCallback: CharacteristicCallback, completionCallback: OperationCallback): void;
   unsubscribeFromCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: OperationCallback): void;
+  isSubscribedToCharacteristic(deviceId: string, serviceId: string, characteristicId: string): boolean;
 
   // Bluetooth state management
   requestBluetoothEnable(callback: OperationCallback): void;