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

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,15 +5,24 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { FirmwareUpdateTipMessage } from '../../events/ui-request';
 import { FirmwareUpdateBaseMethod } from '../firmware/FirmwareUpdateBaseMethod';
 import { getSysResourceBinary } from '../firmware/getBinary';
-import { updateBootloader } from '../firmware/uploadFirmware';
+import { updateBootloader, updateBootloaderFromSource } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-import { checkBootloaderLength } from '../firmware/updateBootloader';
+import { checkBootloaderLength, checkBootloaderSourceLength } from '../firmware/updateBootloader';
+import { openFirmwareByteSource } from '../firmware/FirmwareArtifactSource';
+import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBinding';
+import {
+  assertFirmwareUpdatePreparedPlanBinding,
+  assertFirmwareUpdatePreparedPlanDeviceIdentity,
+} from '../firmware/FirmwareUpdatePreparedPlan';
+import { getDeviceType, getDeviceUUID } from '../../utils';
+import { resolveDeviceBootloaderMode } from '../../utils/deviceFeaturesCompat';
 
 import type { DeviceUpdateBootloaderParams } from '../../types/api/deviceUpdateBootloader';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Device } from '../../device/Device';
 import type { Features } from '../../types';
+import type { FirmwareByteSource } from '../firmware/FirmwareArtifactSource';
 
 export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any> {
   init() {
@@ -43,17 +52,68 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     return true;
   }
 
+  async updateBootloaderWithEmmcFileWriteFromSource(_device: Device, source: FirmwareByteSource) {
+    const filePath = '0:boot/bootloader.bin';
+
+    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+    await this.emmcCommonUpdateProcessFromSource({
+      source,
+      filePath,
+    });
+    this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
+    await this.reboot(RebootType.Normal);
+    this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloaderSuccess);
+    return true;
+  }
+
   async updateTouchBootloader({
     device,
     features,
     firmwareType,
+    binary: preparedBinary,
+    source: preparedSource,
   }: {
     device: Device;
     features?: Features;
     firmwareType: EFirmwareType;
+    binary?: ArrayBuffer;
+    source?: FirmwareByteSource;
   }) {
-    let { binary } = this.payload;
+    if (preparedSource) {
+      if (!(await checkBootloaderSourceLength(preparedSource))) {
+        throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
+      }
+      if (features && device.isBootloader()) {
+        this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
+        const result = await this.updateBootloaderWithEmmcFileWriteFromSource(
+          device,
+          preparedSource
+        );
+        return result;
+      }
+      if (features && !device.isBootloader()) {
+        await updateBootloaderFromSource(
+          this.device.getCommands().typedCall.bind(this.device.getCommands()),
+          this.postMessage,
+          device,
+          preparedSource
+        );
+        return true;
+      }
+    }
+
+    let binary = preparedBinary;
     if (!binary) {
+      if (DataManager.getSettings('firmwareManifestMode') === 'external-only') {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Bootloader must be prepared by the external firmware host',
+          {
+            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+            artifactName: 'bootloader',
+          }
+        );
+      }
       this.postTipMessage(FirmwareUpdateTipMessage.CheckLatestUiResource);
       const resourceUrl = features
         ? DataManager.getBootloaderResource(features, firmwareType)
@@ -68,7 +128,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!checkBootloaderLength(binary)) {
+    if (!binary || !checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
@@ -76,7 +136,8 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     if (features && device.isBootloader()) {
       // Use emmcFileWrite + reboot logic for bootloader mode
       this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-      return this.updateBootloaderWithEmmcFileWrite(device, binary);
+      const result = await this.updateBootloaderWithEmmcFileWrite(device, binary);
+      return result;
     }
 
     if (features && !device.isBootloader()) {
@@ -96,13 +157,71 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const { features } = device;
 
     const payload = this.payload as DeviceUpdateBootloaderParams;
+    const hostBinding = payload.artifact
+      ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
+      : undefined;
+    const executionParams = {
+      ...payload,
+      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
+    };
+    if (payload.artifact) {
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan: payload.preparedPlan,
+        deviceIdentity: getDeviceUUID(features) || undefined,
+        bootloaderMode: resolveDeviceBootloaderMode(features),
+        deviceModel: String(getDeviceType(features)),
+      });
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan: payload.preparedPlan,
+        executor: 'v2',
+        scopeTargets: ['bootloader'],
+        bindings: [
+          {
+            target: 'bootloader',
+            artifact: payload.artifact,
+          },
+        ],
+      });
+      const source = await openFirmwareByteSource({
+        artifact: payload.artifact,
+        reader: executionParams.artifactReader,
+      });
+      if (!source) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Bootloader artifact is not prepared'
+        );
+      }
+      try {
+        const deviceType = device.getCurrentDeviceType();
+        const deviceFirmwareType = device.getCurrentFirmwareType();
+        const firmwareType = payload.firmwareType ?? deviceFirmwareType;
+        if (DeviceModelToTypes.model_touch.includes(deviceType)) {
+          return await this.updateTouchBootloader({
+            device,
+            features,
+            firmwareType,
+            source,
+          });
+        }
+        return true;
+      } finally {
+        await source.close().catch(() => undefined);
+      }
+    }
 
