@onekeyfe/hd-transport-react-native 1.2.8-alpha.10 → 1.2.8-alpha.100

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,307 +0,0 @@
1
- import EventEmitter from 'events';
2
-
3
- import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
4
-
5
- import ReactNativeBleTransport, {
6
- ANDROID_KEY_MISSING_GRACE_MS,
7
- ANDROID_KEY_MISSING_LINK_WINDOW_MS,
8
- } from '../index';
9
- import { SYSTEM_BONDING_RESTART_WINDOW_MS, onDeviceBondState } from '../BleManager';
10
- import { stopBleKeyMissingTracking } from '../bleKeyMissing';
11
- import protocolV1Schema from './protocolV1SchemaFixture';
12
-
13
- let mockKeyMissingSupported = true;
14
- let mockEmitKeyMissing: ((event: { id?: string }) => void) | undefined;
15
- let mockEmitBondState: ((peripheral: unknown) => void) | undefined;
16
-
17
- jest.mock(
18
- 'react-native',
19
- () => ({
20
- Platform: { OS: 'android', select: (spec: Record<string, unknown>) => spec.android },
21
- PermissionsAndroid: {
22
- PERMISSIONS: {},
23
- RESULTS: {},
24
- request: jest.fn(),
25
- requestMultiple: jest.fn(),
26
- },
27
- }),
28
- { virtual: true }
29
- );
30
-
31
- jest.mock('react-native-ble-plx', () => ({
32
- BleATTErrorCode: { InvalidHandle: 1 },
33
- BleError: Error,
34
- BleErrorCode: { DeviceDisconnected: 201, OperationStartFailed: 601 },
35
- BleManager: jest.fn(),
36
- ScanMode: { LowLatency: 2 },
37
- }));
38
-
39
- jest.mock('@onekeyfe/react-native-ble-utils', () => ({
40
- __esModule: true,
41
- default: {
42
- getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
43
- getBondedPeripherals: jest.fn(() => Promise.resolve([])),
44
- pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
45
- supportsDeviceKeyMissing: jest.fn(() => mockKeyMissingSupported),
46
- onDeviceKeyMissing: jest.fn((callback: (event: { id?: string }) => void) => {
47
- mockEmitKeyMissing = callback;
48
- return () => {
49
- mockEmitKeyMissing = undefined;
50
- };
51
- }),
52
- onDeviceBondState: jest.fn((callback: (peripheral: unknown) => void) => {
53
- mockEmitBondState = callback;
54
- return () => {
55
- mockEmitBondState = undefined;
56
- };
57
- }),
58
- },
59
- }));
60
-
61
- const UUID = 'CC:06:1C:FD:48:E9';
62
-
63
- const flush = () =>
64
- new Promise(resolve => {
65
- setImmediate(resolve);
66
- });
67
-
68
- const advance = async (ms: number) => {
69
- jest.advanceTimersByTime(ms);
70
- await flush();
71
- };
72
-
73
- // What ble-plx reports when the device drops the link while the first write is queued.
74
- const peerTerminated = () =>
75
- Promise.reject(
76
- Object.assign(new Error(`Device ${UUID} was disconnected`), {
77
- errorCode: 201,
78
- attErrorCode: 19,
79
- reason: 'Disconnected with status 19 (GATT_CONN_TERMINATE_PEER_USER)',
80
- })
81
- );
82
-
83
- function createConnectedTransport(linkAgeMs = 0) {
84
- const t = new ReactNativeBleTransport({});
85
- t.configure(protocolV1Schema);
86
- (t as any).deviceProtocol.set(UUID, 'V1');
87
- (t as any).getCachedTransport = () => ({
88
- writeCharacteristic: { writeWithoutResponse: jest.fn(peerTerminated) },
89
- });
90
- (t as any).androidLinkStartedAt.set(UUID, Date.now() - linkAgeMs);
91
- return t;
92
- }
93
-
94
- const settle = (promise: Promise<unknown>) => {
95
- const outcome: { error?: { errorCode?: unknown }; done: boolean } = { done: false };
96
- promise.then(
97
- () => {
98
- outcome.done = true;
99
- },
100
- error => {
101
- outcome.error = error;
102
- outcome.done = true;
103
- }
104
- );
105
- return outcome;
106
- };
107
-
108
- describe('Android key missing', () => {
109
- beforeEach(() => {
110
- jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
111
- mockKeyMissingSupported = true;
112
- });
113
-
114
- afterEach(() => {
115
- stopBleKeyMissingTracking();
116
- jest.clearAllTimers();
117
- jest.useRealTimers();
118
- });
119
-
120
- describe('link dropped right after connect', () => {
121
- test('reports an invalid bond when the system says the keys are missing', async () => {
122
- const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
123
- await flush();
124
- // The broadcast is delivered separately and can trail the GATT disconnect.
125
- mockEmitKeyMissing?.({ id: UUID.toLowerCase() });
126
- await flush();
127
-
128
- expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
129
- });
130
-
131
- test('keeps the original error when no key missing follows', async () => {
132
- const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
133
- await flush();
134
- expect(outcome.done).toBe(false);
135
-
136
- await advance(ANDROID_KEY_MISSING_GRACE_MS);
137
-
138
- expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
139
- });
140
-
141
- test('ignores key missing reported for an earlier link', async () => {
142
- const transport = createConnectedTransport();
143
- const earlier = settle(transport.call(UUID, 'GetFeatures', {}));
144
- await flush();
145
- mockEmitKeyMissing?.({ id: UUID });
146
- await flush();
147
- expect(earlier.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
148
-
149
- // The user re-paired; a later link that drops is an ordinary disconnect.
150
- await advance(1000);
151
- (transport as any).androidLinkStartedAt.set(UUID, Date.now());
152
- const later = settle(transport.call(UUID, 'GetFeatures', {}));
153
- await flush();
154
- await advance(ANDROID_KEY_MISSING_GRACE_MS);
155
-
156
- expect(later.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
157
- });
158
-
159
- test('ignores key missing for another device', async () => {
160
- const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
161
- await flush();
162
- mockEmitKeyMissing?.({ id: 'E9:B9:F4:DD:DE:CD' });
163
- await advance(ANDROID_KEY_MISSING_GRACE_MS);
164
-
165
- expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
166
- });
167
-
168
- test('does not wait on a link that has been up for a while', async () => {
169
- const transport = createConnectedTransport(ANDROID_KEY_MISSING_LINK_WINDOW_MS + 1);
170
- const outcome = settle(transport.call(UUID, 'GetFeatures', {}));
171
- await flush();
172
-
173
- expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
174
- });
175
-
176
- test('does not wait when the OS or native build never reports key missing', async () => {
177
- mockKeyMissingSupported = false;
178
- const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
179
- await flush();
180
-
181
- expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
182
- });
183
- });
184
-
185
- describe('acquire over a bond the device no longer holds', () => {
186
- // Android still reports BONDED, so connect, MTU and GATT setup all succeed and the
187
- // protocol probe is the first operation to meet the dropped link.
188
- function createStaleBondHarness() {
189
- const writeCharacteristic = {
190
- uuid: '00000002-0000-1000-8000-00805f9b34fb',
191
- isWritableWithoutResponse: true,
192
- writeWithoutResponse: jest.fn(peerTerminated),
193
- };
194
- const notifyCharacteristic = {
195
- uuid: '00000003-0000-1000-8000-00805f9b34fb',
196
- isNotifiable: true,
197
- monitor: jest.fn(() => ({ remove: jest.fn() })),
198
- };
199
- const device = {
200
- id: UUID,
201
- name: 'Pro 2 48E9',
202
- localName: 'Pro 2 48E9',
203
- mtu: 247,
204
- serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
205
- isConnected: jest.fn(() => Promise.resolve(true)),
206
- cancelConnection: jest.fn(() => Promise.resolve()),
207
- discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
208
- characteristicsForService: jest.fn(() =>
209
- Promise.resolve([writeCharacteristic, notifyCharacteristic])
210
- ),
211
- services: jest.fn(() => Promise.resolve([])),
212
- onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
213
- };
214
- const transport = new ReactNativeBleTransport({});
215
- (transport as any).blePlxManager = {
216
- devices: jest.fn(() => Promise.resolve([device])),
217
- connectedDevices: jest.fn(() => Promise.resolve([])),
218
- cancelTransaction: jest.fn(() => Promise.resolve()),
219
- cancelDeviceConnection: jest.fn(() => Promise.resolve()),
220
- onStateChange: jest.fn((listener: (state: string) => void) => {
221
- setImmediate(() => listener('PoweredOn'));
222
- return { remove: jest.fn() };
223
- }),
224
- state: jest.fn(() => Promise.resolve('PoweredOn')),
225
- };
226
- transport.init(
227
- { debug: jest.fn(), error: jest.fn(), warn: jest.fn() } as any,
228
- new EventEmitter()
229
- );
230
- transport.configure(protocolV1Schema);
231
- return { transport, write: writeCharacteristic.writeWithoutResponse };
232
- }
233
-
234
- async function acquireUntilSettled(keyMissing: boolean) {
235
- const { transport, write } = createStaleBondHarness();
236
- const outcome = settle(transport.acquire({ uuid: UUID }));
237
- for (let i = 0; i < 100 && !outcome.done; i += 1) {
238
- // eslint-disable-next-line no-await-in-loop
239
- await advance(100);
240
- // The broadcast follows the dropped link, which the probe write is first to meet.
241
- if (keyMissing && write.mock.calls.length > 0) mockEmitKeyMissing?.({ id: UUID });
242
- }
243
- expect(write).toHaveBeenCalled();
244
- return JSON.parse(JSON.stringify(ERRORS.serializeError({ error: outcome.error })));
245
- }
246
-
247
- test('ends as an invalid bond that survives the Core response path', async () => {
248
- await expect(acquireUntilSettled(true)).resolves.toEqual({
249
- code: HardwareErrorCode.BleBondInvalid,
250
- error: expect.stringContaining('Forget the device'),
251
- params: { phase: 'connect', reason: 'key_missing' },
252
- });
253
- });
254
-
255
- test('keeps the legacy error when the system reports nothing', async () => {
256
- await expect(acquireUntilSettled(false)).resolves.toMatchObject({
257
- code: HardwareErrorCode.BleDeviceNotBonded,
258
- });
259
- });
260
- });
261
-
262
- describe('waiting for bonding', () => {
263
- const bondState = (preState: string, state: string) =>
264
- mockEmitBondState?.({ id: UUID, bondState: { preState, state } });
265
-
266
- test('fails as an invalid bond when the system re-pair ends in key missing', async () => {
267
- const outcome = settle(onDeviceBondState(UUID, undefined, { systemInitiated: true }));
268
- mockEmitKeyMissing?.({ id: UUID });
269
- await flush();
270
-
271
- expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
272
- });
273
-
274
- test('follows a system re-pair that replaces the bond', async () => {
275
- const outcome = settle(onDeviceBondState(UUID, undefined, { systemInitiated: true }));
276
- bondState('BOND_BONDING', 'BOND_NONE');
277
- bondState('BOND_NONE', 'BOND_BONDING');
278
- await advance(SYSTEM_BONDING_RESTART_WINDOW_MS);
279
- expect(outcome.done).toBe(false);
280
-
281
- bondState('BOND_BONDING', 'BOND_BONDED');
282
- await flush();
283
-
284
- expect(outcome.done).toBe(true);
285
- expect(outcome.error).toBeUndefined();
286
- });
287
-
288
- test('fails a system re-pair that ends without a bond', async () => {
289
- const outcome = settle(onDeviceBondState(UUID, undefined, { systemInitiated: true }));
290
- bondState('BOND_BONDING', 'BOND_NONE');
291
- await flush();
292
- expect(outcome.done).toBe(false);
293
-
294
- await advance(SYSTEM_BONDING_RESTART_WINDOW_MS);
295
-
296
- expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
297
- });
298
-
299
- test('fails a bonding this transport started as soon as it ends without a bond', async () => {
300
- const outcome = settle(onDeviceBondState(UUID));
301
- bondState('BOND_BONDING', 'BOND_NONE');
302
- await flush();
303
-
304
- expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
305
- });
306
- });
307
- });
@@ -1,47 +0,0 @@
1
- import { HardwareErrorCode } from '@onekeyfe/hd-shared';
2
-
3
- import { isNativeBleStaleBondError, toBleStaleBondHardwareError } from '../bleStaleBond';
4
-
5
- describe('native BLE stale bond mapping', () => {
6
- test.each([
7
- [
8
- { attErrorCode: 15, reason: 'Encryption is insufficient' },
9
- HardwareErrorCode.BleDeviceBondError,
10
- ],
11
- [
12
- { attErrorCode: 5, reason: 'GATT_INSUF_AUTHENTICATION' },
13
- HardwareErrorCode.BleDeviceBondError,
14
- ],
15
- [
16
- { androidErrorCode: 5, reason: 'Connection state changed with status 5' },
17
- HardwareErrorCode.BleDeviceBondError,
18
- ],
19
- [
20
- { androidErrorCode: 15, reason: 'Connection state changed with status 15' },
21
- HardwareErrorCode.BleDeviceBondError,
22
- ],
23
- [
24
- { iosErrorCode: 14, reason: 'Peer removed pairing information' },
25
- HardwareErrorCode.BlePeerRemovedPairingInformation,
26
- ],
27
- [
28
- { reason: 'peer removed pairing information' },
29
- HardwareErrorCode.BlePeerRemovedPairingInformation,
30
- ],
31
- [
32
- { message: 'PEER REMOVED PAIRING INFORMATION' },
33
- HardwareErrorCode.BlePeerRemovedPairingInformation,
34
- ],
35
- ])('maps %j to %s', (nativeError, errorCode) => {
36
- expect(isNativeBleStaleBondError(nativeError)).toBe(true);
37
- expect(toBleStaleBondHardwareError(nativeError)).toMatchObject({ errorCode });
38
- });
39
-
40
- test('does not treat the generic ATT unlikely error as a stale bond', () => {
41
- expect(isNativeBleStaleBondError({ attErrorCode: 14, reason: 'Unlikely error' })).toBe(false);
42
- });
43
-
44
- test('does not treat a generic disconnect as a stale bond', () => {
45
- expect(isNativeBleStaleBondError({ reason: 'Device disconnected' })).toBe(false);
46
- });
47
- });
@@ -1,318 +0,0 @@
1
- import EventEmitter from 'events';
2
- import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
3
-
4
- import ReactNativeBleTransport from '../index';
5
- import {
6
- IOS_PEER_TERMINATION_LINK_WINDOW_MS,
7
- IOS_PEER_TERMINATION_REPEAT_WINDOW_MS,
8
- IosPeerTerminationTracker,
9
- } from '../bleIosStaleBond';
10
- import protocolV1Schema from './protocolV1SchemaFixture';
11
-
12
- jest.mock(
13
- 'react-native',
14
- () => ({
15
- Platform: { OS: 'ios', select: (spec: Record<string, unknown>) => spec.ios },
16
- PermissionsAndroid: {
17
- PERMISSIONS: {},
18
- RESULTS: {},
19
- request: jest.fn(),
20
- requestMultiple: jest.fn(),
21
- },
22
- }),
23
- { virtual: true }
24
- );
25
-
26
- jest.mock('react-native-ble-plx', () => ({
27
- BleATTErrorCode: { InvalidHandle: 1, UnlikelyError: 14 },
28
- BleError: Error,
29
- BleErrorCode: {
30
- DeviceDisconnected: 201,
31
- OperationStartFailed: 601,
32
- DeviceMTUChangeFailed: 401,
33
- OperationCancelled: 2,
34
- OperationTimedOut: 3,
35
- DeviceAlreadyConnected: 203,
36
- },
37
- BleManager: jest.fn(),
38
- ScanMode: { LowLatency: 2 },
39
- }));
40
-
41
- jest.mock('@onekeyfe/react-native-ble-utils', () => ({
42
- __esModule: true,
43
- default: {
44
- getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
45
- getBondedPeripherals: jest.fn(() => Promise.resolve([])),
46
- pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
47
- onDeviceBondState: jest.fn(),
48
- },
49
- }));
50
-
51
- const UUID = '2146E74A-21CC-2EA6-2CE3-B4258520FD0F';
52
-
53
- // What ble-plx rejects the in-flight operation with when the device ends the link. An iPhone 17
54
- // reports a wiped device this way instead of CBErrorPeerRemovedPairingInformation.
55
- const nativeDisconnect = (iosErrorCode: number, reason: string) =>
56
- Object.assign(new Error(`Device ${UUID} was disconnected`), {
57
- errorCode: 201,
58
- iosErrorCode,
59
- reason,
60
- });
61
- const peerEndedLink = () => nativeDisconnect(7, 'The specified device has disconnected from us.');
62
- const linkTimedOut = () => nativeDisconnect(6, 'The connection has timed out unexpectedly.');
63
-
64
- function createHarness() {
65
- const writeCharacteristic = {
66
- uuid: '00000002-0000-1000-8000-00805f9b34fb',
67
- isWritableWithResponse: true,
68
- writeWithResponse: jest.fn(() => Promise.resolve()),
69
- };
70
- const notifyCharacteristic = {
71
- uuid: '00000003-0000-1000-8000-00805f9b34fb',
72
- isNotifiable: true,
73
- monitor: jest.fn(() => ({ remove: jest.fn() })),
74
- };
75
- const device = {
76
- id: UUID,
77
- name: 'Pro 2 48E9',
78
- localName: 'Pro 2 48E9',
79
- mtu: 247,
80
- serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
81
- isConnected: jest.fn(() => Promise.resolve(false)),
82
- cancelConnection: jest.fn(() => Promise.resolve()),
83
- connect: jest.fn(),
84
- discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
85
- characteristicsForService: jest.fn(() =>
86
- Promise.resolve([writeCharacteristic, notifyCharacteristic])
87
- ),
88
- services: jest.fn(() => Promise.resolve([])),
89
- onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
90
- };
91
- device.connect.mockImplementation(() => Promise.resolve(device));
92
- const transport = new ReactNativeBleTransport({});
93
- (transport as any).blePlxManager = {
94
- devices: jest.fn(() => Promise.resolve([device])),
95
- connectedDevices: jest.fn(() => Promise.resolve([])),
96
- connectToDevice: jest.fn(() => Promise.resolve(device)),
97
- cancelTransaction: jest.fn(() => Promise.resolve()),
98
- cancelDeviceConnection: jest.fn(() => Promise.resolve()),
99
- onStateChange: jest.fn((listener: (state: string) => void) => {
100
- setImmediate(() => listener('PoweredOn'));
101
- return { remove: jest.fn() };
102
- }),
103
- state: jest.fn(() => Promise.resolve('PoweredOn')),
104
- };
105
- const logger = { debug: jest.fn(), error: jest.fn(), warn: jest.fn() };
106
- transport.init(logger as any, new EventEmitter());
107
- transport.configure(protocolV1Schema);
108
- return { transport, device, writeCharacteristic, notifyCharacteristic, logger };
109
- }
110
-
111
- type Outcome = { code?: unknown; params?: unknown; native?: unknown };
112
-
113
- const flush = () =>
114
- new Promise(resolve => {
115
- setImmediate(resolve);
116
- });
117
-
118
- /** Runs one acquire to its end, moving the fake clock past the transport's own waits. */
119
- async function acquire(
120
- transport: ReactNativeBleTransport,
121
- input: Record<string, unknown> = {}
122
- ): Promise<Outcome> {
123
- let outcome: Outcome | undefined;
124
- transport.acquire({ uuid: UUID, ...input } as never).then(
125
- () => {
126
- outcome = {};
127
- },
128
- error => {
129
- const { code, params } = ERRORS.serializeError({ error });
130
- outcome = { code, params, native: (error as { iosErrorCode?: unknown }).iosErrorCode };
131
- }
132
- );
133
- for (let i = 0; i < 400 && !outcome; i += 1) {
134
- // eslint-disable-next-line no-await-in-loop
135
- await flush();
136
- if (!outcome) jest.advanceTimersByTime(100);
137
- }
138
- if (!outcome) throw new Error('acquire did not settle');
139
- return outcome;
140
- }
141
-
142
- describe('iOS link ended by the device right after connecting', () => {
143
- beforeEach(() => {
144
- jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance', 'nextTick'] });
145
- });
146
-
147
- afterEach(() => {
148
- jest.clearAllTimers();
149
- jest.useRealTimers();
150
- });
151
-
152
- test('keeps the first error so Core retries, then reports an invalid bond', async () => {
153
- const { transport, device } = createHarness();
154
- device.discoverAllServicesAndCharacteristics.mockImplementation(() =>
155
- Promise.reject(peerEndedLink())
156
- );
157
-
158
- // Core retries an error it cannot classify, which is what makes the second attempt.
159
- await expect(acquire(transport)).resolves.toEqual({ native: 7 });
160
- await expect(acquire(transport)).resolves.toEqual({
161
- code: HardwareErrorCode.BleBondInvalid,
162
- params: { phase: 'connect', reason: 'peer_disconnected' },
163
- });
164
- // The verdict consumes the evidence, so the next one needs two attempts again.
165
- await expect(acquire(transport)).resolves.toEqual({ native: 7 });
166
- });
167
-
168
- test('counts a drop that interrupts the first write the same way', async () => {
169
- const { transport, writeCharacteristic } = createHarness();
170
- writeCharacteristic.writeWithResponse.mockImplementation(() => Promise.reject(peerEndedLink()));
171
-
172
- await expect(acquire(transport)).resolves.toMatchObject({
173
- code: HardwareErrorCode.BleDeviceNotBonded,
174
- });
175
- await expect(acquire(transport)).resolves.toMatchObject({
176
- code: HardwareErrorCode.BleBondInvalid,
177
- });
178
- });
179
-
180
- test('counts a drop that only the notification stream reports', async () => {
181
- const { transport, notifyCharacteristic } = createHarness();
182
- // The request went out before the link ended, so no write is there to fail.
183
- notifyCharacteristic.monitor.mockImplementation(((
184
- listener: (error: unknown, characteristic: unknown) => void
185
- ) => {
186
- setTimeout(() => listener(peerEndedLink(), null), 50);
187
- return { remove: jest.fn() };
188
- }) as never);
189
-
190
- await expect(acquire(transport)).resolves.not.toMatchObject({
191
- code: HardwareErrorCode.BleBondInvalid,
192
- });
193
- await expect(acquire(transport)).resolves.toMatchObject({
194
- code: HardwareErrorCode.BleBondInvalid,
195
- });
196
- });
197
-
198
- test('needs the second drop soon after the first', async () => {
199
- const { transport, device } = createHarness();
200
- device.discoverAllServicesAndCharacteristics.mockImplementation(() =>
201
- Promise.reject(peerEndedLink())
202
- );
203
-
204
- await acquire(transport);
205
- jest.setSystemTime(Date.now() + IOS_PEER_TERMINATION_REPEAT_WINDOW_MS + 1);
206
-
207
- await expect(acquire(transport)).resolves.toEqual({ native: 7 });
208
- });
209
-
210
- test('starts over after an attempt that failed for another reason', async () => {
211
- const { transport, device } = createHarness();
212
- device.discoverAllServicesAndCharacteristics
213
- .mockImplementationOnce(() => Promise.reject(peerEndedLink()))
214
- .mockImplementationOnce(() => Promise.reject(linkTimedOut()))
215
- .mockImplementation(() => Promise.reject(peerEndedLink()));
216
-
217
- await acquire(transport);
218
- await expect(acquire(transport)).resolves.toEqual({ native: 6 });
219
- await expect(acquire(transport)).resolves.toEqual({ native: 7 });
220
- });
221
-
222
- test('starts over once the device has answered', async () => {
223
- const { transport, device } = createHarness();
224
- (transport as any).detectProtocol = jest.fn(() => Promise.resolve('V1'));
225
- device.discoverAllServicesAndCharacteristics
226
- .mockImplementationOnce(() => Promise.reject(peerEndedLink()))
227
- .mockImplementationOnce(() => Promise.resolve())
228
- .mockImplementation(() => Promise.reject(peerEndedLink()));
229
-
230
- await acquire(transport);
231
- await expect(acquire(transport)).resolves.toEqual({});
232
-
233
- await expect(acquire(transport)).resolves.toEqual({ native: 7 });
234
- });
235
-
236
- test('never classifies a firmware-install reconnect', async () => {
237
- const { transport, device } = createHarness();
238
- device.discoverAllServicesAndCharacteristics.mockImplementation(() =>
239
- Promise.reject(peerEndedLink())
240
- );
241
- const reconnect = { expectedProtocol: 'V2', skipProtocolProbe: true };
242
-
243
- await expect(acquire(transport, reconnect)).resolves.toEqual({ native: 7 });
244
- await expect(acquire(transport, reconnect)).resolves.toEqual({ native: 7 });
245
- // The device was rebooting, so those drops are not evidence for a later attempt either.
246
- await expect(acquire(transport)).resolves.toEqual({ native: 7 });
247
- });
248
-
249
- test('logs the native codes of the failed operation, which iOS reports nowhere else', async () => {
250
- const { transport, device, logger } = createHarness();
251
- device.discoverAllServicesAndCharacteristics.mockImplementation(() =>
252
- Promise.reject(peerEndedLink())
253
- );
254
-
255
- await acquire(transport);
256
-
257
- expect(logger.debug).toHaveBeenCalledWith('[ReactNativeBleTransport] iOS operation failed', {
258
- connectIdSuffix: UUID.slice(-8),
259
- stage: 'gatt-setup',
260
- errorCode: 201,
261
- iosErrorCode: 7,
262
- attErrorCode: undefined,
263
- });
264
- });
265
-
266
- test('reports a lost bond that iOS names during GATT setup', async () => {
267
- const { transport, device } = createHarness();
268
- device.discoverAllServicesAndCharacteristics.mockImplementation(() =>
269
- Promise.reject(nativeDisconnect(14, 'Peer removed pairing information'))
270
- );
271
-
272
- await expect(acquire(transport)).resolves.toMatchObject({
273
- code: HardwareErrorCode.BlePeerRemovedPairingInformation,
274
- });
275
- });
276
- });
277
-
278
- describe('IosPeerTerminationTracker', () => {
279
- beforeEach(() => {
280
- jest.useFakeTimers({ doNotFake: ['performance'] });
281
- });
282
-
283
- afterEach(() => {
284
- jest.useRealTimers();
285
- });
286
-
287
- const dropLink = (tracker: IosPeerTerminationTracker, linkAgeMs = 0) => {
288
- tracker.attemptStarted(UUID);
289
- tracker.linkStarted(UUID);
290
- jest.setSystemTime(Date.now() + linkAgeMs);
291
- tracker.note(UUID, peerEndedLink());
292
- return tracker.attemptFailed(UUID);
293
- };
294
-
295
- test('ignores a drop on a link that was reused or had been up for a while', () => {
296
- const tracker = new IosPeerTerminationTracker();
297
- expect(dropLink(tracker)).toBe(false);
298
-
299
- tracker.attemptStarted(UUID);
300
- tracker.note(UUID, peerEndedLink());
301
- expect(tracker.attemptFailed(UUID)).toBe(false);
302
-
303
- expect(dropLink(tracker)).toBe(false);
304
- expect(dropLink(tracker, IOS_PEER_TERMINATION_LINK_WINDOW_MS + 1)).toBe(false);
305
- });
306
-
307
- test('ignores errors that do not say the peer ended the link', () => {
308
- const tracker = new IosPeerTerminationTracker();
309
- expect(dropLink(tracker)).toBe(false);
310
-
311
- tracker.attemptStarted(UUID);
312
- tracker.linkStarted(UUID);
313
- tracker.note(UUID, linkTimedOut());
314
- tracker.note(UUID, { errorCode: 201 });
315
- tracker.note(UUID, undefined);
316
- expect(tracker.attemptFailed(UUID)).toBe(false);
317
- });
318
- });