@onekeyfe/hd-core 0.1.26 → 0.1.29

package/dist/index.js

@@ -75,6 +75,7 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
         stellarGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'stellarGetAddress' })),
         stellarSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'stellarSignTransaction' })),
         firmwareUpdate: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareUpdate' })),
+        requestWebUsbDevice: () => call({ method: 'requestWebUsbDevice' }),
     };
     return api;
 };
@@ -9657,7 +9658,7 @@ const createLogMessage = (type, payload) => ({
 
 const MAX_ENTRIES = 500;
 let postMessage$1;
-class Log$6 {
+class Log$7 {
     constructor(prefix, enabled) {
         this.prefix = prefix;
         this.enabled = enabled;
@@ -9709,7 +9710,7 @@ class Log$6 {
 }
 const _logs = {};
 const initLog = (prefix, enabled) => {
-    const instance = new Log$6(prefix, !!enabled);
+    const instance = new Log$7(prefix, !!enabled);
     _logs[prefix] = instance;
     return instance;
 };
@@ -9770,6 +9771,8 @@ exports.LoggerNames = void 0;
     LoggerNames["DeviceCommands"] = "DeviceCommands";
     LoggerNames["DeviceConnector"] = "DeviceConnector";
     LoggerNames["DeviceList"] = "DeviceList";
+    LoggerNames["DevicePool"] = "DevicePool";
+    LoggerNames["HdCommonConnectSdk"] = "@onekey/common-connect-sdk";
     LoggerNames["HdBleSdk"] = "@onekey/hd-ble-sdk";
     LoggerNames["HdTransportHttp"] = "@onekey/hd-transport-http";
     LoggerNames["HdBleTransport"] = "@onekey/hd-ble-transport";
@@ -9785,6 +9788,7 @@ const LoggerMap = {
     [exports.LoggerNames.DeviceCommands]: initLog(exports.LoggerNames.DeviceCommands),
     [exports.LoggerNames.DeviceConnector]: initLog(exports.LoggerNames.DeviceConnector),
     [exports.LoggerNames.DeviceList]: initLog(exports.LoggerNames.DeviceList),
+    [exports.LoggerNames.DevicePool]: initLog(exports.LoggerNames.DevicePool),
     [exports.LoggerNames.HdBleSdk]: initLog(exports.LoggerNames.HdBleSdk),
     [exports.LoggerNames.HdTransportHttp]: initLog(exports.LoggerNames.HdTransportHttp),
     [exports.LoggerNames.HdBleTransport]: initLog(exports.LoggerNames.HdBleTransport),
@@ -9792,6 +9796,7 @@ const LoggerMap = {
     [exports.LoggerNames.Iframe]: initLog(exports.LoggerNames.Iframe),
     [exports.LoggerNames.SendMessage]: initLog(exports.LoggerNames.SendMessage),
     [exports.LoggerNames.Method]: initLog(exports.LoggerNames.Method),
+    [exports.LoggerNames.HdCommonConnectSdk]: initLog(exports.LoggerNames.Method),
 };
 const getLogger = (key) => LoggerMap[key];
 
@@ -9935,83 +9940,6 @@ DataManager.getTransportStatus = (localVersion) => {
     return isLatest ? 'valid' : 'outdated';
 };
 
-const Log$5 = getLogger(exports.LoggerNames.Transport);
-const BleLogger = getLogger(exports.LoggerNames.HdBleTransport);
-const HttpLogger = getLogger(exports.LoggerNames.HdTransportHttp);
-class TransportManager {
-    static load() {
-        Log$5.debug('transport manager load');
-        this.defaultMessages = DataManager.getProtobufMessages();
-        this.currentMessages = this.defaultMessages;
-    }
-    static configure() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const env = DataManager.getSettings('env');
-                Log$5.debug('Initializing transports');
-                if (env === 'react-native') {
-                    if (!this.reactNativeInit) {
-                        yield this.transport.init(BleLogger);
-                        this.reactNativeInit = true;
-                    }
-                    else {
-                        Log$5.debug('React Native Do Not Initializing transports');
-                    }
-                }
-                else {
-                    yield this.transport.init(HttpLogger);
-                }
-                Log$5.debug('Configuring transports');
-                yield this.transport.configure(JSON.stringify(this.defaultMessages));
-                Log$5.debug('Configuring transports done');
-            }
-            catch (error) {
-                Log$5.debug('Initializing transports error: ', error);
-                if (error.code === 'ECONNABORTED') {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
-                }
-            }
-        });
-    }
-    static reconfigure(messages) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (Array.isArray(messages)) {
-                messages = DataManager.getProtobufMessages();
-            }
-            if (this.currentMessages === messages || !messages) {
-                return;
-            }
-            try {
-                yield this.transport.configure(JSON.stringify(messages));
-                this.currentMessages = messages;
-            }
-            catch (error) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
-            }
-        });
-    }
-    static setTransport(TransportConstructor) {
-        const env = DataManager.getSettings('env');
-        if (env === 'react-native') {
-            this.transport = new TransportConstructor({ scanTimeout: 3000 });
-        }
-        else {
-            this.transport = new TransportConstructor();
-        }
-        Log$5.debug('set transport: ', this.transport);
-    }
-    static getTransport() {
-        return this.transport;
-    }
-    static getDefaultMessages() {
-        return this.defaultMessages;
-    }
-    static getCurrentMessages() {
-        return this.currentMessages;
-    }
-}
-TransportManager.reactNativeInit = false;
-
 const CORE_EVENT = 'CORE_EVENT';
 const parseMessage = (messageData) => {
     const { data } = messageData;
@@ -10124,6 +10052,279 @@ const createFirmwareMessage = (type, payload) => ({
     payload,
 });
 
+const Log$6 = getLogger(exports.LoggerNames.DevicePool);
+const getDiff = (current, descriptors) => {
+    const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
+    const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
+    const changedSessions = descriptors.filter(d => {
+        const currentDescriptor = current.find(x => x.path === d.path);
+        if (currentDescriptor) {
+            return currentDescriptor.session !== d.session;
+        }
+        return false;
+    });
+    const acquired = changedSessions.filter(d => typeof d.session === 'string');
+    const released = changedSessions.filter(d => typeof d.session !== 'string');
+    const changedDebugSessions = descriptors.filter(d => {
+        const currentDescriptor = current.find(x => x.path === d.path);
+        if (currentDescriptor) {
+            return currentDescriptor.debugSession !== d.debugSession;
+        }
+        return false;
+    });
+    const debugAcquired = changedSessions.filter(d => typeof d.debugSession === 'string');
+    const debugReleased = changedSessions.filter(d => typeof d.debugSession !== 'string');
+    const didUpdate = connected.length + disconnected.length + changedSessions.length + changedDebugSessions.length >
+        0;
+    return {
+        connected,
+        disconnected,
+        changedSessions,
+        acquired,
+        released,
+        changedDebugSessions,
+        debugAcquired,
+        debugReleased,
+        didUpdate,
+        descriptors,
+    };
+};
+class DevicePool extends events.exports {
+    static setConnector(connector) {
+        this.connector = connector;
+    }
+    static getDevices(descriptorList, connectId) {
+        var descriptorList_1, descriptorList_1_1;
+        var e_1, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            Log$6.debug('get device list');
+            const devices = {};
+            const deviceList = [];
+            if (connectId) {
+                const device = this.devicesCache[connectId];
+                if (device) {
+                    const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
+                    if (exist) {
+                        Log$6.debug('find existed Device: ', connectId);
+                        device.updateDescriptor(exist, true);
+                        devices[connectId] = device;
+                        deviceList.push(device);
+                        yield this._checkDevicePool();
+                        return { devices, deviceList };
+                    }
+                    Log$6.debug('found device in cache, but path is different: ', connectId);
+                }
+            }
+            try {
+                for (descriptorList_1 = __asyncValues(descriptorList); descriptorList_1_1 = yield descriptorList_1.next(), !descriptorList_1_1.done;) {
+                    const descriptor = descriptorList_1_1.value;
+                    const device = yield this._createDevice(descriptor);
+                    if (device.features) {
+                        const uuid = getDeviceUUID(device.features);
+                        if (this.devicesCache[uuid]) {
+                            const cache = this.devicesCache[uuid];
+                            cache.updateDescriptor(descriptor, true);
+                        }
+                        this.devicesCache[uuid] = device;
+                        devices[uuid] = device;
+                    }
+                    deviceList.push(device);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (descriptorList_1_1 && !descriptorList_1_1.done && (_a = descriptorList_1.return)) yield _a.call(descriptorList_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            Log$6.debug('get devices result : ', devices, deviceList);
+            console.log('device poll -> connected: ', this.connectedPool);
+            console.log('device poll -> disconnected: ', this.disconnectPool);
+            yield this._checkDevicePool();
+            return { devices, deviceList };
+        });
+    }
+    static _createDevice(descriptor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let device = this.getDeviceByPath(descriptor.path);
+            if (!device) {
+                device = Device.fromDescriptor(descriptor);
+                device.deviceConnector = this.connector;
+                yield device.connect();
+                yield device.initialize();
+                yield device.release();
+            }
+            return device;
+        });
+    }
+    static _checkDevicePool() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._sendConnectMessage();
+            this._sendDisconnectMessage();
+        });
+    }
+    static _sendConnectMessage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let i = this.connectedPool.length - 1; i >= 0; i--) {
+                const descriptor = this.connectedPool[i];
+                const device = yield this._createDevice(descriptor);
+                Log$6.debug('emit DEVICE.CONNECT: ', device);
+                this.emitter.emit(DEVICE.CONNECT, device);
+                this.connectedPool.splice(i, 1);
+            }
+        });
+    }
+    static _sendDisconnectMessage() {
+        for (let i = this.disconnectPool.length - 1; i >= 0; i--) {
+            const descriptor = this.connectedPool[i];
+            const device = this.getDeviceByPath(descriptor.path);
+            if (device) {
+                this.emitter.emit(DEVICE.DISCONNECT, device);
+            }
+            this.disconnectPool.splice(i, 1);
+        }
+    }
+    static reportDeviceChange(upcoming) {
+        const diff = getDiff(this.current || [], upcoming);
+        this.upcoming = upcoming;
+        this.current = this.upcoming;
+        console.log('device pool -> current: ', this.current);
+        console.log('device pool -> upcomming: ', this.upcoming);
+        console.log('DeviceCache.reportDeviceChange diff: ', diff);
+        if (!diff.didUpdate) {
+            return;
+        }
+        diff.connected.forEach(d => {
+            const device = this.getDeviceByPath(d.path);
+            if (!device) {
+                this._addConnectedDeviceToPool(d);
+                return;
+            }
+            Log$6.debug('emit DEVICE.CONNECT: ', device);
+            this.emitter.emit(DEVICE.CONNECT, device);
+        });
+        diff.disconnected.forEach(d => {
+            this._removeDeviceFromConnectedPool(d.path);
+            const device = this.getDeviceByPath(d.path);
+            if (!device) {
+                this._addDisconnectedDeviceToPool(d);
+                return;
+            }
+            Log$6.debug('emit DEVICE.DISCONNECT: ', device);
+            this.emitter.emit(DEVICE.DISCONNECT, device);
+        });
+    }
+    static getDeviceByPath(path) {
+        return Object.values(this.devicesCache).find(d => d.originalDescriptor.path === path);
+    }
+    static _addConnectedDeviceToPool(descriptor) {
+        const existDescriptorIndex = this.connectedPool.findIndex(d => d.path === descriptor.path);
+        if (existDescriptorIndex > -1) {
+            this.connectedPool.splice(existDescriptorIndex, 1, descriptor);
+            return;
+        }
+        this.connectedPool.push(descriptor);
+    }
+    static _removeDeviceFromConnectedPool(path) {
+        const index = this.connectedPool.findIndex(d => d.path === path);
+        if (index > -1) {
+            this.connectedPool.splice(index, 1);
+        }
+    }
+    static _addDisconnectedDeviceToPool(descriptor) {
+        const existDescriptorIndex = this.disconnectPool.findIndex(d => d.path === descriptor.path);
+        if (existDescriptorIndex > -1) {
+            this.disconnectPool.splice(existDescriptorIndex, 1, descriptor);
+            return;
+        }
+        this.disconnectPool.push(descriptor);
+    }
+}
+DevicePool.current = null;
+DevicePool.upcoming = [];
+DevicePool.connectedPool = [];
+DevicePool.disconnectPool = [];
+DevicePool.devicesCache = {};
+DevicePool.emitter = new events.exports();
+
+const Log$5 = getLogger(exports.LoggerNames.Transport);
+const BleLogger = getLogger(exports.LoggerNames.HdBleTransport);
+const HttpLogger = getLogger(exports.LoggerNames.HdTransportHttp);
+class TransportManager {
+    static load() {
+        Log$5.debug('transport manager load');
+        this.defaultMessages = DataManager.getProtobufMessages();
+        this.currentMessages = this.defaultMessages;
+    }
+    static configure() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const env = DataManager.getSettings('env');
+                Log$5.debug('Initializing transports');
+                if (env === 'react-native') {
+                    if (!this.reactNativeInit) {
+                        yield this.transport.init(BleLogger, DevicePool.emitter);
+                        this.reactNativeInit = true;
+                    }
+                    else {
+                        Log$5.debug('React Native Do Not Initializing transports');
+                    }
+                }
+                else {
+                    yield this.transport.init(HttpLogger);
+                }
+                Log$5.debug('Configuring transports');
+                yield this.transport.configure(JSON.stringify(this.defaultMessages));
+                Log$5.debug('Configuring transports done');
+            }
+            catch (error) {
+                Log$5.debug('Initializing transports error: ', error);
+                if (error.code === 'ECONNABORTED') {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
+                }
+            }
+        });
+    }
+    static reconfigure(messages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Array.isArray(messages)) {
+                messages = DataManager.getProtobufMessages();
+            }
+            if (this.currentMessages === messages || !messages) {
+                return;
+            }
+            try {
+                yield this.transport.configure(JSON.stringify(messages));
+                this.currentMessages = messages;
+            }
+            catch (error) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
+            }
+        });
+    }
+    static setTransport(TransportConstructor) {
+        const env = DataManager.getSettings('env');
+        if (env === 'react-native') {
+            this.transport = new TransportConstructor({ scanTimeout: 3000 });
+        }
+        else {
+            this.transport = new TransportConstructor();
+        }
+        Log$5.debug('set transport: ', this.transport);
+    }
+    static getTransport() {
+        return this.transport;
+    }
+    static getDefaultMessages() {
+        return this.defaultMessages;
+    }
+    static getCurrentMessages() {
+        return this.currentMessages;
+    }
+}
+TransportManager.reactNativeInit = false;
+
 const assertType = (res, resType) => {
     const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
     if (!splitResTypes.includes(res.type)) {
@@ -10240,7 +10441,11 @@ class DeviceCommands {
             return this._commonCall('ButtonAck', {});
         }
         if (res.type === 'EntropyRequest') ;
+        const isWebusbEnv = DataManager.getSettings('env') === 'webusb';
         if (res.type === 'PinMatrixRequest') {
+            if (isWebusbEnv) {
+                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please unlock your device'));
+            }
             return this._promptPin(res.message.type).then(pin => {
                 if (pin === '@@ONEKEY_INPUT_PIN_IN_DEVICE') {
                     return this._commonCall('BixinPinInputOnDevice');
@@ -10711,62 +10916,19 @@ class Device extends events.exports {
     }
 }
 
-const cacheDeviceMap = {};
-const Log$2 = getLogger(exports.LoggerNames.DeviceList);
 class DeviceList extends events.exports {
     constructor() {
         super(...arguments);
         this.devices = {};
     }
     getDeviceLists(connectId) {
-        var e_1, _a;
-        var _b, _c;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const deviceDiff = yield ((_b = this.connector) === null || _b === void 0 ? void 0 : _b.enumerate());
-            const descriptorList = (_c = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _c !== void 0 ? _c : [];
+            const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
+            const descriptorList = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
             this.devices = {};
-            const deviceList = [];
-            Log$2.debug('get device list');
-            if (connectId) {
-                const device = cacheDeviceMap[connectId];
-                if (device) {
-                    const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
-                    if (exist) {
-                        device.updateDescriptor(exist, true);
-                        Log$2.debug('find existed Device: ', connectId);
-                        this.devices[connectId] = device;
-                        return [device];
-                    }
-                }
-            }
-            try {
-                for (var descriptorList_1 = __asyncValues(descriptorList), descriptorList_1_1; descriptorList_1_1 = yield descriptorList_1.next(), !descriptorList_1_1.done;) {
-                    const descriptor = descriptorList_1_1.value;
-                    let device = Device.fromDescriptor(descriptor);
-                    device.deviceConnector = this.connector;
-                    yield device.connect();
-                    yield device.initialize();
-                    yield device.release();
-                    deviceList.push(device);
-                    if (device.features) {
-                        const uuid = getDeviceUUID(device.features);
-                        if (cacheDeviceMap[uuid]) {
-                            const cache = cacheDeviceMap[uuid];
-                            cache === null || cache === void 0 ? void 0 : cache.updateFromCache(device);
-                            device = cache;
-                        }
-                        this.devices[uuid] = device;
-                        cacheDeviceMap[uuid] = device;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (descriptorList_1_1 && !descriptorList_1_1.done && (_a = descriptorList_1.return)) yield _a.call(descriptorList_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
+            const { deviceList, devices } = yield DevicePool.getDevices(descriptorList, connectId);
+            this.devices = devices;
             return deviceList;
         });
     }
@@ -10845,12 +11007,11 @@ class SearchDevices extends BaseMethod {
         this.useDevice = false;
     }
     run() {
-        var e_1, _a;
-        var _b, _c;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             yield TransportManager.configure();
-            const deviceDiff = yield ((_b = this.connector) === null || _b === void 0 ? void 0 : _b.enumerate());
-            const devicesDescriptor = (_c = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _c !== void 0 ? _c : [];
+            const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
+            const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
             const env = DataManager.getSettings('env');
             if (env === 'react-native') {
                 return devicesDescriptor.map(device => {
@@ -10858,26 +11019,8 @@ class SearchDevices extends BaseMethod {
                     return (Object.assign(Object.assign({}, device), { connectId: device.id, deviceType: getDeviceTypeByBleName((_a = device.name) !== null && _a !== void 0 ? _a : '') }));
                 });
             }
-            const devices = [];
-            try {
-                for (var devicesDescriptor_1 = __asyncValues(devicesDescriptor), devicesDescriptor_1_1; devicesDescriptor_1_1 = yield devicesDescriptor_1.next(), !devicesDescriptor_1_1.done;) {
-                    const descriptor = devicesDescriptor_1_1.value;
-                    const device = Device.fromDescriptor(descriptor);
-                    device.deviceConnector = this.connector;
-                    yield device.connect();
-                    yield device.initialize();
-                    yield device.release();
-                    devices.push(device);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (devicesDescriptor_1_1 && !devicesDescriptor_1_1.done && (_a = devicesDescriptor_1.return)) yield _a.call(devicesDescriptor_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            return devices.map(device => device.toMessageObject());
+            const { deviceList } = yield DevicePool.getDevices(devicesDescriptor);
+            return deviceList.map(device => device.toMessageObject());
         });
     }
 }
@@ -13481,6 +13624,36 @@ class FirmwareUpdate extends BaseMethod {
     }
 }
 
+const Log$2 = getLogger(exports.LoggerNames.Method);
+class RequestWebUsbDevice extends BaseMethod {
+    init() {
+        this.useDevice = false;
+    }
+    run() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield TransportManager.configure();
+            const env = DataManager.getSettings('env');
+            if (env !== 'webusb') {
+                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Not webusb environment'));
+            }
+            try {
+                const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
+                const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
+                const { deviceList } = yield DevicePool.getDevices(devicesDescriptor);
+                if (deviceList.length > 0) {
+                    return { device: deviceList[0].toMessageObject() };
+                }
+                return yield Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+            }
+            catch (error) {
+                Log$2.debug(error);
+                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+            }
+        });
+    }
+}
+
 class CheckBridgeStatus extends BaseMethod {
     init() {
         this.useDevice = false;
@@ -13537,6 +13710,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     stellarGetAddress: StellarGetAddress,
     stellarSignTransaction: StellarSignTransaction,
     firmwareUpdate: FirmwareUpdate,
+    requestWebUsbDevice: RequestWebUsbDevice,
     getLogs: CheckBridgeStatus
 });
 
@@ -13572,48 +13746,6 @@ const resolveAfter = (msec, value) => new Promise(resolve => {
 });
 
 const Log$1 = getLogger(exports.LoggerNames.DeviceConnector);
-const getDiff = (current, descriptors) => {
-    const env = DataManager.getSettings('env');
-    if (env === 'react-native') {
-        return {
-            descriptors,
-        };
-    }
-    const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
-    const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
-    const changedSessions = descriptors.filter(d => {
-        const currentDescriptor = current.find(x => x.path === d.path);
-        if (currentDescriptor) {
-            return currentDescriptor.session !== d.session;
-        }
-        return false;
-    });
-    const acquired = changedSessions.filter(d => typeof d.session === 'string');
-    const released = changedSessions.filter(d => typeof d.session !== 'string');
-    const changedDebugSessions = descriptors.filter(d => {
-        const currentDescriptor = current.find(x => x.path === d.path);
-        if (currentDescriptor) {
-            return currentDescriptor.debugSession !== d.debugSession;
-        }
-        return false;
-    });
-    const debugAcquired = changedSessions.filter(d => typeof d.debugSession === 'string');
-    const debugReleased = changedSessions.filter(d => typeof d.debugSession !== 'string');
-    const didUpdate = connected.length + disconnected.length + changedSessions.length + changedDebugSessions.length >
-        0;
-    return {
-        connected,
-        disconnected,
-        changedSessions,
-        acquired,
-        released,
-        changedDebugSessions,
-        debugAcquired,
-        debugReleased,
-        didUpdate,
-        descriptors,
-    };
-};
 class DeviceConnector {
     constructor() {
         this.listenTimestamp = 0;
@@ -13622,14 +13754,15 @@ class DeviceConnector {
         this.listening = false;
         TransportManager.load();
         this.transport = TransportManager.getTransport();
+        DevicePool.setConnector(this);
     }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                this.upcoming = yield this.transport.enumerate();
-                const diff = this._reportDevicesChange();
-                Log$1.debug('diff result: ', diff);
-                return diff;
+                const descriptors = yield this.transport.enumerate();
+                this.upcoming = descriptors;
+                this._reportDevicesChange();
+                return { descriptors };
             }
             catch (error) {
                 safeThrowError(error);
@@ -13704,9 +13837,7 @@ class DeviceConnector {
         });
     }
     _reportDevicesChange() {
-        const diff = getDiff(this.current || [], this.upcoming);
-        this.current = this.upcoming;
-        return diff;
+        DevicePool.reportDeviceChange(this.upcoming);
     }
 }
 
@@ -13736,6 +13867,7 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
     catch (error) {
         return Promise.reject(error);
     }
+    DevicePool.emitter.on(DEVICE.CONNECT, onDeviceConnectHandler);
     if (!method.useDevice) {
         try {
             const response = yield method.run();
@@ -13775,12 +13907,12 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
             if (versionRange && device.features) {
                 const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
                 if (semver__default["default"].valid(versionRange.min) && semver__default["default"].lt(currentVersion, versionRange.min)) {
-                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceFwException, `Device firmware version is too low, please update to ${versionRange.min}`));
+                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodNeedUpgradeFirmware, `Device firmware version is too low, please update to ${versionRange.min}`, { current: currentVersion, require: versionRange.min }));
                 }
                 if (versionRange.max &&
                     semver__default["default"].valid(versionRange.max) &&
-                    semver__default["default"].gt(currentVersion, versionRange.max)) {
-                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceFwException, `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`));
+                    semver__default["default"].gte(currentVersion, versionRange.max)) {
+                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodDeprecated, `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`, { current: currentVersion, deprecated: versionRange.max }));
                 }
             }
             const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
