@onekeyfe/hd-transport-react-native 1.2.3-alpha.3 → 1.2.3-alpha.4

package/src/__tests__/staleCallTimeout.test.ts

@@ -56,6 +56,34 @@ function createHarness() {
 }
 
 describe('Protocol V1 stale call timeout', () => {
+  test('settles a cancelled read and waits for native teardown before completing cancel', async () => {
+    const { t, disconnectSpy } = createHarness();
+    let finishDisconnect!: () => void;
+    disconnectSpy.mockImplementationOnce(
+      () =>
+        new Promise<void>(resolve => {
+          finishDisconnect = resolve;
+        })
+    );
+    const call = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    const result = call.catch(error => error);
+    await flush();
+    let cancelled = false;
+    const cleanup = t.cancel().then(() => {
+      cancelled = true;
+    });
+    await flush();
+    expect(await result).toMatchObject({ errorCode: HardwareErrorCode.CallQueueActionCancelled });
+    expect(t.runPromise).toBeNull();
+    expect(disconnectSpy).toHaveBeenCalledWith(UUID);
+    expect(cancelled).toBe(false);
+    finishDisconnect();
+    await cleanup;
+    jest.advanceTimersByTime(25000);
+    await flush();
+    expect(disconnectSpy).toHaveBeenCalledTimes(1);
+  });
+
   beforeAll(() => {
     jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
   });
@@ -172,24 +200,25 @@ describe('Protocol V1 stale call timeout', () => {
     expect(secondErrors).toHaveLength(1);
   });
 
-  test('orphan timer left behind by cancel() must not disconnect the transport', async () => {
+  test('a cancelled read cannot disconnect a later transport when its old deadline passes', async () => {
     const { t, disconnectSpy } = createHarness();
 
-    // cancel() nulls the ownership slot without settling the deferred, so the
-    // call's response timer stays armed (reachable via DeviceCommands.dispose).
     const errors: Array<{ errorCode?: unknown }> = [];
     const p = t.call(UUID, 'GetFeatures', {}, { timeoutMs: 5000 });
     p.catch(e => errors.push(e));
     await flush();
 
-    t.cancel();
+    await t.cancel();
+    await flush();
+    expect(disconnectSpy).toHaveBeenCalledTimes(1);
+    disconnectSpy.mockClear();
 
     jest.advanceTimersByTime(5000);
     await flush();
 
     expect(disconnectSpy).not.toHaveBeenCalled();
     expect(errors).toHaveLength(1);
-    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleTimeoutError);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.CallQueueActionCancelled);
   });
 
   test('timeout on the active call still disconnects the transport', async () => {

package/src/bleNativeDisconnect.ts

@@ -0,0 +1,40 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+const BLE_PLX_DEVICE_DISCONNECTED = 201;
+const IOS_PERIPHERAL_DISCONNECTED = 7;
+
+type NativeBleErrorFields = {
+  errorCode?: unknown;
+  iosErrorCode?: unknown;
+  reason?: unknown;
+  message?: unknown;
+};
+
+const nativeErrorText = (error: NativeBleErrorFields) =>
+  [error.reason, error.message]
+    .filter((value): value is string => typeof value === 'string')
+    .join(' ');
+
+export const isNativeBleDisconnectError = (error: unknown): boolean => {
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+
+  const nativeError = error as NativeBleErrorFields;
+  return (
+    nativeError.errorCode === BLE_PLX_DEVICE_DISCONNECTED ||
+    nativeError.iosErrorCode === IOS_PERIPHERAL_DISCONNECTED
+  );
+};
+
+export const toBleDisconnectHardwareError = (error: unknown) => {
+  if ((error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleDeviceDisconnected) {
+    return error as Error;
+  }
+
+  const nativeError = (error ?? {}) as NativeBleErrorFields;
+  return ERRORS.TypedError(
+    HardwareErrorCode.BleDeviceDisconnected,
+    nativeErrorText(nativeError) || undefined
+  );
+};