incyclist-devices 2.3.0-beta.1 → 2.3.0-beta.10

package/lib/base/adpater.d.ts

@@ -11,6 +11,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     started: boolean;
     stopped: boolean;
     paused: boolean;
+    scanning: boolean;
     protected props: P;
     protected cyclingMode: ICyclingMode;
     protected logger: EventLogger;
@@ -37,6 +38,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     resume(): Promise<boolean>;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
+    resetData(): void;
     getControllerInfo(): ControllerConfig | undefined;
     isControllable(): boolean;
     getCapabilities(): IncyclistCapability[];
@@ -65,5 +67,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     getStartProps(startProps?: P): P;
     hasDataListeners(): boolean | OnDeviceDataCallback;
     onData(callback: OnDeviceDataCallback): void;
+    onScanStart(): void;
+    onScanStop(): void;
 }
 export type IncyclistDeviceAdapter = IncyclistDevice<DeviceProperties>;

package/lib/base/adpater.js

@@ -26,6 +26,7 @@ class IncyclistDevice extends events_1.default {
         this.started = false;
         this.stopped = false;
         this.paused = false;
+        this.scanning = false;
         this.user = {};
         this.data = {};
         this.cyclingMode = this.getDefaultCyclingMode();
@@ -100,6 +101,9 @@ class IncyclistDevice extends events_1.default {
     }
     connect() { throw new Error('not implemented'); }
     close() { throw new Error('not implemented'); }
+    resetData() {
+        delete this.lastUpdate;
+    }
     getControllerInfo() {
         const a = this.constructor;
         const config = a.controllers;
@@ -223,11 +227,15 @@ class IncyclistDevice extends events_1.default {
         const updateFrequency = this.getMaxUpdateFrequency();
         if (updateFrequency === -1 || updateFrequency === undefined)
             return true;
-        return (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+        const ok = (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+        return ok;
     }
     canEmitData() {
-        if (this.paused || this.stopped)
+        if (this.scanning)
+            return this.isUpdateWithinFrequency();
+        if (this.paused || this.stopped) {
             return false;
+        }
         return this.isUpdateWithinFrequency();
     }
     emitData(data) {
@@ -261,6 +269,12 @@ class IncyclistDevice extends events_1.default {
     onData(callback) {
         this.onDataFn = callback;
     }
+    onScanStart() {
+        this.scanning = true;
+    }
+    onScanStop() {
+        this.scanning = false;
+    }
 }
 IncyclistDevice.controllers = {};
 exports.default = IncyclistDevice;

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

@@ -1,5 +1,5 @@
 import IncyclistDevice from "../../base/adpater";
-import { BleDeviceProperties, BleDeviceSettings, BleStartProperties, IBlePeripheral } from "../types";
+import { BleDeviceProperties, BleDeviceSettings, BleStartProperties, IBleInterface, IBlePeripheral } from "../types";
 import { IAdapter, IncyclistBikeData, IncyclistAdapterData, DeviceProperties } from "../../types";
 import { BleDeviceData } from "./types";
 import { LegacyProfile } from "../../antv2/types";
@@ -48,9 +48,12 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     protected initControl(_props?: BleStartProperties): Promise<void>;
     protected startAdapter(startProps?: BleStartProperties): Promise<boolean>;
     startSensor(): Promise<boolean>;
+    protected onDisconnectDone(): Promise<void>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
+    protected getBle(): IBleInterface<any>;
     update(): void;
     setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
+    onScanStart(): void;
 }

package/lib/ble/base/adapter.js

@@ -38,20 +38,20 @@ class BleAdapter extends adpater_1.default {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-            return yield iface.connect();
+            const ble = this.getBle();
+            return yield ble.connect();
         });
     }
     getPeripheral() {
-        const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-        const p = iface === null || iface === void 0 ? void 0 : iface.createPeripheralFromSettings(this.settings);
+        const ble = this.getBle();
+        const p = ble === null || ble === void 0 ? void 0 : ble.createPeripheralFromSettings(this.settings);
         return p;
     }
     waitForPeripheral() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'waiting for sensor ...' });
-            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-            const peripheral = yield iface.waitForPeripheral(this.settings);
+            this.logEvent({ message: 'waiting for sensor ...', device: this.getName(), interface: this.getInterface() });
+            const ble = this.getBle();
+            const peripheral = yield ble.waitForPeripheral(this.settings);
             this.updateSensor(peripheral);
         });
     }
