@ukeyfe/hardware-transport-react-native 1.1.13

package/src/index.ts

@@ -0,0 +1,672 @@
+import { Platform, PermissionsAndroid } from 'react-native';
+import { Buffer } from 'buffer';
+import {
+  BleManager as BlePlxManager,
+  Device,
+  BleErrorCode,
+  Characteristic,
+  ScanMode,
+  BleATTErrorCode,
+  BleError,
+} from 'react-native-ble-plx';
+import ByteBuffer from 'bytebuffer';
+import transport, { COMMON_HEADER_SIZE, LogBlockCommand } from '@ukeyfe/hardware-transport';
+import {
+  createDeferred,
+  Deferred,
+  ERRORS,
+  HardwareErrorCode,
+  isUkeyDevice,
+} from '@ukeyfe/hardware-shared';
+import type EventEmitter from 'events';
+import { getConnectedDeviceIds, onDeviceBondState, pairDevice } from './BleManager';
+import { subscribeBleOn } from './subscribeBleOn';
+import {
+  getBluetoothServiceUuids,
+  getInfosForServiceUuid,
+  IOS_PACKET_LENGTH,
+  ANDROID_PACKET_LENGTH,
+} from './constants';
+import { isHeaderChunk } from './utils/validateNotify';
+import BleTransport from './BleTransport';
+import timer from './utils/timer';
+import type { BleAcquireInput, TransportOptions } from './types';
+
+const { check, buildBuffers, receiveOne, parseConfigure } = transport;
+
+const transportCache: Record<string, any> = {};
+
+let connectOptions: Record<string, unknown> = {
+  requestMTU: 256,
+  timeout: 3000,
+  refreshGatt: 'OnConnected',
+};
+
+const tryToGetConfiguration = (device: Device) => {
+  if (!device || !device.serviceUUIDs) return null;
+  const [serviceUUID] = device.serviceUUIDs;
+  const infos = getInfosForServiceUuid(serviceUUID, 'classic');
+  if (!infos) return null;
+  return infos;
+};
+
+type IOBleErrorRemap = Error | BleError | null | undefined;
+
+function remapError(error: IOBleErrorRemap) {
+  if (error instanceof BleError) {
+    if (
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      error.iosErrorCode === BleATTErrorCode.UnlikelyError ||
+      error.reason === 'Peer removed pairing information'
+    ) {
+      throw ERRORS.TypedError(HardwareErrorCode.BlePeerRemovedPairingInformation);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore It's not documented but seems to match a refusal on Android pairing
+    if (error?.attErrorCode === 22) {
+      throw ERRORS.TypedError(HardwareErrorCode.BleDeviceBondError);
+    }
+  }
+
+  if (
+    error instanceof Error &&
+    error.message &&
+    (error.message.includes('was disconnected') || error.message.includes('not found'))
+  ) {
+    throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
+  }
+
+  // @ts-expect-error
+  throw ERRORS.TypedError(HardwareErrorCode.BleConnectedError, error.reason ?? error);
+}
+
+export default class ReactNativeBleTransport {
+  blePlxManager: BlePlxManager | undefined;
+
+  _messages: ReturnType<typeof transport.parseConfigure> | undefined;
+
+  name = 'ReactNativeBleTransport';
+
+  configured = false;
+
+  stopped = false;
+
+  scanTimeout = 3000;
+
+  runPromise: Deferred<any> | null = null;
+
+  Log?: any;
+
+  emitter?: EventEmitter;
+
+  constructor(options: TransportOptions) {
+    this.scanTimeout = options.scanTimeout ?? 3000;
+  }
+
+  init(logger: any, emitter: EventEmitter) {
+    this.Log = logger;
+    this.emitter = emitter;
+  }
+
+  configure(signedData: any) {
+    const messages = parseConfigure(signedData);
+    this.configured = true;
+    this._messages = messages;
+  }
+
+  listen() {
+    // empty
+  }
+
+  getPlxManager(): Promise<BlePlxManager> {
+    if (this.blePlxManager) return Promise.resolve(this.blePlxManager);
+    this.blePlxManager = new BlePlxManager();
+    return Promise.resolve(this.blePlxManager);
+  }
+
+  /**
+   * 获取设备列表
+   * 在搜索超过超时时间或设备数量大于 5 台时，返回 UKey 设备，
+   * @returns
+   */
+  async enumerate() {
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise<Device[]>(async (resolve, reject) => {
+      const deviceList: Device[] = [];
+      const blePlxManager = await this.getPlxManager();
+      try {
+        await subscribeBleOn(blePlxManager);
+      } catch (error) {
+        this.Log.debug('subscribeBleOn error: ', error);
+        reject(error);
+        return;
+      }
+
+      if (Platform.OS === 'android' && Platform.Version >= 31) {
+        this.Log.debug('requesting permissions, please wait...');
+
+        const resultConnect = await PermissionsAndroid.requestMultiple([
+          PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+          PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
+        ]);
+
+        this.Log.debug('requesting permissions, result: ', resultConnect);
+        if (
+          resultConnect[PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT] !== 'granted' ||
+          resultConnect[PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN] !== 'granted'
+        ) {
+          reject(ERRORS.TypedError(HardwareErrorCode.BlePermissionError));
+          return;
+        }
+      }
+
+      blePlxManager.startDeviceScan(
+        null,
+        {
+          scanMode: ScanMode.LowLatency,
+        },
+        (error, device) => {
+          if (error) {
+            this.Log.debug('ble scan manager: ', blePlxManager);
+            this.Log.debug('ble scan error: ', error);
+            if (
+              [BleErrorCode.BluetoothPoweredOff, BleErrorCode.BluetoothInUnknownState].includes(
+                error.errorCode
+              )
+            ) {
+              reject(ERRORS.TypedError(HardwareErrorCode.BlePermissionError));
+            } else if (error.errorCode === BleErrorCode.BluetoothUnauthorized) {
+              reject(ERRORS.TypedError(HardwareErrorCode.BleLocationError));
+            } else if (error.errorCode === BleErrorCode.LocationServicesDisabled) {
+              reject(ERRORS.TypedError(HardwareErrorCode.BleLocationServicesDisabled));
+            } else if (error.errorCode === BleErrorCode.ScanStartFailed) {
+              // Android Bluetooth will report an error when the search frequency is too fast,
+              // then nothing is processed and an empty array of devices is returned.
+              // Then the next search will be back to normal
+              timer.timeout(() => {}, this.scanTimeout);
+            } else {
+              reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.reason ?? ''));
+            }
+            return;
+          }
+
+          if (isUkeyDevice(device?.name ?? null, device?.id)) {
+            this.Log.debug('search device start ======================');
+            const { name, localName, id } = device ?? {};
+            this.Log.debug(
+              `device name: ${name ?? ''}\nlocalName: ${localName ?? ''}\nid: ${id ?? ''}`
+            );
+            addDevice(device as unknown as Device);
+            this.Log.debug('search device end ======================\n');
+          }
+        }
+      );
+
+      getConnectedDeviceIds(getBluetoothServiceUuids()).then(devices => {
+        for (const device of devices) {
+          this.Log.debug('search connected peripheral: ', device.id);
+          addDevice(device as unknown as Device);
+        }
+      });
+
+      const addDevice = (device: Device) => {
+        if (deviceList.every(d => d.id !== device.id)) {
+          deviceList.push(device);
+        }
+      };
+
+      timer.timeout(() => {
+        blePlxManager.stopDeviceScan();
+        resolve(deviceList);
+      }, this.scanTimeout);
+    });
+  }
+
+  async acquire(input: BleAcquireInput) {
+    const { uuid, forceCleanRunPromise } = input;
+
+    if (!uuid) {
+      throw ERRORS.TypedError(HardwareErrorCode.BleRequiredUUID);
+    }
+
+    let device: Device | null = null;
+
+    if (transportCache[uuid]) {
+      /**
+       * If the transport is not released due to an exception operation
+       * it will be handled again here
+       */
+      this.Log.debug('transport not be released, will release: ', uuid);
+      await this.release(uuid);
+    }
+
+    if (forceCleanRunPromise && this.runPromise) {
+      this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise));
+      this.Log.debug(
+        'Force clean Bluetooth run promise, forceCleanRunPromise: ',
+        forceCleanRunPromise
+      );
+    }
+
+    const blePlxManager = await this.getPlxManager();
+    try {
+      await subscribeBleOn(blePlxManager);
+    } catch (error) {
+      this.Log.debug('subscribeBleOn error: ', error);
+      throw error;
+    }
+
+    // check device is bonded
+    if (Platform.OS === 'android') {
+      const bondState = await pairDevice(uuid);
+      if (bondState.bonding) {
+        await onDeviceBondState(uuid);
+      }
+    }
+
+    if (!device) {
+      const devices = await blePlxManager.devices([uuid]);
+      [device] = devices;
+    }
+
+    if (!device) {
+      const connectedDevice = await blePlxManager.connectedDevices(getBluetoothServiceUuids());
+      const deviceFilter = connectedDevice.filter(device => device.id === uuid);
+      this.Log.debug(`found connected device count: ${deviceFilter.length}`);
+      [device] = deviceFilter;
+    }
+
+    if (!device) {
+      this.Log.debug('try to connect to device: ', uuid);
+      try {
+        device = await blePlxManager.connectToDevice(uuid, connectOptions);
+      } catch (e) {
+        this.Log.debug('try to connect to device has error: ', e);
+        if (
+          e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
+          e.errorCode === BleErrorCode.OperationCancelled
+        ) {
+          connectOptions = {};
+          this.Log.debug('first try to reconnect without params');
+          device = await blePlxManager.connectToDevice(uuid);
+        } else if (e.errorCode === BleErrorCode.DeviceAlreadyConnected) {
+          this.Log.debug('device already connected');
+          throw ERRORS.TypedError(HardwareErrorCode.BleAlreadyConnected);
+        } else {
+          remapError(e);
+        }
+      }
+    }
+
+    if (!device) {
+      throw ERRORS.TypedError(HardwareErrorCode.BleConnectedError, 'unable to connect to device');
+    }
+
+    if (!(await device.isConnected())) {
+      this.Log.debug('not connected, try to connect to device: ', uuid);
+
+      try {
+        await device.connect(connectOptions);
+      } catch (e) {
+        this.Log.debug('not connected, try to connect to device has error: ', e);
+        if (
+          e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
+          e.errorCode === BleErrorCode.OperationCancelled
+        ) {
+          connectOptions = {};
+          this.Log.debug('second try to reconnect without params');
+          try {
+            await device.connect();
+          } catch (e) {
+            this.Log.debug('last try to reconnect error: ', e);
+            // last try to reconnect device if this issue exists
+            // https://github.com/dotintent/react-native-ble-plx/issues/426
+            if (e.errorCode === BleErrorCode.OperationCancelled) {
+              this.Log.debug('last try to reconnect');
+              await device.cancelConnection();
+              await device.connect();
+            }
+          }
+        } else {
+          remapError(e);
+        }
+      }
+    }
+
+    await device.discoverAllServicesAndCharacteristics();
+    let infos = tryToGetConfiguration(device);
+    let characteristics;
+
+    if (!infos) {
+      for (const serviceUuid of getBluetoothServiceUuids()) {
+        try {
+          characteristics = await device.characteristicsForService(serviceUuid);
+          infos = getInfosForServiceUuid(serviceUuid, 'classic');
+          break;
+        } catch (e) {
+          this.Log.error(e);
+        }
+      }
+    }
+
+    if (!infos) {
+      try {
+        this.Log.debug('cancel connection when service not found');
+        await device.cancelConnection();
+      } catch (e) {
+        this.Log.debug('cancel connection error when service not found: ', e.message || e.reason);
+      }
+      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
+    }
+
+    const { serviceUuid, writeUuid, notifyUuid } = infos;
+
+    if (!characteristics) {
+      characteristics = await device.characteristicsForService(serviceUuid);
+    }
+
+    if (!characteristics) {
+      throw ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound);
+    }
+
+    let writeCharacteristic;
+    let notifyCharacteristic;
+    for (const c of characteristics) {
+      if (c.uuid === writeUuid) {
+        writeCharacteristic = c;
+      } else if (c.uuid === notifyUuid) {
+        notifyCharacteristic = c;
+      }
+    }
+
+    if (!writeCharacteristic) {
+      throw ERRORS.TypedError('BLECharacteristicNotFound: write characteristic not found');
+    }
+
+    if (!notifyCharacteristic) {
+      throw ERRORS.TypedError('BLECharacteristicNotFound: notify characteristic not found');
+    }
+
+    if (!writeCharacteristic.isWritableWithResponse) {
+      throw ERRORS.TypedError('BLECharacteristicNotWritable: write characteristic not writable');
+    }
+
+    if (!notifyCharacteristic.isNotifiable) {
+      throw ERRORS.TypedError(
+        'BLECharacteristicNotNotifiable: notify characteristic not notifiable'
+      );
+    }
+
+    // release transport before new transport instance
+    await this.release(uuid);
+
+    const transport = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
+    transport.nofitySubscription = this._monitorCharacteristic(transport.notifyCharacteristic);
+    transportCache[uuid] = transport;
+
+    this.emitter?.emit('device-connect', {
+      name: device.name,
+      id: device.id,
+      connectId: device.id,
+    });
+
+    const disconnectSubscription = device.onDisconnected(() => {
+      try {
+        this.Log.debug('device disconnect: ', device?.id);
+        this.emitter?.emit('device-disconnect', {
+          name: device?.name,
+          id: device?.id,
+          connectId: device?.id,
+        });
+        if (this.runPromise) {
+          this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError));
+        }
+      } catch (e) {
+        this.Log.debug('device disconnect error: ', e);
+      } finally {
+        this.release(uuid);
+        disconnectSubscription?.remove();
+      }
+    });
+
+    return { uuid };
+  }
+
+  _monitorCharacteristic(characteristic: Characteristic) {
+    let bufferLength = 0;
+    let buffer: any[] = [];
+    const subscription = characteristic.monitor((error, c) => {
+      if (error) {
+        this.Log.debug(
+          `error monitor ${characteristic.uuid}, deviceId: ${characteristic.deviceID}: ${
+            error as unknown as string
+          }`
+        );
+        if (this.runPromise) {
+          let ERROR:
+            | typeof HardwareErrorCode.BleDeviceBondError
+            | typeof HardwareErrorCode.BleCharacteristicNotifyError
+            | typeof HardwareErrorCode.BleTimeoutError =
+            HardwareErrorCode.BleCharacteristicNotifyError;
+          if (error.reason?.includes('The connection has timed out unexpectedly')) {
+            ERROR = HardwareErrorCode.BleTimeoutError;
+          }
+          if (error.reason?.includes('Encryption is insufficient')) {
+            ERROR = HardwareErrorCode.BleDeviceBondError;
+          }
+          if (
+            error.reason?.includes('Cannot write client characteristic config descriptor') ||
+            error.reason?.includes('Cannot find client characteristic config descriptor') || // pro firmware 2.3.0 upgrade
+            error.reason?.includes('The handle is invalid') ||
+            error.reason?.includes('Writing is not permitted') || // pro firmware 2.3.4 upgrade
+            error.reason?.includes('notify change failed for device')
+          ) {
+            this.runPromise.reject(
+              ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotifyChangeFailure)
+            );
+            this.Log.debug(
+              `${HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`
+            );
+            return;
+          }
+          this.runPromise.reject(ERRORS.TypedError(ERROR));
+          this.Log.debug(': monitor notify error, and has unreleased Promise', Error);
+        }
+
+        return;
+      }
+
+      if (!c) {
+        throw ERRORS.TypedError(HardwareErrorCode.BleMonitorError);
+      }
+
+      try {
+        const data = Buffer.from(c.value as string, 'base64');
+        // console.log('[hd-transport-react-native] Received a packet, ', 'buffer: ', data);
+        if (isHeaderChunk(data)) {
+          bufferLength = data.readInt32BE(5);
+          buffer = [...data.subarray(3)];
+        } else {
+          buffer = buffer.concat([...data]);
+        }
+
+        if (buffer.length - COMMON_HEADER_SIZE >= bufferLength) {
+          const value = Buffer.from(buffer);
+          // console.log(
+          //   '[hd-transport-react-native] Received a complete packet of data, resolve Promise, this.runPromise: ',
+          //   this.runPromise,
+          //   'buffer: ',
+          //   value
+          // );
+          bufferLength = 0;
+          buffer = [];
+          this.runPromise?.resolve(value.toString('hex'));
+        }
+      } catch (error) {
+        this.Log.debug('monitor data error: ', error);
+        this.runPromise?.reject(ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError));
+      }
+    });
+
+    return () => {
+      this.Log.debug('remove characteristic monitor: ', characteristic.uuid);
+      subscription.remove();
+    };
+  }
+
+  async release(uuid: string) {
+    const transport = transportCache[uuid];
+
+    if (transport) {
+      delete transportCache[uuid];
+      transport.nofitySubscription?.();
+      // Temporary close the Android disconnect after each request
+      if (Platform.OS === 'android') {
+        // await this.blePlxManager?.cancelDeviceConnection(uuid);
+      }
+    }
+
+    return Promise.resolve(true);
+  }
+
+  async post(session: string, name: string, data: Record<string, unknown>) {
+    await this.call(session, name, data);
+  }
+
+  async call(uuid: string, name: string, data: Record<string, unknown>) {
+    if (this.stopped) {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      return Promise.reject(ERRORS.TypedError('Transport stopped.'));
+    }
+    if (this._messages == null) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+
+    const forceRun = name === 'Initialize' || name === 'Cancel';
+
+    this.Log.debug('transport-react-native call this.runPromise', this.runPromise);
+    if (this.runPromise && !forceRun) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
+    }
+
+    const transport = transportCache[uuid] as BleTransport;
+    if (!transport) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
+    }
+
+    this.runPromise = createDeferred();
+    const messages = this._messages;
+    // Upload resources on low-end phones may OOM
+    if (name === 'ResourceUpdate' || name === 'ResourceAck') {
+      this.Log.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', {
+        file_name: data?.file_name,
+        hash: data?.hash,
+      });
+    } else if (LogBlockCommand.has(name)) {
+      this.Log.debug('transport-react-native', 'call-', ' name: ', name);
+    } else {
+      this.Log.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', data);
+    }
+
+    const buffers = buildBuffers(messages, name, data);
+
+    async function writeChunkedData(
+      buffers: ByteBuffer[],
+      writeFunction: (data: string) => Promise<void>,
+      onError: (e: any) => void
+    ) {
+      const packetCapacity = Platform.OS === 'ios' ? IOS_PACKET_LENGTH : ANDROID_PACKET_LENGTH;
+      let index = 0;
+      let chunk = ByteBuffer.allocate(packetCapacity);
+
+      while (index < buffers.length) {
+        const buffer = buffers[index].toBuffer();
+        chunk.append(buffer);
+        index += 1;
+
+        if (chunk.offset === packetCapacity || index >= buffers.length) {
+          chunk.reset();
+          try {
+            await writeFunction(chunk.toString('base64'));
+            chunk = ByteBuffer.allocate(packetCapacity);
+          } catch (e) {
+            onError(e);
+            throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
+          }
+        }
+      }
+    }
+
+    if (name === 'EmmcFileWrite') {
+      await writeChunkedData(
+        buffers,
+        data => transport.writeWithRetry(data),
+        e => {
+          this.runPromise = null;
+          this.Log.error('writeCharacteristic write error: ', e);
+        }
+      );
+    } else if (name === 'FirmwareUpload') {
+      await writeChunkedData(
+        buffers,
+        async data => {
+          await transport.writeCharacteristic.writeWithoutResponse(data);
+        },
+        e => {
+          this.runPromise = null;
+          this.Log.error('writeCharacteristic write error: ', e);
+        }
+      );
+    } else {
+      for (const o of buffers) {
+        const outData = o.toString('base64');
+        // Upload resources on low-end phones may OOM
+        // this.Log.debug('send hex strting: ', o.toString('hex'));
+        try {
+          await transport.writeCharacteristic.writeWithoutResponse(outData);
+        } catch (e) {
+          this.Log.debug('writeCharacteristic write error: ', e);
+          this.runPromise = null;
+          if (e.errorCode === BleErrorCode.DeviceDisconnected) {
+            throw ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded);
+          } else if (e.errorCode === BleErrorCode.OperationStartFailed) {
+            throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError, e.reason);
+          } else {
+            throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
+          }
+        }
+      }
+    }
+
+    try {
+      const response = await this.runPromise.promise;
+
+      if (typeof response !== 'string') {
+        throw new Error('Returning data is not string.');
+      }
+
+      this.Log.debug('receive data: ', response);
+      const jsonData = receiveOne(messages, response);
+      return check.call(jsonData);
+    } catch (e) {
+      this.Log.error('call error: ', e);
+      throw e;
+    } finally {
+      this.runPromise = null;
+    }
+  }
+
+  stop() {
+    this.stopped = true;
+  }
+
+  cancel() {
+    this.Log.debug('transport-react-native transport cancel');
+    if (this.runPromise) {
+      // this.runPromise.reject(new Error('Transport_CallCanceled'));
+    }
+    this.runPromise = null;
+  }
+}

package/src/subscribeBleOn.ts

@@ -0,0 +1,26 @@
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { BlePlxManager } from './types';
+import timer from './utils/timer';
+
+export const subscribeBleOn = (bleManager: BlePlxManager, ms = 1000): Promise<void> =>
+  new Promise((resolve, reject) => {
+    let done = false;
+
+    const subscription = bleManager.onStateChange(state => {
+      console.log('ble state -> ', state);
+
+      if (state === 'PoweredOn') {
+        if (done) return;
+        clearTimeout();
+        done = true;
+        subscription.remove();
+        resolve();
+      }
+    }, true);
+
+    const clearTimeout = timer.timeout(() => {
+      if (done) return;
+      subscription.remove();
+      reject(ERRORS.TypedError(HardwareErrorCode.BlePermissionError));
+    }, ms);
+  });

package/src/types.ts

@@ -0,0 +1,10 @@
+export type { BleManager as BlePlxManager } from 'react-native-ble-plx';
+
+export type TransportOptions = {
+  scanTimeout?: number;
+};
+
+export type BleAcquireInput = {
+  uuid: string;
+  forceCleanRunPromise?: boolean;
+};