@onekeyfe/hd-transport-react-native 1.2.8-alpha.117 → 1.2.8-alpha.119

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,917 +0,0 @@
1
- import { EventEmitter } from 'events';
2
- import transportPackage, {
3
- PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
4
- PROTOCOL_V2_CHANNEL_BLE_UART,
5
- ProtocolV2,
6
- ProtocolV2FrameAssembler,
7
- } from '@onekeyfe/hd-transport';
8
- import { HardwareErrorCode } from '@onekeyfe/hd-shared';
9
-
10
- import ReactNativeBleTransport, {
11
- BLE_WRITE_PACKET_TIMEOUT_MS,
12
- configureProtocolV2BleTuning,
13
- getProtocolV2BleTuning,
14
- resetProtocolV2BleTuning,
15
- } from '../index';
16
- import protocolV1SchemaFixture from './protocolV1SchemaFixture';
17
-
18
- jest.mock(
19
- 'react-native',
20
- () => ({
21
- PermissionsAndroid: {},
22
- Platform: { OS: 'android' },
23
- }),
24
- { virtual: true }
25
- );
26
-
27
- jest.mock('react-native-ble-plx', () => ({
28
- BleATTErrorCode: { UnlikelyError: 14 },
29
- BleError: class BleError extends Error {},
30
- BleErrorCode: {
31
- DeviceAlreadyConnected: 203,
32
- DeviceDisconnected: 201,
33
- DeviceMTUChangeFailed: 206,
34
- OperationCancelled: 2,
35
- OperationStartFailed: 601,
36
- CharacteristicNotFound: 404,
37
- },
38
- BleManager: jest.fn(),
39
- ConnectionPriority: { Balanced: 0, High: 1, LowPower: 2 },
40
- ScanMode: { LowLatency: 2 },
41
- }));
42
-
43
- jest.mock('../BleManager', () => ({
44
- getConnectedDeviceIds: jest.fn(() => Promise.resolve([])),
45
- onDeviceBondState: jest.fn(() => Promise.resolve()),
46
- pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
47
- }));
48
-
49
- jest.mock('../subscribeBleOn', () => ({
50
- subscribeBleOn: jest.fn(() => Promise.resolve()),
51
- }));
52
-
53
- type Platform = 'ios' | 'android';
54
-
55
- const setPlatformOS = (os: Platform) => {
56
- const reactNative: { Platform: { OS: string } } = jest.requireMock('react-native');
57
- reactNative.Platform.OS = os;
58
- };
59
-
60
- const { parseConfigure } = transportPackage;
61
-
62
- const FRAME_TX_PATTERN = /^dev:v2frame:3:\d+$/;
63
- const PACKET_CAPACITY = 244;
64
- const PERF_MESSAGE = '[ReactNativeBleTransport] FileWrite perf';
65
- const MODE_MESSAGE = '[ReactNativeBleTransport] Protocol V2 frame write mode';
66
-
67
- const flush = () =>
68
- new Promise(resolve => {
69
- setImmediate(resolve);
70
- });
71
-
72
- const createFrame = (length: number) => Uint8Array.from({ length }, (_, index) => index % 251);
73
-
74
- const neverSettles = () =>
75
- new Promise<void>(() => {
76
- // never settles
77
- });
78
-
79
- type FrameWrite = (
80
- characteristicIdentifier: number,
81
- base64Frame: string,
82
- packetSize: number,
83
- transactionId: string
84
- ) => Promise<void>;
85
-
86
- const createFrameManager = ({
87
- supported = true,
88
- write = () => Promise.resolve(),
89
- }: {
90
- supported?: boolean | (() => boolean);
91
- write?: FrameWrite;
92
- } = {}) => ({
93
- isWriteCharacteristicWithoutResponseFrameSupported: jest.fn(
94
- typeof supported === 'function' ? supported : () => supported
95
- ),
96
- writeCharacteristicWithoutResponseFrame: jest.fn(write),
97
- cancelTransaction: jest.fn(() => Promise.resolve()),
98
- cancelDeviceConnection: jest.fn(() => Promise.resolve()),
99
- destroy: jest.fn(),
100
- });
101
-
102
- const createUnit = ({
103
- manager,
104
- characteristicId = 42,
105
- }: {
106
- manager?: unknown;
107
- characteristicId?: unknown;
108
- } = {}) => {
109
- const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
110
- transport.blePlxManager = manager;
111
- const writeWithoutResponse = jest.fn().mockResolvedValue(undefined);
112
- const writeWithResponse = jest.fn().mockResolvedValue(undefined);
113
- const bleTransport = {
114
- mtuSize: 247,
115
- writeCharacteristic: {
116
- id: characteristicId,
117
- isWritableWithResponse: true,
118
- isWritableWithoutResponse: true,
119
- writeWithResponse,
120
- writeWithoutResponse,
121
- },
122
- };
123
- return { transport, bleTransport, writeWithoutResponse, writeWithResponse };
124
- };
125
-
126
- const createContext = (overrides: Record<string, unknown> = {}) => {
127
- const controller = new AbortController();
128
- return {
129
- controller,
130
- context: {
131
- messageName: 'FilesystemFileWrite',
132
- timeoutMs: 1000,
133
- highThroughput: true,
134
- generation: 3,
135
- signal: controller.signal,
136
- ...overrides,
137
- },
138
- };
139
- };
140
-
141
- const createGenerationGuard = () => {
142
- let current = true;
143
- return {
144
- assert: jest.fn(() => {
145
- if (!current) throw new Error('Protocol V2 monitor generation changed for dev');
146
- }),
147
- change() {
148
- current = false;
149
- },
150
- };
151
- };
152
-
153
- const frameCancellations = (manager: { cancelTransaction: jest.Mock }) =>
154
- manager.cancelTransaction.mock.calls.filter(([transactionId]) =>
155
- String(transactionId).includes(':v2frame:')
156
- );
157
-
158
- afterEach(() => {
159
- resetProtocolV2BleTuning();
160
- setPlatformOS('android');
161
- jest.restoreAllMocks();
162
- });
163
-
164
- describe('Protocol V2 native frame write selection', () => {
165
- test('defaults the native frame write tuning on and keeps it across unrelated tuning', () => {
166
- expect(getProtocolV2BleTuning().nativeFrameWrite).toBe(true);
167
- configureProtocolV2BleTuning({ androidPacketLength: 200 });
168
- expect(getProtocolV2BleTuning().nativeFrameWrite).toBe(true);
169
- configureProtocolV2BleTuning({ nativeFrameWrite: false });
170
- configureProtocolV2BleTuning({ iosPacketLength: 200 });
171
- expect(getProtocolV2BleTuning().nativeFrameWrite).toBe(false);
172
- });
173
-
174
- test.each(['ios', 'android'] as const)(
175
- 'writes each multi-packet high-throughput frame with one native call on %s',
176
- async platform => {
177
- setPlatformOS(platform);
178
- const manager = createFrameManager();
179
- const { transport, bleTransport, writeWithoutResponse, writeWithResponse } = createUnit({
180
- manager,
181
- });
182
- const { context } = createContext();
183
- const first = createFrame(600);
184
- const second = createFrame(1855);
185
-
186
- await transport.writeProtocolV2Frame('dev', bleTransport, first, context, jest.fn());
187
- await transport.writeProtocolV2Frame('dev', bleTransport, second, context, jest.fn());
188
-
189
- const { calls } = manager.writeCharacteristicWithoutResponseFrame.mock;
190
- expect(calls).toHaveLength(2);
191
- expect(calls[0]).toEqual([
192
- 42,
193
- Buffer.from(first).toString('base64'),
194
- PACKET_CAPACITY,
195
- expect.stringMatching(FRAME_TX_PATTERN),
196
- ]);
197
- expect(calls[1]).toEqual([
198
- 42,
199
- Buffer.from(second).toString('base64'),
200
- PACKET_CAPACITY,
201
- expect.stringMatching(FRAME_TX_PATTERN),
202
- ]);
203
- expect(calls[0][3]).not.toBe(calls[1][3]);
204
- expect(writeWithoutResponse).not.toHaveBeenCalled();
205
- expect(writeWithResponse).not.toHaveBeenCalled();
206
- expect(manager.cancelTransaction).not.toHaveBeenCalled();
207
- expect(transport.protocolV2FrameWrites.size).toBe(0);
208
- }
209
- );
210
-
211
- test.each([
212
- ['the JS wrapper reports no native support', () => createFrameManager({ supported: false })],
213
- [
214
- 'the support check throws',
215
- () =>
216
- createFrameManager({
217
- supported: () => {
218
- throw new TypeError('native module missing');
219
- },
220
- }),
221
- ],
222
- ['ble-plx is unpatched', () => ({ cancelTransaction: jest.fn(() => Promise.resolve()) })],
223
- [
224
- 'the wrapper reports support without the frame method',
225
- () => ({
226
- isWriteCharacteristicWithoutResponseFrameSupported: jest.fn(() => true),
227
- cancelTransaction: jest.fn(() => Promise.resolve()),
228
- }),
229
- ],
230
- ])('keeps the per-packet path when %s', async (_label, createManager) => {
231
- const manager = createManager() as {
232
- writeCharacteristicWithoutResponseFrame?: jest.Mock;
233
- };
234
- const { transport, bleTransport, writeWithoutResponse } = createUnit({ manager });
235
- const { context } = createContext();
236
-
237
- await expect(
238
- transport.writeProtocolV2Frame('dev', bleTransport, createFrame(600), context, jest.fn())
239
- ).resolves.toBeUndefined();
240
-
241
- expect(writeWithoutResponse).toHaveBeenCalledTimes(3);
242
- expect(manager.writeCharacteristicWithoutResponseFrame ?? jest.fn()).not.toHaveBeenCalled();
243
- });
244
-
245
- test('keeps the per-packet path when the native frame write tuning is off', async () => {
246
- configureProtocolV2BleTuning({ nativeFrameWrite: false });
247
- const manager = createFrameManager();
248
- const { transport, bleTransport, writeWithoutResponse } = createUnit({ manager });
249
- const { context } = createContext();
250
-
251
- await transport.writeProtocolV2Frame('dev', bleTransport, createFrame(600), context, jest.fn());
252
-
253
- expect(writeWithoutResponse).toHaveBeenCalledTimes(3);
254
- expect(manager.writeCharacteristicWithoutResponseFrame).not.toHaveBeenCalled();
255
- });
256
-
257
- test.each([
258
- ['a with-response write', { writeWithResponse: true }, 600, 'writeWithResponse', 3],
259
- ['a non-high-throughput frame', { highThroughput: false }, 600, 'writeWithoutResponse', 3],
260
- ['a single-packet frame', {}, PACKET_CAPACITY, 'writeWithoutResponse', 1],
261
- ] as const)(
262
- 'keeps the per-packet path for %s',
263
- async (_label, overrides, frameLength, packetWrite, packets) => {
264
- const manager = createFrameManager();
265
- const unit = createUnit({ manager });
266
- const { context } = createContext(overrides);
267
-
268
- await unit.transport.writeProtocolV2Frame(
269
- 'dev',
270
- unit.bleTransport,
271
- createFrame(frameLength),
272
- context,
273
- jest.fn()
274
- );
275
-
276
- expect(unit[packetWrite]).toHaveBeenCalledTimes(packets);
277
- expect(manager.writeCharacteristicWithoutResponseFrame).not.toHaveBeenCalled();
278
- }
279
- );
280
-
281
- test('keeps the per-packet path when the characteristic has no native identifier', async () => {
282
- const manager = createFrameManager();
283
- const { transport, bleTransport, writeWithoutResponse } = createUnit({
284
- manager,
285
- characteristicId: null,
286
- });
287
- const { context } = createContext();
288
-
289
- await transport.writeProtocolV2Frame('dev', bleTransport, createFrame(600), context, jest.fn());
290
-
291
- expect(writeWithoutResponse).toHaveBeenCalledTimes(3);
292
- expect(manager.writeCharacteristicWithoutResponseFrame).not.toHaveBeenCalled();
293
- });
294
- });
295
-
296
- describe('Protocol V2 native frame write failures', () => {
297
- test('cancels the frame transaction once when the call aborts', async () => {
298
- let rejectNative: (error: unknown) => void = () => undefined;
299
- const manager = createFrameManager({
300
- write: () =>
301
- new Promise<void>((_, reject) => {
302
- rejectNative = reject;
303
- }),
304
- });
305
- const { transport, bleTransport } = createUnit({ manager });
306
- const { controller, context } = createContext();
307
-
308
- const write = transport.writeProtocolV2Frame(
309
- 'dev',
310
- bleTransport,
311
- createFrame(600),
312
- context,
313
- jest.fn()
314
- );
315
- const rejection = expect(write).rejects.toThrow(
316
- 'Protocol V2 BLE write aborted for FilesystemFileWrite'
317
- );
318
- await flush();
319
- controller.abort();
320
- await rejection;
321
-
322
- const [[, , , transactionId]] = manager.writeCharacteristicWithoutResponseFrame.mock.calls;
323
- expect(manager.cancelTransaction).toHaveBeenCalledTimes(1);
324
- expect(manager.cancelTransaction).toHaveBeenCalledWith(transactionId);
325
- // The cancelled native write settles late; it must neither surface nor cancel again.
326
- rejectNative({ errorCode: 2, message: 'Operation was cancelled' });
327
- await transport.disconnect('dev');
328
- expect(frameCancellations(manager)).toHaveLength(1);
329
- });
330
-
331
- test('does not start a native frame write once the call is aborted', async () => {
332
- const manager = createFrameManager();
333
- const { transport, bleTransport } = createUnit({ manager });
334
- const { controller, context } = createContext();
335
- controller.abort();
336
-
337
- await expect(
338
- transport.writeProtocolV2Frame('dev', bleTransport, createFrame(600), context, jest.fn())
339
- ).rejects.toThrow('Protocol V2 BLE write aborted for FilesystemFileWrite');
340
- expect(manager.writeCharacteristicWithoutResponseFrame).not.toHaveBeenCalled();
341
- expect(manager.cancelTransaction).not.toHaveBeenCalled();
342
- });
343
-
344
- test('cancels the frame transaction once when the generation changes mid-frame', async () => {
345
- let resolveNative: () => void = () => undefined;
346
- const manager = createFrameManager({
347
- write: () =>
348
- new Promise<void>(resolve => {
349
- resolveNative = resolve;
350
- }),
351
- });
352
- const { transport, bleTransport } = createUnit({ manager });
353
- const { context } = createContext();
354
- const generation = createGenerationGuard();
355
-
356
- const write = transport.writeProtocolV2Frame(
357
- 'dev',
358
- bleTransport,
359
- createFrame(600),
360
- context,
361
- generation.assert
362
- );
363
- const rejection = expect(write).rejects.toThrow('Protocol V2 monitor generation changed');
364
- await flush();
365
- generation.change();
366
- resolveNative();
367
- await rejection;
368
-
369
- const [[, , , transactionId]] = manager.writeCharacteristicWithoutResponseFrame.mock.calls;
370
- expect(manager.cancelTransaction).toHaveBeenCalledTimes(1);
371
- expect(manager.cancelTransaction).toHaveBeenCalledWith(transactionId);
372
- });
373
-
374
- test('cancels a frame of an invalidated link only for its own generation', async () => {
375
- const manager = createFrameManager({ write: () => neverSettles() });
376
- const { transport, bleTransport } = createUnit({ manager });
377
- const { context } = createContext();
378
-
379
- const write = transport.writeProtocolV2Frame(
380
- 'dev',
381
- bleTransport,
382
- createFrame(600),
383
- context,
384
- jest.fn()
385
- );
386
- const rejection = expect(write).rejects.toThrow('link reset');
387
- await flush();
388
- transport.cancelProtocolV2FrameWrite('dev', new Error('older link reset'), 2);
389
- expect(manager.cancelTransaction).not.toHaveBeenCalled();
390
- transport.cancelProtocolV2FrameWrite('dev', new Error('link reset'), 3);
391
- await rejection;
392
- expect(manager.cancelTransaction).toHaveBeenCalledTimes(1);
393
- });
394
-
395
- test('cancels the in-flight frame before a BLE manager reset destroys the manager', async () => {
396
- const manager = createFrameManager({ write: () => neverSettles() });
397
- const { transport, bleTransport } = createUnit({ manager });
398
- const { context } = createContext();
399
-
400
- const write = transport.writeProtocolV2Frame(
401
- 'dev',
402
- bleTransport,
403
- createFrame(600),
404
- context,
405
- jest.fn()
406
- );
407
- const rejection = expect(write).rejects.toThrow('React Native BLE manager reset');
408
- await flush();
409
- transport.resetPlxManager();
410
- await rejection;
411
-
412
- expect(manager.cancelTransaction).toHaveBeenCalledTimes(1);
413
- expect(manager.destroy).toHaveBeenCalledTimes(1);
414
- expect(manager.cancelTransaction.mock.invocationCallOrder[0]).toBeLessThan(
415
- manager.destroy.mock.invocationCallOrder[0]
416
- );
417
- await flush();
418
- });
419
-
420
- test('does not retry a native frame that fails with congestion', async () => {
421
- const manager = createFrameManager({
422
- write: () => Promise.reject(Object.assign(new Error('GATT_CONGESTED'), { status: 143 })),
423
- });
424
- const { transport, bleTransport, writeWithoutResponse } = createUnit({ manager });
425
- const { context } = createContext();
426
-
427
- await expect(
428
- transport.writeProtocolV2Frame('dev', bleTransport, createFrame(600), context, jest.fn())
429
- ).rejects.toMatchObject({ errorCode: HardwareErrorCode.BleWriteCharacteristicError });
430
-
431
- expect(manager.writeCharacteristicWithoutResponseFrame).toHaveBeenCalledTimes(1);
432
- expect(writeWithoutResponse).not.toHaveBeenCalled();
433
- expect(manager.cancelTransaction).not.toHaveBeenCalled();
434
- });
435
-
436
- test('maps a synchronous native failure to a link-fatal write error', async () => {
437
- const manager = createFrameManager({
438
- write: () => {
439
- throw new TypeError('native method missing');
440
- },
441
- });
442
- const { transport, bleTransport } = createUnit({ manager });
443
- const { context } = createContext();
444
-
445
- await expect(
446
- transport.writeProtocolV2Frame('dev', bleTransport, createFrame(600), context, jest.fn())
447
- ).rejects.toMatchObject({ errorCode: HardwareErrorCode.BleWriteCharacteristicError });
448
- expect(transport.protocolV2FrameWrites.size).toBe(0);
449
- });
450
-
451
- test.each([
452
- ['ble-plx', { errorCode: 201, reason: 'Device dev was disconnected' }],
453
- ['CoreBluetooth', { errorCode: 0, iosErrorCode: 7, message: 'Peripheral disconnected' }],
454
- ])('maps a %s native disconnect to the BLE disconnect error', async (_label, nativeError) => {
455
- const manager = createFrameManager({ write: () => Promise.reject(nativeError) });
456
- const { transport, bleTransport } = createUnit({ manager });
457
- const { context } = createContext();
458
-
459
- await expect(
460
- transport.writeProtocolV2Frame('dev', bleTransport, createFrame(600), context, jest.fn())
461
- ).rejects.toMatchObject({ errorCode: HardwareErrorCode.BleDeviceDisconnected });
462
- expect(manager.writeCharacteristicWithoutResponseFrame).toHaveBeenCalledTimes(1);
463
- });
464
-
465
- describe('watchdog', () => {
466
- beforeEach(() => {
467
- jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
468
- });
469
-
470
- afterEach(() => {
471
- jest.clearAllTimers();
472
- jest.useRealTimers();
473
- });
474
-
475
- test('cancels a wedged frame once and tears the link down', async () => {
476
- const manager = createFrameManager({ write: () => neverSettles() });
477
- const { transport, bleTransport } = createUnit({ manager });
478
- const disconnect = jest.spyOn(transport, 'disconnect').mockResolvedValue(undefined);
479
- const { context } = createContext();
480
-
481
- const write = transport.writeProtocolV2Frame(
482
- 'dev',
483
- bleTransport,
484
- createFrame(600),
485
- context,
486
- jest.fn()
487
- );
488
- const rejection = expect(write).rejects.toMatchObject({
489
- errorCode: HardwareErrorCode.BleWriteCharacteristicError,
490
- message: `BLE write timeout after ${BLE_WRITE_PACKET_TIMEOUT_MS}ms`,
491
- });
492
- jest.advanceTimersByTime(BLE_WRITE_PACKET_TIMEOUT_MS - 1);
493
- expect(manager.cancelTransaction).not.toHaveBeenCalled();
494
- jest.advanceTimersByTime(1);
495
- await rejection;
496
-
497
- const [[, , , transactionId]] = manager.writeCharacteristicWithoutResponseFrame.mock.calls;
498
- expect(manager.cancelTransaction).toHaveBeenCalledTimes(1);
499
- expect(manager.cancelTransaction).toHaveBeenCalledWith(transactionId);
500
- expect(disconnect).toHaveBeenCalledTimes(1);
501
- expect(disconnect).toHaveBeenCalledWith('dev');
502
- });
503
-
504
- test('cancels a superseded wedged frame without tearing down the current link', async () => {
505
- const manager = createFrameManager({ write: () => neverSettles() });
506
- const { transport, bleTransport } = createUnit({ manager });
507
- const disconnect = jest.spyOn(transport, 'disconnect').mockResolvedValue(undefined);
508
- const { context } = createContext();
509
- const generation = createGenerationGuard();
510
-
511
- const write = transport.writeProtocolV2Frame(
512
- 'dev',
513
- bleTransport,
514
- createFrame(600),
515
- context,
516
- generation.assert
517
- );
518
- const rejection = expect(write).rejects.toMatchObject({
519
- errorCode: HardwareErrorCode.BleWriteCharacteristicError,
520
- });
521
- generation.change();
522
- jest.advanceTimersByTime(BLE_WRITE_PACKET_TIMEOUT_MS);
523
- await rejection;
524
-
525
- expect(manager.cancelTransaction).toHaveBeenCalledTimes(1);
526
- expect(disconnect).not.toHaveBeenCalled();
527
- });
528
- });
529
- });
530
-
531
- describe('Protocol V1 never uses the native frame write', () => {
532
- test('keeps Protocol V1 writes on the per-packet path', async () => {
533
- const uuid = 'v1-device';
534
- const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
535
- transport.configure(protocolV1SchemaFixture);
536
- transport.deviceProtocol.set(uuid, 'V1');
537
- const manager = createFrameManager();
538
- transport.blePlxManager = manager;
539
- const writeWithoutResponse = jest.fn(() => Promise.resolve());
540
- const writeWithRetry = jest.fn(() => Promise.resolve());
541
- transport.getCachedTransport = () => ({
542
- mtuSize: 247,
543
- writeCharacteristic: {
544
- id: 42,
545
- isWritableWithResponse: false,
546
- isWritableWithoutResponse: true,
547
- writeWithResponse: jest.fn(),
548
- writeWithoutResponse,
549
- },
550
- writeWithRetry,
551
- });
552
- jest.spyOn(transport, 'disconnect').mockResolvedValue(undefined);
553
-
554
- await expect(
555
- transport.call(uuid, 'FirmwareUpload', { payload: new Uint8Array(2000) }, { timeoutMs: 50 })
556
- ).rejects.toMatchObject({ errorCode: HardwareErrorCode.BleTimeoutError });
557
- await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).rejects.toMatchObject({
558
- errorCode: HardwareErrorCode.BleTimeoutError,
559
- });
560
-
561
- expect(writeWithRetry.mock.calls.length).toBeGreaterThan(1);
562
- expect(writeWithoutResponse).toHaveBeenCalled();
563
- expect(manager.writeCharacteristicWithoutResponseFrame).not.toHaveBeenCalled();
564
- expect(manager.isWriteCharacteristicWithoutResponseFrameSupported).not.toHaveBeenCalled();
565
- });
566
- });
567
-
568
- const protocolV1Schema = {
569
- nested: {
570
- Initialize: { fields: {} },
571
- GetFeatures: { fields: {} },
572
- Success: { fields: { message: { type: 'string', id: 1 } } },
573
- Failure: { fields: { code: { type: 'uint32', id: 1 }, message: { type: 'string', id: 2 } } },
574
- MessageType: {
575
- values: {
576
- MessageType_Initialize: 0,
577
- MessageType_Success: 2,
578
- MessageType_Failure: 3,
579
- MessageType_GetFeatures: 55,
580
- },
581
- },
582
- },
583
- };
584
-
585
- const protocolV2Schema = {
586
- nested: {
587
- Ping: { fields: { message: { type: 'string', id: 1 } } },
588
- Success: { fields: { message: { type: 'string', id: 1 } } },
589
- Failure: {
590
- fields: {
591
- code: { type: 'uint32', id: 1 },
592
- subcode: { type: 'uint32', id: 2 },
593
- message: { type: 'string', id: 3 },
594
- },
595
- },
596
- FilesystemFile: {
597
- fields: {
598
- path: { type: 'string', id: 1 },
599
- offset: { type: 'uint32', id: 2 },
600
- total_size: { type: 'uint32', id: 3 },
601
- data: { type: 'bytes', id: 4 },
602
- processed_byte: { type: 'uint32', id: 6 },
603
- },
604
- },
605
- FilesystemFileWrite: {
606
- fields: {
607
- file: { type: 'FilesystemFile', id: 1 },
608
- overwrite: { type: 'bool', id: 2 },
609
- append: { type: 'bool', id: 3 },
610
- },
611
- },
612
- MessageType: {
613
- values: {
614
- MessageType_Ping: 60206,
615
- MessageType_Success: 60207,
616
- MessageType_Failure: 60208,
617
- MessageType_FilesystemFile: 60803,
618
- MessageType_FilesystemFileWrite: 60805,
619
- },
620
- },
621
- },
622
- };
623
-
624
- const schemas = {
625
- protocolV1: parseConfigure(protocolV1Schema),
626
- protocolV2: parseConfigure(protocolV2Schema),
627
- };
628
-
629
- const FILE_PATH = 'vol0:/test-app.bin';
630
- const CHUNK_BYTES = 1800;
631
-
632
- const fileChunks = (totalSize: number) => {
633
- const chunks: Record<string, unknown>[] = [];
634
- for (let offset = 0; offset < totalSize; offset += CHUNK_BYTES) {
635
- chunks.push({
636
- file: {
637
- path: FILE_PATH,
638
- offset,
639
- total_size: totalSize,
640
- data: new Uint8Array(Math.min(CHUNK_BYTES, totalSize - offset)),
641
- },
642
- overwrite: offset === 0,
643
- append: false,
644
- });
645
- }
646
- return chunks;
647
- };
648
-
649
- /** A Pro2-like peripheral that reassembles written frames and answers Ping and file writes. */
650
- const createLinkHarness = ({
651
- nativeFrameSupported,
652
- holdFileWrites = false,
653
- }: {
654
- nativeFrameSupported: boolean;
655
- holdFileWrites?: boolean;
656
- }) => {
657
- const uuid = 'dev';
658
- const assembler = new ProtocolV2FrameAssembler(PROTOCOL_V2_BLE_FRAME_MAX_BYTES);
659
- const writtenFrames: number[] = [];
660
- let responseSeq = 0;
661
- let notifyCallback:
662
- | ((error: Error | null, characteristic: { value: string } | null) => void)
663
- | undefined;
664
- const respond = (name: string, message: Record<string, unknown>) => {
665
- responseSeq += 1;
666
- const response = ProtocolV2.encodeFrame(schemas, name, message, {
667
- router: PROTOCOL_V2_CHANNEL_BLE_UART,
668
- seq: responseSeq,
669
- });
670
- notifyCallback?.(null, { value: Buffer.from(response).toString('base64') });
671
- };
672
- const receive = (bytes: Uint8Array) => {
673
- for (const frame of assembler.drain(bytes)) {
674
- writtenFrames.push(frame.length);
675
- const decoded = ProtocolV2.decodeFrame(schemas, frame);
676
- if (decoded.type === 'Ping') {
677
- respond('Success', { message: 'ok' });
678
- } else if (decoded.type === 'FilesystemFileWrite') {
679
- const { file } = decoded.message as {
680
- file: { path: string; offset: number; total_size: number; data: string };
681
- };
682
- // Decoded protobuf bytes are hex strings.
683
- respond('FilesystemFile', {
684
- path: file.path,
685
- offset: file.offset,
686
- total_size: file.total_size,
687
- processed_byte: Number(file.offset) + file.data.length / 2,
688
- });
689
- }
690
- }
691
- };
692
- const packetWrite = jest.fn((base64: string) => {
693
- receive(new Uint8Array(Buffer.from(base64, 'base64')));
694
- return Promise.resolve();
695
- });
696
- const writeCharacteristic = {
697
- id: 42,
698
- uuid: '0002',
699
- deviceID: uuid,
700
- isWritableWithResponse: true,
701
- isWritableWithoutResponse: true,
702
- writeWithResponse: packetWrite,
703
- writeWithoutResponse: packetWrite,
704
- };
705
- const notifyCharacteristic = {
706
- id: 43,
707
- uuid: '0003',
708
- deviceID: uuid,
709
- isNotifiable: true,
710
- monitor: jest.fn(callback => {
711
- notifyCallback = callback;
712
- return { remove: jest.fn() };
713
- }),
714
- };
715
- const device = {
716
- id: uuid,
717
- name: 'OneKey Pro 2',
718
- localName: 'OneKey Pro 2',
719
- mtu: 247,
720
- serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
721
- isConnected: jest.fn(() => Promise.resolve(true)),
722
- cancelConnection: jest.fn(() => Promise.resolve()),
723
- connect: jest.fn(),
724
- onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
725
- requestMTU: jest.fn(),
726
- requestConnectionPriority: jest.fn(),
727
- };
728
- device.connect.mockResolvedValue(device);
729
- device.requestMTU.mockResolvedValue(device);
730
- device.requestConnectionPriority.mockResolvedValue(device);
731
- const bleManager = {
732
- devices: jest.fn(() => Promise.resolve([device])),
733
- connectedDevices: jest.fn(() => Promise.resolve([])),
734
- cancelTransaction: jest.fn(() => Promise.resolve()),
735
- cancelDeviceConnection: jest.fn(() => Promise.resolve()),
736
- destroy: jest.fn(),
737
- isWriteCharacteristicWithoutResponseFrameSupported: jest.fn(() => nativeFrameSupported),
738
- writeCharacteristicWithoutResponseFrame: jest.fn(
739
- (_id: number, base64Frame: string, _packetSize: number, _transactionId: string) => {
740
- if (holdFileWrites) return neverSettles();
741
- receive(new Uint8Array(Buffer.from(base64Frame, 'base64')));
742
- return Promise.resolve();
743
- }
744
- ),
745
- };
746
- const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
747
- const logger = { debug: jest.fn(), error: jest.fn() };
748
- transport.blePlxManager = bleManager;
749
- transport.resolveCharacteristics = jest.fn(() =>
750
- Promise.resolve({ writeCharacteristic, notifyCharacteristic })
751
- );
752
- transport.init(logger, new EventEmitter());
753
- transport.configure(protocolV1Schema);
754
- transport.configureProtocolV2(protocolV2Schema);
755
-
756
- const writeFile = (totalSize: number, timeoutMs = 5000) => {
757
- const [first, ...rest] = fileChunks(totalSize);
758
- const confirmations: unknown[] = [];
759
- const call = transport.call(uuid, 'FilesystemFileWrite', first, {
760
- timeoutMs,
761
- fileWritePipeline: {
762
- next: () => Promise.resolve(rest.shift()),
763
- onResponse: (response: unknown) => confirmations.push(response),
764
- },
765
- }) as Promise<{ type: string }>;
766
- return { call, confirmations };
767
- };
768
-
769
- const logs = (message: string) =>
770
- logger.debug.mock.calls
771
- .filter(([logMessage]) => logMessage === message)
772
- .map(([, params]) => params as Record<string, unknown>);
773
-
774
- return { transport, uuid, bleManager, packetWrite, writtenFrames, writeFile, logs };
775
- };
776
-
777
- const expectScalarOnly = (value: unknown) => {
778
- if (Array.isArray(value)) {
779
- value.forEach(item => expect(typeof item).toBe('number'));
780
- return;
781
- }
782
- if (value && typeof value === 'object') {
783
- Object.values(value).forEach(item => expectScalarOnly(item));
784
- return;
785
- }
786
- expect(['number', 'string', 'boolean']).toContain(typeof value);
787
- };
788
-
789
- describe('Protocol V2 FileWrite perf summary', () => {
790
- test.each([
791
- ['ios', true, 'native-frame'],
792
- ['android', true, 'native-frame'],
793
- ['ios', false, 'per-packet'],
794
- ['android', false, 'per-packet'],
795
- ] as const)(
796
- 'logs one scalar summary per pipelined file write on %s (native support %s)',
797
- async (platform, nativeFrameSupported, mode) => {
798
- setPlatformOS(platform);
799
- const harness = createLinkHarness({ nativeFrameSupported });
800
- const { transport, uuid, bleManager, packetWrite, writtenFrames } = harness;
801
- await transport.acquire({ uuid, expectedProtocol: 'V2' });
802
- const probeFrames = writtenFrames.length;
803
- const probePacketWrites = packetWrite.mock.calls.length;
804
-
805
- try {
806
- const totalSize = 3 * CHUNK_BYTES + 500;
807
- const { call, confirmations } = harness.writeFile(totalSize);
808
- await expect(call).resolves.toMatchObject({ type: 'FilesystemFile' });
809
- expect(confirmations).toHaveLength(4);
810
- // A second pipelined write on the same link still logs its own summary.
811
- await expect(harness.writeFile(2 * CHUNK_BYTES).call).resolves.toMatchObject({
812
- type: 'FilesystemFile',
813
- });
814
-
815
- const fileFrames = writtenFrames.slice(probeFrames, probeFrames + 4);
816
- const expectedPackets = fileFrames.reduce(
817
- (sum, length) => sum + Math.ceil(length / PACKET_CAPACITY),
818
- 0
819
- );
820
- const summaries = harness.logs(PERF_MESSAGE);
821
- expect(summaries).toHaveLength(2);
822
- const [summary] = summaries;
823
- expect(Object.keys(summary).sort()).toEqual(
824
- [
825
- 'platform',
826
- 'mode',
827
- 'ok',
828
- 'frames',
829
- 'packets',
830
- 'frameBytes',
831
- 'elapsedMs',
832
- 'writeMs',
833
- 'readWaitMs',
834
- ...(mode === 'per-packet' ? ['packetMs'] : []),
835
- ].sort()
836
- );
837
- expect(summary).toMatchObject({
838
- platform,
839
- mode,
840
- ok: true,
841
- frames: 4,
842
- packets: expectedPackets,
843
- frameBytes: fileFrames.reduce((sum, length) => sum + length, 0),
844
- });
845
- expect(Object.keys(summary.writeMs as object).sort()).toEqual(['avg', 'max', 'total']);
846
- expect(Object.keys(summary.readWaitMs as object).sort()).toEqual(['avg', 'max', 'total']);
847
- if (mode === 'per-packet') {
848
- const packetMs = summary.packetMs as { hist: number[] };
849
- expect(Object.keys(packetMs).sort()).toEqual(['avg', 'hist', 'max']);
850
- expect(packetMs.hist).toHaveLength(6);
851
- expect(packetMs.hist.reduce((sum, count) => sum + count, 0)).toBe(expectedPackets);
852
- expect(bleManager.writeCharacteristicWithoutResponseFrame).not.toHaveBeenCalled();
853
- } else {
854
- expect(bleManager.writeCharacteristicWithoutResponseFrame).toHaveBeenCalledTimes(6);
855
- expect(packetWrite).toHaveBeenCalledTimes(probePacketWrites);
856
- }
857
- summaries.forEach(item => expectScalarOnly(item));
858
- expect(JSON.stringify(summaries)).not.toContain(FILE_PATH);
859
- expect(JSON.stringify(summaries)).not.toContain(uuid);
860
-
861
- const modeLogs = harness.logs(MODE_MESSAGE);
862
- expect(modeLogs).toHaveLength(1);
863
- expect(modeLogs[0]).toMatchObject({ platform, mode });
864
- } finally {
865
- await transport.release(uuid, true);
866
- }
867
- }
868
- );
869
-
870
- test('does not log a perf summary for writes outside the file write pipeline', async () => {
871
- const harness = createLinkHarness({ nativeFrameSupported: true });
872
- const { transport, uuid } = harness;
873
- await transport.acquire({ uuid, expectedProtocol: 'V2' });
874
-
875
- try {
876
- const [chunk] = fileChunks(CHUNK_BYTES);
877
- await expect(
878
- transport.call(uuid, 'FilesystemFileWrite', chunk, { timeoutMs: 5000 })
879
- ).resolves.toMatchObject({ type: 'FilesystemFile' });
880
- await transport.call(uuid, 'Ping', { message: 'control' }, { timeoutMs: 5000 });
881
-
882
- expect(harness.logs(PERF_MESSAGE)).toHaveLength(0);
883
- expect(harness.bleManager.writeCharacteristicWithoutResponseFrame).toHaveBeenCalledTimes(1);
884
- } finally {
885
- await transport.release(uuid, true);
886
- }
887
- });
888
-
889
- test('cancels the in-flight frame once when the link is released and logs a failed summary', async () => {
890
- const harness = createLinkHarness({ nativeFrameSupported: true, holdFileWrites: true });
891
- const { transport, uuid, bleManager } = harness;
892
- await transport.acquire({ uuid, expectedProtocol: 'V2' });
893
-
894
- const { call } = harness.writeFile(3 * CHUNK_BYTES);
895
- const rejection = expect(call).rejects.toThrow('React Native BLE transport released');
896
- // Bounded so a regression fails this test instead of keeping the jest worker alive.
897
- for (
898
- let attempt = 0;
899
- attempt < 50 && bleManager.writeCharacteristicWithoutResponseFrame.mock.calls.length < 1;
900
- attempt += 1
901
- ) {
902
- // eslint-disable-next-line no-await-in-loop
903
- await flush();
904
- }
905
- expect(bleManager.writeCharacteristicWithoutResponseFrame).toHaveBeenCalledTimes(1);
906
- await transport.release(uuid, true);
907
- await rejection;
908
-
909
- const [[, , , transactionId]] = bleManager.writeCharacteristicWithoutResponseFrame.mock.calls;
910
- expect(transactionId).toMatch(new RegExp(`^${uuid}:v2frame:\\d+:\\d+$`));
911
- expect(frameCancellations(bleManager)).toEqual([[transactionId]]);
912
- expect(bleManager.writeCharacteristicWithoutResponseFrame).toHaveBeenCalledTimes(1);
913
- const summaries = harness.logs(PERF_MESSAGE);
914
- expect(summaries).toHaveLength(1);
915
- expect(summaries[0]).toMatchObject({ mode: 'native-frame', ok: false, frames: 0 });
916
- });
917
- });