incyclist-devices 2.3.0 → 2.3.1

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

@@ -1,10 +1,12 @@
 import EventEmitter from "events";
 import { DeviceSettings, InterfaceProps } from "../../types";
 import { EventLogger } from "gd-eventlog";
-import { BleBinding, BleInterfaceState, BlePeripheralAnnouncement, BlePeripheralInfo, BleRawPeripheral, BleScanProps, IBlePeripheral } from "../types";
+import { BleBinding, BleDeviceSettings, BleInterfaceState, BlePeripheralAnnouncement, BleRawPeripheral, BleScanProps, IBlePeripheral } from "../types";
 import { IBleInterface } from '../../ble/types';
 import { InteruptableTask, TaskState } from "../../utils/task";
 import { InterfaceFactory } from "./types";
+import { BleAdapterFactory } from "../factories";
+import { TBleSensor } from "./sensor";
 interface Announcement {
     service: BlePeripheralAnnouncement;
     ts: number;
@@ -27,11 +29,13 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected connectTask: InteruptableTask<TaskState, boolean>;
     protected scanTask: InteruptableTask<TaskState, void>;
     protected discoverTask: InteruptableTask<TaskState, void>;
-    protected onDiscovered: (peripheral: BlePeripheralInfo) => void;
+    protected onDiscovered: (peripheral: BleRawPeripheral) => void;
     protected instanceId: number;
     protected connectedPeripherals: IBlePeripheral[];
+    protected connectAttemptCnt: number;
     static getInstance(props?: InterfaceProps): BleInterface;
     protected constructor(props: InterfaceProps);
+    setProps(props: InterfaceProps): void;
     getLogger(): EventLogger;
     setLogger(logger: EventLogger): void;
     getName(): string;
@@ -39,7 +43,7 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     getBinding(): BleBinding;
     protected autoConnect(): void;
     connect(reconnect?: boolean): Promise<boolean>;
-    disconnect(): Promise<boolean>;
+    disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;
     registerConnected(peripheral: IBlePeripheral): void;
     protected isConnecting(): boolean;
@@ -52,15 +56,17 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     createPeripheral(announcement: BlePeripheralAnnouncement): IBlePeripheral;
     createPeripheralFromSettings(settings: DeviceSettings): IBlePeripheral;
     waitForPeripheral(settings: DeviceSettings): Promise<IBlePeripheral>;
-    createDeviceSetting(service: BlePeripheralAnnouncement): DeviceSettings;
+    createDeviceSetting(service: BlePeripheralAnnouncement): BleDeviceSettings;
     protected reconnect(): Promise<void>;
     protected startPeripheralScan(retry?: boolean): Promise<void>;
     protected stopPeripheralScan(): Promise<void>;
+    protected emitDisconnectAllPeripherals(): void;
+    protected disconnectAllPeripherals(): Promise<void>;
     protected isDiscovering(): boolean;
     protected discoverPeripherals(): Promise<void>;
-    pauseDiscovery(): Promise<void>;
-    resumeDiscovery(): Promise<void>;
     protected onPeripheralFound(peripheral: BleRawPeripheral): void;
+    protected checkForWahooEnhancement(announcement: BlePeripheralAnnouncement): boolean;
+    protected processWahooAnnouncement(announcement: BlePeripheralAnnouncement): void;
     protected buildAnnouncement(peripheral: BleRawPeripheral): BlePeripheralAnnouncement;
     protected updateWithServices(announcement: BlePeripheralAnnouncement): Promise<BlePeripheralAnnouncement>;
     protected discoverServices(announcement: BlePeripheralAnnouncement): Promise<string[]>;
@@ -68,10 +74,7 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected startScan(): Promise<unknown>;
     private emitCachedDevices;
     protected emitDevice(service: BlePeripheralAnnouncement): void;
-    protected buildDeviceSettings(matching?: string[]): {
-        interface: string;
-        name: string;
-    }[];
+    protected buildDeviceSettings(matching?: string[]): BleDeviceSettings[];
     protected addCompleting(service: BlePeripheralAnnouncement): void;
     protected addUnsupported(service: BlePeripheralAnnouncement): void;
     protected isKnownUnsupported(service: BlePeripheralAnnouncement): boolean;
@@ -84,7 +87,13 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     setDebug(enabled: boolean): void;
     protected connectBle(): Promise<boolean>;
     protected waitForBleConnected(): Promise<boolean>;
+    protected onError(err: Error): void;
+    protected onConnected(): void;
+    protected onDisconnected(): Promise<void>;
     protected onBleStateChange(state: BleInterfaceState): void;
+    protected getAdapterFactory(): BleAdapterFactory<TBleSensor>;
+    protected getConnectTimeout(): number;
+    protected getExpectedServices(): string[];
     logEvent(event: any): void;
     logError(err: Error, fn: string, args?: any): void;
 }

