@bota-dev/react-native-sdk 0.0.10 → 0.0.12

package/src/ble/BleManager.ts

@@ -341,7 +341,7 @@ export class BleManager extends EventEmitter<BleManagerEvents> {
         this.emit(
           'deviceDisconnected',
           disconnectedDevice.id,
-          error ? new Error(error.message) : undefined
+          error ? new Error(error.message || 'Device disconnected') : undefined
         );
       });
       this.disconnectSubscriptions.set(deviceId, disconnectSub);
@@ -350,8 +350,9 @@ export class BleManager extends EventEmitter<BleManagerEvents> {
       return device;
     } catch (error) {
       const bleError = error as BleError;
-      log.error('Connection failed', new Error(bleError.message), { deviceId });
-      throw DeviceError.connectionFailed(deviceId, new Error(bleError.message));
+      const msg = bleError.message || 'Connection failed';
+      log.error('Connection failed', new Error(msg), { deviceId });
+      throw DeviceError.connectionFailed(deviceId, new Error(msg));
     }
   }
 
@@ -436,16 +437,17 @@ export class BleManager extends EventEmitter<BleManagerEvents> {
       return Buffer.from(characteristic.value, 'base64');
     } catch (error) {
       const bleError = error as BleError;
-      log.error('Read characteristic failed', new Error(bleError.message), {
+      const msg = bleError.message || 'Unknown BLE error';
+      log.error('Read characteristic failed', new Error(msg), {
         deviceId,
         serviceUuid,
         characteristicUuid,
       });
       throw new DeviceError(
-        `Failed to read characteristic: ${bleError.message}`,
+        `Failed to read characteristic: ${msg}`,
         'READ_FAILED',
         deviceId,
-        new Error(bleError.message)
+        new Error(msg)
       );
     }
   }
@@ -483,16 +485,17 @@ export class BleManager extends EventEmitter<BleManagerEvents> {
       }
     } catch (error) {
       const bleError = error as BleError;
-      log.error('Write characteristic failed', new Error(bleError.message), {
+      const msg = bleError.message || 'Unknown BLE error';
+      log.error('Write characteristic failed', new Error(msg), {
         deviceId,
         serviceUuid,
         characteristicUuid,
       });
       throw new DeviceError(
-        `Failed to write characteristic: ${bleError.message}`,
+        `Failed to write characteristic: ${msg}`,
         'WRITE_FAILED',
         deviceId,
-        new Error(bleError.message)
+        new Error(msg)
       );
     }
   }
@@ -521,7 +524,9 @@ export class BleManager extends EventEmitter<BleManagerEvents> {
           const errorMessage = error.message || 'Unknown BLE error';
           const isCancelled = errorMessage.includes('cancelled') ||
                               errorMessage.includes('disconnected') ||
-                              error.errorCode === 2; // BleErrorCode.OperationCancelled
+                              error.errorCode === 2 || // BleErrorCode.OperationCancelled
+                              error.errorCode === 201 || // BleErrorCode.DeviceDisconnected
+                              !this.connectedDevices.has(deviceId); // Device already removed
 
           if (!isCancelled) {
             log.error('Notification error', new Error(errorMessage), {

package/src/ble/constants.ts

@@ -126,6 +126,7 @@ export const ACK_TYPE_NACK = 0x11;
 export const ACK_TYPE_ABORT = 0x12;
 
 // Device command values
+export const DEVICE_CMD_FACTORY_RESET = 0x01;
 export const DEVICE_CMD_ENTER_DFU = 0x03;
 
 // Recording control opcodes (for remote start/stop)

package/src/ble/parsers.ts

@@ -154,7 +154,8 @@ export function parseDeviceFlags(value: number): DeviceFlags {
  * Byte 3:      Pending recordings count
  * Bytes 4-7:   Last sync timestamp (Unix seconds)
  * Byte 8:      Flags (1-byte bitmask)
- * Bytes 9-11:  Reserved
+ * Bytes 9-10:  Storage total MB (uint16LE)
+ * Byte 11:     Reserved
  */
 export function parseDeviceStatus(data: Buffer): DeviceStatus {
   if (data.length < 12) {
@@ -168,10 +169,12 @@ export function parseDeviceStatus(data: Buffer): DeviceStatus {
   const lastSyncTimestamp = data.readUInt32LE(4);
   const flagsValue = data.readUInt8(8);
   const flags = parseDeviceFlags(flagsValue);
+  const storageTotalMb = data.readUInt16LE(9);
 
   return {
     batteryLevel,
     storageUsedPercent,
+    storageTotalMb,
     state,
     pendingRecordings,
     lastSyncAt: lastSyncTimestamp > 0 ? new Date(lastSyncTimestamp * 1000) : null,

package/src/managers/DeviceManager.ts

@@ -40,6 +40,8 @@ import {
   RECORDING_RESULT_NOT_RECORDING,
   RECORDING_RESULT_INVALID_GRANT,
   RECORDING_RESULT_GRANT_EXPIRED,
+  CHAR_DEVICE_COMMAND,
+  DEVICE_CMD_FACTORY_RESET,
 } from '../ble/constants';
 import {
   parsePairingState,
@@ -247,6 +249,37 @@ export class DeviceManager extends EventEmitter<DeviceManagerEvents> {
     this.emit('connectionStateChanged', device.id, 'disconnected');
   }
 
+  /**
+   * Send factory reset command to a device.
+   * Clears stored token and recordings on the device.
+   * Device returns to unpaired state after this.
+   */
+  async factoryReset(device: ConnectedDevice): Promise<void> {
+    log.info('Sending factory reset to device', { deviceId: device.id });
+
+    if (!this.isConnected(device.id)) {
+      throw DeviceError.notConnected(device.id);
+    }
+
+    const resultPromise = this.waitForProvisioningResult(device.id);
+
+    await this.bleManager.writeCharacteristic(
+      device.id,
+      SERVICE_BOTA_CONTROL,
+      CHAR_DEVICE_COMMAND,
+      Buffer.from([DEVICE_CMD_FACTORY_RESET])
+    );
+
+    try {
+      await resultPromise;
+    } catch {
+      // Timeout is acceptable — device may disconnect before responding
+      log.warn('Factory reset result not received (device may have disconnected)');
+    }
+
+    log.info('Factory reset sent', { deviceId: device.id });
+  }
+
   /**
    * Check if a device is connected
    */

package/src/models/Device.ts

@@ -117,6 +117,8 @@ export interface DeviceStatus {
   batteryLevel: number;
   /** Storage used percentage (0-100) */
   storageUsedPercent: number;
+  /** Total storage capacity in MB (from firmware, uint16LE, max 65535) */
+  storageTotalMb: number;
   /** Current operational state */
   state: DeviceState;
   /** Number of pending recordings to sync */