@onekeyfe/hd-transport-react-native 1.2.0-alpha.6 → 1.2.0-alpha.63

package/src/__tests__/staleCallTimeout.test.ts

@@ -0,0 +1,211 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport from '../index';
+
+import messages from '@onekeyfe/hd-transport/messages.json';
+
+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(messages);
+  (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);
+  });
+});

package/src/__tests__/writePacketTimeout.test.ts

@@ -0,0 +1,306 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport, {
+  BLE_WRITE_PACKET_TIMEOUT_MS,
+  BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD,
+} from '../index';
+
+import messages from '@onekeyfe/hd-transport/messages.json';
+
+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 = 'wedged-write-device';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+/** Drive fake timers forward in slices until `settled()` reports done. */
+async function advanceUntil(settled: () => boolean, totalMs: number, stepMs = 500) {
+  for (let elapsed = 0; elapsed < totalMs; elapsed += stepMs) {
+    jest.advanceTimersByTime(stepMs);
+    // eslint-disable-next-line no-await-in-loop
+    await flush();
+    if (settled()) return;
+  }
+  throw new Error(`fake timers exhausted after ${totalMs}ms before the call settled`);
+}
+
+/** Drive fake timers forward without requiring the work to settle. */
+async function drain(totalMs: number, stepMs = 500) {
+  for (let elapsed = 0; elapsed < totalMs; elapsed += stepMs) {
+    jest.advanceTimersByTime(stepMs);
+    // eslint-disable-next-line no-await-in-loop
+    await flush();
+  }
+}
+
+function createHarness(writeImpl: () => Promise<void>) {
+  const t = new ReactNativeBleTransport({});
+  t.configure(messages);
+  (t as any).deviceProtocol.set(UUID, 'V1');
+  const writeWithoutResponse = jest.fn(writeImpl);
+  const fakeBleTransport = {
+    writeCharacteristic: { writeWithoutResponse },
+    writeWithRetry: jest.fn(writeImpl),
+  };
+  (t as any).getCachedTransport = () => fakeBleTransport;
+  const disconnectSpy = jest.spyOn(t, 'disconnect').mockResolvedValue(undefined);
+  return { t, disconnectSpy, writeWithoutResponse };
+}
+
+describe('BLE packet write timeout', () => {
+  beforeAll(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+  });
+
+  test('a never-settling write rejects instead of hanging the call forever', async () => {
+    // iOS never resolves writeWithoutResponse when the peripheral stops reporting
+    // "ready to send"; without a bounded write the response timeout is never armed.
+    const { t } = createHarness(
+      () =>
+        new Promise<void>(() => {
+          // never settles
+        })
+    );
+
+    const errors: Array<{ errorCode?: unknown }> = [];
+    let settled = false;
+    const call = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    call.catch(e => {
+      errors.push(e);
+      settled = true;
+    });
+    await flush();
+
+    await advanceUntil(() => settled, 30000);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleWriteCharacteristicError);
+  });
+
+  test('a wedged write tears the BLE link down so the next call reconnects', async () => {
+    const { t, disconnectSpy } = createHarness(
+      () =>
+        new Promise<void>(() => {
+          // never settles
+        })
+    );
+
+    let settled = false;
+    const call = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    call.catch(() => {
+      settled = true;
+    });
+    await flush();
+
+    await advanceUntil(() => settled, 30000);
+
+    expect(disconnectSpy).toHaveBeenCalledWith(UUID);
+  });
+
+  test('the write budget is per packet, not per call', async () => {
+    // Five packets at 4s each: the call's write phase far outlives one packet budget,
+    // but no single packet does, so nothing may be torn down.
+    const { t, disconnectSpy, writeWithoutResponse } = createHarness(
+      () =>
+        new Promise<void>(resolve => {
+          setTimeout(resolve, 4000);
+        })
+    );
+
+    const errors: Array<{ errorCode?: unknown }> = [];
+    let settled = false;
+    const call = t.call(UUID, 'Ping', { message: 'x'.repeat(300) }, { timeoutMs: 120000 });
+    call.catch(e => {
+      errors.push(e);
+      settled = true;
+    });
+    await flush();
+
+    await advanceUntil(() => settled, 200000);
+
+    // Every packet was written: none was aborted even though the write phase as a
+    // whole ran far past a single packet budget.
+    expect(writeWithoutResponse.mock.calls.length).toBeGreaterThan(1);
+    expect(4000 * writeWithoutResponse.mock.calls.length).toBeGreaterThan(
+      BLE_WRITE_PACKET_TIMEOUT_MS
+    );
+    // Fails on the RESPONSE timeout the device never answered, not on a write timeout.
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleTimeoutError);
+  });
+
+  test('a superseded call whose write wedges must not tear down the successor link', async () => {
+    // Only the first call's write wedges; the successor writes normally.
+    let writes = 0;
+    const { t, disconnectSpy } = createHarness(() => {
+      writes += 1;
+      return writes === 1
+        ? new Promise<void>(() => {
+            // never settles
+          })
+        : Promise.resolve();
+    });
+
+    const first = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    first.catch(() => undefined);
+    await flush();
+
+    // A forceRun call supersedes it and becomes the transport owner.
+    const second = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+    second.catch(() => undefined);
+    await flush();
+
+    await drain(BLE_WRITE_PACKET_TIMEOUT_MS + 2000);
+
+    expect(disconnectSpy).not.toHaveBeenCalled();
+    expect(t.runPromise).not.toBeNull();
+  });
+
+  test('repeated wedged writes recreate the BLE manager', async () => {
+    const { t, disconnectSpy } = createHarness(
+      () =>
+        new Promise<void>(() => {
+          // never settles
+        })
+    );
+    const destroy = jest.fn();
+    (t as any).blePlxManager = { destroy };
+
+    for (let attempt = 0; attempt < BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
+      (t as any).deviceProtocol.set(UUID, 'V1');
+      let settled = false;
+      const call = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
+      call.catch(() => {
+        settled = true;
+      });
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      // eslint-disable-next-line no-await-in-loop
+      await advanceUntil(() => settled, BLE_WRITE_PACKET_TIMEOUT_MS + 2000);
+    }
+
+    expect(disconnectSpy).toHaveBeenCalledTimes(BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD);
+    expect(destroy).toHaveBeenCalledTimes(1);
+    expect((t as any).blePlxManager).toBeUndefined();
+  });
+
+  test('slow but progressing writes are not aborted', async () => {
+    // Each packet takes a while but keeps completing: this must not be mistaken
+    // for a wedged link, even when the whole call outlives a single packet budget.
+    const { t, writeWithoutResponse } = createHarness(
+      () =>
+        new Promise<void>(resolve => {
+          setTimeout(resolve, 4000);
+        })
+    );
+
+    const errors: unknown[] = [];
+    let settled = false;
+    const call = t.call(UUID, 'Initialize', {}, { timeoutMs: 60000 });
+    call.catch(e => {
+      errors.push(e);
+      settled = true;
+    });
+    await flush();
+
+    // Let every packet drain; the call then waits for a device response that never
+    // comes, and must fail with the RESPONSE timeout, not a write timeout.
+    await advanceUntil(() => settled, 90000);
+
+    expect(writeWithoutResponse).toHaveBeenCalled();
+    expect(errors).toHaveLength(1);
+    expect((errors[0] as { errorCode?: unknown })?.errorCode).toBe(
+      HardwareErrorCode.BleTimeoutError
+    );
+  });
+});
+
+describe('protocol probe state visibility', () => {
+  beforeAll(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+  });
+
+  test('an in-flight probe does not publish its protocol as confirmed', async () => {
+    const { t } = createHarness(
+      () =>
+        new Promise<void>(() => {
+          // never settles
+        })
+    );
+    (t as any).deviceProtocol.delete(UUID);
+
+    const probe = (t as any).probeProtocolV1(UUID) as Promise<boolean>;
+    probe.catch(() => undefined);
+    await flush();
+
+    // The call itself must still route as V1 while probing...
+    expect(t.getProtocolType(UUID)).toBe('V1');
+    // ...but acquire's cached-transport reuse gate must not treat it as detected.
+    expect((t as any).deviceProtocol.get(UUID)).toBeUndefined();
+
+    await drain(BLE_WRITE_PACKET_TIMEOUT_MS + 2000);
+  });
+
+  test('a probe that confirms its protocol leaves no probing entry behind', async () => {
+    const { t } = createHarness(() => Promise.resolve());
+    (t as any).deviceProtocol.delete(UUID);
+
+    const probe = (t as any).probeProtocolV1(UUID) as Promise<boolean>;
+    probe.catch(() => undefined);
+    await flush();
+    // The device answers the probe.
+    t.runPromise?.resolve('deadbeef');
+    await flush();
+
+    expect((t as any).probingProtocols.size).toBe(0);
+  });
+});

