@onekeyfe/hd-transport-react-native 1.2.2-alpha.11 → 1.2.2-alpha.111

package/src/__tests__/protocolV2Link.test.ts

@@ -4,7 +4,7 @@ import transportPackage, {
   ProtocolV2,
   TRANSPORT_EVENT,
 } from '@onekeyfe/hd-transport';
-import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
 import ReactNativeBleTransport, {
   BLE_NATIVE_TEARDOWN_TIMEOUT_MS,
@@ -28,7 +28,7 @@ jest.mock('react-native-ble-plx', () => ({
   BleError: class BleError extends Error {},
   BleErrorCode: {
     DeviceAlreadyConnected: 203,
-    DeviceDisconnected: 205,
+    DeviceDisconnected: 201,
     DeviceMTUChangeFailed: 206,
     OperationCancelled: 2,
     CharacteristicNotFound: 404,
@@ -360,6 +360,186 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(new ReactNativeBleTransport({}).scanTimeout).toBe(3000);
   });
 
+  test.each(['V1', 'V2'] as const)(
+    'waits for Android bonding before connecting the %s GATT link',
+    async protocol => {
+      setPlatformOS('android');
+      const { transport, uuid, device } = protocol === 'V1' ? createV1Harness() : createHarness();
+      const operationOrder: string[] = [];
+      const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+      const bondStateMock = jest.requireMock('../BleManager').onDeviceBondState as jest.Mock;
+      const bonding = createDeferred<void>();
+
+      device.isConnected.mockResolvedValueOnce(false);
+      device.connect = jest.fn(() => {
+        operationOrder.push('connect');
+        return Promise.resolve(device);
+      });
+      pairDeviceMock.mockImplementationOnce(() => {
+        operationOrder.push('bond');
+        return Promise.resolve({ bonded: false, bonding: true });
+      });
+      bondStateMock.mockImplementationOnce(() => bonding.promise);
+
+      const acquiring = transport.acquire({ uuid, expectedProtocol: protocol });
+      await new Promise(resolve => {
+        setImmediate(resolve);
+      });
+      expect(operationOrder).toEqual(['bond']);
+      expect(device.connect).not.toHaveBeenCalled();
+
+      bonding.resolve();
+      await expect(acquiring).resolves.toEqual({
+        uuid,
+        protocolType: protocol,
+      });
+
+      expect(operationOrder).toEqual(['bond', 'connect']);
+      await transport.release(uuid, true);
+    }
+  );
+
+  test('preserves Android connect errors after bonding when both reconnect attempts fail', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device } = createHarness();
+    const BleErrorMock = jest.requireMock('react-native-ble-plx').BleError as new (
+      message: string
+    ) => Error;
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+    const firstError = Object.assign(new BleErrorMock('MTU change failed'), {
+      errorCode: 206,
+      reason: 'MTU change failed',
+    });
+    const fallbackError = Object.assign(new BleErrorMock('GATT connect failed'), {
+      errorCode: 205,
+      reason: 'GATT connect failed',
+    });
+
+    device.isConnected.mockResolvedValueOnce(false);
+    device.connect = jest
+      .fn()
+      .mockRejectedValueOnce(firstError)
+      .mockRejectedValueOnce(fallbackError);
+    pairDeviceMock.mockClear();
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleConnectedError,
+    });
+    expect(device.connect).toHaveBeenCalledTimes(2);
+    expect(pairDeviceMock).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not connect Android GATT when the system cannot start bonding', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device, bleManager } = createHarness();
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+
+    device.connect = jest.fn().mockResolvedValue(device);
+    pairDeviceMock.mockClear();
+    pairDeviceMock.mockResolvedValueOnce({ bonded: false, bonding: false });
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceNotBonded,
+    });
+    expect(device.connect).not.toHaveBeenCalled();
+    expect(bleManager.devices).not.toHaveBeenCalled();
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+  });
+
+  test('checks that Android GATT is connected after bonding and reconnecting', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device, bleManager } = createHarness();
+    device.isConnected.mockResolvedValueOnce(false).mockResolvedValueOnce(false);
+    device.connect = jest.fn().mockResolvedValue(device);
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleConnectedError,
+    });
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
+  });
+
+  test.each([
+    [
+      'ios',
+      'OneKey Neo',
+      {
+        iosErrorCode: 14,
+        reason: 'Peer removed pairing information',
+      },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+    [
+      'android',
+      'OneKey Pro 2',
+      {
+        androidErrorCode: 5,
+        reason: 'Connection state changed with status 5',
+      },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+  ] as const)(
+    'maps a %s %s stale bond during connect before protocol detection',
+    async (platform, deviceName, nativeError, errorCode) => {
+      setPlatformOS(platform);
+      const { transport, uuid, device } = createHarness({ deviceName });
+      const BleErrorMock = jest.requireMock('react-native-ble-plx').BleError as new (
+        message: string
+      ) => Error;
+      const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+      pairDeviceMock.mockClear();
+
+      device.isConnected.mockResolvedValueOnce(false);
+      device.connect = jest
+        .fn()
+        .mockRejectedValue(Object.assign(new BleErrorMock(nativeError.reason), nativeError));
+
+      await expect(transport.acquire({ uuid })).rejects.toMatchObject({ errorCode });
+      expect(pairDeviceMock).toHaveBeenCalledTimes(platform === 'android' ? 1 : 0);
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+    }
+  );
+
+  test('cleans up Android bonding failures without starting GATT', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device, bleManager } = createHarness();
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+
+    pairDeviceMock.mockRejectedValueOnce(new Error('bonding canceled'));
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toThrow(
+      'bonding canceled'
+    );
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(bleManager.devices).not.toHaveBeenCalled();
+    expect(device.isConnected).not.toHaveBeenCalled();
+  });
+
+  test('does not connect after stop while Android bonding is pending', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, bleManager } = createHarness();
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+    const bondStateMock = jest.requireMock('../BleManager').onDeviceBondState as jest.Mock;
+    const bonding = createDeferred<void>();
+    pairDeviceMock.mockResolvedValueOnce({ bonded: false, bonding: true });
+    bondStateMock.mockImplementationOnce(() => bonding.promise);
+
+    const acquiring = transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const rejection = expect(acquiring).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    await new Promise(resolve => {
+      setImmediate(resolve);
+    });
+    const stopping = transport.stop();
+    bonding.resolve();
+
+    await rejection;
+    await stopping;
+    expect(bleManager.devices).not.toHaveBeenCalled();
+  });
+
   test('uses withResponse for consecutive iOS Protocol V1 control commands without releasing', async () => {
     const { transport, uuid, writeCharacteristic } = createV1Harness({
       respondOnWriteCount: [1, 2],
@@ -534,7 +714,72 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   test.each(['ios', 'android'] as const)(
-    'keeps a first expected Protocol V2 probe miss retryable on %s',
+    'waits for native disconnect after failed protocol detection before reconnecting on %s',
+    async platform => {
+      setPlatformOS(platform);
+      const { transport, uuid, device, bleManager } = createHarness();
+      const probes = transport as unknown as {
+        probeProtocolV1(uuid: string): Promise<boolean>;
+        probeProtocolV2(uuid: string): Promise<boolean>;
+        releaseNative(uuid: string, onclose: boolean): Promise<void>;
+      };
+      jest.spyOn(probes, 'probeProtocolV1').mockResolvedValueOnce(false);
+      const probesFinished = createDeferred<void>();
+      const probeProtocolV2 = jest
+        .spyOn(probes, 'probeProtocolV2')
+        .mockImplementationOnce(async () => {
+          // A link-fatal V2 timeout removes the cached transport before acquire fails.
+          await probes.releaseNative(uuid, true);
+          probesFinished.resolve();
+          return false;
+        });
+      let connected = true;
+      device.isConnected.mockImplementation(() => Promise.resolve(connected));
+      device.connect = jest.fn(() => {
+        connected = true;
+        return Promise.resolve(device);
+      });
+      const disconnectGate = createDeferred<void>();
+      bleManager.cancelDeviceConnection.mockImplementation(async () => {
+        await disconnectGate.promise;
+        connected = false;
+      });
+
+      const acquiring = transport.acquire({ uuid });
+      const failure = expect(acquiring).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleTimeoutError,
+      });
+      const reconnecting = transport.acquire({ uuid, expectedProtocol: 'V2' });
+
+      try {
+        await probesFinished.promise;
+        await new Promise(resolve => {
+          setImmediate(resolve);
+        });
+        expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+        expect(device.connect).not.toHaveBeenCalled();
+        expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+
+        disconnectGate.resolve();
+        await failure;
+        await expect(reconnecting).resolves.toEqual({ uuid, protocolType: 'V2' });
+        expect(device.connect).toHaveBeenCalledTimes(1);
+        await expect(
+          transport.call(uuid, 'Ping', { message: 'after-reconnect' })
+        ).resolves.toMatchObject({
+          type: 'Success',
+          message: { message: 'ok' },
+        });
+      } finally {
+        disconnectGate.resolve();
+        await Promise.allSettled([failure, reconnecting]);
+        await transport.release(uuid, true);
+      }
+    }
+  );
+
+  test.each(['ios', 'android'] as const)(
+    'disconnects after a first expected Protocol V2 probe miss while keeping it retryable on %s',
     async platform => {
       setPlatformOS(platform);
       const { transport, uuid, device } = createHarness();
@@ -544,13 +789,13 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
         errorCode: HardwareErrorCode.RuntimeError,
       });
 
-      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalledTimes(1);
       expect(transport.getProtocolType(uuid)).toBeUndefined();
     }
   );
 
   test.each(['ios', 'android'] as const)(
-    'keeps a second expected Protocol V2 probe miss retryable on %s',
+    'disconnects after each expected Protocol V2 probe miss while keeping it retryable on %s',
     async platform => {
       setPlatformOS(platform);
       const { transport, uuid, device } = createHarness();
@@ -563,7 +808,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
         errorCode: HardwareErrorCode.RuntimeError,
       });
 
