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

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,32 +360,46 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(new ReactNativeBleTransport({}).scanTimeout).toBe(3000);
   });
 
-  test('connects the Android GATT link before starting system bonding', async () => {
-    setPlatformOS('android');
-    const { transport, uuid, device } = createHarness();
-    const operationOrder: string[] = [];
-    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+  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: true, bonding: false });
-    });
+      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);
 
-    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
+      const acquiring = transport.acquire({ uuid, expectedProtocol: protocol });
+      await new Promise(resolve => {
+        setImmediate(resolve);
+      });
+      expect(operationOrder).toEqual(['bond']);
+      expect(device.connect).not.toHaveBeenCalled();
 
-    expect(operationOrder).toEqual(['connect', 'bond']);
-    await transport.release(uuid, true);
-  });
+      bonding.resolve();
+      await expect(acquiring).resolves.toEqual({
+        uuid,
+        protocolType: protocol,
+      });
 
-  test('does not start Android bonding when both reconnect attempts fail', async () => {
+      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 (
@@ -412,22 +426,35 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       errorCode: HardwareErrorCode.BleConnectedError,
     });
     expect(device.connect).toHaveBeenCalledTimes(2);
-    expect(pairDeviceMock).not.toHaveBeenCalled();
+    expect(pairDeviceMock).toHaveBeenCalledTimes(1);
   });
 
-  test('checks that the Android GATT link is connected before bonding', async () => {
+  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.isConnected.mockResolvedValueOnce(false).mockResolvedValueOnce(false);
     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(pairDeviceMock).not.toHaveBeenCalled();
     expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
     expect(device.cancelConnection).toHaveBeenCalledTimes(1);
   });
@@ -468,12 +495,12 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
         .mockRejectedValue(Object.assign(new BleErrorMock(nativeError.reason), nativeError));
 
       await expect(transport.acquire({ uuid })).rejects.toMatchObject({ errorCode });
-      expect(pairDeviceMock).not.toHaveBeenCalled();
+      expect(pairDeviceMock).toHaveBeenCalledTimes(platform === 'android' ? 1 : 0);
       expect(transport.getProtocolType(uuid)).toBeUndefined();
     }
   );
 
-  test('closes the Android GATT link when system bonding fails', async () => {
+  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;
@@ -485,7 +512,32 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     );
 
     expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
-    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
+    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 () => {
@@ -830,6 +882,116 @@ 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 } = 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);
+      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

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