@onekeyfe/hd-transport-react-native 1.2.2-alpha.114 → 1.2.2-alpha.116

package/src/__tests__/connectTimeout.test.ts

@@ -6,6 +6,9 @@ import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
 import { onDeviceBondState } from '../BleManager';
 import ReactNativeBleTransport, {
+  ANDROID_LINK_DROP_QUIET_MS,
+  ANDROID_LINK_DROP_TIMEOUT_MS,
+  ANDROID_MTU_EXCHANGE_TIMEOUT_MS,
   BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
   BLE_CONNECT_TIMEOUT_MS,
   BLE_GATT_SETUP_TIMEOUT_MS,
@@ -641,3 +644,104 @@ describe('BLE connect timeout', () => {
     expect((transport as any).connectionSetupTimeoutCounts.has(UUID)).toBe(false);
   });
 });
+
+describe('Android MTU and link-drop bounds', () => {
+  beforeAll(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+    Object.assign(Platform, { OS: 'ios' });
+  });
+
+  test('the bounds sit above a cold-cache discovery and the 4s GATT link idle timer', () => {
+    // Single discovery passes on a Pro 2 at MTU 23 measured up to 4.8s, a refresh plus
+    // restart 7.7s; a stuck exchange never completes, so the bound only has to clear those.
+    expect(ANDROID_MTU_EXCHANGE_TIMEOUT_MS).toBeGreaterThanOrEqual(10_000);
+    expect(ANDROID_MTU_EXCHANGE_TIMEOUT_MS).toBeLessThanOrEqual(20_000);
+    // Android keeps the LE link for 4s after the last GATT client closes.
+    expect(ANDROID_LINK_DROP_QUIET_MS).toBeGreaterThan(4000);
+    expect(ANDROID_LINK_DROP_QUIET_MS).toBeLessThanOrEqual(ANDROID_LINK_DROP_TIMEOUT_MS);
+    expect(ANDROID_LINK_DROP_TIMEOUT_MS).toBeLessThanOrEqual(10_000);
+  });
+
+  test('holds an unusable link past the idle timer even when the GATT registry is already empty', 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);
+
+    // BluetoothManager.getConnectedDevices(GATT) reports this app's GATT client, which is
+    // already closed; the LE link itself stays up for the idle timer, so the wait must not
+    // release on that signal alone.
+    expect(
+      (BleUtils as unknown as { getConnectedPeripherals: jest.Mock }).getConnectedPeripherals
+    ).toHaveBeenCalled();
+    jest.advanceTimersByTime(4000);
+    await flush();
+    await flush();
+    expect(settled).toBeUndefined();
+
+    await advanceUntil(() => !!settled, ANDROID_LINK_DROP_TIMEOUT_MS);
+    await acquire;
+    expect(settled).toMatchObject({ errorCode: HardwareErrorCode.BleConnectedError });
+  });
+
+  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), 8000);
+          })
+      ),
+    });
+    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(8000);
+    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);
+  });
+});