@onetokenfe/hd-core 1.1.23

package/src/api/FirmwareUpdate.ts

@@ -0,0 +1,219 @@
+import {
+  EFirmwareType,
+  ERRORS,
+  HardwareError,
+  HardwareErrorCode,
+  createDeferred,
+} from '@onetokenfe/hd-shared';
+
+import { UI_REQUEST } from '../constants/ui-request';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import { getBinary } from './firmware/getBinary';
+import { uploadFirmware } from './firmware/uploadFirmware';
+import { createUiMessage } from '../events';
+import { DeviceModelToTypes, type KnownDevice } from '../types';
+import { isEnteredManuallyBoot } from './firmware/bootloaderHelper';
+import { LoggerNames, getDeviceType, getDeviceUUID, getLogger, wait } from '../utils';
+import { DataManager } from '../data-manager';
+import { DevicePool } from '../device/DevicePool';
+
+import type { Deferred } from '@onetokenfe/hd-shared';
+
+type Params = {
+  binary?: ArrayBuffer;
+  version?: number[];
+  updateType: 'firmware' | 'ble';
+};
+
+const Log = getLogger(LoggerNames.Method);
+
+export default class FirmwareUpdate extends BaseMethod<Params> {
+  checkPromise: Deferred<any> | null = null;
+
+  init() {
+    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
+    this.requireDeviceMode = [];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+
+    const { payload } = this;
+
+    validateParams(payload, [
+      { name: 'version', type: 'array' },
+      { name: 'binary', type: 'buffer' },
+      { name: 'updateType', type: 'string', required: true },
+      { name: 'rebootOnSuccess', type: 'boolean' },
+    ]);
+
+    this.params = { updateType: payload.updateType };
+
+    if ('version' in payload) {
+      this.params = {
+        ...this.params,
+        version: payload.version,
+      };
+    }
+
+    if ('binary' in payload) {
+      this.params = {
+        ...this.params,
+        binary: payload.binary,
+      };
+    }
+  }
+
+  postTipMessage = (message: string) => {
+    this.postMessage(
+      createUiMessage(UI_REQUEST.FIRMWARE_TIP, {
+        device: this.device.toMessageObject() as KnownDevice,
+        data: {
+          message,
+        },
+      })
+    );
+  };
+
+  checkDeviceToBootloader(connectId: string | undefined) {
+    this.checkPromise = createDeferred();
+    const env = DataManager.getSettings('env');
+    const isBleReconnect = connectId && DataManager.isBleConnect(env);
+
+    Log.log('FirmwareUpdate [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
+
+    // check device goto bootloader mode
+    const intervalTimer: ReturnType<typeof setInterval> | undefined = setInterval(
+      async () => {
+        if (isBleReconnect) {
+          try {
+            await this.device.deviceConnector?.acquire(
+              this.device.originalDescriptor.id,
+              null,
+              true
+            );
+            await this.device.initialize();
+            if (this.device.features?.bootloader_mode) {
+              clearInterval(intervalTimer);
+              this.checkPromise?.resolve(true);
+            }
+          } catch (e) {
+            // ignore error because of device is not connected
+            Log.log('catch Bluetooth error when device is restarting: ', e);
+          }
+        } else {
+          const deviceDiff = await this.device.deviceConnector?.enumerate();
+          const devicesDescriptor = deviceDiff?.descriptors ?? [];
+          const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId);
+
+          if (deviceList.length === 1 && deviceList[0]?.features?.bootloader_mode) {
+            // should update current device from cache
+            // because device was reboot and had some new requests
+            this.device.updateFromCache(deviceList[0]);
+            this.device.commands.disposed = false;
+
+            clearInterval(intervalTimer);
+            this.checkPromise?.resolve(true);
+          }
+        }
+      },
+      isBleReconnect ? 3000 : 2000
+    );
+
+    // check goto bootloader mode timeout and throw error
+    setTimeout(() => {
+      if (this.checkPromise) {
+        clearInterval(intervalTimer);
+        this.checkPromise.reject(new Error());
+      }
+    }, 30000);
+  }
+
+  async run() {
+    const { device, params } = this;
+    const { features, commands } = device;
+    const deviceType = getDeviceType(features);
+
+    if (!features?.bootloader_mode && features) {
+      const uuid = getDeviceUUID(features);
+      // should go to bootloader mode manually
+      if (isEnteredManuallyBoot(features, params.updateType)) {
+        return Promise.reject(ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateManuallyEnterBoot));
+      }
+
+      // auto go to bootloader mode
+      try {
+        this.postTipMessage('AutoRebootToBootloader');
+        const bootRes = await commands.typedCall('DeviceBackToBoot', 'Success');
+        // @ts-expect-error
+        if (bootRes.type === 'CallMethodError') {
+          throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure);
+        }
+        this.postTipMessage('GoToBootloaderSuccess');
+        this.checkDeviceToBootloader(this.payload.connectId);
+
+        // force clean classic device cache so that the device can initialize again
+        if (DeviceModelToTypes.model_classic.includes(deviceType)) {
+          DevicePool.clearDeviceCache(uuid);
+        }
+        delete DevicePool.devicesCache[''];
+        await this.checkPromise?.promise;
+        this.checkPromise = null;
+        /**
+         * Touch 1 with bootloader v2.5.0 issue: BLE chip need more time for looking up name, here change the delay time to 3000ms after rebooting.
+         */
+        const isTouch = DeviceModelToTypes.model_touch.includes(deviceType);
+        await wait(isTouch ? 3000 : 1500);
+      } catch (e) {
+        if (e instanceof HardwareError) {
+          return Promise.reject(e);
+        }
+        Log.log('auto go to bootloader mode failed: ', e);
+        return Promise.reject(
+          ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure)
+        );
+      }
+    }
+
+    let binary;
+    try {
+      if (params.binary) {
+        binary = this.params.binary;
+      } else {
+        if (!device.features) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'no features found for this device'
+          );
+        }
+        this.postTipMessage('DownloadFirmware');
+        const firmware = await getBinary({
+          features: device.features,
+          version: params.version,
+          updateType: params.updateType,
+          firmwareType: EFirmwareType.Universal,
+        });
+        binary = firmware.binary;
+        this.postTipMessage('DownloadFirmwareSuccess');
+      }
+    } catch (err) {
+      throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
+    }
+
+    await this.device.acquire();
+
+    const response = await uploadFirmware(
+      params.updateType,
+      this.device.getCommands().typedCall.bind(this.device.getCommands()),
+      this.postMessage,
+      device,
+      { payload: binary, rebootOnSuccess: this.payload.rebootOnSuccess },
+      false
+    );
+
+    if (this.connectId) {
+      DevicePool.clearDeviceCache(this.connectId);
+    }
+
+    return response;
+  }
+}

