incyclist-devices 2.3.0-beta.9 → 2.3.1

package/lib/ble/base/interface.js

@@ -28,6 +28,7 @@ class BleInterface extends events_1.default {
         if (BleInterface._instance === undefined)
             BleInterface._instance = new BleInterface(props);
         else {
+            BleInterface._instance.setProps(props);
             if (props.binding) {
                 BleInterface._instance.setBinding(props.binding);
             }
@@ -60,9 +61,13 @@ class BleInterface extends events_1.default {
         }
         this.internalEvents = new events_1.default();
         this.onDiscovered = this.onPeripheralFound.bind(this);
-        if (this.binding)
+        const { enabled = true } = props;
+        if (this.binding && enabled)
             this.autoConnect();
     }
+    setProps(props) {
+        this.props = props;
+    }
     getLogger() {
         return this.logger;
     }
@@ -73,8 +78,9 @@ class BleInterface extends events_1.default {
         return BleInterface.INTERFACE_NAME;
     }
     setBinding(binding) {
+        const prev = this.binding;
         this.binding = binding;
-        if (!this.isConnected()) {
+        if (!prev && !this.isConnected() && this.props.enabled) {
             this.autoConnect();
         }
     }
@@ -110,23 +116,29 @@ class BleInterface extends events_1.default {
             return success;
         });
     }
-    disconnect() {
+    disconnect(connectionLost) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (!this.getBinding()) {
                 return false;
             }
-            if (!this.isConnected())
+            if (!this.isConnected() && !connectionLost)
                 return true;
-            this.logEvent({ message: 'disconnect request' });
+            if (!connectionLost)
+                this.logEvent({ message: 'disconnect request' });
+            this.emit('disconnect-request');
             yield this.stopPeripheralScan();
-            const promises = this.connectedPeripherals.map(p => p.disconnect());
-            yield Promise.allSettled(promises);
-            this.connectedPeripherals = [];
+            if (connectionLost) {
+                this.emitDisconnectAllPeripherals();
+            }
+            else {
+                yield this.disconnectAllPeripherals();
+            }
             if (this.isConnecting())
                 yield ((_a = this.connectTask) === null || _a === void 0 ? void 0 : _a.stop());
             this.getBinding().removeAllListeners();
             this.connectAttemptCnt = 0;
+            this.emit('disconnect-done');
             return true;
         });
     }
@@ -150,7 +162,7 @@ class BleInterface extends events_1.default {
                     .then(() => { return this.onScanDone(); })
                     .catch(() => []);
             }
-            this.logEvent({ message: 'starting scan ..' });
+            this.logEvent({ message: 'starting scan ..', interface: 'ble' });
             this.scanTask = new task_1.InteruptableTask(this.startScan(), {
                 timeout: props.timeout,
                 name: 'scan',
@@ -181,10 +193,14 @@ class BleInterface extends events_1.default {
         return this.buildDeviceSettings(this.matching);
     }
     pauseLogging() {
+        this.logEvent({ message: 'pausing logging' });
         this.logDisabled = true;
+        this.getBinding().pauseLogging();
     }
     resumeLogging() {
+        this.getBinding().resumeLogging();
         this.logDisabled = false;
+        this.logEvent({ message: 'resuming logging' });
     }
     isLoggingPaused() {
         return this.logDisabled;
@@ -203,11 +219,16 @@ class BleInterface extends events_1.default {
         if (peripheral)
             return Promise.resolve(peripheral);
         return new Promise((done) => {
+            const wasDiscovering = this.isDiscovering();
+            if (!wasDiscovering)
+                this.startPeripheralScan();
             const onDevice = (device) => {
                 if (device.name === settings.name) {
                     const peripheral = this.createPeripheralFromSettings(settings);
                     if (peripheral) {
                         this.off('device', onDevice);
+                        if (!wasDiscovering)
+                            this.stopPeripheralScan();
                         done(peripheral);
                     }
                 }
@@ -266,6 +287,20 @@ class BleInterface extends events_1.default {
             });
         });
     }
+    emitDisconnectAllPeripherals() {
+        this.connectedPeripherals.forEach(p => {
+            const peripheral = p.getPeripheral();
+            peripheral.emit('disconnect');
+        });
+        this.connectedPeripherals = [];
+    }
+    disconnectAllPeripherals() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = this.connectedPeripherals.map(p => p.disconnect());
+            yield Promise.allSettled(promises);
+            this.connectedPeripherals = [];
+        });
+    }
     isDiscovering() {
         var _a;
         return ((_a = this.discoverTask) === null || _a === void 0 ? void 0 : _a.isRunning()) === true;
@@ -289,21 +324,6 @@ class BleInterface extends events_1.default {
             });
         });
     }
