incyclist-devices 1.4.43 → 1.4.46

package/lib/ble/ble-interface.js

@@ -8,24 +8,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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_peripheral_1 = __importDefault(require("./ble-peripheral"));
 const CONNECT_TIMEOUT = 5000;
+const DEFAULT_SCAN_TIMEOUT = 20000;
+const BACKGROUND_SCAN_TIMEOUT = 30000;
+const DEFAULT_SERVICES = ['1818', '180d', '1826'];
 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.deviceCache = [];
         this.peripheralCache = [];
         if (props.logger)
             this.logger = props.logger;
-        else if (props.log) {
-            this.logger = new gd_eventlog_1.EventLogger('BLE');
-        }
+        this.logger = new gd_eventlog_1.EventLogger('BLE');
     }
     static getInstance(props = {}) {
         if (!BleInterface._instance) {
@@ -71,8 +75,9 @@ class BleInterface extends ble_1.BleInterfaceClass {
     connect(props = {}) {
         const timeout = props.timeout || 2000;
         const runBackgroundScan = () => {
+            return;
             this.scanState.isBackgroundScan = true;
-            this.scan({ timeout: 5000, isBackgroundScan: true })
+            this.scan({ timeout: BACKGROUND_SCAN_TIMEOUT, isBackgroundScan: true })
                 .then(() => {
                 this.scanState.isBackgroundScan = false;
             })
@@ -211,7 +216,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
             });
         };
         if (typeof services === 'string') {
-            return get(deviceTypes, (s) => s === ble_1.uuid(services));
+            return get(deviceTypes, (s) => s === (0, ble_1.uuid)(services));
         }
         if (Array.isArray(services)) {
             return get(deviceTypes, s => services.map(ble_1.uuid).includes(s));
@@ -219,19 +224,24 @@ class BleInterface extends ble_1.BleInterfaceClass {
         return [];
     }
     getServicesFromDeviceTypes(deviceTypes) {
-        if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
-            return [];
-        }
-        const services = [];
-        deviceTypes.forEach(DeviceType => {
-            if (DeviceType.services) {
-                const dtServices = DeviceType.services;
-                dtServices.forEach(s => {
-                    if (!services.find(s2 => s2 === s))
-                        services.push(s);
-                });
+        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) {
@@ -261,15 +271,124 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }, 100);
         });
     }
-    connectDevice(requested, timeout = CONNECT_TIMEOUT) {
+    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));
+    }
+    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* () {
-            const { id, name, address, getProfile } = requested;
-            const profile = getProfile && typeof (getProfile) === 'function' ? getProfile() : undefined;
+            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 } = props;
+        if ((!deviceTypes || deviceTypes.length === 0)) {
+            const classes = BleInterface.deviceClasses.map(c => c.Class);
+            DeviceClasses = this.getDevicesFromServices(classes, peripheral.advertisement.serviceUuids);
+        }
+        else {
+            DeviceClasses = this.getDevicesFromServices(deviceTypes, peripheral.advertisement.serviceUuids);
+        }
+        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) {
+        const C = DeviceClass;
+        const device = new C({ peripheral });
+        const existingDevice = this.devices.find(i => i.device.id === device.id && i.device.getProfile() === device.getProfile());
+        if (existingDevice)
+            return existingDevice;
+        device.setInterface(this);
+        device.characteristics = characteristics;
+        return device;
+    }
+    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(10000);
+                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) {
+                const connected = 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;
+                            yield devices[i].connect();
+                            this.devices[idx].isConnected = true;
+                        }
+                    }
+                }
+            }
             let devices = [];
             let retry = false;
             let retryCount = 0;
@@ -278,7 +397,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     this.logEvent({ message: 'retry connect device', id, name, address, profile, retryCount });
                 }
                 try {
-                    devices = yield this.scan({ timeout, device: requested });
+                    devices = yield this.scan({ timeout: DEFAULT_SCAN_TIMEOUT, requested: requested });
                     if (devices.length === 0) {
                         retryCount++;
                         retry = retryCount < 5;
@@ -286,7 +405,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 }
                 catch (err) {
                     if (err.message === 'scanning already in progress') {
-                        yield utils_1.sleep(1000);
+                        yield (0, utils_1.sleep)(1000);
                         retryCount++;
                         retry = retryCount < 5;
                         continue;
@@ -331,26 +450,17 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }, 100);
         });
     }
