@trezor/connect 9.0.10 → 9.1.1

package/lib/device/DeviceList.d.ts

@@ -1,21 +1,11 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
-import { Transport, TrezorDeviceInfoWithSession as DeviceDescriptor } from '@trezor/transport';
-import { TRANSPORT, DEVICE, TransportInfo } from '../events';
-import { DescriptorStream } from './DescriptorStream';
+import { TypedEmitter } from '@trezor/utils/lib/typedEventEmitter';
+import { Transport, TRANSPORT, Descriptor } from '@trezor/transport';
+import { DEVICE, TransportInfo } from '../events';
 import { Device } from './Device';
 import type { Device as DeviceTyped } from '../types';
-type LowLevelPlugin = {
-    name: 'WebUsbPlugin' | 'ReactNativePlugin';
-    unreadableHidDeviceChange: {
-        on: (event: string, fn: any) => void;
-    };
-    unreadableHidDevice: boolean;
-};
 interface DeviceListEvents {
     [TRANSPORT.START]: TransportInfo;
     [TRANSPORT.ERROR]: string;
-    [TRANSPORT.STREAM]: DescriptorStream;
     [DEVICE.CONNECT]: DeviceTyped;
     [DEVICE.CONNECT_UNACQUIRED]: DeviceTyped;
     [DEVICE.DISCONNECT]: DeviceTyped;
@@ -23,49 +13,43 @@ interface DeviceListEvents {
     [DEVICE.RELEASED]: DeviceTyped;
     [DEVICE.ACQUIRED]: DeviceTyped;
 }
-export interface DeviceList {
-    on<K extends keyof DeviceListEvents>(type: K, listener: (event: DeviceListEvents[K]) => void): this;
-    off<K extends keyof DeviceListEvents>(type: K, listener: (event: DeviceListEvents[K]) => void): this;
-    emit<K extends keyof DeviceListEvents>(type: K, args: DeviceListEvents[K]): boolean;
-}
-export declare class DeviceList extends EventEmitter {
+export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
     transport: Transport;
-    transportPlugin: LowLevelPlugin | typeof undefined;
-    stream: DescriptorStream;
+    transports: Transport[];
     devices: {
         [path: string]: Device;
     };
+    messages: JSON | Record<string, any>;
     creatingDevicesDescriptors: {
-        [k: string]: DeviceDescriptor;
+        [k: string]: Descriptor;
     };
-    messages: JSON | Record<string, any>;
     transportStartPending: number;
     penalizedDevices: {
         [deviceID: string]: number;
     };
-    fetchController?: AbortController | null;
     constructor();
     init(): Promise<void>;
-    resolveTransportEvent(): void;
+    private resolveTransportEvent;
     waitForTransportFirstEvent(): Promise<void>;
-    _initStream(): void;
-    _createAndSaveDevice(descriptor: DeviceDescriptor): Promise<void>;
-    _createUnacquiredDevice(descriptor: DeviceDescriptor): Device;
-    _createUnreadableDevice(descriptor: DeviceDescriptor, unreadableError: string): Device;
+    private _createAndSaveDevice;
+    private _createUnacquiredDevice;
+    private _createUnreadableDevice;
     getDevice(path: string): Device;
     getFirstDevicePath(): string;
     asArray(): DeviceTyped[];
     allDevices(): Device[];
     length(): number;
-    transportType(): string;
+    transportType(): "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport";
     getTransportInfo(): TransportInfo;
     dispose(): Promise<void>;
     disconnectDevices(): void;
-    enumerate(): void;
+    enumerate(): Promise<void>;
     addAuthPenalty(device: Device): void;
-    getAuthPenalty(): number;
+    private getAuthPenalty;
     removeAuthPenalty(device: Device): void;
+    private handle;
+    private _takeAndCreateDevice;
+    private _handleUsedElsewhere;
 }
-export declare const getDeviceList: () => Promise<DeviceList>;
 export {};
 //# sourceMappingURL=DeviceList.d.ts.map

package/lib/device/DeviceList.js

@@ -1,148 +1,228 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDeviceList = exports.DeviceList = void 0;
-const tslib_1 = require("tslib");
-const events_1 = tslib_1.__importDefault(require("events"));
-const transport_1 = tslib_1.__importDefault(require("@trezor/transport"));
-const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
+exports.DeviceList = void 0;
+const typedEventEmitter_1 = require("@trezor/utils/lib/typedEventEmitter");
+const transport_1 = require("@trezor/transport");
 const constants_1 = require("../constants");
-const events_2 = require("../events");
-const DescriptorStream_1 = require("./DescriptorStream");
+const events_1 = require("../events");
 const Device_1 = require("./Device");
 const DataManager_1 = require("../data/DataManager");
 const transportInfo_1 = require("../data/transportInfo");
 const debug_1 = require("../utils/debug");
 const promiseUtils_1 = require("../utils/promiseUtils");
-const workers_1 = require("../workers/workers");
-const { BridgeV2, Fallback } = transport_1.default;
 const _log = (0, debug_1.initLog)('DeviceList');
 let autoResolveTransportEventTimeout;
-class DeviceList extends events_1.default {
+class DeviceList extends typedEventEmitter_1.TypedEmitter {
     constructor() {
-        var _a;
         super();
+        this.transports = [];
         this.devices = {};
         this.creatingDevicesDescriptors = {};
         this.transportStartPending = 0;
         this.penalizedDevices = {};
-        const env = DataManager_1.DataManager.getSettings('env');
-        let transportSettings = DataManager_1.DataManager.getSettings('transports');
-        const transports = [];
-        if (!(transportSettings === null || transportSettings === void 0 ? void 0 : transportSettings.length)) {
-            transportSettings = ['BridgeTransport'];
-        }
-        if (env === 'react-native' && typeof workers_1.ReactNativeUsbPlugin !== 'undefined') {
-            transports.push((0, workers_1.ReactNativeUsbPlugin)());
-        }
-        else if (transportSettings === null || transportSettings === void 0 ? void 0 : transportSettings.includes('BridgeTransport')) {
-            const bridgeLatestVersion = (0, transportInfo_1.getBridgeInfo)().version.join('.');
-            const bridge = new BridgeV2(undefined, undefined);
-            bridge.setBridgeLatestVersion(bridgeLatestVersion);
-            this.fetchController = new AbortController();
-            const { signal } = this.fetchController;
-            const fetchWithSignal = (args, options = {}) => (0, cross_fetch_1.default)(args, { ...options, signal });
-            const isNode = !!((_a = process === null || process === void 0 ? void 0 : process.release) === null || _a === void 0 ? void 0 : _a.name) && process.release.name.search(/node|io\.js/) !== -1;
-            BridgeV2.setFetch(fetchWithSignal, isNode);
-            transports.push(bridge);
-        }
-        if ((transportSettings === null || transportSettings === void 0 ? void 0 : transportSettings.includes('WebUsbTransport')) && typeof workers_1.WebUsbPlugin !== 'undefined') {
-            transports.push((0, workers_1.WebUsbPlugin)());
-        }
-        this.transport = new Fallback(transports);
+        let { transports } = DataManager_1.DataManager.getSettings();
+        const { debug } = DataManager_1.DataManager.getSettings();
         this.messages = DataManager_1.DataManager.getProtobufMessages();
+        if (!(transports === null || transports === void 0 ? void 0 : transports.length)) {
+            transports = ['BridgeTransport'];
+        }
+        const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
+        transports.forEach(transportType => {
+            if (typeof transportType === 'string') {
+                switch (transportType) {
+                    case 'WebUsbTransport':
+                        this.transports.push(new transport_1.WebUsbTransport({
+                            messages: this.messages,
+                            logger: transportLogger,
+                        }));
+                        break;
+                    case 'NodeUsbTransport':
+                        this.transports.push(new transport_1.NodeUsbTransport({
+                            messages: this.messages,
+                            logger: transportLogger,
+                        }));
+                        break;
+                    case 'BridgeTransport':
+                        this.transports.push(new transport_1.BridgeTransport({
+                            latestVersion: (0, transportInfo_1.getBridgeInfo)().version.join('.'),
+                            messages: this.messages,
+                            logger: transportLogger,
+                        }));
+                        break;
+                    default:
+                        throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
+                }
+            }
+            else if (transportType instanceof transport_1.Transport) {
+                this.transports.unshift(transportType);
+            }
+            else {
+                throw constants_1.ERRORS.TypedError('Runtime', 'DeviceList.init: transports[] of unexpected type');
+            }
+        });
     }
     async init() {
-        const { transport } = this;
         try {
             _log.debug('Initializing transports');
-            await transport.init(_log.enabled);
-            _log.debug('Configuring transports');
-            await transport.configure(JSON.stringify(this.messages));
-            _log.debug('Configuring transports done');
-            const { activeName } = transport;
-            if (activeName === 'WebUsbTransport') {
-                this.transportPlugin = transport.activeTransport.plugin;
+            let lastError;
+            for (const transport of this.transports) {
+                this.transport = transport;
+                const result = await this.transport.init().promise;
+                if (result.success) {
+                    lastError = undefined;
+                    break;
+                }
+                else {
+                    lastError = result.error;
+                }
+            }
+            if (lastError) {
+                this.emit(transport_1.TRANSPORT.ERROR, lastError);
+                return;
+            }
+            this.transport.on(transport_1.TRANSPORT.UPDATE, diff => {
+                diff.connected.forEach(async (descriptor) => {
+                    const path = descriptor.path.toString();
+                    const priority = DataManager_1.DataManager.getSettings('priority');
+                    const penalty = this.getAuthPenalty();
+                    if (priority || penalty) {
+                        await (0, promiseUtils_1.resolveAfter)(501 + penalty + 100 * priority, null).promise;
+                    }
+                    if (descriptor.session == null) {
+                        await this._createAndSaveDevice(descriptor);
+                    }
+                    else {
+                        const device = this._createUnacquiredDevice(descriptor);
+                        this.devices[path] = device;
+                        this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+                    }
+                });
+                diff.acquiredElsewhere.forEach((descriptor) => {
+                    const path = descriptor.path.toString();
+                    const device = this.devices[path];
+                    if (device) {
+                        device.featuresNeedsReload = true;
+                        device.interruptionFromOutside();
+                    }
+                });
+                diff.released.forEach(descriptor => {
+                    var _a;
+                    const path = descriptor.path.toString();
+                    const device = this.devices[path];
+                    const methodStillRunning = !((_a = device === null || device === void 0 ? void 0 : device.commands) === null || _a === void 0 ? void 0 : _a.disposed);
+                    if (device && methodStillRunning) {
+                        device.keepSession = false;
+                    }
+                });
+                diff.releasedElsewhere.forEach(async (descriptor) => {
+                    const path = descriptor.path.toString();
+                    const device = this.devices[path];
+                    await (0, promiseUtils_1.resolveAfter)(1000, null).promise;
+                    if (device) {
+                        if (!device.isUsed() && device.isUnacquired() && !device.isInconsistent()) {
+                            _log.debug('Create device from unacquired', device);
+                            await this._createAndSaveDevice(descriptor);
+                        }
+                    }
+                });
+                const events = [
+                    {
+                        d: diff.changedSessions,
+                        e: events_1.DEVICE.CHANGED,
+                    },
+                    {
+                        d: diff.acquired,
+                        e: events_1.DEVICE.ACQUIRED,
+                    },
+                    {
+                        d: diff.released,
+                        e: events_1.DEVICE.RELEASED,
+                    },
+                ];
+                events.forEach(({ d, e }) => {
+                    d.forEach(descriptor => {
+                        const path = descriptor.path.toString();
+                        const device = this.devices[path];
+                        _log.debug('Event', e, device);
+                        if (device) {
+                            this.emit(e, device.toMessageObject());
+                        }
+                    });
+                });
+                diff.disconnected.forEach(descriptor => {
+                    const path = descriptor.path.toString();
+                    const device = this.devices[path];
+                    if (device) {
+                        device.disconnect();
+                        delete this.devices[path];
+                        this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
+                    }
+                });
+                diff.descriptors.forEach(d => {
+                    if (this.devices[d.path]) {
+                        this.devices[d.path].originalDescriptor = {
+                            session: d.session,
+                            path: d.path,
+                        };
+                    }
+                });
+            });
+            this.transport.on(transport_1.TRANSPORT.ERROR, error => {
+                this.emit(transport_1.TRANSPORT.ERROR, error);
+            });
+            const enumerateResult = await this.transport.enumerate().promise;
+            if (!enumerateResult.success) {
+                this.emit(transport_1.TRANSPORT.ERROR, enumerateResult.error);
+                return;
+            }
+            const descriptors = enumerateResult.payload;
+            if (descriptors.length > 0 && DataManager_1.DataManager.getSettings('pendingTransportEvent')) {
+                this.transportStartPending = descriptors.length;
+                this.on(events_1.DEVICE.CONNECT, this.resolveTransportEvent.bind(this));
+                this.on(events_1.DEVICE.CONNECT_UNACQUIRED, this.resolveTransportEvent.bind(this));
+                autoResolveTransportEventTimeout = setTimeout(() => {
+                    this.emit(transport_1.TRANSPORT.START, this.getTransportInfo());
+                }, 10000);
             }
-            await this._initStream();
-            this.on(events_2.DEVICE.CONNECT, this.resolveTransportEvent.bind(this));
-            this.on(events_2.DEVICE.CONNECT_UNACQUIRED, this.resolveTransportEvent.bind(this));
+            else {
+                this.emit(transport_1.TRANSPORT.START, this.getTransportInfo());
+            }
+            this.transport.handleDescriptorsChange(descriptors);
+            this.transport.listen();
         }
         catch (error) {
-            this.emit(events_2.TRANSPORT.ERROR, error);
+            console.error('DeviceList init error', error);
         }
     }
     resolveTransportEvent() {
         this.transportStartPending--;
+        if (autoResolveTransportEventTimeout) {
+            clearTimeout(autoResolveTransportEventTimeout);
+        }
         if (this.transportStartPending === 0) {
-            this.stream.emit(events_2.TRANSPORT.START);
+            this.emit(transport_1.TRANSPORT.START, this.getTransportInfo());
         }
     }
     async waitForTransportFirstEvent() {
         await new Promise(resolve => {
             const handler = () => {
-                this.removeListener(events_2.TRANSPORT.START, handler);
-                this.removeListener(events_2.TRANSPORT.ERROR, handler);
+                this.removeListener(transport_1.TRANSPORT.START, handler);
+                this.removeListener(transport_1.TRANSPORT.ERROR, handler);
                 resolve();
             };
-            this.on(events_2.TRANSPORT.START, handler);
-            this.on(events_2.TRANSPORT.ERROR, handler);
-        });
-    }
-    _initStream() {
-        const stream = new DescriptorStream_1.DescriptorStream(this.transport);
-        stream.on(events_2.TRANSPORT.START_PENDING, (pending) => {
-            this.transportStartPending = pending;
-            autoResolveTransportEventTimeout = setTimeout(() => {
-                this.resolveTransportEvent();
-            }, 5000);
+            this.on(transport_1.TRANSPORT.START, handler);
+            this.on(transport_1.TRANSPORT.ERROR, handler);
         });
-        stream.on(events_2.TRANSPORT.START, () => {
-            this.emit(events_2.TRANSPORT.START, this.getTransportInfo());
-            if (autoResolveTransportEventTimeout) {
-                clearTimeout(autoResolveTransportEventTimeout);
-            }
-        });
-        stream.on(events_2.TRANSPORT.UPDATE, (diff) => {
-            new DiffHandler(this, diff).handle();
-        });
-        stream.on(events_2.TRANSPORT.ERROR, error => {
-            this.emit(events_2.TRANSPORT.ERROR, error);
-            stream.stop();
-        });
-        stream.listen();
-        this.stream = stream;
-        if (this.transportPlugin && this.transportPlugin.name === 'WebUsbPlugin') {
-            const { unreadableHidDeviceChange } = this.transportPlugin;
-            const UNREADABLE_PATH = 'unreadable';
-            unreadableHidDeviceChange.on('change', () => {
-                if (this.transportPlugin && this.transportPlugin.unreadableHidDevice) {
-                    const device = this._createUnreadableDevice({
-                        path: UNREADABLE_PATH,
-                        session: null,
-                        debugSession: null,
-                        debug: false,
-                    }, 'HID_DEVICE');
-                    this.devices[UNREADABLE_PATH] = device;
-                    this.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
-                }
-                else {
-                    const device = this.devices[UNREADABLE_PATH];
-                    delete this.devices[UNREADABLE_PATH];
-                    this.emit(events_2.DEVICE.DISCONNECT, device.toMessageObject());
-                }
-            });
-        }
-        this.emit(events_2.TRANSPORT.STREAM, stream);
     }
     async _createAndSaveDevice(descriptor) {
         _log.debug('Creating Device', descriptor);
-        await new CreateDeviceHandler(descriptor, this).handle();
+        await this.handle(descriptor);
     }
     _createUnacquiredDevice(descriptor) {
         _log.debug('Creating Unacquired Device', descriptor);
         const device = Device_1.Device.createUnacquired(this.transport, descriptor);
-        device.once(events_2.DEVICE.ACQUIRED, () => {
-            this.emit(events_2.DEVICE.CONNECT, device.toMessageObject());
+        device.once(events_1.DEVICE.ACQUIRED, () => {
+            this.emit(events_1.DEVICE.CONNECT, device.toMessageObject());
         });
         return device;
     }
@@ -166,9 +246,7 @@ class DeviceList extends events_1.default {
         return this.asArray().length;
     }
     transportType() {
-        const { transport } = this;
-        const { activeName } = transport;
-        return activeName || 'UnknownTransport';
+        return this.transport.name;
     }
     getTransportInfo() {
         return {
@@ -179,35 +257,29 @@ class DeviceList extends events_1.default {
     }
     async dispose() {
         this.removeAllListeners();
-        if (this.stream) {
-            this.stream.stop();
-        }
         if (autoResolveTransportEventTimeout) {
             clearTimeout(autoResolveTransportEventTimeout);
         }
         await Promise.all(this.allDevices().map(device => device.dispose()));
-        if (this.transport) {
-            this.transport.stop();
-        }
-        if (this.fetchController) {
-            this.fetchController.abort();
-            this.fetchController = null;
-        }
+        this.transport.stop();
     }
     disconnectDevices() {
         this.allDevices().forEach(device => {
-            this.emit(events_2.DEVICE.DISCONNECT, device.toMessageObject());
+            this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
         });
     }
-    enumerate() {
-        this.stream.enumerate();
-        if (!this.stream.current)
+    async enumerate() {
+        const res = await this.transport.enumerate().promise;
+        if (!res.success) {
             return;
-        this.stream.current.forEach(descriptor => {
-            const path = descriptor.path.toString();
-            const device = this.devices[path];
-            if (device) {
-                device.updateDescriptor(descriptor);
+        }
+        res.payload.forEach(d => {
+            if (this.devices[d.path]) {
+                this.devices[d.path].originalDescriptor = {
+                    session: d.session,
+                    path: d.path,
+                };
+                this.devices[d.path].activitySessionID = d.session;
             }
         });
     }
@@ -230,164 +302,58 @@ class DeviceList extends events_1.default {
         const deviceID = device.features.device_id;
         delete this.penalizedDevices[deviceID];
     }
-}
-exports.DeviceList = DeviceList;
-const getDeviceList = async () => {
-    const list = new DeviceList();
-    await list.init();
-    return list;
-};
-exports.getDeviceList = getDeviceList;
-class CreateDeviceHandler {
-    constructor(descriptor, list) {
-        this.descriptor = descriptor;
-        this.list = list;
-        this.path = descriptor.path.toString();
-    }
-    async handle() {
+    async handle(descriptor) {
         var _a;
-        this.list.creatingDevicesDescriptors[this.path] = this.descriptor;
+        const path = descriptor.path.toString();
+        this.creatingDevicesDescriptors[path] = descriptor;
         try {
-            await this._takeAndCreateDevice();
+            await this._takeAndCreateDevice(descriptor);
         }
         catch (error) {
             _log.debug('Cannot create device', error);
-            if (error.code === 'Device_NotFound' || error.message === 'device not found') {
+            if (error.code === 'Device_NotFound' ||
+                error.message === transport_1.TRANSPORT_ERROR.DEVICE_NOT_FOUND ||
+                error.message === transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION ||
+                error.message === transport_1.TRANSPORT_ERROR.UNEXPECTED_ERROR ||
+                error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE) {
+                delete this.devices[path];
             }
-            else if (error.message === constants_1.ERRORS.WRONG_PREVIOUS_SESSION_ERROR_MESSAGE ||
-                error.toString() === constants_1.ERRORS.WEBUSB_ERROR_MESSAGE) {
-                this.list.enumerate();
-                this._handleUsedElsewhere();
+            else if (error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS) {
+                this.enumerate();
+                this._handleUsedElsewhere(descriptor);
             }
             else if (((_a = error.message) === null || _a === void 0 ? void 0 : _a.indexOf(constants_1.ERRORS.LIBUSB_ERROR_MESSAGE)) >= 0) {
-                const device = this.list._createUnreadableDevice(this.list.creatingDevicesDescriptors[this.path], error.message);
-                this.list.devices[this.path] = device;
-                this.list.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+                const device = this._createUnreadableDevice(this.creatingDevicesDescriptors[path], error.message);
+                this.devices[path] = device;
+                this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
             }
             else if (error.code === 'Device_InitializeFailed') {
-                this._handleUsedElsewhere();
+                this._handleUsedElsewhere(descriptor);
             }
             else if (error.code === 'Device_UsedElsewhere') {
-                this._handleUsedElsewhere();
+                this._handleUsedElsewhere(descriptor);
             }
             else {
                 await (0, promiseUtils_1.resolveAfter)(501, null).promise;
-                await this.handle();
+                await this.handle(descriptor);
             }
         }
-        delete this.list.creatingDevicesDescriptors[this.path];
-    }
-    async _takeAndCreateDevice() {
-        const device = Device_1.Device.fromDescriptor(this.list.transport, this.descriptor);
-        this.list.devices[this.path] = device;
-        await device.run();
-        this.list.emit(events_2.DEVICE.CONNECT, device.toMessageObject());
-    }
-    _handleUsedElsewhere() {
-        const device = this.list._createUnacquiredDevice(this.list.creatingDevicesDescriptors[this.path]);
-        this.list.devices[this.path] = device;
-        this.list.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
-    }
-}
-class DiffHandler {
-    constructor(list, diff) {
-        this.list = list;
-        this.diff = diff;
-    }
-    handle() {
-        _log.debug('Update DescriptorStream', this.diff);
-        this._createConnectedDevices();
-        this._createReleasedDevices();
-        this._signalAcquiredDevices();
-        this._updateDescriptors();
-        this._emitEvents();
-        this._disconnectDevices();
-    }
-    _updateDescriptors() {
-        this.diff.descriptors.forEach((descriptor) => {
-            const path = descriptor.path.toString();
-            const device = this.list.devices[path];
-            if (device) {
-                device.updateDescriptor(descriptor);
-            }
-        });
-    }
-    _emitEvents() {
-        const events = [
-            {
-                d: this.diff.changedSessions,
-                e: events_2.DEVICE.CHANGED,
-            },
-            {
-                d: this.diff.acquired,
-                e: events_2.DEVICE.ACQUIRED,
-            },
-            {
-                d: this.diff.released,
-                e: events_2.DEVICE.RELEASED,
-            },
-        ];
-        events.forEach(({ d, e }) => {
-            d.forEach(descriptor => {
-                const path = descriptor.path.toString();
-                const device = this.list.devices[path];
-                _log.debug('Event', e, device);
-                if (device) {
-                    this.list.emit(e, device.toMessageObject());
-                }
-            });
-        });
-    }
-    _createConnectedDevices() {
-        this.diff.connected.forEach(async (descriptor) => {
-            const path = descriptor.path.toString();
-            const priority = DataManager_1.DataManager.getSettings('priority');
-            const penalty = this.list.getAuthPenalty();
-            _log.debug('Connected', priority, penalty, descriptor.session, this.list.devices);
-            if (priority || penalty) {
-                await (0, promiseUtils_1.resolveAfter)(501 + penalty + 100 * priority, null).promise;
-            }
-            if (descriptor.session == null) {
-                await this.list._createAndSaveDevice(descriptor);
-            }
-            else {
-                const device = await this.list._createUnacquiredDevice(descriptor);
-                this.list.devices[path] = device;
-                this.list.emit(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
-            }
-        });
-    }
-    _signalAcquiredDevices() {
-        this.diff.acquired.forEach(descriptor => {
-            const path = descriptor.path.toString();
-            if (this.list.creatingDevicesDescriptors[path]) {
-                this.list.creatingDevicesDescriptors[path] = descriptor;
-            }
-        });
-    }
-    _createReleasedDevices() {
-        this.diff.released.forEach(async (descriptor) => {
-            const path = descriptor.path.toString();
-            const device = this.list.devices[path];
-            if (device) {
-                if (device.isUnacquired() && !device.isInconsistent()) {
-                    await (0, promiseUtils_1.resolveAfter)(501, null).promise;
-                    _log.debug('Create device from unacquired', device);
-                    await this.list._createAndSaveDevice(descriptor);
-                }
-            }
-        });
-    }
-    _disconnectDevices() {
-        this.diff.disconnected.forEach(descriptor => {
-            const path = descriptor.path.toString();
-            const device = this.list.devices[path];
-            if (device != null) {
-                device.disconnect();
-                delete this.list.devices[path];
-                this.list.emit(events_2.DEVICE.DISCONNECT, device.toMessageObject());
-            }
-        });
+        delete this.creatingDevicesDescriptors[path];
+    }
+    async _takeAndCreateDevice(descriptor) {
+        const device = Device_1.Device.fromDescriptor(this.transport, descriptor);
+        const path = descriptor.path.toString();
+        this.devices[path] = device;
+        const promise = device.run();
+        await promise;
+        this.emit(events_1.DEVICE.CONNECT, device.toMessageObject());
+    }
+    _handleUsedElsewhere(descriptor) {
+        const path = descriptor.path.toString();
+        const device = this._createUnacquiredDevice(this.creatingDevicesDescriptors[path]);
+        this.devices[path] = device;
+        this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
     }
 }
+exports.DeviceList = DeviceList;
 //# sourceMappingURL=DeviceList.js.map