package/src/api/FirmwareUpdateV2.ts

@@ -0,0 +1,408 @@
+import {
+  type Deferred,
+  EDeviceType,
+  type EFirmwareType,
+  ERRORS,
+  HardwareError,
+  HardwareErrorCode,
+  createDeferred,
+} from '@onetokenfe/hd-shared';
+import semver from 'semver';
+
+import { UI_REQUEST } from '../constants/ui-request';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import { DevicePool } from '../device/DevicePool';
+import { getBinary, getInfo, getSysResourceBinary } from './firmware/getBinary';
+import { updateResources, uploadFirmware } from './firmware/uploadFirmware';
+import {
+  LoggerNames,
+  getDeviceFirmwareVersion,
+  getDeviceType,
+  getDeviceUUID,
+  getFirmwareType,
+  getLogger,
+  wait,
+} from '../utils';
+import { FirmwareUpdateTipMessage, createUiMessage } from '../events/ui-request';
+import { DeviceModelToTypes } from '../types';
+import { DataManager } from '../data-manager';
+import { DEVICE } from '../events';
+
+import type { Features, KnownDevice } from '../types';
+import type { Device } from '../device/Device';
+
+type Params = {
+  binary?: ArrayBuffer;
+  version?: number[];
+  updateType: 'firmware' | 'ble';
+  forcedUpdateRes?: boolean;
+  isUpdateBootloader?: boolean;
+  firmwareType?: EFirmwareType;
+};
+
+const Log = getLogger(LoggerNames.Method);
+
+export default class FirmwareUpdateV2 extends BaseMethod<Params> {
+  checkPromise: Deferred<any> | null = null;
+
+  init() {
+    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
+    this.requireDeviceMode = [];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+
+    const { payload } = this;
+
+    validateParams(payload, [
+      { name: 'version', type: 'array' },
+      { name: 'binary', type: 'buffer' },
+      { name: 'forcedUpdateRes', type: 'boolean' },
+      { name: 'platform', type: 'string', required: true },
+      { name: 'firmwareType', type: 'string' },
+    ]);
+
+    if (!payload.updateType) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'updateType is required'
+      );
+    }
+
+    this.params = {
+      updateType: payload.updateType,
+      forcedUpdateRes: payload.forcedUpdateRes,
+      isUpdateBootloader: payload.isUpdateBootloader,
+    };
+
+    if ('version' in payload) {
+      this.params = {
+        ...this.params,
+        version: payload.version,
+        firmwareType: payload.firmwareType,
+      };
+    }
+
+    if ('binary' in payload) {
+      this.params = {
+        ...this.params,
+        binary: payload.binary,
+      };
+    }
+  }
+
+  postTipMessage = (message: string) => {
+    this.postMessage(
+      createUiMessage(UI_REQUEST.FIRMWARE_TIP, {
+        device: this.device.toMessageObject() as KnownDevice,
+        data: {
+          message,
+        },
+      })
+    );
+  };
+
+  private async _promptDeviceInBootloaderForWebDevice({ device }: { device: Device }) {
+    return new Promise((resolve, reject) => {
+      if (this.device.listenerCount(DEVICE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE) > 0) {
+        this.device.emit(
+          DEVICE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE,
+          this.device,
+          (err, deviceId) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(deviceId);
+            }
+          }
+        );
+      }
+    });
+  }
+
+  checkDeviceToBootloader(connectId: string | undefined) {
+    this.checkPromise = createDeferred();
+    const env = DataManager.getSettings('env');
+    const isBleReconnect = connectId && DataManager.isBleConnect(env);
+
+    Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
+
+    // check device goto bootloader mode
+    let isFirstCheck = true;
+    let checkCount = 0;
+    // eslint-disable-next-line prefer-const
+    let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
+
+    const isTouchOrProDevice =
+      getDeviceType(this?.device?.features) === EDeviceType.Touch ||
+      getDeviceType(this?.device?.features) === EDeviceType.Pro;
+
+    const intervalTimer: ReturnType<typeof setInterval> | undefined = setInterval(
+      async () => {
+        checkCount += 1;
+        Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
+        if (isTouchOrProDevice && isFirstCheck) {
+          isFirstCheck = false;
+          Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] wait 3000ms');
+          await wait(3000);
+        }
+
+        if (
+          checkCount > 4 &&
+          DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
+          !this.payload.skipWebDevicePrompt
+        ) {
+          clearInterval(intervalTimer);
+          clearTimeout(timeoutTimer);
+
+          try {
+            this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
+            const confirmed = await this._promptDeviceInBootloaderForWebDevice({
+              device: this.device,
+            });
+            if (confirmed) {
+              await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
+            }
+          } catch (e) {
+            Log.log(
+              'FirmwareUpdateV2 [checkDeviceToBootloader] promptDeviceInBootloaderForWebDevice failed: ',
+              e
+            );
+            this.checkPromise?.reject(e);
+          }
+          return;
+        }
+
+        if (isBleReconnect) {
+          try {
+            await this.device.deviceConnector?.acquire(
+              this.device.originalDescriptor.id,
+              null,
+              true
+            );
+            await this.device.initialize();
+            if (this.device.features?.bootloader_mode) {
+              clearInterval(intervalTimer);
+              this.checkPromise?.resolve(true);
+            }
+          } catch (e) {
+            // ignore error because of device is not connected
+            Log.log('catch Bluetooth error when device is restarting: ', e);
+          }
+        } else {
+          await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
+        }
+      },
+      isBleReconnect ? 3000 : 2000
+    );
+
+    // check goto bootloader mode timeout and throw error
+    timeoutTimer = setTimeout(() => {
+      if (this.checkPromise) {
+        clearInterval(intervalTimer);
+        this.checkPromise.reject(new Error());
+      }
+    }, 30000);
+  }
+
+  private async _checkDeviceInBootloaderMode(
+    connectId: string | undefined,
+    intervalTimer?: ReturnType<typeof setInterval>,
+    timeoutTimer?: ReturnType<typeof setTimeout>
+  ) {
+    const deviceDiff = await this.device.deviceConnector?.enumerate();
+    const devicesDescriptor = deviceDiff?.descriptors ?? [];
+    const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId);
+
+    if (deviceList.length === 1 && deviceList[0]?.features?.bootloader_mode) {
+      // should update current device from cache
+      // because device was reboot and had some new requests
+      this.device.updateFromCache(deviceList[0]);
+      this.device.commands.disposed = false;
+
+      if (intervalTimer) clearInterval(intervalTimer);
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      this.checkPromise?.resolve(true);
+      return true;
+    }
+    return false;
+  }
+
+  isEnteredManuallyBoot(features: Features) {
+    const deviceType = getDeviceType(features);
+    const isMini = deviceType === EDeviceType.Mini;
+    const isBoot183ClassicUpBle =
+      this.params.updateType === 'firmware' &&
+      deviceType === EDeviceType.Classic &&
+      features.bootloader_version === '1.8.3';
+    return isMini || isBoot183ClassicUpBle;
+  }
+
+  isSupportResourceUpdate(features: Features, updateType: string) {
+    if (updateType !== 'firmware') return false;
+
+    const deviceType = getDeviceType(features);
+    const isTouchMode = deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro;
+    const currentVersion = getDeviceFirmwareVersion(features).join('.');
+
+    return isTouchMode && semver.gte(currentVersion, '3.2.0');
+  }
+
+  /**
+   * Check the version number of Touch to determine if it
+   * needs to be upgraded via the desktop
+   */
+  checkVersionForCopyTouchResource(features: Features | undefined, firmwareType: EFirmwareType) {
+    if (!features) return;
+    const deviceType = getDeviceType(features);
+    const currentVersion = getDeviceFirmwareVersion(features).join('.');
+    const targetVersion = this.params.version?.join('.');
+    const { updateType } = this.params;
+
+    const releaseInfo = getInfo({ features, updateType, firmwareType });
+    if (!releaseInfo) return;
+    const { fullResourceRange } = releaseInfo;
+    if (!fullResourceRange) return;
+
+    const [minVersion, limitVersion] = fullResourceRange;
+    if (deviceType === EDeviceType.Touch && updateType === 'firmware' && targetVersion) {
+      if (
+        semver.lt(currentVersion, minVersion) &&
+        semver.gte(targetVersion, limitVersion) &&
+        this.payload.platform !== 'desktop'
+      ) {
+        throw ERRORS.TypedError(HardwareErrorCode.UseDesktopToUpdateFirmware);
+      }
+    }
+  }
+
+  async run() {
+    const { device, params } = this;
+    const { features, commands } = device;
+    const deviceType = getDeviceType(features);
+
+    const deviceFirmwareType = getFirmwareType(device.features);
+    const firmwareType = params.firmwareType ?? deviceFirmwareType;
+
+    this.checkVersionForCopyTouchResource(features, firmwareType);
+
+    if (!features?.bootloader_mode && features) {
+      const uuid = getDeviceUUID(features);
+      // should go to bootloader mode manually
+      if (this.isEnteredManuallyBoot(features)) {
+        return Promise.reject(ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateManuallyEnterBoot));
+      }
+
+      // check & upgrade firmware resource
+      if (features && this.isSupportResourceUpdate(features, params.updateType)) {
+        this.postTipMessage('CheckLatestUiResource');
+        const resourceUrl = DataManager.getSysResourcesLatestRelease({
+          features,
+          forcedUpdateRes: params.forcedUpdateRes,
+          firmwareType,
+        });
+        if (resourceUrl) {
+          this.postTipMessage('DownloadLatestUiResource');
+          const resource = await getSysResourceBinary(resourceUrl);
+          this.postTipMessage('DownloadLatestUiResourceSuccess');
+          if (resource) {
+            await updateResources(
+              this.device.getCommands().typedCall.bind(this.device.getCommands()),
+              this.postMessage,
+              device,
+              resource.binary
+            );
+          }
+        }
+      }
+
+      // check if the device commands has been disposed
+      this.device?.commands?.checkDisposed();
+
+      // auto go to bootloader mode
+      try {
+        this.postTipMessage('AutoRebootToBootloader');
+        const bootRes = await commands.typedCall('DeviceBackToBoot', 'Success');
+        // @ts-expect-error
+        if (bootRes.type === 'CallMethodError') {
+          throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure);
+        }
+        this.postTipMessage('GoToBootloaderSuccess');
+        this.checkDeviceToBootloader(this.payload.connectId);
+
+        // force clean classic device cache so that the device can initialize again
+        if (DeviceModelToTypes.model_classic.includes(deviceType)) {
+          DevicePool.clearDeviceCache(uuid);
+        }
+        delete DevicePool.devicesCache[''];
+        await this.checkPromise?.promise;
+        this.checkPromise = null;
+
+        // check if the device commands has been disposed
+        this.device?.commands?.checkDisposed();
+
+        /**
+         * Touch 1 with bootloader v2.5.0 issue: BLE chip need more time for looking up name, here change the delay time to 3000ms after rebooting.
+         */
+        const isTouch = DeviceModelToTypes.model_touch.includes(deviceType);
+        await wait(isTouch ? 3000 : 1500);
+      } catch (e) {
+        if (e instanceof HardwareError) {
+          return Promise.reject(e);
+        }
+        console.log('auto go to bootloader mode failed: ', e);
+        return Promise.reject(
+          ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure)
+        );
+      }
+    }
+
+    let binary;
+
+    try {
+      if (params.binary) {
+        binary = this.params.binary;
+      } else {
+        if (!device.features) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'no features found for this device'
+          );
+        }
+        this.postTipMessage('DownloadFirmware');
+
+        const firmware = await getBinary({
+          features: device.features,
+          version: params.version,
+          updateType: params.updateType,
+          isUpdateBootloader: params.isUpdateBootloader,
+          firmwareType,
+        });
+        binary = firmware.binary;
+        this.postTipMessage('DownloadFirmwareSuccess');
+      }
+    } catch (err) {
+      throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
+    }
+
+    // check if the device commands has been disposed
+    this.device?.commands?.checkDisposed();
+
+    await this.device.acquire();
+
+    const response = await uploadFirmware(
+      params.updateType,
+      this.device.getCommands().typedCall.bind(this.device.getCommands()),
+      this.postMessage,
+      device,
+      { payload: binary, rebootOnSuccess: true },
+      params.isUpdateBootloader
+    );
+
+    if (this.connectId) {
+      DevicePool.clearDeviceCache(this.connectId);
+    }
+
+    return response;
+  }
+}