+    const { binary } = payload;
     const deviceType = device.getCurrentDeviceType();
     const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-      return this.updateTouchBootloader({ device, features, firmwareType });
+      return this.updateTouchBootloader({
+        device,
+        features,
+        firmwareType,
+        binary,
+      });
     }
 
     return Promise.resolve(true);

package/src/api/firmware/FirmwareArtifactSource.ts

@@ -0,0 +1,278 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import type {
+  FirmwareArtifactReader,
+  FirmwareArtifactReference,
+} from '../../types/api/firmwareUpdate';
+
+export const MAX_FIRMWARE_ARTIFACT_READ_BYTES = 256 * 1024;
+
+export interface FirmwareByteSource {
+  readonly size: number;
+  readAt(offset: number, length: number): Promise<ArrayBuffer>;
+  close(): Promise<void>;
+}
+
+const artifactError = (
+  code:
+    | 'FirmwareArtifactReceiptMismatch'
+    | 'FirmwareArtifactReaderInvalid'
+    | 'FirmwareArtifactReadOutOfBounds'
+    | 'FirmwareArtifactReadTooLarge',
+  message: string
+): never => {
+  throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, message, {
+    firmwareUpdateCode: code,
+  });
+};
+
+const assertSafeSize = (value: number, name: string) => {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    artifactError('FirmwareArtifactReceiptMismatch', `${name} must be a positive safe integer`);
+  }
+};
+
+export const assertFirmwareArtifactReference = (
+  artifact: FirmwareArtifactReference
+): FirmwareArtifactReference => {
+  if (
+    !artifact ||
+    typeof artifact.artifactRef !== 'string' ||
+    artifact.artifactRef.length === 0 ||
+    artifact.artifactRef.length > 160 ||
+    artifact.artifactRef.includes('/') ||
+    artifact.artifactRef.includes('\\')
+  ) {
+    artifactError(
+      'FirmwareArtifactReceiptMismatch',
+      'Firmware artifactRef must be an opaque identifier'
+    );
+  }
+  assertSafeSize(artifact.size, 'Firmware artifact size');
+  if (typeof artifact.sha256 !== 'string' || !/^[a-f0-9]{64}$/i.test(artifact.sha256)) {
+    artifactError(
+      'FirmwareArtifactReceiptMismatch',
+      'Firmware artifact sha256 must be a 32-byte hexadecimal digest'
+    );
+  }
+  return artifact;
+};
+
+const assertFirmwareArtifactRead = (size: number, offset: number, length: number) => {
+  if (
+    !Number.isSafeInteger(offset) ||
+    offset < 0 ||
+    offset >= size ||
+    !Number.isSafeInteger(length) ||
+    length <= 0 ||
+    offset + length > size
+  ) {
+    artifactError(
+      'FirmwareArtifactReadOutOfBounds',
+      `Firmware artifact read is outside size ${size}: offset=${offset}, length=${length}`
+    );
+  }
+  if (length > MAX_FIRMWARE_ARTIFACT_READ_BYTES) {
+    artifactError(
+      'FirmwareArtifactReadTooLarge',
+      `Firmware artifact read length ${length} exceeds ${MAX_FIRMWARE_ARTIFACT_READ_BYTES}`
+    );
+  }
+};
+
+const createMemoryFirmwareByteSource = (binary: ArrayBuffer): FirmwareByteSource => {
+  let bytes: Uint8Array | null = new Uint8Array(binary);
+  const { byteLength: size } = binary;
+  assertSafeSize(size, 'Firmware binary size');
+  return {
+    size,
+    readAt: (offset, length) => {
+      if (!bytes) {
+        return Promise.reject(
+          ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Firmware byte source is closed', {
+            firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+          })
+        );
+      }
+      assertFirmwareArtifactRead(size, offset, length);
+      return Promise.resolve(bytes.slice(offset, offset + length).buffer);
+    },
+    close: () => {
+      bytes = null;
+      return Promise.resolve();
+    },
+  };
+};
+
+class ReaderFirmwareByteSource implements FirmwareByteSource {
+  readonly size: number;
+
+  private closed = false;
+
+  private reading = false;
+
+  private constructor(
+    private readonly reader: FirmwareArtifactReader,
+    private readonly readerId: string,
+    size: number
+  ) {
+    this.size = size;
+  }
+
+  static async open(
+    artifact: FirmwareArtifactReference,
+    reader: FirmwareArtifactReader
+  ): Promise<ReaderFirmwareByteSource> {
+    const opened = await reader.open({ artifactRef: artifact.artifactRef });
+    if (
+      !opened ||
+      typeof opened.readerId !== 'string' ||
+      opened.readerId.length === 0 ||
+      !Number.isSafeInteger(opened.size) ||
+      opened.size !== artifact.size
+    ) {
+      if (opened?.readerId) {
+        await reader.close({ readerId: opened.readerId }).catch(() => undefined);
+      }
+      return artifactError(
+        'FirmwareArtifactReceiptMismatch',
+        `Firmware artifact opened with size ${opened?.size ?? 'unknown'}, expected ${artifact.size}`
+      );
+    }
+    return new ReaderFirmwareByteSource(reader, opened.readerId, opened.size);
+  }
+
+  async readAt(offset: number, length: number): Promise<ArrayBuffer> {
+    if (this.closed) {
+      return artifactError('FirmwareArtifactReaderInvalid', 'Firmware artifact reader is closed');
+    }
+    if (this.reading) {
+      return artifactError(
+        'FirmwareArtifactReaderInvalid',
+        'Firmware artifact reader only permits one in-flight read'
+      );
+    }
+    assertFirmwareArtifactRead(this.size, offset, length);
+    this.reading = true;
+    try {
+      const result = await this.reader.read({
+        readerId: this.readerId,
+        offset,
+        length,
+      });
+      const expectedEof = offset + length === this.size;
+      if (
+        !result ||
+        !(result.data instanceof ArrayBuffer) ||
+        result.data.byteLength !== length ||
+        result.bytesRead !== length ||
+        result.eof !== expectedEof
+      ) {
+        return artifactError(
+          'FirmwareArtifactReaderInvalid',
+          'Firmware artifact reader returned an invalid read result'
+        );
+      }
+      return result.data;
+    } finally {
+      this.reading = false;
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.reader.close({ readerId: this.readerId });
+  }
+}
+
+export const openFirmwareByteSource = async ({
+  binary,
+  artifact,
+  reader,
+}: {
+  binary?: ArrayBuffer;
+  artifact?: FirmwareArtifactReference;
+  reader?: FirmwareArtifactReader;
+}): Promise<FirmwareByteSource | null> => {
+  if (binary && artifact) {
+    return artifactError(
+      'FirmwareArtifactReceiptMismatch',
+      'Firmware input must not contain both binary and artifactRef'
+    );
+  }
+  if (binary) {
+    return createMemoryFirmwareByteSource(binary);
+  }
+  if (!artifact) {
+    return null;
+  }
+  assertFirmwareArtifactReference(artifact);
+  if (!reader) {
+    return artifactError(
+      'FirmwareArtifactReaderInvalid',
+      'Firmware artifact reader is required for artifactRef input'
+    );
+  }
+  return ReaderFirmwareByteSource.open(artifact, reader);
+};
+
+export const readFirmwareByteSourceFully = async (
+  source: FirmwareByteSource
+): Promise<ArrayBuffer> => {
+  const output = new Uint8Array(source.size);
+  let offset = 0;
+  while (offset < source.size) {
+    const length = Math.min(MAX_FIRMWARE_ARTIFACT_READ_BYTES, source.size - offset);
+    output.set(new Uint8Array(await source.readAt(offset, length)), offset);
+    offset += length;
+  }
+  return output.buffer;
+};
+
+export const writeFirmwareByteSource = async ({
+  source,
+  chunkSize,
+  write,
+}: {
+  source: FirmwareByteSource;
+  chunkSize: number;
+  write: (input: {
+    data: ArrayBuffer;
+    sourceOffset: number;
+    length: number;
+    first: boolean;
+  }) => Promise<number>;
+}) => {
+  if (
+    !Number.isSafeInteger(chunkSize) ||
+    chunkSize <= 0 ||
+    chunkSize > MAX_FIRMWARE_ARTIFACT_READ_BYTES
+  ) {
+    return artifactError(
+      'FirmwareArtifactReadTooLarge',
+      `Firmware artifact chunk size must be between 1 and ${MAX_FIRMWARE_ARTIFACT_READ_BYTES}`
+    );
+  }
+  let offset = 0;
+  while (offset < source.size) {
+    const length = Math.min(chunkSize, source.size - offset);
+    const data = await source.readAt(offset, length);
+    const processed = await write({
+      data,
+      sourceOffset: offset,
+      length,
+      first: offset === 0,
+    });
+    if (processed !== length) {
+      return artifactError(
+        'FirmwareArtifactReaderInvalid',
+        `Firmware artifact writer processed ${processed} bytes, expected ${length}`
+      );
+    }
+    offset += length;
+  }
+  return offset;
+};

package/src/api/firmware/FirmwareHostBinding.ts

@@ -0,0 +1,100 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import type { FirmwareUpdateHostBinding } from '../../types/api/firmwareUpdate';
+
+const bindingError = (message: string): never => {
+  throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, message, {
+    firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+  });
+};
+
+class FirmwareHostBindingRegistry {
+  private generation = 0;
+
+  private binding?: FirmwareUpdateHostBinding;
+
+  register(binding: FirmwareUpdateHostBinding): number {
+    if (
+      !binding ||
+      typeof binding.artifactReader?.open !== 'function' ||
+      typeof binding.artifactReader.read !== 'function' ||
+      typeof binding.artifactReader.close !== 'function'
+    ) {
+      return bindingError('Firmware host binding is invalid');
+    }
+    this.generation += 1;
+    this.binding = binding;
+    return this.generation;
+  }
+
+  unregister(generation?: number): boolean {
+    if (generation !== undefined && generation !== this.generation) {
+      return false;
+    }
+    this.generation += 1;
+    this.binding = undefined;
+    return true;
+  }
+
+  getGeneration(): number {
+    return this.generation;
+  }
+
+  resolve(generation: number): FirmwareUpdateHostBinding {
+    if (
+      !Number.isSafeInteger(generation) ||
+      generation <= 0 ||
+      generation !== this.generation ||
+      !this.binding
+    ) {
+      return bindingError(`Firmware host binding generation ${generation} is stale`);
+    }
+    const { binding } = this;
+    const assertCurrent = () => {
+      if (generation !== this.generation || binding !== this.binding) {
+        bindingError(`Firmware host binding generation ${generation} is stale`);
+      }
+    };
+    return {
+      artifactReader: {
+        open: async input => {
+          assertCurrent();
+          const opened = await binding.artifactReader.open(input);
+          try {
+            assertCurrent();
+          } catch (error) {
+            if (opened?.readerId) {
+              await binding.artifactReader
+                .close({ readerId: opened.readerId })
+                .catch(() => undefined);
+            }
+            throw error;
+          }
+          return opened;
+        },
+        read: async input => {
+          assertCurrent();
+          const result = await binding.artifactReader.read(input);
+          assertCurrent();
+          return result;
+        },
+        close: input => binding.artifactReader.close(input),
+      },
+    };
+  }
+}
+
+const firmwareHostBindingRegistry = new FirmwareHostBindingRegistry();
+
+export const registerFirmwareUpdateHostBinding = (binding: FirmwareUpdateHostBinding): number =>
+  firmwareHostBindingRegistry.register(binding);
+
+export const unregisterFirmwareUpdateHostBinding = (generation?: number): boolean =>
+  firmwareHostBindingRegistry.unregister(generation);
+
+export const getFirmwareUpdateHostBindingGeneration = (): number =>
+  firmwareHostBindingRegistry.getGeneration();
+
+export const resolveFirmwareUpdateHostBinding = (
+  generation: number | undefined
+): FirmwareUpdateHostBinding => firmwareHostBindingRegistry.resolve(generation ?? Number.NaN);

