@onekeyfe/hd-transport-react-native 1.2.0-alpha.65 → 1.2.0-alpha.66

package/src/__tests__/protocolV2Link.test.ts

@@ -3,7 +3,6 @@ import transportPackage, {
   PROTOCOL_V2_CHANNEL_BLE_UART,
   ProtocolV2,
   TRANSPORT_EVENT,
-  bytesToHex,
 } from '@onekeyfe/hd-transport';
 import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
@@ -46,6 +45,11 @@ jest.mock('../subscribeBleOn', () => ({
   subscribeBleOn: jest.fn(() => Promise.resolve()),
 }));
 
+const setPlatformOS = (os: 'ios' | 'android') => {
+  const reactNative: { Platform: { OS: string } } = jest.requireMock('react-native');
+  reactNative.Platform.OS = os;
+};
+
 const { parseConfigure } = transportPackage;
 
 const protocolV1Schema = {
@@ -69,11 +73,13 @@ const protocolV1Schema = {
 
 const protocolV2Schema = {
   nested: {
+    ProtocolInfoRequest: { fields: {} },
     Ping: {
       fields: {
         message: { type: 'string', id: 1 },
       },
     },
+    DeviceInfoGet: { fields: {} },
     FileWrite: { fields: {} },
     Success: {
       fields: {
@@ -82,8 +88,10 @@ const protocolV2Schema = {
     },
     MessageType: {
       values: {
+        MessageType_ProtocolInfoRequest: 60200,
         MessageType_Ping: 60206,
         MessageType_Success: 60207,
+        MessageType_DeviceInfoGet: 60600,
         MessageType_FileWrite: 60805,
       },
     },
@@ -95,7 +103,13 @@ const schemas = {
   protocolV2: parseConfigure(protocolV2Schema),
 };
 
-const createHarness = () => {
+const createHarness = ({
+  deviceName = 'OneKey Pro 2',
+  isWritableWithResponse = true,
+}: {
+  deviceName?: string;
+  isWritableWithResponse?: boolean;
+} = {}) => {
   const uuid = 'rn-pro2-id';
   const sentSeqs: number[] = [];
   let responseSeq = 0;
@@ -134,15 +148,15 @@ const createHarness = () => {
   const writeCharacteristic = {
     uuid: '0002',
     deviceID: uuid,
-    isWritableWithResponse: true,
+    isWritableWithResponse,
     isWritableWithoutResponse: true,
     writeWithResponse: jest.fn(handleWrite),
     writeWithoutResponse: jest.fn(handleWrite),
   };
   const device = {
     id: uuid,
-    name: 'OneKey Pro 2',
-    localName: 'OneKey Pro 2',
+    name: deviceName,
+    localName: deviceName,
     serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
     isConnected: jest.fn(() => Promise.resolve(true)),
     cancelConnection: jest.fn(() => Promise.resolve()),
@@ -184,7 +198,13 @@ const createHarness = () => {
   };
 };
 
-const createV1Harness = () => {
+const createV1Harness = ({
+  respondOnWriteCount = 1,
+  isWritableWithResponse = true,
+}: {
+  respondOnWriteCount?: number | number[];
+  isWritableWithResponse?: boolean;
+} = {}) => {
   const uuid = 'rn-classic-id';
   const notifySubscriptionRemovers: jest.Mock[] = [];
   const disconnectSubscriptionRemovers: jest.Mock[] = [];
@@ -203,20 +223,25 @@ const createV1Harness = () => {
     }),
   };
   let writeCount = 0;
+  const responseWriteCounts = new Set(
+    Array.isArray(respondOnWriteCount) ? respondOnWriteCount : [respondOnWriteCount]
+  );
+  const handleWrite = () => {
+    writeCount += 1;
+    if (responseWriteCounts.has(writeCount)) {
+      notifyCallback?.(null, {
+        value: Buffer.from('3f23230002000000040a026f6b', 'hex').toString('base64'),
+      });
+    }
+    return Promise.resolve();
+  };
   const writeCharacteristic = {
     uuid: '0002',
     deviceID: uuid,
-    isWritableWithResponse: true,
+    isWritableWithResponse,
     isWritableWithoutResponse: true,
-    writeWithoutResponse: jest.fn(() => {
-      writeCount += 1;
-      if (writeCount === 1) {
-        notifyCallback?.(null, {
-          value: Buffer.from('3f23230002000000040a026f6b', 'hex').toString('base64'),
-        });
-      }
-      return Promise.resolve();
-    }),
+    writeWithResponse: jest.fn(handleWrite),
+    writeWithoutResponse: jest.fn(handleWrite),
   };
   const device = {
     id: uuid,
@@ -249,6 +274,7 @@ const createV1Harness = () => {
     uuid,
     device,
     bleManager,
+    writeCharacteristic,
     notifySubscriptionRemovers,
     disconnectSubscriptionRemovers,
   };
@@ -264,6 +290,19 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     ).toBeNull();
   });
 
+  test.each(['status 143', 'status:143', 'status = 143', 'GATT_CONGESTED'])(
+    'classifies %s as transient GATT congestion',
+    message => {
+      expect(getFirmwareUploadWriteRetryType({ message })).toBe('congested');
+    }
+  );
+
+  test('handles long uncontrolled status messages without a backtracking regular expression', () => {
+    const message = `status${' '.repeat(100_000)}142`;
+
+    expect(getFirmwareUploadWriteRetryType({ message })).toBeNull();
+  });
+
   test('keeps another device reader when releasing a device with an active V1 call', async () => {
     const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
     const activeV1Call = createDeferred<string>();
@@ -302,12 +341,101 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(new ReactNativeBleTransport({}).scanTimeout).toBe(3000);
   });
 
+  test('uses withResponse for consecutive iOS Protocol V1 control commands without releasing', async () => {
+    const { transport, uuid, writeCharacteristic } = createV1Harness({
+      respondOnWriteCount: [1, 2],
+    });
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V1' })).resolves.toEqual({
+      uuid,
+      protocolType: 'V1',
+    });
+    const releaseNative = jest.spyOn(transport as any, 'releaseNative');
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+
+    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).resolves.toBeDefined();
+    await expect(transport.call(uuid, 'GetFeatures', {}, { timeoutMs: 50 })).resolves.toBeDefined();
+
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(2);
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    expect(releaseNative).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
+  test('falls back to withoutResponse for an iOS Protocol V1 control command when required', async () => {
+    const { transport, uuid, writeCharacteristic } = createV1Harness({
+      isWritableWithResponse: false,
+    });
+
+    await transport.acquire({ uuid, expectedProtocol: 'V1' });
+    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).resolves.toBeDefined();
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    await transport.release(uuid, true);
+  });
+
+  test('does not resend a failed iOS Protocol V1 control write without response', async () => {
+    const { transport, uuid, writeCharacteristic } = createV1Harness();
+    const writeError = new Error('write with response failed');
+
+    await transport.acquire({ uuid, expectedProtocol: 'V1' });
+    writeCharacteristic.writeWithResponse.mockRejectedValueOnce(writeError);
+
+    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleWriteCharacteristicError,
+    });
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
+  test('actively probes Protocol V2 on iOS when only a name-derived hint is available', async () => {
+    const { transport, uuid, sentSeqs, writeCharacteristic } = createHarness({
+      deviceName: 'Pro2 6E9E',
+    });
+
+    await expect(transport.acquire({ uuid })).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+
+    await expect(
+      transport.call(uuid, 'Ping', { message: 'first-core-command' })
+    ).resolves.toBeDefined();
+    expect(sentSeqs).toEqual([1, 2]);
+    await transport.release(uuid, true);
+  });
+
+  test('falls back to the other active probe on iOS when protocol metadata is absent', async () => {
+    const { transport, uuid } = createHarness({ deviceName: 'OneKey' });
+    const probeProtocolV1 = jest
+      .spyOn(transport as any, 'probeProtocolV1')
+      .mockResolvedValue(false);
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2').mockResolvedValue(true);
+
+    await expect(transport.acquire({ uuid })).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(probeProtocolV1).toHaveBeenCalledTimes(1);
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+    expect(probeProtocolV1.mock.invocationCallOrder[0]).toBeLessThan(
+      probeProtocolV2.mock.invocationCallOrder[0]
+    );
+    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 } =
       createV1Harness();
     const probeProtocolV2 = jest
       .spyOn(transport as any, 'probeProtocolV2')
-      .mockImplementationOnce(async () => {
+      .mockImplementation(async () => {
         await (transport as any).releaseNative(uuid, true);
         return false;
       });
@@ -333,8 +461,9 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   test('cleans the rebuilt transport when Protocol V1 fallback also fails', async () => {
+    setPlatformOS('android');
     const { transport, uuid, device, bleManager, notifySubscriptionRemovers } = createV1Harness();
-    jest.spyOn(transport as any, 'probeProtocolV2').mockImplementationOnce(async () => {
+    jest.spyOn(transport as any, 'probeProtocolV2').mockImplementation(async () => {
       await (transport as any).releaseNative(uuid, true);
       return false;
     });
@@ -353,7 +482,9 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   test('disconnects and invalidates a Protocol V1 link after a response timeout', async () => {
-    const { transport, uuid, device } = createV1Harness();
+    const { transport, uuid, device } = createV1Harness({
+      respondOnWriteCount: Number.POSITIVE_INFINITY,
+    });
 
     await transport.acquire({ uuid, expectedProtocol: 'V1' });
     await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 5 })).rejects.toMatchObject({
@@ -365,29 +496,31 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   afterEach(() => {
+    setPlatformOS('ios');
     resetProtocolV2BleTuning();
   });
 
-  test('keeps the Protocol V2 sequence across probe and the next call', async () => {
+  test('uses the first Protocol V2 sequence for the first Core call when protocol is known', async () => {
     const { transport, uuid, sentSeqs } = createHarness();
 
-    await transport.acquire({ uuid });
-    await transport.call(uuid, 'Ping', { message: 'after-probe' });
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    await transport.call(uuid, 'Ping', { message: 'first-core-command' });
 
-    expect(sentSeqs).toEqual([1, 2]);
-    expect(bytesToHex(new Uint8Array([sentSeqs[0], sentSeqs[1]]))).toBe('0102');
+    expect(sentSeqs).toEqual([1]);
     await transport.release(uuid, true);
   });
 
   test('rejects the active Protocol V2 reader when the current monitor errors', async () => {
     const harness = createHarness();
     const { transport, uuid, sentSeqs } = harness;
-    await transport.acquire({ uuid });
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
     harness.setShouldRespond(false);
 
     const call = transport.call(uuid, 'Ping', { message: 'wait-for-monitor' }, { timeoutMs: 50 });
-    while (sentSeqs.length < 2) {
-      await Promise.resolve();
+    while (sentSeqs.length < 1) {
+      await new Promise(resolve => {
+        setTimeout(resolve, 0);
+      });
     }
     await new Promise(resolve => {
       setTimeout(resolve, 0);
@@ -402,40 +535,147 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   test('retains the sequence cursor when a new monitor generation is acquired', async () => {
     const { transport, uuid, sentSeqs } = createHarness();
 
-    await transport.acquire({ uuid });
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    await transport.call(uuid, 'Ping', { message: 'first-generation' });
     await transport.release(uuid, true);
-    await transport.acquire({ uuid });
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    await transport.call(uuid, 'Ping', { message: 'second-generation' });
 
     expect(sentSeqs).toEqual([1, 2]);
     await transport.release(uuid, true);
   });
 
-  test('uses withoutResponse for normal and high-volume calls', async () => {
+  test('uses withResponse for consecutive iOS Protocol V2 control calls without releasing', async () => {
     const { transport, uuid, writeCharacteristic } = createHarness();
 
-    await transport.acquire({ uuid });
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const releaseNative = jest.spyOn(transport as any, 'releaseNative');
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
     expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
 
-    await transport.call(uuid, 'Ping', { message: 'normal' });
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(2);
-    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    await transport.call(uuid, 'DeviceInfoGet', {});
+    await transport.call(uuid, 'ProtocolInfoRequest', {});
+
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(2);
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    expect(releaseNative).not.toHaveBeenCalled();
+
+    await transport.release(uuid, true);
+  });
+
+  test('keeps iOS Protocol V2 high-volume calls on withoutResponse', async () => {
+    const { transport, uuid, writeCharacteristic } = createHarness();
+
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
 
     await transport.call(uuid, 'FileWrite', {});
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(3);
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
+  test('uses withResponse for an iOS Protocol V2 firmware file write when requested', async () => {
+    const { transport, uuid, writeCharacteristic } = createHarness();
+
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+
+    await transport.call(uuid, 'FileWrite', {}, { writeWithResponse: true });
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
+  test('falls back to withoutResponse for an iOS Protocol V2 control call when required', async () => {
+    const { transport, uuid, writeCharacteristic } = createHarness({
+      isWritableWithResponse: false,
+    });
+
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    await transport.call(uuid, 'ProtocolInfoRequest', {});
+
     expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
     await transport.release(uuid, true);
   });
 
+  test('does not resend a failed iOS Protocol V2 control write without response', async () => {
+    const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
+    const writeError = new Error('write with response failed');
+    const writeWithResponse = jest.fn().mockRejectedValue(writeError);
+    const writeWithoutResponse = jest.fn().mockResolvedValue(undefined);
+    const context = {
+      messageName: 'ProtocolInfoRequest',
+      timeoutMs: 1000,
+      highVolume: false,
+      generation: 1,
+      signal: new AbortController().signal,
+    };
+
+    await expect(
+      transport.writeProtocolV2Packet(
+        {
+          writeCharacteristic: {
+            isWritableWithResponse: true,
+            writeWithResponse,
+            writeWithoutResponse,
+          },
+        },
+        Buffer.from('control').toString('base64'),
+        context,
+        jest.fn()
+      )
+    ).rejects.toBe(writeError);
+    expect(writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeWithoutResponse).not.toHaveBeenCalled();
+  });
+
+  test('paces 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 = {
+      mtuSize: 23,
+      writeCharacteristic: { writeWithoutResponse },
+    };
+    const context = {
+      messageName: 'ProtocolInfoRequest',
+      timeoutMs: 1000,
+      highVolume: false,
+      generation: 1,
+      signal: new AbortController().signal,
+    };
+    configureProtocolV2BleTuning({ iosPacketLength: 20 });
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
+
+    try {
+      const call = transport.writeProtocolV2Frame(
+        bleTransport,
+        new Uint8Array(10),
+        context,
+        jest.fn()
+      );
+
+      await Promise.resolve();
+      expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 5);
+      expect(writeWithoutResponse).not.toHaveBeenCalled();
+
+      await call;
+      expect(writeWithoutResponse).toHaveBeenCalledTimes(1);
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+  });
+
   test('rejects an active Protocol V2 reader when disconnect resets the link', async () => {
     const harness = createHarness();
     const { transport, uuid, sentSeqs } = harness;
-    await transport.acquire({ uuid });
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
     harness.setShouldRespond(false);
 
     const call = transport.call(uuid, 'Ping', { message: 'disconnect' }, { timeoutMs: 50 });
-    while (sentSeqs.length < 2) {
-      await Promise.resolve();
+    while (sentSeqs.length < 1) {
+      await new Promise(resolve => {
+        setTimeout(resolve, 0);
+      });
     }
 
     const rejection = expect(call).rejects.toThrow('React Native BLE transport disconnected');
@@ -448,7 +688,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     const disconnectListener = jest.fn();
     harness.emitter.on(TRANSPORT_EVENT.DEVICE_DISCONNECT, disconnectListener);
 
-    await harness.transport.acquire({ uuid: harness.uuid });
+    await harness.transport.acquire({ uuid: harness.uuid, expectedProtocol: 'V2' });
     harness.emitDisconnect();
     await harness.transport.disconnect(harness.uuid);
 
@@ -482,7 +722,6 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     configureProtocolV2BleTuning({ iosPacketLength: 20 });
 
     await transport.writeProtocolV2Frame(
-      'device-uuid',
       bleTransport,
       new Uint8Array(30),
       context,
@@ -514,13 +753,7 @@ 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);
   });