@onekeyfe/hd-common-connect-sdk 1.2.11-alpha.8 → 1.2.11-alpha.9
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.
- package/README.md +24 -1
- package/__tests__/direct-lowlevel.test.js +249 -0
- package/dist/index.d.ts +3 -2
- package/dist/index.js +160 -41
- package/package.json +17 -10
- package/scripts/check-bundle.mjs +35 -0
- package/src/index.ts +130 -24
package/README.md
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
# `@onekeyfe/hd-common-connect-sdk`
|
|
2
2
|
|
|
3
|
-
`@onekeyfe/hd-common-connect-sdk` is a
|
|
3
|
+
`@onekeyfe/hd-common-connect-sdk` is a unified in-process Hardware SDK entry point that runs Core and the selected transport directly in Node.js, Electron, browser/extension, and native bridge (`lowlevel`) runtimes.
|
|
4
4
|
|
|
5
5
|
## Installation
|
|
6
6
|
|
|
@@ -28,6 +28,29 @@ function init() {
|
|
|
28
28
|
}
|
|
29
29
|
```
|
|
30
30
|
|
|
31
|
+
## Local LowLevel host
|
|
32
|
+
|
|
33
|
+
The named `HardwareSDKLowLevel` export runs Core and the selected transport in the
|
|
34
|
+
same JavaScript runtime. A trusted local host, including an extension offscreen
|
|
35
|
+
document, can use it without a hardware SDK iframe:
|
|
36
|
+
|
|
37
|
+
```typescript
|
|
38
|
+
import { HardwareSDKLowLevel } from '@onekeyfe/hd-common-connect-sdk';
|
|
39
|
+
|
|
40
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
41
|
+
// Forward SDK calls and correlated UI responses through the host's existing bridge.
|
|
42
|
+
await HardwareSDKLowLevel.dispose();
|
|
43
|
+
```
|
|
44
|
+
|
|
45
|
+
The package's `browser` mapping excludes the native USB dependency from browser
|
|
46
|
+
bundles. The browser host still needs a `Buffer` polyfill for Core and its
|
|
47
|
+
dependencies. Use `env: 'node-usb'` from a Node.js build.
|
|
48
|
+
|
|
49
|
+
The host still obtains WebUSB permission through a user gesture and handles device
|
|
50
|
+
confirmation, PIN and passphrase events. An extension service worker should proxy
|
|
51
|
+
to its offscreen host. Use one active SDK host per runtime and dispose it before
|
|
52
|
+
replacing it. The package's default SDK export keeps its existing behavior.
|
|
53
|
+
|
|
31
54
|
## Desktop USB identity discovery
|
|
32
55
|
|
|
33
56
|
`probeUsbDeviceIdentities({ commType: 'webusb' | 'bridge' })` is a named export for
|
|
@@ -0,0 +1,249 @@
|
|
|
1
|
+
import EventEmitter from 'events';
|
|
2
|
+
import {
|
|
3
|
+
CORE_EVENT,
|
|
4
|
+
DEVICE,
|
|
5
|
+
DEVICE_EVENT,
|
|
6
|
+
UI_EVENT,
|
|
7
|
+
UI_REQUEST,
|
|
8
|
+
IFRAME,
|
|
9
|
+
UI_RESPONSE,
|
|
10
|
+
initCore,
|
|
11
|
+
switchTransport,
|
|
12
|
+
} from '@onekeyfe/hd-core';
|
|
13
|
+
import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
|
|
14
|
+
|
|
15
|
+
import { HardwareSDKLowLevel } from '../src';
|
|
16
|
+
|
|
17
|
+
jest.mock('../../core/src/data/config', () => ({
|
|
18
|
+
getSDKVersion: jest.fn(() => '1.0.0-test'),
|
|
19
|
+
DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
|
|
20
|
+
}));
|
|
21
|
+
jest.mock('@onekeyfe/hd-core', () => ({
|
|
22
|
+
__esModule: true,
|
|
23
|
+
...jest.requireActual('@onekeyfe/hd-core'),
|
|
24
|
+
initCore: jest.fn(),
|
|
25
|
+
switchTransport: jest.fn(),
|
|
26
|
+
}));
|
|
27
|
+
jest.mock('@onekeyfe/hd-transport-http', () => ({}));
|
|
28
|
+
jest.mock('@onekeyfe/hd-transport-web-device', () => ({ WebUsbTransport: {} }));
|
|
29
|
+
jest.mock('@onekeyfe/hd-transport-lowlevel', () => ({}));
|
|
30
|
+
jest.mock('@onekeyfe/hd-transport-emulator', () => ({}));
|
|
31
|
+
|
|
32
|
+
const core = Object.assign(new EventEmitter(), {
|
|
33
|
+
handleMessage: jest.fn(),
|
|
34
|
+
dispose: jest.fn(() => {
|
|
35
|
+
core.removeAllListeners();
|
|
36
|
+
return Promise.resolve();
|
|
37
|
+
}),
|
|
38
|
+
});
|
|
39
|
+
|
|
40
|
+
beforeEach(() => {
|
|
41
|
+
jest.clearAllMocks();
|
|
42
|
+
initCore.mockResolvedValue(core);
|
|
43
|
+
});
|
|
44
|
+
afterEach(async () => HardwareSDKLowLevel.dispose());
|
|
45
|
+
|
|
46
|
+
test('initializes, calls and switches the local Core without a DOM or iframe', async () => {
|
|
47
|
+
expect(typeof document).toBe('undefined');
|
|
48
|
+
expect(await HardwareSDKLowLevel.init({ env: 'webusb' })).toBe(true);
|
|
49
|
+
expect(initCore).toHaveBeenCalledWith(
|
|
50
|
+
expect.objectContaining({ env: 'webusb' }),
|
|
51
|
+
expect.anything(),
|
|
52
|
+
undefined,
|
|
53
|
+
expect.any(AbortSignal)
|
|
54
|
+
);
|
|
55
|
+
const response = { success: true, payload: { test: true } };
|
|
56
|
+
core.handleMessage.mockResolvedValue(response);
|
|
57
|
+
expect(await HardwareSDKLowLevel.call({ method: 'getFeatures' })).toBe(response);
|
|
58
|
+
expect(core.handleMessage).toHaveBeenCalledWith(
|
|
59
|
+
expect.objectContaining({
|
|
60
|
+
event: IFRAME.CALL,
|
|
61
|
+
type: IFRAME.CALL,
|
|
62
|
+
payload: expect.objectContaining({ method: 'getFeatures' }),
|
|
63
|
+
})
|
|
64
|
+
);
|
|
65
|
+
expect(await HardwareSDKLowLevel.switchTransport('webusb')).toStrictEqual({
|
|
66
|
+
success: true,
|
|
67
|
+
payload: {},
|
|
68
|
+
});
|
|
69
|
+
expect(switchTransport).toHaveBeenCalledWith({
|
|
70
|
+
env: 'webusb',
|
|
71
|
+
owner: core,
|
|
72
|
+
loadTransport: expect.any(Function),
|
|
73
|
+
plugin: undefined,
|
|
74
|
+
});
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
test('keeps the Web LowLevel event envelope and cleans listeners on dispose', async () => {
|
|
78
|
+
const listener = jest.fn();
|
|
79
|
+
HardwareSDKLowLevel.addHardwareGlobalEventListener(listener);
|
|
80
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
81
|
+
const payload = { device: { label: 'Synthetic device' } };
|
|
82
|
+
core.emit(CORE_EVENT, { event: DEVICE_EVENT, type: DEVICE.CONNECT, payload });
|
|
83
|
+
expect(listener).toHaveBeenLastCalledWith({
|
|
84
|
+
...payload,
|
|
85
|
+
event: DEVICE.CONNECT,
|
|
86
|
+
type: DEVICE.CONNECT,
|
|
87
|
+
});
|
|
88
|
+
const message = { event: UI_EVENT, type: UI_REQUEST.REQUEST_BUTTON, payload: {} };
|
|
89
|
+
core.emit(CORE_EVENT, message);
|
|
90
|
+
expect(listener).toHaveBeenLastCalledWith(message);
|
|
91
|
+
await HardwareSDKLowLevel.dispose();
|
|
92
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
93
|
+
listener.mockClear();
|
|
94
|
+
core.emit(CORE_EVENT, message);
|
|
95
|
+
expect(listener).not.toHaveBeenCalled();
|
|
96
|
+
expect(core.listenerCount(CORE_EVENT)).toBe(1);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
test('uses settings staged before initialization', async () => {
|
|
100
|
+
await HardwareSDKLowLevel.updateSettings({ env: 'webusb' });
|
|
101
|
+
await HardwareSDKLowLevel.init({ debug: false });
|
|
102
|
+
expect(initCore).toHaveBeenCalledWith(
|
|
103
|
+
expect.objectContaining({ env: 'webusb' }),
|
|
104
|
+
expect.anything(),
|
|
105
|
+
undefined,
|
|
106
|
+
expect.any(AbortSignal)
|
|
107
|
+
);
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
test('reports settings errors through the Promise contract', async () => {
|
|
111
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
112
|
+
const result = HardwareSDKLowLevel.updateSettings({});
|
|
113
|
+
await expect(result).rejects.toMatchObject({
|
|
114
|
+
errorCode: HardwareErrorCode.IFrameAleradyInitialized,
|
|
115
|
+
});
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
test('rejects settings updates as soon as initialization is queued', async () => {
|
|
119
|
+
const initializing = HardwareSDKLowLevel.init({ env: 'webusb', fetchConfig: true });
|
|
120
|
+
|
|
121
|
+
await expect(
|
|
122
|
+
HardwareSDKLowLevel.updateSettings({ firmwareManifestMode: 'external-only' })
|
|
123
|
+
).rejects.toMatchObject({ errorCode: HardwareErrorCode.IFrameAleradyInitialized });
|
|
124
|
+
|
|
125
|
+
await expect(initializing).resolves.toBe(true);
|
|
126
|
+
});
|
|
127
|
+
|
|
128
|
+
test.each([
|
|
129
|
+
UI_REQUEST.FIRMWARE_PROGRESS,
|
|
130
|
+
UI_REQUEST.FIRMWARE_TIP,
|
|
131
|
+
UI_REQUEST.PREVIOUS_ADDRESS_RESULT,
|
|
132
|
+
])('forwards %s once with the original UI envelope', async type => {
|
|
133
|
+
const listener = jest.fn();
|
|
134
|
+
HardwareSDKLowLevel.addHardwareGlobalEventListener(listener);
|
|
135
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
136
|
+
const message = { event: UI_EVENT, type, payload: { progress: 1 } };
|
|
137
|
+
core.emit(CORE_EVENT, message);
|
|
138
|
+
expect(listener).toHaveBeenCalledTimes(1);
|
|
139
|
+
expect(listener).toHaveBeenCalledWith(message);
|
|
140
|
+
});
|
|
141
|
+
|
|
142
|
+
test('waits for an in-flight initialization to release its Core on dispose', async () => {
|
|
143
|
+
const entered = createDeferred();
|
|
144
|
+
const initializingCore = createDeferred();
|
|
145
|
+
const cleanupStarted = createDeferred();
|
|
146
|
+
const cleanupFinished = createDeferred();
|
|
147
|
+
initCore.mockImplementationOnce(() => {
|
|
148
|
+
entered.resolve();
|
|
149
|
+
return initializingCore.promise;
|
|
150
|
+
});
|
|
151
|
+
core.dispose.mockImplementationOnce(() => {
|
|
152
|
+
cleanupStarted.resolve();
|
|
153
|
+
return cleanupFinished.promise;
|
|
154
|
+
});
|
|
155
|
+
const initializing = HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
156
|
+
await entered.promise;
|
|
157
|
+
const disposing = HardwareSDKLowLevel.dispose();
|
|
158
|
+
const settled = jest.fn();
|
|
159
|
+
const completion = disposing.then(settled);
|
|
160
|
+
initializingCore.resolve(core);
|
|
161
|
+
try {
|
|
162
|
+
await Promise.race([cleanupStarted.promise, disposing]);
|
|
163
|
+
expect(settled).not.toHaveBeenCalled();
|
|
164
|
+
} finally {
|
|
165
|
+
cleanupFinished.resolve();
|
|
166
|
+
}
|
|
167
|
+
await completion;
|
|
168
|
+
expect(await initializing).toBe(false);
|
|
169
|
+
expect(core.dispose).toHaveBeenCalledTimes(1);
|
|
170
|
+
expect(core.listenerCount(CORE_EVENT)).toBe(0);
|
|
171
|
+
});
|
|
172
|
+
|
|
173
|
+
test('cancels initialization on disposal and lets the next initialization proceed', async () => {
|
|
174
|
+
const started = createDeferred();
|
|
175
|
+
initCore.mockImplementationOnce((_settings, _transport, _plugin, signal) => {
|
|
176
|
+
started.resolve();
|
|
177
|
+
return new Promise(resolve => {
|
|
178
|
+
signal.addEventListener('abort', () => resolve(undefined), { once: true });
|
|
179
|
+
});
|
|
180
|
+
});
|
|
181
|
+
|
|
182
|
+
const abandoned = HardwareSDKLowLevel.init({ env: 'webusb', fetchConfig: true });
|
|
183
|
+
await started.promise;
|
|
184
|
+
const disposing = HardwareSDKLowLevel.dispose();
|
|
185
|
+
const restarted = HardwareSDKLowLevel.init({ env: 'webusb', fetchConfig: false });
|
|
186
|
+
|
|
187
|
+
await expect(disposing).resolves.toBeUndefined();
|
|
188
|
+
await expect(abandoned).resolves.toBe(false);
|
|
189
|
+
await expect(restarted).resolves.toBe(true);
|
|
190
|
+
expect(core.listenerCount(CORE_EVENT)).toBe(1);
|
|
191
|
+
});
|
|
192
|
+
|
|
193
|
+
test('binds the switch to its Core before waiting for the transport', async () => {
|
|
194
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
195
|
+
const switching = HardwareSDKLowLevel.switchTransport('webusb');
|
|
196
|
+
expect(switchTransport).toHaveBeenCalledWith({
|
|
197
|
+
env: 'webusb',
|
|
198
|
+
owner: core,
|
|
199
|
+
loadTransport: expect.any(Function),
|
|
200
|
+
plugin: undefined,
|
|
201
|
+
});
|
|
202
|
+
await switching;
|
|
203
|
+
});
|
|
204
|
+
|
|
205
|
+
test('preserves PIN and passphrase response correlation through the real Common adapter', async () => {
|
|
206
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
207
|
+
core.handleMessage.mockResolvedValue(undefined);
|
|
208
|
+
for (const type of [UI_RESPONSE.RECEIVE_PIN, UI_RESPONSE.RECEIVE_PASSPHRASE]) {
|
|
209
|
+
const response = {
|
|
210
|
+
type,
|
|
211
|
+
payload: type === UI_RESPONSE.RECEIVE_PIN ? '' : { value: '', passphraseOnDevice: true },
|
|
212
|
+
interactionId: 'synthetic-interaction',
|
|
213
|
+
deviceId: 'synthetic-device',
|
|
214
|
+
};
|
|
215
|
+
HardwareSDKLowLevel.uiResponse(response);
|
|
216
|
+
expect(core.handleMessage).toHaveBeenLastCalledWith({ ...response, event: UI_EVENT });
|
|
217
|
+
}
|
|
218
|
+
});
|
|
219
|
+
|
|
220
|
+
test('transport switching waits for completion and propagates rejection', async () => {
|
|
221
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
222
|
+
let finish;
|
|
223
|
+
switchTransport.mockReturnValueOnce(
|
|
224
|
+
new Promise(resolve => {
|
|
225
|
+
finish = resolve;
|
|
226
|
+
})
|
|
227
|
+
);
|
|
228
|
+
const settled = jest.fn();
|
|
229
|
+
const switching = HardwareSDKLowLevel.switchTransport('webusb').then(settled);
|
|
230
|
+
await Promise.resolve();
|
|
231
|
+
await Promise.resolve();
|
|
232
|
+
expect(settled).not.toHaveBeenCalled();
|
|
233
|
+
finish();
|
|
234
|
+
await switching;
|
|
235
|
+
expect(settled).toHaveBeenCalledWith({ success: true, payload: {} });
|
|
236
|
+
const failure = new Error('synthetic switch failure');
|
|
237
|
+
switchTransport.mockRejectedValueOnce(failure);
|
|
238
|
+
await expect(HardwareSDKLowLevel.switchTransport('webusb')).rejects.toBe(failure);
|
|
239
|
+
});
|
|
240
|
+
|
|
241
|
+
test('rejects unsupported react-native transport in Common SDK', async () => {
|
|
242
|
+
await HardwareSDKLowLevel.init({ env: 'webusb' });
|
|
243
|
+
switchTransport.mockImplementationOnce(async ({ loadTransport }) => {
|
|
244
|
+
await loadTransport();
|
|
245
|
+
});
|
|
246
|
+
await expect(HardwareSDKLowLevel.switchTransport('react-native')).rejects.toMatchObject({
|
|
247
|
+
errorCode: HardwareErrorCode.TransportNotConfigured,
|
|
248
|
+
});
|
|
249
|
+
});
|
package/dist/index.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import * as _onekeyfe_hd_core from '@onekeyfe/hd-core';
|
|
2
|
-
import { UsbDeviceIdentity } from '@onekeyfe/hd-core';
|
|
2
|
+
import { UsbDeviceIdentity, LowLevelCoreApi } from '@onekeyfe/hd-core';
|
|
3
3
|
import { Deferred } from '@onekeyfe/hd-shared';
|
|
4
4
|
|
|
5
5
|
/** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
|
|
@@ -9,6 +9,7 @@ declare const probeUsbDeviceIdentities: ({ commType, }: {
|
|
|
9
9
|
declare const messagePromises: {
|
|
10
10
|
[key: number]: Deferred<any>;
|
|
11
11
|
};
|
|
12
|
+
declare const HardwareSDKLowLevel: LowLevelCoreApi;
|
|
12
13
|
declare const HardwareCommonConnectSdk: _onekeyfe_hd_core.CoreApi;
|
|
13
14
|
|
|
14
|
-
export { HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
|
|
15
|
+
export { HardwareSDKLowLevel, HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };
|
package/dist/index.js
CHANGED
|
@@ -586,6 +586,9 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
|
|
|
586
586
|
return __generator(this, function (_a) {
|
|
587
587
|
switch (_a.label) {
|
|
588
588
|
case 0:
|
|
589
|
+
if (env === 'react-native') {
|
|
590
|
+
throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'React Native transport is not supported by @onekeyfe/hd-common-connect-sdk');
|
|
591
|
+
}
|
|
589
592
|
if (env === 'desktop-web-ble') {
|
|
590
593
|
return [2 /*return*/, hdTransportWebDevice.ElectronBleTransport];
|
|
591
594
|
}
|
|
@@ -597,6 +600,10 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
|
|
|
597
600
|
return [4 /*yield*/, Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@onekeyfe/hd-transport-usb')); })];
|
|
598
601
|
case 1:
|
|
599
602
|
NodeUsbTransport = (_a.sent()).default;
|
|
603
|
+
// Browser bundlers replace this Node-only package with an empty module.
|
|
604
|
+
if (typeof NodeUsbTransport !== 'function') {
|
|
605
|
+
throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Node USB requires Node.js');
|
|
606
|
+
}
|
|
600
607
|
return [2 /*return*/, NodeUsbTransport];
|
|
601
608
|
case 2:
|
|
602
609
|
if (env === 'emulator')
|
|
@@ -606,7 +613,10 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
|
|
|
606
613
|
});
|
|
607
614
|
}); };
|
|
608
615
|
var _core;
|
|
616
|
+
var _plugin;
|
|
609
617
|
var _settings = HardwareSdk.parseConnectSettings();
|
|
618
|
+
var lifecycle = Promise.resolve(undefined);
|
|
619
|
+
var pendingInitializations = new Set();
|
|
610
620
|
var usbIdentityProbeTransports = {};
|
|
611
621
|
var usbIdentityProbes = {};
|
|
612
622
|
/** Identify WebUSB without disposing the current SDK, changing settings, or opening a wallet. */
|
|
@@ -634,21 +644,26 @@ var probeUsbDeviceIdentities = function (_a) {
|
|
|
634
644
|
var _messageID = 0;
|
|
635
645
|
var messagePromises = {};
|
|
636
646
|
var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
637
|
-
var core;
|
|
638
|
-
|
|
639
|
-
|
|
640
|
-
switch (_b.label) {
|
|
647
|
+
var core, pending, disposing;
|
|
648
|
+
return __generator(this, function (_a) {
|
|
649
|
+
switch (_a.label) {
|
|
641
650
|
case 0:
|
|
642
651
|
core = _core;
|
|
652
|
+
pendingInitializations.forEach(function (controller) { return controller.abort(); });
|
|
653
|
+
pendingInitializations.clear();
|
|
654
|
+
pending = lifecycle.catch(function () { return undefined; });
|
|
643
655
|
_core = undefined;
|
|
656
|
+
_plugin = undefined;
|
|
644
657
|
eventEmitter.removeAllListeners();
|
|
645
658
|
Object.keys(messagePromises).forEach(function (key) {
|
|
646
659
|
delete messagePromises[Number(key)];
|
|
647
660
|
});
|
|
648
661
|
_settings = HardwareSdk.parseConnectSettings();
|
|
649
|
-
|
|
662
|
+
disposing = Promise.all([pending, core === null || core === void 0 ? void 0 : core.dispose()]);
|
|
663
|
+
lifecycle = disposing;
|
|
664
|
+
return [4 /*yield*/, disposing];
|
|
650
665
|
case 1:
|
|
651
|
-
|
|
666
|
+
_a.sent();
|
|
652
667
|
return [2 /*return*/];
|
|
653
668
|
}
|
|
654
669
|
});
|
|
@@ -657,13 +672,16 @@ var uiResponse = function (response) {
|
|
|
657
672
|
if (!_core) {
|
|
658
673
|
throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
|
|
659
674
|
}
|
|
660
|
-
|
|
661
|
-
|
|
675
|
+
_core
|
|
676
|
+
.handleMessage(__assign(__assign({}, response), { event: HardwareSdk.UI_EVENT }))
|
|
677
|
+
.catch(function (error) { return Log.error(HardwareSdk.createErrorMessage(error)); });
|
|
662
678
|
};
|
|
663
679
|
var cancel = function (connectId) {
|
|
664
680
|
if (_core === undefined)
|
|
665
681
|
return;
|
|
666
|
-
_core
|
|
682
|
+
_core
|
|
683
|
+
.handleMessage({ event: HardwareSdk.IFRAME.CANCEL, type: HardwareSdk.IFRAME.CANCEL, payload: { connectId: connectId } })
|
|
684
|
+
.catch(function (error) { return Log.debug('cancel error: ', error); });
|
|
667
685
|
};
|
|
668
686
|
function handleMessage(message) {
|
|
669
687
|
var event = message.event;
|
|
@@ -729,37 +747,73 @@ function postMessage(message, usePromise) {
|
|
|
729
747
|
});
|
|
730
748
|
});
|
|
731
749
|
}
|
|
732
|
-
var init = function (settings, _, plugin) {
|
|
733
|
-
var Transport, error_1;
|
|
750
|
+
var init = function (settings, _, plugin) {
|
|
734
751
|
var _a;
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
752
|
+
_settings = __assign(__assign(__assign({}, _settings), settings), { env: (_a = settings.env) !== null && _a !== void 0 ? _a : 'node' });
|
|
753
|
+
var initSettings = _settings;
|
|
754
|
+
var controller = new AbortController();
|
|
755
|
+
var signal = controller.signal;
|
|
756
|
+
pendingInitializations.add(controller);
|
|
757
|
+
var initialize = function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
758
|
+
var Transport, previous, core, error_1;
|
|
759
|
+
return __generator(this, function (_a) {
|
|
760
|
+
switch (_a.label) {
|
|
761
|
+
case 0:
|
|
762
|
+
if (signal.aborted)
|
|
763
|
+
return [2 /*return*/, false];
|
|
764
|
+
HardwareSdk.enableLog(!!settings.debug);
|
|
765
|
+
Log.debug('init');
|
|
766
|
+
_a.label = 1;
|
|
767
|
+
case 1:
|
|
768
|
+
_a.trys.push([1, 8, , 9]);
|
|
769
|
+
return [4 /*yield*/, getTransport(initSettings.env)];
|
|
770
|
+
case 2:
|
|
771
|
+
Transport = _a.sent();
|
|
772
|
+
if (signal.aborted)
|
|
773
|
+
return [2 /*return*/, false];
|
|
774
|
+
previous = _core;
|
|
775
|
+
_core = undefined;
|
|
776
|
+
_plugin = undefined;
|
|
777
|
+
if (!previous) return [3 /*break*/, 4];
|
|
778
|
+
return [4 /*yield*/, previous.dispose()];
|
|
779
|
+
case 3:
|
|
780
|
+
_a.sent();
|
|
781
|
+
_a.label = 4;
|
|
782
|
+
case 4:
|
|
783
|
+
if (signal.aborted)
|
|
784
|
+
return [2 /*return*/, false];
|
|
785
|
+
return [4 /*yield*/, HardwareSdk.initCore(initSettings, Transport, plugin, signal)];
|
|
786
|
+
case 5:
|
|
787
|
+
core = _a.sent();
|
|
788
|
+
if (!core)
|
|
789
|
+
return [2 /*return*/, false];
|
|
790
|
+
if (!signal.aborted) return [3 /*break*/, 7];
|
|
791
|
+
return [4 /*yield*/, core.dispose()];
|
|
792
|
+
case 6:
|
|
793
|
+
_a.sent();
|
|
794
|
+
return [2 /*return*/, false];
|
|
795
|
+
case 7:
|
|
796
|
+
_core = core;
|
|
797
|
+
_plugin = plugin;
|
|
798
|
+
core.on(HardwareSdk.CORE_EVENT, handleMessage);
|
|
799
|
+
HardwareSdk.setLoggerPostMessage(handleMessage);
|
|
800
|
+
return [2 /*return*/, true];
|
|
801
|
+
case 8:
|
|
802
|
+
error_1 = _a.sent();
|
|
803
|
+
Log.error(HardwareSdk.createErrorMessage(error_1));
|
|
804
|
+
return [2 /*return*/, false];
|
|
805
|
+
case 9: return [2 /*return*/];
|
|
806
|
+
}
|
|
807
|
+
});
|
|
808
|
+
}); };
|
|
809
|
+
var initializing = lifecycle.then(initialize, initialize).finally(function () {
|
|
810
|
+
pendingInitializations.delete(controller);
|
|
759
811
|
});
|
|
760
|
-
|
|
812
|
+
lifecycle = initializing;
|
|
813
|
+
return initializing;
|
|
814
|
+
};
|
|
761
815
|
var call = function (params) { return __awaiter(void 0, void 0, void 0, function () {
|
|
762
|
-
var blockLog, response, error_2;
|
|
816
|
+
var blockLog, response, emitBleUiWarning, error_2;
|
|
763
817
|
var _a, _b, _c, _d;
|
|
764
818
|
return __generator(this, function (_e) {
|
|
765
819
|
switch (_e.label) {
|
|
@@ -775,17 +829,22 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
|
|
|
775
829
|
if (response) {
|
|
776
830
|
Log.debug('response: ', blockLog ? '[REDACTED]' : response);
|
|
777
831
|
if (!response.success) {
|
|
832
|
+
emitBleUiWarning = function (message) {
|
|
833
|
+
postMessage(message, false).catch(function (error) {
|
|
834
|
+
return Log.debug('postMessage warning error: ', error);
|
|
835
|
+
});
|
|
836
|
+
};
|
|
778
837
|
if (((_a = response.payload) === null || _a === void 0 ? void 0 : _a.code) === hdShared.HardwareErrorCode.BleUnsupported) {
|
|
779
|
-
|
|
838
|
+
emitBleUiWarning(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_UNSUPPORTED));
|
|
780
839
|
}
|
|
781
840
|
if (((_b = response.payload) === null || _b === void 0 ? void 0 : _b.code) === hdShared.HardwareErrorCode.BlePoweredOff) {
|
|
782
|
-
|
|
841
|
+
emitBleUiWarning(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_POWERED_OFF));
|
|
783
842
|
}
|
|
784
843
|
if (((_c = response.payload) === null || _c === void 0 ? void 0 : _c.code) === hdShared.HardwareErrorCode.BlePermissionError) {
|
|
785
|
-
|
|
844
|
+
emitBleUiWarning(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.BLUETOOTH_PERMISSION));
|
|
786
845
|
}
|
|
787
846
|
if (((_d = response.payload) === null || _d === void 0 ? void 0 : _d.code) === hdShared.HardwareErrorCode.BleLocationError) {
|
|
788
|
-
|
|
847
|
+
emitBleUiWarning(HardwareSdk.createUiMessage(HardwareSdk.UI_REQUEST.LOCATION_PERMISSION));
|
|
789
848
|
}
|
|
790
849
|
}
|
|
791
850
|
return [2 /*return*/, response];
|
|
@@ -801,6 +860,65 @@ var call = function (params) { return __awaiter(void 0, void 0, void 0, function
|
|
|
801
860
|
}); };
|
|
802
861
|
var updateSettings = function () { return Promise.resolve(true); };
|
|
803
862
|
var switchTransport = function () { return Promise.resolve({ success: true }); };
|
|
863
|
+
var addHardwareGlobalEventListener = function (listener) {
|
|
864
|
+
[
|
|
865
|
+
HardwareSdk.UI_EVENT,
|
|
866
|
+
HardwareSdk.LOG_EVENT,
|
|
867
|
+
HardwareSdk.FIRMWARE_EVENT,
|
|
868
|
+
HardwareSdk.DEVICE.CONNECT,
|
|
869
|
+
HardwareSdk.DEVICE.DISCONNECT,
|
|
870
|
+
HardwareSdk.DEVICE.FEATURES,
|
|
871
|
+
HardwareSdk.DEVICE.STATE,
|
|
872
|
+
HardwareSdk.DEVICE.SUPPORT_FEATURES,
|
|
873
|
+
].forEach(function (eventName) {
|
|
874
|
+
eventEmitter.on(eventName, function (message) {
|
|
875
|
+
// Match the Web SDK envelope for device events emitted as payloads.
|
|
876
|
+
var envelope = message;
|
|
877
|
+
var emitMessage = message;
|
|
878
|
+
if (envelope && typeof envelope === 'object' && !envelope.event && !envelope.type) {
|
|
879
|
+
emitMessage = __assign({}, message);
|
|
880
|
+
Object.assign(emitMessage, { event: eventName, type: eventName });
|
|
881
|
+
}
|
|
882
|
+
listener(emitMessage);
|
|
883
|
+
});
|
|
884
|
+
});
|
|
885
|
+
};
|
|
886
|
+
var HardwareSDKLowLevel = HardwareSdk.HardwareSDKLowLevel({
|
|
887
|
+
eventEmitter: eventEmitter,
|
|
888
|
+
init: function (settings, sdk, plugin) { return init(__assign(__assign({}, _settings), settings), sdk, plugin); },
|
|
889
|
+
call: call,
|
|
890
|
+
cancel: cancel,
|
|
891
|
+
dispose: dispose,
|
|
892
|
+
addHardwareGlobalEventListener: addHardwareGlobalEventListener,
|
|
893
|
+
uiResponse: uiResponse,
|
|
894
|
+
updateSettings: function (settings) {
|
|
895
|
+
if (_core || pendingInitializations.size > 0) {
|
|
896
|
+
return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.IFrameAleradyInitialized));
|
|
897
|
+
}
|
|
898
|
+
_settings = HardwareSdk.parseConnectSettings(__assign(__assign({}, _settings), settings));
|
|
899
|
+
return Promise.resolve(true);
|
|
900
|
+
},
|
|
901
|
+
switchTransport: function (env) { return __awaiter(void 0, void 0, void 0, function () {
|
|
902
|
+
var owner;
|
|
903
|
+
return __generator(this, function (_a) {
|
|
904
|
+
switch (_a.label) {
|
|
905
|
+
case 0:
|
|
906
|
+
owner = _core;
|
|
907
|
+
if (!owner)
|
|
908
|
+
throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotInitialized);
|
|
909
|
+
return [4 /*yield*/, HardwareSdk.switchTransport({
|
|
910
|
+
env: env,
|
|
911
|
+
owner: owner,
|
|
912
|
+
loadTransport: function () { return getTransport(env); },
|
|
913
|
+
plugin: _plugin,
|
|
914
|
+
})];
|
|
915
|
+
case 1:
|
|
916
|
+
_a.sent();
|
|
917
|
+
return [2 /*return*/, { success: true, payload: {} }];
|
|
918
|
+
}
|
|
919
|
+
});
|
|
920
|
+
}); },
|
|
921
|
+
});
|
|
804
922
|
var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
|
|
805
923
|
eventEmitter: eventEmitter,
|
|
806
924
|
init: init,
|
|
@@ -812,6 +930,7 @@ var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
|
|
|
812
930
|
switchTransport: switchTransport,
|
|
813
931
|
});
|
|
814
932
|
|
|
933
|
+
exports.HardwareSDKLowLevel = HardwareSDKLowLevel;
|
|
815
934
|
exports["default"] = HardwareCommonConnectSdk;
|
|
816
935
|
exports.messagePromises = messagePromises;
|
|
817
936
|
exports.probeUsbDeviceIdentities = probeUsbDeviceIdentities;
|
package/package.json
CHANGED
|
@@ -1,10 +1,13 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@onekeyfe/hd-common-connect-sdk",
|
|
3
|
-
"version": "1.2.11-alpha.
|
|
3
|
+
"version": "1.2.11-alpha.9",
|
|
4
4
|
"author": "OneKey",
|
|
5
5
|
"homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
|
|
6
6
|
"license": "ISC",
|
|
7
7
|
"main": "dist/index.js",
|
|
8
|
+
"browser": {
|
|
9
|
+
"@onekeyfe/hd-transport-usb": false
|
|
10
|
+
},
|
|
8
11
|
"types": "dist/index.d.ts",
|
|
9
12
|
"repository": {
|
|
10
13
|
"type": "git",
|
|
@@ -15,19 +18,23 @@
|
|
|
15
18
|
},
|
|
16
19
|
"scripts": {
|
|
17
20
|
"dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
|
|
18
|
-
"build": "rimraf dist && rollup -c ../../build/rollup.config.js",
|
|
21
|
+
"build": "rimraf dist && rollup -c ../../build/rollup.config.js && node scripts/check-bundle.mjs",
|
|
19
22
|
"test": "jest",
|
|
20
23
|
"lint": "eslint .",
|
|
21
24
|
"lint:fix": "eslint . --fix"
|
|
22
25
|
},
|
|
26
|
+
"devDependencies": {
|
|
27
|
+
"esbuild": "^0.27.0"
|
|
28
|
+
},
|
|
23
29
|
"dependencies": {
|
|
24
|
-
"@onekeyfe/hd-core": "1.2.11-alpha.
|
|
25
|
-
"@onekeyfe/hd-shared": "1.2.11-alpha.
|
|
26
|
-
"@onekeyfe/hd-transport-emulator": "1.2.11-alpha.
|
|
27
|
-
"@onekeyfe/hd-transport-http": "1.2.11-alpha.
|
|
28
|
-
"@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.
|
|
29
|
-
"@onekeyfe/hd-transport-usb": "1.2.11-alpha.
|
|
30
|
-
"@onekeyfe/hd-transport-web-device": "1.2.11-alpha.
|
|
30
|
+
"@onekeyfe/hd-core": "1.2.11-alpha.9",
|
|
31
|
+
"@onekeyfe/hd-shared": "1.2.11-alpha.9",
|
|
32
|
+
"@onekeyfe/hd-transport-emulator": "1.2.11-alpha.9",
|
|
33
|
+
"@onekeyfe/hd-transport-http": "1.2.11-alpha.9",
|
|
34
|
+
"@onekeyfe/hd-transport-lowlevel": "1.2.11-alpha.9",
|
|
35
|
+
"@onekeyfe/hd-transport-usb": "1.2.11-alpha.9",
|
|
36
|
+
"@onekeyfe/hd-transport-web-device": "1.2.11-alpha.9",
|
|
37
|
+
"events": "^3.3.0"
|
|
31
38
|
},
|
|
32
|
-
"gitHead": "
|
|
39
|
+
"gitHead": "42a772503abc1acb973bc31232a4c30f113034d1"
|
|
33
40
|
}
|
|
@@ -0,0 +1,35 @@
|
|
|
1
|
+
import assert from 'node:assert/strict';
|
|
2
|
+
import { fileURLToPath } from 'node:url';
|
|
3
|
+
|
|
4
|
+
import { buildSync } from 'esbuild';
|
|
5
|
+
|
|
6
|
+
const packageDirectory = fileURLToPath(new URL('..', import.meta.url));
|
|
7
|
+
const options = {
|
|
8
|
+
absWorkingDir: packageDirectory,
|
|
9
|
+
stdin: {
|
|
10
|
+
contents: `export { HardwareSDKLowLevel } from '@onekeyfe/hd-common-connect-sdk';`,
|
|
11
|
+
resolveDir: packageDirectory,
|
|
12
|
+
},
|
|
13
|
+
bundle: true,
|
|
14
|
+
format: 'cjs',
|
|
15
|
+
logLevel: 'error',
|
|
16
|
+
metafile: true,
|
|
17
|
+
write: false,
|
|
18
|
+
};
|
|
19
|
+
|
|
20
|
+
const nativeUsbModule = /(?:^|\/)(?:hd-transport-usb|usb|node-gyp-build)\//u;
|
|
21
|
+
const hasNativeUsb = ({ metafile }) =>
|
|
22
|
+
Object.keys(metafile.inputs).some(
|
|
23
|
+
input => !input.startsWith('(disabled):') && nativeUsbModule.test(input)
|
|
24
|
+
);
|
|
25
|
+
|
|
26
|
+
assert.equal(
|
|
27
|
+
hasNativeUsb(buildSync({ ...options, platform: 'browser' })),
|
|
28
|
+
false,
|
|
29
|
+
'Browser bundles must exclude the native USB transport'
|
|
30
|
+
);
|
|
31
|
+
assert.equal(
|
|
32
|
+
hasNativeUsb(buildSync({ ...options, platform: 'node' })),
|
|
33
|
+
true,
|
|
34
|
+
'Node bundles must retain the native USB transport'
|
|
35
|
+
);
|
package/src/index.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import EventEmitter from 'events';
|
|
2
2
|
import HardwareSdk, {
|
|
3
|
+
HardwareSDKLowLevel as HardwareLowLevelSdk,
|
|
3
4
|
CORE_EVENT,
|
|
4
5
|
DEVICE,
|
|
5
6
|
DEVICE_EVENT,
|
|
@@ -19,6 +20,7 @@ import HardwareSdk, {
|
|
|
19
20
|
parseConnectSettings,
|
|
20
21
|
probeUsbDeviceIdentitiesWithTransport,
|
|
21
22
|
setLoggerPostMessage,
|
|
23
|
+
switchTransport as switchCoreTransport,
|
|
22
24
|
} from '@onekeyfe/hd-core';
|
|
23
25
|
import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
|
|
24
26
|
import HttpTransport from '@onekeyfe/hd-transport-http';
|
|
@@ -41,15 +43,26 @@ const eventEmitter = new EventEmitter();
|
|
|
41
43
|
const Log = getLogger(LoggerNames.HdCommonConnectSdk);
|
|
42
44
|
|
|
43
45
|
const getTransport = async (env: ConnectSettings['env']) => {
|
|
46
|
+
if (env === 'react-native') {
|
|
47
|
+
throw ERRORS.TypedError(
|
|
48
|
+
HardwareErrorCode.TransportNotConfigured,
|
|
49
|
+
'React Native transport is not supported by @onekeyfe/hd-common-connect-sdk'
|
|
50
|
+
);
|
|
51
|
+
}
|
|
44
52
|
if (env === 'desktop-web-ble') {
|
|
45
53
|
return ElectronBleTransport;
|
|
46
54
|
}
|
|
47
55
|
if (env === 'webusb' || env === 'desktop-webusb') return WebUsbTransport;
|
|
48
56
|
if (env === 'lowlevel') return LowlevelTransport;
|
|
49
57
|
if (env === 'node-usb') {
|
|
50
|
-
// Dynamic import — usb is a native Node.js module (libusb C++ bindings)
|
|
51
|
-
// that cannot be resolved by browser/React Native bundlers
|
|
52
58
|
const { default: NodeUsbTransport } = await import('@onekeyfe/hd-transport-usb');
|
|
59
|
+
// Browser bundlers replace this Node-only package with an empty module.
|
|
60
|
+
if (typeof NodeUsbTransport !== 'function') {
|
|
61
|
+
throw ERRORS.TypedError(
|
|
62
|
+
HardwareErrorCode.TransportNotConfigured,
|
|
63
|
+
'Node USB requires Node.js'
|
|
64
|
+
);
|
|
65
|
+
}
|
|
53
66
|
return NodeUsbTransport;
|
|
54
67
|
}
|
|
55
68
|
if (env === 'emulator') return EmulatorTransport;
|
|
@@ -57,7 +70,10 @@ const getTransport = async (env: ConnectSettings['env']) => {
|
|
|
57
70
|
};
|
|
58
71
|
|
|
59
72
|
let _core: Core | undefined;
|
|
73
|
+
let _plugin: LowlevelTransportSharedPlugin | undefined;
|
|
60
74
|
let _settings = parseConnectSettings();
|
|
75
|
+
let lifecycle = Promise.resolve<unknown>(undefined);
|
|
76
|
+
const pendingInitializations = new Set<AbortController>();
|
|
61
77
|
|
|
62
78
|
const usbIdentityProbeTransports: Partial<Record<UsbDeviceIdentity['commType'], WebUsbTransport>> =
|
|
63
79
|
{};
|
|
@@ -95,26 +111,35 @@ export const messagePromises: { [key: number]: Deferred<any> } = {};
|
|
|
95
111
|
|
|
96
112
|
const dispose = async () => {
|
|
97
113
|
const core = _core;
|
|
114
|
+
pendingInitializations.forEach(controller => controller.abort());
|
|
115
|
+
pendingInitializations.clear();
|
|
116
|
+
const pending = lifecycle.catch(() => undefined);
|
|
98
117
|
_core = undefined;
|
|
118
|
+
_plugin = undefined;
|
|
99
119
|
eventEmitter.removeAllListeners();
|
|
100
120
|
Object.keys(messagePromises).forEach(key => {
|
|
101
121
|
delete messagePromises[Number(key)];
|
|
102
122
|
});
|
|
103
123
|
_settings = parseConnectSettings();
|
|
104
|
-
|
|
124
|
+
const disposing = Promise.all([pending, core?.dispose()]);
|
|
125
|
+
lifecycle = disposing;
|
|
126
|
+
await disposing;
|
|
105
127
|
};
|
|
106
128
|
|
|
107
129
|
const uiResponse = (response: UiResponseEvent) => {
|
|
108
130
|
if (!_core) {
|
|
109
131
|
throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
|
|
110
132
|
}
|
|
111
|
-
|
|
112
|
-
|
|
133
|
+
_core
|
|
134
|
+
.handleMessage({ ...response, event: UI_EVENT } as CoreMessage)
|
|
135
|
+
.catch(error => Log.error(createErrorMessage(error)));
|
|
113
136
|
};
|
|
114
137
|
|
|
115
138
|
const cancel = (connectId?: string) => {
|
|
116
139
|
if (_core === undefined) return;
|
|
117
|
-
_core
|
|
140
|
+
_core
|
|
141
|
+
.handleMessage({ event: IFRAME.CANCEL, type: IFRAME.CANCEL, payload: { connectId } })
|
|
142
|
+
.catch(error => Log.debug('cancel error: ', error));
|
|
118
143
|
};
|
|
119
144
|
|
|
120
145
|
function handleMessage(message: CoreMessage) {
|
|
@@ -177,29 +202,53 @@ async function postMessage(message: CoreMessage, usePromise = true) {
|
|
|
177
202
|
_core.handleMessage(message);
|
|
178
203
|
}
|
|
179
204
|
|
|
180
|
-
const init =
|
|
205
|
+
const init = (
|
|
181
206
|
settings: Partial<ConnectSettings>,
|
|
182
207
|
_?: LowLevelCoreApi,
|
|
183
208
|
plugin?: LowlevelTransportSharedPlugin
|
|
184
209
|
) => {
|
|
185
210
|
_settings = { ..._settings, ...settings, env: settings.env ?? 'node' };
|
|
211
|
+
const initSettings = _settings;
|
|
212
|
+
const controller = new AbortController();
|
|
213
|
+
const { signal } = controller;
|
|
214
|
+
pendingInitializations.add(controller);
|
|
186
215
|
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
216
|
+
const initialize = async () => {
|
|
217
|
+
if (signal.aborted) return false;
|
|
218
|
+
enableLog(!!settings.debug);
|
|
219
|
+
Log.debug('init');
|
|
190
220
|
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
_core?.on(CORE_EVENT, handleMessage);
|
|
195
|
-
setLoggerPostMessage(handleMessage);
|
|
221
|
+
try {
|
|
222
|
+
const Transport = await getTransport(initSettings.env);
|
|
223
|
+
if (signal.aborted) return false;
|
|
196
224
|
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
225
|
+
const previous = _core;
|
|
226
|
+
_core = undefined;
|
|
227
|
+
_plugin = undefined;
|
|
228
|
+
if (previous) await previous.dispose();
|
|
229
|
+
if (signal.aborted) return false;
|
|
230
|
+
const core = await initCore(initSettings, Transport, plugin, signal);
|
|
231
|
+
if (!core) return false;
|
|
232
|
+
if (signal.aborted) {
|
|
233
|
+
await core.dispose();
|
|
234
|
+
return false;
|
|
235
|
+
}
|
|
236
|
+
_core = core;
|
|
237
|
+
_plugin = plugin;
|
|
238
|
+
core.on(CORE_EVENT, handleMessage);
|
|
239
|
+
setLoggerPostMessage(handleMessage);
|
|
240
|
+
return true;
|
|
241
|
+
} catch (error) {
|
|
242
|
+
Log.error(createErrorMessage(error));
|
|
243
|
+
return false;
|
|
244
|
+
}
|
|
245
|
+
};
|
|
200
246
|
|
|
201
|
-
|
|
202
|
-
|
|
247
|
+
const initializing = lifecycle.then(initialize, initialize).finally(() => {
|
|
248
|
+
pendingInitializations.delete(controller);
|
|
249
|
+
});
|
|
250
|
+
lifecycle = initializing;
|
|
251
|
+
return initializing;
|
|
203
252
|
};
|
|
204
253
|
|
|
205
254
|
const call = async (params: any) => {
|
|
@@ -212,17 +261,22 @@ const call = async (params: any) => {
|
|
|
212
261
|
Log.debug('response: ', blockLog ? '[REDACTED]' : response);
|
|
213
262
|
|
|
214
263
|
if (!response.success) {
|
|
264
|
+
const emitBleUiWarning = (message: CoreMessage) => {
|
|
265
|
+
postMessage(message, false).catch(error =>
|
|
266
|
+
Log.debug('postMessage warning error: ', error)
|
|
267
|
+
);
|
|
268
|
+
};
|
|
215
269
|
if (response.payload?.code === HardwareErrorCode.BleUnsupported) {
|
|
216
|
-
|
|
270
|
+
emitBleUiWarning(createUiMessage(UI_REQUEST.BLUETOOTH_UNSUPPORTED));
|
|
217
271
|
}
|
|
218
272
|
if (response.payload?.code === HardwareErrorCode.BlePoweredOff) {
|
|
219
|
-
|
|
273
|
+
emitBleUiWarning(createUiMessage(UI_REQUEST.BLUETOOTH_POWERED_OFF));
|
|
220
274
|
}
|
|
221
275
|
if (response.payload?.code === HardwareErrorCode.BlePermissionError) {
|
|
222
|
-
|
|
276
|
+
emitBleUiWarning(createUiMessage(UI_REQUEST.BLUETOOTH_PERMISSION));
|
|
223
277
|
}
|
|
224
278
|
if (response.payload?.code === HardwareErrorCode.BleLocationError) {
|
|
225
|
-
|
|
279
|
+
emitBleUiWarning(createUiMessage(UI_REQUEST.LOCATION_PERMISSION));
|
|
226
280
|
}
|
|
227
281
|
}
|
|
228
282
|
|
|
@@ -239,6 +293,58 @@ const call = async (params: any) => {
|
|
|
239
293
|
const updateSettings = () => Promise.resolve(true);
|
|
240
294
|
const switchTransport = () => Promise.resolve({ success: true });
|
|
241
295
|
|
|
296
|
+
const addHardwareGlobalEventListener = (listener: (message: CoreMessage) => void) => {
|
|
297
|
+
[
|
|
298
|
+
UI_EVENT,
|
|
299
|
+
LOG_EVENT,
|
|
300
|
+
FIRMWARE_EVENT,
|
|
301
|
+
DEVICE.CONNECT,
|
|
302
|
+
DEVICE.DISCONNECT,
|
|
303
|
+
DEVICE.FEATURES,
|
|
304
|
+
DEVICE.STATE,
|
|
305
|
+
DEVICE.SUPPORT_FEATURES,
|
|
306
|
+
].forEach(eventName => {
|
|
307
|
+
eventEmitter.on(eventName, (message: CoreMessage) => {
|
|
308
|
+
// Match the Web SDK envelope for device events emitted as payloads.
|
|
309
|
+
const envelope = message as { event?: string; type?: string } | null | undefined;
|
|
310
|
+
let emitMessage = message;
|
|
311
|
+
if (envelope && typeof envelope === 'object' && !envelope.event && !envelope.type) {
|
|
312
|
+
emitMessage = { ...message };
|
|
313
|
+
Object.assign(emitMessage, { event: eventName, type: eventName });
|
|
314
|
+
}
|
|
315
|
+
listener(emitMessage);
|
|
316
|
+
});
|
|
317
|
+
});
|
|
318
|
+
};
|
|
319
|
+
|
|
320
|
+
export const HardwareSDKLowLevel = HardwareLowLevelSdk({
|
|
321
|
+
eventEmitter,
|
|
322
|
+
init: (settings, sdk, plugin) => init({ ..._settings, ...settings }, sdk, plugin),
|
|
323
|
+
call,
|
|
324
|
+
cancel,
|
|
325
|
+
dispose,
|
|
326
|
+
addHardwareGlobalEventListener,
|
|
327
|
+
uiResponse,
|
|
328
|
+
updateSettings: (settings: Partial<ConnectSettings>) => {
|
|
329
|
+
if (_core || pendingInitializations.size > 0) {
|
|
330
|
+
return Promise.reject(ERRORS.TypedError(HardwareErrorCode.IFrameAleradyInitialized));
|
|
331
|
+
}
|
|
332
|
+
_settings = parseConnectSettings({ ..._settings, ...settings });
|
|
333
|
+
return Promise.resolve(true);
|
|
334
|
+
},
|
|
335
|
+
switchTransport: async (env: ConnectSettings['env']) => {
|
|
336
|
+
const owner = _core;
|
|
337
|
+
if (!owner) throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
|
|
338
|
+
await switchCoreTransport({
|
|
339
|
+
env,
|
|
340
|
+
owner,
|
|
341
|
+
loadTransport: () => getTransport(env),
|
|
342
|
+
plugin: _plugin,
|
|
343
|
+
});
|
|
344
|
+
return { success: true, payload: {} };
|
|
345
|
+
},
|
|
346
|
+
});
|
|
347
|
+
|
|
242
348
|
const HardwareCommonConnectSdk = HardwareSdk({
|
|
243
349
|
eventEmitter,
|
|
244
350
|
init,
|