package/src/api/firmware/FirmwarePreparationError.ts

@@ -0,0 +1,12 @@
+import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+export const normalizeFirmwarePreparationError = (error: unknown) => {
+  if (error instanceof HardwareError && error.params?.firmwareUpdateCode) {
+    return error;
+  }
+
+  return ERRORS.TypedError(
+    HardwareErrorCode.FirmwareUpdateDownloadFailed,
+    error instanceof Error ? error.message : String(error)
+  );
+};

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -13,6 +13,7 @@ import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
+import { writeFirmwareByteSource } from './FirmwareArtifactSource';
 
 import type {
   FirmwareProgress,
@@ -24,11 +25,22 @@ import type { RebootType } from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { KnownDevice } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
 
+/**
+ * Response timeout for each Initialize probe while polling a rebooting device over BLE.
+ * Overlap safety comes from the poll's in-flight guard, not from this value. Keep it
+ * well below the 30s reboot budget so several attempts fit: a probe written into the
+ * dying pre-reboot connection is never answered, and its timeout tears that stale link
+ * down so the next tick reconnects fresh. Raise it only if a device model is proven to
+ * answer bootloader Initialize slower than this on a fresh connection.
+ */
+export const BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS = 5000;
+
 type FirmwareTransferMetrics = Pick<
   FirmwareProgress['payload'],
   'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
@@ -143,6 +155,10 @@ export class FirmwareUpdateBaseMethod<Params> 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('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
 
@@ -198,6 +214,8 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
         }
 
         if (isBleReconnect) {
+          if (bleProbeInFlight) return;
+          bleProbeInFlight = true;
           try {
             await this.device.deviceConnector?.acquire(
               this.device.originalDescriptor.id,
@@ -205,7 +223,10 @@ export class FirmwareUpdateBaseMethod<Params> 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);
@@ -213,6 +234,8 @@ export class FirmwareUpdateBaseMethod<Params> 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);
@@ -394,6 +417,54 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
   }
 
+  async emmcCommonUpdateProcessFromSource({
+    source,
+    filePath,
+    processedSize,
+    totalSize,
+  }: {
+    source: FirmwareByteSource;
+    filePath: string;
+    processedSize?: number;
+    totalSize?: number;
+  }) {
+    if (!filePath.startsWith('0:')) {
+      throw new Error('filePath must start with 0:');
+    }
+    const env = DataManager.getSettings('env');
+    const chunkSize = 1024 * (DataManager.isBleConnect(env) ? 16 : 128);
+
+    await writeFirmwareByteSource({
+      source,
+      chunkSize,
+      write: async ({ data, sourceOffset, length, first }) => {
+        const progress =
+          totalSize !== undefined && processedSize !== undefined
+            ? Math.min(Math.ceil(((processedSize + sourceOffset + length) / totalSize) * 100), 99)
+            : Math.min(Math.ceil(((sourceOffset + length) / source.size) * 100), 99);
+        const writeRes = await this.emmcFileWriteWithRetry(
+          filePath,
+          length,
+          sourceOffset,
+          data,
+          first,
+          progress
+        );
+        if (!writeRes) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.EmmcFileWriteFirmwareError,
+            'transfer data error'
+          );
+        }
+        const processedBytes = Number(writeRes.message.processed_byte);
+        this.postProgressMessage(progress, 'transferData');
+        return Number.isFinite(processedBytes) ? processedBytes : length;
+      },
+    });
+
+    return totalSize !== undefined ? (processedSize ?? 0) + source.size : 0;
+  }
+
   async emmcFileWriteWithRetry(
     filePath: string,
     chunkLength: number,