-      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalledTimes(2);
       expect(transport.getProtocolType(uuid)).toBeUndefined();
     }
   );
@@ -598,7 +843,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   );
 
   test.each(['ios', 'android'] as const)(
-    'keeps a confirmed Protocol V2 probe miss retryable on %s without native bond evidence',
+    'disconnects after a confirmed Protocol V2 probe miss on %s without reporting a bond error',
     async platform => {
       setPlatformOS(platform);
       const { transport, uuid, device } = createHarness();
@@ -610,7 +855,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
         errorCode: HardwareErrorCode.RuntimeError,
       });
 
-      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalledTimes(1);
       expect(transport.getProtocolType(uuid)).toBeUndefined();
     }
   );
@@ -702,6 +947,118 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     BLE_NATIVE_TEARDOWN_TIMEOUT_MS + 5_000
   );
 
+  test('preserves the unpaired error when iOS disconnects during the first V1 probe', async () => {
+    const { transport, uuid, writeCharacteristic } = createHarness({ deviceName: 'Neo Test' });
+    writeCharacteristic.writeWithResponse.mockRejectedValueOnce({
+      errorCode: 201,
+      iosErrorCode: 7,
+      reason: 'The specified device has disconnected from us.',
+    });
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+
+    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceNotBonded,
+    });
+
+    expect(probeProtocolV2).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
+  test('preserves a native iOS disconnect during an expected Protocol V2 probe', async () => {
+    const { transport, uuid, writeCharacteristic, bleManager } = createHarness({
+      deviceName: 'Neo Test',
+    });
+    const nativeDisconnect = {
+      errorCode: 201,
+      iosErrorCode: 7,
+      reason: 'The specified device has disconnected from us.',
+    };
+    writeCharacteristic.writeWithoutResponse.mockRejectedValueOnce(nativeDisconnect);
+    const probeProtocolV1 = jest.spyOn(transport as any, 'probeProtocolV1');
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+
+    expect(probeProtocolV1).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
+  test('preserves a native iOS disconnect during a V2-first probe without falling back to V1', async () => {
+    const { transport, uuid, writeCharacteristic } = createHarness({ deviceName: 'Neo Test' });
+    writeCharacteristic.writeWithoutResponse.mockRejectedValueOnce({
+      errorCode: 201,
+      iosErrorCode: 7,
+      reason: 'The specified device has disconnected from us.',
+    });
+    const probeProtocolV1 = jest.spyOn(transport as any, 'probeProtocolV1');
+
+    await expect(transport.acquire({ uuid, protocolHint: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+
+    expect(probeProtocolV1).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
+  test.each(['V1', 'V2'] as const)(
+    'preserves terminal BLE failures from the %s probe without trying another protocol',
+    async protocol => {
+      for (const errorCode of [
+        HardwareErrorCode.BleDeviceNotBonded,
+        HardwareErrorCode.BleDeviceBondedCanceled,
+        HardwareErrorCode.BlePeerRemovedPairingInformation,
+        HardwareErrorCode.BleDeviceDisconnected,
+        HardwareErrorCode.BleCharacteristicNotifyError,
+        HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
+        HardwareErrorCode.BleWriteCharacteristicError,
+      ]) {
+        const { transport, uuid } = createHarness();
+        const error = ERRORS.TypedError(errorCode);
+        const call = jest
+          .spyOn(transport as any, protocol === 'V1' ? 'callProtocolV1' : 'callProtocolV2')
+          .mockRejectedValue(error);
+        const otherProbe = jest.spyOn(
+          transport as any,
+          protocol === 'V1' ? 'probeProtocolV2' : 'probeProtocolV1'
+        );
+
+        await expect(transport.acquire({ uuid, protocolHint: protocol })).rejects.toBe(error);
+
+        expect(call).toHaveBeenCalledTimes(1);
+        expect(otherProbe).not.toHaveBeenCalled();
+        expect(transport.getProtocolType(uuid)).toBeUndefined();
+      }
+    }
+  );
+
+  test.each(['V1', 'V2'] as const)(
+    'still falls back after a silent %s probe timeout',
+    async protocol => {
+      const { transport, uuid, device, bleManager } = createHarness();
+      jest
+        .spyOn(transport as any, protocol === 'V1' ? 'callProtocolV1' : 'callProtocolV2')
+        .mockRejectedValue(ERRORS.TypedError(HardwareErrorCode.BleTimeoutError));
+      const otherProbe = jest
+        .spyOn(transport as any, protocol === 'V1' ? 'probeProtocolV2' : 'probeProtocolV1')
+        .mockResolvedValue(true);
+
+      await expect(transport.acquire({ uuid, protocolHint: protocol })).resolves.toEqual({
+        uuid,
+        protocolType: protocol === 'V1' ? 'V2' : 'V1',
+      });
+
+      expect(otherProbe).toHaveBeenCalledTimes(1);
+      expect(bleManager.cancelDeviceConnection).not.toHaveBeenCalled();
+      expect(device.cancelConnection).not.toHaveBeenCalled();
+      await transport.release(uuid, true);
+    }
+  );
+
   test('falls back to the other active probe on iOS when protocol metadata is absent', async () => {
     const { transport, uuid } = createHarness({ deviceName: 'OneKey' });
     const probeProtocolV1 = jest
@@ -883,6 +1240,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(notifySubscriptionRemovers[0]).toHaveBeenCalledTimes(1);
     expect(notifySubscriptionRemovers[1]).toHaveBeenCalledTimes(1);
     expect(bleManager.cancelTransaction).toHaveBeenCalled();
+    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
     expect(transport.getProtocolType(uuid)).toBeUndefined();
   });
 
@@ -937,6 +1295,115 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     });
   });
 
+  test.each(['ios', 'android'] as const)(
+    'disconnects after an active V2 timeout and reconnects even if a listener fails on %s',
+    async platform => {
+      setPlatformOS(platform);
+      const harness = createHarness();
+      const { transport, uuid, device, bleManager, sentSeqs, emitter } = harness;
+      const disconnected = jest.fn(() => {
+        throw new Error('Disconnect listener failed');
+      });
+      emitter.on(TRANSPORT_EVENT.DEVICE_DISCONNECT, disconnected);
+      let connected = true;
+      device.isConnected.mockImplementation(() => Promise.resolve(connected));
+      device.connect = jest.fn(() => {
+        connected = true;
+        return Promise.resolve(device);
+      });
+      bleManager.cancelDeviceConnection.mockImplementation(() => {
+        connected = false;
+        return Promise.resolve();
+      });
+
+      await transport.acquire({ uuid, expectedProtocol: 'V2' });
+      harness.setShouldRespond(false);
+      await expect(transport.call(uuid, 'Ping', {}, { timeoutMs: 10 })).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleTimeoutError,
+      });
+
+      expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+      expect(connected).toBe(false);
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+      expect(disconnected).toHaveBeenCalledTimes(1);
+      expect(disconnected).toHaveBeenCalledWith({
+        id: uuid,
+        connectId: uuid,
+        name: device.name,
+      });
+
+      harness.setShouldRespond(true);
+      await transport.acquire({ uuid, expectedProtocol: 'V2' });
+      await expect(transport.call(uuid, 'Ping', {})).resolves.toMatchObject({ type: 'Success' });
+      expect(device.connect).toHaveBeenCalledTimes(1);
+      expect(sentSeqs).toEqual([1, 2, 3, 4]);
+      await transport.release(uuid, true);
+    }
+  );
+
+  test('does not disconnect an active Protocol V2 call when a queued call times out', async () => {
+    const harness = createHarness();
+    const { transport, uuid, bleManager } = harness;
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    harness.setShouldRespond(false);
+    const active = transport.call(uuid, 'Ping', {}, { timeoutMs: 1000 }).catch(error => error);
+    await new Promise(resolve => {
+      setImmediate(resolve);
+    });
+
+    try {
+      await expect(transport.call(uuid, 'Ping', {}, { timeoutMs: 10 })).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleTimeoutError,
+      });
+      expect(bleManager.cancelDeviceConnection).not.toHaveBeenCalled();
+      expect(transport.getProtocolType(uuid)).toBe('V2');
+    } finally {
+      await transport.disconnect(uuid);
+      await active;
+    }
+  });
+
+  test('does not disconnect a newer acquire when V2 timeout cleanup waits for the lifecycle lock', async () => {
+    const harness = createHarness();
+    const { transport, uuid, bleManager } = harness;
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const lifecycle = transport as unknown as {
+      runLifecycleOperation(id: string, operation: () => Promise<void>): Promise<void>;
+      releaseNative(id: string, onclose: boolean): Promise<boolean>;
+    };
+    const gate = createDeferred<void>();
+    const holding = lifecycle.runLifecycleOperation(uuid, () => gate.promise);
+    const reacquiring = transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const invalidated = createDeferred<void>();
+    const releaseNative = lifecycle.releaseNative.bind(lifecycle);
+    jest.spyOn(lifecycle, 'releaseNative').mockImplementationOnce(async (id, onclose) => {
+      const result = await releaseNative(id, onclose);
+      invalidated.resolve();
+      return result;
+    });
+    harness.setShouldRespond(false);
+    const failure = expect(
+      transport.call(uuid, 'Ping', {}, { timeoutMs: 10 })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+    });
+
+    try {
+      await invalidated.promise;
+      harness.setShouldRespond(true);
+      gate.resolve();
+      await holding;
+      await reacquiring;
+      await failure;
+      expect(bleManager.cancelDeviceConnection).not.toHaveBeenCalled();
+      await expect(transport.call(uuid, 'Ping', {})).resolves.toMatchObject({ type: 'Success' });
+    } finally {
+      gate.resolve();
+      await Promise.allSettled([holding, reacquiring, failure]);
+      await transport.release(uuid, true);
+    }
+  });
+
   test('retains the sequence cursor when a new monitor generation is acquired', async () => {
     const { transport, uuid, sentSeqs } = createHarness();
 

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
+  );
+};

package/src/bleStaleBond.ts

@@ -13,6 +13,7 @@ const IOS_PEER_REMOVED_PAIRING_INFORMATION = 14;
 
 type NativeBleErrorFields = {
   attErrorCode?: unknown;
+  androidErrorCode?: unknown;
   iosErrorCode?: unknown;
   reason?: unknown;
   message?: unknown;
@@ -32,6 +33,8 @@ export const isNativeBleStaleBondError = (error: unknown): boolean => {
   if (
     nativeError.attErrorCode === ATT_INSUFFICIENT_AUTHENTICATION ||
     nativeError.attErrorCode === ATT_INSUFFICIENT_ENCRYPTION ||
+    nativeError.androidErrorCode === ATT_INSUFFICIENT_AUTHENTICATION ||
+    nativeError.androidErrorCode === ATT_INSUFFICIENT_ENCRYPTION ||
     nativeError.iosErrorCode === IOS_PEER_REMOVED_PAIRING_INFORMATION
   ) {
     return true;