@onekeyfe/hd-core 1.2.0-alpha.19 → 1.2.0-alpha.20

package/src/core/RequestQueue.ts

@@ -1,14 +1,28 @@
+import { type Deferred, createDeferred } from '@onekeyfe/hd-shared';
+
 import { LoggerNames, getLogger } from '../utils';
 
-import type { Deferred } from '@onekeyfe/hd-shared';
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
+const OPERATION_PRE_CANCEL_TTL_MS = 30_000;
+const DEFAULT_BACKGROUND_PREEMPT_TIMEOUT_MS = 5_500;
+
 export type RequestTask = {
   id: number;
   method: BaseMethod;
   callPromise?: Deferred<any> | undefined;
   abortController?: AbortController;
+  settled: Deferred<void>;
+  released: Deferred<void>;
+};
+
+export type RequestAdmission =
+  | { status: 'reserved'; task: RequestTask }
+  | { status: 'busy'; blockingTask?: RequestTask };
+
+export type RequestAdmissionOptions = {
+  backgroundPreemptTimeoutMs?: number;
 };
 
 export default class RequestQueue {
@@ -16,8 +30,18 @@ export default class RequestQueue {
 
   private operationRequestIds = new Map<string, number>();
 
+  private pendingOperationCancellations = new Map<string, number>();
+
   private pendingCallbackTasks = new Map<string, Deferred<void>>();
 
+  private prunePendingOperationCancellations(now = Date.now()) {
+    this.pendingOperationCancellations.forEach((expiresAt, operationId) => {
+      if (expiresAt <= now) {
+        this.pendingOperationCancellations.delete(operationId);
+      }
+    });
+  }
+
   // 生成唯一请求ID
   public generateRequestId = (method?: BaseMethod) => {
     if (method && method.responseID != null) {
@@ -33,18 +57,91 @@ export default class RequestQueue {
     }
     const abortController = new AbortController();
     method.abortSignal = abortController.signal;
-    const task = { id: requestId, method, abortController };
+    const task = {
+      id: requestId,
+      method,
+      abortController,
+      settled: createDeferred<void>(),
+      released: createDeferred<void>(),
+    };
     this.requestQueue.set(requestId, task);
     const operationId = method.payload?.operationId;
     if (typeof operationId === 'string' && operationId) {
       this.operationRequestIds.set(operationId, requestId);
+      this.prunePendingOperationCancellations();
+      if (this.pendingOperationCancellations.delete(operationId)) {
+        abortController.abort();
+      }
     }
     return task;
   }
 
+  public async admitTask(
+    method: BaseMethod,
+    options: RequestAdmissionOptions = {}
+  ): Promise<RequestAdmission> {
+    const activeTasks = Array.from(this.requestQueue.values()).filter(
+      task => task.method.connectId === method.connectId
+    );
+
+    if (method.executionPriority === 'background') {
+      if (activeTasks.length) {
+        Log.debug(
+          `Reject background method ${method.name}: device is occupied by ${activeTasks[0].method.name}`
+        );
+        return { status: 'busy', blockingTask: activeTasks[0] };
+      }
+      return { status: 'reserved', task: this.createTask(method) };
+    }
+
+    const backgroundTasks = activeTasks.filter(
+      task => task.method.executionPriority === 'background'
+    );
+    if (!backgroundTasks.length) {
+      return { status: 'reserved', task: this.createTask(method) };
+    }
+
+    Log.debug(
+      `Preempt ${backgroundTasks.length} background request(s) for user method ${method.name}`
+    );
+    backgroundTasks.forEach(task => task.abortController?.abort());
+    const timeoutMs =
+      options.backgroundPreemptTimeoutMs ??
+      Math.max(
+        DEFAULT_BACKGROUND_PREEMPT_TIMEOUT_MS,
+        ...backgroundTasks.map(task => task.method.maxAbortLatencyMs ?? 0)
+      );
+    const released = await this.waitForTasksReleased(backgroundTasks, timeoutMs);
+    if (!released) {
+      Log.warn(`Background request cleanup timed out before user method ${method.name}`);
+      return { status: 'busy', blockingTask: backgroundTasks[0] };
+    }
+
+    return { status: 'reserved', task: this.createTask(method) };
+  }
+
+  private async waitForTasksReleased(tasks: RequestTask[], timeoutMs: number) {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeoutPromise = new Promise<false>(resolve => {
+      timer = setTimeout(() => resolve(false), timeoutMs);
+    });
+    const releasedPromise = Promise.all(tasks.map(task => task.released.promise)).then(() => true);
+    const released = await Promise.race([releasedPromise, timeoutPromise]);
+    if (timer) {
+      clearTimeout(timer);
+    }
+    return released;
+  }
+
   public abortOperation(operationId: string) {
     const requestId = this.operationRequestIds.get(operationId);
-    return requestId === undefined ? false : this.abortRequest(requestId);
+    if (requestId !== undefined) {
+      return this.abortRequest(requestId);
+    }
+    const now = Date.now();
+    this.prunePendingOperationCancellations(now);
+    this.pendingOperationCancellations.set(operationId, now + OPERATION_PRE_CANCEL_TTL_MS);
+    return false;
   }
 
   public getTask(requestId: number): RequestTask | undefined {
@@ -89,6 +186,7 @@ export default class RequestQueue {
         count++;
       }
     });
+    this.pendingOperationCancellations.clear();
     return count;
   }
 
@@ -102,8 +200,8 @@ export default class RequestQueue {
     const request = this.requestQueue.get(requestId);
     if (request) {
       request.callPromise?.resolve(response);
+      request.settled.resolve();
     }
-    this.releaseTask(requestId);
   }
 
   // 拒绝请求
@@ -111,19 +209,22 @@ export default class RequestQueue {
     const request = this.requestQueue.get(requestId);
     if (request) {
       request.callPromise?.reject(error);
+      request.settled.resolve();
     }
-    this.releaseTask(requestId);
   }
 
   // 删除请求
   public releaseTask(requestId: number) {
-    const operationId = this.requestQueue.get(requestId)?.method.payload?.operationId;
+    const task = this.requestQueue.get(requestId);
+    const operationId = task?.method.payload?.operationId;
     if (
       typeof operationId === 'string' &&
       this.operationRequestIds.get(operationId) === requestId
     ) {
       this.operationRequestIds.delete(operationId);
     }
+    task?.settled.resolve();
+    task?.released.resolve();
     this.requestQueue.delete(requestId);
   }
 

package/src/core/index.ts

@@ -52,6 +52,7 @@ import {
   createDeviceMessage,
   createResponseMessage,
   createUiMessage,
+  getLogBlockLabel,
 } from '../events';
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
@@ -98,14 +99,14 @@ function hasDeriveCardano(method: BaseMethod): boolean {
 
 const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   initSession: method?.payload.initSession,
-  passphraseState: method?.payload.passphraseState,
+  passphraseState: method?.payload.useEmptyPassphrase ? undefined : method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
   connectProtocol: method?.payload.connectProtocol,
   protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
 });
 
