@onekeyfe/hd-transport-react-native 1.2.2-alpha.105 → 1.2.2-alpha.107

package/src/BleManager.ts

@@ -7,6 +7,19 @@ import type { Peripheral } from '@onekeyfe/react-native-ble-utils';
 
 const Logger = bleLogger;
 
+// Android BluetoothDevice.EXTRA_UNBOND_REASON values.
+const bondFailureReasons: Record<number, string> = {
+  1: 'authentication_failed',
+  2: 'rejected',
+  3: 'canceled',
+  4: 'device_unreachable',
+  5: 'discovery_in_progress',
+  6: 'timeout',
+  7: 'repeated_attempts',
+  8: 'remote_canceled',
+  9: 'removed',
+};
+
 /**
  * get the device basic info of connected devices
  * @param serviceUuids
@@ -30,7 +43,12 @@ export const onDeviceBondState = (bleMacAddress: string): Promise<Peripheral | u
 
     const timeout = setTimeout(() => {
       cleanup();
-      reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded'));
+      reject(
+        ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', {
+          phase: 'bond',
+          reason: 'timeout',
+        })
+      );
     }, 60 * 1000);
 
     const cleanupListener = BleUtils.onDeviceBondState(peripheral => {
@@ -40,14 +58,50 @@ export const onDeviceBondState = (bleMacAddress: string): Promise<Peripheral | u
       const { bondState } = peripheral;
 
       const hasBonded = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_BONDED';
-      const hasCanceled = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
+      const hasFailed = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
       Logger.debug('onDeviceBondState bondState:', bondState);
       if (hasBonded) {
         cleanup();
         resolve(peripheral);
-      } else if (hasCanceled) {
+      } else if (hasFailed) {
         cleanup();
-        reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceBondedCanceled, 'bonding canceled'));
+        const nativeReason =
+          'reason' in bondState && typeof bondState.reason === 'number'
+            ? bondState.reason
+            : undefined;
+        const reason =
+          nativeReason === undefined ? 'unknown' : bondFailureReasons[nativeReason] ?? 'unknown';
+        const params = {
+          phase: 'bond',
+          reason,
+          ...(nativeReason === undefined ? {} : { nativeReason }),
+        };
+        if (reason === 'timeout') {
+          // Connection timeouts are retried by Core; pairing requires a new user attempt.
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.BleDeviceNotBonded,
+              'Bluetooth pairing timed out',
+              params
+            )
+          );
+        } else if (reason === 'canceled') {
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.BleDeviceBondedCanceled,
+              'Bluetooth pairing canceled',
+              params
+            )
+          );
+        } else {
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.BleDeviceNotBonded,
+              'Bluetooth pairing failed',
+              params
+            )
+          );
+        }
       }
     });
   });

package/src/__tests__/bleNativeDisconnect.test.ts

@@ -0,0 +1,33 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { isNativeBleDisconnectError, toBleDisconnectHardwareError } from '../bleNativeDisconnect';
+
+describe('native BLE disconnect mapping', () => {
+  test.each([
+    [{ errorCode: 201, reason: 'The specified device has disconnected from us.' }],
+    [{ errorCode: 201, iosErrorCode: 7, reason: 'The specified device has disconnected from us.' }],
+    [{ iosErrorCode: 7, reason: 'Peripheral disconnected' }],
+  ])('recognizes %j as a native disconnect', nativeError => {
+    expect(isNativeBleDisconnectError(nativeError)).toBe(true);
+    expect(toBleDisconnectHardwareError(nativeError)).toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+  });
+
+  test('does not treat a stale-bond iOS code as a disconnect', () => {
+    expect(
+      isNativeBleDisconnectError({
+        iosErrorCode: 14,
+        reason: 'Peer removed pairing information',
+      })
+    ).toBe(false);
+  });
+
+  test('does not treat an already-canonical unpaired error as a native disconnect', () => {
+    expect(
+      isNativeBleDisconnectError({
+        errorCode: HardwareErrorCode.BleDeviceNotBonded,
+      })
+    ).toBe(false);
+  });
+});

package/src/__tests__/connectTimeout.test.ts

@@ -1,7 +1,10 @@
 import { EventEmitter } from 'events';
-import { BleErrorCode } from 'react-native-ble-plx';
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Platform } from 'react-native';
+import { BleErrorCode, BleManager } from 'react-native-ble-plx';
+import BleUtils from '@onekeyfe/react-native-ble-utils';
+import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
+import { onDeviceBondState } from '../BleManager';
 import ReactNativeBleTransport, {
   BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
   BLE_CONNECT_TIMEOUT_MS,
@@ -10,6 +13,8 @@ import ReactNativeBleTransport, {
 } from '../index';
 import protocolV1Schema from './protocolV1SchemaFixture';
 
+import type { Peripheral } from '@onekeyfe/react-native-ble-utils';
+
 jest.mock(
   'react-native',
   () => ({
@@ -44,12 +49,105 @@ jest.mock('@onekeyfe/react-native-ble-utils', () => ({
   default: {
     getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
     getBondedPeripherals: jest.fn(() => Promise.resolve([])),
-    pairDevice: jest.fn(() => Promise.resolve()),
+    pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
+    onDeviceBondState: jest.fn(),
   },
 }));
 
 const UUID = 'stalled-connect-device';
 
+describe('Android bond failure reasons', () => {
+  let emitBondState: (peripheral: Peripheral) => void;
+  const cleanup = jest.fn();
+
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    cleanup.mockClear();
+    jest.spyOn(BleUtils, 'onDeviceBondState').mockImplementation(listener => {
+      emitBondState = listener;
+      return cleanup;
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    jest.useRealTimers();
+  });
+
+  test.each([
+    [6, 'timeout', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out'],
+    [3, 'canceled', HardwareErrorCode.BleDeviceBondedCanceled, 'Bluetooth pairing canceled'],
+    [1, 'authentication_failed', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [2, 'rejected', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [4, 'device_unreachable', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [5, 'discovery_in_progress', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [7, 'repeated_attempts', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [8, 'remote_canceled', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [9, 'removed', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [undefined, 'unknown', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [999, 'unknown', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+  ] as const)(
+    'preserves Android reason %s as %s across serialization',
+    async (nativeReason, reason, code, message) => {
+      const result = onDeviceBondState(UUID).catch(error =>
+        JSON.parse(JSON.stringify(ERRORS.serializeError({ error })))
+      );
+      emitBondState({
+        id: UUID,
+        advertising: {},
+        bondState: {
+          preState: 'BOND_BONDING',
+          state: 'BOND_NONE',
+          ...(nativeReason === undefined ? {} : { reason: nativeReason }),
+        },
+      });
+
+      await expect(result).resolves.toEqual({
+        code,
+        error: message,
+        params: {
+          phase: 'bond',
+          reason,
+          ...(nativeReason === undefined ? {} : { nativeReason }),
+        },
+      });
+      expect(cleanup).toHaveBeenCalledTimes(1);
+      expect(jest.getTimerCount()).toBe(0);
+    }
+  );
+
+  test('reports a timeout if no bond event arrives within the SDK deadline', async () => {
+    const result = onDeviceBondState(UUID);
+    const rejection = expect(result).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceNotBonded,
+      params: { phase: 'bond', reason: 'timeout' },
+    });
+    jest.advanceTimersByTime(60_000);
+    await rejection;
+    expect(cleanup).toHaveBeenCalledTimes(1);
+  });
+
+  test('ignores other devices and clears the deadline after bonding succeeds', async () => {
+    const result = onDeviceBondState(UUID);
+    const otherPeripheral = {
+      id: 'another-device',
+      advertising: {},
+      bondState: { preState: 'BOND_BONDING', state: 'BOND_NONE', reason: 6 },
+    };
+    emitBondState(otherPeripheral);
+    expect(cleanup).not.toHaveBeenCalled();
+    const peripheral: Peripheral = {
+      id: UUID.toUpperCase(),
+      advertising: {},
+      bondState: { preState: 'BOND_BONDING', state: 'BOND_BONDED' },
+    };
+    emitBondState(peripheral);
+    await expect(result).resolves.toBe(peripheral);
+    expect(cleanup).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+});
+
 const flush = () =>
   new Promise(resolve => {
     setImmediate(resolve);
@@ -129,6 +227,60 @@ describe('BLE connect timeout', () => {
   afterEach(() => {
     jest.clearAllTimers();
     jest.restoreAllMocks();
+    Object.assign(Platform, { OS: 'ios' });
+  });
+
+  test('waits for singleton destruction before creating the next manager', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const destruction = createDeferred<void>();
+    Object.assign(bleManager, { destroy: jest.fn(() => destruction.promise) });
+    const createManager = jest.mocked(BleManager);
+    createManager.mockClear();
+    (transport as unknown as { resetPlxManager(): void }).resetPlxManager();
+    const first = transport.getPlxManager();
+    const second = transport.getPlxManager();
+    await flush();
+    expect(createManager).not.toHaveBeenCalled();
+    destruction.resolve();
+    expect(await first).toBe(await second);
+    expect(createManager).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not reuse a manager after asynchronous destruction fails', async () => {
+    const { bleManager } = createHarness(() => Promise.resolve());
+    let transport!: ReactNativeBleTransport;
+    jest.isolateModules(() => {
+      const { default: Transport } = jest.requireActual<typeof import('../index')>('../index');
+      transport = new Transport({});
+    });
+    transport.blePlxManager = bleManager as never;
+    const destruction = createDeferred<void>();
+    Object.assign(bleManager, { destroy: jest.fn(() => destruction.promise) });
+    (transport as unknown as { resetPlxManager(): void }).resetPlxManager();
+    const result = transport.getPlxManager();
+    const failure = expect(result).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.PollingTimeout,
+    });
+    destruction.reject(new Error('Native destruction failed'));
+    await failure;
+  });
+
+  test('bounds reset waiting without letting a new transport bypass unfinished destruction', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const destruction = createDeferred<void>();
+    Object.assign(bleManager, { destroy: jest.fn(() => destruction.promise) });
+    const createManager = jest.mocked(BleManager);
+    createManager.mockClear();
+    (transport as unknown as { resetPlxManager(): void }).resetPlxManager();
+    const nextTransport = new ReactNativeBleTransport({});
+    const result = nextTransport.getPlxManager().catch(error => error);
+    await flush();
+    jest.advanceTimersByTime(BLE_CONNECT_TIMEOUT_MS);
+    await expect(result).resolves.toMatchObject({ errorCode: HardwareErrorCode.PollingTimeout });
+    expect(createManager).not.toHaveBeenCalled();
+    destruction.resolve();
+    await nextTransport.getPlxManager();
+    expect(createManager).toHaveBeenCalledTimes(1);
   });
 
   test('a native connect that never settles is bounded instead of blocking forever', async () => {
@@ -155,6 +307,61 @@ describe('BLE connect timeout', () => {
     expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
   });
 
+  test('stop drains its scan and removes the timer before another transport scans', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const nativeStop = createDeferred<void>();
+    bleManager.stopDeviceScan.mockImplementation(() => nativeStop.promise);
+    const scanned = transport.enumerate().catch(error => error);
+    await flush();
+    await flush();
+    expect(bleManager.startDeviceScan).toHaveBeenCalledTimes(1);
+    const stopping = transport.stop();
+    expect(transport.stop()).toBe(stopping);
+    let stopped = false;
+    stopping.then(() => {
+      stopped = true;
+    });
+    await flush();
+    expect(stopped).toBe(false);
+    nativeStop.resolve();
+    await stopping;
+    await expect(scanned).resolves.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    jest.advanceTimersByTime(transport.scanTimeout);
+    await flush();
+    expect(bleManager.stopDeviceScan).toHaveBeenCalledTimes(1);
+    await expect(transport.getPlxManager()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+  });
+
+  test('stop rejects a pending read and waits for native disconnection without destroying the shared manager', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const nativeDisconnect = createDeferred<void>();
+    bleManager.cancelDeviceConnection.mockImplementation(() => nativeDisconnect.promise);
+    const destroy = jest.fn();
+    Object.assign(bleManager, { destroy });
+    const read = createDeferred<void>();
+    transport.runPromise = read;
+    Object.assign(transport, { runPromiseDeviceId: UUID });
+    const readResult = read.promise.catch(error => error);
+    let stopped = false;
+    const stopping = transport.stop().then(() => {
+      stopped = true;
+    });
+    await flush();
+    await expect(readResult).resolves.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    expect(stopped).toBe(false);
+    nativeDisconnect.resolve();
+    await advanceUntil(() => stopped, 1000);
+    await stopping;
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+    expect(destroy).not.toHaveBeenCalled();
+  });
+
   test('the connect budget leaves generous headroom over a healthy connect', () => {
     // Healthy connects finish in ~2-3s (the native budget is 3s); this backstop only
     // fires when the native timeout itself fails to.
@@ -162,6 +369,78 @@ describe('BLE connect timeout', () => {
     expect(BLE_CONNECT_TIMEOUT_MS).toBeLessThanOrEqual(12000);
   });
 
+  test.each(
+    (['ios', 'android'] as const).flatMap(platform =>
+      (['connect', 'mtu', 'gatt'] as const).flatMap(stage =>
+        (['reject', 'resolve'] as const).map(completion => ({ platform, stage, completion }))
+      )
+    )
+  )(
+    'stop cancels $platform $stage before draining a late $completion',
+    async ({ platform, stage, completion }) => {
+      Object.assign(Platform, { OS: platform });
+      const { transport, device, bleManager, connect } = createHarness(
+        () => nativeOperation.promise
+      );
+      const nativeOperation = createDeferred<typeof device>();
+      const nativeDisconnect = createDeferred<void>();
+      const requestMtu = jest.fn(() => Promise.resolve(device));
+      Object.assign(device, { mtu: 247, requestMTU: requestMtu });
+      device.isConnected.mockResolvedValue(true);
+      if (stage === 'connect') device.isConnected.mockResolvedValueOnce(false);
+      if (stage === 'mtu') requestMtu.mockImplementationOnce(() => nativeOperation.promise);
+      if (stage === 'gatt') {
+        device.discoverAllServicesAndCharacteristics.mockImplementationOnce(() =>
+          nativeOperation.promise.then(() => undefined)
+        );
+      }
+      const destroy = jest.fn();
+      Object.assign(bleManager, { destroy });
+      const monitor = jest.spyOn(transport, '_monitorCharacteristic');
+      const acquire = transport.acquire({ uuid: UUID }).catch(error => error);
+      await flush();
+      await flush();
+      const pending = {
+        connect,
+        mtu: requestMtu,
+        gatt: device.discoverAllServicesAndCharacteristics,
+      }[stage];
+      expect(pending).toHaveBeenCalledTimes(1);
+
+      bleManager.cancelDeviceConnection.mockImplementation(() => nativeDisconnect.promise);
+      let stopped = false;
+      const stopping = transport.stop().then(() => {
+        stopped = true;
+      });
+      try {
+        await flush();
+        expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+        expect(stopped).toBe(false);
+      } finally {
+        // Native completion can race cancellation; neither outcome may restart setup.
+        if (completion === 'resolve') nativeOperation.resolve(device);
+        else
+          nativeOperation.reject(
+            Object.assign(new Error('Operation was cancelled'), {
+              errorCode: BleErrorCode.OperationCancelled,
+            })
+          );
+        nativeDisconnect.resolve();
+        await advanceUntil(() => stopped, BLE_CONNECT_TIMEOUT_MS + BLE_GATT_SETUP_TIMEOUT_MS);
+        await stopping;
+      }
+      await expect(acquire).resolves.toBeInstanceOf(Error);
+      expect(connect).toHaveBeenCalledTimes(stage === 'connect' ? 1 : 0);
+      expect(monitor).not.toHaveBeenCalled();
+      if (stage === 'mtu')
+        expect(device.discoverAllServicesAndCharacteristics).not.toHaveBeenCalled();
+      expect(bleManager.cancelDeviceConnection.mock.calls).toEqual(
+        Array.from({ length: bleManager.cancelDeviceConnection.mock.calls.length }, () => [UUID])
+      );
+      expect(destroy).not.toHaveBeenCalled();
+    }
+  );
+
   test('a stalled connect is abandoned natively so the next attempt is not cancelled by it', async () => {
     const { transport, bleManager } = createHarness(
       () =>