@onekeyfe/hd-core 1.2.0-alpha.167 → 1.2.0-alpha.169

package/src/api/FirmwareUpdateV4.ts

@@ -375,6 +375,18 @@ const isProtocolV2TargetStatusInProgress = (
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_PENDING ||
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS;
 
+const getProtocolV2FirmwareStatusFingerprint = (
+  statusTargets: ProtocolV2FirmwareUpdateStatusTarget[]
+) =>
+  JSON.stringify(
+    statusTargets.map(target => ({
+      targetId: normalizeProtocolV2TargetId(target.target_id) ?? target.target_id,
+      status: normalizeProtocolV2TargetStatus(target.status) ?? target.status ?? null,
+      payloadVersion: target.payload_version ?? null,
+      path: target.path ?? null,
+    }))
+  );
+
 const isProtocolV2TargetStatusFailed = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) => {
   const normalizedStatus = normalizeProtocolV2TargetStatus(status);
   return (
@@ -530,6 +542,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2InstallBaselineVersions = new Map<number, string>();
 
+  private protocolV2InstallStatusBaseline?: ProtocolV2FirmwareUpdateStatusTarget[];
+
+  private protocolV2InstallNeedsBleReconnect = false;
+
   private protocolV2LastRuntimeProbeFeatures?: Features;
 
   private protocolV2LastTransferProgress?: number;
@@ -2383,23 +2399,34 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   ) {
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
     const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
-    const startTime = Date.now();
+    const confirmationStartedAt = Date.now();
+    let installStartedAt = requireCurrentInstallStatus ? undefined : confirmationStartedAt;
+    const effectiveBaselineStatusTargets = this.protocolV2InstallStatusBaseline;
+    const baselineStatusFingerprint = effectiveBaselineStatusTargets
+      ? getProtocolV2FirmwareStatusFingerprint(effectiveBaselineStatusTargets)
+      : undefined;
     let lastError: unknown;
-    // DeviceFirmwareUpdateRequest leaves the current loader link usable for status polling.
-    // Reconnecting here probes DeviceInfo, which loaders reject while installation is active.
-    let shouldReconnect = false;
+    // USB may keep the loader link usable. BLE can release it as installation starts, so its
+    // recovery reconnects directly to status polling without generic Ping or DeviceInfo probes.
+    let shouldReconnect = this.protocolV2InstallNeedsBleReconnect;
+    this.protocolV2InstallNeedsBleReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
+    let bleInstallLinkReady = false;
     let installEvidenceObserved = false;
     let currentInstallStatusObserved = false;
 
-    while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
+    while (Date.now() - (installStartedAt ?? confirmationStartedAt) < PROTOCOL_V2_INSTALL_TIMEOUT) {
       // A transport release caused by an explicit workflow cancellation must not
       // be mistaken for the expected device reboot during installation.
       this.throwIfAborted();
       try {
         if (shouldReconnect) {
-          await this.reconnectProtocolV2Device();
-          deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+          const isBleInstallReconnect = this.isBleReconnect();
+          await this.reconnectProtocolV2Device({ skipBleProtocolProbe: isBleInstallReconnect });
+          bleInstallLinkReady = isBleInstallReconnect;
+          deviceInfo = isBleInstallReconnect
+            ? undefined
+            : await this.verifyProtocolV2ReconnectIdentity();
           shouldReconnect = false;
         }
         const currentDeviceInfo = deviceInfo;
@@ -2426,7 +2453,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             statusResponse.type === 'DeviceFirmwareUpdateStatus'
               ? ((statusResponse.message.records ?? []) as ProtocolV2FirmwareUpdateStatusTarget[])
               : [];
-          const hasInProgressTarget = statusTargets.some(target => {
+          const hasPendingOrInProgressTarget = statusTargets.some(target => {
             const targetId = normalizeProtocolV2TargetId(target.target_id);
             return (
               targetId !== undefined &&
@@ -2434,8 +2461,25 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               isProtocolV2TargetStatusInProgress(target.status)
             );
           });
-          if (hasInProgressTarget) {
+          const isExpectedStatusSnapshot =
+            statusTargets.length === targets.length &&
+            targets.every((expectedTarget, index) => {
+              const statusTarget = statusTargets[index];
+              return (
+                statusTarget !== undefined &&
+                normalizeProtocolV2TargetId(statusTarget.target_id) === expectedTarget.target_id &&
+                statusTarget.path === expectedTarget.path
+              );
+            });
+          const statusFingerprint = getProtocolV2FirmwareStatusFingerprint(statusTargets);
+          const hasCurrentInstallTransition =
+            baselineStatusFingerprint !== undefined
+              ? isExpectedStatusSnapshot && statusFingerprint !== baselineStatusFingerprint
+              : hasPendingOrInProgressTarget;
+          if (!currentInstallStatusObserved && hasCurrentInstallTransition) {
             currentInstallStatusObserved = true;
+            installStartedAt = Date.now();
+            Log.log('[FirmwareUpdateV4] current firmware install records observed');
           }
           const hasMatchingTargetStatus = statusTargets.some(target => {
             const targetId = normalizeProtocolV2TargetId(target.target_id);
@@ -2514,12 +2558,22 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           // missing endpoint as completion only after the runtime probe confirms App mode.
           if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
             if (!currentDeviceInfo) {
+              if (!bleInstallLinkReady) {
+                throw ERRORS.TypedError(
+                  HardwareErrorCode.RuntimeError,
+                  'Protocol V2 device identity is unavailable during install polling'
+                );
+              }
+              deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+            }
+            const reconnectDeviceInfo = currentDeviceInfo ?? deviceInfo;
+            if (!reconnectDeviceInfo) {
               throw ERRORS.TypedError(
                 HardwareErrorCode.RuntimeError,
                 'Protocol V2 device identity is unavailable during install polling'
               );
             }
-            const isNormalMode = await this.probeProtocolV2NormalMode(currentDeviceInfo);
+            const isNormalMode = await this.probeProtocolV2NormalMode(reconnectDeviceInfo);
             if (
               isNormalMode &&
               (installEvidenceObserved ||
@@ -2544,6 +2598,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           } else {
             shouldReconnect = true;
             deviceInfo = undefined;
+            bleInstallLinkReady = false;
             lastError = error;
             Log.log(
               '[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ',
@@ -2567,6 +2622,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
         shouldReconnect = true;
         deviceInfo = undefined;
+        bleInstallLinkReady = false;
         Log.log('Protocol V2 firmware install device readiness probe failed: ', error);
       }
       await wait(1000);
@@ -2704,9 +2760,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     );
   }
 
-  private async reconnectProtocolV2Device() {
+  private async reconnectProtocolV2Device(options?: { skipBleProtocolProbe?: boolean }) {
     if (this.isBleReconnect()) {
-      await this.acquireProtocolV2BleDevice();
+      await this.acquireProtocolV2BleDevice(options?.skipBleProtocolProbe);
       return;
     }
 
@@ -2834,13 +2890,31 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     await wait(2000);
   }
 
-  private async acquireProtocolV2BleDevice() {
-    await this.device.deviceConnector?.acquire(
-      this.device.originalDescriptor.id,
+  private async acquireProtocolV2BleDevice(skipProtocolProbe = false) {
+    const connector = this.device.deviceConnector;
+    const expectedId = this.device.originalDescriptor.id;
+    if (!skipProtocolProbe) {
+      await connector?.acquire(expectedId, null, true, PROTOCOL_V2_CONNECT_PROTOCOL);
+      return;
+    }
+    const deviceDiff = await connector?.enumerate();
+    const reconnectDescriptor = deviceDiff?.descriptors?.find(
+      descriptor => descriptor.id === expectedId
+    );
+    if (!reconnectDescriptor) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
+    }
+    await connector?.acquire(
+      reconnectDescriptor.id,
       null,
       true,
-      PROTOCOL_V2_CONNECT_PROTOCOL
+      PROTOCOL_V2_CONNECT_PROTOCOL,
+      undefined,
+      undefined,
+      skipProtocolProbe
     );
+    this.device.commands.disposed = false;
+    this.device.getCommands().mainId = reconnectDescriptor.id;
   }
 
   private async protocolV2StartFirmwareUpdate({
@@ -2849,8 +2923,31 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     targets: Array<{ target_id: number; path: string }>;
   }) {
     this.protocolV2LastRuntimeProbeFeatures = undefined;
+    this.protocolV2InstallStatusBaseline = undefined;
+    this.protocolV2InstallNeedsBleReconnect = false;
     const commands = this.device.getCommands();
     await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
+    try {
+      const baselineStatusResponse = await commands.typedCall(
+        'DeviceFirmwareUpdateStatusGet',
+        ['DeviceFirmwareUpdateStatus', 'Success'],
+        {
+          fields: {
+            status: true,
+            payload_version: true,
+            path: true,
+          },
+        },
+        { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT }
+      );
+      this.protocolV2InstallStatusBaseline =
+        baselineStatusResponse.type === 'DeviceFirmwareUpdateStatus'
+          ? ((baselineStatusResponse.message.records ??
+              []) as ProtocolV2FirmwareUpdateStatusTarget[])
+          : [];
+    } catch (error) {
+      Log.log('[FirmwareUpdateV4] unable to capture pre-install firmware status: ', error);
+    }
     this.device.setCancelableAction(() => commands.cancelDevice());
     const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
     this.postMessage(
@@ -2864,7 +2961,20 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         ...(interaction ? { interaction } : {}),
       })
     );
-    await commands.call('DeviceFirmwareUpdateRequest', {}, { returnAfterWrite: true });
+    try {
+      await commands.call('DeviceFirmwareUpdateRequest', {});
+    } catch (error) {
+      this.throwIfAborted();
+      if (!isProtocolV2DeviceDisconnectedError(error)) {
+        throw error;
+      }
+      Log.log(
+        '[FirmwareUpdateV4] BLE transport released after install request; continue status polling'
+      );
+      if (this.isBleReconnect()) {
+        this.protocolV2InstallNeedsBleReconnect = true;
+      }
+    }
   }
 
   private async protocolV2Reboot(rebootType: DeviceRebootType) {

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

@@ -7,6 +7,7 @@ import { BaseMethod } from '../BaseMethod';
 import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
 import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+import { DataManager } from '../../data-manager';
 import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
 import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
 import { LoggerNames, getLogger } from '../../utils';
@@ -14,6 +15,7 @@ import {
   PRO2_WALLPAPER_HEIGHT,
   PRO2_WALLPAPER_WIDTH,
   type Pro2WallpaperColorFormat,
+  type Pro2WallpaperEncoding,
   encodePro2Wallpaper,
 } from '../../utils/pro2Wallpaper';
 
@@ -21,6 +23,7 @@ export type DeviceUploadWallpaperParams = {
   jpegBase64: string;
   fileName?: string;
   chunkSize?: number;
+  encoding?: Pro2WallpaperEncoding;
 };
 
 export type DeviceUploadWallpaperResponse = {
@@ -61,10 +64,16 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
   private path = '';
 
   init() {
-    const { jpegBase64, fileName, chunkSize } = this.payload;
+    const { jpegBase64, fileName, chunkSize, encoding } = this.payload;
     if (chunkSize !== undefined && (!Number.isInteger(chunkSize) || chunkSize <= 0)) {
       throw invalidParameter('Parameter [chunkSize] must be a positive integer.');
     }
+    if (encoding !== undefined && encoding !== 'rgb565' && encoding !== 'i8-lz4') {
+      throw invalidParameter('Parameter [encoding] must be either rgb565 or i8-lz4.');
+    }
+    const env = DataManager.getSettings('env');
+    const resolvedEncoding: Pro2WallpaperEncoding =
+      encoding ?? (env && DataManager.isBleConnect(env) ? 'i8-lz4' : 'rgb565');
 
     const decoded = decodeJpegBase64ToRgba({
       jpegBase64,
@@ -76,9 +85,10 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
       width: PRO2_WALLPAPER_WIDTH,
       height: PRO2_WALLPAPER_HEIGHT,
       rgba: decoded.data,
+      encoding: resolvedEncoding,
     });
     this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
-    this.params = { jpegBase64, fileName, chunkSize };
+    this.params = { jpegBase64, fileName, chunkSize, encoding: resolvedEncoding };
     this.unlockPolicy = 'unlock-before-run';
     // File writes and wallpaper apply require an unlocked device. Either PIN
     // may authorize this device-management action.

package/src/core/index.ts

@@ -415,13 +415,6 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
-    // This early return bypasses the normal-path bookkeeping at the end of the
-    // call. Without it the task leaks and haunts every later queue snapshot
-    // and cancel sweep (field log: a completed task lingered for 6 minutes),
-    // and the request stays in the active maps, so repeated preconnects pile
-    // up phantom work in diagnostics.
-    completeMethodRequestContext(method);
-    requestQueue.releaseTask(method.responseID);
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -961,60 +954,7 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
  */
-// device.acquire awaits a transport reply with no deadline of its own; a
-// transport that never settles (field case: Electron main lost an IPC reply,
-// "reply was never sent" after 5 minutes) hangs the call forever and cancel()
-// only takes effect at poll checkpoints. Race acquire against a deadline and
-// the caller's abort signal so the hang is bounded and cancel is immediate.
-const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
-
-function raceBleAcquire<T>(acquirePromise: Promise<T>, abortSignal?: AbortSignal): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    let settled = false;
-    const settle = (fn: () => void) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(deadline);
-      abortSignal?.removeEventListener('abort', onAbort);
-      fn();
-    };
-    const onAbort = () =>
-      settle(() => reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)));
-    const deadline = setTimeout(
-      () =>
-        settle(() =>
-          reject(
-            ERRORS.TypedError(
-              HardwareErrorCode.BleTimeoutError,
-              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`
-            )
-          )
-        ),
-      BLE_ACQUIRE_DEADLINE_MS
-    );
-    // Attach before any early return so a late settlement of acquirePromise
-    // is always consumed — an abort or deadline must never leave the acquire
-    // rejection unhandled.
-    acquirePromise.then(
-      value => settle(() => resolve(value)),
-      error => settle(() => reject(error))
-    );
-    if (abortSignal) {
-      if (abortSignal.aborted) {
-        onAbort();
-        return;
-      }
-      abortSignal.addEventListener('abort', onAbort);
-    }
-  });
-}
-
-async function connectDeviceForBle(
-  method: BaseMethod,
-  device: Device,
-  abortSignal?: AbortSignal,
-  retryCount = 0
-) {
+async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
     if (device.wasInterruptedByUser()) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
@@ -1028,43 +968,9 @@ async function connectDeviceForBle(
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
-      // The deadline/abort guards are scoped to the desktop electron
-      // transport: its IPC acquire is the only path with a proven
-      // never-settling failure mode, while react-native/lowlevel acquire may
-      // legitimately block on a user-driven system bonding prompt for longer
-      // than any sane deadline. Other envs keep the plain acquire unchanged.
-      const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
-      // A cancel landing during the retry backoff must not start a new acquire.
-      if (useAcquireGuards && abortSignal?.aborted) {
-        throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
-      }
-      if (!useAcquireGuards) {
-        await device.acquire(method.payload.connectProtocol, {
-          forceProtocolDetection: method.payload.forceProtocolDetection,
-        });
-      } else {
-        try {
-          await raceBleAcquire(
-            device.acquire(method.payload.connectProtocol, {
-              forceProtocolDetection: method.payload.forceProtocolDetection,
-            }),
-            abortSignal
-          );
-        } catch (err) {
-          // A deadline hit means the transport is wedged mid-acquire; drop the
-          // link before the retry so it cold-connects instead of stacking a
-          // second connect onto the half-open one.
-          if (
-            err.errorCode === HardwareErrorCode.BleTimeoutError &&
-            device.mainId &&
-            device.deviceConnector
-          ) {
-            await device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
-            device.markTransportDisconnected();
-          }
-          throw err;
-        }
-      }
+      await device.acquire(method.payload.connectProtocol, {
+        forceProtocolDetection: method.payload.forceProtocolDetection,
+      });
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -1104,7 +1010,7 @@ async function connectDeviceForBle(
       const nextRetry = retryCount + 1;
       Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device, abortSignal, nextRetry);
+      await connectDeviceForBle(method, device, nextRetry);
     } else {
       throw err;
     }
@@ -1214,7 +1120,7 @@ const ensureConnected = async (
             if (tryCount === 1) {
               device.beginConnectionAttempt();
             }
-            await connectDeviceForBle(method, device, abortSignal);
+            await connectDeviceForBle(method, device);
           }
           resolve(device);
           return;

package/src/device/DeviceConnector.ts

@@ -96,7 +96,8 @@ export default class DeviceConnector {
     forceCleanRunPromise?: boolean,
     expectedProtocol?: HardwareConnectProtocol,
     protocolHint?: HardwareConnectProtocol,
-    forceProtocolDetection?: boolean
+    forceProtocolDetection?: boolean,
+    skipProtocolProbe?: boolean
   ) {
     Log.debug('acquire', path, session, expectedProtocol, protocolHint);
     const env = DataManager.getSettings('env');
@@ -104,13 +105,17 @@ export default class DeviceConnector {
       const transport = this.getActiveTransport();
       let res;
       if (DataManager.isBleConnect(env)) {
-        res = await transport.acquire({
+        const acquireInput: Parameters<Transport['acquire']>[0] & {
+          skipProtocolProbe?: boolean;
+        } = {
           uuid: path,
           forceCleanRunPromise,
           expectedProtocol,
           protocolHint,
           forceProtocolDetection,
-        });
+          skipProtocolProbe,
+        };
+        res = await transport.acquire(acquireInput);
       } else {
         res = await transport.acquire({
           path,