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

package/jest.config.js

@@ -2,9 +2,4 @@ module.exports = {
   preset: '../../jest.config.js',
   testEnvironment: 'node',
   modulePathIgnorePatterns: ['node_modules', '<rootDir>/dist'],
-  moduleNameMapper: {
-    // The workspace symlinks resolve to prebuilt dist outputs that can lag behind src.
-    '^@onekeyfe/hd-transport$': '<rootDir>/../hd-transport/src/index.ts',
-    '^@onekeyfe/hd-shared$': '<rootDir>/../shared/src/index.ts',
-  },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.0-alpha.68",
+  "version": "1.2.0-alpha.69",
   "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.0-alpha.68",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.68",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.68",
+    "@onekeyfe/hd-core": "1.2.0-alpha.69",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.69",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.69",
     "@onekeyfe/react-native-ble-utils": "^0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "6e8a931d08768980cfe7fa918bba447ed73e2724"
+  "gitHead": "c6baed25917e3c3f027f83dfc23cde85400de558"
 }

package/src/BleTransport.ts

@@ -9,7 +9,7 @@ export default class BleTransport {
 
   device: Device;
 
-  mtuSize = 23;
+  mtuSize: number | undefined;
 
   writeCharacteristic: Characteristic;
 

package/src/__tests__/bleStrategy.test.ts

@@ -1,4 +1,8 @@
-import { hasWritableCapability, resolveProtocolV2PacketCapacity } from '../bleStrategy';
+import {
+  hasWritableCapability,
+  resolveProtocolV2PacketCapacity,
+  shouldWriteProtocolV2WithResponse,
+} from '../bleStrategy';
 
 describe('React Native BLE strategy', () => {
   test('accepts writeWithoutResponse-only characteristics', () => {
@@ -10,27 +14,35 @@ describe('React Native BLE strategy', () => {
     expect(hasWritableCapability(characteristic)).toBe(true);
   });
 
-  test('falls back to Android default ATT payload when MTU is unavailable', () => {
-    expect(
+  test('rejects Protocol V2 packet sizing when MTU is unavailable', () => {
+    expect(() =>
       resolveProtocolV2PacketCapacity({
         platform: 'android',
-        androidPacketLength: 192,
         mtu: null,
       })
-    ).toBe(20);
+    ).toThrow('Protocol V2 BLE requires a negotiated MTU');
   });
 
   test('caps Android packet length by negotiated MTU payload', () => {
     expect(
       resolveProtocolV2PacketCapacity({
         platform: 'android',
-        androidPacketLength: 192,
+        androidPacketLength: 244,
         mtu: 100,
       })
     ).toBe(97);
   });
 
-  test('keeps iOS packet length controlled by tuning profile', () => {
+  test('uses the Android 517 MTU payload when fully negotiated', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'android',
+        mtu: 517,
+      })
+    ).toBe(514);
+  });
+
+  test('caps iOS packet length by the system-negotiated write payload', () => {
     expect(
       resolveProtocolV2PacketCapacity({
         platform: 'ios',
@@ -39,4 +51,62 @@ describe('React Native BLE strategy', () => {
       })
     ).toBe(244);
   });
+
+  test('uses the reported iOS MTU without a compatibility fallback', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'ios',
+        iosPacketLength: 128,
+        mtu: 23,
+      })
+    ).toBe(20);
+  });
+
+  test('uses a smaller system-negotiated iOS write payload', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'ios',
+        iosPacketLength: 244,
+        mtu: 185,
+      })
+    ).toBe(182);
+  });
+
+  test('uses withoutResponse for a high-volume write unless explicitly overridden', () => {
+    const characteristic = {
+      isWritableWithResponse: true,
+      isWritableWithoutResponse: true,
+    };
+
+    expect(
+      shouldWriteProtocolV2WithResponse({
+        platform: 'ios',
+        highVolume: true,
+        requestedWithResponse: false,
+        characteristic,
+      })
+    ).toBe(false);
+    expect(
+      shouldWriteProtocolV2WithResponse({
+        platform: 'ios',
+        highVolume: true,
+        requestedWithResponse: true,
+        characteristic,
+      })
+    ).toBe(true);
+  });
+
+  test('falls back to withResponse when withoutResponse is unavailable', () => {
+    expect(
+      shouldWriteProtocolV2WithResponse({
+        platform: 'ios',
+        highVolume: true,
+        requestedWithResponse: false,
+        characteristic: {
+          isWritableWithResponse: true,
+          isWritableWithoutResponse: false,
+        },
+      })
+    ).toBe(true);
+  });
 });

package/src/__tests__/protocolV2Link.test.ts

@@ -32,6 +32,7 @@ jest.mock('react-native-ble-plx', () => ({
     CharacteristicNotFound: 404,
   },
   BleManager: jest.fn(),
+  ConnectionPriority: { Balanced: 0, High: 1, LowPower: 2 },
   ScanMode: { LowLatency: 2 },
 }));
 
@@ -157,6 +158,7 @@ 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()),
@@ -164,7 +166,9 @@ 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([])),
@@ -172,18 +176,21 @@ 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({ debug: jest.fn(), error: jest.fn() }, emitter);
+  transport.init(logger, emitter);
   transport.configure(protocolV1Schema);
   transport.configureProtocolV2(protocolV2Schema);
 
   return {
     transport,
     emitter,
+    logger,
     uuid,
+    device,
     sentSeqs,
     writeCharacteristic,
     setShouldRespond(value: boolean) {
@@ -247,6 +254,7 @@ 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()),
@@ -255,7 +263,8 @@ 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])),
@@ -392,7 +401,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, sentSeqs, writeCharacteristic } = createHarness({
+    const { transport, uuid, device, sentSeqs, writeCharacteristic } = createHarness({
       deviceName: 'Pro2 6E9E',
     });
 
@@ -400,6 +409,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       uuid,
       protocolType: 'V2',
     });