-    pauseDiscovery() {
-        this.getBinding().off('discover', this.onDiscovered);
-        return new Promise(done => {
-            try {
-                this.getBinding().stopScanning();
-                done();
-            }
-            catch (err) {
-                done();
-            }
-        });
-    }
-    resumeDiscovery() {
-        return this.discoverPeripherals();
-    }
     onPeripheralFound(peripheral) {
         if (!this.isConnected() || !this.isDiscovering())
             return;
@@ -358,9 +378,10 @@ class BleInterface extends events_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isConnected() || !this.isDiscovering())
                 return;
+            this.addCompleting(announcement);
+            this.logEvent({ message: 'updateWithServices', peripheral: announcement.name });
             try {
-                yield this.discoverServices(announcement);
-                return announcement;
+                announcement.serviceUUIDs = yield this.discoverServices(announcement);
             }
             catch (err) {
                 this.logError(err, 'updateWithServices');
@@ -373,15 +394,14 @@ class BleInterface extends events_1.default {
             const device = Object.assign({}, announcement);
             delete device.peripheral;
             const { peripheral } = announcement;
-            let paused = false;
             try {
                 peripheral.on('error', (err) => {
                     peripheral.removeAllListeners();
-                    this.logEvent({ message: 'Device error', error: err.message });
+                    this.logEvent({ message: 'peripheral error', error: err.message });
                 });
                 peripheral.on('disconnect', () => {
                     peripheral.removeAllListeners();
-                    this.logEvent({ message: 'Device disconnected' });
+                    this.logEvent({ message: 'peripheral disconnected' });
                 });
                 yield peripheral.connectAsync();
                 if (peripheral.discoverServicesAsync !== undefined) {
@@ -397,10 +417,7 @@ class BleInterface extends events_1.default {
                 this.logEvent({ message: 'discover services failed', reason: err.message, device });
             }
             peripheral === null || peripheral === void 0 ? void 0 : peripheral.removeAllListeners();
-            if (paused) {
-                yield this.resumeDiscovery();
-            }
-            return device.serviceUUIDs;
+            return announcement.serviceUUIDs;
         });
     }
     isScanning() {
@@ -495,7 +512,7 @@ class BleInterface extends events_1.default {
         const expected = this.expectedServices.map(utils_1.parseUUID);
         const supported = (_b = found.filter(uuid => expected.includes(uuid))) !== null && _b !== void 0 ? _b : [];
         if (!supported.length) {
-            this.logEvent({ message: 'service not supported', name: service.name, uuids: service.serviceUUIDs });
+            this.logEvent({ message: 'peripheral not supported', name: service.name, uuids: service.serviceUUIDs });
             this.addUnsupported(service);
         }
         return supported.length > 0;
@@ -529,10 +546,7 @@ class BleInterface extends events_1.default {
             });
             this.getBinding().on('stateChange', (state) => {
                 if (state === 'poweredOn') {
-                    this.logEvent({ message: 'BLE connected' });
-                    this.getBinding().removeAllListeners('stateChange');
-                    this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
-                    this.getBinding().on('error', console.log);
+                    this.onConnected();
                     return done(true);
                 }
                 else {
@@ -541,7 +555,30 @@ class BleInterface extends events_1.default {
             });
         });
     }
+    onError(err) {
+        this.logError(err, 'BLE connect');
+    }
+    onConnected() {
+        this.logEvent({ message: 'BLE connected' });
+        this.getBinding().removeAllListeners('error');
+        this.getBinding().removeAllListeners('stateChange');
+        this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
+        this.getBinding().on('error', this.onError.bind(this));
+    }
+    onDisconnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'BLE Disconnected' });
+            yield this.disconnect(true);
+            this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
+            this.getBinding().on('error', this.onError.bind(this));
+        });
+    }
     onBleStateChange(state) {
+        if (state !== 'poweredOn') {
+            this.onDisconnected();
+        }
+        else
+            this.onConnected();
     }
     getAdapterFactory() {
         return factories_1.BleAdapterFactory.getInstance('ble');
@@ -555,13 +592,13 @@ class BleInterface extends events_1.default {
     logEvent(event) {
         if (this.logDisabled && event.message !== 'Error')
             return;
-        this.getLogger().logEvent(event);
+        this.getLogger().logEvent(Object.assign(Object.assign({}, event), { interface: 'ble' }));
         const emitPayload = Object.assign({}, event);
         delete emitPayload.ts;
         this.emit('log', emitPayload);
         const w = global.window;
         if (this.debug || (w === null || w === void 0 ? void 0 : w.SERVICE_DEBUG) || process.env.DEBUG)
-            console.log(`~~~ ${this.logger.getName().toUpperCase()}-SVC`, event);
+            console.log(`~~~ ${this.logger.getName().toUpperCase()}-SVC`, Object.assign(Object.assign({}, event), { interface: 'ble' }));
     }
     logError(err, fn, args) {
         const logInfo = args || {};

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

@@ -11,22 +11,26 @@ export declare class BlePeripheral implements IBlePeripheral {
         callback: (data: Buffer) => void;
     }>;
     protected disconnecting: boolean;
+    protected onErrorHandler: any;
     constructor(announcement: BlePeripheralAnnouncement);
     get services(): BleService[];
-    protected getPeripheral(): BleRawPeripheral;
+    getPeripheral(): BleRawPeripheral;
     connect(): Promise<boolean>;
-    disconnect(): Promise<boolean>;
+    disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;
     isConnecting(): boolean;
     onDisconnect(callback: () => void): void;
+    protected onPeripheralDisconnect(): Promise<void>;
+    protected onPeripheralError(err: Error): 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>;
+    unsubscribeAll(connectionLost?: boolean): Promise<void>;
     read(characteristicUUID: string): Promise<Buffer>;
     write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
     protected getRawCharacteristic(uuid: string): BleRawCharacteristic;

package/lib/ble/base/peripheral.js

@@ -19,6 +19,7 @@ class BlePeripheral {
         this.characteristics = {};
         this.subscribed = [];
         this.disconnecting = false;
+        this.onErrorHandler = this.onPeripheralError.bind(this);
         this.ble = interface_1.BleInterface.getInstance();
     }
     get services() {
@@ -29,31 +30,42 @@ class BlePeripheral {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.getPeripheral().connectAsync();
+            if (this.isConnected())
+                return true;
+            const peripheral = this.getPeripheral();
+            yield peripheral.connectAsync();
             this.ble.registerConnected(this);
+            peripheral.once('disconnect', () => { this.onPeripheralDisconnect(); });
+            peripheral.on('error', this.onErrorHandler);
             this.connected = true;
-            return true;
+            return this.connected;
         });
     }
     disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
             this.disconnecting = true;
             if (!this.isConnected())
                 return true;
-            yield this.unsubscribeAll();
+            yield this.unsubscribeAll(connectionLost);
             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(); }); });
