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

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/__tests__/subscribeBleOn.test.ts

@@ -0,0 +1,111 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { subscribeBleOn } from '../subscribeBleOn';
+
+import type { BlePlxManager } from '../types';
+
+type BleState = Parameters<Parameters<BlePlxManager['onStateChange']>[0]>[0];
+
+const createBleManager = () => {
+  let stateListener: ((state: BleState) => void) | undefined;
+  const remove = jest.fn();
+  const bleManager = {
+    onStateChange: jest.fn(listener => {
+      stateListener = listener;
+      return { remove };
+    }),
+  } as unknown as BlePlxManager;
+
+  return {
+    bleManager,
+    emitState: (state: BleState) => stateListener?.(state),
+    remove,
+  };
+};
+
+describe('subscribeBleOn', () => {
+  beforeAll(() => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+  });
+
+  test('resolves when Bluetooth is powered on', async () => {
+    const { bleManager, emitState, remove } = createBleManager();
+    const result = subscribeBleOn(bleManager);
+
+    emitState('PoweredOn');
+
+    await expect(result).resolves.toBeUndefined();
+    expect(remove).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test('cleans up when the current state is emitted synchronously', async () => {
+    const remove = jest.fn();
+    const bleManager = {
+      onStateChange: jest.fn(listener => {
+        listener('PoweredOn');
+        return { remove };
+      }),
+    } as unknown as BlePlxManager;
+
+    await expect(subscribeBleOn(bleManager)).resolves.toBeUndefined();
+    expect(remove).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test.each([
+    ['PoweredOff', HardwareErrorCode.BlePoweredOff],
+    ['Unsupported', HardwareErrorCode.BleUnsupported],
+    ['Unauthorized', HardwareErrorCode.BlePermissionError],
+  ] as const)('maps %s to hardware error %s', async (state, errorCode) => {
+    const { bleManager, emitState, remove } = createBleManager();
+    const result = subscribeBleOn(bleManager);
+    const rejection = expect(result).rejects.toMatchObject({ errorCode });
+
+    emitState(state);
+
+    await rejection;
+    expect(remove).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test('settles only once when terminal states repeat', async () => {
+    const { bleManager, emitState, remove } = createBleManager();
+    const result = subscribeBleOn(bleManager);
+    const rejection = expect(result).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BlePoweredOff,
+    });
+
+    emitState('PoweredOff');
+    emitState('PoweredOn');
+
+    await rejection;
+    expect(remove).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test.each(['Unknown', 'Resetting'] as const)(
+    'reports %s as a scan error if no stable state arrives before timeout',
+    async state => {
+      const { bleManager, emitState, remove } = createBleManager();
+      const result = subscribeBleOn(bleManager, 1000);
+      const rejection = expect(result).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleScanError,
+      });
+
+      emitState(state);
+      jest.advanceTimersByTime(1000);
+
+      await rejection;
+      expect(remove).toHaveBeenCalledTimes(1);
+    }
+  );
+});

package/src/bleNativeDisconnect.ts

@@ -0,0 +1,41 @@
+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 ||
+    nativeErrorText(nativeError).toLowerCase().includes('was 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
+  );
+};