@@ -87,6 +87,7 @@ class BleAdapter extends adpater_1.default {
         return (_a = this.device) === null || _a === void 0 ? void 0 : _a.isConnected();
     }
     resetData() {
+        super.resetData();
         this.dataMsgCount = 0;
         this.deviceData = {};
         this.data = {};
@@ -121,7 +122,7 @@ class BleAdapter extends adpater_1.default {
         if (this.isStopped() || this.isPaused())
             return;
         try {
-            this.logEvent({ message: 'refreshDeviceData', data: this.deviceData, isControllable: this.isControllable() });
+            this.logEvent({ message: 'refreshDeviceData', device: this.getName(), interface: this.getInterface(), data: this.deviceData, isControllable: this.isControllable() });
             if (this.isControllable()) {
                 const mappedData = this.mapData(this.deviceData);
                 const incyclistData = this.getCyclingMode().updateData(mappedData);
@@ -133,7 +134,7 @@ class BleAdapter extends adpater_1.default {
             this.emitData(this.data);
         }
         catch (err) {
-            this.logEvent({ message: 'error', fn: 'refreshDeviceData', error: err.message, stack: err.stack });
+            this.logEvent({ message: 'error', fn: 'refreshDeviceData', device: this.getName(), interface: this.getInterface(), error: err.message, stack: err.stack });
         }
     }
     onDeviceData(deviceData) {
@@ -141,9 +142,10 @@ class BleAdapter extends adpater_1.default {
             this.dataMsgCount++;
             this.lastDataTS = Date.now();
             this.deviceData = Object.assign({}, deviceData);
-            if (!this.canEmitData())
+            if (!this.canEmitData()) {
                 return;
-            this.logEvent({ message: 'onDeviceData', data: deviceData, isControllable: this.isControllable() });
+            }
+            this.logEvent({ message: 'onDeviceData', device: this.getName(), interface: this.getInterface(), data: deviceData, isControllable: this.isControllable() });
             if (this.isControllable()) {
                 const mappedData = this.mapData(deviceData);
                 const incyclistData = this.getCyclingMode().updateData(mappedData);
@@ -155,7 +157,7 @@ class BleAdapter extends adpater_1.default {
             this.emitData(this.data);
         }
         catch (err) {
-            this.logEvent({ message: 'Error', fn: 'onDeviceData', error: err.message, stack: err.stack });
+            this.logEvent({ message: 'Error', fn: 'onDeviceData', device: this.getName(), interface: this.getInterface(), error: err.message, stack: err.stack });
         }
     }
     mapData(deviceData) {
@@ -183,10 +185,7 @@ class BleAdapter extends adpater_1.default {
             this.stopped = false;
             if (wasPaused)
                 this.resume();
-            if (this.started && !wasPaused && !wasStopped) {
-                return 'done';
-            }
-            if (this.started && wasPaused) {
+            if (this.started && !wasStopped) {
                 return 'done';
             }
             const connected = yield this.connect();
@@ -200,6 +199,8 @@ class BleAdapter extends adpater_1.default {
             if (this.isStarting()) {
                 yield this.stop();
             }
+            const ble = this.getBle();
+            ble.once('disconnect-done', this.onDisconnectDone.bind(this));
             this.startTask = new task_1.InteruptableTask(this.startAdapter(startProps), {
                 timeout: startProps === null || startProps === void 0 ? void 0 : startProps.timeout,
                 name: 'start',
@@ -240,11 +241,11 @@ class BleAdapter extends adpater_1.default {
                 errorOnTimeout: false,
                 timeout: startupTimeout
             });
-            this.logEvent({ message: 'wait for sensor data', device: this.getName() });
+            this.logEvent({ message: 'wait for sensor data', device: this.getName(), interface: this.getInterface() });
             const hasData = yield waitTask.run();
             clearInterval(iv);
             if (hasData)
-                this.logEvent({ message: 'sensor data received', device: this.getName() });
+                this.logEvent({ message: 'sensor data received', device: this.getName(), interface: this.getInterface() });
         });
     }
     checkCapabilities() {
@@ -256,41 +257,52 @@ class BleAdapter extends adpater_1.default {
     startAdapter(startProps) {
         return __awaiter(this, void 0, void 0, function* () {
             const props = this.getStartProps(startProps);
-            const { timeout = this.getDefaultStartupTimeout() } = startProps;
+            const { timeout = this.getDefaultStartupTimeout() } = startProps !== null && startProps !== void 0 ? startProps : {};
             const wasPaused = this.paused;
             const preCheckResult = yield this.startPreChecks(props);
             if (preCheckResult === 'done') {
                 yield (0, utils_1.resolveNextTick)();
+                this.logEvent({ message: `start result: ${this.started ? 'success' : 'failed'}`, preCheckResult, device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
                 return this.started;
             }
             if (preCheckResult === 'connection-failed') {
-                this.logEvent({ message: 'start result: error', error: 'could not start device, reason:could not connect', protocol: this.getProtocolName() });
+                this.logEvent({ message: 'start result: error', error: 'could not start device, reason:could not connect', device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
                 yield (0, utils_1.resolveNextTick)();
                 return false;
             }
-            this.logEvent({ message: 'starting device', device: this.getName(), props, isStarted: this.started });
+            this.logEvent({ message: 'starting device', device: this.getName(), interface: this.getInterface(), props, isStarted: this.started });
             try {
+                this.resetData();
+                this.stopped = false;
                 const connected = yield this.startSensor();
                 if (connected) {
-                    this.logEvent({ message: 'peripheral connected', device: this.getName(), props });
+                    this.logEvent({ message: 'peripheral connected', device: this.getName(), interface: this.getInterface(), props });
                 }
                 else {
-                    this.logEvent({ message: 'peripheral connection failed', device: this.getName(), reason: 'unknown', props });
+                    this.logEvent({ message: 'peripheral connection failed', device: this.getName(), interface: this.getInterface(), reason: 'unknown', props });
+                    this.stopped = true;
                     return false;
                 }
                 yield this.waitForInitialData(timeout);
-                yield this.checkCapabilities();
+                this.checkCapabilities();
                 if (this.hasCapability(types_1.IncyclistCapability.Control))
                     yield this.initControl(startProps);
-                this.resetData();
                 this.stopped = false;
                 this.started = true;
                 if (wasPaused)
                     this.resume();
+                if (!this.isStarting()) {
+                    this.started = false;
+                    this.stopped = true;
+                    return false;
+                }
+                this.logEvent({ message: 'start result: success', device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
                 return true;
             }
             catch (err) {
-                this.logEvent({ message: 'start result: error', error: err.message, protocol: this.getProtocolName() });
+                this.logEvent({ message: 'start result: error', error: err.message, device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
+                this.started = false;
+                this.stopped = true;
                 return false;
             }
         });
@@ -304,43 +316,56 @@ class BleAdapter extends adpater_1.default {
             if (!this.getComms()) {
                 return false;
             }
-            const connected = yield this.getComms().startSensor();
+            const sensor = this.getComms();
+            const connected = yield sensor.startSensor();
+            yield sensor.subscribe();
             if (connected) {
-                this.getComms().on('data', this.onDeviceDataHandler);
-                this.getComms().on('disconnected', this.emit.bind(this));
-                this.getComms().on('error', console.log);
+                sensor.on('data', this.onDeviceDataHandler);
+                sensor.on('disconnected', this.emit.bind(this));
+                sensor.on('error', console.log);
             }
             return connected;
         });
     }
-    stop() {
+    onDisconnectDone() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'stopping device', device: this.getName() });
+            this.logEvent({ message: 'disconnecting device', device: this.getName(), interface: this.getInterface() });
             if (this.isStarting()) {
                 yield this.startTask.stop();
             }
             let reason = 'unknown';
             let stopped = false;
-            if (!this.getComms()) {
-                this.logEvent({ message: 'device stopped - not started yet', device: this.getName() });
-                return true;
-            }
-            this.getComms().reset();
+            const sensor = this.getComms();
             try {
-                stopped = yield this.getComms().stopSensor();
+                stopped = yield sensor.stopSensor();
             }
             catch (err) {
                 reason = err.message;
             }
-            if (stopped) {
-                this.logEvent({ message: 'device stopped', device: this.getName() });
+            if (!stopped) {
+                this.logEvent({ message: 'disconnecting device failed', device: this.getName(), interface: this.getInterface(), reason });
             }
-            else {
-                this.logEvent({ message: 'stopping device failed', device: this.getName(), reason });
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'stopping device', device: this.getName(), interface: this.getInterface() });
+            if (this.isStarting()) {
+                yield this.startTask.stop();
             }
             this.started = false;
+            this.resetData();
+            if (!this.getComms()) {
+                this.logEvent({ message: 'device stopped - not started yet', device: this.getName(), interface: this.getInterface() });
+                return true;
+            }
+            const sensor = this.getComms();
+            sensor.reset();
+            this.resetData();
             this.stopped = true;
-            return stopped;
+            this.started = false;
+            this.logEvent({ message: 'device stopped', device: this.getName(), interface: this.getInterface() });
+            return this.stopped;
         });
     }
     pause() {
@@ -349,8 +374,8 @@ class BleAdapter extends adpater_1.default {
         });
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield _super.pause.call(this);
-            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-            iface.pauseLogging();
+            const ble = this.getBle();
+            ble.pauseLogging();
             return res;
         });
     }
@@ -359,17 +384,24 @@ class BleAdapter extends adpater_1.default {
             resume: { get: () => super.resume }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-            iface.resumeLogging();
+            const ble = this.getBle();
+            ble.resumeLogging();
             const res = yield _super.resume.call(this);
             return res;
         });
     }
+    getBle() {
+        return interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
+    }
     update() {
     }
     setCyclingMode(mode, settings, sendInitCommands) {
         super.setCyclingMode(mode, settings, sendInitCommands);
         this.refreshDeviceData();
     }
+    onScanStart() {
+        if (!this.isStarted())
+            this.start();
+    }
 }
 exports.default = BleAdapter;

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

@@ -1,7 +1,7 @@
 import EventEmitter from "events";
 import { DeviceSettings, InterfaceProps } from "../../types";
 import { EventLogger } from "gd-eventlog";
-import { BleBinding, BleDeviceSettings, 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";
@@ -29,9 +29,10 @@ 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);
     getLogger(): EventLogger;
@@ -41,7 +42,7 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     getBinding(): BleBinding;
     protected autoConnect(): void;
     connect(reconnect?: boolean): Promise<boolean>;
-    disconnect(): Promise<boolean>;
+    disconnect(cleanup?: boolean): Promise<boolean>;
     isConnected(): boolean;
     registerConnected(peripheral: IBlePeripheral): void;
     protected isConnecting(): boolean;
@@ -60,9 +61,9 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected stopPeripheralScan(): 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[]>;
@@ -83,8 +84,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;
 }