incyclist-devices 2.3.0-beta.19 → 2.3.0-beta.20

package/lib/ble/base/comms.js

@@ -1,6 +1,599 @@
 "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 });
-exports.BleSensor = void 0;
-class BleSensor {
+exports.BleComms = void 0;
+const events_1 = __importDefault(require("events"));
+const gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("../../utils/utils");
+const ble_interface_1 = __importDefault(require("../ble-interface"));
+const utils_2 = require("../utils");
+const CONNECT_WAIT_TIMEOUT = 10000;
+const BLE_TIMEOUT = 1000;
+class BleComms extends events_1.default {
+    constructor(props) {
+        super();
+        this.characteristics = [];
+        this.deviceInfo = {};
+        this.connectState = { isConnecting: false, isConnected: false, isDisconnecting: false };
+        this.id = props.id;
+        this.address = props.address;
+        this.name = props.name;
+        this.services = props.services;
+        this.ble = ble_interface_1.default.getInstance();
+        this.characteristics = [];
+        this.subscribedCharacteristics = [];
+        this.isInitialized = false;
+        this.writeQueue = [];
+        this.workerIv = null;
+        this.prevMessages = [];
+        this.paused = false;
+        if (props.peripheral) {
+            const { id, address, advertisement, state } = props.peripheral;
+            this.peripheral = props.peripheral;
+            this.id = id;
+            this.address = address;
+            this.name = advertisement.localName;
+            this.services = advertisement.serviceUuids;
+            this.state = state;
+        }
+        if (props.logger) {
+            this.logger = props.logger;
+        }
+        else if (props.log !== false) {
+            this.logger = new gd_eventlog_1.EventLogger('BleDevice');
+        }
+    }
+    getConnectState() {
+        return this.connectState;
+    }
+    isConnected() {
+        return this.connectState.isConnected;
+    }
+    pause() {
+        this.ble.pauseLogging();
+        this.paused = true;
+    }
+    resume() {
+        this.paused = false;
+        this.ble.resumeLogging();
+    }
+    getServiceUUids() {
+        throw new Error("Method not implemented.");
+    }
+    getProfile() {
+        throw new Error("Method not implemented.");
+    }
+    getProtocol() {
+        throw new Error("Method not implemented.");
+    }
+    getSettings() {
+        const { id, address, name } = this;
+        return { id, name, address, interface: 'ble', protocol: this.getProtocol() };
+    }
+    getServices() {
+        return this.services;
+    }
+    logEvent(event) {
+        if (this.paused)
+            return;
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            console.log('~~~ BLE', event);
+        }
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    setInterface(ble) {
+        this.ble = ble;
+    }
+    static isMatching(characteristics) {
+        return true;
+    }
+    reset() {
+        if (this.connectState.isConnecting)
+            this.ble.stopConnectSensor();
+    }
+    cleanupListeners() {
+        if (this.characteristics === undefined) {
+            this.characteristics = [];
+        }
+        else {
+            if (this.peripheral) {
+                const connector = this.ble.peripheralCache.getConnector(this.peripheral);
+                this.characteristics.forEach(c => {
+                    connector.removeAllListeners((0, utils_2.uuid)(c.uuid));
+                });
+            }
+            else {
+                this.characteristics = [];
+            }
+        }
+    }
+    onDisconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
+            this.state = "disconnected";
+            const wasConnecting = this.connectState.isConnecting;
+            this.connectState.isConnecting = false;
+            this.connectState.isConnected = false;
+            if (!this.connectState.isDisconnecting) {
+                this.peripheral.state = 'disconnected';
+                this.cleanupListeners();
+                this.subscribedCharacteristics = [];
+                this.ble.onDisconnect(this.peripheral);
+                if (wasConnecting) {
+                    this.emit('connection-failed');
+                }
+                else {
+                    this.connect({ reconnect: true });
+                }
+            }
+        });
+    }
+    waitForConnectFinished(timeout) {
+        const waitStart = Date.now();
+        const waitTimeout = waitStart + timeout;
+        return new Promise((resolve, reject) => {
+            const waitIv = setInterval(() => {
+                try {
+                    if (this.connectState.isConnecting && Date.now() > waitTimeout) {
+                        clearInterval(waitIv);
+                        return reject(new Error('connection already in progress'));
+                    }
+                    if (!this.connectState.isConnecting) {
+                        clearInterval(waitIv);
+                        return resolve(true);
+                    }
+                }
+                catch (err) {
+                    this.logEvent({ message: 'error', fn: '', error: err.message, stack: err.stack });
+                }
+            }, 100);
+        });
+    }
+    hasService(serviceUuid) {
+        return this.services && this.services.find(s => s === serviceUuid || (0, utils_2.uuid)(serviceUuid)) !== undefined;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.initDevice();
+        });
+    }
+    initDevice() {
+        this.logEvent({ message: 'get device info' });
+        return this.getDeviceInfo().then((info) => {
+            this.emit('deviceInfo', info);
+            this.logEvent(Object.assign({ message: 'device init done' }, info));
+            this.isInitialized = true;
+            return true;
+        });
+    }
+    connectPeripheral(peripheral) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connectState.isConnecting = true;
+            let disconnectSignalled = false;
+            return new Promise((done) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const connector = this.ble.peripheralCache.getConnector(peripheral);
+                    const disconnectHandler = () => {
+                        this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
+                        this.state = "disconnected";
+                        disconnectSignalled = true;
+                        this.cleanupListeners();
+                        this.subscribedCharacteristics = [];
+                        this.connectState.isConnecting = false;
+                        this.connectState.isConnected = false;
+                        this.ble.onDisconnect(this.peripheral);
+                        done(false);
+                    };
+                    connector.removeAllListeners('disconnect');
+                    connector.once('disconnect', disconnectHandler);
+                    yield connector.connect();
+                    if (disconnectSignalled)
+                        return;
+                    const initialized = yield connector.initialize();
+                    if (!initialized || disconnectSignalled)
+                        return done(false);
+                    yield this.subscribeAll(connector);
+                    if (disconnectSignalled)
+                        return done(false);
+                    this.connectState.isConnected = true;
+                    this.state = "connected";
+                    this.emit('connected');
+                    connector.removeAllListeners('disconnect');
+                    connector.on('disconnect', this.onDisconnect.bind(this));
+                    const success = yield this.init();
+                    done(success);
+                    return;
+                }
+                catch (err) {
+                    this.logEvent({ message: 'Error', fn: 'connectPeripheral()', error: err.message, stack: err.stack });
+                }
+                this.connectState.isConnecting = false;
+                if (disconnectSignalled)
+                    return;
+                done(true);
+            }));
+        });
+    }
+    subscribeMultiple(characteristics, conn) {
+        this.logEvent({ message: 'subscribe', characteristics });
+        return new Promise(resolve => {
+            try {
+                const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
+                const subscribeSingle = (c) => {
+                    connector.removeAllListeners(c);
+                    connector.on(c, (uuid, data) => {
+                        this.onData(uuid, data);
+                    });
+                    return connector.subscribe(c).then(res => {
+                        this.subscribedCharacteristics.push(c);
+                        return res;
+                    }).catch(err => {
+                        this.logEvent({ message: 'subscription failed', characteristic: c, error: err.message });
+                    });
+                };
+                const promises = characteristics
+                    .filter(c => {
+                    if (this.characteristics) {
+                        const existing = this.characteristics.find(rc => rc.uuid === c || (0, utils_2.uuid)(rc.uuid) === c);
+                        if (!existing)
+                            return false;
+                    }
+                    const isAlreadySubscribed = connector.isSubscribed(c);
+                    return !isAlreadySubscribed;
+                })
+                    .map(c => subscribeSingle(c));
+                Promise.all(promises).then(() => resolve());
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'subscribeMultiple()', error: err.message, stack: err.stack });
+            }
+        });
+    }
+    subscribeAll(conn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
+                const subscribed = yield connector.subscribeAll((uuid, data) => { this.onData(uuid, data); });
+                subscribed.forEach(c => this.subscribedCharacteristics.push(c));
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
+            }
+        });
+    }
+    unsubscribeAll(conn) {
+        const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
+        connector.unsubscribeAll();
+    }
+    connect(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ble.resumeLogging();
+            if (!this.ble.isConnected()) {
+                try {
+                    yield this.ble.connect();
+                    if (!this.ble.isConnected())
+                        return false;
+                }
+                catch (err) {
+                    return false;
+                }
+            }
+            yield (0, utils_1.sleep)(Math.random() * 100);
+            yield this.ble.waitForSensorConnectionFinish();
+            this.ble.startConnectSensor();
+            const { reconnect } = props || {};
+            try {
+                this.logEvent({ message: reconnect ? 'reconnect' : 'connect', name: this.name, id: this.id, address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
+                if (!reconnect && this.connectState.isConnecting) {
+                    yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
+                }
+                if (this.connectState.isConnected) {
+                    try {
+                        yield this.subscribeAll();
+                        yield this.init();
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'cannot reconnect', error: err.message || err });
+                        this.ble.stopConnectSensor();
+                        return false;
+                    }
+                    this.ble.stopConnectSensor();
+                    return true;
+                }
+                this.connectState.isConnecting = true;
+                if (!this.peripheral) {
+                    const { id, name, address } = this;
+                    try {
+                        this.peripheral = this.ble.peripheralCache.getPeripheral({ id, name, address });
+                        const connector = this.ble.peripheralCache.getConnector(this.peripheral);
+                        if (!connector) {
+                        }
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'error', fn: 'connect()', error: err.message, stack: err.stack });
+                    }
+                }
+                if (this.peripheral) {
+                    const { id, address, advertisement } = this.peripheral;
+                    const name = advertisement === null || advertisement === void 0 ? void 0 : advertisement.localName;
+                    this.logEvent({ message: 'connect requested', mode: 'peripheral', device: { id, name, address: address } });
+                    const connected = yield this.connectPeripheral(this.peripheral);
+                    this.logEvent({ message: 'connect result: ', connected, mode: 'peripheral', device: { id, name, address } });
+                    this.connectState.isConnecting = false;
+                    this.connectState.isConnected = connected;
+                    this.ble.stopConnectSensor();
+                    return connected;
+                }
+                else {
+                    const { id, name, address } = this;
+                    let error;
+                    if (this.address || this.id || this.name) {
+                        this.logEvent({ message: 'connect requested', mode: 'device', device: { id, name, address } });
+                        try {
+                            if (this.ble.isScanning()) {
+                                yield this.ble.stopScan();
+                            }
+                            const peripheral = yield this.ble.scanForDevice(this, {});
+                            if (peripheral) {
+                                this.peripheral = peripheral;
+                                const connected = yield this.connectPeripheral(this.peripheral);
+                                this.logEvent({ message: 'connect result: ', connected, mode: 'device', device: { id, name, address } });
+                                this.connectState.isConnecting = false;
+                                this.connectState.isConnected = connected;
+                                this.ble.stopConnectSensor();
+                                return connected;
+                            }
+                        }
+                        catch (err) {
+                            error = err;
+                        }
+                    }
+                    this.logEvent({ message: 'connect result: failure', mode: 'device', device: { id, name, address }, error: error.message });
+                    this.connectState.isConnecting = false;
+                    this.connectState.isConnected = false;
+                    this.ble.stopConnectSensor();
+                    return false;
+                }
+            }
+            catch (err) {
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                this.logEvent({ message: 'connect result: error', error: err.message, stack: err.stack });
+                this.ble.stopConnectSensor();
+                return false;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { id, name, address } = this;
+            this.logEvent({ message: 'disconnect requested', device: { id, name, address } });
+            this.ble.pauseLogging();
+            this.connectState.isDisconnecting = true;
+            if (this.workerIv) {
+                this.stopWorker();
+            }
+            if (!this.connectState.isConnecting && !this.connectState.isConnected) {
+                this.connectState.isDisconnecting = false;
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                return true;
+            }
+            if (this.connectState.isConnecting) {
+                this.cleanupListeners();
+                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
+                this.logEvent({ message: 'disconnect result: unclear - connect ongoing', device: { id, name, address } });
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                return true;
+            }
+            if (this.connectState.isConnected) {
+                this.cleanupListeners();
+                this.unsubscribeAll();
+                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                this.connectState.isDisconnecting = false;
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                return true;
+            }
+        });
+    }
+    checkForDuplicate(characteristic, data) {
+        const prev = this.prevMessages.find(i => i.uuid === characteristic);
+        if (prev) {
+            if (prev.data === data.toString('hex') && prev.timestamp > Date.now() - 500) {
+                prev.timestamp = Date.now();
+                return true;
+            }
+            else {
+                prev.data = data.toString('hex');
+                prev.timestamp = Date.now();
+            }
+        }
+        else {
+            this.prevMessages.push({ uuid: characteristic, timestamp: Date.now(), data: data.toString('hex') });
+        }
+        return false;
+    }
+    onData(characteristic, _data) {
+        const data = Buffer.from(_data);
+        const isDuplicate = this.checkForDuplicate(characteristic, data);
+        if (isDuplicate) {
+            return false;
+        }
+        this.logEvent({ message: 'got data', characteristic, data: data.toString('hex'), writeQueue: this.writeQueue.length });
+        if (this.writeQueue.length > 0) {
+            const writeIdx = this.writeQueue.findIndex(i => (0, utils_2.matches)(i.uuid, characteristic));
+            if (writeIdx !== -1) {
+                const writeItem = this.writeQueue[writeIdx];
+                this.writeQueue.splice(writeIdx, 1);
+                if (writeItem.resolve)
+                    writeItem.resolve(data);
+                return false;
+            }
+        }
+        return true;
+    }
+    timeoutCheck() {
+        const now = Date.now();
+        const updatedQueue = [];
+        let hasTimeout = false;
+        this.writeQueue.forEach(writeItem => {
+            if (writeItem.timeout && writeItem.timeout < now) {
+                if (writeItem.reject) {
+                    hasTimeout = true;
+                    writeItem.reject(new Error('timeout'));
+                }
+            }
+            else {
+                updatedQueue.push(writeItem);
+            }
+        });
+        if (hasTimeout)
+            this.writeQueue = updatedQueue;
+    }
+    startWorker() {
+        if (this.workerIv)
+            return;
+        this.workerIv = setInterval(() => { this.timeoutCheck(); }, 100);
+    }
+    stopWorker() {
+        if (!this.workerIv)
+            return;
+        clearInterval(this.workerIv);
+        this.workerIv = null;
+    }
+    write(characteristicUuid, data, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected())
+                throw new Error('not connected');
+            try {
+                const { withoutResponse, timeout } = props || {};
+                let fireAndForget = withoutResponse;
+                const connector = this.ble.peripheralCache.getConnector(this.peripheral);
+                const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
+                if (!withoutResponse && !this.workerIv) {
+                    this.startWorker();
+                }
+                if (!withoutResponse && !isAlreadySubscribed) {
+                    const connector = this.ble.peripheralCache.getConnector(this.peripheral);
+                    connector.removeAllListeners(characteristicUuid);
+                    connector.on(characteristicUuid, (uuid, data) => {
+                        this.onData(uuid, data);
+                    });
+                    this.logEvent({ message: 'write:subscribing ', characteristic: characteristicUuid });
+                    try {
+                        yield connector.subscribe(characteristicUuid);
+                        this.subscribedCharacteristics.push(characteristicUuid);
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'write:subscribing failed', characteristic: characteristicUuid, error: err.message });
+                        fireAndForget = true;
+                    }
+                }
+                return new Promise((resolve, reject) => {
+                    const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_2.uuid)(c.uuid) === characteristicUuid);
+                    if (!characteristic) {
+                        this.logEvent({ message: 'write: Characteristic not found', characteristicUuid, characteristics: this.characteristics.map(c => c.uuid) });
+                        reject(new Error(`Characteristic not found`));
+                        return;
+                    }
+                    if (fireAndForget) {
+                        this.logEvent({ message: 'writing', data: data.toString('hex'), withoutResponse: 'true' });
+                        characteristic.write(data, true);
+                        resolve(new ArrayBuffer(0));
+                        return;
+                    }
+                    else {
+                        const writeId = this.writeQueue.length;
+                        let messageDeleted = false;
+                        const writeTimeout = timeout !== undefined ? timeout : BLE_TIMEOUT;
+                        this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, timeout: Date.now() + writeTimeout, resolve, reject });
+                        const to = setTimeout(() => {
+                            if (this.writeQueue.length > writeId && !messageDeleted)
+                                this.writeQueue.splice(writeId, 1);
+                            this.logEvent({ message: 'writing response', err: 'timeout' });
+                            reject(new Error('timeout'));
+                        }, 5000);
+                        this.logEvent({ message: 'writing' });
+                        characteristic.write(data, withoutResponse, (err) => {
+                            clearTimeout(to);
+                            this.logEvent({ message: 'writing response', err });
+                            if (err) {
+                                this.writeQueue.splice(writeId, 1);
+                                messageDeleted = true;
+                                reject(err);
+                            }
+                        });
+                    }
+                });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'write', error: err.message || err, stack: err.stack });
+            }
+        });
+    }
+    read(characteristicUuid) {
+        return new Promise((resolve, reject) => {
+            if (!this.isConnected())
+                return reject(new Error('not connected'));
+            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_2.uuid)(c.uuid) === characteristicUuid);
+            if (!characteristic) {
+                this.logEvent({ message: 'read: Characteristic not found', characteristicUuid, characteristics: this.characteristics.map(c => c.uuid) });
+                reject(new Error('Characteristic not found'));
+                return;
+            }
+            characteristic.read((err, data) => {
+                if (err && data instanceof Error)
+                    reject(err);
+                else if (data instanceof Error)
+                    reject(data);
+                else
+                    resolve(data);
+            });
+        });
+    }
+    getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = this.deviceInfo;
+            const readValue = (c) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const b = yield this.read(c);
+                    const buffer = b ? Buffer.from(b) : undefined;
+                    return buffer ? buffer.toString() : undefined;
+                }
+                catch (_a) {
+                    return undefined;
+                }
+            });
+            info.model = info.model || (yield readValue('2a24'));
+            info.serialNo = info.serialNo || (yield readValue('2a25'));
+            info.fwRevision = info.fwRevision || (yield readValue('2a26'));
+            info.hwRevision = info.hwRevision || (yield readValue('2a27'));
+            info.swRevision = info.swRevision || (yield readValue('2a28'));
+            info.manufacturer = info.manufacturer || (yield readValue('2a29'));
+            this.deviceInfo = info;
+            return info;
+        });
+    }
 }
