@onekeyfe/hd-core 1.1.34-alpha.2 → 1.1.34-alpha.3

package/src/core/RequestQueue.ts

@@ -1,21 +1,47 @@
+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 {
   private requestQueue = new Map<number, RequestTask>();
 
+  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) {
@@ -30,11 +56,94 @@ export default class RequestQueue {
       method.responseID = requestId;
     }
     const abortController = new AbortController();
-    const task = { id: requestId, method, abortController };
+    method.abortSignal = abortController.signal;
+    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);
+    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 {
     return this.requestQueue.get(requestId);
   }
@@ -77,6 +186,7 @@ export default class RequestQueue {
         count++;
       }
     });
+    this.pendingOperationCancellations.clear();
     return count;
   }
 
@@ -90,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);
   }
 
   // 拒绝请求
@@ -99,12 +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 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/deviceEventRegistration.ts

@@ -0,0 +1,23 @@
+import { DEVICE } from '../events';
+
+import type { Device, DeviceEvents } from '../device/Device';
+
+export type HardwareUiEventHandlers = {
+  pin: (...event: DeviceEvents[typeof DEVICE.PIN]) => void;
+  button: (...event: DeviceEvents[typeof DEVICE.BUTTON]) => void;
+  passphrase: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE]) => void;
+  passphraseOnDevice: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE_ON_DEVICE]) => void;
+  attachPinOnDevice: (...event: DeviceEvents[typeof DEVICE.ATTACH_PIN_ON_DEVICE]) => void;
+};
+
+export function registerHardwareUiEventListeners(
+  device: Pick<Device, 'on'>,
+  handlers: HardwareUiEventHandlers
+) {
+  device.on(DEVICE.PIN, handlers.pin);
+  device.on(DEVICE.BUTTON, handlers.button);
+  device.on(DEVICE.PASSPHRASE, handlers.passphrase);
+  device.on(DEVICE.PASSPHRASE_ON_DEVICE, handlers.passphraseOnDevice);
+  device.on(DEVICE.ATTACH_PIN_ON_DEVICE, handlers.attachPinOnDevice);
+  return true;
+}