-let _core: Core;
+let _core: Core | undefined;
 let _deviceList: DeviceList | undefined;
 let _connector: DeviceConnector | undefined;
 let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
@@ -149,7 +150,7 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   }
 
   // find api method
-  let method: BaseMethod;
+  let method!: BaseMethod;
   try {
     method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
@@ -165,7 +166,11 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
 
     method.init();
   } catch (error) {
-    return Promise.reject(error);
+    if (method) {
+      completeMethodRequestContext(method, error);
+      method.dispose();
+    }
+    return createResponseMessage(method?.responseID ?? message.id, false, { error });
   }
 
   DevicePool.emitter.on(DEVICE.CONNECT, onDeviceConnectHandler);
@@ -191,34 +196,25 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   //   );
   // }
 
-  const { requestQueue, methodSynchronize } = context;
-  const error = await methodSynchronize(() => {
-    for (const requestId of requestQueue.getRequestTasksId()) {
-      const task = requestQueue.getTask(requestId);
-      Log.debug(
-        'pre request task: ',
-        `task?.id: ${task?.id},
-      task?.method.connectId: ${task?.method.connectId},
-      task?.method.deviceId: ${task?.method.deviceId},
-      task?.method.name: ${task?.method.name}`
-      );
-      // if (task) {
-      //   return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceBusy));
-      // }
-    }
-    return null;
-  });
-
-  if (error) {
-    return createResponseMessage(method.responseID, false, { error });
-  }
-
   // only the pre-warm signal (PreInitialize) forks here; normal methods fall
   // through to onCallDevice below, so the pre-warm dedup/guards never touch them
   if (method.isPreWarmSignal) {
     return handlePreWarmSignal(context, message, method);
   }
 
