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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.3-alpha.3",
+  "version": "1.2.3-alpha.4",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,11 +20,11 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.3-alpha.3",
-    "@onekeyfe/hd-shared": "1.2.3-alpha.3",
-    "@onekeyfe/hd-transport": "1.2.3-alpha.3",
-    "@onekeyfe/react-native-ble-utils": "^0.1.6",
+    "@onekeyfe/hd-core": "1.2.3-alpha.4",
+    "@onekeyfe/hd-shared": "1.2.3-alpha.4",
+    "@onekeyfe/hd-transport": "1.2.3-alpha.4",
+    "@onekeyfe/react-native-ble-utils": "0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "8b116adb144b967f042f189cd27384a75ca1f7ae"
+  "gitHead": "705729baaec54b86a4fc28cce310a85b67b82730"
 }

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
@@ -19,18 +32,37 @@ export const getBondedDevices = () => BleUtils.getBondedPeripherals();
 
 export const pairDevice = (macAddress: string) => BleUtils.pairDevice(macAddress);
 
-export const onDeviceBondState = (bleMacAddress: string): Promise<Peripheral | undefined> =>
+export const onDeviceBondState = (
+  bleMacAddress: string,
+  signal?: AbortSignal
+): Promise<Peripheral | undefined> =>
   new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
