@onekeyfe/hd-transport-react-native 1.2.2-alpha.120 → 1.2.2-alpha.122

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.2-alpha.120",
+  "version": "1.2.2-alpha.122",
   "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.2-alpha.120",
-    "@onekeyfe/hd-shared": "1.2.2-alpha.120",
-    "@onekeyfe/hd-transport": "1.2.2-alpha.120",
+    "@onekeyfe/hd-core": "1.2.2-alpha.122",
+    "@onekeyfe/hd-shared": "1.2.2-alpha.122",
+    "@onekeyfe/hd-transport": "1.2.2-alpha.122",
     "@onekeyfe/react-native-ble-utils": "0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "26958fa2be6aa34a07f42403fb7022d2785e70b9"
+  "gitHead": "37770cd3ae109751f082715228b6155487b7da56"
 }

package/src/__tests__/connectTimeout.test.ts

@@ -6,6 +6,8 @@ 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,
@@ -446,7 +448,7 @@ describe('BLE connect timeout', () => {
       const nativeOperation = createDeferred<typeof device>();
       const nativeDisconnect = createDeferred<void>();
       const requestMtu = jest.fn(() => Promise.resolve(device));
-      Object.assign(device, { mtu: 247, requestMTU: requestMtu });
+      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);
@@ -608,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;
@@ -640,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);
+  });
 });