-exports.BleSensor = BleSensor;
+exports.BleComms = BleComms;
+BleComms.services = [];

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

@@ -1,8 +1,8 @@
 import { EventLogger } from 'gd-eventlog';
 import BleAdapterFactory from './adapter-factory';
-import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic, IBleInterface } from './types';
+import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic } from './types';
 import { BleComms } from './base/comms';
-import { IncyclistScanProps } from '../types';
+import { IncyclistInterface, IncyclistScanProps } from '../types';
 import BlePeripheralCache from './peripheral-cache';
 import EventEmitter from 'events';
 export interface ScanState {
@@ -31,7 +31,7 @@ export interface BleDeviceClassInfo {
     services: string[];
     id: string;
 }
-export default class BleInterface extends EventEmitter implements IBleInterface {
+export default class BleInterface extends EventEmitter implements IncyclistInterface {
     scanState: ScanState;
     connectState: ConnectState;
     peripheralCache: BlePeripheralCache;
@@ -62,8 +62,7 @@ export default class BleInterface extends EventEmitter implements IBleInterface
     pauseLogging(debugOnly?: boolean): void;
     resumeLogging(): void;
     protected isDebugEnabled(): boolean;
-    logEvent(event: any): void;
-    logError(err: Error, fn: string, args?: any): void;
+    protected logEvent(event: any): void;
     protected onStateChange(state: BleInterfaceState): void;
     protected onError(err: any): void;
     connect(to?: number): Promise<boolean>;
@@ -80,8 +79,6 @@ export default class BleInterface extends EventEmitter implements IBleInterface
     }): Promise<any>;
     scanForDevice(comms: BleComms, props: IncyclistScanProps): Promise<BlePeripheral>;
     scan(props?: BleScanProps): Promise<BleDeviceSettings[]>;
-    protected legacyScan(props?: BleScanProps): Promise<BleDeviceSettings[]>;
     stopScan(): Promise<boolean>;
     isScanning(): boolean;
-    getLogger(): EventLogger;
 }

