incyclist-devices 1.5.11 → 1.5.12

package/lib/ble/ble-interface.js

@@ -1,721 +1,721 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": 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 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');
-    }
-    static getInstance(props = {}) {
-        if (!BleInterface._instance) {
-            BleInterface._instance = new BleInterface(props);
-        }
-        else {
-            if (props.binding) {
-                BleInterface._instance.setBinding(props.binding);
-            }
-            if (props.logger) {
-                BleInterface._instance.logger = props.logger;
-            }
-            if (props.log && !BleInterface._instance.logger) {
-                BleInterface._instance.logger = new gd_eventlog_1.EventLogger('BLE');
-            }
-        }
-        return BleInterface._instance;
-    }
-    static register(id, type, Class, services) {
-        if (this.deviceClasses.find(i => i.id === id))
-            return;
-        this.deviceClasses.push({ id, type, Class, services });
-    }
-    logEvent(event) {
-        if (this.logger) {
-            this.logger.logEvent(event);
-        }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~BLE:', event);
-        }
-    }
-    onStateChange(state) {
-        if (state !== ble_1.BleState.POWERED_ON) {
-            this.connectState.isConnected = false;
-        }
-        else {
-            this.connectState.isConnected = true;
-        }
-    }
-    onError(err) {
-        this.logEvent({ message: 'error', error: err.message, stack: err.stack });
-    }
-    connect(props = {}) {
-        const timeout = props.timeout || 2000;
-        return new Promise((resolve, reject) => {
-            if (this.connectState.isConnected) {
-                return resolve(true);
-            }
-            this.logEvent({ message: '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'));
-            }, 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) {
-                    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' });
-                    resolve(true);
-                    return;
-                }
-                else {
-                    this.getBinding().once('error', (err) => {
-                        this.connectState.isConnected = true;
-                        this.connectState.isConnecting = false;
-                        this.logEvent({ message: 'connect result: error', error: err.message });
-                        this.getBinding().on('error', this.onError.bind(this));
-                        return reject(err);
-                    });
-                    this.getBinding().on('stateChange', (state) => {
-                        if (state === ble_1.BleState.POWERED_ON) {
-                            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' });
-                            return resolve(true);
-                        }
-                        else {
-                            this.logEvent({ message: 'BLE state change', state });
-                        }
-                    });
-                }
-            }
-            catch (err) {
-                this.connectState.isConnected = false;
-                this.connectState.isConnecting = false;
-                if (this.connectState.timeout)
-                    clearTimeout(this.connectState.timeout);
-                this.connectState.timeout = null;
-                this.logEvent({ message: 'connect result: error', error: err.message });
-                return reject(new Error('bluetooth unavailable, cause: ' + err.message));
-            }
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.connectState.isConnected) {
-                return Promise.resolve(true);
-            }
-            if (!this.getBinding())
-                return Promise.reject(new Error('no binding defined'));
-            this.logEvent({ message: 'disconnect request' });
-            if (this.scanState.isScanning) {
-                yield this.stopScan();
-            }
-            const connectedDevices = this.devices.filter(d => d.isConnected);
-            for (let i = 0; i < connectedDevices.length; i++) {
-                const d = connectedDevices[i];
-                const device = d.device;
-                yield device.disconnect();
-            }
-            this.connectState.isConnected = false;
-            this.connectState.isConnecting = false;
-            if (this.connectState.timeout) {
-                clearTimeout(this.connectState.timeout);
-                this.connectState.timeout = null;
-            }
-            this.logEvent({ message: 'disconnect result: success' });
-            return true;
-        });
-    }
-    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;
-        return new Promise((resolve, reject) => {
-            const waitIv = setInterval(() => {
-                if (this.scanState.isConnecting && Date.now() > waitTimeout) {
-                    clearInterval(waitIv);
-                    return reject(new Error('Connecting already in progress'));
-                }
-                if (!this.scanState.isConnecting) {
-                    clearInterval(waitIv);
-                    return resolve(true);
-                }
-            }, 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;
-    }
-    getCharacteristics(peripheral) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let characteristics = undefined;
-            let chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
-            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);
-            }
-            const connector = chachedPeripheralInfo.connector;
-            if (!chachedPeripheralInfo.characteristics) {
-                try {
-                    chachedPeripheralInfo.state = { isConfigured: false, isLoading: true, isInterrupted: false };
-                    yield connector.connect();
-                    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}`) });
-                    chachedPeripheralInfo.characteristics = characteristics;
-                    chachedPeripheralInfo.state = { isConfigured: true, isLoading: false, isInterrupted: false };
-                }
-                catch (err) {
-                    console.log(err);
-                }
-            }
-            else {
-                characteristics = chachedPeripheralInfo.characteristics;
-                this.logEvent({ message: 'characteristic info (*):', info: characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
-            }
-            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;
-        return new Promise((resolve, reject) => {
-            const waitIv = setInterval(() => {
-                if (this.scanState.isScanning && Date.now() > waitTimeout) {
-                    clearInterval(waitIv);
-                    return reject(new Error('scanning already in progress'));
-                }
-                if (!this.scanState.isScanning) {
-                    clearInterval(waitIv);
-                    return resolve(true);
-                }
-            }, 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) {
-        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();
-            }
-            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 });
-            }
-            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 });
-            }
-            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);
-                }
-            }
-            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 } });
-                    }
-                }
-                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.scanState.isScanning = false;
-                        if (scanForDevice) {
-                            reject(new Error('device not found'));
-                            return;
-                        }
-                        resolve(this.devices.map(i => i.device));
-                    });
-                };
-                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;
-                    }
-                    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]);
-                            });
-                        });
-                    }
-                });
-                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()) || [];
-                    }
-                }
-                bleBinding.startScanning(services, false, (err) => {
-                    if (err) {
-                        this.logEvent({ message: `${opStr} result: error`, requested: scanForDevice ? { name, address, profile } : undefined, error: err.message });
-                        this.scanState.isScanning = false;
-                        return reject(err);
-                    }
-                    bleBinding.on('discover', (p) => {
-                        onPeripheralFound(p);
-                    });
-                });
-                this.scanState.timeout = setTimeout(onTimeout, timeout);
-            });
-        });
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'scan stop request' });
-            if (!this.scanState.isScanning) {
-                this.logEvent({ message: 'scan stop result: not scanning' });
-                return true;
-            }
-            if (!this.getBinding())
-                throw new Error('no binding defined');
-            this.getBinding().removeAllListeners('discover');
-            const ongoing = this.peripheralCache.filter(i => i.state.isLoading);
-            if (ongoing)
-                ongoing.forEach(i => { i.isInterrupted = true; });
-            yield this.getBinding().stopScanning();
-            this.scanState.isScanning = false;
-            this.logEvent({ message: 'scan stop result: success' });
-            return true;
-        });
-    }
-    isScanning() {
-        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;
-    }
-    removeConnectedDevice(device) {
-        const existigDevice = this.devices.find(i => i.device.id === device.id);
-        if (existigDevice) {
-            existigDevice.isConnected = false;
-            return;
-        }
-    }
-}
-exports.default = BleInterface;
-BleInterface.deviceClasses = [];
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 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');
+    }
+    static getInstance(props = {}) {
+        if (!BleInterface._instance) {
+            BleInterface._instance = new BleInterface(props);
+        }
+        else {
+            if (props.binding) {
+                BleInterface._instance.setBinding(props.binding);
+            }
+            if (props.logger) {
+                BleInterface._instance.logger = props.logger;
+            }
+            if (props.log && !BleInterface._instance.logger) {
+                BleInterface._instance.logger = new gd_eventlog_1.EventLogger('BLE');
+            }
+        }
+        return BleInterface._instance;
+    }
+    static register(id, type, Class, services) {
+        if (this.deviceClasses.find(i => i.id === id))
+            return;
+        this.deviceClasses.push({ id, type, Class, services });
+    }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        if (process.env.BLE_DEBUG) {
+            console.log('~~BLE:', event);
+        }
+    }
+    onStateChange(state) {
+        if (state !== ble_1.BleState.POWERED_ON) {
+            this.connectState.isConnected = false;
+        }
+        else {
+            this.connectState.isConnected = true;
+        }
+    }
+    onError(err) {
+        this.logEvent({ message: 'error', error: err.message, stack: err.stack });
+    }
+    connect(props = {}) {
+        const timeout = props.timeout || 2000;
+        return new Promise((resolve, reject) => {
+            if (this.connectState.isConnected) {
+                return resolve(true);
+            }
+            this.logEvent({ message: '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'));
+            }, 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) {
+                    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' });
+                    resolve(true);
+                    return;
+                }
+                else {
+                    this.getBinding().once('error', (err) => {
+                        this.connectState.isConnected = true;
+                        this.connectState.isConnecting = false;
+                        this.logEvent({ message: 'connect result: error', error: err.message });
+                        this.getBinding().on('error', this.onError.bind(this));
+                        return reject(err);
+                    });
+                    this.getBinding().on('stateChange', (state) => {
+                        if (state === ble_1.BleState.POWERED_ON) {
+                            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' });
+                            return resolve(true);
+                        }
+                        else {
+                            this.logEvent({ message: 'BLE state change', state });
+                        }
+                    });
+                }
+            }
+            catch (err) {
+                this.connectState.isConnected = false;
+                this.connectState.isConnecting = false;
+                if (this.connectState.timeout)
+                    clearTimeout(this.connectState.timeout);
+                this.connectState.timeout = null;
+                this.logEvent({ message: 'connect result: error', error: err.message });
+                return reject(new Error('bluetooth unavailable, cause: ' + err.message));
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connectState.isConnected) {
+                return Promise.resolve(true);
+            }
+            if (!this.getBinding())
+                return Promise.reject(new Error('no binding defined'));
+            this.logEvent({ message: 'disconnect request' });
+            if (this.scanState.isScanning) {
+                yield this.stopScan();
+            }
+            const connectedDevices = this.devices.filter(d => d.isConnected);
+            for (let i = 0; i < connectedDevices.length; i++) {
+                const d = connectedDevices[i];
+                const device = d.device;
+                yield device.disconnect();
+            }
+            this.connectState.isConnected = false;
+            this.connectState.isConnecting = false;
+            if (this.connectState.timeout) {
+                clearTimeout(this.connectState.timeout);
+                this.connectState.timeout = null;
+            }
+            this.logEvent({ message: 'disconnect result: success' });
+            return true;
+        });
+    }
+    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;
+        return new Promise((resolve, reject) => {
+            const waitIv = setInterval(() => {
+                if (this.scanState.isConnecting && Date.now() > waitTimeout) {
+                    clearInterval(waitIv);
+                    return reject(new Error('Connecting already in progress'));
+                }
+                if (!this.scanState.isConnecting) {
+                    clearInterval(waitIv);
+                    return resolve(true);
+                }
+            }, 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;
+    }
+    getCharacteristics(peripheral) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let characteristics = undefined;
+            let chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
+            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);
+            }
+            const connector = chachedPeripheralInfo.connector;
+            if (!chachedPeripheralInfo.characteristics) {
+                try {
+                    chachedPeripheralInfo.state = { isConfigured: false, isLoading: true, isInterrupted: false };
+                    yield connector.connect();
+                    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}`) });
+                    chachedPeripheralInfo.characteristics = characteristics;
+                    chachedPeripheralInfo.state = { isConfigured: true, isLoading: false, isInterrupted: false };
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            }
+            else {
+                characteristics = chachedPeripheralInfo.characteristics;
+                this.logEvent({ message: 'characteristic info (*):', info: characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
+            }
+            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;
+        return new Promise((resolve, reject) => {
+            const waitIv = setInterval(() => {
+                if (this.scanState.isScanning && Date.now() > waitTimeout) {
+                    clearInterval(waitIv);
+                    return reject(new Error('scanning already in progress'));
+                }
+                if (!this.scanState.isScanning) {
+                    clearInterval(waitIv);
+                    return resolve(true);
+                }
+            }, 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) {
+        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();
+            }
+            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 });
+            }
+            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 });
+            }
+            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);
+                }
+            }
+            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 } });
+                    }
+                }
+                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.scanState.isScanning = false;
+                        if (scanForDevice) {
+                            reject(new Error('device not found'));
+                            return;
+                        }
+                        resolve(this.devices.map(i => i.device));
+                    });
+                };
+                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;
+                    }
+                    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]);
+                            });
+                        });
+                    }
+                });
+                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()) || [];
+                    }
+                }
+                bleBinding.startScanning(services, false, (err) => {
+                    if (err) {
+                        this.logEvent({ message: `${opStr} result: error`, requested: scanForDevice ? { name, address, profile } : undefined, error: err.message });
+                        this.scanState.isScanning = false;
+                        return reject(err);
+                    }
+                    bleBinding.on('discover', (p) => {
+                        onPeripheralFound(p);
+                    });
+                });
+                this.scanState.timeout = setTimeout(onTimeout, timeout);
+            });
+        });
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'scan stop request' });
+            if (!this.scanState.isScanning) {
+                this.logEvent({ message: 'scan stop result: not scanning' });
+                return true;
+            }
+            if (!this.getBinding())
+                throw new Error('no binding defined');
+            this.getBinding().removeAllListeners('discover');
+            const ongoing = this.peripheralCache.filter(i => i.state.isLoading);
+            if (ongoing)
+                ongoing.forEach(i => { i.isInterrupted = true; });
+            yield this.getBinding().stopScanning();
+            this.scanState.isScanning = false;
+            this.logEvent({ message: 'scan stop result: success' });
+            return true;
+        });
+    }
+    isScanning() {
+        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;
+    }
+    removeConnectedDevice(device) {
+        const existigDevice = this.devices.find(i => i.device.id === device.id);
+        if (existigDevice) {
+            existigDevice.isConnected = false;
+            return;
+        }
+    }
+}
+exports.default = BleInterface;
+BleInterface.deviceClasses = [];