@onekeyfe/hd-core 1.2.0-alpha.10 → 1.2.0-alpha.11

package/src/api/FirmwareUpdateV4.ts

@@ -30,7 +30,7 @@ import {
   isProtocolV2DeviceDisconnectedError,
 } from './protocol-v2/helpers';
 
-import type { FirmwareUpdateV4Params } from '../types/api/firmwareUpdate';
+import type { FirmwareUpdateV4Params, FirmwareUpdateV4Target } from '../types/api/firmwareUpdate';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { PROTO } from '../constants';
 import type { TypedResponseMessage } from '../device/DeviceCommands';
@@ -188,6 +188,17 @@ const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS: Readonly<
   },
 };
 
+const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<number, FirmwareUpdateV4Target>([
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER, 'boot'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, 'app_v1'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2, 'app_v2'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR, 'coprocessor'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01, 'se01'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02, 'se02'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03, 'se03'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04, 'se04'],
+]);
+
 const PROTOCOL_V2_ROMLOADER_UNSUPPORTED_MESSAGE =
   'FW_MGMT_TARGET_ROMLOADER is not accepted by the current Pro2 bootloader update request. Flash romloader with the loader-specific flow instead of firmwareUpdateV4.';
 
@@ -282,13 +293,6 @@ const versionArrayToNumber = (version?: IVersionArray) => {
   return version[0] * 0x10000 + version[1] * 0x100 + version[2];
 };
 
-const versionStringToArray = (version?: string | null): IVersionArray | undefined => {
-  if (!version) return undefined;
-  const parts = version.split('.').map(part => Number(part));
-  if (parts.length !== 3 || parts.some(part => !Number.isFinite(part))) return undefined;
-  return parts as IVersionArray;
-};
-
 const compareProtocolV2Versions = (current?: IVersionArray, target?: IVersionArray) => {
   const currentNumber = versionArrayToNumber(current);
   const targetNumber = versionArrayToNumber(target);
@@ -418,6 +422,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'se03Binary', type: 'buffer' },
       { name: 'se04Binary', type: 'buffer' },
       { name: 'firmwareType', type: 'string' },
+      { name: 'targetsToUpdate', type: 'array', allowEmpty: true },
       { name: 'platform', type: 'string' },
       { name: 'resourceBundleFiles', type: 'array', allowEmpty: true },
     ]);
@@ -436,6 +441,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       se04Binary: payload.se04Binary,
       resourceBundleFiles: payload.resourceBundleFiles,
       firmwareType: payload.firmwareType,
+      targetsToUpdate: payload.targetsToUpdate,
       platform: payload.platform,
     };
   }
@@ -601,63 +607,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return target;
   }
 
-  private getProtocolV2ComponentTargetVersion(
-    release: IFirmwareReleaseInfo,
-    component: IProtocolV2FirmwareComponent,
-    target: ProtocolV2RemoteComponentTarget
-  ) {
-    if (component.version) return component.version;
-    if (target.targetId === ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER) {
-      return release.bootloaderVersion;
-    }
-    if (
-      target.targetId === ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1 ||
-      target.targetId === ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2
-    ) {
-      return release.version;
-    }
-    return undefined;
-  }
-
-  private getProtocolV2ComponentCurrentVersion(
-    features: Features,
-    target: ProtocolV2RemoteComponentTarget
-  ) {
-    switch (target.targetId) {
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER:
-        return getDeviceBootloaderVersion(features);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1:
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2:
-        return getDeviceFirmwareVersion(features);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR:
-        return getDeviceBLEFirmwareVersion(features);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01:
-        return versionStringToArray(features.se01Version);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02:
-        return versionStringToArray(features.se02Version);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03:
-        return versionStringToArray(features.se03Version);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04:
-        return versionStringToArray(features.se04Version);
-      default:
-        return undefined;
-    }
-  }
-
-  private isProtocolV2ComponentVersionSatisfied(
-    release: IFirmwareReleaseInfo,
-    component: IProtocolV2FirmwareComponent,
-    target: ProtocolV2RemoteComponentTarget,
-    features: Features
-  ) {
-    const targetVersion = this.getProtocolV2ComponentTargetVersion(release, component, target);
-    if (!targetVersion) return false;
-
-    const currentVersion = this.getProtocolV2ComponentCurrentVersion(features, target);
-    const compareResult = compareProtocolV2Versions(currentVersion, targetVersion);
-    return compareResult !== undefined && compareResult >= 0;
-  }
-
   private getProtocolV2ResourceFilePath(path: string) {
     if (path.startsWith('vol')) return path;
     if (path.startsWith('/')) return `vol0:${path}`;
@@ -709,25 +658,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return parseProtocolV2OkppHeader(headerBytes);
   }
 
