@onekeyfe/hd-core 1.2.0-alpha.66 → 1.2.0-alpha.68

package/src/api/CheckAllFirmwareRelease.ts

@@ -1,6 +1,13 @@
-import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import {
+  EDeviceType,
+  EFirmwareType,
+  ERRORS,
+  HardwareError,
+  HardwareErrorCode,
+} from '@onekeyfe/hd-shared';
 import semver from 'semver';
 
+import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { DataManager } from '../data-manager';
 import {
@@ -8,13 +15,22 @@ import {
   getBootloaderReleaseInfo,
   getFirmwareReleaseInfo,
 } from './firmware/releaseHelper';
+import {
+  buildFirmwareUpdatePlan,
+  validateFirmwareUpdatePlanForceTargets,
+} from './firmware/FirmwareUpdatePlan';
 import { getBridgeReleaseInfo } from '../utils/bridgeUpdate';
-import { getDeviceFirmwareVersion, getDeviceType, getFirmwareType } from '../utils';
-import { BaseMethod } from './BaseMethod';
 import {
   buildProtocolV2ResourceUpdatePlan,
   readProtocolV2ResourceInventory,
 } from '../protocols/protocol-v2/resources';
+import {
+  LoggerNames,
+  getDeviceFirmwareVersion,
+  getDeviceType,
+  getFirmwareType,
+  getLogger,
+} from '../utils';
 
 import type {
   AllFirmwareRelease,
@@ -30,6 +46,7 @@ import type {
   IProtocolV2FirmwareComponent,
   IProtocolV2FirmwareComponentTarget,
 } from '../types';
+import type { FirmwareUpdatePlan } from '../types/api/firmwareUpdatePlan';
 
 const UPDATE_TARGET_BY_COMPONENT_TARGET: Readonly<
   Partial<Record<IProtocolV2FirmwareComponentTarget, FirmwareUpdateV4Target>>
@@ -252,6 +269,8 @@ export function buildProtocolV2FirmwareRelease({
   };
 }
 
+const Log = getLogger(LoggerNames.Method);
+
 export default class CheckAllFirmwareRelease extends BaseMethod {
   getSupportedProtocols() {
     return ['V1', 'V2'] as const;
@@ -269,8 +288,13 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
     }
 
     const { features } = this.device;
-    const { checkBridgeRelease, firmwareType: firmwareTypeParams } = this
-      .payload as CheckAllFirmwareReleaseParams;
+    const {
+      checkBridgeRelease,
+      firmwareType: firmwareTypeParams,
+      platform,
+      forceUpdateTargets,
+    } = this.payload as CheckAllFirmwareReleaseParams;
+    const validatedForceUpdateTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
 
     if (!features) {
       return Promise.resolve(null);
@@ -301,6 +325,32 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
       firmwareType,
     });
     const bleFirmwareReleaseInfo = getBleFirmwareReleaseInfo(features);
+    let firmwareUpdatePlan: FirmwareUpdatePlan | undefined;
+    try {
+      firmwareUpdatePlan = buildFirmwareUpdatePlan({
+        features,
+        firmwareType,
+        platform: platform ?? 'web',
+        firmware: firmwareRelease,
+        ble: bleFirmwareReleaseInfo,
+        bootloader: bootloaderRelease,
+        forceUpdateTargets: validatedForceUpdateTargets,
+      });
+    } catch (error) {
+      if (
+        validatedForceUpdateTargets.length > 0 ||
+        !(error instanceof HardwareError) ||
+        error.params?.firmwareUpdateCode !== 'FirmwarePlanInvalid'
+      ) {
+        throw error;
+      }
+      // A Plan is an optional external-host capability. Release checks remain
+      // available for legacy and recovery flows when a Plan cannot be built.
+      Log.warn(
+        '[CheckAllFirmwareRelease] Optional firmware Plan is unavailable; using the legacy release result'
+      );
+      firmwareUpdatePlan = undefined;
+    }
 
     return {
       firmware: firmwareRelease,
@@ -315,7 +365,8 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
           }
         : undefined,
       features,
-    } as AllFirmwareRelease;
+      firmwareUpdatePlan,
+    } as unknown as AllFirmwareRelease;
   }
 
   private async runProtocolV2(): Promise<AllFirmwareRelease> {

package/src/api/FirmwareUpdate.ts

@@ -10,6 +10,7 @@ import { UI_REQUEST } from '../constants/ui-request';
 import { BaseMethod } from './BaseMethod';
 import { validateParams } from './helpers/paramsValidator';
 import { getBinary } from './firmware/getBinary';
+import { BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS } from './firmware/FirmwareUpdateBaseMethod';
 import { uploadFirmware } from './firmware/uploadFirmware';
 import { createUiMessage } from '../events';
 import { DeviceModelToTypes, type KnownDevice } from '../types';
@@ -78,6 +79,10 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
     this.checkPromise = createDeferred();
     const env = DataManager.getSettings('env');
     const isBleReconnect = connectId && DataManager.isBleConnect(env);
+    // Tracks the in-flight BLE probe so interval ticks never overlap: a superseded
+    // Initialize left pending on the V1 transport is exactly what later times out
+    // and used to tear down the connection mid-firmware-upload.
+    let bleProbeInFlight = false;
 
     Log.log('FirmwareUpdate [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
 
@@ -85,6 +90,8 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
     const intervalTimer: ReturnType<typeof setInterval> | undefined = setInterval(
       async () => {
         if (isBleReconnect) {
+          if (bleProbeInFlight) return;
+          bleProbeInFlight = true;
           try {
             await this.device.deviceConnector?.acquire(
               this.device.originalDescriptor.id,
@@ -92,7 +99,10 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
               true,
               this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
             );
-            await this.device.initialize();
+            // Bound each probe so a request the rebooting device never received
+            // frees the slot for the next tick instead of hanging into the
+            // 30s reboot budget.
+            await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
             if (this.device.isBootloader()) {
               clearInterval(intervalTimer);
               this.checkPromise?.resolve(true);
@@ -100,6 +110,8 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
           } catch (e) {
             // ignore error because of device is not connected
             Log.log('catch Bluetooth error when device is restarting: ', e);
+          } finally {
+            bleProbeInFlight = false;
           }
         } else {
           const deviceDiff = await this.device.deviceConnector?.enumerate();

package/src/api/FirmwareUpdateV2.ts

@@ -14,18 +14,45 @@ 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, getLogger, wait } from '../utils';
+import { normalizeFirmwarePreparationError } from './firmware/FirmwarePreparationError';
+import {
+  updateResources,
+  updateResourcesFromSources,
+  uploadFirmwareFromSource,
+} from './firmware/uploadFirmware';
+import { BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS } from './firmware/FirmwareUpdateBaseMethod';
+import { LoggerNames, getDeviceType, getDeviceUUID, getLogger, wait } from '../utils';
+import { resolveDeviceBootloaderMode } from '../utils/deviceFeaturesCompat';
 import { FirmwareUpdateTipMessage, createUiMessage } from '../events/ui-request';
 import { DeviceModelToTypes } from '../types';
 import { DataManager } from '../data-manager';
 import { DEVICE } from '../events';
+import { type FirmwareByteSource, openFirmwareByteSource } from './firmware/FirmwareArtifactSource';
+import { resolveFirmwareUpdateHostBinding } from './firmware/FirmwareHostBinding';
+import {
+  assertFirmwareUpdatePreparedPlanBinding,
+  assertFirmwareUpdatePreparedPlanDeviceIdentity,
+  getFirmwareUpdateResourceName,
+} from './firmware/FirmwareUpdatePreparedPlan';
 
 import type { Features, KnownDevice } from '../types';
 import type { FirmwareBinary } from './firmware/getBinary';
+import type {
+  FirmwareArtifactReader,
+  FirmwareArtifactReference,
+} from '../types/api/firmwareUpdate';
+import type { FirmwareUpdatePreparedPlan } from '../types/api/firmwareUpdatePreparedPlan';
 
 type Params = {
   binary?: ArrayBuffer;
+  artifact?: FirmwareArtifactReference;
+  resourceEntries?: Array<{
+    entryName: string;
+    artifact: FirmwareArtifactReference;
+  }>;
+  artifactReader?: FirmwareArtifactReader;
+  preparedPlan?: FirmwareUpdatePreparedPlan;
+  platform?: FirmwareUpdatePreparedPlan['platform'];
   version?: number[];
   updateType: 'firmware' | 'ble';
   forcedUpdateRes?: boolean;
@@ -106,6 +133,13 @@ const normalizeFirmwareBinary = (binary: unknown): FirmwareBinary | undefined =>
   return normalized.buffer;
 };
 
+const toArrayBuffer = (binary: FirmwareBinary): ArrayBuffer => {
+  if (binary instanceof ArrayBuffer) {
+    return binary;
+  }
+  return new Uint8Array(binary.buffer, binary.byteOffset, binary.byteLength).slice().buffer;
+};
+
 export default class FirmwareUpdateV2 extends BaseMethod<Params> {
   checkPromise: Deferred<any> | null = null;
 
@@ -152,6 +186,32 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
         binary: payload.binary,
       };
     }
+
+    if ('artifact' in payload) {
+      const hostBinding = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration);
+      const target = payload.isUpdateBootloader ? 'bootloader' : payload.updateType;
+      const resourceBindings = (payload.resourceEntries ?? []).map(
+        (entry: { entryName: string; artifact: FirmwareArtifactReference }) => ({
+          target: 'resource' as const,
+          entryName: entry.entryName,
+          artifact: entry.artifact,
+        })
+      );
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan: payload.preparedPlan,
+        executor: 'v2',
+        platform: payload.platform,
+        scopeTargets: [target, ...(target === 'firmware' ? (['resource'] as const) : [])],
+        bindings: [{ target, artifact: payload.artifact }, ...resourceBindings],
+      });
+      this.params = {
+        ...this.params,
+        preparedPlan: payload.preparedPlan,
+        artifact: payload.artifact,
+        resourceEntries: payload.resourceEntries,
+        artifactReader: hostBinding.artifactReader,
+      };
+    }
   }
 
   postTipMessage = (message: string) => {
@@ -187,6 +247,10 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
     this.checkPromise = createDeferred();
     const env = DataManager.getSettings('env');
     const isBleReconnect = connectId && DataManager.isBleConnect(env);
+    // Tracks the in-flight BLE probe so interval ticks never overlap: a superseded
+    // Initialize left pending on the V1 transport is exactly what later times out
+    // and used to tear down the connection mid-firmware-upload.
+    let bleProbeInFlight = false;
 
     Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
 
@@ -234,6 +298,8 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
         }
 
         if (isBleReconnect) {
+          if (bleProbeInFlight) return;
+          bleProbeInFlight = true;
           try {
             await this.device.deviceConnector?.acquire(
               this.device.originalDescriptor.id,
@@ -241,7 +307,10 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
               true,
               this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
             );
-            await this.device.initialize();
+            // Bound each probe so a request the rebooting device never received
+            // frees the slot for the next tick instead of hanging into the
+            // 30s reboot budget.
+            await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
             if (this.device.isBootloader()) {
               clearInterval(intervalTimer);
               this.checkPromise?.resolve(true);
@@ -249,6 +318,8 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
           } catch (e) {
             // ignore error because of device is not connected
             Log.log('catch Bluetooth error when device is restarting: ', e);
+          } finally {
+            bleProbeInFlight = false;
           }
         } else {
           await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
@@ -344,151 +415,255 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
     const { features, commands } = device;
     const deviceType = device.getCurrentDeviceType();
 
+    // Protocol V2 (Pro2) uses DeviceFirmwareUpdate and must not enter this legacy flow.
+    if (device.isProtocolV2()) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 firmware update must use firmwareUpdateV4'
+      );
+    }
+    if (params.preparedPlan) {
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan: params.preparedPlan,
+        deviceIdentity: getDeviceUUID(features) || undefined,
+        bootloaderMode: resolveDeviceBootloaderMode(features),
+        deviceModel: String(getDeviceType(features)),
+      });
+    }
+
     const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = params.firmwareType ?? deviceFirmwareType;
 
     this.checkVersionForCopyTouchResource(features, firmwareType);
 