package/lib/ble/base/interface.js

@@ -20,7 +20,6 @@ const peripheral_1 = require("./peripheral");
 const utils_1 = require("../utils");
 const types_1 = require("./types");
 const factories_1 = require("../factories");
-const BLE_DEFAULT_SCAN_TIMEOUT = 30 * 1000;
 const BLE_EXPIRATION_TIMEOUT = 10 * 1000 * 60;
 const BLE_DEFAULT_CONNECT_TIMEOUT = 30 * 1000;
 let instanceCount = 0;
@@ -29,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);
             }
@@ -50,6 +50,7 @@ class BleInterface extends events_1.default {
         this.expectedServices = ['180d', '1818', '1826', '6e40fec1'];
         this.matching = [];
         this.connectedPeripherals = [];
+        this.connectAttemptCnt = 0;
         this.instanceId = ++instanceCount;
         this.props = props;
         this.logEnabled = props.log || true;
@@ -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,7 +78,11 @@ class BleInterface extends events_1.default {
         return BleInterface.INTERFACE_NAME;
     }
     setBinding(binding) {
+        const prev = this.binding;
         this.binding = binding;
+        if (!prev && !this.isConnected() && this.props.enabled) {
+            this.autoConnect();
+        }
     }
     getBinding() {
         return this.binding;
@@ -88,46 +97,54 @@ class BleInterface extends events_1.default {
                 return false;
             }
             if (this.isConnecting()) {
-                this.logEvent({ message: 'connect - already connecting' });
+                this.logEvent({ message: 'BLE connect - already connecting' });
                 return this.connectTask.getPromise();
             }
             if (this.isConnected())
                 return true;
-            this.logEvent({ message: 'Ble connect request' });
+            this.logEvent({ message: 'BLE connect request' });
             this.connectTask = new task_1.InteruptableTask(this.connectBle(), {
-                timeout: BLE_DEFAULT_CONNECT_TIMEOUT,
-                name: 'connect',
+                timeout: this.getConnectTimeout(),
+                name: 'BLE connect',
                 errorOnTimeout: false,
                 log: this.logEvent.bind(this),
             });
-            const success = yield this.connectTask.run();
+            const success = yield this.connectTask.run().catch(() => false);
             if (success) {
                 this.startPeripheralScan();
             }
-            this.expectedServices = factories_1.BleAdapterFactory.getInstance('ble').getAllSupportedServices();
             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 = [];
-            yield this.connectTask.stop();
+            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;
         });
     }
     isConnected() {
         var _a;
-        return ((_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.state) === 'poweredOn';
+        return this.connectAttemptCnt > 0 && ((_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.state) === 'poweredOn';
     }
     registerConnected(peripheral) {
         this.connectedPeripherals.push(peripheral);
@@ -145,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',
@@ -162,10 +179,13 @@ class BleInterface extends events_1.default {
         });
     }
     stopScan() {
-        if (!this.isScanning())
-            return Promise.resolve(true);
-        this.logEvent({ message: 'stopping scan ...' });
-        this.scanTask.stop();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isScanning())
+                return true;
+            this.logEvent({ message: 'stopping scan ...', interface: 'ble' });
+            const res = yield this.scanTask.stop();
+            return (res === true);
+        });
     }
     onScanDone() {
         this.logEvent({ message: 'scan stopped' });
@@ -173,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;
@@ -195,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);
                     }
                 }
