@onekeyfe/hd-transport-react-native 1.2.0-alpha.69 → 1.2.0-alpha.70

package/src/__tests__/protocolV2Link.test.ts

@@ -32,7 +32,6 @@ jest.mock('react-native-ble-plx', () => ({
     CharacteristicNotFound: 404,
   },
   BleManager: jest.fn(),
-  ConnectionPriority: { Balanced: 0, High: 1, LowPower: 2 },
   ScanMode: { LowLatency: 2 },
 }));
 
@@ -158,7 +157,6 @@ const createHarness = ({
     id: uuid,
     name: deviceName,
     localName: deviceName,
-    mtu: 247,
     serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
     isConnected: jest.fn(() => Promise.resolve(true)),
     cancelConnection: jest.fn(() => Promise.resolve()),
@@ -166,9 +164,7 @@ const createHarness = ({
       disconnectCallback = callback;
       return { remove: jest.fn() };
     }),
-  } as any;
-  device.requestMTU = jest.fn(() => Promise.resolve(device));
-  device.requestConnectionPriority = jest.fn(() => Promise.resolve(device));
+  };
   const bleManager = {
     devices: jest.fn(() => Promise.resolve([device])),
     connectedDevices: jest.fn(() => Promise.resolve([])),
@@ -176,21 +172,18 @@ const createHarness = ({
   };
   const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
   const emitter = new EventEmitter();
-  const logger = { debug: jest.fn(), error: jest.fn() };
   transport.blePlxManager = bleManager;
   transport.resolveCharacteristics = jest.fn(() =>
     Promise.resolve({ writeCharacteristic, notifyCharacteristic })
   );
-  transport.init(logger, emitter);
+  transport.init({ debug: jest.fn(), error: jest.fn() }, emitter);
   transport.configure(protocolV1Schema);
   transport.configureProtocolV2(protocolV2Schema);
 
   return {
     transport,
     emitter,
-    logger,
     uuid,
-    device,
     sentSeqs,
     writeCharacteristic,
     setShouldRespond(value: boolean) {
@@ -254,7 +247,6 @@ const createV1Harness = ({
     id: uuid,
     name: 'OneKey Classic',
     localName: 'OneKey Classic',
-    mtu: 247,
     serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
     isConnected: jest.fn(() => Promise.resolve(true)),
     cancelConnection: jest.fn(() => Promise.resolve()),
@@ -263,8 +255,7 @@ const createV1Harness = ({
       disconnectSubscriptionRemovers.push(remove);
       return { remove };
     }),
-  } as any;
-  device.requestMTU = jest.fn(() => Promise.resolve(device));
+  };
   const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
   const bleManager = {
     devices: jest.fn(() => Promise.resolve([device])),
@@ -401,7 +392,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   test('actively probes Protocol V2 on iOS when only a name-derived hint is available', async () => {
-    const { transport, uuid, device, sentSeqs, writeCharacteristic } = createHarness({
+    const { transport, uuid, sentSeqs, writeCharacteristic } = createHarness({
       deviceName: 'Pro2 6E9E',
     });
 
@@ -409,7 +400,6 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).toHaveBeenCalledWith(247);
     expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
 
     await expect(
@@ -439,57 +429,6 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
-  test('continues with the current MTU when the connected snapshot refresh fails', async () => {
-    const { transport, uuid, device } = createHarness();
-    const mtuError = new Error('MTU refresh failed');
-    device.requestMTU.mockRejectedValueOnce(mtuError);
-
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
-    expect(device.requestMTU).toHaveBeenCalledTimes(1);
-    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(247);
-    await transport.release(uuid, true);
-  });
-
-  test('refreshes a transient bootloader MTU after notifications are ready', async () => {
-    const { transport, uuid, device } = createHarness();
-    device.mtu = 23;
-    device.requestMTU
-      .mockResolvedValueOnce(device)
-      .mockResolvedValueOnce(device)
-      .mockImplementationOnce(() => {
-        device.mtu = 247;
-        return Promise.resolve(device);
-      });
-
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
-    expect(device.requestMTU).toHaveBeenCalledTimes(3);
-    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(247);
-    await transport.release(uuid, true);
-  });
-
-  test('continues with a low bootloader MTU when the bounded retry fails', async () => {
-    const { transport, uuid, device } = createHarness();
-    device.mtu = 23;
-    device.requestMTU
-      .mockResolvedValueOnce(device)
-      .mockResolvedValueOnce(device)
-      .mockRejectedValueOnce(new Error('bootloader MTU retry failed'));
-
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
-    expect(device.requestMTU).toHaveBeenCalledTimes(3);
-    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
-    await transport.release(uuid, true);
-  });
-
   test('reconnects before falling back to Protocol V1 after a fatal V2 probe failure', async () => {
     setPlatformOS('android');
     const { transport, uuid, device, notifySubscriptionRemovers, disconnectSubscriptionRemovers } =
@@ -625,38 +564,14 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   test('keeps iOS Protocol V2 high-volume calls on withoutResponse', async () => {
-    const { transport, uuid, logger, writeCharacteristic } = createHarness();
+    const { transport, uuid, writeCharacteristic } = createHarness();
 
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
 
     await transport.call(uuid, 'FileWrite', {});
-    await transport.call(uuid, 'FileWrite', {});
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(2);
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
     expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
-    expect(
-      logger.debug.mock.calls.filter(
-        ([message]) =>
-          message === '[ReactNativeBleTransport] Protocol V2 high-volume write configured'
-      )
-    ).toHaveLength(1);
-    await transport.release(uuid, true);
-  });
-
-  test('uses Android 517 MTU and high connection priority during Protocol V2 high-volume calls', async () => {
-    setPlatformOS('android');
-    const { transport, uuid, device } = createHarness();
-
-    await transport.acquire({ uuid, expectedProtocol: 'V2' });
-    expect(device.requestMTU).toHaveBeenCalledWith(517);
-
-    await transport.call(uuid, 'FileWrite', {});
-    await transport.call(uuid, 'FileWrite', {});
-
-    expect(device.requestConnectionPriority).toHaveBeenCalledTimes(1);
-    expect(device.requestConnectionPriority).toHaveBeenCalledWith(1);
-
     await transport.release(uuid, true);
-    expect(device.requestConnectionPriority).toHaveBeenLastCalledWith(0);
   });
 
   test('uses withResponse for an iOS Protocol V2 firmware file write when requested', async () => {
@@ -698,6 +613,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
 
     await expect(
       transport.writeProtocolV2Packet(
+        'test-device',
         {
           writeCharacteristic: {
             isWritableWithResponse: true,
@@ -714,7 +630,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(writeWithoutResponse).not.toHaveBeenCalled();
   });
 
-  test('does not pace a one-packet Protocol V2 control write on iOS', async () => {
+  test('paces a one-packet Protocol V2 control write on iOS', async () => {
     const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
     const writeWithoutResponse = jest.fn().mockResolvedValue(undefined);
     const bleTransport = {
@@ -732,9 +648,19 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
 
     try {
-      await transport.writeProtocolV2Frame(bleTransport, new Uint8Array(10), context, jest.fn());
+      const call = transport.writeProtocolV2Frame(
+        'test-device',
+        bleTransport,
+        new Uint8Array(10),
+        context,
+        jest.fn()
+      );
+
+      await Promise.resolve();
+      expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 5);
+      expect(writeWithoutResponse).not.toHaveBeenCalled();
 
-      expect(setTimeoutSpy).not.toHaveBeenCalled();
+      await call;
       expect(writeWithoutResponse).toHaveBeenCalledTimes(1);
     } finally {
       setTimeoutSpy.mockRestore();
@@ -798,6 +724,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     configureProtocolV2BleTuning({ iosPacketLength: 20 });
 
     await transport.writeProtocolV2Frame(
+      'device-uuid',
       bleTransport,
       new Uint8Array(30),
       context,
@@ -829,34 +756,14 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     configureProtocolV2BleTuning({ iosPacketLength: 20 });
 
     await expect(
-      transport.writeProtocolV2Frame(bleTransport, new Uint8Array(30), context, jest.fn())
+      transport.writeProtocolV2Frame(
+        'device-uuid',
+        bleTransport,
+        new Uint8Array(30),
+        context,
+        jest.fn()
+      )
     ).rejects.toMatchObject({ errorCode: 205 });
     expect(writeWithoutResponse).toHaveBeenCalledTimes(1);
   });
-
-  test('does not apply fixed burst or flush pauses to high-volume Protocol V2 writes', async () => {
-    const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
-    const writeWithoutResponse = jest.fn().mockResolvedValue(undefined);
-    const bleTransport = {
-      mtuSize: 247,
-      writeCharacteristic: { writeWithoutResponse },
-    };
-    const context = {
-      messageName: 'FileWrite',
-      timeoutMs: 1000,
-      highVolume: true,
-      generation: 1,
-      signal: new AbortController().signal,
-    };
-    const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
-
-    try {
-      await transport.writeProtocolV2Frame(bleTransport, new Uint8Array(600), context, jest.fn());
-
-      expect(writeWithoutResponse).toHaveBeenCalledTimes(3);
-      expect(setTimeoutSpy).not.toHaveBeenCalled();
-    } finally {
-      setTimeoutSpy.mockRestore();
-    }
-  });
 });

package/src/__tests__/staleCallTimeout.test.ts

@@ -0,0 +1,210 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport from '../index';
+import protocolV1Schema from './protocolV1SchemaFixture';
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'ios', select: (spec: Record<string, unknown>) => spec.ios },
+    PermissionsAndroid: {
+      PERMISSIONS: {},
+      RESULTS: {},
+      request: jest.fn(),
+      requestMultiple: jest.fn(),
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('react-native-ble-plx', () => ({
+  BleATTErrorCode: { InvalidHandle: 1 },
+  BleError: Error,
+  BleErrorCode: { DeviceDisconnected: 201, OperationStartFailed: 601 },
+  BleManager: jest.fn(),
+  ScanMode: { LowLatency: 2 },
+}));
+
+jest.mock('@onekeyfe/react-native-ble-utils', () => ({
+  __esModule: true,
+  default: {
+    getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
+    getBondedPeripherals: jest.fn(() => Promise.resolve([])),
+    pairDevice: jest.fn(() => Promise.resolve()),
+  },
+}));
+
+const UUID = 'stale-timeout-device';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+function createHarness() {
+  const t = new ReactNativeBleTransport({});
+  t.configure(protocolV1Schema);
+  (t as any).deviceProtocol.set(UUID, 'V1');
+  const writeWithoutResponse = jest.fn(() => Promise.resolve());
+  const fakeBleTransport = {
+    writeCharacteristic: { writeWithoutResponse },
+    writeWithRetry: jest.fn(() => Promise.resolve()),
+  };
+  (t as any).getCachedTransport = () => fakeBleTransport;
+  const disconnectSpy = jest.spyOn(t, 'disconnect').mockResolvedValue(undefined);
+  return { t, disconnectSpy, writeWithoutResponse };
+}
+
+describe('Protocol V1 stale call timeout', () => {
+  beforeAll(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+  });
+
+  test('superseded Initialize timeout does not tear down the shared transport', async () => {
+    const { t, disconnectSpy } = createHarness();
+
+    // Initialize #1: written while the device reboots, never answered.
+    const firstErrors: unknown[] = [];
+    const first = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    first.catch(e => firstErrors.push(e));
+    await flush();
+
+    // Initialize #2 (forceRun) supersedes #1 three seconds later.
+    jest.advanceTimersByTime(3000);
+    const secondErrors: unknown[] = [];
+    const second = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    second.catch(e => secondErrors.push(e));
+    await flush();
+
+    // The device answers Initialize #2 (settle its deferred at the transport seam).
+    expect(t.runPromise).not.toBeNull();
+    t.runPromise?.reject(new Error('settled by device response'));
+    await flush();
+
+    // FirmwareUpload is now the active call on the same transport, awaiting its response.
+    const uploadErrors: unknown[] = [];
+    const upload = t.call(UUID, 'FirmwareUpload', { payload: Buffer.alloc(300) });
+    upload.catch(e => uploadErrors.push(e));
+    await flush();
+    jest.advanceTimersByTime(100); // firmware upload flush delay
+    await flush();
+
+    // Initialize #1's 25s response timer elapses while the upload is in flight.
+    jest.advanceTimersByTime(25000);
+    await flush();
+
+    expect(disconnectSpy).not.toHaveBeenCalled();
+    expect(firstErrors).toHaveLength(1);
+    expect(uploadErrors).toHaveLength(0);
+  });
+
+  test('forceRun supersede settles the previous pending call immediately', async () => {
+    const { t } = createHarness();
+
+    const firstErrors: Array<{ errorCode?: unknown }> = [];
+    const first = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    first.catch(e => firstErrors.push(e));
+    await flush();
+
+    const second = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    second.catch(() => undefined);
+    await flush();
+
+    expect(firstErrors).toHaveLength(1);
+    expect(firstErrors[0]?.errorCode).toBe(HardwareErrorCode.BleForceCleanRunPromise);
+
+    t.runPromise?.reject(new Error('settle second call'));
+    await flush();
+  });
+
+  test('late write failure of a superseded call keeps the successor as owner', async () => {
+    const { t, disconnectSpy } = createHarness();
+
+    // First call's write hangs; its promise is controlled by the test.
+    let rejectFirstWrite: ((e: Error) => void) | undefined;
+    const fakeBleTransport = {
+      writeCharacteristic: {
+        writeWithoutResponse: jest
+          .fn()
+          .mockImplementationOnce(
+            () =>
+              new Promise((_resolve, reject) => {
+                rejectFirstWrite = reject;
+              })
+          )
+          .mockImplementation(() => Promise.resolve()),
+      },
+      writeWithRetry: jest.fn(() => Promise.resolve()),
+    };
+    (t as any).getCachedTransport = () => fakeBleTransport;
+
+    const firstErrors: unknown[] = [];
+    const first = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    first.catch(e => firstErrors.push(e));
+    await flush();
+
+    // forceRun successor takes ownership while the first call is stuck writing.
+    const secondErrors: unknown[] = [];
+    const second = t.call(UUID, 'Initialize', {}, { timeoutMs: 5000 });
+    second.catch(e => secondErrors.push(e));
+    await flush();
+
+    // The first call's write now fails late; it must not clear the successor's slot.
+    rejectFirstWrite?.(new Error('late write failure'));
+    await flush();
+
+    expect(t.runPromise).not.toBeNull();
+
+    // The successor's genuine timeout must still tear the connection down.
+    jest.advanceTimersByTime(5000);
+    await flush();
+
+    expect(disconnectSpy).toHaveBeenCalledTimes(1);
+    expect(secondErrors).toHaveLength(1);
+  });
+
+  test('orphan timer left behind by cancel() must not disconnect the transport', 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();
+
+    jest.advanceTimersByTime(5000);
+    await flush();
+
+    expect(disconnectSpy).not.toHaveBeenCalled();
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleTimeoutError);
+  });
+
+  test('timeout on the active call still disconnects the transport', async () => {
+    const { t, disconnectSpy } = createHarness();
+
+    const errors: Array<{ errorCode?: unknown }> = [];
+    const p = t.call(UUID, 'GetFeatures', {}, { timeoutMs: 5000 });
+    p.catch(e => errors.push(e));
+    await flush();
+
+    jest.advanceTimersByTime(5000);
+    await flush();
+
+    expect(disconnectSpy).toHaveBeenCalledTimes(1);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleTimeoutError);
+  });
+});