-    let preparedBinary: FirmwareBinary | undefined;
-    const acquireFirmwareBinary = async (): Promise<FirmwareBinary> => {
-      try {
-        if (preparedBinary) {
-          return preparedBinary;
-        }
-
-        if (params.binary !== undefined) {
-          preparedBinary = normalizeFirmwareBinary(params.binary);
-          if (!preparedBinary) {
-            throw new Error('firmware binary is empty or invalid');
+    let preparedSource: FirmwareByteSource | undefined;
+    try {
+      const acquireFirmwareSource = async (): Promise<FirmwareByteSource> => {
+        try {
+          if (preparedSource) {
+            return preparedSource;
           }
-          return preparedBinary;
-        }
 
-        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,
-          requestOptions: FIRMWARE_DOWNLOAD_REQUEST_OPTIONS,
-        });
-        preparedBinary = normalizeFirmwareBinary(firmware.binary);
-        if (!preparedBinary) {
-          throw new Error('downloaded firmware binary is empty or invalid');
-        }
-        this.postTipMessage('DownloadFirmwareSuccess');
-        return preparedBinary;
-      } catch (err) {
-        throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
-      }
-    };
+          if (params.binary !== undefined) {
+            const binary = normalizeFirmwareBinary(params.binary);
+            if (!binary) {
+              throw new Error('firmware binary is empty or invalid');
+            }
+            const source = await openFirmwareByteSource({
+              binary: toArrayBuffer(binary),
+            });
+            if (!source) {
+              throw new Error('firmware binary is empty or invalid');
+            }
+            preparedSource = source;
+            return source;
+          }
 
-    if (!device.isBootloader() && features) {
-      const serialNo = device.getCurrentSerialNo();
-      // should go to bootloader mode manually
-      if (this.isEnteredManuallyBoot()) {
-        return Promise.reject(ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateManuallyEnterBoot));
-      }
+          if (params.artifact) {
+            const source = await openFirmwareByteSource({
+              artifact: params.artifact,
+              reader: params.artifactReader,
+            });
+            if (!source) {
+              throw new Error('firmware artifact is not prepared');
+            }
+            preparedSource = source;
+            return source;
+          }
 
-      // check & upgrade firmware resource
-      if (this.isSupportResourceUpdate(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
+          if (!device.features) {
+            throw ERRORS.TypedError(
+              HardwareErrorCode.RuntimeError,
+              'no features found for this device'
             );
           }
-        }
-      }
-
-      // check if the device commands has been disposed
-      this.device?.commands?.checkDisposed();
 
-      // A failed firmware download must leave the device in normal mode.
-      await acquireFirmwareBinary();
+          if (
+            params.artifactReader ||
+            DataManager.getSettings('firmwareManifestMode') === 'external-only'
+          ) {
+            throw ERRORS.TypedError(
+              HardwareErrorCode.RuntimeError,
+              'Firmware must be prepared by the external firmware host',
+              {
+                firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+                artifactName: 'firmware',
+              }
+            );
+          }
 
-      // The request may outlive the current transport command instance.
-      this.device?.commands?.checkDisposed();
+          this.postTipMessage('DownloadFirmware');
+          const firmware = await getBinary({
+            features: device.features,
+            version: params.version,
+            updateType: params.updateType,
+            isUpdateBootloader: params.isUpdateBootloader,
+            firmwareType,
+            requestOptions: FIRMWARE_DOWNLOAD_REQUEST_OPTIONS,
+          });
+          const binary = normalizeFirmwareBinary(firmware.binary);
+          if (!binary) {
+            throw new Error('downloaded firmware binary is empty or invalid');
+          }
+          const source = await openFirmwareByteSource({
+            binary: toArrayBuffer(binary),
+          });
+          if (!source) {
+            throw new Error('downloaded firmware binary is empty or invalid');
+          }
+          preparedSource = source;
+          this.postTipMessage('DownloadFirmwareSuccess');
+          return source;
+        } catch (err) {
+          throw normalizeFirmwarePreparationError(err);
+        }
+      };
 
