react-native-ble-nitro 1.4.0 → 1.5.0

package/src/__tests__/index.test.ts

@@ -10,6 +10,7 @@ jest.mock('../specs/NativeBleNitro', () => ({
     disconnect: jest.fn(),
     isConnected: jest.fn(),
     requestMTU: jest.fn(),
+    readRSSI: jest.fn(),
     discoverServices: jest.fn(),
     getServices: jest.fn(),
     getCharacteristics: jest.fn(),
@@ -121,10 +122,66 @@ describe('BleNitro', () => {
   test('writeCharacteristic requires connected device', async () => {
     const data = [1, 2, 3];
     await expect(
-      BleManager.writeCharacteristic('device', 'service', 'char',data)
+      BleManager.writeCharacteristic('device', 'service', 'char', data)
     ).rejects.toThrow('Device not connected');
   });
 
+  test('writeCharacteristic without response returns empty array', async () => {
+    // First connect
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
+      callback(true, id, '');
+    });
+    await BleManager.connect('device-write');
+
+    // Mock writeCharacteristic with new signature (success, responseData, error)
+    mockNative.writeCharacteristic.mockImplementation((_deviceId: string, _serviceId: string, _charId: string, _data: ArrayBuffer, withResponse: boolean, callback: (success: boolean, responseData: ArrayBuffer, error: string) => void) => {
+      // For withResponse=false, return empty ArrayBuffer
+      const emptyBuffer = new ArrayBuffer(0);
+      callback(true, emptyBuffer, '');
+    });
+
+    const data = [1, 2, 3];
+    const result = await BleManager.writeCharacteristic('device-write', 'service', 'char', data, false);
+    
+    expect(mockNative.writeCharacteristic).toHaveBeenCalledWith(
+      'device-write',
+      '0service-0000-1000-8000-00805f9b34fb',
+      '0000char-0000-1000-8000-00805f9b34fb',
+      expect.any(ArrayBuffer),
+      false,
+      expect.any(Function)
+    );
+    expect(result).toEqual([]); // Empty ByteArray for no response
+  });
+
+  test('writeCharacteristic with response returns response data', async () => {
+    // First connect
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
+      callback(true, id, '');
+    });
+    await BleManager.connect('device-write-resp');
+
+    // Mock writeCharacteristic to return response data
+    mockNative.writeCharacteristic.mockImplementation((_deviceId: string, _serviceId: string, _charId: string, _data: ArrayBuffer, withResponse: boolean, callback: (success: boolean, responseData: ArrayBuffer, error: string) => void) => {
+      // For withResponse=true, return some response data
+      const responseData = new Uint8Array([0xAA, 0xBB, 0xCC]).buffer;
+      callback(true, responseData, '');
+    });
+
+    const data = [1, 2, 3];
+    const result = await BleManager.writeCharacteristic('device-write-resp', 'service', 'char', data, true);
+    
+    expect(mockNative.writeCharacteristic).toHaveBeenCalledWith(
+      'device-write-resp',
+      '0service-0000-1000-8000-00805f9b34fb',
+      '0000char-0000-1000-8000-00805f9b34fb',
+      expect.any(ArrayBuffer),
+      true,
+      expect.any(Function)
+    );
+    expect(result).toEqual([0xAA, 0xBB, 0xCC]); // Response data as ByteArray
+  });
+
   test('readCharacteristic works after connection', async () => {
     // First connect
     mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
@@ -220,4 +277,51 @@ describe('BleNitro', () => {
     await new Promise(resolve => setTimeout(resolve, 30));
     expect(onDisconnect).toHaveBeenCalledWith(deviceId, true, 'Connection lost');
   });
+
+  test('readRSSI requires connected device', async () => {
+    await expect(
+      BleManager.readRSSI('device-not-connected')
+    ).rejects.toThrow('Device not connected');
+  });
+
+  test('readRSSI works after connection', async () => {
+    // First connect
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
+      callback(true, id, '');
+    });
+    await BleManager.connect('device-rssi');
+
+    // Mock readRSSI with new signature (success, rssi, error)
+    mockNative.readRSSI.mockImplementation((_deviceId: string, callback: (success: boolean, rssi: number, error: string) => void) => {
+      callback(true, -65, ''); // Mock RSSI value of -65 dBm
+    });
+
+    const rssi = await BleManager.readRSSI('device-rssi');
+    
+    expect(mockNative.readRSSI).toHaveBeenCalledWith(
+      'device-rssi',
+      expect.any(Function)
+    );
+    expect(rssi).toBe(-65);
+  });
+
+  test('readRSSI handles failure', async () => {
+    // First connect
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
+      callback(true, id, '');
+    });
+    await BleManager.connect('device-rssi-fail');
+
+    // Mock readRSSI failure
+    mockNative.readRSSI.mockImplementation((_deviceId: string, callback: (success: boolean, rssi: number, error: string) => void) => {
+      callback(false, 0, 'RSSI read failed');
+    });
+
+    await expect(BleManager.readRSSI('device-rssi-fail')).rejects.toThrow('RSSI read failed');
+    
+    expect(mockNative.readRSSI).toHaveBeenCalledWith(
+      'device-rssi-fail',
+      expect.any(Function)
+    );
+  });
 });

package/src/manager.ts