package/src/bleStrategy.ts

@@ -7,35 +7,10 @@ export type BleWriteCapability = {
   isWritableWithoutResponse?: boolean | null;
 };
 
-export type BleWriteMode = 'withResponse' | 'withoutResponse';
-
 export function hasWritableCapability(characteristic: BleWriteCapability) {
   return !!(characteristic.isWritableWithResponse || characteristic.isWritableWithoutResponse);
 }
 
-export function resolveBleWriteMode(
-  characteristic: BleWriteCapability,
-  preferredMode: BleWriteMode = 'withoutResponse'
-): BleWriteMode {
-  if (preferredMode === 'withoutResponse' && characteristic.isWritableWithoutResponse) {
-    return 'withoutResponse';
-  }
-
-  if (preferredMode === 'withResponse' && characteristic.isWritableWithResponse) {
-    return 'withResponse';
-  }
-
-  if (characteristic.isWritableWithoutResponse) {
-    return 'withoutResponse';
-  }
-
-  if (characteristic.isWritableWithResponse) {
-    return 'withResponse';
-  }
-
-  return preferredMode;
-}
-
 export function resolveProtocolV2PacketCapacity({
   platform,
   iosPacketLength = IOS_PACKET_LENGTH,

package/src/constants.ts

@@ -1,3 +1,5 @@
+import { createKnownBleUuidAliases, matchesKnownBleUuid } from '@onekeyfe/hd-shared';
+
 export const IOS_PACKET_LENGTH = 128;
 export const ANDROID_PACKET_LENGTH = 192;
 export const ANDROID_DEFAULT_MTU = 23;
@@ -40,7 +42,9 @@ export const getInfosForServiceUuid = (serviceUuid: string, deviceType: 'classic
   const service =
     services[serviceUuid] ??
     Object.values(services).find(
-      item => normalizeBleUuid(item.serviceUuid) === normalizedServiceUuid
+      item =>
+        normalizeBleUuid(item.serviceUuid) === normalizedServiceUuid ||
+        matchesKnownBleUuid(serviceUuid, createKnownBleUuidAliases(item.serviceUuid))
     );
   if (!service) {
     return null;
@@ -51,17 +55,7 @@ export const getInfosForServiceUuid = (serviceUuid: string, deviceType: 'classic
 export const normalizeBleUuid = (uuid?: string | null) =>
   (uuid ?? '').replace(/-/g, '').toLowerCase();
 
-export const getBleUuidKey = (uuid?: string | null) => {
-  const normalized = normalizeBleUuid(uuid);
-  return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
-};
-
 export const isSameBleUuid = (left?: string | null, right?: string | null) => {
-  const normalizedLeft = normalizeBleUuid(left);
-  const normalizedRight = normalizeBleUuid(right);
-
-  return (
-    normalizedLeft === normalizedRight ||
-    (getBleUuidKey(left) !== '' && getBleUuidKey(left) === getBleUuidKey(right))
-  );
+  if (!left || !right) return false;
+  return matchesKnownBleUuid(left, createKnownBleUuidAliases(right));
 };