-      // 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);
+      if (!device.isBootloader() && features) {
+        const serialNo = device.getCurrentSerialNo();
+        // should go to bootloader mode manually
+        if (this.isEnteredManuallyBoot()) {
+          throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateManuallyEnterBoot);
         }
-        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(serialNo);
+        // All network-backed input must be ready before the first device mutation.
+        await acquireFirmwareSource();
+
+        // check & upgrade firmware resource
+        if (this.isSupportResourceUpdate(params.updateType)) {
+          this.postTipMessage('CheckLatestUiResource');
+          const resourceUrl = DataManager.getSysResourcesLatestRelease({
+            features,
+            forcedUpdateRes: params.forcedUpdateRes,
+            firmwareType,
+          });
+          if (resourceUrl) {
+            this.postTipMessage('DownloadLatestUiResource');
+            if (params.resourceEntries?.length) {
+              const sources: Array<{
+                entryName: string;
+                source: FirmwareByteSource;
+              }> = [];
+              try {
+                for (const entry of params.resourceEntries) {
+                  const resourceName = getFirmwareUpdateResourceName(entry.entryName);
+                  const source = await openFirmwareByteSource({
+                    artifact: entry.artifact,
+                    reader: params.artifactReader,
+                  });
+                  if (!source) {
+                    throw new Error('Firmware resource entry is not prepared');
+                  }
+                  sources.push({ entryName: resourceName, source });
+                }
+                await updateResourcesFromSources(
+                  this.device.getCommands().typedCall.bind(this.device.getCommands()),
+                  this.postMessage,
+                  device,
+                  sources.map(entry => ({
+                    entryName: entry.entryName,
+                    source: entry.source,
+                  }))
+                );
+              } finally {
+                await Promise.all(
+                  sources.map(entry => entry.source.close().catch(() => undefined))
+                );
+              }
+              this.postTipMessage('DownloadLatestUiResourceSuccess');
+            } else {
+              if (
+                params.artifactReader ||
+                DataManager.getSettings('firmwareManifestMode') === 'external-only'
+              ) {
+                throw ERRORS.TypedError(
+                  HardwareErrorCode.RuntimeError,
+                  'Firmware resource must be prepared by the external firmware host',
+                  {
+                    firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+                    artifactName: 'resource',
+                  }
+                );
+              }
+              const resourceBinary: ArrayBuffer | Buffer = (await getSysResourceBinary(resourceUrl))
+                .binary;
+              this.postTipMessage('DownloadLatestUiResourceSuccess');
+              await updateResources(
+                this.device.getCommands().typedCall.bind(this.device.getCommands()),
+                this.postMessage,
+                device,
+                resourceBinary
+              );
+            }
+          }
         }
