@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.9

package/src/api/FirmwareUpdateV4.ts

@@ -38,7 +38,6 @@ import type {
   Features,
   IFirmwareReleaseInfo,
   IProtocolV2FirmwareComponent,
-  IProtocolV2ResourceManifestPackage,
   IVersionArray,
 } from '../types';
 
@@ -47,19 +46,20 @@ const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
 const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
-const PROTOCOL_V2_START_UPDATE_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_START_UPDATE_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
 const PROTOCOL_V2_TARGET_STATUS_FAILED_MIN = 3;
 const PROTOCOL_V2_CONNECT_PROTOCOL = 'V2';
-const PROTOCOL_V2_FIRMWARE_STAGING_VOLUME = 'vol1:';
+const PROTOCOL_V2_FIRMWARE_STAGING_VOLUME = 'vol0:/';
 const PROTOCOL_V2_MIN_FILE_CHUNK_SIZE = 64;
 const PROTOCOL_V2_CONNECT_RETRY_COUNT = 10;
 const PROTOCOL_V2_CONNECT_POLL_INTERVAL = 500;
 const PROTOCOL_V2_CONNECT_SINGLE_TIMEOUT = 75 * 1000;
 const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT = 3;
 const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
 const PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET = 0x200;
 const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
@@ -107,6 +107,25 @@ type ProtocolV2InstallTarget = ProtocolV2InstallItem & {
   path: string;
 };
 
+type ProtocolV2FileTransferParams = PROTO.FirmwareUpload & {
+  filePath: string;
+  processedSize?: number;
+  totalSize?: number;
+  onTransferredBytes?: (transferredBytes: number) => void;
+};
+
+/** RESC bundle okpkg（FileWrite 直写模式），每个独立同步到 devicePath */
+type ProtocolV2ResourceBundleBinary = {
+  name: string;
+  binary: ArrayBuffer;
+  devicePath: string;
+  /** 远端配置模式下的下载 URL（手动模式不填） */
+  url?: string;
+  version?: IVersionArray;
+  payloadHash?: string;
+  headerHash?: string;
+};
+
 type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
   binary: ArrayBuffer;
 };
@@ -114,7 +133,7 @@ type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
 type ProtocolV2RemoteComponentTarget = {
   fileName: string;
   targetId: number;
-  kind: 'bootloader' | 'firmware' | 'resource';
+  kind: 'bootloader' | 'firmware';
 };
 
 type ProtocolV2OkppHeader = {
@@ -167,11 +186,6 @@ const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS: Readonly<
     targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04,
     kind: 'firmware',
   },
-  CRATE: {
-    fileName: 'resource.bin',
-    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-    kind: 'resource',
-  },
 };
 
 const PROTOCOL_V2_ROMLOADER_UNSUPPORTED_MESSAGE =
@@ -393,7 +407,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     validateParams(payload, [
       { name: 'chunkSize', type: 'number' },
-      { name: 'resourceBinaries', type: 'array', allowEmpty: true },
       { name: 'forcedUpdateRes', type: 'boolean' },
       { name: 'bootloaderBinary', type: 'buffer' },
       { name: 'romloaderBinary', type: 'buffer' },
@@ -406,6 +419,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'se04Binary', type: 'buffer' },
       { name: 'firmwareType', type: 'string' },
       { name: 'platform', type: 'string' },
+      { name: 'resourceBundleFiles', type: 'array', allowEmpty: true },
     ]);
 
     this.params = {
@@ -420,7 +434,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       se02Binary: payload.se02Binary,
       se03Binary: payload.se03Binary,
       se04Binary: payload.se04Binary,
-      resourceBinaries: payload.resourceBinaries,
+      resourceBundleFiles: payload.resourceBundleFiles,
       firmwareType: payload.firmwareType,
       platform: payload.platform,
     };
@@ -459,13 +473,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const deviceFirmwareType = getFirmwareType(deviceFeatures);
     const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
 
-    let resourceBinaryMap: ProtocolV2TargetBinary[] = [];
     let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
     let installItems: ProtocolV2InstallItem[] | undefined;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
-      resourceBinaryMap = await this.prepareResourceBinaries(firmwareType, deviceFeatures);
       fwBinaryMap = this.collectExplicitTargetBinaries();
       bootloaderBinary = this.prepareBootloaderBinary();
       if (!this.hasExplicitProtocolV2Payload(fwBinaryMap)) {
@@ -473,7 +485,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           firmwareType,
           deviceFeatures
         );