+      return;
+    }
     const cleanup = () => {
       if (timeout) {
         clearTimeout(timeout);
       }
       if (cleanupListener) cleanupListener();
+      signal?.removeEventListener('abort', onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
     };
 
+    signal?.addEventListener('abort', onAbort, { once: true });
+
     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 +72,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,8 +1,13 @@
 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, {
+  ANDROID_LINK_DROP_QUIET_MS,
+  ANDROID_MTU_EXCHANGE_TIMEOUT_MS,
   BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
   BLE_CONNECT_TIMEOUT_MS,
   BLE_GATT_SETUP_TIMEOUT_MS,
@@ -10,6 +15,8 @@ import ReactNativeBleTransport, {
 } from '../index';
 import protocolV1Schema from './protocolV1SchemaFixture';
 
+import type { Peripheral } from '@onekeyfe/react-native-ble-utils';
+
 jest.mock(
   'react-native',
   () => ({
@@ -44,12 +51,131 @@ 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('aborts the bond wait and removes its listener and deadline', async () => {
+    const controller = new AbortController();
+    const result = onDeviceBondState(UUID, controller.signal);
+    const rejection = expect(result).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+
+    controller.abort();
+
+    await rejection;
+    expect(cleanup).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test('does not subscribe when the transport stopped before the bond wait starts', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    const subscribe = jest.spyOn(BleUtils, 'onDeviceBondState').mockClear();
+
+    await expect(onDeviceBondState(UUID, controller.signal)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    expect(subscribe).not.toHaveBeenCalled();
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  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 +255,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 +335,96 @@ 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.each(['V1', 'V2'] as const)(
+    'stop completes while Android %s bonding remains pending',
+    async expectedProtocol => {
+      Object.assign(Platform, { OS: 'android' });
+      const { transport, bleManager, connect } = createHarness(() => Promise.resolve());
+      jest.spyOn(BleUtils, 'pairDevice').mockResolvedValueOnce({ bonded: false, bonding: true });
+      const listening = createDeferred<void>();
+      const cleanup = jest.fn();
+      jest.spyOn(BleUtils, 'onDeviceBondState').mockImplementationOnce(() => {
+        listening.resolve();
+        return cleanup;
+      });
+      const acquiring = transport.acquire({ uuid: UUID, expectedProtocol });
+      const rejection = expect(acquiring).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleDeviceDisconnected,
+      });
+      await listening.promise;
+
+      // Advance only the existing 100ms disconnect drain, not the bond deadline.
+      let stopped = false;
+      const stopping = transport.stop().then(() => {
+        stopped = true;
+      });
+      await advanceUntil(() => stopped, 1000);
+      expect(stopped).toBe(true);
+      await stopping;
+
+      await rejection;
+      expect(cleanup).toHaveBeenCalledTimes(1);
+      expect(jest.getTimerCount()).toBe(0);
+      expect(bleManager.devices).not.toHaveBeenCalled();
+      expect(connect).not.toHaveBeenCalled();
+    }
+  );
+
+  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 +432,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: stage === 'mtu' ? 23 : 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(
       () =>
@@ -268,6 +610,19 @@ describe('BLE connect timeout', () => {
     expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
   });
 
+  test('a native GATT timeout abandons the native connection', async () => {
+    const { transport, device, bleManager } = createHarness(() => Promise.resolve());
+    const nativeTimeout = Object.assign(new Error('Operation timed out'), {
+      errorCode: BleErrorCode.OperationTimedOut,
+    });
+    device.discoverAllServicesAndCharacteristics.mockRejectedValueOnce(nativeTimeout);
+
+    await expect((transport as any).resolveCharacteristicsWithTimeout(UUID, device)).rejects.toBe(
+      nativeTimeout
+    );
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+  });
+
   test('a successful GATT retry clears the timeout budget before an abandoned call settles', async () => {
     const { transport, device, bleManager } = createHarness(() => Promise.resolve());
     let resolveAbandonedDiscovery: (() => void) | undefined;
@@ -300,4 +655,73 @@ describe('BLE connect timeout', () => {
     expect(bleManager.cancelDeviceConnection).toHaveBeenCalledTimes(1);
     expect((transport as any).connectionSetupTimeoutCounts.has(UUID)).toBe(false);
   });
+
+  test('holds an unusable link past the idle timer', async () => {
+    Object.assign(Platform, { OS: 'android' });
+    const { transport, device, bleManager } = createHarness(() => Promise.resolve(device));
+    device.isConnected.mockResolvedValue(true);
+    Object.assign(device, { mtu: 23, requestMTU: jest.fn(() => new Promise(() => {})) });
+    let settled: Error | undefined;
+    const acquire = transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }).catch(error => {
+      settled = error;
+    });
+    await flush();
+    await flush();
+    expect(device.requestMTU).toHaveBeenCalledTimes(1);
+
+    jest.advanceTimersByTime(ANDROID_MTU_EXCHANGE_TIMEOUT_MS);
+    await flush();
+    await flush();
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+
+    jest.advanceTimersByTime(4000);
+    await flush();
+    await flush();
+    expect(settled).toBeUndefined();
+
+    await advanceUntil(() => !!settled, ANDROID_LINK_DROP_QUIET_MS);
+    await acquire;
+    expect(settled).toMatchObject({ errorCode: HardwareErrorCode.BleConnectedError });
+    expect(device.discoverAllServicesAndCharacteristics).not.toHaveBeenCalled();
+  });
+
+  test('a slow but successful MTU exchange completes inside the bound', async () => {
+    Object.assign(Platform, { OS: 'android' });
+    const { transport, device } = createHarness(() => Promise.resolve(device));
+    device.isConnected.mockResolvedValue(true);
+    const negotiated = { ...device, mtu: 247 };
+    Object.assign(device, {
+      mtu: 23,
+      // A cold cache makes the stack discover first; the exchange then completes late.
+      requestMTU: jest.fn(
+        () =>
+          new Promise(resolve => {
+            setTimeout(() => resolve(negotiated), 10_000);
+          })
+      ),
+    });
+    const [, notifyCharacteristic] = await device.characteristicsForService();
+    Object.assign(notifyCharacteristic, { monitor: jest.fn(() => ({ remove: jest.fn() })) });
+    let result: unknown;
+    let failure: Error | undefined;
+    const acquire = transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }).then(
+      value => {
+        result = value;
+      },
+      error => {
+        failure = error;
+      }
+    );
+    await flush();
+    await flush();
+    expect(device.discoverAllServicesAndCharacteristics).not.toHaveBeenCalled();
+
+    jest.advanceTimersByTime(10_000);
+    await advanceUntil(() => result !== undefined || failure !== undefined, 5000);
+    await acquire;
+    expect(failure).toBeUndefined();
+    expect(result).toEqual({ uuid: UUID, protocolType: 'V1' });
+    expect(device.discoverAllServicesAndCharacteristics).toHaveBeenCalledTimes(1);
+    await transport.release(UUID, true);
+  });
 });