-    addPeripheralToCache(peripheral) {
-        try {
-            this.logEvent({ message: 'adding device to cache', device: { address: peripheral.address, name: peripheral.advertisement ? peripheral.advertisement.localName : '' } });
-            const existing = this.deviceCache.find(p => p.address === peripheral.address);
-            if (!existing)
-                this.deviceCache.push(peripheral);
-            else {
-                if (peripheral.advertisement && peripheral.advertisement.localName !== '' && existing.advertisement && existing.advertisement.localName === '')
-                    existing.advertisement.localName = peripheral.advertisement.localName;
-            }
-        }
-        catch (err) {
-            console.log('~~~ error', err);
-        }
-    }
     scan(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { timeout = 5000, deviceTypes = [], device } = props;
-            const scanForDevice = (device !== null && device !== undefined);
-            const services = this.getServicesFromDeviceTypes(deviceTypes);
+            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 = (props.isBackgroundScan || !deviceTypes || deviceTypes.length === 0) ? DEFAULT_SERVICES : this.getServicesFromDeviceTypes(deviceTypes);
             const bleBinding = this.getBinding();
             if (!bleBinding)
                 return Promise.reject(new Error('no binding defined'));
@@ -358,7 +468,11 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 yield this.connect();
             }
             const peripheralsProcessed = [];
-            this.logEvent({ message: 'scan()', props, scanState: this.scanState, cache: this.deviceCache.map(p => ({ name: p.advertisement ? p.advertisement.localName : '', address: p.address })) });
+            const devicesProcessed = [];
+            this.logEvent({ message: 'scan()', props, 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 }))
+            });
             if (!props.isBackgroundScan && this.scanState.isBackgroundScan) {
                 yield this.stopScan();
                 this.scanState.isBackgroundScan = false;
@@ -366,7 +480,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
             let opStr;
             if (scanForDevice) {
                 opStr = 'search device';
-                const { id, address, name } = device;
                 this.logEvent({ message: 'search device request', device: { id, address, name }, deviceTypes });
             }
             else {
@@ -387,158 +500,93 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 this.scanState.isScanning = true;
                 if (props.isBackgroundScan)
                     this.scanState.isBackgroundScan = true;
-                if (scanForDevice && device instanceof ble_1.BleDeviceClass) {
+                if (scanForDevice) {
                     if (this.devices && this.devices.length > 0) {
-                        const connectedDevices = this.devices.map(i => ({ name: i.device.name, address: i.device.address, isConnected: i.isConnected, connectState: i.device.getConnectState() }));
-                        const { name, address } = device;
-                        this.logEvent({ message: `${opStr}: check if already registered`, device: { name, address }, connectedDevices });
-                        const existing = this.devices.find(i => (i.device.address === device.address || i.device.name === device.name));
-                        if (existing) {
-                            const d = device;
-                            const linkedDevice = existing.device;
-                            d.peripheral = existing.device.peripheral;
-                            if (d.setInterface && typeof (d.setInterface) === 'function')
-                                d.setInterface(this);
-                            setTimeout(() => {
-                                let connectState = linkedDevice.getConnectState();
-                                this.logEvent({ message: `${opStr}: device already registered`, device: device.name, address: device.address, connectState });
-                                if (connectState.isConnecting) {
-                                    const waitStart = Date.now();
-                                    const waitTimeout = waitStart + timeout;
-                                    const waitIv = setInterval(() => {
-                                        try {
-                                            connectState = linkedDevice.getConnectState();
-                                            if (connectState.isConnecting && Date.now() > waitTimeout) {
-                                                clearInterval(waitIv);
-                                                this.scanState.isScanning = false;
-                                                return resolve([]);
-                                            }
-                                            if (!connectState.isConnecting) {
-                                                clearInterval(waitIv);
-                                                this.scanState.isScanning = false;
-                                                return resolve([device]);
-                                            }
-                                        }
-                                        catch (err) {
-                                            console.log('~~~ error', err);
-                                        }
-                                    }, 100);
-                                }
-                                else if (connectState.isConnected) {
-                                    this.scanState.isScanning = false;
-                                    resolve([device]);
-                                }
-                                else {
-                                    this.scanState.isScanning = false;
-                                    resolve([]);
-                                }
-                            }, 100);
-                        }
+                        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));
                     }
                 }
+                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 (fromCache)
                         this.logEvent({ message: 'adding from Cache', peripheral: peripheral.address });
-                    if (!peripheral || !peripheral.advertisement)
+                    if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.serviceUuids || peripheral.advertisement.serviceUuids.length === 0)
                         return;