@@ -208,8 +237,12 @@ class BleInterface extends events_1.default {
         });
     }
     createDeviceSetting(service) {
-        const name = service.name;
-        return { interface: BleInterface.INTERFACE_NAME, name };
+        const { peripheral } = service;
+        if (peripheral.address === undefined || peripheral.address === '')
+            peripheral.address = peripheral.id || peripheral.name;
+        const protocol = this.getAdapterFactory().getProtocol(service.serviceUUIDs);
+        const { id, name, address } = (0, utils_1.getPeripheralInfo)(peripheral);
+        return { interface: BleInterface.INTERFACE_NAME, protocol, id, name, address };
     }
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -219,6 +252,7 @@ class BleInterface extends events_1.default {
     }
     startPeripheralScan() {
         return __awaiter(this, arguments, void 0, function* (retry = false) {
+            this.expectedServices = this.getExpectedServices();
             if (!retry)
                 this.logEvent({ message: 'starting peripheral discovery ...' });
             if (!this.isConnected() || this.isDiscovering()) {
@@ -245,13 +279,28 @@ class BleInterface extends events_1.default {
             return;
         this.logEvent({ message: 'stopping peripheral discovery ...' });
         this.discoverTask.stop();
-        this.getBinding().off('discover', this.onDiscovered);
+        const ble = this.getBinding();
+        ble.off('discover', this.onDiscovered);
         return new Promise(done => {
-            this.getBinding().stopScanning(() => {
+            ble.stopScanning(() => {
                 done();
             });
         });
     }
+    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;
@@ -275,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;
@@ -303,24 +337,33 @@ class BleInterface extends events_1.default {
             return;
         }
         if (announcement.serviceUUIDs.length === 0) {
-            if (this.isCompleting(announcement)) {
-                return;
-            }
-            this.addCompleting(announcement);
-            setTimeout(() => {
-                if (this.find(announcement)) {
-                    this.removeCompleting(announcement);
-                    return;
-                }
-                this.updateWithServices(announcement)
-                    .then(() => {
-                    if (this.isSupportedPeripheral(announcement))
-                        this.addService(announcement);
-                });
-            }, 1000);
+            return;
+        }
+        const isWahoo = this.checkForWahooEnhancement(announcement);
+        if (isWahoo) {
+            this.processWahooAnnouncement(announcement);
+            return;
         }
         this.addService(announcement);
     }
+    checkForWahooEnhancement(announcement) {
+        if (announcement.name.includes('KICKR')) {
+            const supported = announcement.serviceUUIDs.map(s => (0, utils_1.beautifyUUID)(s));
+            if (supported.length === 1 && supported[0] === '1818')
+                return true;
+        }
+        return false;
+    }
+    processWahooAnnouncement(announcement) {
+        if (this.isCompleting(announcement)) {
+            return;
+        }
+        this.updateWithServices(announcement)
+            .then(() => {
+            if (this.isSupportedPeripheral(announcement))
+                this.addService(announcement);
+        });
+    }
     buildAnnouncement(peripheral) {
         var _a;
         return {
@@ -335,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');
@@ -350,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) {
@@ -369,15 +412,12 @@ class BleInterface extends events_1.default {
                     const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
                     announcement.serviceUUIDs = res.services.map(s => s.uuid);
                 }
-                peripheral.removeAllListeners();
             }
             catch (err) {
                 this.logEvent({ message: 'discover services failed', reason: err.message, device });
             }
-            if (paused) {
-                yield this.resumeDiscovery();
-            }
-            return device.serviceUUIDs;
+            peripheral === null || peripheral === void 0 ? void 0 : peripheral.removeAllListeners();
+            return announcement.serviceUUIDs;
         });
     }
     isScanning() {
@@ -399,10 +439,14 @@ class BleInterface extends events_1.default {
     }
     emitDevice(service) {
         const settings = this.createDeviceSetting(service);
+        this.logEvent({ message: 'device found', settings });
         this.emit('device', settings, service);
     }
     buildDeviceSettings(matching = []) {
-        return matching.map((name) => ({ interface: BleInterface.INTERFACE_NAME, name }));
+        return matching.map((name) => {
+            const announcement = this.services.find(s => s.service.name === name);
+            return this.createDeviceSetting(announcement.service);
+        });
     }
     addCompleting(service) {
         const existing = this.incompleteServices.find(s => s.name === service.name);
@@ -468,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;
@@ -484,8 +528,10 @@ class BleInterface extends events_1.default {
     }
     connectBle() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.connectAttemptCnt++;
             const state = this.getBinding().state;
             if (state === 'poweredOn') {
+                this.logEvent({ message: 'BLE connected' });
                 return true;
             }
             const res = yield this.waitForBleConnected();
@@ -500,10 +546,7 @@ class BleInterface extends events_1.default {
             });
             this.getBinding().on('stateChange', (state) => {
                 if (state === 'poweredOn') {
-                    this.logEvent({ message: 'Ble connect result: success' });
-                    this.getBinding().removeAllListeners('stateChange');
-                    this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
-                    this.getBinding().on('error', console.log);
+                    this.onConnected();
                     return done(true);
                 }
                 else {
@@ -512,18 +555,50 @@ 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');
+    }
+    getConnectTimeout() {
+        return BLE_DEFAULT_CONNECT_TIMEOUT;
+    }
+    getExpectedServices() {
+        return this.getAdapterFactory().getAllSupportedServices();
     }
     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;