@ukeyfe/hardware-core 1.1.13

package/src/api/CheckFirmwareRelease.ts

@@ -0,0 +1,24 @@
+import { BaseMethod } from './BaseMethod';
+import { UI_REQUEST } from '../constants/ui-request';
+
+import { getFirmwareReleaseInfo } from './firmware/releaseHelper';
+
+export default class CheckFirmwareRelease extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [
+      ...this.allowDeviceMode,
+      UI_REQUEST.NOT_INITIALIZE,
+      UI_REQUEST.BOOTLOADER,
+    ];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  run() {
+    if (this.device.features) {
+      const releaseInfo = getFirmwareReleaseInfo(this.device.features);
+      return Promise.resolve(releaseInfo);
+    }
+    return Promise.resolve(null);
+  }
+}

package/src/api/CipherKeyValue.ts

@@ -0,0 +1,67 @@
+import { CipherKeyValue as HardwareCipherKeyValue } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../constants/ui-request';
+import { serializedPath, validatePath } from './helpers/pathUtils';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import { CipheredKeyValue, CipheredKeyValueParams } from '../types';
+import { formatAnyHex } from './helpers/hexUtils';
+
+export default class CipherKeyValue extends BaseMethod<HardwareCipherKeyValue[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: CipheredKeyValueParams) => {
+      const addressN = validatePath(batch.path);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'key', type: 'string' },
+        { name: 'value', type: 'hexString' },
+        { name: 'encrypt', type: 'boolean' },
+        { name: 'askOnEncrypt', type: 'boolean' },
+        { name: 'askOnDecrypt', type: 'boolean' },
+        { name: 'iv', type: 'hexString' },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        key: batch.key,
+        value: formatAnyHex(batch.value),
+        encrypt: batch.encrypt,
+        ask_on_encrypt: batch.askOnEncrypt,
+        ask_on_decrypt: batch.askOnDecrypt,
+        iv: formatAnyHex(batch.iv),
+      });
+    });
+  }
+
+  async run() {
+    const responses: CipheredKeyValue[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('CipherKeyValue', 'CipheredKeyValue', {
+        ...param,
+      });
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        ...res.message,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/EmmcFileWrite.ts

@@ -0,0 +1,49 @@
+import { RebootType } from '@ukeyfe/hardware-transport';
+import { validateParams } from './helpers/paramsValidator';
+import { UI_REQUEST } from '../events/ui-request';
+import { FirmwareUpdateBaseMethod } from './firmware/FirmwareUpdateBaseMethod';
+import type { PROTO } from '../constants';
+
+/**
+ * 简单封装的 EMMC 文件写入方法
+ * - 仅调用 emmcCommonUpdateProcess，将指定二进制内容写入到给定 emmc 路径
+ */
+type EmmcFileWriteParams = PROTO.FirmwareUpload & {
+  /** 目标写入路径（需以 `0:` 开头，例如 `0:updates/firmware.bin`） */
+  filePath: string;
+};
+
+export default class EmmcFileWrite extends FirmwareUpdateBaseMethod<EmmcFileWriteParams> {
+  init() {
+    const { payload } = this;
+    // 仅做基本参数校验，不引入任何接口条件判断
+    validateParams(payload, [
+      { name: 'payload', type: 'buffer', required: true },
+      { name: 'filePath', type: 'string', required: true },
+    ]);
+
+    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      payload: payload.payload,
+      filePath: payload.filePath,
+    };
+  }
+
+  async run() {
+    const { payload, filePath } = this.params;
+    await this.enterBootloaderMode();
+    await this.emmcCommonUpdateProcess({ payload, filePath });
+    // 写入完成后执行正常重启
+    try {
+      await this.reboot(RebootType.Normal);
+    } catch (e) {
+      // 重启失败不影响写入结果，保守记录但不抛出
+    }
+
+    return {
+      filePath,
+    };
+  }
+}

package/src/api/FirmwareUpdate.ts

@@ -0,0 +1,216 @@
+import {
+  ERRORS,
+  HardwareErrorCode,
+  HardwareError,
+  createDeferred,
+  Deferred,
+} from '@ukeyfe/hardware-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 { type KnownDevice, DeviceModelToTypes } 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';
+
+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,
+        });
+        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 }
+    );
+
+    if (this.connectId) {
+      DevicePool.clearDeviceCache(this.connectId);
+    }
+
+    return response;
+  }
+}