-                    let existingPeripheral = this.peripheralCache.find(i => i.address === peripheral.address);
-                    if (existingPeripheral && Date.now() - existingPeripheral.ts > 600000) {
-                        existingPeripheral.ts = Date.now();
-                    }
-                    if (!existingPeripheral) {
-                        this.peripheralCache.push({ address: peripheral.address, ts: Date.now(), peripheral });
-                        existingPeripheral = this.peripheralCache.find(i => i.address === peripheral.address);
-                    }
-                    let shouldAddDevice = peripheralsProcessed.find(p => p === peripheral.address) === undefined;
-                    if (shouldAddDevice) {
-                        if (process.env.BLE_DEBUG)
-                            console.log('discovered', peripheral.id, peripheral.address, peripheral.advertisement.localName);
-                        peripheralsProcessed.push(peripheral.address);
-                        let characteristics;
-                        if (!existingPeripheral.characteristics) {
-                            try {
-                                if (existingPeripheral.peripheral && existingPeripheral.peripheral.state !== 'connected')
-                                    yield peripheral.connectAsync();
-                                const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
-                                this.logEvent({ message: 'characteristic info (+):', info: res.characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
-                                if (peripheral.disconnect && typeof (peripheral.disconnect) === 'function')
-                                    peripheral.disconnect(() => { });
-                                existingPeripheral.characteristics = res.characteristics;
-                                characteristics = res.characteristics;
-                            }
-                            catch (err) {
-                                console.log(err);
-                            }
-                        }
-                        else {
-                            characteristics = existingPeripheral.characteristics;
-                            this.logEvent({ message: 'characteristic info (+):', info: characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
-                        }
-                        if (!fromCache)
-                            this.addPeripheralToCache(peripheral);
-                        let DeviceClasses;
-                        if (scanForDevice && (!deviceTypes || deviceTypes.length === 0)) {
-                            const classes = BleInterface.deviceClasses.map(c => c.Class);
-                            DeviceClasses = this.getDevicesFromServices(classes, peripheral.advertisement.serviceUuids);
+                    const isPeripheralProcessed = peripheralsProcessed.find(p => p === peripheral.address) !== undefined;
+                    if (isPeripheralProcessed)
+                        return;
+                    peripheralsProcessed.push(peripheral.address);
+                    let chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
+                    const str = fromCache ? 'added' : 'detected';
+                    const characteristics = yield this.getCharacteristics(peripheral);
+                    const DeviceClasses = this.getDeviceClasses(peripheral, { profile });
+                    let cntFound = 0;
+                    DeviceClasses.forEach((DeviceClass) => __awaiter(this, void 0, void 0, function* () {
+                        if (!DeviceClass)
+                            return;
+                        if (scanForDevice && cntFound > 0)
+                            return;
+                        const d = this.createDevice(DeviceClass, peripheral, characteristics);
+                        yield d.connect();
+                        if (scanForDevice) {
+                            if ((id && id !== '' && d.id === id) ||
+                                (address && address !== '' && d.address === address) ||
+                                (name && name !== '' && d.name === name))
+                                cntFound++;
                         }
-                        else {
-                            DeviceClasses = this.getDevicesFromServices(deviceTypes, peripheral.advertisement.serviceUuids);
+                        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, address: d.address, services: d.services.join(',') });
+                            this.addDeviceToCache(d, peripheral.state === 'connected');
+                            devicesProcessed.push(d);
+                            this.emit('device', d);
+                            return;
                         }
-                        DeviceClasses.forEach(DeviceClass => {
-                            let cntFound = 0;
-                            if (!DeviceClass)
-                                return;
-                            if (scanForDevice && cntFound > 0)
-                                return;
-                            const C = DeviceClass;
-                            const d = new C({ peripheral });
-                            if (device && device.getProfile && device.getProfile() !== d.getProfile())
-                                return;
-                            d.setInterface(this);
-                            d.characteristics = characteristics;
-                            if (scanForDevice) {
-                                if ((device.id && device.id !== '' && d.id === device.id) ||
-                                    (device.address && device.address !== '' && d.address === device.address) ||
-                                    (device.name && device.name !== '' && d.name === device.name))
-                                    cntFound++;
-                            }
-                            else
-                                cntFound++;
-                            const existing = this.devices.find(i => i.device.id === d.id && i.device.getProfile() === d.getProfile());
-                            if (!scanForDevice && cntFound > 0 && !existing) {
-                                this.logEvent({ message: `${opStr}: device found`, device: d.name, address: d.address, services: d.services.join(',') });
-                                this.devices.push({ device: d, isConnected: false });
-                                this.emit('device', d);
-                            }
-                            if (scanForDevice && cntFound > 0) {
-                                if (fromCache) {
-                                    resolve([d]);
-                                    return;
-                                }
+                        if (scanForDevice && cntFound > 0) {
+                            this.logEvent({ message: `${opStr}: device found`, device: d.name, 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: device.name, address: device.address } : undefined, });
-                                    bleBinding.stopScanning(() => {
-                                        this.getBinding().removeAllListeners('discover');
-                                        this.scanState.isScanning = false;
-                                        resolve([d]);
-                                    });
                                 }
-                                else {
+                                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: device.name, address: device.address } : undefined, timeout });
-                this.deviceCache.forEach(peripheral => {
-                    onPeripheralFound(peripheral, true);
+                this.logEvent({ message: `${opStr}: start scanning`, requested: scanForDevice ? { name, address, profile } : undefined, timeout });
+                this.peripheralCache.forEach(i => {
+                    onPeripheralFound(i.peripheral, true);
                 });
                 bleBinding.startScanning([], true, (err) => {
                     if (err) {
-                        this.logEvent({ message: `${opStr} result: error`, requested: scanForDevice ? { name: device.name, address: device.address } : undefined, error: err.message });
+                        this.logEvent({ message: `${opStr} result: error`, requested: scanForDevice ? { name, address, profile } : undefined, error: err.message });
                         this.scanState.isScanning = false;
                         return reject(err);
                     }
@@ -546,20 +594,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         onPeripheralFound(p);
                     });
                 });
-                this.scanState.timeout = setTimeout(() => {
-                    this.scanState.timeout = null;
-                    this.logEvent({ message: `${opStr} result: devices found`, requested: scanForDevice ? { name: device.name, address: device.address } : 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: device.name, address: device.address } : undefined, });
-                    bleBinding.stopScanning(() => {
-                        this.scanState.isScanning = false;
-                        if (scanForDevice) {
-                            reject(new Error('device not found'));
-                            return;
-                        }
-                        resolve(this.devices.map(i => i.device));
-                    });
-                }, timeout);
+                this.scanState.timeout = setTimeout(onTimeout, timeout);
             });
         });
     }
@@ -570,6 +605,9 @@ class BleInterface extends ble_1.BleInterfaceClass {
         if (!this.getBinding())
             return Promise.reject(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; });
         this.logEvent({ message: 'scan stop request' });
         return new Promise(resolve => {
             this.getBinding().stopScanning(() => {
@@ -583,19 +621,30 @@ class BleInterface extends ble_1.BleInterfaceClass {
         return this.scanState.isScanning;
     }
     addConnectedDevice(device) {
-        const existigDevice = this.devices.find(i => i.device.id === device.id);
+        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) {

package/lib/ble/ble-peripheral.d.ts

@@ -0,0 +1,34 @@
+import { BleCharacteristic, BlePeripheral } from "./ble";
+import BleInterface from "./ble-interface";
+export declare type ConnectorState = {
+    isConnected: boolean;
+    isConnecting: boolean;
+    isInitialized: boolean;
+    isInitializing: boolean;
+    isSubscribing: boolean;
+    subscribed?: string[];
+};
+export default class BlePeripheralConnector {
+    private state;
+    private services;
+    private characteristics;
+    private ble;
+    private peripheral;
+    private logger?;
+    private emitter;
+    constructor(ble: BleInterface, peripheral: BlePeripheral);
+    logEvent(event: any): void;
+    connect(): Promise<void>;
+    reconnect(): Promise<void>;
+    onDisconnect(): void;
+    initialize(enforce?: boolean): Promise<void>;
+    subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
+    subscribe(characteristicUuid: string): Promise<boolean>;
+    onData(characteristicUuid: string, data: any): void;
+    on(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
+    off(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
+    removeAllListeners(characteristicUuid: string): void;
+    getState(): string;
+    getCharachteristics(): BleCharacteristic[];
+    getServices(): string[];
+}