incyclist-devices 1.5.38 → 2.0.0

package/lib/ble/ble-interface.js

@@ -13,23 +13,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("../utils");
-const ble_1 = require("./ble");
-const ble_2 = require("./ble");
-const ble_peripheral_1 = __importDefault(require("./ble-peripheral"));
-const CONNECT_TIMEOUT = 5000;
+const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+const utils_1 = require("./utils");
+const comms_utils_1 = require("./base/comms-utils");
+const peripheral_cache_1 = __importDefault(require("./peripheral-cache"));
+const events_1 = __importDefault(require("events"));
+const utils_2 = require("../utils/utils");
 const DEFAULT_SCAN_TIMEOUT = 20000;
-class BleInterface extends ble_1.BleInterfaceClass {
-    constructor(props = {}) {
-        super(props);
-        this.scanState = { isScanning: false, isConnecting: false, timeout: undefined, isBackgroundScan: false };
-        this.connectState = { isConnecting: false, isConnected: false, isInitSuccess: false };
-        this.devices = [];
-        this.peripheralCache = [];
-        if (props.logger)
-            this.logger = props.logger;
-        this.logger = new gd_eventlog_1.EventLogger('BLE');
-    }
+class BleInterface extends events_1.default {
     static getInstance(props = {}) {
         if (!BleInterface._instance) {
             BleInterface._instance = new BleInterface(props);
@@ -47,10 +38,42 @@ class BleInterface extends ble_1.BleInterfaceClass {
         }
         return BleInterface._instance;
     }
-    static register(id, type, Class, services) {
-        if (this.deviceClasses.find(i => i.id === id))
+    constructor(props = {}) {
+        super();
+        this.scanState = { isScanning: false, isConnecting: false, timeout: undefined, isBackgroundScan: false };
+        this.connectState = { isConnecting: false, isConnected: false, isInitSuccess: false };
+        this.props = props;
+        if (props.binding)
+            this.setBinding(props.binding);
+        this.peripheralCache = new peripheral_cache_1.default();
+        this.connectedDevices = [];
+        if (props.logger)
+            this.logger = props.logger;
+        else
+            this.logger = new gd_eventlog_1.EventLogger('BLE');
+    }
+    getBinding() { return this.binding; }
+    setBinding(binding) { if (binding)
+        this.binding = binding; }
+    getName() {
+        return 'ble';
+    }
+    startConnectSensor() {
+        this.sensorIsConnecting = true;
+    }
+    stopConnectSensor() {
+        this.sensorIsConnecting = false;
+    }
+    waitForSensorConnectionFinish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (this.sensorIsConnecting && this.connectState.isConnected) {
+                yield (0, utils_2.sleep)(100);
+            }
             return;
-        this.deviceClasses.push({ id, type, Class, services });
+        });
+    }
+    getAdapterFactory() {
+        return adapter_factory_1.default.getInstance();
     }
     logEvent(event) {
         if (this.logger) {
@@ -61,7 +84,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
         }
     }
     onStateChange(state) {
-        if (state !== ble_1.BleState.POWERED_ON) {
+        if (state !== 'poweredOn') {
             this.connectState.isConnected = false;
         }
         else {
@@ -71,48 +94,25 @@ class BleInterface extends ble_1.BleInterfaceClass {
     onError(err) {
         this.logEvent({ message: 'error', error: err.message, stack: err.stack });
     }
-    connect(props = {}) {
-        const timeout = props.timeout || 2000;
+    connect(to) {
+        const timeout = this.props.timeout || to || 2000;
         return new Promise((resolve, reject) => {
             if (this.connectState.isConnected) {
                 return resolve(true);
             }
-            this.logEvent({ message: 'connect request', });
+            this.logEvent({ message: 'Ble connect request', });
             if (!this.getBinding())
                 return Promise.reject(new Error('no binding defined'));
             this.connectState.timeout = setTimeout(() => {
                 this.connectState.isConnected = false;
                 this.connectState.isConnecting = false;
                 this.connectState.timeout = null;
-                this.logEvent({ message: 'connect result: timeout' });
-                reject(new Error('timeout'));
+                this.logEvent({ message: 'Ble connect result: timeout' });
+                resolve(false);
             }, timeout);
             try {
-                if (!this.connectState.isInitSuccess) {
-                    const binding = this.getBinding()._bindings;
-                    if (binding) {
-                        const binding_init_original = binding.init.bind(binding);
-                        const self = this;
-                        binding.on('error', (err) => { this.getBinding().emit('error', err); });
-                        binding.init = function () {
-                            try {
-                                binding_init_original();
-                                self.connectState.isInitSuccess = true;
-                            }
-                            catch (err) {
-                                self.connectState.isInitSuccess = false;
-                                self.connectState.isConnected = false;
-                                self.connectState.isConnecting = false;
-                                self.logEvent({ message: 'connect result: error', error: err.message });
-                                return reject(new Error(err.message));
-                            }
-                        };
-                    }
-                    else {
-                    }
-                }
                 const state = this.getBinding().state;
-                if (state === ble_1.BleState.POWERED_ON) {
+                if (state === 'poweredOn') {
                     clearTimeout(this.connectState.timeout);
                     this.connectState.timeout = null;
                     this.getBinding().removeAllListeners('stateChange');
@@ -132,14 +132,14 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         return reject(err);
                     });
                     this.getBinding().on('stateChange', (state) => {
-                        if (state === ble_1.BleState.POWERED_ON) {
+                        if (state === 'poweredOn') {
                             clearTimeout(this.connectState.timeout);
                             this.connectState.timeout = null;
                             this.getBinding().removeAllListeners('stateChange');
                             this.getBinding().on('stateChange', this.onStateChange.bind(this));
                             this.connectState.isConnected = true;
                             this.connectState.isConnecting = false;
-                            this.logEvent({ message: 'connect result: success' });
+                            this.logEvent({ message: 'Ble connect result: success' });
                             return resolve(true);
                         }
                         else {
@@ -154,7 +154,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 if (this.connectState.timeout)
                     clearTimeout(this.connectState.timeout);
                 this.connectState.timeout = null;
-                this.logEvent({ message: 'connect result: error', error: err.message });
+                this.logEvent({ message: 'Ble connect result: error', error: err.message });
                 return reject(new Error('bluetooth unavailable, cause: ' + err.message));
             }
         });
@@ -170,11 +170,11 @@ class BleInterface extends ble_1.BleInterfaceClass {
             if (this.scanState.isScanning) {
                 yield this.stopScan();
             }
-            const connectedDevices = this.devices.filter(d => d.isConnected);
+            const devices = this.getAdapterFactory().getAllInstances();
+            const connectedDevices = devices.filter(d => d.isConnected());
             for (let i = 0; i < connectedDevices.length; i++) {
                 const d = connectedDevices[i];
-                const device = d.device;
-                yield device.disconnect();
+                yield d.close();
             }
             this.connectState.isConnected = false;
             this.connectState.isConnecting = false;
@@ -189,83 +189,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
     isConnected() {
         return this.connectState.isConnected;
     }
-    getDevicesFromServices(deviceTypes, services) {
-        if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
-            return [];
-        }
-        const get = (deviceTypes, fnCompare) => {
-            const types = deviceTypes.filter(DeviceType => {
-                const C = DeviceType;
-                let found = false;
-                if (C.services)
-                    found = C.services.find((s) => fnCompare(s));
-                return found;
-            });
-            return types;
-        };
-        if (typeof services === 'string') {
-            return get(deviceTypes, (s) => (0, ble_2.matches)(s, services));
-        }
-        if (Array.isArray(services)) {
-            const sids = services.map(ble_1.uuid);
-            return get(deviceTypes, s => {
-                const res = sids.find((service) => (0, ble_2.matches)(s, service));
-                return res !== undefined;
-            });
-        }
-        return [];
-    }
-    getAllSupportedServices() {
-        const supported = BleInterface.deviceClasses;
-        const res = [];
-        if (supported && supported.length > 0) {
-            supported.forEach(dc => {
-                if (dc && dc.services) {
-                    dc.services.forEach(s => {
-                        if (!res.includes(s))
-                            res.push(s);
-                    });
-                }
-            });
-        }
-        return res;
-    }
-    getAllSupportedDeviceTypes() {
-        const supported = BleInterface.deviceClasses;
-        return supported.map(dc => dc.Class);
-    }
-    getServicesFromDeviceTypes(deviceTypes) {
-        let services = [];
-        try {
-            if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
-                return [];
-            }
-            deviceTypes.forEach(DeviceType => {
-                if (DeviceType.services) {
-                    const dtServices = DeviceType.services;
-                    dtServices.forEach(s => {
-                        if (!services.find(s2 => s2 === s))
-                            services.push(s);
-                    });
-                }
-            });
-        }
-        catch (err) {
-            console.log(err);
-        }
-        return services;
-    }
-    getServicesFromDevice(device) {
-        if (!device)
-            return [];
-        const services = [];
-        const dServices = device.getServiceUUids();
-        dServices.forEach(s => {
-            if (!services.find(s2 => s2 === s))
-                services.push(s);
-        });
-        return services;
-    }
     waitForConnectFinished(timeout) {
         const waitStart = Date.now();
         const waitTimeout = waitStart + timeout;
@@ -282,39 +205,18 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }, 100);
         });
     }
-    addPeripheralToCache(peripheral, props = {}) {
-        const info = this.peripheralCache.find(i => i.address === peripheral.address);
-        const connector = info && info.connector ? info.connector : new ble_peripheral_1.default(this, peripheral);
-        this.peripheralCache.push(Object.assign({ address: peripheral.address, ts: Date.now(), peripheral, connector }, props));
-    }
     onDisconnect(peripheral) {
-        const idx = this.peripheralCache.findIndex(i => i.address === peripheral.address);
-        if (idx !== -1)
-            this.peripheralCache.splice(idx, 1);
-    }
-    getConnector(peripheral) {
-        const info = this.peripheralCache.find(i => i.address === peripheral.address);
-        if (!info) {
-            const connector = new ble_peripheral_1.default(this, peripheral);
-            this.peripheralCache.push({ address: peripheral.address, ts: Date.now(), peripheral, connector });
-            return connector;
-        }
-        return info.connector;
-    }
-    findPeripheral(peripheral) {
-        const info = this.peripheralCache.find(i => i.address === peripheral.address || peripheral.address === i.peripheral.address || peripheral.name === i.peripheral.name || peripheral.id === i.peripheral.id);
-        return info ? info.peripheral : undefined;
+        this.peripheralCache.remove(peripheral);
     }
     getCharacteristics(peripheral) {
         return __awaiter(this, void 0, void 0, function* () {
             let characteristics = undefined;
-            let chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
+            let chachedPeripheralInfo = this.peripheralCache.find({ peripheral });
             if (chachedPeripheralInfo && Date.now() - chachedPeripheralInfo.ts > 600000) {
                 chachedPeripheralInfo.ts = Date.now();
             }
             if (!chachedPeripheralInfo) {
-                this.addPeripheralToCache(peripheral);
-                chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
+                chachedPeripheralInfo = this.peripheralCache.add({ address: peripheral.address, ts: Date.now(), peripheral });
             }
             const connector = chachedPeripheralInfo.connector;
             if (!chachedPeripheralInfo.characteristics) {
@@ -324,150 +226,23 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     peripheral.state = connector.getState();
                     yield connector.initialize();
                     characteristics = connector.getCharachteristics();
-                    this.logEvent({ message: 'characteristic info (+):', info: characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
+                    this.logEvent({ message: 'characteristic info (+):', address: peripheral.address, info: characteristics.map(utils_1.getCharachteristicsInfo) });
                     chachedPeripheralInfo.characteristics = characteristics;
                     chachedPeripheralInfo.state = { isConfigured: true, isLoading: false, isInterrupted: false };
                 }
                 catch (err) {
-                    console.log(err);
+                    console.log('~~ ERROR', err);
                 }
             }
             else {
                 characteristics = chachedPeripheralInfo.characteristics;
-                this.logEvent({ message: 'characteristic info (*):', info: characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
+                this.logEvent({ message: 'characteristic info (*):', address: peripheral.address, info: characteristics.map(utils_1.getCharachteristicsInfo) });
             }
             if (!characteristics)
                 this.logEvent({ message: 'characteristic info:', info: 'none' });
             return characteristics;
         });
     }
-    getDeviceClasses(peripheral, props = {}) {
-        let DeviceClasses;
-        const { deviceTypes, profile, services = peripheral.advertisement.serviceUuids } = props;
-        if ((!deviceTypes || deviceTypes.length === 0)) {
-            const classes = BleInterface.deviceClasses.map(c => c.Class);
-            DeviceClasses = this.getDevicesFromServices(classes, services);
-        }
-        else {
-            DeviceClasses = this.getDevicesFromServices(deviceTypes, services);
-        }
-        if (profile && DeviceClasses && DeviceClasses.length > 0) {
-            DeviceClasses = DeviceClasses.filter(C => {
-                const device = new C({ peripheral });
-                if (device.getProfile() !== profile)
-                    return false;
-                return true;
-            });
-        }
-        return DeviceClasses;
-    }
-    createDevice(DeviceClass, peripheral, characteristics) {
-        try {
-            const C = DeviceClass;
-            const device = new C({ peripheral });
-            const cids = characteristics ? characteristics.map(c => (0, ble_1.uuid)(c.uuid)) : [];
-            this.logEvent({ message: 'trying to create device', peripheral: peripheral.address, characteristics: cids, profile: device.getProfile() });
-            const existingDevice = this.devices.find(i => i.device.id === device.id && i.device.getProfile() === device.getProfile());
-            if (existingDevice)
-                return existingDevice.device;
-            device.setInterface(this);
-            if (characteristics && device.isMatching(cids)) {
-                device.characteristics = characteristics;
-                device.setCharacteristicUUIDs(characteristics.map(c => c.uuid));
-                return device;
-            }
-            else {
-                this.logEvent({ message: 'failed to create device', peripheral: peripheral.address, profile: device.getProfile() });
-            }
-        }
-        catch (err) {
-            this.logEvent({ message: 'error', fn: '', error: err.message || err, stack: err.stack });
-        }
-    }
-    connectDevice(requested, timeout = DEFAULT_SCAN_TIMEOUT + CONNECT_TIMEOUT) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { id, name, address } = requested;
-            const profile = requested instanceof ble_1.BleDeviceClass ?
-                (requested.getProfile && typeof (requested.getProfile) === 'function' ? requested.getProfile() : undefined) :
-                requested.profile;
-            this.logEvent({ message: 'connectDevice', id, name, address, profile, isbusy: this.scanState.isConnecting });
-            if (this.scanState.isConnecting) {
-                yield this.waitForConnectFinished(CONNECT_TIMEOUT);
-            }
-            this.scanState.isConnecting = true;
-            const existing = this.devices.find(i => (!profile || i.device.getProfile() === profile) && (i.device.address === requested.address || i.device.id === requested.id || i.device.name === requested.name));
-            if (existing) {
-                this.logEvent({ message: 'connect existing device' });
-                yield existing.device.connect();
-                this.scanState.isConnecting = false;
-                return existing.device;
-            }
-            const peripheralInfo = this.peripheralCache.find(i => (i.address === requested.address || (i.periphal && i.peripheral.id === requested.id)));
-            if (peripheralInfo) {
-                if (!peripheralInfo.characteristic) {
-                    yield this.getCharacteristics(peripheralInfo.periphal);
-                    const DeviceClasses = this.getDeviceClasses(peripheralInfo.peripheral, { profile });
-                    if (!DeviceClasses || DeviceClasses.length === 0)
-                        return;
-                    const devices = DeviceClasses.map(C => this.createDevice(C, peripheralInfo.periphal, peripheralInfo.characteristics));
-                    if (devices && devices.length > 0) {
-                        for (let i = 0; i < devices.length; i++) {
-                            const idx = this.devices.push({ device: devices[i], isConnected: false }) - 1;
-                            if (!devices[i].isConnected())
-                                yield devices[i].connect();
-                            this.devices[idx].isConnected = true;
-                        }
-                    }
-                }
-                const connectedDevice = this.devices.find(d => d.isConnected);
-                if (connectedDevice)
-                    return connectedDevice.device;
-            }
-            let devices = [];
-            let retry = false;
-            let retryCount = 0;
-            do {
-                if (retryCount > 0) {
-                    this.logEvent({ message: 'retry connect device', id, name, address, profile, retryCount });
-                }
-                try {
-                    devices = yield this.scan({ timeout: DEFAULT_SCAN_TIMEOUT, requested: requested });
-                    if (devices.length === 0) {
-                        retryCount++;
-                        retry = retryCount < 5;
-                    }
-                }
-                catch (err) {
-                    if (err.message === 'scanning already in progress') {
-                        yield (0, utils_1.sleep)(1000);
-                        retryCount++;
-                        retry = retryCount < 5;
-                        continue;
-                    }
-                    this.scanState.isConnecting = false;
-                    throw err;
-                }
-            } while (devices.length === 0 && retry);
-            if (devices.length === 0) {
-                this.logEvent({ message: 'connectDevice failure', id, name, address, profile, error: 'device not found' });
-                this.scanState.isConnecting = false;
-                throw new Error('device not found');
-            }
-            if (devices[0]) {
-                this.logEvent({ message: 'connectDevice connecting', id, name, address, profile });
-                const connected = yield devices[0].connect();
-                this.scanState.isConnecting = false;
-                if (connected) {
-                    this.logEvent({ message: 'connectDevice success', id, name, address, profile });
-                    return devices[0];
-                }
-                else {
-                    this.logEvent({ message: 'connectDevice failure', id, name, address, profile });
-                    throw new Error('connect failed');
-                }
-            }
-        });
-    }
     waitForScanFinished(timeout) {
         const waitStart = Date.now();
         const waitTimeout = waitStart + timeout;
@@ -484,181 +259,222 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }, 100);
         });
     }
-    getBestDeviceMatch(DeviceClasses) {
-        if (!DeviceClasses || DeviceClasses.length === 0)
-            return;
-        const details = DeviceClasses.map(c => ({ name: c.prototype.constructor.name, priority: c.detectionPriority || 0, class: c }));
-        details.sort((a, b) => b.priority - a.priority);
-        return details[0].class;
-    }
-    scan(props) {
+    onPeripheralFound(p, callback, props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { timeout = DEFAULT_SCAN_TIMEOUT, deviceTypes = [], requested } = props;
-            let profile;
-            if (requested)
-                profile = requested instanceof ble_1.BleDeviceClass ?
-                    (requested.getProfile && typeof (requested.getProfile) === 'function' ? requested.getProfile() : undefined) :
-                    requested.profile;
-            const { id, address, name } = requested || {};
-            const scanForDevice = (requested !== null && requested !== undefined);
-            const services = (!deviceTypes || deviceTypes.length === 0) ? this.getAllSupportedServices() : this.getServicesFromDeviceTypes(deviceTypes);
-            const bleBinding = this.getBinding();
-            if (!bleBinding)
-                return Promise.reject(new Error('no binding defined'));
-            if (!this.isConnected()) {
-                yield this.connect();
+            let peripheral = p;
+            if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.localName) {
+                return;
+            }
+            const scanForDevice = (props.comms !== undefined) || (props.request !== undefined && props.request !== null);
+            const request = props.comms ? props.comms.getSettings() : props.request;
+            if (scanForDevice && this.scanState.peripherals.size > 0) {
+                return;
+            }
+            if (!this.scanState.peripherals)
+                this.scanState.peripherals = new Map();
+            if (peripheral.address === undefined || peripheral.address === '')
+                peripheral.address = peripheral.id || peripheral.name;
+            const isPeripheralProcessed = this.scanState.peripherals.get(peripheral.address) !== undefined;
+            if (isPeripheralProcessed) {
+                return;
             }
-            const peripheralsProcessed = [];
-            const devicesProcessed = [];
-            this.logEvent({ message: 'scan()', props: { timeout }, scanState: this.scanState,
-                peripheralCache: this.peripheralCache.map(i => ({ address: i.address, ts: i.ts, name: i.peripheral ? i.peripheral.advertisement.localName : '' })),
-                deviceCache: this.devices.map(i => ({ address: i.device.address, profile: i.device.getProfile(), isConnected: i.isConnected }))
-            });
-            let opStr;
             if (scanForDevice) {
-                opStr = 'search device';
-                this.logEvent({ message: 'search device request', services, device: { id, address, name }, deviceTypes });
+                let found = false;
+                found =
+                    (request.name && peripheral.advertisement && request.name === peripheral.advertisement.localName) ||
+                        (request.address && request.address === peripheral.address);
+                if (!found) {
+                    return;
+                }
+                this.logEvent({ message: 'search device: found device', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), scanForDevice, callback: callback !== undefined });
+                this.scanState.peripherals.set(peripheral.address, peripheral);
+                const characteristics = yield this.getCharacteristics(peripheral);
+                callback(peripheral, characteristics);
+                return;
             }
             else {
-                opStr = 'scan';
-                const supported = BleInterface.deviceClasses.map(dc => ({ id: dc.id, type: dc.type, services: dc.services }));
-                this.logEvent({ message: 'scan start', services, supported });
+                this.logEvent({ message: 'BLE scan: found device', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), scanForDevice, callback: callback !== undefined });
+                this.scanState.peripherals.set(peripheral.address, peripheral);
+                const { protocolFilter } = props;
+                const connector = this.peripheralCache.getConnector(p);
+                const characteristics = yield this.getCharacteristics(p);
+                const announcedServices = connector.getServices();
+                const services = announcedServices ? announcedServices.map(utils_1.uuid) : undefined;
+                peripheral = connector.getPeripheral();
+                const DeviceClasses = this.getAdapterFactory().getDeviceClasses(peripheral, { services }) || [];
+                const MatchingClasses = protocolFilter && DeviceClasses ? DeviceClasses.filter(C => protocolFilter.includes(C.protocol)) : DeviceClasses;
+                const DeviceClass = (0, comms_utils_1.getBestDeviceMatch)(MatchingClasses.filter(C => C.isMatching(characteristics.map(c => c.uuid))));
+                this.logEvent({ message: 'BLE scan: device connected', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), services, protocols: DeviceClasses.map(c => c.protocol) });
+                if (!DeviceClass)
+                    return callback(null);
+                const { id, name, address } = (0, utils_1.getPeripheralInfo)(peripheral);
+                const settings = { protocol: DeviceClass.protocol, interface: 'ble', id, name: peripheral.name || name, address: peripheral.address || address };
+                callback(settings, characteristics);
+            }
+        });
+    }
+    scanForDevice(comms, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { timeout = DEFAULT_SCAN_TIMEOUT } = props;
+            const request = comms.getSettings();
+            const { protocol } = request;
+            const ble = this.getBinding();
+            if (!this.isConnected()) {
+                yield this.connect();
             }
+            const device = adapter_factory_1.default.getInstance().createInstance(request);
+            if (device.isConnected())
+                return device.getComms().peripheral;
+            let opStr;
+            opStr = 'search device';
+            this.logEvent({ message: 'search device request', request });
             if (this.scanState.isScanning) {
                 try {
                     this.logEvent({ message: `${opStr}: waiting for previous scan to finish` });
                     yield this.waitForScanFinished(timeout);
                 }
                 catch (err) {
-                    this.logEvent({ message: `${opStr} result: already scanning` });
-                    return Promise.reject(err);
+                    this.logEvent({ message: `${opStr} result: already scanning`, error: err.message });
+                    throw (err);
                 }
             }
             return new Promise((resolve, reject) => {
                 this.scanState.isScanning = true;
-                if (scanForDevice) {
-                    if (this.devices && this.devices.length > 0) {
-                        const knownDevices = this.devices.map(i => ({ name: i.device.name, address: i.device.address, isConnected: i.isConnected, connectState: i.device.getConnectState() }));
-                        this.logEvent({ message: `${opStr}: check if already registered`, device: { name, address }, knownDevices });
-                        const existing = this.devices.find(i => (i.device.address === address || i.device.name === name || i.device.id === id));
-                        if (existing)
-                            this.logEvent({ message: `${opStr}: device already registered`, device: { name, address } });
-                    }
-                }
+                this.scanState.peripherals = new Map();
                 const onTimeout = () => {
                     if (!this.scanState.isScanning || !this.scanState.timeout)
                         return;
                     this.scanState.timeout = null;
-                    this.logEvent({ message: `${opStr} result: devices found`, requested: scanForDevice ? { name, address, profile } : undefined, devices: this.devices.map(i => i.device.name + (!i.device.name || i.device.name === '') ? `addr=${i.device.address}` : '') });
-                    this.getBinding().removeAllListeners('discover');
-                    this.logEvent({ message: `${opStr}: stop scanning`, requested: scanForDevice ? { name, address, profile } : undefined, });
-                    bleBinding.stopScanning(() => {
+                    this.logEvent({ message: `${opStr} result: timeout`, request });
+                    ble.removeAllListeners('discover');
+                    this.logEvent({ message: `${opStr}: stop scanning`, request });
+                    ble.stopScanning(() => {
                         this.scanState.isScanning = false;
-                        if (scanForDevice) {
-                            reject(new Error('device not found'));
-                            return;
-                        }
-                        resolve(this.devices.map(i => i.device));
+                        reject(new Error('device not found'));
+                        return;
                     });
                 };
-                const onPeripheralFound = (peripheral, fromCache = false) => __awaiter(this, void 0, void 0, function* () {
-                    if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.localName || !peripheral.advertisement.serviceUuids)
-                        return;
-                    if (fromCache) {
-                        this.logEvent({ message: 'adding from Cache', peripheral: peripheral.address });
-                    }
-                    else {
-                        const { id, name, address, advertisement = {} } = peripheral;
-                        this.logEvent({ message: 'BLE scan: found device', peripheral: { id, name: advertisement.localName, address, services: advertisement.serviceUuids } });
-                    }
-                    if (peripheral.address === undefined || peripheral.address === '')
-                        peripheral.address = peripheral.id;
-                    const isPeripheralProcessed = peripheralsProcessed.find(p => p === peripheral.address) !== undefined;
-                    if (isPeripheralProcessed)
-                        return;
-                    peripheralsProcessed.push(peripheral.address);
-                    if (scanForDevice && requested.name && requested.name !== peripheral.advertisement.localName)
-                        return;
-                    const connector = this.getConnector(peripheral);
-                    const characteristics = yield this.getCharacteristics(peripheral);
-                    const connectedServices = connector.getServices();
-                    const services = connectedServices ? connectedServices.map(cs => cs.uuid) : undefined;
-                    const connectedPeripheral = connector.getPeripheral();
-                    const { id, name, address, advertisement = {} } = connectedPeripheral;
-                    const DeviceClasses = this.getDeviceClasses(connectedPeripheral, { profile, services }) || [];
-                    this.logEvent({ message: 'BLE scan: device connected', peripheral: { id, name, address, services: advertisement.serviceUuids }, services, classes: DeviceClasses.map(c => c.prototype.constructor.name) });
-                    let cntFound = 0;
-                    const DeviceClass = this.getBestDeviceMatch(DeviceClasses);
-                    if (!DeviceClass)
-                        return;
-                    if (scanForDevice && cntFound > 0)
-                        return;
-                    const d = this.createDevice(DeviceClass, peripheral, characteristics);
-                    if (!d) {
-                        this.logEvent({ message: `${opStr}: could not create device `, DeviceClass });
-                        return;
-                    }
-                    try {
-                        this.logEvent({ message: `${opStr}: connecting `, device: d.name, profile: d.getProfile(), address: d.address });
-                        yield d.connect();
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'error', fn: 'onPeripheralFound()', error: err.message || err, stack: err.stack });
-                    }
-                    if (scanForDevice) {
-                        if ((id && id !== '' && d.id === id) ||
-                            (address && address !== '' && d.address === address) ||
-                            (name && name !== '' && d.name === name))
-                            cntFound++;
-                    }
-                    else
-                        cntFound++;
-                    const existing = devicesProcessed.find(device => device.id === d.id && device.getProfile() === d.getProfile());
-                    if (!scanForDevice && cntFound > 0 && !existing) {
-                        this.logEvent({ message: `${opStr}: device found`, device: d.name, profile: d.getProfile(), address: d.address, services: d.services.join(',') });
-                        this.addDeviceToCache(d, peripheral.state === 'connected');
-                        devicesProcessed.push(d);
-                        this.emit('device', d);
-                        return;
+                this.logEvent({ message: `${opStr}: start scanning`, request, timeout });
+                let services = [];
+                if (protocol !== 'tacx') {
+                    services = (device.getComms().getServices()) || [];
+                }
+                ble.startScanning(services, false, (err) => {
+                    if (err) {
+                        this.logEvent({ message: `${opStr} result: error`, request, error: err.message });
+                        this.scanState.isScanning = false;
+                        return reject(err);
                     }
-                    if (scanForDevice && cntFound > 0) {
-                        this.logEvent({ message: `${opStr}: device found`, device: d.name, profile: d.getProfile(), address: d.address, services: d.services.join(',') });
-                        this.addDeviceToCache(d, peripheral.state === 'connected');
-                        devicesProcessed.push(d);
-                        this.emit('device', d);
-                        process.nextTick(() => {
-                            if (this.scanState.timeout) {
-                                clearTimeout(this.scanState.timeout);
-                                this.scanState.timeout = null;
-                            }
-                            this.logEvent({ message: `${opStr}: stop scanning`, requested: scanForDevice ? { name, address, profile } : undefined, });
-                            bleBinding.stopScanning(() => {
-                                this.getBinding().removeAllListeners('discover');
-                                this.scanState.isScanning = false;
-                                resolve([d]);
+                    ble.on('discover', (p) => {
+                        this.onPeripheralFound(p, (peripheral, characteristics) => {
+                            device.getComms().characteristics = characteristics;
+                            process.nextTick(() => {
+                                if (this.scanState.timeout) {
+                                    clearTimeout(this.scanState.timeout);
+                                    this.scanState.timeout = null;
+                                }
+                                this.logEvent({ message: `${opStr}: stop scanning`, request });
+                                ble.stopScanning(() => {
+                                    ble.removeAllListeners('discover');
+                                    this.scanState.isScanning = false;
+                                    resolve(peripheral);
+                                });
                             });
-                        });
+                        }, { comms });
+                    });
+                    const cachedItem = this.peripheralCache.find(request);
+                    if (cachedItem) {
+                        this.logEvent({ message: `${opStr}: adding peripheral from cache `, peripheral: (0, utils_1.getPeripheralInfo)(cachedItem.peripheral) });
+                        ble.emit('discover', cachedItem.peripheral);
                     }
                 });
-                this.logEvent({ message: `${opStr}: start scanning`, requested: scanForDevice ? { name, address, profile } : undefined, timeout });
-                let services = [];
-                if (scanForDevice && name && !name.toLowerCase().startsWith('tacx')) {
-                    if (props.requested instanceof ble_1.BleDeviceClass) {
-                        const device = props.requested;
-                        services = (device.getServices()) || [];
-                    }
+                this.scanState.timeout = setTimeout(onTimeout, timeout);
+            });
+        });
+    }
+    scan(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { timeout = DEFAULT_SCAN_TIMEOUT, protocol, protocols } = props;
+            const requestedProtocols = protocols || [];
+            if (protocol && !requestedProtocols.find(p => p === protocol))
+                requestedProtocols.push(protocol);
+            const protocolFilter = requestedProtocols.length > 0 ? requestedProtocols : null;
+            const services = protocolFilter === null ? this.getAdapterFactory().getAllSupportedServices() : (0, comms_utils_1.getServicesFromProtocols)(protocolFilter);
+            const ble = this.getBinding();
+            const opStr = 'scan';
+            if (this.scanState.isScanning) {
+                try {
+                    this.logEvent({ message: `${opStr}: waiting for previous scan to finish` });
+                    yield this.waitForScanFinished(timeout);
+                }
+                catch (err) {
+                    this.logEvent({ message: `${opStr} result: already scanning` });
+                    throw (err);
                 }
-                bleBinding.startScanning(services, false, (err) => {
+            }
+            this.scanState.isScanning = true;
+            const tsStart = Date.now();
+            const tsTimeoutExpired = tsStart + timeout;
+            while (!this.isConnected() && this.scanState.isScanning && Date.now() < tsTimeoutExpired) {
+                const connected = yield this.connect();
+                if (!connected)
+                    yield (0, utils_2.sleep)(1000);
+            }
+            if (Date.now() > tsTimeoutExpired) {
+                return [];
+            }
+            if (!this.scanState.isScanning) {
+                return [];
+            }
+            const adjustedScanTimeout = tsStart - Date.now() + timeout;
+            const supported = adapter_factory_1.default.getInstance().getAll().map(i => i.protocol);
+            this.logEvent({ message: 'scan start', services, supported });
+            return new Promise((resolve, reject) => {
+                this.scanState.peripherals = new Map();
+                const detected = [];
+                const requested = protocolFilter;
+                const onTimeout = () => {
+                    if (!this.scanState.isScanning || !this.scanState.timeout)
+                        return;
+                    this.scanState.timeout = null;
+                    const devices = detected.map(d => {
+                        const { id, name, address, protocol } = d;
+                        return { id, name, address, protocol };
+                    });
+                    this.logEvent({ message: `${opStr} result: timeout, devices found`, requested, devices });
+                    ble.removeAllListeners('discover');
+                    this.logEvent({ message: `${opStr}: stop scanning`, requested });
+                    ble.stopScanning(() => {
+                        this.scanState.isScanning = false;
+                        resolve(detected);
+                    });
+                };
+                this.logEvent({ message: `${opStr}: start scanning`, requested, timeout });
+                this.scanState.timeout = setTimeout(onTimeout, adjustedScanTimeout);
+                ble.startScanning(protocolFilter ? services : [], false, (err) => {
                     if (err) {
-                        this.logEvent({ message: `${opStr} result: error`, requested: scanForDevice ? { name, address, profile } : undefined, error: err.message });
+                        this.logEvent({ message: `${opStr} result: error`, requested, error: err.message });
                         this.scanState.isScanning = false;
                         return reject(err);
                     }
-                    bleBinding.on('discover', (p) => {
-                        onPeripheralFound(p);
+                    ble.on('discover', (p) => {
+                        this.onPeripheralFound(p, (deviceSettings, characteristics) => {
+                            if (deviceSettings) {
+                                detected.push(deviceSettings);
+                                const device = this.getAdapterFactory().createInstance(deviceSettings);
+                                device.getComms().characteristics = characteristics;
+                                this.emit('device', deviceSettings);
+                            }
+                        }, { protocolFilter });
                     });
+                    const cachedItems = this.peripheralCache.filter(protocolFilter ? services : []);
+                    if (cachedItems && cachedItems.length > 0) {
+                        cachedItems.map(c => c.peripheral).forEach(peripheral => {
+                            this.logEvent({ message: `${opStr}: adding peripheral from cache `, peripheral: (0, utils_1.getPeripheralInfo)(peripheral) });
+                            ble.emit('discover', peripheral);
+                        });
+                    }
                 });
-                this.scanState.timeout = setTimeout(onTimeout, timeout);
             });
         });
     }
@@ -669,13 +485,12 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 this.logEvent({ message: 'scan stop result: not scanning' });
                 return true;
             }
-            if (!this.getBinding())
+            const ble = this.getBinding();
+            if (!ble)
                 throw new Error('no binding defined');
-            this.getBinding().removeAllListeners('discover');
-            const ongoing = this.peripheralCache.filter(i => i.state && i.state.isLoading);
-            if (ongoing)
-                ongoing.forEach(i => { i.isInterrupted = true; });
-            yield this.getBinding().stopScanning();
+            ble.removeAllListeners('discover');
+            this.peripheralCache.handleStopScan();
+            ble.stopScanning();
             this.scanState.isScanning = false;
             this.logEvent({ message: 'scan stop result: success' });
             return true;
@@ -685,37 +500,14 @@ class BleInterface extends ble_1.BleInterfaceClass {
         return this.scanState.isScanning === true;
     }
     addConnectedDevice(device) {
-        const existigDevice = this.devices.find(i => i.device.id === device.id && i.device.getProfile() === device.getProfile());
-        if (existigDevice) {
-            existigDevice.isConnected = true;
-            return;
-        }
-        this.devices.push({ device, isConnected: true });
-    }
-    addDeviceToCache(device, isConnected) {
-        const existigDevice = this.devices.find(i => i.device.id === device.id && i.device.getProfile() === device.getProfile());
-        if (existigDevice) {
-            return;
-        }
-        this.devices.push({ device, isConnected });
-    }
-    findConnected(device) {
-        const connected = this.devices.find(i => i.device.id === device.id && i.isConnected);
-        if (connected)
-            return connected.device;
-        return undefined;
-    }
-    findDeviceInCache(device) {
-        const existing = this.devices.find(i => (i.device.id === device.id || i.device.address === device.address || i.device.name === device.name) && i.device.getProfile() === device.profile);
-        return existing ? existing.device : undefined;
+        const idx = this.connectedDevices.findIndex(d => d.isSame(device));
+        if (idx === -1)
+            this.connectedDevices.push(device);
     }
     removeConnectedDevice(device) {
-        const existigDevice = this.devices.find(i => i.device.id === device.id);
-        if (existigDevice) {
-            existigDevice.isConnected = false;
-            return;
-        }
+        const idx = this.connectedDevices.findIndex(d => d.isSame(device));
+        if (idx !== -1)
+            this.connectedDevices.splice(idx);
     }
 }
 exports.default = BleInterface;
-BleInterface.deviceClasses = [];