@onekeyfe/hd-transport-react-native 1.2.0-alpha.5 → 1.2.0-alpha.51

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