-                };
+            const peripheral = this.getPeripheral();
+            if (peripheral) {
+                if (!connectionLost) {
+                    if (!peripheral.disconnectAsync) {
+                        peripheral.disconnectAsync = () => {
+                            return new Promise((done) => { this.getPeripheral().disconnect(() => { done(); }); });
+                        };
+                    }
+                    yield this.getPeripheral().disconnectAsync();
+                }
+                peripheral.removeAllListeners();
             }
-            yield this.getPeripheral().disconnectAsync();
             this.connected = false;
             this.disconnecting = false;
-            return true;
+            return !this.connected;
         });
     }
     isConnected() {
@@ -65,13 +77,29 @@ class BlePeripheral {
     onDisconnect(callback) {
         this.onDisconnectHandler = callback;
     }
+    onPeripheralDisconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'disconnect' });
+            try {
+                yield this.disconnect(true);
+            }
+            catch (_a) { }
+            if (this.onDisconnectHandler)
+                this.onDisconnectHandler();
+        });
+    }
+    onPeripheralError(err) {
+        this.logEvent({ message: 'peripheral error', error: err.message });
+    }
     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);
             }
@@ -92,8 +120,17 @@ class BlePeripheral {
             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);
@@ -114,12 +151,6 @@ class BlePeripheral {
                         }
                         else {
                             if (callback) {
-                                const onData = (data) => {
-                                    try {
-                                        callback(characteristicUUID, data);
-                                    }
-                                    catch (_a) { }
-                                };
                                 this.subscribed.push({ uuid: characteristicUUID, callback: onData });
                                 c.on('data', onData);
                             }
@@ -177,16 +208,16 @@ class BlePeripheral {
                     yield this.discoverAllCharacteristics();
                 }
                 const retry = [];
-                for (let i = 0; i < characteristics.length; i++) {
-                    const c = this.getRawCharacteristic(characteristics[i]);
+                for (const element of characteristics) {
+                    const c = this.getRawCharacteristic(element);
                     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];
+                for (const element of retry) {
+                    const c = element;
                     yield this.subscribe(c.uuid, callback);
                 }
                 return true;
@@ -214,6 +245,24 @@ class BlePeripheral {
             }
         });
     }
