incyclist-devices 2.2.10-beta.0 → 2.3.0-beta.10

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

@@ -0,0 +1,35 @@
+import { BleCharacteristic, BlePeripheralAnnouncement, BleRawCharacteristic, BleRawPeripheral, BleService, BleWriteProps, IBlePeripheral } from "../types";
+import { BleInterface } from "./interface";
+export declare class BlePeripheral implements IBlePeripheral {
+    protected announcement: BlePeripheralAnnouncement;
+    protected connected: boolean;
+    protected characteristics: Record<string, BleRawCharacteristic>;
+    protected onDisconnectHandler?: () => void;
+    protected ble: BleInterface;
+    protected subscribed: Array<{
+        uuid: string;
+        callback: (data: Buffer) => void;
+    }>;
+    protected disconnecting: boolean;
+    constructor(announcement: BlePeripheralAnnouncement);
+    get services(): BleService[];
+    protected getPeripheral(): BleRawPeripheral;
+    connect(): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
+    isConnecting(): boolean;
+    onDisconnect(callback: () => void): void;
+    discoverServices(): Promise<string[]>;
+    discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
+    subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    unsubscribe(characteristicUUID: string): Promise<boolean>;
+    subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    discoverAllCharacteristics(): Promise<string[]>;
+    discoverSomeCharacteristics(characteristics: string[]): Promise<string[]>;
+    subscribeAll(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    unsubscribeAll(): Promise<boolean>;
+    read(characteristicUUID: string): Promise<Buffer>;
+    write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
+    protected getRawCharacteristic(uuid: string): BleRawCharacteristic;
+    logEvent(event: any): void;
+}

package/lib/ble/base/peripheral.js

@@ -0,0 +1,311 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlePeripheral = void 0;
+const utils_1 = require("../utils");
+const interface_1 = require("./interface");
+class BlePeripheral {
+    constructor(announcement) {
+        this.announcement = announcement;
+        this.connected = false;
+        this.characteristics = {};
+        this.subscribed = [];
+        this.disconnecting = false;
+        this.ble = interface_1.BleInterface.getInstance();
+    }
+    get services() {
+        return this.announcement.peripheral.services;
+    }
+    getPeripheral() {
+        return this.announcement.peripheral;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected())
+                return true;
+            yield this.getPeripheral().connectAsync();
+            this.ble.registerConnected(this);
+            this.connected = true;
+            return this.connected;
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.disconnecting = true;
+            if (!this.isConnected())
+                return true;
+            yield this.unsubscribeAll();
+            Object.keys(this.characteristics).forEach(uuid => {
+                const c = this.characteristics[uuid];
+                c.removeAllListeners();
+            });
+            if (!this.getPeripheral().disconnectAsync) {
+                this.getPeripheral().disconnectAsync = () => {
+                    return new Promise((done) => { this.getPeripheral().disconnect(() => { done(); }); });
+                };
+            }
+            yield this.getPeripheral().disconnectAsync();
+            this.connected = false;
+            this.disconnecting = false;
+            return !this.connected;
+        });
+    }
+    isConnected() {
+        return this.connected;
+    }
+    isConnecting() {
+        return false;
+    }
+    onDisconnect(callback) {
+        this.onDisconnectHandler = callback;
+    }
+    discoverServices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.getPeripheral().discoverServicesAsync) {
+                this.logEvent({ message: 'discover services' });
+                const services = yield this.getPeripheral().discoverServicesAsync([]);
+                return services.map(s => s.uuid);
+            }
+            else {
+                this.logEvent({ message: 'discover services and characteristics' });
+                const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
+                return res.services.map(s => s.uuid);
+            }
+        });
+    }
+    discoverCharacteristics(serviceUUID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([serviceUUID], []);
+            res.characteristics.forEach(c => this.characteristics[(0, utils_1.beautifyUUID)(c.uuid)] = c);
+            return res.characteristics.map(c => {
+                const { uuid, properties, name, _serviceUuid } = c;
+                return { uuid, properties, name, _serviceUuid };
+            });
+        });
+    }
+    subscribe(characteristicUUID, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.disconnecting || !this.connected)
+                    return false;
+                const onData = (data) => {
+                    try {
+                        callback(characteristicUUID, data);
+                    }
+                    catch (_a) { }
+                };
+                const subscription = this.subscribed.find(s => s.uuid === characteristicUUID);
+                if (subscription) {
+                    const c = this.getRawCharacteristic(characteristicUUID);
+                    if (c)
+                        c.on('data', onData);
+                    return true;
+                }
+                const c = this.getRawCharacteristic(characteristicUUID);
+                if (!c) {
+                    return false;
+                }
+                return new Promise((resolve, reject) => {
+                    const info = this.subscribed.find(s => s.uuid === characteristicUUID);
+                    if (info) {
+                        return Promise.resolve(true);
+                    }
+                    const uuid = (0, utils_1.beautifyUUID)(characteristicUUID);
+                    this.logEvent({ message: 'subscribe request', characteristic: uuid, success: true });
+                    c.subscribe((err) => {
+                        if (err) {
+                            this.logEvent({ message: 'subscribe result', characteristic: uuid, success: false, reason: err.message });
+                            resolve(false);
+                        }
+                        else {
+                            if (callback) {
+                                this.subscribed.push({ uuid: characteristicUUID, callback: onData });
+                                c.on('data', onData);
+                            }
+                            else {
+                                this.subscribed.push({ uuid: characteristicUUID, callback: null });
+                            }
+                            this.logEvent({ message: 'subscribe result', characteristic: uuid, success: true });
+                            resolve(true);
+                        }
+                    });
+                });
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'subscribe', error: err.message, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    unsubscribe(characteristicUUID) {
+        try {
+            const subscription = this.subscribed.find(s => s.uuid === characteristicUUID);
+            if (!subscription) {
+                return Promise.resolve(true);
+            }
+            const c = this.getRawCharacteristic(characteristicUUID);
+            if (!c) {
+                return Promise.resolve(false);
+            }
+            return new Promise((resolve, reject) => {
+                c.unsubscribe((err) => {
+                    if (err) {
+                        resolve(false);
+                    }
+                    else {
+                        const info = this.subscribed.find(s => s.uuid === characteristicUUID);
+                        if (info) {
+                            this.subscribed.splice(this.subscribed.indexOf(info), 1);
+                            if (info.callback)
+                                c.off('data', info.callback);
+                        }
+                        resolve(true);
+                    }
+                });
+            });
+        }
+        catch (err) {
+            this.logEvent({ message: 'Error', fn: 'unsubscribe', error: err.message, stack: err.stack });
+            return Promise.resolve(false);
+        }
+    }
+    subscribeSelected(characteristics, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (Object.keys(this.characteristics).length === 0) {
+                    yield this.discoverAllCharacteristics();
+                }
+                const retry = [];
+                for (let i = 0; i < characteristics.length; i++) {
+                    const c = this.getRawCharacteristic(characteristics[i]);
+                    if (c === null || c === void 0 ? void 0 : c.properties.includes('notify')) {
+                        const success = yield this.subscribe(c.uuid, callback);
+                        if (!success)
+                            retry.push(c);
+                    }
+                }
+                for (let i = 0; i < retry.length; i++) {
+                    const c = retry[i];
+                    yield this.subscribe(c.uuid, callback);
+                }
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'subscribeSelected', error: err.message, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    discoverAllCharacteristics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
+                const found = [];
+                res.characteristics.forEach(c => {
+                    this.characteristics[(0, utils_1.beautifyUUID)(c.uuid)] = c;
+                    found.push(c.uuid);
+                });
+                return found;
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'discoverAllCharacteristics', error: err.message, stack: err.stack });
+                return [];
+            }
+        });
+    }
+    discoverSomeCharacteristics(characteristics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const target = characteristics.map(c => (0, utils_1.fullUUID)(c));
+                const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], target);
+                const found = [];
+                res.characteristics.forEach(c => {
+                    this.characteristics[(0, utils_1.beautifyUUID)(c.uuid)] = c;
+                    found.push(c.uuid);
+                });
+                return found;
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'discoverAllCharacteristics', error: err.message, stack: err.stack });
+                return [];
+            }
+        });
+    }
+    subscribeAll(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const characteristics = yield this.discoverAllCharacteristics();
+            const success = yield this.subscribeSelected(characteristics, callback);
+            return success;
+        });
+    }
+    unsubscribeAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            this.subscribed.forEach(d => {
+                promises.push(this.unsubscribe(d.uuid));
+            });
+            yield Promise.allSettled(promises);
+            return true;
+        });
+    }
+    read(characteristicUUID) {
+        if (this.disconnecting || !this.connected)
+            return Promise.resolve(Buffer.from([]));
+        const c = this.characteristics[(0, utils_1.beautifyUUID)(characteristicUUID)];
+        if (!c) {
+            return Promise.reject(new Error('characteristic not found'));
+        }
+        return new Promise((resolve, reject) => {
+            c.read((err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    write(characteristicUUID, data, options) {
+        if (this.disconnecting || !this.connected)
+            return Promise.resolve(Buffer.from([]));
+        const uuid = (0, utils_1.beautifyUUID)(characteristicUUID);
+        const c = this.characteristics[uuid];
+        if (!c) {
+            return Promise.reject(new Error('characteristic not found'));
+        }
+        return new Promise((resolve, reject) => {
+            this.subscribe(characteristicUUID, null).then(success => {
+                if (this.disconnecting || !this.connected)
+                    return Promise.resolve(Buffer.from([]));
+                c.on('data', (data) => {
+                    c.removeAllListeners('data');
+                    resolve(data);
+                });
+                this.logEvent({ message: 'write request', characteristic: uuid, data: data.toString('hex'), withoutResponse: (options === null || options === void 0 ? void 0 : options.withoutResponse) === true });
+                c.write(data, (options === null || options === void 0 ? void 0 : options.withoutResponse) === true, (err) => {
+                    if (err)
+                        reject(err);
+                });
+                if (options === null || options === void 0 ? void 0 : options.withoutResponse) {
+                    resolve(Buffer.from([]));
+                }
+            });
+        });
+    }
+    getRawCharacteristic(uuid) {
+        return this.characteristics[(0, utils_1.beautifyUUID)(uuid)];
+    }
+    logEvent(event) {
+        this.ble.logEvent(event);
+    }
+}
+exports.BlePeripheral = BlePeripheral;

package/lib/ble/base/sensor.d.ts

@@ -0,0 +1,32 @@
+import { LegacyProfile } from "../../antv2/types";
+import { BleWriteProps, IBlePeripheral, BleProtocol, IBleSensor } from "../types";
+import { EventLogger } from "gd-eventlog";
+import EventEmitter from "events";
+export declare class TBleSensor extends EventEmitter implements IBleSensor {
+    protected peripheral: IBlePeripheral;
+    static readonly protocol: BleProtocol;
+    protected logger: EventLogger;
+    protected stopRequested: boolean;
+    protected onDataHandler: any;
+    logEvent(event: any, ...args: any[]): void;
+    constructor(peripheral: IBlePeripheral, props?: {
+        logger?: EventLogger;
+    });
+    getDetectionPriority(): number;
+    getProfile(): LegacyProfile;
+    getProtocol(): BleProtocol;
+    getServiceUUids(): string[];
+    isMatching(serviceUUIDs: string[]): boolean;
+    hasPeripheral(): boolean;
+    startSensor(reconnect?: boolean): Promise<boolean>;
+    protected getRequiredCharacteristics(): Array<string>;
+    subscribe(): Promise<boolean>;
+    stopSensor(): Promise<boolean>;
+    reconnectSensor(): Promise<void>;
+    reset(): void;
+    isConnected(): boolean;
+    read(characteristicUUID: string): Promise<Buffer>;
+    write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
+    onData(characteristic: string, data: Buffer): boolean;
+    protected getDefaultLogger(): EventLogger;
+}

package/lib/ble/base/sensor.js

@@ -0,0 +1,135 @@
+"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.TBleSensor = void 0;
+const utils_1 = require("../../utils/utils");
+const gd_eventlog_1 = require("gd-eventlog");
+const utils_2 = require("../utils");
+const events_1 = __importDefault(require("events"));
+class TBleSensor extends events_1.default {
+    logEvent(event, ...args) {
+        this.logger.logEvent(event, ...args);
+    }
+    constructor(peripheral, props) {
+        super();
+        this.peripheral = peripheral;
+        this.logger = (props === null || props === void 0 ? void 0 : props.logger) || this.getDefaultLogger();
+        this.reset();
+        this.onDataHandler = this.onData.bind(this);
+    }
+    getDetectionPriority() {
+        var _a;
+        const C = this.constructor;
+        return (_a = C['detectionPriority']) !== null && _a !== void 0 ? _a : 0;
+    }
+    getProfile() {
+        const C = this.constructor;
+        return C['profile'];
+    }
+    getProtocol() {
+        const C = this.constructor;
+        return C['protocol'];
+    }
+    getServiceUUids() {
+        const C = this.constructor;
+        return C['services'];
+    }
+    isMatching(serviceUUIDs) {
+        const uuids = serviceUUIDs.map(uuid => (0, utils_2.beautifyUUID)(uuid));
+        const required = this.getServiceUUids();
+        if (!required)
+            return true;
+        let missing = false;
+        required.forEach(uuid => {
+            if (!uuids.includes((0, utils_2.beautifyUUID)(uuid))) {
+                missing = true;
+            }
+        });
+        return (missing === false);
+    }
+    hasPeripheral() {
+        return !!this.peripheral;
+    }
+    startSensor(reconnect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!reconnect)
+                this.stopRequested = false;
+            if (!this.peripheral) {
+                this.logEvent({ message: 'no peripheral' });
+                return false;
+            }
+            const connected = yield this.peripheral.connect();
+            if (!connected)
+                return false;
+            if (!reconnect)
+                this.peripheral.onDisconnect(this.reconnectSensor.bind(this));
+            return true;
+        });
+    }
+    getRequiredCharacteristics() {
+        return null;
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const selected = this.getRequiredCharacteristics();
+            if (selected === null)
+                return yield this.peripheral.subscribeAll(this.onDataHandler);
+            if (selected.length === 0)
+                return true;
+            return yield this.peripheral.subscribeSelected(selected, this.onDataHandler);
+        });
+    }
+    stopSensor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.removeAllListeners();
+            if (!this.peripheral)
+                return true;
+            this.stopRequested = true;
+            return yield this.peripheral.disconnect();
+        });
+    }
+    reconnectSensor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let success = false;
+            do {
+                success = yield this.startSensor(true);
+                if (!success) {
+                    yield (0, utils_1.sleep)(5000);
+                }
+            } while (!success || this.stopRequested);
+        });
+    }
+    reset() {
+        throw new Error("Method not implemented.");
+    }
+    isConnected() {
+        var _a;
+        return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.isConnected();
+    }
+    read(characteristicUUID) {
+        var _a;
+        return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.read(characteristicUUID);
+    }
+    write(characteristicUUID, data, options) {
+        var _a;
+        return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.write(characteristicUUID, data, options);
+    }
+    onData(characteristic, data) {
+        return true;
+    }
+    getDefaultLogger() {
+        return new gd_eventlog_1.EventLogger(this.constructor.name);
+    }
+}
+exports.TBleSensor = TBleSensor;