package/lib/ble/ble-interface.js

@@ -118,10 +118,6 @@ class BleInterface extends events_1.default {
             console.log('~~~ BLE', event);
         }
     }
-    logError(err, fn, args) {
-        const logInfo = args || {};
-        this.logEvent(Object.assign(Object.assign({ message: 'Error', fn }, logInfo), { error: err.message, stack: err.stack }));
-    }
     onStateChange(state) {
         if (state !== 'poweredOn') {
             this.logEvent({ message: 'Ble disconnected', });
@@ -146,12 +142,10 @@ class BleInterface extends events_1.default {
             this.resumeLogging();
             const timeout = this.props.timeout || to || 2000;
             const connect = new Promise((resolve, reject) => {
-                this.logEvent({ message: 'Ble connect request', timeout });
+                this.logEvent({ message: 'Ble connect request' });
                 if (!this.getBinding())
                     return reject(new Error('no binding defined'));
-                this.connectState.isConnecting = true;
                 this.connectState.timeout = setTimeout(() => {
-                    console.log('connect timeout');
                     this.connectState.isConnected = false;
                     this.connectState.isConnecting = false;
                     this.connectState.timeout = null;
@@ -500,13 +494,8 @@ class BleInterface extends events_1.default {
     }
     scan() {
         return __awaiter(this, arguments, void 0, function* (props = {}) {
-            return yield this.legacyScan(props);
-        });
-    }
-    legacyScan() {
-        return __awaiter(this, arguments, void 0, function* (props = {}) {
-            this.resumeLogging();
             this.logEvent({ message: 'starting scan ..' });
+            this.resumeLogging();
             const { timeout, protocol, protocols } = props;
             const requestedProtocols = protocols || [];
             if (protocol && !requestedProtocols.find(p => p === protocol))
@@ -629,8 +618,5 @@ class BleInterface extends events_1.default {
     isScanning() {
         return this.scanState.isScanning === true;
     }
-    getLogger() {
-        return this.logger;
-    }
 }
 exports.default = BleInterface;