-        delete DevicePool.devicesCache[''];
-        await this.checkPromise?.promise;
-        this.checkPromise = null;
 
-        // check if the device commands has been disposed
+        // The request may outlive the current transport command instance.
         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);
+        // 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(serialNo);
+          }
+          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)
+          );
         }
-        console.log('auto go to bootloader mode failed: ', e);
-        return Promise.reject(
-          ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure)
-        );
       }
-    }
 
-    // Devices already in bootloader mode still acquire through the same helper.
-    const binary = await acquireFirmwareBinary();
+      // Devices already in bootloader mode still acquire through the same helper.
+      const source = await acquireFirmwareSource();
 
-    // check if the device commands has been disposed
-    this.device?.commands?.checkDisposed();
+      // check if the device commands has been disposed
+      this.device?.commands?.checkDisposed();
 
-    await this.device.acquire();
+      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
-    );
+      const response = await uploadFirmwareFromSource(
+        params.updateType,
+        this.device.getCommands().typedCall.bind(this.device.getCommands()),
+        this.postMessage,
+        device,
+        source,
+        true,
+        params.isUpdateBootloader
+      );
 
-    if (this.connectId) {
-      DevicePool.clearDeviceCache(this.connectId);
-    }
+      if (this.connectId) {
+        DevicePool.clearDeviceCache(this.connectId);
+      }
 
-    return response;
+      return response;
+    } finally {
+      await preparedSource?.close().catch(() => undefined);
+    }
   }
 }