package/lib/ble/base/types.d.ts

@@ -1,2 +1,9 @@
+import { IBleInterface } from "../types";
 export interface BleDeviceData {
 }
+export interface IInterfaceFactory {
+    getInterface(): IBleInterface<any>;
+}
+export declare class InterfaceFactory implements IInterfaceFactory {
+    getInterface(): IBleInterface<any>;
+}

package/lib/ble/base/types.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceFactory = void 0;
+class InterfaceFactory {
+    getInterface() {
+        throw new Error('Not implemented');
+    }
+}
+exports.InterfaceFactory = InterfaceFactory;

package/lib/ble/bindings/mock.js

@@ -82,6 +82,12 @@ class MockPeripheral extends events_1.default {
         };
         this.services = p.services;
     }
+    disconnectAsync() {
+        throw new Error('Method not implemented.');
+    }
+    discoverServicesAsync(serviceUUIDs) {
+        throw new Error('Method not implemented.');
+    }
     connectAsync() {
         return __awaiter(this, void 0, void 0, function* () {
         });

package/lib/ble/bindings/types.d.ts

@@ -1,13 +1,12 @@
 import EventEmitter from "events";
-import { BleCharacteristic } from "../types";
-export type Property = 'read' | 'write' | 'notify' | 'indicate';
+import { BleCharacteristic, BleProperty } from "../types";
 export type Descriptor = {
     uuid: string;
     value: string | Buffer;
 };
 export type Characteristic = {
     uuid: string;
-    properties: Property[];
+    properties: BleProperty[];
     secure?: boolean;
     value: Buffer;
     descriptors: Descriptor[];
@@ -19,7 +18,7 @@ export declare const RESULT_INVALID_ATTRIBUTE_LENGTH = 13;
 export declare const RESULT_UNLIKELY_ERROR = 14;
 export declare class MockCharacteristic extends EventEmitter implements BleCharacteristic {
     uuid: string;
-    properties: Property[];
+    properties: BleProperty[];
     secure?: boolean | undefined;
     value: Buffer;
     descriptors: Descriptor[];

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 } from './types';
+import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic, IBleInterface } from './types';
 import { BleComms } from './base/comms';
-import { IncyclistInterface, IncyclistScanProps } from '../types';
+import { 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 IncyclistInterface {
+export default class BleInterface extends EventEmitter implements IBleInterface {
     scanState: ScanState;
     connectState: ConnectState;
     peripheralCache: BlePeripheralCache;
@@ -62,7 +62,8 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     pauseLogging(debugOnly?: boolean): void;
     resumeLogging(): void;
     protected isDebugEnabled(): boolean;
-    protected logEvent(event: any): void;
+    logEvent(event: any): void;
+    logError(err: Error, fn: string, args?: any): void;
     protected onStateChange(state: BleInterfaceState): void;
     protected onError(err: any): void;
     connect(to?: number): Promise<boolean>;
@@ -79,6 +80,8 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     }): 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,6 +118,10 @@ 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', });
@@ -142,10 +146,12 @@ 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' });
+                this.logEvent({ message: 'Ble connect request', timeout });
                 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;
@@ -494,8 +500,13 @@ class BleInterface extends events_1.default {
     }
     scan() {
         return __awaiter(this, arguments, void 0, function* (props = {}) {
-            this.logEvent({ message: 'starting scan ..' });
+            return yield this.legacyScan(props);
+        });
+    }
+    legacyScan() {
+        return __awaiter(this, arguments, void 0, function* (props = {}) {
             this.resumeLogging();
+            this.logEvent({ message: 'starting scan ..' });
             const { timeout, protocol, protocols } = props;
             const requestedProtocols = protocols || [];
             if (protocol && !requestedProtocols.find(p => p === protocol))
@@ -618,5 +629,8 @@ class BleInterface extends events_1.default {
     isScanning() {
         return this.scanState.isScanning === true;
     }
+    getLogger() {
+        return this.logger;
+    }
 }
 exports.default = BleInterface;

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

@@ -18,6 +18,7 @@ export default class BlePeripheralConnector implements IBlePeripheralConnector {
     private emitter;
     constructor(peripheral: BlePeripheral);
     logEvent(event: any): void;
+    logError(err: Error, fn: string, args?: any): void;
     connect(): Promise<void>;
     reconnect(): Promise<void>;
     onDisconnect(): void;