-  private shouldInstallRemoteProtocolV2Component(
-    release: IFirmwareReleaseInfo,
-    key: string,
-    component: IProtocolV2FirmwareComponent,
-    target: ProtocolV2RemoteComponentTarget,
-    features: Features
-  ) {
-    const versionSatisfied = this.isProtocolV2ComponentVersionSatisfied(
-      release,
-      component,
-      target,
-      features
-    );
-    if (versionSatisfied) {
-      Log.log(`[FirmwareUpdateV4] skip Protocol V2 component ${key}; version is up to date`);
-    }
-    return !versionSatisfied;
-  }
-
   private async downloadRemoteProtocolV2Component(
     key: string,
     component: IProtocolV2FirmwareComponent
@@ -763,16 +693,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     const entries = this.getRemoteComponentEntries(release);
+    const targetsToUpdate = new Set(this.params.targetsToUpdate ?? []);
 
     for (const [key, component] of entries) {
       const target = this.getRemoteComponentTarget(key, component);
-      const shouldInstall = this.shouldInstallRemoteProtocolV2Component(
-        release,
-        key,
-        component,
-        target,
-        features
-      );
+      const updateTarget = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId);
+      const shouldInstall = updateTarget ? targetsToUpdate.has(updateTarget) : false;
       if (shouldInstall) {
         const remoteBinary = await this.downloadRemoteProtocolV2Component(key, component);
         if (remoteBinary.kind === 'bootloader') {
@@ -827,6 +753,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       }));
     }
 
+    if (!this.params.targetsToUpdate?.includes('resource')) {
+      return undefined;
+    }
+
     // 模式2：远端配置模式，后续按需下载 + 比对
     const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
     if (!release?.resourceBundles?.length) return undefined;

package/src/api/GetPassphraseState.ts

@@ -11,27 +11,18 @@ export default class GetPassphraseState extends BaseMethod {
   }
 
   async run() {
-    const { passphraseState, newSession, unlockedAttachPin } =
-      await getPassphraseStateWithRefreshDeviceInfo(this.device, {
-        expectPassphraseState: this.payload.passphraseState,
-        onlyMainPin: this.payload.useEmptyPassphrase,
-        allowCreateAttachPin: this.payload.allowCreateAttachPin,
-        initSession: this.payload.initSession,
-      });
+    const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(this.device, {
+      expectPassphraseState: this.payload.passphraseState,
+      onlyMainPin: this.payload.useEmptyPassphrase,
+      initSession: this.payload.initSession,
+    });
 
-    const { features } = this.device;
-    const passphraseProtection = this.device.getCurrentPassphraseProtection() ?? null;
+    const passphraseProtection = this.device.getCurrentPassphraseProtection();
     const deviceType = this.device.getCurrentDeviceType();
     const isProSeries = deviceType === EDeviceType.Pro || deviceType === EDeviceType.Pro2;
 
-    // refresh device info
-    return Promise.resolve({
-      passphraseState: isProSeries || passphraseProtection === true ? passphraseState : undefined,
-      sessionId: this.payload.initSession
-        ? newSession ?? undefined
-        : newSession ?? features?.sessionId ?? undefined,
-      unlockedAttachPin: unlockedAttachPin ?? features?.unlockedAttachPin,
-      passphraseProtection,
-    });
+    return Promise.resolve(
+      isProSeries || passphraseProtection === true ? passphraseState : undefined
+    );
   }
 }

package/src/api/UploadPortfolio.ts

@@ -0,0 +1,37 @@
+import FileWrite from './FileWrite';
+
+export type UploadPortfolioParams = {
+  packageBytes: ArrayBuffer | Uint8Array | Blob;
+  operationId?: string;
+  timeoutMs?: number | string;
+};
+
+const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.pfol.pending';
+const PORTFOLIO_CHUNK_SIZE = 2048;
+
+export default class UploadPortfolio extends FileWrite {
+  init() {
+    const { packageBytes, timeoutMs } = this.payload as UploadPortfolioParams;
+    this.payload = {
+      ...this.payload,
+      path: PORTFOLIO_PENDING_PATH,
+      offset: 0,
+      data: packageBytes,
+      chunkSize: PORTFOLIO_CHUNK_SIZE,
+      overwrite: true,
+      append: false,
+      timeoutMs,
+    };
+    super.init();
+  }
+
+  async run() {
+    const stagedFile = await super.run();
+    this.throwIfAborted();
+    await this.device.commands.typedCall('PortfolioUpdate', 'Success', {});
+    return {
+      ...stagedFile,
+      portfolioUpdated: true,
+    };
+  }
+}