+  const { requestQueue, methodSynchronize } = context;
+  const admission = await methodSynchronize(
+    () => requestQueue.admitTask(method),
+    method.connectId ?? method.deviceId ?? 'unknown-device'
+  );
+  if (admission.status === 'busy') {
+    const error = ERRORS.TypedError(HardwareErrorCode.DeviceBusy);
+    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
+    completeMethodRequestContext(method, error);
+    method.dispose();
+    return createResponseMessage(method.responseID, false, { error });
+  }
+
   return onCallDevice(context, message, method);
 };
 
@@ -231,6 +227,7 @@ const handlePreWarmSignal = async (
   method: BaseMethod
 ): Promise<any> => {
   const createAckResponse = () => {
+    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
     completeMethodRequestContext(method);
     method.dispose();
     return createResponseMessage(method.responseID, true, true);
@@ -337,7 +334,7 @@ const onCallDevice = async (
 
   await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
-  const task = requestQueue.createTask(method);
+  const task = requestQueue.getTask(method.responseID) ?? requestQueue.createTask(method);
 
   // Pre-warm holds the device as a per-connectId callback task so a concurrent
   // real call waits (before ensureConnected) instead of racing its Initialize.
@@ -364,7 +361,7 @@ const onCallDevice = async (
     );
   } catch (e) {
     preWarmCallbackTask?.resolve();
-    console.log('ensureConnected error: ', e);
+    Log.debug('ensureConnected error: ', e);
 
     completeMethodRequestContext(method, e);
 
@@ -381,6 +378,10 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
+    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
+    requestQueue.releaseTask(method.responseID);
+    completeMethodRequestContext(method);
+    method.dispose();
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -432,8 +433,8 @@ const onCallDevice = async (
     await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
     const inner = async (): Promise<void> => {
-      // Protocol V2 专属方法统一守卫：协议在 acquire/initialize 后已确定，
-      // 非 V2 设备直接抛出明确的 NotSupport 错误（见 BaseMethod.requireProtocolV2）。
+      // The protocol is established after acquire/initialize. Reject Protocol V2-only
+      // methods on other devices through BaseMethod.requireProtocolV2.
       if (method.requireProtocolV2 && !device.isProtocolV2()) {
         throw createDeviceNotSupportMethodError(method.name, device.getCurrentFirmwareType());
       }
@@ -447,8 +448,8 @@ const onCallDevice = async (
       const deviceFirmwareType = device.getCurrentFirmwareType();
       let newVersionStatus: ReturnType<typeof DataManager.getFirmwareStatus> | undefined;
 
-      // 故障批次检测与远端强制升级门禁基于 V1 features/remote config，
-      // Pro2(V2) 暂不参与：profile 版的 firmwareStatus 需要 DataManager 支持后再接入。
+      // Defective-batch and forced-update gates depend on V1 features/remote config.
+      // Pro2 joins after DataManager supports its profile firmwareStatus.
       if (device.features && !device.isProtocolV2()) {
         await DataManager.checkAndReloadData();
 
@@ -660,8 +661,9 @@ const onCallDevice = async (
       skipInitialize: canSkipInitialize(method, device),
       ...parseInitOptions(method),
     };
-    const deviceRun = () => device.run(inner, runOptions);
-    task.callPromise = createDeferred<any>(deviceRun);
+    const deviceRunPromise = device.run(inner, runOptions);
+    task.callPromise = createDeferred<any>();
+    deviceRunPromise.catch(error => task.callPromise?.reject(error));
 
     try {
       return await task.callPromise.promise;
@@ -669,6 +671,8 @@ const onCallDevice = async (
       Log.debug('Device Run Error: ', e);
       completeMethodRequestContext(method, e);
       return createResponseMessage(method.responseID, false, { error: e });
+    } finally {
+      await deviceRunPromise.catch(() => undefined);
     }
   } catch (error) {
     messageResponse = createResponseMessage(method.responseID, false, { error });
@@ -1192,16 +1196,16 @@ const closePopup = () => {
 };
 
 const onDeviceConnectHandler = (device: Device) => {
-  const env = DataManager.getSettings('env');
-  const deviceObject = DataManager.isBleConnect(env) ? device : device.toMessageObject();
-  postMessage(createDeviceMessage(DEVICE.CONNECT, { device: deviceObject as KnownDevice }));
+  const deviceObject = device.toMessageObject();
+  if (!deviceObject) return;
+  postMessage(createDeviceMessage(DEVICE.CONNECT, { device: deviceObject }));
 };
 
 const onDeviceDisconnectHandler = (device: Device) => {
   device.clearPreInitialized();
-  const env = DataManager.getSettings('env');
-  const deviceObject = DataManager.isBleConnect(env) ? device : device.toMessageObject();
-  postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject as KnownDevice }));
+  const deviceObject = device.toMessageObject();
+  if (!deviceObject) return;
+  postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject }));
 };
 
 const onDevicePinHandler = async (...[device, type, callback]: DeviceEvents['pin']) => {
@@ -1371,6 +1375,8 @@ export default class Core extends EventEmitter {
 
   private requestQueue = new RequestQueue();
 
+  private disposePromise?: Promise<void>;
+
   // background task
   private prePendingCallPromise: Promise<void> | undefined;
 
@@ -1433,10 +1439,17 @@ export default class Core extends EventEmitter {
       }
 
       case IFRAME.CALL: {
-        Log.log(`[${Date.now()}][CALL_API]`, message);
+        const logBlockLabel = getLogBlockLabel(message);
+        Log.log(
+          `[${Date.now()}][CALL_API]`,
+          logBlockLabel ? { method: logBlockLabel, payload: '[REDACTED]' } : message
+        );
         const response = await callAPI(this.getCoreContext(), message);
         const { success, payload } = response;
-        Log.log(`[${Date.now()}][CALL_API_RESPONSE]`, response);
+        Log.log(
+          `[${Date.now()}][CALL_API_RESPONSE]`,
+          logBlockLabel ? { method: logBlockLabel, payload: '[REDACTED]' } : response
+        );
         if (success) {
           return response;
         }
@@ -1470,20 +1483,52 @@ export default class Core extends EventEmitter {
     return Promise.resolve(message);
   }
 
-  dispose() {
+  dispose(): Promise<void> {
+    if (!this.disposePromise) {
+      this.disposePromise = this.disposeResources();
+    }
+    return this.disposePromise;
+  }
+
+  private async disposeResources(): Promise<void> {
+    Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
+    pollingManager.stopAll();
+    this.requestQueue.abortAllRequests();
+    cleanup();
+
+    _connector?.stop();
+    let transportCleanup: Promise<void>;
+    try {
+      transportCleanup = Promise.resolve(TransportManager.getTransport()?.stop?.()).catch(error => {
+        Log.warn('[Core] Transport cleanup failed:', error);
+      });
+    } catch (error) {
+      Log.warn('[Core] Transport cleanup failed:', error);
+      transportCleanup = Promise.resolve();
+    }
+
+    // Preserve synchronous dispose semantics for in-memory state and listeners.
     _deviceList = undefined;
     _connector = undefined;
+    DevicePool.resetState();
     deviceCacheMap.clear();
     preWarmInflight.clear();
     preWarmDoneAt.clear();
-    Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
+    preConnectCache = { passphraseState: undefined };
+    this.prePendingCallPromise = undefined;
+    this.removeAllListeners();
     cleanupSdkInstance(this.sdkInstanceId);
+    if (_core === this) _core = undefined;
+
+    // Transports, especially Node USB, may release native handles asynchronously.
+    await transportCleanup;
   }
 }
 
 export const initCore = () => {
-  _core = new Core();
-  return _core;
+  const core = new Core();
+  _core = core;
+  return core;
 };
 
 export const initConnector = () => {

package/src/data/messages/messages-protocol-v2.json

@@ -482,7 +482,7 @@
         "MessageType_DeviceStatus": 60603,
         "MessageType_DevGetOnboardingStatus": 60604,
         "MessageType_DevOnboardingStatus": 60605,
-        "MessageType_DeviceSessionOpen": 60606,
+        "MessageType_DeviceSessionGet": 60606,
         "MessageType_DeviceSession": 60607,
         "MessageType_DeviceSessionAskPin": 60608,
         "MessageType_FilesystemPermissionFix": 60800,
@@ -11849,61 +11849,49 @@
     },
     "DeviceSettings": {
       "fields": {
-        "label": {
-          "type": "string",
-          "id": 1
-        },
         "bt_enable": {
           "type": "bool",
-          "id": 2
+          "id": 1
         },
         "language": {
           "type": "string",
-          "id": 3
+          "id": 2
         },
         "wallpaper_path": {
           "type": "string",
-          "id": 4
+          "id": 3
         },
         "brightness": {
           "type": "uint32",
-          "id": 7
-        },
-        "autolock_delay_ms": {
-          "type": "uint32",
-          "id": 8
-        },
-        "autoshutdown_delay_ms": {
-          "type": "uint32",
-          "id": 9
+          "id": 4
         },
         "animation_enable": {
           "type": "bool",
-          "id": 10
+          "id": 5
         },
         "tap_to_wake": {
           "type": "bool",
-          "id": 11
+          "id": 6
         },
         "haptic_feedback": {
           "type": "bool",
-          "id": 12
+          "id": 7
         },
         "device_name_display_enabled": {
           "type": "bool",
-          "id": 13
+          "id": 8
         },
         "airgap_mode": {
           "type": "bool",
-          "id": 14
+          "id": 9
         },
         "usb_lock_enable": {
           "type": "bool",
-          "id": 17
+          "id": 10
         },
         "random_keypad": {
           "type": "bool",
-          "id": 18
+          "id": 11
         },
         "passphrase_enable": {
           "type": "bool",
@@ -11912,6 +11900,18 @@
         "fido_enabled": {
           "type": "bool",
           "id": 101
+        },
+        "autolock_delay_ms": {
+          "type": "uint32",
+          "id": 102
+        },
+        "autoshutdown_delay_ms": {
+          "type": "uint32",
+          "id": 103
+        },
+        "label": {
+          "type": "string",
+          "id": 104
         }
       }
     },
@@ -12427,68 +12427,14 @@
         }
       }
     },
-    "DeviceSessionResume": {
+    "DeviceSessionGet": {
       "fields": {
         "session_id": {
-          "rule": "required",
           "type": "bytes",
           "id": 1
         }
       }
     },
-    "DeviceHostPassphrase": {
-      "fields": {
-        "passphrase": {
-          "rule": "required",
-          "type": "string",
-          "id": 1
-        }
-      }
-    },
-    "DevicePassphraseOnDevice": {
-      "fields": {}
-    },
-    "DeviceAttachPinOnDevice": {
-      "fields": {}
-    },
-    "DeviceWalletSelect": {
-      "oneofs": {
-        "access": {
-          "oneof": ["host_passphrase", "passphrase_on_device", "attach_pin_on_device"]
-        }
-      },
-      "fields": {
-        "host_passphrase": {
-          "type": "DeviceHostPassphrase",
-          "id": 1
-        },
-        "passphrase_on_device": {
-          "type": "DevicePassphraseOnDevice",
-          "id": 2
-        },
-        "attach_pin_on_device": {
-          "type": "DeviceAttachPinOnDevice",
-          "id": 3
-        }
-      }
-    },
-    "DeviceSessionOpen": {
-      "oneofs": {
-        "mode": {
-          "oneof": ["resume", "select"]
-        }
-      },
-      "fields": {
-        "resume": {
-          "type": "DeviceSessionResume",
-          "id": 1
-        },
-        "select": {
-          "type": "DeviceWalletSelect",
-          "id": 2
-        }
-      }
-    },
     "DeviceSession": {
       "fields": {
         "session_id": {

package/src/data-manager/DataManager.ts

@@ -309,15 +309,15 @@ export default class DataManager {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return 'unknown';
 
-    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+    const deviceBleFirmwareVersion = getDeviceBLEFirmwareVersion(features);
 
     /** mini has no device ble_ver */
-    if (!deviceBLEFirmwareVersion) {
+    if (!deviceBleFirmwareVersion) {
       return 'none';
     }
 
     const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
-    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    const currentVersion = deviceBleFirmwareVersion.join('.');
     return getReleaseStatus(targetDeviceConfigList, currentVersion);
   };
 
@@ -325,14 +325,14 @@ export default class DataManager {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return [];
 
-    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+    const deviceBleFirmwareVersion = getDeviceBLEFirmwareVersion(features);
 
-    if (!deviceBLEFirmwareVersion) {
+    if (!deviceBleFirmwareVersion) {
       return [];
     }
 
     const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
-    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    const currentVersion = deviceBleFirmwareVersion.join('.');
     return getReleaseChangelog(targetDeviceConfigList, currentVersion);
   };