@bota-dev/react-native-sdk 0.0.2

package/src/managers/OTAManager.ts

@@ -0,0 +1,263 @@
+/**
+ * OTA Manager - Handles firmware over-the-air updates
+ *
+ * Note: Full Nordic DFU implementation requires native modules.
+ * This is a placeholder that handles version checking and update preparation.
+ * Actual DFU transfer would need react-native-nordic-dfu or similar.
+ */
+
+import EventEmitter from 'eventemitter3';
+
+import { getBleManager } from '../ble/BleManager';
+import {
+  SERVICE_BOTA_CONTROL,
+  CHAR_DEVICE_COMMAND,
+  DEVICE_CMD_ENTER_DFU,
+} from '../ble/constants';
+import type { ConnectedDevice } from '../models/Device';
+import { DeviceError } from '../utils/errors';
+import { logger } from '../utils/logger';
+import { Buffer } from 'buffer';
+
+const log = logger.tag('OTAManager');
+
+/**
+ * Firmware info
+ */
+export interface FirmwareInfo {
+  version: string;
+  url: string;
+  checksum: string;
+  releaseNotes?: string;
+  size: number;
+}
+
+/**
+ * OTA progress stages
+ */
+export type OtaStage =
+  | 'checking'
+  | 'downloading'
+  | 'preparing'
+  | 'updating'
+  | 'verifying'
+  | 'completed'
+  | 'failed';
+
+/**
+ * OTA progress
+ */
+export interface OtaProgress {
+  stage: OtaStage;
+  progress: number;
+  error?: string;
+}
+
+/**
+ * Events emitted by OTAManager
+ */
+interface OTAManagerEvents {
+  updateAvailable: (firmware: FirmwareInfo) => void;
+  progress: (deviceId: string, progress: OtaProgress) => void;
+  completed: (deviceId: string, version: string) => void;
+  failed: (deviceId: string, error: Error) => void;
+}
+
+/**
+ * OTA Manager class
+ */
+export class OTAManager extends EventEmitter<OTAManagerEvents> {
+  private firmwareCdnUrl: string;
+
+  constructor(firmwareCdnUrl: string = 'https://cdn.bota.dev/firmware') {
+    super();
+    this.firmwareCdnUrl = firmwareCdnUrl;
+  }
+
+  /**
+   * Check for available firmware updates
+   */
+  async checkForUpdate(device: ConnectedDevice): Promise<FirmwareInfo | null> {
+    log.info('Checking for firmware update', {
+      deviceId: device.id,
+      currentVersion: device.firmwareVersion,
+      deviceType: device.deviceType,
+    });
+
+    this.emit('progress', device.id, { stage: 'checking', progress: 0 });
+
+    try {
+      // Fetch latest firmware info from CDN
+      const response = await fetch(
+        `${this.firmwareCdnUrl}/latest?device_type=${device.deviceType}&current=${device.firmwareVersion}`
+      );
+
+      if (!response.ok) {
+        if (response.status === 404) {
+          log.info('No update available', { deviceId: device.id });
+          return null;
+        }
+        throw new Error(`Failed to check for updates: ${response.status}`);
+      }
+
+      const firmware = (await response.json()) as FirmwareInfo;
+
+      // Compare versions
+      if (this.isNewerVersion(firmware.version, device.firmwareVersion)) {
+        log.info('Update available', {
+          deviceId: device.id,
+          currentVersion: device.firmwareVersion,
+          newVersion: firmware.version,
+        });
+
+        this.emit('updateAvailable', firmware);
+        return firmware;
+      }
+
+      log.info('Device is up to date', {
+        deviceId: device.id,
+        version: device.firmwareVersion,
+      });
+
+      return null;
+    } catch (error) {
+      log.error('Failed to check for update', error as Error, {
+        deviceId: device.id,
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Download firmware package
+   */
+  async downloadFirmware(firmware: FirmwareInfo): Promise<ArrayBuffer> {
+    log.info('Downloading firmware', {
+      version: firmware.version,
+      size: firmware.size,
+    });
+
+    const response = await fetch(firmware.url);
+
+    if (!response.ok) {
+      throw new Error(`Failed to download firmware: ${response.status}`);
+    }
+
+    const data = await response.arrayBuffer();
+
+    // Verify checksum
+    // Note: In production, implement proper checksum verification
+    log.info('Firmware downloaded', { size: data.byteLength });
+
+    return data;
+  }
+
+  /**
+   * Prepare device for DFU mode
+   */
+  async enterDfuMode(device: ConnectedDevice): Promise<void> {
+    if (!getBleManager().isConnected(device.id)) {
+      throw DeviceError.notConnected(device.id);
+    }
+
+    log.info('Entering DFU mode', { deviceId: device.id });
+
+    // Send DFU command to device
+    await getBleManager().writeCharacteristic(
+      device.id,
+      SERVICE_BOTA_CONTROL,
+      CHAR_DEVICE_COMMAND,
+      Buffer.from([DEVICE_CMD_ENTER_DFU])
+    );
+
+    // Device will disconnect and reboot into DFU mode
+    log.info('DFU command sent, device will reboot', { deviceId: device.id });
+  }
+
+  /**
+   * Perform firmware update
+   *
+   * Note: This is a placeholder. Full implementation requires:
+   * 1. react-native-nordic-dfu for actual DFU transfer
+   * 2. Native module integration
+   * 3. DFU package preparation
+   */
+  async performUpdate(
+    device: ConnectedDevice,
+    firmware: FirmwareInfo
+  ): Promise<void> {
+    log.info('Starting firmware update', {
+      deviceId: device.id,
+      version: firmware.version,
+    });
+
+    this.emit('progress', device.id, { stage: 'downloading', progress: 0 });
+
+    try {
+      // Download firmware
+      await this.downloadFirmware(firmware);
+
+      this.emit('progress', device.id, { stage: 'downloading', progress: 1 });
+      this.emit('progress', device.id, { stage: 'preparing', progress: 0 });
+
+      // Enter DFU mode
+      await this.enterDfuMode(device);
+
+      this.emit('progress', device.id, { stage: 'preparing', progress: 1 });
+
+      // Note: At this point, we would use react-native-nordic-dfu
+      // to perform the actual firmware transfer.
+      // For now, we throw an error indicating this needs native implementation.
+
+      throw new Error(
+        'Full DFU implementation requires react-native-nordic-dfu native module. ' +
+        'Device has entered DFU mode and is advertising as "BotaDFU-xxx".'
+      );
+
+      // After DFU completes:
+      // this.emit('progress', device.id, { stage: 'completed', progress: 1 });
+      // this.emit('completed', device.id, firmware.version);
+    } catch (error) {
+      const err = error as Error;
+      log.error('Firmware update failed', err, { deviceId: device.id });
+
+      this.emit('progress', device.id, {
+        stage: 'failed',
+        progress: 0,
+        error: err.message,
+      });
+      this.emit('failed', device.id, err);
+
+      throw error;
+    }
+  }
+
+  /**
+   * Compare semantic versions
+   */
+  private isNewerVersion(newVersion: string, currentVersion: string): boolean {
+    const parseVersion = (v: string): number[] => {
+      return v.split('.').map((n) => parseInt(n, 10) || 0);
+    };
+
+    const newParts = parseVersion(newVersion);
+    const currentParts = parseVersion(currentVersion);
+
+    for (let i = 0; i < Math.max(newParts.length, currentParts.length); i++) {
+      const newPart = newParts[i] || 0;
+      const currentPart = currentParts[i] || 0;
+
+      if (newPart > currentPart) return true;
+      if (newPart < currentPart) return false;
+    }
+
+    return false;
+  }
+
+  /**
+   * Clean up resources
+   */
+  destroy(): void {
+    this.removeAllListeners();
+  }
+}

package/src/managers/RecordingManager.ts

@@ -0,0 +1,434 @@
+/**
+ * Recording Manager - Handles recording sync and upload operations
+ */
+
+import EventEmitter from 'eventemitter3';
+
+import { ProtocolHandler } from '../protocol/ProtocolHandler';
+import { StorageManager } from '../storage/StorageManager';
+import { UploadQueue } from '../upload/UploadQueue';
+import type { ConnectedDevice, StorageInfo } from '../models/Device';
+import type {
+  DeviceRecording,
+  UploadInfo,
+  SyncProgress,
+  UploadTask,
+} from '../models/Recording';
+import type { RecordingManagerEvents } from '../models/Status';
+import { DeviceError } from '../utils/errors';
+import { logger } from '../utils/logger';
+import { getBleManager } from '../ble/BleManager';
+
+const log = logger.tag('RecordingManager');
+
+/**
+ * Upload info provider callback type
+ */
+export type UploadInfoProvider = (
+  recording: DeviceRecording
+) => Promise<UploadInfo>;
+
+/**
+ * Recording Manager class
+ */
+export class RecordingManager extends EventEmitter<RecordingManagerEvents> {
+  private protocolHandler: ProtocolHandler;
+  private storage: StorageManager;
+  private uploadQueue: UploadQueue;
+  private isInitialized = false;
+
+  constructor() {
+    super();
+    this.protocolHandler = new ProtocolHandler();
+    this.storage = new StorageManager();
+    this.uploadQueue = new UploadQueue(this.storage, { autoStart: false });
+
+    this.setupUploadQueueListeners();
+  }
+
+  /**
+   * Initialize the recording manager
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    await this.storage.initialize();
+    this.isInitialized = true;
+
+    // Start processing any pending uploads
+    this.uploadQueue.resume();
+
+    log.info('RecordingManager initialized');
+  }
+
+  /**
+   * Set up upload queue event listeners
+   */
+  private setupUploadQueueListeners(): void {
+    this.uploadQueue.on('taskAdded', () => {
+      this.emit('queueUpdated', this.uploadQueue.getAllTasks());
+    });
+
+    this.uploadQueue.on('taskUpdated', () => {
+      this.emit('queueUpdated', this.uploadQueue.getAllTasks());
+    });
+
+    this.uploadQueue.on('taskCompleted', (taskId, recordingId) => {
+      this.emit('uploadCompleted', taskId, recordingId);
+      this.emit('queueUpdated', this.uploadQueue.getAllTasks());
+    });
+
+    this.uploadQueue.on('taskFailed', (taskId, error) => {
+      this.emit('uploadFailed', taskId, error);
+      this.emit('queueUpdated', this.uploadQueue.getAllTasks());
+    });
+
+    this.uploadQueue.on('uploadProgress', (taskId, progress) => {
+      this.emit('uploadProgress', taskId, progress);
+    });
+  }
+
+  /**
+   * Get storage info from device
+   */
+  async getStorageInfo(device: ConnectedDevice): Promise<StorageInfo> {
+    if (!getBleManager().isConnected(device.id)) {
+      throw DeviceError.notConnected(device.id);
+    }
+
+    return this.protocolHandler.getStorageInfo(device.id);
+  }
+
+  /**
+   * List recordings on a device
+   */
+  async listRecordings(device: ConnectedDevice): Promise<DeviceRecording[]> {
+    if (!getBleManager().isConnected(device.id)) {
+      throw DeviceError.notConnected(device.id);
+    }
+
+    log.info('Listing recordings', { deviceId: device.id });
+
+    const recordings = await this.protocolHandler.listRecordings(device.id);
+
+    log.info('Found recordings', {
+      deviceId: device.id,
+      count: recordings.length,
+    });
+
+    return recordings;
+  }
+
+  /**
+   * Sync a single recording from device
+   * Transfers from device, saves locally, and queues for upload
+   */
+  async *syncRecording(
+    device: ConnectedDevice,
+    recording: DeviceRecording,
+    uploadInfo: UploadInfo
+  ): AsyncGenerator<SyncProgress> {
+    if (!getBleManager().isConnected(device.id)) {
+      throw DeviceError.notConnected(device.id);
+    }
+
+    log.info('Starting recording sync', {
+      deviceId: device.id,
+      recordingUuid: recording.uuid,
+    });
+
+    this.emit('syncStarted', recording.uuid);
+
+    try {
+      // Stage: Preparing
+      yield {
+        stage: 'preparing',
+        progress: 0,
+        totalBytes: recording.fileSizeBytes,
+      };
+
+      // Stage: Transferring from device
+      const audioData = await this.protocolHandler.transferRecording(
+        device.id,
+        recording.uuid,
+        (_bytesReceived, _totalBytes) => {
+          // Progress callback - can be used for real-time progress updates
+        }
+      );
+
+      yield {
+        stage: 'transferring',
+        progress: 1,
+        bytesTransferred: audioData.length,
+        totalBytes: recording.fileSizeBytes,
+      };
+
+      // Save locally
+      const localPath = await this.storage.saveRecordingData(
+        device.id,
+        recording.uuid,
+        audioData
+      );
+
+      // Stage: Uploading
+      yield {
+        stage: 'uploading',
+        progress: 0,
+        bytesUploaded: 0,
+        totalBytes: audioData.length,
+      };
+
+      // Queue for upload (this will process in background)
+      const task = await this.uploadQueue.enqueue({
+        recordingId: uploadInfo.recordingId,
+        deviceId: device.id,
+        localPath,
+        uploadUrl: uploadInfo.uploadUrl,
+        uploadToken: uploadInfo.uploadToken,
+        completeUrl: uploadInfo.completeUrl,
+      });
+
+      // Wait for upload to complete
+      await this.waitForUpload(task.id);
+
+      // Stage: Completing - Confirm sync to device
+      yield {
+        stage: 'completing',
+        progress: 0.5,
+      };
+
+      await this.protocolHandler.confirmSync(device.id, recording.uuid);
+
+      // Update last sync time
+      await this.storage.setLastSyncTime(device.id);
+
+      // Stage: Completed
+      yield {
+        stage: 'completed',
+        progress: 1,
+        recordingId: uploadInfo.recordingId,
+      };
+
+      log.info('Recording sync completed', {
+        deviceId: device.id,
+        recordingUuid: recording.uuid,
+        recordingId: uploadInfo.recordingId,
+      });
+
+      this.emit('syncCompleted', recording.uuid, uploadInfo.recordingId);
+    } catch (error) {
+      const err = error as Error;
+      log.error('Recording sync failed', err, {
+        deviceId: device.id,
+        recordingUuid: recording.uuid,
+      });
+
+      yield {
+        stage: 'failed',
+        progress: 0,
+        error: err.message,
+      };
+
+      this.emit('syncFailed', recording.uuid, err);
+      throw error;
+    }
+  }
+
+  /**
+   * Wait for an upload task to complete
+   */
+  private async waitForUpload(taskId: string): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      const checkTask = () => {
+        const task = this.storage.getUploadTask(taskId);
+        if (!task) {
+          reject(new Error('Upload task not found'));
+          return true;
+        }
+
+        if (task.status === 'completed') {
+          resolve();
+          return true;
+        }
+
+        if (task.status === 'failed') {
+          reject(new Error(task.errorMessage || 'Upload failed'));
+          return true;
+        }
+
+        return false;
+      };
+
+      // Check immediately
+      if (checkTask()) return;
+
+      // Poll for completion
+      const interval = setInterval(() => {
+        if (checkTask()) {
+          clearInterval(interval);
+        }
+      }, 500);
+
+      // Also listen for events
+      const onComplete = (completedTaskId: string) => {
+        if (completedTaskId === taskId) {
+          clearInterval(interval);
+          this.uploadQueue.off('taskCompleted', onComplete);
+          this.uploadQueue.off('taskFailed', onFailed);
+          resolve();
+        }
+      };
+
+      const onFailed = (failedTaskId: string, error: Error) => {
+        if (failedTaskId === taskId) {
+          clearInterval(interval);
+          this.uploadQueue.off('taskCompleted', onComplete);
+          this.uploadQueue.off('taskFailed', onFailed);
+          reject(error);
+        }
+      };
+
+      this.uploadQueue.on('taskCompleted', onComplete);
+      this.uploadQueue.on('taskFailed', onFailed);
+    });
+  }
+
+  /**
+   * Sync all recordings from a device
+   */
+  async *syncAllRecordings(
+    device: ConnectedDevice,
+    uploadInfoProvider: UploadInfoProvider
+  ): AsyncGenerator<SyncProgress & { recordingIndex?: number; totalRecordings?: number }> {
+    if (!getBleManager().isConnected(device.id)) {
+      throw DeviceError.notConnected(device.id);
+    }
+
+    log.info('Syncing all recordings', { deviceId: device.id });
+
+    // List recordings
+    const recordings = await this.listRecordings(device);
+
+    if (recordings.length === 0) {
+      log.info('No recordings to sync', { deviceId: device.id });
+      return;
+    }
+
+    log.info('Starting sync of recordings', {
+      deviceId: device.id,
+      count: recordings.length,
+    });
+
+    // Sync each recording
+    for (let i = 0; i < recordings.length; i++) {
+      const recording = recordings[i];
+
+      try {
+        // Get upload info from customer backend
+        const uploadInfo = await uploadInfoProvider(recording);
+
+        // Sync the recording
+        for await (const progress of this.syncRecording(
+          device,
+          recording,
+          uploadInfo
+        )) {
+          yield {
+            ...progress,
+            recordingIndex: i,
+            totalRecordings: recordings.length,
+          };
+        }
+      } catch (error) {
+        const err = error as Error;
+        log.error('Failed to sync recording', err, {
+          deviceId: device.id,
+          recordingUuid: recording.uuid,
+          index: i,
+        });
+
+        yield {
+          stage: 'failed',
+          progress: 0,
+          error: err.message,
+          recordingIndex: i,
+          totalRecordings: recordings.length,
+        };
+
+        // Continue with next recording
+      }
+    }
+  }
+
+  /**
+   * Get pending uploads
+   */
+  getPendingUploads(): UploadTask[] {
+    return this.uploadQueue.getPendingTasks();
+  }
+
+  /**
+   * Get all uploads
+   */
+  getAllUploads(): UploadTask[] {
+    return this.uploadQueue.getAllTasks();
+  }
+
+  /**
+   * Cancel a pending upload
+   */
+  async cancelUpload(taskId: string): Promise<void> {
+    await this.uploadQueue.cancel(taskId);
+  }
+
+  /**
+   * Retry failed uploads
+   */
+  async retryFailedUploads(): Promise<void> {
+    await this.uploadQueue.retryFailed();
+  }
+
+  /**
+   * Clear completed uploads from queue
+   */
+  async clearCompletedUploads(): Promise<void> {
+    await this.storage.clearCompletedTasks();
+    this.emit('queueUpdated', this.uploadQueue.getAllTasks());
+  }
+
+  /**
+   * Clear all uploads
+   */
+  async clearAllUploads(): Promise<void> {
+    await this.uploadQueue.cancelAll();
+    this.emit('queueUpdated', []);
+  }
+
+  /**
+   * Pause upload processing
+   */
+  pauseUploads(): void {
+    this.uploadQueue.pause();
+  }
+
+  /**
+   * Resume upload processing
+   */
+  resumeUploads(): void {
+    this.uploadQueue.resume();
+  }
+
+  /**
+   * Clean up resources
+   */
+  destroy(): void {
+    log.info('Destroying RecordingManager');
+    this.protocolHandler.destroy();
+    this.uploadQueue.destroy();
+    this.storage.destroy();
+    this.removeAllListeners();
+    this.isInitialized = false;
+  }
+}

package/src/managers/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Managers module exports
+ */
+
+export { DeviceManager } from './DeviceManager';
+export { RecordingManager, type UploadInfoProvider } from './RecordingManager';
+export {
+  OTAManager,
+  type FirmwareInfo,
+  type OtaStage,
+  type OtaProgress,
+} from './OTAManager';