package/src/api/index.ts

@@ -54,6 +54,10 @@ export { default as deviceFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpd
 export { default as deviceGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';
 export { default as deviceFactoryInfoSet } from './protocol-v2/DeviceFactoryInfoSet';
 export { default as deviceFactoryInfoGet } from './protocol-v2/DeviceFactoryInfoGet';
+export { default as deviceSettingsGet } from './protocol-v2/DeviceSettingsGet';
+export { default as deviceSettingsSet } from './protocol-v2/DeviceSettingsSet';
+export { default as deviceSettingsPageShow } from './protocol-v2/DeviceSettingsPageShow';
+export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
 export { default as filesystemPermissionFix } from './protocol-v2/FilesystemPermissionFix';
 export { default as filesystemFormat } from './protocol-v2/FilesystemFormat';
 export { default as filesystemDiskControl } from './protocol-v2/FilesystemDiskControl';
@@ -66,6 +70,7 @@ export { default as dirRemove } from './DirRemove';
 export { default as pathInfo } from './PathInfo';
 export { default as filesystemFileRead } from './FileRead';
 export { default as filesystemFileWrite } from './FileWrite';
+export { default as uploadPortfolio } from './UploadPortfolio';
 export { default as filesystemFileDelete } from './FileDelete';
 export { default as filesystemDirList } from './DirList';
 export { default as filesystemDirMake } from './DirMake';

package/src/api/protocol-v2/DeviceSessionGet.ts

@@ -1,26 +1,15 @@
 import { BaseMethod } from '../BaseMethod';
 
-export type DeviceSessionGetParams = {
-  sessionId?: string;
-};
-
-export default class DeviceSessionGet extends BaseMethod<DeviceSessionGetParams> {
+export default class DeviceSessionGet extends BaseMethod {
   init() {
     this.requireProtocolV2 = true;
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
-    this.params = {
-      sessionId: this.payload.sessionId,
-    };
+    this.params = undefined;
   }
 
   async run() {
-    const payload = this.params.sessionId ? { session_id: this.params.sessionId } : {};
-    const { message } = await this.device.commands.typedCall(
-      'DeviceSessionGet',
-      'DeviceSession',
-      payload
-    );
+    const { message } = await this.device.commands.typedCall('DeviceSessionGet', 'DeviceSession', {});
     return message;
   }
 }

package/src/api/protocol-v2/DeviceSettingsGet.ts

@@ -0,0 +1,16 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceSettingsGet extends BaseMethod {
+  init() {
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceSettingsGet', 'DeviceSettings', {});
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/DeviceSettingsPageShow.ts

@@ -0,0 +1,59 @@
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+
+export type SupportedDeviceSettingsPage = DeviceSettingsPage;
+
+export type DeviceSettingsPageShowParams = {
+  page?:
+    | SupportedDeviceSettingsPage
+    | 'DeviceReset'
+    | 'DevicePinChange'
+    | 'DevicePassphrase'
+    | 'DeviceAirgap';
+  fieldName?: string;
+  field_name?: string;
+};
+
+const SUPPORTED_PAGES = new Set<number>([
+  DeviceSettingsPage.DeviceReset,
+  DeviceSettingsPage.DevicePinChange,
+  DeviceSettingsPage.DevicePassphrase,
+  DeviceSettingsPage.DeviceAirgap,
+]);
+
+function normalizePage(value: DeviceSettingsPageShowParams['page']): SupportedDeviceSettingsPage {
+  const page = typeof value === 'string' ? DeviceSettingsPage[value] : value;
+  if (page !== undefined && SUPPORTED_PAGES.has(page)) {
+    return page as SupportedDeviceSettingsPage;
+  }
+  throw invalidParameter(
+    'Parameter [page] must be DeviceReset, DevicePinChange, DevicePassphrase, or DeviceAirgap.'
+  );
+}
+
+export default class DeviceSettingsPageShow extends BaseMethod<{
+  page: SupportedDeviceSettingsPage;
+  field_name?: string;
+}> {
+  init() {
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      page: normalizePage(this.payload.page),
+      field_name: this.payload.field_name ?? this.payload.fieldName,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DeviceSettingsPageShow',
+      'Success',
+      this.params
+    );
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/DeviceSettingsSet.ts

@@ -0,0 +1,39 @@
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+
+import type { DeviceSettings } from '@onekeyfe/hd-transport';
+
+export type DeviceSettingsSetParams = {
+  settings?: Omit<DeviceSettings, 'passphrase_enable' | 'airgap_mode'>;
+};
+
+export default class DeviceSettingsSet extends BaseMethod<{
+  settings: Omit<DeviceSettings, 'passphrase_enable' | 'airgap_mode'>;
+}> {
+  init() {
+    const settings = this.payload.settings;
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+      throw invalidParameter('Parameter [settings] must be an object.');
+    }
+
+    const {
+      passphrase_enable: _passphraseEnable,
+      airgap_mode: _airgapMode,
+      ...supported
+    } = settings as DeviceSettings;
+    if (Object.keys(supported).length === 0) {
+      throw invalidParameter('Parameter [settings] must contain at least one supported setting.');
+    }
+
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { settings: supported };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', this.params);
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -0,0 +1,160 @@
+import { blake2s } from '@noble/hashes/blake2s';
+import { bytesToHex } from '@noble/hashes/utils';
+import {
+  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
+  PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
+  WallpaperTarget,
+} from '@onekeyfe/hd-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+import { DataManager } from '../../data-manager';
+import {
+  encodePro2Wallpaper,
+  PRO2_WALLPAPER_HEIGHT,
+  PRO2_WALLPAPER_WIDTH,
+  type Pro2WallpaperColorFormat,
+} from '../../utils/pro2Wallpaper';
+
+export type DeviceUploadWallpaperParams = {
+  width: number;
+  height: number;
+  rgba: Uint8Array | ArrayBuffer;
+  fileName?: string;
+  chunkSize?: number;
+};
+
+export type DeviceUploadWallpaperResponse = {
+  path: string;
+  size: number;
+  colorFormat: Pro2WallpaperColorFormat;
+  message?: string;
+};
+
+const WALLPAPER_DIRECTORY = 'vol0:/wallpapers/user';
+const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
+
+function getDefaultChunkSize(): number {
+  const env = DataManager.getSettings('env');
+  return env && DataManager.isBleConnect(env)
+    ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
+    : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+
+function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
+  if (fileName !== undefined && (!fileName || !SAFE_FILE_NAME.test(fileName))) {
+    throw invalidParameter(
+      'Parameter [fileName] may only contain letters, numbers, underscores, hyphens and an optional .bin suffix.'
+    );
+  }
+  const baseName = fileName ?? `wallpaper-${bytesToHex(blake2s(data)).slice(0, 12)}`;
+  return baseName.endsWith('.bin') ? baseName : `${baseName}.bin`;
+}
+
+export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpaperParams> {
+  private encoded?: { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat };
+
+  private directoryReady = false;
+
+  private uploaded = false;
+
+  private path = '';
+
+  init() {
+    const { width, height, rgba, fileName, chunkSize } = this.payload;
+    if (width !== PRO2_WALLPAPER_WIDTH || height !== PRO2_WALLPAPER_HEIGHT) {
+      throw invalidParameter(
+        `Pro2 wallpaper dimensions must be ${PRO2_WALLPAPER_WIDTH}x${PRO2_WALLPAPER_HEIGHT}.`
+      );
+    }
+    if (!(rgba instanceof ArrayBuffer) && !ArrayBuffer.isView(rgba)) {
+      throw invalidParameter('Parameter [rgba] must be an ArrayBuffer or Uint8Array.');
+    }
+    if (chunkSize !== undefined && (!Number.isInteger(chunkSize) || chunkSize <= 0)) {
+      throw invalidParameter('Parameter [chunkSize] must be a positive integer.');
+    }
+
+    const rgbaBytes =
+      rgba instanceof ArrayBuffer
+        ? rgba
+        : new Uint8Array(rgba.buffer, rgba.byteOffset, rgba.byteLength);
+    this.encoded = encodePro2Wallpaper({ width, height, rgba: rgbaBytes });
+    this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
+    this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+  }
+
+  private async ensureDirectory() {
+    if (this.directoryReady) return;
+    try {
+      await this.device.commands.typedCall('FilesystemDirMake', 'Success', {
+        path: WALLPAPER_DIRECTORY,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!/exist/i.test(message)) throw error;
+    }
+    this.directoryReady = true;
+  }
+
+  private async upload() {
+    if (this.uploaded) return;
+    const encoded = this.encoded;
+    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+
+    const maxChunkSize = getDefaultChunkSize();
+    const requestedChunkSize = this.params.chunkSize ?? maxChunkSize;
+    const chunkSize = Math.min(Math.max(64, Math.floor(requestedChunkSize)), maxChunkSize);
+    let offset = 0;
+    while (offset < encoded.data.byteLength) {
+      const chunk = encoded.data.slice(offset, Math.min(offset + chunkSize, encoded.data.byteLength));
+      const response = await this.device.commands.typedCall(
+        'FilesystemFileWrite',
+        'FilesystemFile',
+        {
+          file: {
+            path: this.path,
+            offset,
+            total_size: encoded.data.byteLength,
+            data: chunk,
+          },
+          overwrite: offset === 0,
+          append: false,
+          ui_percentage: Math.min(
+            Math.ceil(((offset + chunk.byteLength) / encoded.data.byteLength) * 100),
+            100
+          ),
+        },
+        { timeoutMs: undefined }
+      );
+      const processedByte = Number(response.message?.processed_byte);
+      offset = Number.isFinite(processedByte) && processedByte > offset
+        ? processedByte
+        : offset + chunk.byteLength;
+      if (offset > encoded.data.byteLength) {
+        throw invalidParameter(`Invalid processed_byte returned by device: ${processedByte}.`);
+      }
+    }
+    this.uploaded = true;
+  }
+
+  async run(): Promise<DeviceUploadWallpaperResponse> {
+    const encoded = this.encoded;
+    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+    await this.ensureDirectory();
+    await this.upload();
+    const response = await this.device.commands.typedCall('SetWallpaper', 'Success', {
+      target: WallpaperTarget.Lock,
+      path: this.path,
+    });
+    return {
+      path: this.path,
+      size: encoded.data.byteLength,
+      colorFormat: encoded.colorFormat,
+      message: response.message?.message,
+    };
+  }
+}

package/src/core/RequestQueue.ts

@@ -14,6 +14,8 @@ export type RequestTask = {
 export default class RequestQueue {
   private requestQueue = new Map<number, RequestTask>();
 
+  private operationRequestIds = new Map<string, number>();
+
   private pendingCallbackTasks = new Map<string, Deferred<void>>();
 
   // 生成唯一请求ID
@@ -30,11 +32,21 @@ export default class RequestQueue {
       method.responseID = requestId;
     }
     const abortController = new AbortController();
+    method.abortSignal = abortController.signal;
     const task = { id: requestId, method, abortController };
     this.requestQueue.set(requestId, task);
+    const operationId = method.payload?.operationId;
+    if (typeof operationId === 'string' && operationId) {
+      this.operationRequestIds.set(operationId, requestId);
+    }
     return task;
   }
 
+  public abortOperation(operationId: string) {
+    const requestId = this.operationRequestIds.get(operationId);
+    return requestId === undefined ? false : this.abortRequest(requestId);
+  }
+
   public getTask(requestId: number): RequestTask | undefined {
     return this.requestQueue.get(requestId);
   }
@@ -105,6 +117,13 @@ export default class RequestQueue {
 
   // 删除请求
   public releaseTask(requestId: number) {
+    const operationId = this.requestQueue.get(requestId)?.method.payload?.operationId;
+    if (
+      typeof operationId === 'string' &&
+      this.operationRequestIds.get(operationId) === requestId
+    ) {
+      this.operationRequestIds.delete(operationId);
+    }
     this.requestQueue.delete(requestId);
   }
 

package/src/core/index.ts

@@ -56,6 +56,7 @@ import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
 import { getSynchronize } from '../utils/getSynchronize';
+import { runMethodWithUnlockRetry } from '../protocols/protocol-v2/unlockRetry';
 
 import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
@@ -616,7 +617,7 @@ const onCallDevice = async (
       method.device?.commands?.checkDisposed();
 
       try {
-        const response: object = await method.run();
+        const response: object = await runMethodWithUnlockRetry(method, device);
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -1341,6 +1342,10 @@ export default class Core extends EventEmitter {
     Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
   }
 
+  cancelOperation(operationId: string) {
+    this.requestQueue.abortOperation(operationId);
+  }
+
   private getCoreContext() {
     return {
       sdkInstanceId: this.sdkInstanceId,
@@ -1409,6 +1414,10 @@ export default class Core extends EventEmitter {
         cancel(this.getCoreContext(), message.payload.connectId);
         break;
       }
+      case IFRAME.CANCEL_OPERATION: {
+        this.cancelOperation(message.payload.operationId);
+        break;
+      }
       case IFRAME.CALLBACK: {
         Log.log('callback message: ', message);
         postMessage(message);