-        resourceBinaryMap = remoteBinaries.resourceBinaryMap;
         bootloaderBinary = remoteBinaries.bootloaderBinary;
         fwBinaryMap = remoteBinaries.fwBinaryMap;
         installItems = remoteBinaries.installItems;
@@ -483,7 +494,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
     }
 
-    if (resourceBinaryMap.length === 0 && !bootloaderBinary && fwBinaryMap.length === 0) {
+    const resourceBundles = this.prepareProtocolV2ResourceBundles(firmwareType, deviceFeatures);
+
+    if (!bootloaderBinary && fwBinaryMap.length === 0 && !resourceBundles?.length) {
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
         'No firmware to update'
@@ -493,10 +506,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     await this.enterProtocolV2BootloaderMode();
 
     await this.executeProtocolV2Update({
-      resourceBinaryMap,
       fwBinaryMap,
       bootloaderBinary,
       ...(installItems ? { installItems } : undefined),
+      ...(resourceBundles?.length ? { resourceBundles } : undefined),
     });
 
     await this.exitProtocolV2BootloaderToNormal();
@@ -519,68 +532,26 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
   }
 
-  private async prepareResourceBinaries(firmwareType: EFirmwareType, features: Features) {
-    if (this.params.resourceBinaries?.length) {
-      this.params.resourceBinaries.forEach((binary, index) => {
-        if (!(binary instanceof ArrayBuffer)) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.CallMethodInvalidParameter,
-            `Parameter [resourceBinaries.${index}] is of type invalid and should be [buffer].`
-          );
-        }
-      });
-
-      return this.params.resourceBinaries.map((binary, index) => ({
-        fileName: `resource-${index + 1}.bin`,
-        binary,
-        targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-      }));
-    }
-    const resourceUrl = DataManager.getSysResourcesLatestRelease({
-      features,
-      forcedUpdateRes: this.params.forcedUpdateRes,
-      firmwareType,
-    });
-
-    if (resourceUrl) {
-      const resource = (await getSysResourceBinary(resourceUrl)).binary;
-      return [
-        {
-          fileName: 'resource.bin',
-          binary: resource,
-          targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-        },
-      ];
-    }
-    Log.warn('No resource url found');
-    return [];
-  }
-
   private prepareBootloaderBinary(): ArrayBuffer | null {
     return this.params.bootloaderBinary ?? null;
   }
 
   private hasExplicitProtocolV2Payload(fwBinaryMap: ProtocolV2TargetBinary[]) {
     return (
-      !!this.params.resourceBinaries?.length ||
+      !!this.params.resourceBundleFiles?.length ||
       !!this.params.bootloaderBinary ||
       fwBinaryMap.length > 0
     );
   }
 
   private buildProtocolV2InstallItems({
-    resourceBinaryMap,
     bootloaderBinary,
     fwBinaryMap,
   }: {
-    resourceBinaryMap: ProtocolV2TargetBinary[];
     bootloaderBinary: ArrayBuffer | null;
     fwBinaryMap: ProtocolV2TargetBinary[];
   }): ProtocolV2InstallItem[] {
-    const installItems: ProtocolV2InstallItem[] = resourceBinaryMap.map(resource => ({
-      ...resource,
-      kind: 'resource',
-    }));
+    const installItems: ProtocolV2InstallItem[] = [];
 
     if (bootloaderBinary) {
       installItems.push({
@@ -738,86 +709,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return parseProtocolV2OkppHeader(headerBytes);
   }
 
-  private async isProtocolV2ResourcePackageMatched(
-    pkg: IProtocolV2ResourceManifestPackage,
-    manifestVersion?: IVersionArray
-  ) {
-    try {
-      const header = await this.readProtocolV2DeviceFileHeader(pkg.path);
-      if (!header) return false;
-
-      const expectedType = pkg.type ?? 'RESC';
-      const expectedVersion = pkg.version ?? manifestVersion;
-      if (header.type !== expectedType) return false;
-      if (expectedVersion && compareProtocolV2Versions(header.version, expectedVersion) !== 0) {
-        return false;
-      }
-
-      const expectedPayloadHash = normalizeProtocolV2Hex(pkg.payloadHash);
-      if (expectedPayloadHash && header.payloadHash !== expectedPayloadHash) return false;
-
-      const expectedHeaderHash = normalizeProtocolV2Hex(pkg.headerHash);
-      if (expectedHeaderHash && header.headerHash !== expectedHeaderHash) return false;
-
-      return true;
-    } catch (error) {
-      Log.log(`Protocol V2 resource package check failed for ${pkg.path}: `, error);
-      return false;
-    }
-  }
-
-  private async isProtocolV2ResourceManifestSatisfied(
-    manifest: IFirmwareReleaseInfo['resourceManifest']
-  ) {
-    if (!manifest?.packages?.length) return false;
-
-    for (const pkg of manifest.packages) {
-      if (!(await this.isProtocolV2ResourcePackageMatched(pkg, manifest.version))) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  private getProtocolV2ResourceManifest(
-    release: IFirmwareReleaseInfo,
-    component: IProtocolV2FirmwareComponent
-  ) {
-    return component.resourceManifest ?? release.resourceManifest;
-  }
-
-  private getProtocolV2ResourceComponentFileName(key: string) {
-    const safeKey = key.replace(/[^a-z0-9_-]/gi, '_') || 'resource';
-    if (safeKey === 'resource') {
-      return PROTOCOL_V2_REMOTE_COMPONENT_TARGETS.CRATE.fileName;
-    }
-    return `resource-${safeKey}.bin`;
-  }
-
-  private async shouldInstallRemoteProtocolV2Component(
+  private shouldInstallRemoteProtocolV2Component(
     release: IFirmwareReleaseInfo,
     key: string,
     component: IProtocolV2FirmwareComponent,
     target: ProtocolV2RemoteComponentTarget,
     features: Features
   ) {
-    if (target.kind === 'resource') {
-      if (
-        this.params.forcedUpdateRes ||
-        features.bootloaderMode ||
-        features.mode === 'bootloader'
-      ) {
-        return true;
-      }
-      const resourceMatched = await this.isProtocolV2ResourceManifestSatisfied(
-        this.getProtocolV2ResourceManifest(release, component)
-      );
-      if (resourceMatched) {
-        Log.log(`[FirmwareUpdateV4] skip Protocol V2 resource component ${key}; manifest matched`);
-      }
-      return !resourceMatched;
-    }
-
     const versionSatisfied = this.isProtocolV2ComponentVersionSatisfied(
       release,
       component,
@@ -852,14 +750,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async prepareRemoteProtocolV2Binaries(firmwareType: EFirmwareType, features: Features) {
     const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
 
-    const resourceBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
     const fwBinaryMap: ProtocolV2TargetBinary[] = [];
     const installItems: ProtocolV2InstallItem[] = [];
 
     if (!release) {
       return {
-        resourceBinaryMap,
         bootloaderBinary,
         fwBinaryMap,
         installItems,
@@ -870,7 +766,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     for (const [key, component] of entries) {
       const target = this.getRemoteComponentTarget(key, component);
-      const shouldInstall = await this.shouldInstallRemoteProtocolV2Component(
+      const shouldInstall = this.shouldInstallRemoteProtocolV2Component(
         release,
         key,
         component,
@@ -879,15 +775,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       );
       if (shouldInstall) {
         const remoteBinary = await this.downloadRemoteProtocolV2Component(key, component);
-        if (remoteBinary.kind === 'resource') {
-          const binaryEntry = {
-            fileName: this.getProtocolV2ResourceComponentFileName(key),
-            binary: remoteBinary.binary,
-            targetId: remoteBinary.targetId,
-          };
-          resourceBinaryMap.push(binaryEntry);
-          installItems.push({ ...binaryEntry, kind: remoteBinary.kind });
-        } else if (remoteBinary.kind === 'bootloader') {
+        if (remoteBinary.kind === 'bootloader') {
           bootloaderBinary = remoteBinary.binary;
           installItems.push({
             fileName: remoteBinary.fileName,
@@ -908,13 +796,153 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     return {
-      resourceBinaryMap,
       bootloaderBinary,
       fwBinaryMap,
       installItems,
     };
   }
 
+  // ============================================================
+  // RESC bundle 直写增量同步（FileRead 比对 + FilesystemFileWrite 直写）
+  // ============================================================
+
+  /**
+   * 准备 RESC bundle 列表。
+   *
+   * 两种模式（同 FirmwareUpdateV3 的 binary vs version 模式）：
+   * - 用户传了 resourceBundleFiles（binary 数组）：直接用，不做版本比对。
+   * - 用户没传：从远端 config.json 的 release.resourceBundles 拉取，
+   *   此时 syncProtocolV2ResourceBundles 会按需下载 + 比对设备已有 header 跳过。
+   */
+  private prepareProtocolV2ResourceBundles(
+    firmwareType: EFirmwareType,
+    features: Features
+  ): ProtocolV2ResourceBundleBinary[] | undefined {
+    // 模式1：用户手动传入 binary，直接安装，不比对
+    if (this.params.resourceBundleFiles?.length) {
+      return this.params.resourceBundleFiles.map(file => ({
+        name: file.devicePath.split('/').pop() ?? file.devicePath,
+        binary: file.binary,
+        devicePath: file.devicePath,
+      }));
+    }
+
+    // 模式2：远端配置模式，后续按需下载 + 比对
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+    if (!release?.resourceBundles?.length) return undefined;
+
+    return release.resourceBundles.map(bundle => ({
+      name: bundle.name,
+      binary: new ArrayBuffer(0),
+      devicePath: bundle.devicePath,
+      url: bundle.url,
+      version: bundle.version,
+      payloadHash: bundle.payloadHash,
+      headerHash: bundle.headerHash,
+    })) as ProtocolV2ResourceBundleBinary[];
+  }
+
+  /**
+   * 同步 RESC bundles 到设备。
+   *
+   * 手动传入模式（有 binary）：直接 FileWrite 直写，不比对。
+   * 远端配置模式（无 binary，有 url）：按需下载 + FileRead 比对跳过已更新的。
+   */
+  private async syncProtocolV2ResourceBundles(
+    bundles: ProtocolV2ResourceBundleBinary[],
+    firmwareSize: number
+  ): Promise<{ processedSize: number; totalSize: number }> {
+    const transferStartTime = Date.now();
+    const transferTransport = this.getProtocolV2FirmwareTransferTransport();
+
+    const isManualMode = bundles.every(b => b.binary.byteLength > 0);
+    let bundlesToSync = bundles;
+
+    // 远端配置模式：按需下载 + 比对跳过
+    if (!isManualMode) {
+      const filtered: ProtocolV2ResourceBundleBinary[] = [];
+      for (const bundle of bundles) {
+        // 下载 binary
+        if (bundle.binary.byteLength === 0 && bundle.url) {
+          Log.log(`[FirmwareUpdateV4] downloading RESC bundle ${bundle.name} from ${bundle.url}`);
+          const { binary } = await getSysResourceBinary(bundle.url);
+          bundle.binary = binary;
+        }
+        // 比对设备上已有 header
+        const upToDate = await this.isProtocolV2ResourceBundleUpToDate(bundle);
+        if (upToDate) {
+          Log.log(`[FirmwareUpdateV4] skip RESC bundle ${bundle.name}; already up to date`);
+        } else {
+          filtered.push(bundle);
+        }
+      }
+      bundlesToSync = filtered;
+    }
+
+    if (bundlesToSync.length === 0) {
+      Log.log('[FirmwareUpdateV4] all RESC bundles up to date, nothing to sync');
+      return { processedSize: 0, totalSize: firmwareSize };
+    }
+
+    // FileWrite 直写到设备
+    let totalSize = 0;
+    for (const b of bundlesToSync) totalSize += b.binary.byteLength;
+
+    const transferTotalSize = totalSize + firmwareSize;
+    let processedSize = 0;
+    for (const bundle of bundlesToSync) {
+      Log.log(
+        `[FirmwareUpdateV4] syncing RESC bundle ${bundle.name} -> ${bundle.devicePath} bytes=${bundle.binary.byteLength}`
+      );
+      processedSize = await this.protocolV2CommonUpdateProcess({
+        payload: bundle.binary,
+        filePath: bundle.devicePath,
+        processedSize,
+        totalSize: transferTotalSize,
+      });
+    }
+
+    const elapsedMs = Date.now() - transferStartTime;
+    Log.log(
+      `[FirmwareUpdateV4] RESC bundle sync finished transport=${transferTransport} bytes=${totalSize} elapsed=${(
+        elapsedMs / 1000
+      ).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(totalSize, elapsedMs)} KB/s`
+    );
+    return { processedSize, totalSize: transferTotalSize };
+  }
+
+  /**
+   * 比对设备上已有 okpkg 的 OKPP header（仅远端配置模式使用）。
+   */
+  private async isProtocolV2ResourceBundleUpToDate(
+    bundle: ProtocolV2ResourceBundleBinary
+  ): Promise<boolean> {
+    if (this.params.forcedUpdateRes) return false;
+    if (!bundle.version && !bundle.payloadHash) return false;
+
+    try {
+      const header = await this.readProtocolV2DeviceFileHeader(bundle.devicePath);
+      if (!header) return false;
+
+      if (bundle.version) {
+        const cmp = compareProtocolV2Versions(header.version, bundle.version);
+        if (cmp === undefined || cmp !== 0) return false;
+      }
+      if (bundle.payloadHash) {
+        const expected = normalizeProtocolV2Hex(bundle.payloadHash);
+        if (expected && header.payloadHash !== expected) return false;
+      }
+      if (bundle.headerHash) {
+        const expected = normalizeProtocolV2Hex(bundle.headerHash);
+        if (expected && header.headerHash !== expected) return false;
+      }
+      return true;
+    } catch (error) {
+      Log.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
+      return false;
+    }
+  }
+
   private isProtocolV2BootloaderMode() {
     if (typeof this.device.isBootloader === 'function') {
       return this.device.isBootloader();
@@ -1017,30 +1045,48 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   private async executeProtocolV2Update({
-    resourceBinaryMap,
     fwBinaryMap,
     bootloaderBinary,
     installItems,
+    resourceBundles,
   }: {
-    resourceBinaryMap?: ProtocolV2TargetBinary[];
     fwBinaryMap?: ProtocolV2TargetBinary[];
     bootloaderBinary?: ArrayBuffer | null;
     installItems?: ProtocolV2InstallItem[];
+    resourceBundles?: ProtocolV2ResourceBundleBinary[];
   }) {
     const orderedInstallItems =
       installItems ??
       this.buildProtocolV2InstallItems({
-        resourceBinaryMap: resourceBinaryMap ?? [],
         bootloaderBinary: bootloaderBinary ?? null,
         fwBinaryMap: fwBinaryMap ?? [],
       });
-    let totalSize = 0;
-    let processedSize = 0;
-    let transferredSize = 0;
 
-    for (const item of orderedInstallItems) totalSize += item.binary.byteLength;
+    let firmwareSize = 0;
+    for (const item of orderedInstallItems) firmwareSize += item.binary.byteLength;
 
     this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+
+    let processedSize = 0;
+    let totalSize = firmwareSize;
+    if (resourceBundles?.length) {
+      const resourceTransfer = await this.syncProtocolV2ResourceBundles(
+        resourceBundles,
+        firmwareSize
+      );
+      processedSize = resourceTransfer.processedSize;
+      totalSize = resourceTransfer.totalSize;
+    }
+
+    // 只有 RESC bundle、没有固件 target 时跳过 staging/install 阶段
+    if (orderedInstallItems.length === 0) {
+      Log.log('[FirmwareUpdateV4] no firmware targets to install (RESC bundles only)');
+      if (totalSize > 0) {
+        this.postProgressMessage(100, 'transferData');
+      }
+      return;
+    }
+    let transferredSize = processedSize;
     const transferStartTime = Date.now();
     const transferTransport = this.getProtocolV2FirmwareTransferTransport();
     const chunkSize = this.getProtocolV2FirmwareChunkSize();
@@ -1067,6 +1113,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           onTransferredBytes,
         });
         transferredSize = processedSize;
+        await this.verifyProtocolV2StagedFile(filePath, item.binary.byteLength);
 
         stagedInstallTargets.push({
           ...item,
@@ -1109,6 +1156,19 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${item.fileName}`;
   }
 
+  private async verifyProtocolV2StagedFile(path: string, expectedSize: number) {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+    const response = await typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', { path });
+    const actualSize = toProtocolV2FiniteNumber(response.message?.size);
+    if (!response.message?.exist || response.message?.directory || actualSize !== expectedSize) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.EmmcFileWriteFirmwareError,
+        `staged file verification failed: path=${path} exist=${!!response.message
+          ?.exist} expected=${expectedSize} actual=${actualSize ?? 'unknown'}`
+      );
+    }
+  }
+
   private async queryProtocolV2FirmwareUpdateStatus() {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     return typedCall(
@@ -1367,18 +1427,37 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     await this.device.initialize();
   }
 
-  private async protocolV2CommonUpdateProcess({
+  private async protocolV2CommonUpdateProcess(params: ProtocolV2FileTransferParams) {
+    let lastError: unknown;
+    for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
+      try {
+        return await this.protocolV2WriteWholeFile(params);
+      } catch (error) {
+        lastError = error;
+        Log.error(
+          `Protocol V2 file transfer failed path=${params.filePath} attempt=${attempt}/${PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT}; restarting from offset 0`,
+          error
+        );
+        if (attempt === PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
+          break;
+        }
+        await this.recoverProtocolV2FileTransfer();
+      }
+    }
+
+    throw ERRORS.TypedError(
+      HardwareErrorCode.EmmcFileWriteFirmwareError,
+      `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`
+    );
+  }
+
+  private async protocolV2WriteWholeFile({
     payload,
     filePath,
     processedSize,
     totalSize,
     onTransferredBytes,
-  }: PROTO.FirmwareUpload & {
-    filePath: string;
-    processedSize?: number;
-    totalSize?: number;
-    onTransferredBytes?: (transferredBytes: number) => void;
-  }) {
+  }: ProtocolV2FileTransferParams) {
     const chunkSize = this.getProtocolV2FirmwareChunkSize();
     let offset = 0;
     const getUploadProgress = (fileOffset: number) => {
@@ -1399,7 +1478,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         totalSize ?? payload.byteLength
       );
 
-      const writeRes = await this.fileWriteWithRetry(
+      const writeRes = await this.fileWriteChunk(
         filePath,
         payload.byteLength,
         offset,
@@ -1440,7 +1519,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return env ?? 'unknown';
   }
 
-  private async fileWriteWithRetry(
+  private async fileWriteChunk(
     filePath: string,
     totalFileSize: number,
     offset: number,
@@ -1448,57 +1527,37 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     overwrite: boolean,
     progress: number | null
   ): Promise<TypedResponseMessage<'FilesystemFile'>> {
-    const writeFunc = async () => {
-      const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-      const writeRes = await typedCall('FilesystemFileWrite', 'FilesystemFile', {
-        file: {
-          path: filePath,
-          offset,
-          total_size: totalFileSize,
-          data: chunk,
-        },
-        overwrite,
-        append: false,
-        ui_percentage: progress ?? undefined,
-      });
-      if (writeRes.type !== 'FilesystemFile') {
-        if ((writeRes as any).type === 'CallMethodError') {
-          if (((writeRes as any).message.error ?? '').indexOf(SESSION_ERROR) > -1) {
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, SESSION_ERROR);
-          }
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+    const writeRes = await typedCall('FilesystemFileWrite', 'FilesystemFile', {
+      file: {
+        path: filePath,
+        offset,
+        total_size: totalFileSize,
+        data: chunk,
+      },
+      overwrite,
+      append: false,
+      ui_percentage: progress ?? undefined,
+    });
+    if (writeRes.type !== 'FilesystemFile') {
+      if ((writeRes as any).type === 'CallMethodError') {
+        if (((writeRes as any).message.error ?? '').indexOf(SESSION_ERROR) > -1) {
+          throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, SESSION_ERROR);
         }
-        throw ERRORS.TypedError(
-          HardwareErrorCode.EmmcFileWriteFirmwareError,
-          'transfer data error'
-        );
       }
-      return writeRes;
-    };
+      throw ERRORS.TypedError(HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
+    }
+    return writeRes;
+  }
 
-    let retryCount = 10;
-    while (retryCount > 0) {
-      try {
-        const result = await writeFunc();
-        return result;
-      } catch (error) {
-        Log.error(`fileWrite error: `, error);
-        retryCount--;
-        if (retryCount === 0) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.EmmcFileWriteFirmwareError,
-            'transfer data error'
-          );
-        }
-        const env = DataManager.getSettings('env');
-        if (DataManager.isBleConnect(env)) {
-          await wait(3000);
-          await this.acquireProtocolV2BleDevice();
-          await this.device.initialize();
-        }
-        await wait(2000);
-      }
+  private async recoverProtocolV2FileTransfer() {
+    const env = DataManager.getSettings('env');
+    if (DataManager.isBleConnect(env)) {
+      await wait(3000);
+      await this.acquireProtocolV2BleDevice();
+      await this.device.initialize();
     }
-    throw ERRORS.TypedError(HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
+    await wait(2000);
   }
 
   private async acquireProtocolV2BleDevice() {