+    expect(device.requestMTU).toHaveBeenCalledWith(247);
     expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
 
     await expect(
@@ -429,6 +439,57 @@ 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 } =
@@ -564,14 +625,38 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   test('keeps iOS Protocol V2 high-volume calls on withoutResponse', async () => {
-    const { transport, uuid, writeCharacteristic } = createHarness();
+    const { transport, uuid, logger, writeCharacteristic } = createHarness();
 
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
 
     await transport.call(uuid, 'FileWrite', {});
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    await transport.call(uuid, 'FileWrite', {});
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(2);
     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 () => {
@@ -613,7 +698,6 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
 
     await expect(
       transport.writeProtocolV2Packet(
-        'test-device',
         {
           writeCharacteristic: {
             isWritableWithResponse: true,
@@ -630,7 +714,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(writeWithoutResponse).not.toHaveBeenCalled();
   });
 
-  test('paces a one-packet Protocol V2 control write on iOS', async () => {
+  test('does not pace 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 = {
@@ -648,19 +732,9 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
 
     try {
-      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();
+      await transport.writeProtocolV2Frame(bleTransport, new Uint8Array(10), context, jest.fn());
 
-      await call;
+      expect(setTimeoutSpy).not.toHaveBeenCalled();
       expect(writeWithoutResponse).toHaveBeenCalledTimes(1);
     } finally {
       setTimeoutSpy.mockRestore();
@@ -724,7 +798,6 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     configureProtocolV2BleTuning({ iosPacketLength: 20 });
 
     await transport.writeProtocolV2Frame(
-      'device-uuid',
       bleTransport,
       new Uint8Array(30),
       context,
@@ -756,14 +829,34 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     configureProtocolV2BleTuning({ iosPacketLength: 20 });
 
     await expect(
-      transport.writeProtocolV2Frame(
-        'device-uuid',
-        bleTransport,
-        new Uint8Array(30),
-        context,
-        jest.fn()
-      )
+      transport.writeProtocolV2Frame(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/bleStrategy.ts

@@ -1,4 +1,4 @@
-import { ANDROID_DEFAULT_MTU, ANDROID_PACKET_LENGTH, IOS_PACKET_LENGTH } from './constants';
+import { ANDROID_PROTOCOL_V2_PACKET_LENGTH, IOS_PROTOCOL_V2_PACKET_LENGTH } from './constants';
 
 export type BlePlatform = 'ios' | 'android' | string;
 
@@ -13,8 +13,8 @@ export function hasWritableCapability(characteristic: BleWriteCapability) {
 
 export function resolveProtocolV2PacketCapacity({
   platform,
-  iosPacketLength = IOS_PACKET_LENGTH,
-  androidPacketLength = ANDROID_PACKET_LENGTH,
+  iosPacketLength = IOS_PROTOCOL_V2_PACKET_LENGTH,
+  androidPacketLength = ANDROID_PROTOCOL_V2_PACKET_LENGTH,
   mtu,
 }: {
   platform: BlePlatform;
@@ -22,14 +22,27 @@ export function resolveProtocolV2PacketCapacity({
   androidPacketLength?: number;
   mtu?: number | null;
 }) {
-  if (platform === 'ios') {
-    return iosPacketLength;
+  if (typeof mtu !== 'number' || !Number.isFinite(mtu) || mtu <= 3) {
+    throw new Error(`Protocol V2 BLE requires a negotiated MTU, received: ${String(mtu)}`);
   }
 
-  if (platform === 'android') {
-    const payloadLength = Math.max((mtu ?? ANDROID_DEFAULT_MTU) - 3, 1);
-    return Math.min(androidPacketLength, payloadLength);
-  }
+  const payloadLength = Math.floor(mtu) - 3;
+  const configuredPacketLength = platform === 'ios' ? iosPacketLength : androidPacketLength;
+  return Math.min(configuredPacketLength, payloadLength);
+}
 
-  return androidPacketLength;
+export function shouldWriteProtocolV2WithResponse({
+  platform,
+  highVolume,
+  requestedWithResponse,
+  characteristic,
+}: {
+  platform: BlePlatform;
+  highVolume: boolean;
+  requestedWithResponse?: boolean;
+  characteristic: BleWriteCapability;
+}) {
+  if (!characteristic.isWritableWithResponse) return false;
+  if (!characteristic.isWritableWithoutResponse) return true;
+  return requestedWithResponse === true || (platform === 'ios' && !highVolume);
 }

package/src/constants.ts

@@ -2,7 +2,8 @@ import { createKnownBleUuidAliases, matchesKnownBleUuid } from '@onekeyfe/hd-sha
 
 export const IOS_PACKET_LENGTH = 128;
 export const ANDROID_PACKET_LENGTH = 192;
-export const ANDROID_DEFAULT_MTU = 23;
+export const IOS_PROTOCOL_V2_PACKET_LENGTH = 244;
+export const ANDROID_PROTOCOL_V2_PACKET_LENGTH = 514;
 
 type BluetoothServices = Record<
   string,