@bota.dev/react-native-app-sdk 2.0.0-beta.0

package/lib/module/managers/DeviceManager.js

@@ -0,0 +1,641 @@
+"use strict";
+
+import EventEmitter from 'eventemitter3';
+import { getCompatibilityClient, subscribeToCompatibilityDisconnections } from '../compatibility/runtime';
+import { DeviceError, ProvisioningError } from '../utils/errors';
+export class DeviceManager extends EventEmitter {
+  discoveredDevices = new Map();
+  connectedDevices = new Map();
+  knownBleIds = new Map();
+  cache = new Map();
+  cacheListeners = new Set();
+  statusSubscriptions = new Map();
+  statusCallbacks = new Map();
+  wifiStatusSubscriptions = new Map();
+  logSubscriptions = new Map();
+  recordingStateCache = new Map();
+  recordingStatePending = new Map();
+  recordingStateSubscriptions = new Map();
+  reconnectInFlight = new Map();
+  reconnectChain = Promise.resolve();
+  scanSubscription = null;
+  scanActive = false;
+  autoReconnectEnabled = false;
+  autoReconnectSerial = null;
+  autoReconnectTimer = null;
+  autoReconnectAttempting = false;
+  userDisconnected = false;
+  destroyed = false;
+  constructor() {
+    super();
+    this.client = getCompatibilityClient();
+    this.disconnectionSubscription = subscribeToCompatibilityDisconnections(this.client, error => this.handleNativeDisconnection(error));
+  }
+  async initialize() {}
+  async startScan(options = {}) {
+    this.assertAlive();
+    if (this.scanActive) return;
+    this.emit('scanStarted');
+    try {
+      this.scanSubscription = await this.client.devices.startScan(options, device => {
+        this.discoveredDevices.set(device.id, device);
+        this.emit('deviceDiscovered', device);
+      });
+      this.scanActive = true;
+    } catch (error) {
+      this.emit('scanError', asError(error));
+      throw error;
+    }
+  }
+  stopScan() {
+    if (!this.scanActive) return;
+    this.scanActive = false;
+    this.scanSubscription?.remove();
+    this.scanSubscription = null;
+    void this.client.devices.stopScan().catch(error => {
+      this.emit('scanError', asError(error));
+    });
+    this.emit('scanStopped');
+  }
+  getDiscoveredDevices() {
+    return Array.from(this.discoveredDevices.values());
+  }
+  getConnectedDevices() {
+    return Array.from(this.connectedDevices.values());
+  }
+  getKnownBleIds() {
+    return Object.fromEntries(this.knownBleIds);
+  }
+  async connect(device, priority = 'user') {
+    void priority;
+    this.assertAlive();
+    this.userDisconnected = false;
+    this.emit('connectionStateChanged', device.id, 'connecting');
+    try {
+      const connected = await this.client.devices.connect(device);
+      this.rememberConnected(connected);
+      if (this.autoReconnectEnabled) this.ensureStatusWatchdog(connected);
+      this.emit('connectionStateChanged', connected.id, 'connected');
+      this.emit('deviceConnected', connected);
+      return connected;
+    } catch (error) {
+      this.emit('connectionStateChanged', device.id, 'disconnected');
+      throw error;
+    }
+  }
+  async reconnect(serialNumber, options) {
+    this.assertAlive();
+    const existing = this.findConnectedBySerial(serialNumber);
+    if (existing) return existing;
+    this.userDisconnected = false;
+    const inFlight = this.reconnectInFlight.get(serialNumber);
+    if (inFlight) return inFlight;
+    const run = this.reconnectChain.catch(() => undefined).then(async () => {
+      const connected = await this.client.devices.reconnect(serialNumber, options);
+      this.rememberConnected(connected);
+      if (this.autoReconnectEnabled) this.ensureStatusWatchdog(connected);
+      this.emit('connectionStateChanged', connected.id, 'connected');
+      this.emit('deviceConnected', connected);
+      return connected;
+    });
+    this.reconnectChain = run.catch(() => undefined);
+    this.reconnectInFlight.set(serialNumber, run);
+    void run.finally(() => {
+      if (this.reconnectInFlight.get(serialNumber) === run) {
+        this.reconnectInFlight.delete(serialNumber);
+      }
+    }).catch(() => undefined);
+    return run;
+  }
+  async disconnect(device) {
+    this.assertAlive();
+    this.userDisconnected = true;
+    this.stopAutoReconnectLoop();
+    this.emit('connectionStateChanged', device.id, 'disconnecting');
+    await this.removeOwned(this.statusSubscriptions, device.id);
+    this.statusCallbacks.delete(device.id);
+    await this.removeOwned(this.wifiStatusSubscriptions, device.id);
+    await this.removeOwned(this.logSubscriptions, device.id);
+    await this.removeOwned(this.recordingStateSubscriptions, device.id);
+    await this.client.devices.disconnect();
+    this.connectedDevices.delete(device.id);
+    this.recordingStateCache.delete(device.id);
+    this.recordingStatePending.delete(device.id);
+    this.emit('connectionStateChanged', device.id, 'disconnected');
+    this.emit('deviceDisconnected', device.id);
+  }
+  isConnected(deviceId) {
+    return this.connectedDevices.get(deviceId)?.connectionState === 'connected';
+  }
+  async getStatus(device) {
+    this.requireConnected(device.id);
+    return this.client.devices.readStatus();
+  }
+  async isProvisioned(device) {
+    this.requireConnected(device.id);
+    return this.client.controls.isProvisioned(device);
+  }
+  async readPublicKey(device) {
+    this.requireConnected(device.id);
+    return this.client.controls.readPublicKey(device);
+  }
+  async readAuthNonce(device) {
+    this.requireConnected(device.id);
+    return this.client.controls.readAuthNonce(device);
+  }
+  async setApiEndpoint(device, environment) {
+    this.requireConnected(device.id);
+    await this.client.controls.setApiEndpoint(device, environment);
+  }
+  async deliverCert(device, certPem, privkeyPem) {
+    this.requireConnected(device.id);
+    await this.client.controls.deliverCertificate(device, certPem, privkeyPem);
+  }
+  async deliverBackendPubkey(device, pubkey) {
+    this.requireConnected(device.id);
+    await this.client.controls.deliverBackendPublicKey(device, pubkey);
+  }
+  async writeGrant(device, grantBlob) {
+    this.requireConnected(device.id);
+    await this.client.controls.writeGrant(device, grantBlob);
+  }
+  async syncTime(deviceId) {
+    await this.client.controls.syncTime(this.requireConnected(deviceId));
+  }
+  async provision(device, deviceToken, environment = 'production', options) {
+    this.requireConnected(device.id);
+    const provision = () => this.client.provisioning.provision(device, async () => ({
+      apiEndpoint: String.fromCharCode(environmentCode(environment)),
+      deviceToken,
+      mtu: device.mtu
+    }));
+    try {
+      await provision();
+    } catch (error) {
+      if (!isAlreadyPaired(error) || !options?.fetchDeprovisionGrant) {
+        throw provisioningError(error, device.id);
+      }
+      const nonce = await this.readAuthNonce(device).catch(() => null);
+      const grantBlob = await options.fetchDeprovisionGrant(nonce);
+      const result = await this.deprovision(device, grantBlob);
+      if (!result.success) {
+        throw new ProvisioningError(`Auto-deprovision failed: ${result.error ?? 'unknown'}`, 'PROVISIONING_FAILED', device.id);
+      }
+      await provision();
+    }
+  }
+  async deprovision(device, grantBlob) {
+    this.requireConnected(device.id);
+    return this.client.provisioning.deprovision(device, grantBlob);
+  }
+  async factoryReset(device) {
+    this.requireConnected(device.id);
+    throw ProvisioningError.invalidToken(device.id);
+  }
+  async bleFactoryReset(device, grantBlob, persistResult) {
+    this.requireConnected(device.id);
+    let persisted;
+    try {
+      await this.client.factoryReset.factoryReset(device, {
+        commandId: nextCompatibilityResetCommandId(),
+        bindingGeneration: 0
+      }, async () => grantBlob, async result => {
+        await persistResult(result);
+        persisted = result;
+      });
+    } catch (error) {
+      const rejected = factoryResetRejection(error);
+      if (rejected) return rejected;
+      throw error;
+    }
+    if (!persisted) {
+      throw new Error('Factory reset completed without a persisted result');
+    }
+    return persisted;
+  }
+  async resumeBleFactoryReset(device, persistResult) {
+    this.requireConnected(device.id);
+    let persisted;
+    try {
+      await this.client.factoryReset.resumePendingFactoryReset(device, 0, async result => {
+        await persistResult(result);
+        persisted = result;
+      });
+    } catch (error) {
+      const rejected = factoryResetRejection(error);
+      if (rejected) return rejected;
+      throw error;
+    }
+    if (!persisted) {
+      throw new Error('Factory reset resume completed without a persisted result');
+    }
+    return persisted;
+  }
+  async requestStartRecording(device, grantOrFetcher, _options) {
+    this.requireConnected(device.id);
+    if (typeof grantOrFetcher === 'string') {
+      return this.runRecordingControl(device, grantOrFetcher, 'start');
+    }
+    const grantBlob = await this.fetchRecordingGrant(device, grantOrFetcher);
+    return this.runRecordingControl(device, grantBlob, 'start');
+  }
+  async requestStopRecording(device, grantOrFetcher, _options) {
+    this.requireConnected(device.id);
+    if (typeof grantOrFetcher === 'string') {
+      return this.runRecordingControl(device, grantOrFetcher, 'stop');
+    }
+    const grantBlob = await this.fetchRecordingGrant(device, grantOrFetcher);
+    return this.runRecordingControl(device, grantBlob, 'stop');
+  }
+  async getRecordingState(device) {
+    this.requireConnected(device.id);
+    const pending = this.recordingStatePending.get(device.id);
+    if (pending) return pending;
+    try {
+      return await this.readAndCacheRecordingState(device);
+    } catch {
+      return this.cachedRecordingState(device.id);
+    }
+  }
+  subscribeToRecordingState(device, callback) {
+    this.requireConnected(device.id);
+    const promise = this.replaceOwned(this.recordingStateSubscriptions, device.id, this.client.controls.subscribeToRecordingState(device, callback));
+    return idempotentRemoval(() => {
+      void this.removeExpected(this.recordingStateSubscriptions, device.id, promise);
+    });
+  }
+  subscribeToStatus(device, callback) {
+    this.requireConnected(device.id);
+    const callbacks = this.statusCallbacks.get(device.id) ?? new Set();
+    callbacks.add(callback);
+    this.statusCallbacks.set(device.id, callbacks);
+    this.ensureStatusWatchdog(device);
+    return idempotentRemoval(() => {
+      callbacks.delete(callback);
+      if (callbacks.size === 0) {
+        this.statusCallbacks.delete(device.id);
+        if (!this.autoReconnectEnabled) {
+          void this.removeOwned(this.statusSubscriptions, device.id).catch(() => undefined);
+        }
+      }
+    });
+  }
+  async subscribeToDeviceLogs(device, callback) {
+    this.requireConnected(device.id);
+    const promise = this.replaceOwned(this.logSubscriptions, device.id, this.client.logs.subscribe(device, callback));
+    await promise;
+    return idempotentRemoval(() => {
+      void this.removeExpected(this.logSubscriptions, device.id, promise);
+    });
+  }
+  async readConnectionSettings(device) {
+    this.requireConnected(device.id);
+    return this.client.provisioning.readConnectionSettings(device);
+  }
+  async writeConnectionSettings(device, settings) {
+    this.requireConnected(device.id);
+    await this.client.provisioning.writeConnectionSettings(device, settings);
+  }
+  async configureWiFi(deviceId, credentials, grant) {
+    return this.client.wifi.configure(this.requireConnected(deviceId), credentials, grant);
+  }
+  async disconnectWiFi(deviceId) {
+    return this.client.wifi.disconnect(this.requireConnected(deviceId));
+  }
+  async getWiFiStatus(deviceId) {
+    const device = this.requireConnected(deviceId);
+    const status = await this.client.wifi.readStatus(device);
+    this.updateCachedDeviceState(device.serialNumber, {
+      wifiStatus: status
+    });
+    return status;
+  }
+  subscribeToWiFiStatus(deviceId, callback) {
+    const device = this.requireConnected(deviceId);
+    const promise = this.replaceOwned(this.wifiStatusSubscriptions, device.id, this.client.wifi.subscribeToStatus(device, status => {
+      this.updateCachedDeviceState(device.serialNumber, {
+        wifiStatus: status
+      });
+      callback(status);
+    }));
+    return {
+      remove: idempotentRemoval(() => {
+        void this.removeExpected(this.wifiStatusSubscriptions, device.id, promise);
+      })
+    };
+  }
+  async scanWiFiNetworks(device) {
+    this.requireConnected(device.id);
+    return this.client.wifi.scanNetworks(device);
+  }
+  getCachedDeviceState(serialNumber) {
+    return this.cache.get(serialNumber) ?? null;
+  }
+  getCachedWiFiStatus(serialNumber) {
+    return this.cache.get(serialNumber)?.wifiStatus ?? null;
+  }
+  updateCachedDeviceState(serialNumber, patch) {
+    const previous = this.cache.get(serialNumber);
+    const wifiStatus = mergeWiFiStatus(previous?.wifiStatus, patch.wifiStatus);
+    const state = {
+      ...(wifiStatus === undefined ? {} : {
+        wifiStatus
+      }),
+      updatedAt: Date.now()
+    };
+    this.cache.set(serialNumber, state);
+    for (const listener of this.cacheListeners) listener(serialNumber, patch, state);
+  }
+  clearCachedDeviceState(serialNumber) {
+    this.cache.delete(serialNumber);
+  }
+  clearAllCachedDeviceStates() {
+    this.cache.clear();
+  }
+  enableAutoReconnect(serialNumber) {
+    this.assertAlive();
+    this.autoReconnectSerial = serialNumber;
+    this.autoReconnectEnabled = true;
+    this.userDisconnected = false;
+    const connected = this.findConnectedBySerial(serialNumber);
+    if (connected) {
+      this.ensureStatusWatchdog(connected);
+    } else {
+      this.startAutoReconnectLoop();
+    }
+  }
+  disableAutoReconnect() {
+    const serialNumber = this.autoReconnectSerial;
+    this.autoReconnectEnabled = false;
+    this.autoReconnectSerial = null;
+    this.userDisconnected = false;
+    this.stopAutoReconnectLoop();
+    const connected = serialNumber ? this.findConnectedBySerial(serialNumber) : null;
+    if (connected && !this.statusCallbacks.has(connected.id)) {
+      void this.removeOwned(this.statusSubscriptions, connected.id).catch(() => undefined);
+    }
+  }
+  onCachedDeviceStateChanged(listener) {
+    this.cacheListeners.add(listener);
+    return {
+      remove: () => this.cacheListeners.delete(listener)
+    };
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.disconnectionSubscription.remove();
+    this.disableAutoReconnect();
+    this.stopScan();
+    for (const [deviceId] of this.statusSubscriptions) {
+      void this.removeOwned(this.statusSubscriptions, deviceId);
+    }
+    for (const [deviceId] of this.wifiStatusSubscriptions) {
+      void this.removeOwned(this.wifiStatusSubscriptions, deviceId);
+    }
+    for (const [deviceId] of this.logSubscriptions) {
+      void this.removeOwned(this.logSubscriptions, deviceId);
+    }
+    for (const [deviceId] of this.recordingStateSubscriptions) {
+      void this.removeOwned(this.recordingStateSubscriptions, deviceId);
+    }
+    this.connectedDevices.clear();
+    this.recordingStateCache.clear();
+    this.recordingStatePending.clear();
+    this.statusCallbacks.clear();
+    this.cache.clear();
+    this.cacheListeners.clear();
+    this.removeAllListeners();
+  }
+  rememberConnected(device) {
+    this.connectedDevices.set(device.id, device);
+    this.knownBleIds.set(device.serialNumber, device.id);
+  }
+  ensureStatusWatchdog(device) {
+    if (this.statusSubscriptions.has(device.id)) return;
+    const subscription = this.client.devices.subscribeToStatus(status => {
+      for (const callback of this.statusCallbacks.get(device.id) ?? []) {
+        callback(status);
+      }
+      this.emit('deviceStatusUpdated', device.id, status);
+    });
+    this.statusSubscriptions.set(device.id, subscription);
+    void subscription.catch(() => {
+      if (this.statusSubscriptions.get(device.id) === subscription) {
+        this.statusSubscriptions.delete(device.id);
+      }
+    });
+  }
+  handleNativeDisconnection(error) {
+    if (this.destroyed || this.userDisconnected) return;
+    for (const device of this.connectedDevices.values()) {
+      this.connectedDevices.delete(device.id);
+      this.recordingStateCache.delete(device.id);
+      this.recordingStatePending.delete(device.id);
+      this.statusCallbacks.delete(device.id);
+      void this.removeOwned(this.statusSubscriptions, device.id).catch(() => undefined);
+      void this.removeOwned(this.wifiStatusSubscriptions, device.id).catch(() => undefined);
+      void this.removeOwned(this.logSubscriptions, device.id).catch(() => undefined);
+      void this.removeOwned(this.recordingStateSubscriptions, device.id).catch(() => undefined);
+      this.emit('connectionStateChanged', device.id, 'disconnected');
+      this.emit('deviceDisconnected', device.id, error);
+      if (this.autoReconnectEnabled && this.autoReconnectSerial === device.serialNumber) {
+        this.startAutoReconnectLoop();
+      }
+    }
+  }
+  startAutoReconnectLoop() {
+    if (this.autoReconnectTimer || !this.autoReconnectSerial) return;
+    const attempt = async () => {
+      const serialNumber = this.autoReconnectSerial;
+      if (!this.autoReconnectEnabled || !serialNumber || this.userDisconnected || this.destroyed) {
+        this.stopAutoReconnectLoop();
+        return;
+      }
+      if (this.findConnectedBySerial(serialNumber)) {
+        this.stopAutoReconnectLoop();
+        return;
+      }
+      if (this.autoReconnectAttempting) return;
+      this.autoReconnectAttempting = true;
+      try {
+        await this.reconnect(serialNumber, {
+          scanTimeout: 5_000
+        });
+        this.stopAutoReconnectLoop();
+      } catch {
+        // The timer owns retries; callers still receive errors from reconnect().
+      } finally {
+        this.autoReconnectAttempting = false;
+      }
+    };
+    void attempt();
+    this.autoReconnectTimer = setInterval(() => void attempt(), 3_000);
+  }
+  stopAutoReconnectLoop() {
+    if (!this.autoReconnectTimer) return;
+    clearInterval(this.autoReconnectTimer);
+    this.autoReconnectTimer = null;
+  }
+  findConnectedBySerial(serialNumber) {
+    for (const device of this.connectedDevices.values()) {
+      if (device.serialNumber === serialNumber && device.connectionState === 'connected') {
+        return device;
+      }
+    }
+    return null;
+  }
+  requireConnected(deviceId) {
+    const device = this.connectedDevices.get(deviceId);
+    if (!device || device.connectionState !== 'connected') {
+      throw DeviceError.notConnected(deviceId);
+    }
+    return device;
+  }
+  async fetchRecordingGrant(device, fetcher) {
+    const nonce = await this.readAuthNonce(device).catch(() => null);
+    return fetcher(nonce);
+  }
+  async runRecordingControl(device, grantBlob, command) {
+    const operation = command === 'start' ? this.client.controls.requestStartRecording(device, grantBlob) : this.client.controls.requestStopRecording(device, grantBlob);
+    const pendingState = operation.then(() => this.readAndCacheRecordingState(device), () => this.cachedRecordingState(device.id));
+    this.recordingStatePending.set(device.id, pendingState);
+    try {
+      const result = await operation;
+      await pendingState;
+      return result;
+    } catch (error) {
+      await pendingState;
+      throw error;
+    } finally {
+      if (this.recordingStatePending.get(device.id) === pendingState) {
+        this.recordingStatePending.delete(device.id);
+      }
+    }
+  }
+  async readAndCacheRecordingState(device) {
+    const state = await this.client.controls.readRecordingState(device);
+    this.recordingStateCache.set(device.id, state);
+    return state;
+  }
+  cachedRecordingState(deviceId) {
+    return this.recordingStateCache.get(deviceId) ?? {
+      active: false,
+      initiatedBy: 'local'
+    };
+  }
+  replaceOwned(owner, deviceId, next) {
+    void this.removeOwned(owner, deviceId);
+    owner.set(deviceId, next);
+    void next.catch(() => {
+      if (owner.get(deviceId) === next) owner.delete(deviceId);
+    });
+    return next;
+  }
+  async removeExpected(owner, deviceId, expected) {
+    if (owner.get(deviceId) !== expected) return;
+    owner.delete(deviceId);
+    await (await expected).remove();
+  }
+  async removeOwned(owner, deviceId) {
+    const subscription = owner.get(deviceId);
+    if (!subscription) return;
+    owner.delete(deviceId);
+    await (await subscription).remove();
+  }
+  assertAlive() {
+    if (this.destroyed) throw new Error('DeviceManager has been destroyed');
+  }
+}
+const idempotentRemoval = remove => {
+  let removed = false;
+  return () => {
+    if (removed) return;
+    removed = true;
+    remove();
+  };
+};
+const mergeWiFiStatus = (previous, patch) => {
+  if (patch === undefined) return previous;
+  if (patch === null) return undefined;
+  return {
+    status: patch.status ?? previous?.status ?? 'idle',
+    ...((patch.signalStrength ?? previous?.signalStrength) === undefined ? {} : {
+      signalStrength: patch.signalStrength ?? previous?.signalStrength
+    }),
+    ...((patch.ssid ?? previous?.ssid) === undefined ? {} : {
+      ssid: patch.ssid ?? previous?.ssid
+    }),
+    ...((patch.lastError ?? previous?.lastError) === undefined ? {} : {
+      lastError: patch.lastError ?? previous?.lastError
+    })
+  };
+};
+const asError = error => error instanceof Error ? error : new Error(String(error));
+const environmentCode = environment => {
+  switch (environment) {
+    case 'development':
+      return 0;
+    case 'production':
+      return 1;
+    case 'gamma':
+      return 2;
+  }
+};
+const nativeProtocolStatus = error => {
+  if (!error || typeof error !== 'object') return undefined;
+  const direct = Reflect.get(error, 'protocolStatus');
+  if (typeof direct === 'number') return direct;
+  const userInfo = Reflect.get(error, 'userInfo');
+  if (!userInfo || typeof userInfo !== 'object') return undefined;
+  const nested = Reflect.get(userInfo, 'protocolStatus');
+  return typeof nested === 'number' ? nested : undefined;
+};
+const isAlreadyPaired = error => error instanceof ProvisioningError && error.code === 'ALREADY_PAIRED' || nativeProtocolStatus(error) === 4;
+const provisioningError = (error, deviceId) => {
+  if (error instanceof ProvisioningError) return error;
+  switch (nativeProtocolStatus(error)) {
+    case 1:
+      return ProvisioningError.invalidToken(deviceId);
+    case 2:
+      return ProvisioningError.storageError(deviceId);
+    case 3:
+      return ProvisioningError.chunkError(deviceId);
+    case 4:
+      return ProvisioningError.alreadyPaired(deviceId);
+    default:
+      return asError(error);
+  }
+};
+let compatibilityResetSequence = 0;
+const nextCompatibilityResetCommandId = () => {
+  compatibilityResetSequence += 1;
+  return `rn-reset-${Date.now().toString(36)}-${compatibilityResetSequence.toString(36)}`;
+};
+const factoryResetRejection = error => {
+  switch (nativeProtocolStatus(error)) {
+    case 1:
+      return {
+        success: false,
+        error: 'invalid_token'
+      };
+    case 2:
+      return {
+        success: false,
+        error: 'storage_error'
+      };
+    case 3:
+      return {
+        success: false,
+        error: 'chunk_error'
+      };
+    case 4:
+      return {
+        success: false,
+        error: 'already_paired'
+      };
+    default:
+      return undefined;
+  }
+};
+//# sourceMappingURL=DeviceManager.js.map