@@ -73,7 +73,7 @@ export enum AndroidScanMode {
 }
 
 export type BleNitroManagerOptions = {
-  onRestoreState?: RestoreStateCallback;
+  onRestoredState?: RestoreStateCallback;
 };
 
 export function mapNativeBLEStateToBLEState(nativeState: NativeBLEState): BLEState {
@@ -123,29 +123,29 @@ export class BleNitroManager {
   private _isScanning: boolean = false;
   private _connectedDevices: { [deviceId: string]: boolean } = {};
 
-  private _restoreStateCallback: RestoreStateCallback | null = null;
+  private _restoredStateCallback: RestoreStateCallback | null = null;
   private _restoredState: BLEDevice[] | null = null;
 
   constructor(options?: BleNitroManagerOptions) {
-    this._restoreStateCallback = options?.onRestoreState || null;
+    this._restoredStateCallback = options?.onRestoredState || null;
     BleNitroNative.setRestoreStateCallback((peripherals: NativeBLEDevice[]) => this.onNativeRestoreStateCallback(peripherals));
   }
 
   private onNativeRestoreStateCallback(peripherals: NativeBLEDevice[]) {
     const bleDevices = peripherals.map((peripheral) => convertNativeBleDeviceToBleDevice(peripheral));
-    if (this._restoreStateCallback) {
-      this._restoreStateCallback(bleDevices);
+    if (this._restoredStateCallback) {
+      this._restoredStateCallback(bleDevices);
     } else {
       this._restoredState = bleDevices;
     }
   }
 
-  public onRestoreState(callback: RestoreStateCallback) {
+  public onRestoredState(callback: RestoreStateCallback) {
     if (this._restoredState) {
       callback(this._restoredState);
       this._restoredState = null;
     }
-    this._restoreStateCallback = callback;
+    this._restoredStateCallback = callback;
   }
 
   /**
@@ -330,6 +330,32 @@ export class BleNitroManager {
     return deviceMtu;
   }
 
+  /**
+   * Read RSSI for a connected device
+   * @param deviceId ID of the device
+   * @returns Promise resolving to RSSI value
+   */
+  public readRSSI(deviceId: string): Promise<number> {
+    return new Promise((resolve, reject) => {
+      // Check if connected first
+      if (!this._connectedDevices[deviceId]) {
+        reject(new Error('Device not connected'));
+        return;
+      }
+
+      BleNitroNative.readRSSI(
+        deviceId,
+        (success: boolean, rssi: number, error: string) => {
+          if (success) {
+            resolve(rssi);
+          } else {
+            reject(new Error(error));
+          }
+        }
+      );
+    });
+  }
+
   /**
    * Discover services for a connected device
    * @param deviceId ID of the device
@@ -441,7 +467,7 @@ export class BleNitroManager {
    * @param characteristicId ID of the characteristic
    * @param data Data to write as ByteArray (number[])
    * @param withResponse Whether to wait for response
-   * @returns Promise resolving when write is complete
+   * @returns Promise resolving with response data (empty ByteArray when withResponse=false)
    */
   public writeCharacteristic(
     deviceId: string,
@@ -449,7 +475,7 @@ export class BleNitroManager {
     characteristicId: string,
     data: ByteArray,
     withResponse: boolean = true
-  ): Promise<boolean> {
+  ): Promise<ByteArray> {
     return new Promise((resolve, reject) => {
       // Check if connected first
       if (!this._connectedDevices[deviceId]) {
@@ -463,9 +489,11 @@ export class BleNitroManager {
         BleNitroManager.normalizeGattUUID(characteristicId),
         byteArrayToArrayBuffer(data),
         withResponse,
-        (success: boolean, error: string) => {
+        (success: boolean, responseData: ArrayBuffer, error: string) => {
           if (success) {
-            resolve(true);
+            // Convert ArrayBuffer response to ByteArray
+            const responseByteArray = arrayBufferToByteArray(responseData);
+            resolve(responseByteArray);
           } else {
             reject(new Error(error));
           }

package/src/specs/NativeBleNitro.nitro.ts

@@ -55,6 +55,8 @@ export type StateCallback = (state: BLEState) => void;
 export type BooleanCallback = (result: boolean) => void;
 export type StringArrayCallback = (result: string[]) => void;
 export type ReadCharacteristicCallback = (success: boolean, data: BLEValue, error: string) => void;
+export type WriteCharacteristicCallback = (success: boolean, responseData: BLEValue, error: string) => void;
+export type ReadRSSICallback = (success: boolean, rssi: number, error: string) => void;
 export type RestoreCallback = (restoredPeripherals: BLEDevice[]) => void;
 
 export type OperationResult = {
@@ -83,6 +85,7 @@ export interface NativeBleNitro extends HybridObject<{ ios: 'swift'; android: 'k
   disconnect(deviceId: string, callback: OperationCallback): void;
   isConnected(deviceId: string): boolean;
   requestMTU(deviceId: string, mtu: number): number;
+  readRSSI(deviceId: string, callback: ReadRSSICallback): void;
 
   // Service discovery
   discoverServices(deviceId: string, callback: OperationCallback): void;
@@ -91,7 +94,7 @@ export interface NativeBleNitro extends HybridObject<{ ios: 'swift'; android: 'k
 
   // Characteristic operations
   readCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: ReadCharacteristicCallback): void;
-  writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: BLEValue, withResponse: boolean, callback: OperationCallback): void;
+  writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: BLEValue, withResponse: boolean, callback: WriteCharacteristicCallback): void;
   subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, updateCallback: CharacteristicCallback, resultCallback: OperationCallback): void;
   unsubscribeFromCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: OperationCallback): void;