@@ -14014,10 +14146,21 @@ const removeDeviceListener = (device) => {
     device.removeListener(DEVICE.PIN, onDevicePinHandler);
     device.removeListener(DEVICE.BUTTON, onDeviceButtonHandler);
     device.removeListener(DEVICE.FEATURES, onDeviceFeaturesHandler);
+    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
 };
 const closePopup = () => {
     postMessage(createUiMessage(UI_REQUEST$1.CLOSE_UI_WINDOW));
 };
+const onDeviceConnectHandler = (device) => {
+    const env = DataManager.getSettings('env');
+    const deviceObject = env === 'react-native' ? device : device.toMessageObject();
+    postMessage(createDeviceMessage(DEVICE.CONNECT, { device: deviceObject }));
+};
+const onDeviceDisconnectHandler = (device) => {
+    const env = DataManager.getSettings('env');
+    const deviceObject = env === 'react-native' ? device : device.toMessageObject();
+    postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject }));
+};
 const onDevicePinHandler = (...[device, type, callback]) => __awaiter(void 0, void 0, void 0, function* () {
     Log.debug('onDevicePinHandler');
     const uiPromise = createUiPromise(UI_RESPONSE.RECEIVE_PIN, device);
@@ -14093,6 +14236,7 @@ const initCore = () => {
 };
 const initConnector = () => {
     _connector = new DeviceConnector();
+    DevicePool.emitter.on(DEVICE.DISCONNECT, onDeviceDisconnectHandler);
     return _connector;
 };
 const initTransport = (Transport) => {