+    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();
@@ -222,13 +271,16 @@ class BlePeripheral {
         });
     }
     unsubscribeAll() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
+            if (connectionLost) {
+                this.subscribed = [];
+                return;
+            }
             const promises = [];
             this.subscribed.forEach(d => {
                 promises.push(this.unsubscribe(d.uuid));
             });
             yield Promise.allSettled(promises);
-            return true;
         });
     }
     read(characteristicUUID) {
@@ -280,6 +332,8 @@ class BlePeripheral {
         return this.characteristics[(0, utils_1.beautifyUUID)(uuid)];
     }
     logEvent(event) {
+        var _a;
+        event.peripheral = (_a = this.announcement) === null || _a === void 0 ? void 0 : _a.name;
         this.ble.logEvent(event);
     }
 }

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

@@ -20,7 +20,7 @@ export declare class TBleSensor extends EventEmitter implements IBleSensor {
     hasPeripheral(): boolean;
     startSensor(reconnect?: boolean): Promise<boolean>;
     protected getRequiredCharacteristics(): Array<string>;
-    protected subscribe(): Promise<boolean>;
+    subscribe(): Promise<boolean>;
     stopSensor(): Promise<boolean>;
     reconnectSensor(): Promise<void>;
     reset(): void;

package/lib/ble/base/sensor.js

@@ -74,7 +74,7 @@ class TBleSensor extends events_1.default {
                 return false;
             if (!reconnect)
                 this.peripheral.onDisconnect(this.reconnectSensor.bind(this));
-            return yield this.subscribe();
+            return true;
         });
     }
     getRequiredCharacteristics() {
@@ -101,11 +101,19 @@ class TBleSensor extends events_1.default {
     }
     reconnectSensor() {
         return __awaiter(this, void 0, void 0, function* () {
+            let connected = false;
+            let subscribed = false;
             let success = false;
             do {
-                success = yield this.startSensor(true);
+                if (!connected) {
+                    connected = yield this.startSensor(true);
+                }
+                if (connected && !subscribed) {
+                    subscribed = yield this.subscribe();
+                }
+                success = connected && subscribed;
                 if (!success) {
-                    yield (0, utils_1.sleep)(5000);
+                    yield (0, utils_1.sleep)(1000);
                 }
             } while (!success || this.stopRequested);
         });
@@ -119,10 +127,16 @@ class TBleSensor extends events_1.default {
     }
     read(characteristicUUID) {
         var _a;
+        if (!this.isConnected()) {
+            return Promise.reject(new Error('not connected'));
+        }
         return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.read(characteristicUUID);
     }
     write(characteristicUUID, data, options) {
         var _a;
+        if (!this.isConnected()) {
+            return Promise.reject(new Error('not connected'));
+        }
         return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.write(characteristicUUID, data, options);
     }
     onData(characteristic, data) {

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;

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

@@ -18,7 +18,6 @@ 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;

package/lib/ble/ble-peripheral.js

@@ -12,12 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const ble_interface_1 = __importDefault(require("./ble-interface"));
+const gd_eventlog_1 = require("gd-eventlog");
 const events_1 = __importDefault(require("events"));
 const utils_1 = require("./utils");
-const interface_1 = require("./base/interface");
 class BlePeripheralConnector {
     constructor(peripheral) {
-        this.ble = interface_1.BleInterface.getInstance();
+        this.ble = ble_interface_1.default.getInstance();
         this.peripheral = peripheral;
         this.emitter = new events_1.default();
         if (!this.peripheral || !this.ble)
@@ -25,13 +26,16 @@ class BlePeripheralConnector {
         this.state = { subscribed: [], isConnected: false, isConnecting: false, isInitialized: false, isInitializing: false, isSubscribing: false };
         this.services = [];
         this.characteristics = [];
-        this.logger = this.ble.getLogger();
+        this.logger = new gd_eventlog_1.EventLogger('BLE');
     }
     logEvent(event) {
-        this.ble.logEvent(event);
-    }
-    logError(err, fn, args) {
-        this.ble.logError(err, fn, args);
+        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);
+        }
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {