incyclist-devices 2.1.2 → 2.1.4

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

@@ -55,7 +55,6 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData> extends Incy
     checkCapabilities(): Promise<void>;
     initControl(): Promise<void>;
     getDefaultStartupTimeout(): number;
-    sendUpdate(request: any): void;
     startPreChecks(props: AntDeviceProperties): Promise<'done' | 'connected' | 'connection-failed'>;
     resetStartStatus(): void;
     isStartSuccess(): boolean;

package/lib/antv2/base/adapter.js

@@ -48,6 +48,9 @@ class AntAdapter extends adpater_1.default {
         this.updateFrequency = consts_1.DEFAULT_UPDATE_FREQUENCY;
         this.channel = undefined;
         this.ant = interface_1.default.getInstance();
+        if (this.isDebugEnabled()) {
+            this.ant.setLogger(this);
+        }
     }
     getProfileName() {
         const C = this.constructor;
@@ -116,12 +119,10 @@ class AntAdapter extends adpater_1.default {
             if (!ManId && deviceData.ManId) {
                 this.emit('device-info', this.getSettings(), { manufacturer: (0, utils_2.getBrand)(deviceData.ManId) });
             }
-            if (!this.started || this.isStopped())
-                return;
-            if (!this.canEmitData())
-                return;
             const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
             this.logEvent({ message: 'onDeviceData', data: logData, paused: this.paused });
+            if (!this.started || this.isStopped() || !this.canEmitData())
+                return;
             if (this.isControllable()) {
                 let incyclistData = this.mapData(deviceData);
                 incyclistData = this.getCyclingMode().updateData(incyclistData);
@@ -148,6 +149,7 @@ class AntAdapter extends adpater_1.default {
                         resolve(true);
                     }
                     if (!this.promiseWaitForData) {
+                        resolve(false);
                         clearInterval(iv);
                     }
                 }, 10);
@@ -172,9 +174,9 @@ class AntAdapter extends adpater_1.default {
             }
             try {
                 this.promiseWaitForData = (0, utils_1.runWithTimeout)(this._wait(), timeout);
-                yield this.promiseWaitForData;
+                const hasData = yield this.promiseWaitForData;
                 this.promiseWaitForData = null;
-                return true;
+                return hasData;
             }
             catch (err) {
                 this.promiseWaitForData = null;
@@ -188,10 +190,11 @@ class AntAdapter extends adpater_1.default {
         return id.toString();
     }
     getName() {
+        var _a;
         if (this.settings.name)
             return this.settings.name;
-        const deviceID = this.sensor.getDeviceID();
-        const profile = this.sensor.getProfile();
+        const deviceID = this.getID();
+        const profile = (_a = this.sensor) === null || _a === void 0 ? void 0 : _a.getProfile();
         return `Ant+${profile} ${deviceID}`;
     }
     getUniqueName() {
@@ -250,16 +253,6 @@ class AntAdapter extends adpater_1.default {
     getDefaultStartupTimeout() {
         return 20000;
     }
-    sendUpdate(request) {
-        if (!this.isControllable())
-            return;
-        if (this.isPaused() || this.isStopped())
-            return;
-        if (!this.hasCapability(types_2.IncyclistCapability.Control))
-            this.getCyclingMode().sendBikeUpdate(request);
-        else
-            throw new Error('method not implemented');
-    }
     startPreChecks(props) {
         return __awaiter(this, void 0, void 0, function* () {
             const wasPaused = this.paused;
@@ -294,7 +287,7 @@ class AntAdapter extends adpater_1.default {
     reportStartStatus() {
         const success = this.isStartSuccess();
         if (success) {
-            this.logEvent({ message: 'start device success' });
+            this.logEvent({ message: 'start device success', device: this.getName() });
             this.started = true;
             this.paused = false;
             return true;
@@ -302,18 +295,20 @@ class AntAdapter extends adpater_1.default {
         else {
             this.started = false;
             const { sensorStarted, hasData, interrupted } = this.startStatus;
-            if (interrupted)
-                return;
+            if (interrupted) {
+                this.logEvent({ message: 'start device interrupted', device: this.getName() });
+                return false;
+            }
             if (!sensorStarted) {
-                this.logEvent({ message: 'start device failed', reason: 'could not connect' });
+                this.logEvent({ message: 'start device failed', device: this.getName(), reason: 'could not connect' });
                 throw new Error('could not start device, reason:could not connect');
             }
             else if (!hasData) {
-                this.logEvent({ message: 'start device failed', reason: 'no data received' });
+                this.logEvent({ message: 'start device failed', device: this.getName(), reason: 'no data received' });
                 throw new Error('could not start device, reason:no data received');
             }
             else {
-                this.logEvent({ message: 'start device failed', reason: 'could not send FE commands' });
+                this.logEvent({ message: 'start device failed', device: this.getName(), reason: 'could not send FE commands' });
                 throw new Error('could not start device, reason:could not send FE commands');
             }
         }
@@ -323,10 +318,10 @@ class AntAdapter extends adpater_1.default {
             const { sensorStarted, hasData, timeout } = this.startStatus;
             if ((sensorStarted && hasData) || !sensorStarted || timeout)
                 return;
-            this.logEvent({ message: 'wait for sensor data', });
+            this.logEvent({ message: 'wait for sensor data', device: this.getName() });
             this.startStatus.hasData = yield this.waitForData(startupTimeout);
             if (this.startStatus.hasData)
-                this.logEvent({ message: 'sensor data received', });
+                this.logEvent({ message: 'sensor data received', device: this.getName() });
         });
     }
     initSensor(props) {
@@ -334,7 +329,7 @@ class AntAdapter extends adpater_1.default {
             this.startStatus.sensorStarted = this.sensorConnected;
             if (this.startStatus.sensorStarted || this.startStatus.sensorStarted)
                 return;
-            this.logEvent({ message: 'start sensor', props });
+            this.logEvent({ message: 'start sensor', device: this.getName(), props });
             try {
                 this.sensorConnected = yield this.startSensor();
                 if (this.sensorConnected) {
@@ -343,7 +338,7 @@ class AntAdapter extends adpater_1.default {
                 }
             }
             catch (err) {
-                this.logEvent({ message: 'start sensor failed', reason: err.message, props });
+                this.logEvent({ message: 'start sensor failed', device: this.getName(), reason: err.message, props });
             }
         });
     }
@@ -354,7 +349,7 @@ class AntAdapter extends adpater_1.default {
                 return this.started;
             if (preCheckResult === 'connection-failed')
                 throw new Error(`could not start device, reason:could not connect`);
-            this.logEvent({ message: 'starting device', props, isStarted: this.started });
+            this.logEvent({ message: 'starting device', device: this.getName(), props, isStarted: this.started });
             this.resetStartStatus();
             this.resetData();
             const { startupTimeout = this.getDefaultStartupTimeout() } = props || {};
@@ -371,7 +366,7 @@ class AntAdapter extends adpater_1.default {
                         yield this.checkCapabilities();
                         if (this.hasCapability(types_2.IncyclistCapability.Control))
                             yield this.initControl();
-                        if (!this.startStatus.hasData) {
+                        if (!this.startStatus.hasData && !this.startStatus.interrupted) {
                             yield this.stopSensor();
                             yield (0, utils_1.sleep)(retryDelay);
                             continue;
@@ -379,7 +374,7 @@ class AntAdapter extends adpater_1.default {
                         success = this.isStartSuccess();
                     }
                     catch (err) {
-                        this.logEvent({ message: 'error', fn: 'start#doStart', error: err.message, stack: err.stack });
+                        this.logEvent({ message: 'error', fn: 'start#doStart', device: this.getName(), error: err.message, stack: err.stack });
                     }
                 }
                 this.reportStartStatus();
@@ -392,19 +387,24 @@ class AntAdapter extends adpater_1.default {
                 if (err.message === 'Timeout') {
                     this.started = false;
                     this.startStatus.timeout = true;
+                    this.logEvent({ message: 'start device failed', device: this.getName(), reason: 'timeout' });
                     throw new Error(`could not start device, reason:timeout`);
                 }
                 throw err;
             }
-            return true;
+            return this.started;
         });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
             let stopped;
+            this.logger.logEvent({ message: 'stopping device', device: this.getName() });
             this.promiseWaitForData = null;
-            if (this.startStatus)
+            if (this.startStatus) {
                 this.startStatus.interrupted = true;
+                console.log('~~~ still starting');
+                yield (0, utils_1.sleep)(20);
+            }
             try {
                 stopped = yield this.ant.stopSensor(this.sensor);
             }
@@ -416,6 +416,7 @@ class AntAdapter extends adpater_1.default {
             this.stopped = true;
             this.paused = false;
             this.removeAllListeners();
+            this.logEvent({ message: 'stopping device finished', device: this.getName(), stopped });
             return stopped;
         });
     }

package/lib/antv2/base/interface.js

@@ -134,6 +134,7 @@ class AntInterface extends events_1.default {
         return 1000;
     }
     scannerWaitForConnection() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             let scanFinished = false;
             let scanStopRequested = false;
@@ -152,7 +153,7 @@ class AntInterface extends events_1.default {
             }
             if (scanStopRequested)
                 this.emit('scan stopped', true);
-            this.activeScan.emitter.removeAllListeners();
+            (_a = this.activeScan) === null || _a === void 0 ? void 0 : _a.emitter.removeAllListeners();
         });
     }
     scan(props = {}) {
@@ -162,8 +163,8 @@ class AntInterface extends events_1.default {
                 return yield this.scanPromise;
             }
             this.activeScan = { emitter: new events_1.default() };
+            const detected = [];
             const _scan = () => new Promise((done) => __awaiter(this, void 0, void 0, function* () {
-                const detected = [];
                 const onDetected = (profile, deviceID) => {
                     if (deviceID && detected.find(s => s.deviceID === deviceID && s.profile === profile) === undefined) {
                         try {
@@ -222,19 +223,23 @@ class AntInterface extends events_1.default {
                 }));
                 this.activeScan.emitter.on('timeout', () => __awaiter(this, void 0, void 0, function* () {
                     this.activeScan.emitter.removeAllListeners();
+                    yield this.activeScan.channel.stopScanner();
                     this.emit('stop-scan');
                     removeListeners(channel);
+                    this.logEvent({ message: 'scan finished(timeout) ..' });
                     done(detected);
                 }));
             }));
             const { timeout } = props;
             this.scanPromise = _scan();
             if (timeout) {
-                const res = yield (0, utils_1.waitWithTimeout)(this.scanPromise, timeout, () => {
+                yield (0, utils_1.waitWithTimeout)(this.scanPromise, timeout, () => {
                     var _a;
                     (_a = this.activeScan) === null || _a === void 0 ? void 0 : _a.emitter.emit('timeout');
                 });
-                return res || [];
+                this.scanPromise = null;
+                this.activeScan = null;
+                return detected;
             }
             else {
                 const res = yield this.scanPromise;
@@ -255,6 +260,7 @@ class AntInterface extends events_1.default {
             return new Promise(done => {
                 this.activeScan.emitter.emit('stop');
                 this.once('scan stopped', (res) => {
+                    this.logEvent({ message: 'stopping scan done ..' });
                     done(res);
                 });
             });

package/lib/antv2/fe/adapter.d.ts

@@ -5,6 +5,7 @@ import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types"
 import { IncyclistBikeData, ControllerConfig } from "../../types";
 interface AntFEStartDeviceProperties extends AntDeviceProperties {
     reconnect?: boolean;
+    restart?: boolean;
     reconnectTimeout?: number;
 }
 export default class AntFEAdapter extends AntAdapter<FitnessEquipmentSensorState> {

package/lib/antv2/fe/adapter.js

@@ -42,7 +42,7 @@ class AntFEAdapter extends adapter_1.default {
                 return;
             let isReset = request.reset && Object.keys(request).length === 1;
             const update = isReset ? this.getCyclingMode().getBikeInitRequest() : this.getCyclingMode().sendBikeUpdate(request);
-            this.logEvent({ message: 'send bike update requested', update, request });
+            this.logEvent({ message: 'send bike update requested', device: this.getName(), update, request });
             try {
                 const fe = this.sensor;
                 if (update.slope !== undefined) {
@@ -59,7 +59,7 @@ class AntFEAdapter extends adapter_1.default {
                         yield this.reconnect();
                     }
                 }
-                this.logEvent({ message: 'sendBikeUpdate() error', error: err.message });
+                this.logEvent({ message: 'sendBikeUpdate() error', device: this.getName(), error: err.message });
             }
         });
     }
@@ -123,12 +123,18 @@ class AntFEAdapter extends adapter_1.default {
     resetStartStatus() {
         const props = this.startProps;
         const isReconnect = props.reconnect || false;
+        const isRestart = props.restart || false;
         super.resetStartStatus();
         if (isReconnect) {
             delete props.reconnect;
             this.startStatus.userInitialized = true;
             this.startStatus.controlInitialized = true;
         }
+        if (isRestart) {
+            delete props.restart;
+            this.startStatus.sensorStarted = true;
+            this.startStatus.hasData = true;
+        }
     }
     startPreChecks(props) {
         const _super = Object.create(null, {
@@ -137,6 +143,11 @@ class AntFEAdapter extends adapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             this.startProps = props;
             this.setFEDefaultTimeout();
+            if (this.started && this.paused) {
+                this.resume();
+                props.restart = true;
+                return 'connected';
+            }
             return yield _super.startPreChecks.call(this, props);
         });
     }
@@ -164,7 +175,7 @@ class AntFEAdapter extends adapter_1.default {
                 this.startStatus.userInitialized = yield fe.sendUserConfiguration(userWeight, bikeWeight, args.wheelDiameter, args.gearRatio);
             }
             catch (err) {
-                this.logEvent({ message: 'sending FE message error', error: err.message });
+                this.logEvent({ message: 'sending FE message error', device: this.getName(), error: err.message });
                 this.startStatus.userInitialized = false;
             }
         });
@@ -193,7 +204,7 @@ class AntFEAdapter extends adapter_1.default {
                 }
             }
             catch (err) {
-                this.logEvent({ message: 'sending FE message error', error: err.message });
+                this.logEvent({ message: 'sending FE message error', device: this.getName(), error: err.message });
                 this.startStatus.controlInitialized = false;
             }
         });
@@ -209,7 +220,7 @@ class AntFEAdapter extends adapter_1.default {
     }
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'reconnect to device' });
+            this.logEvent({ message: 'reconnect to device', device: this.getName() });
             if (this.promiseReconnect) {
                 return yield this.promiseReconnect;
             }
@@ -218,11 +229,11 @@ class AntFEAdapter extends adapter_1.default {
                     yield this.stop();
                     yield this.start(Object.assign(Object.assign({}, this.startProps), { reconnect: true }));
                     this.started = true;
-                    this.logEvent({ message: 'reconnect success' });
+                    this.logEvent({ message: 'reconnect success', device: this.getName() });
                     return true;
                 }
                 catch (err) {
-                    this.logEvent({ message: 'reconnect failed' });
+                    this.logEvent({ message: 'reconnect failed', device: this.getName() });
                     return false;
                 }
             });

package/lib/base/adpater.d.ts

@@ -20,6 +20,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     protected data: IncyclistAdapterData;
     constructor(settings: DeviceSettings, props?: P);
     getLogger(): EventLogger;
+    isDebugEnabled(): boolean;
     logEvent(event: any): void;
     getName(): string;
     getID(): string;

package/lib/base/adpater.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../types");
 const events_1 = __importDefault(require("events"));
 const consts_1 = require("./consts");
 class IncyclistDevice extends events_1.default {
@@ -29,12 +30,18 @@ class IncyclistDevice extends events_1.default {
         this.cyclingMode = this.getDefaultCyclingMode();
     }
     getLogger() { return this.logger; }
+    isDebugEnabled() {
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
+            return true;
+        }
+        return false;
+    }
     logEvent(event) {
         if (!this.logger || this.paused)
             return;
         this.logger.logEvent(event);
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
+        if (this.isDebugEnabled()) {
             const logText = `~~~ ${this.getInterface()}: ${this.logger.getName()}`;
             console.log(logText, event);
         }
@@ -42,7 +49,7 @@ class IncyclistDevice extends events_1.default {
     getName() {
         return this.settings.name;
     }
-    getID() { throw new Error('not implemented'); }
+    getID() { return ''; }
     getUniqueName() {
         throw new Error("Method not implemented.");
     }
@@ -62,12 +69,16 @@ class IncyclistDevice extends events_1.default {
     stop() { throw new Error("Method not implemented."); }
     pause() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.isStarted() && !this.isStopped())
+                this.logEvent({ message: 'pausing device', device: this.getName() });
             this.paused = true;
             return true;
         });
     }
     resume() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.isStarted() && !this.isStopped())
+                this.logger.logEvent({ message: 'resuming device', device: this.getName() });
             this.paused = false;
             return true;
         });
@@ -170,7 +181,12 @@ class IncyclistDevice extends events_1.default {
     sendUpdate(request) {
         if (!this.isControllable())
             return;
-        throw new Error("Method not implemented.");
+        if (this.isPaused() || this.isStopped())
+            return;
+        if (!this.hasCapability(types_1.IncyclistCapability.Control))
+            this.getCyclingMode().sendBikeUpdate(request);
+        else
+            throw new Error('method not implemented');
     }
     setUser(user) {
         this.user = user;

package/lib/ble/adapter-factory.d.ts

@@ -2,29 +2,30 @@ import BleAdapter from "./base/adapter";
 import { BleDeviceSettings, BleProtocol } from "./types";
 import { DeviceProperties } from "../types";
 import { BleComms } from "./base/comms";
+import { BleDeviceData } from "./base/types";
 export interface BleAdapterInfo {
     protocol: BleProtocol;
-    Adapter: typeof BleAdapter;
+    Adapter: typeof BleAdapter<BleDeviceData, BleComms>;
     Comm: typeof BleComms;
 }
 export default class BleAdapterFactory {
     static _instance: BleAdapterFactory;
     implementations: BleAdapterInfo[];
-    instances: Array<BleAdapter>;
+    instances: Array<BleAdapter<BleDeviceData, BleComms>>;
     static getInstance(): BleAdapterFactory;
     constructor();
     getAdapterInfo(protocol: BleProtocol): BleAdapterInfo;
     getAll(): BleAdapterInfo[];
-    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter;
+    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<BleDeviceData, BleComms>;
     removeInstance(query: {
         settings?: BleDeviceSettings;
-        adapter?: BleAdapter;
+        adapter?: BleAdapter<BleDeviceData, BleComms>;
     }): void;
-    find(settings?: BleDeviceSettings): BleAdapter;
-    register(protocol: BleProtocol, Adapter: typeof BleAdapter, Comm: typeof BleComms): void;
-    getAllInstances(): Array<BleAdapter>;
+    find(settings?: BleDeviceSettings): BleAdapter<BleDeviceData, BleComms>;
+    register(protocol: BleProtocol, Adapter: typeof BleAdapter<BleDeviceData, BleComms>, Comm: typeof BleComms): void;
+    getAllInstances(): Array<BleAdapter<BleDeviceData, BleComms>>;
     getAllSupportedComms(): (typeof BleComms)[];
-    getAllSupportedAdapters(): Array<(typeof BleAdapter)>;
+    getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, BleComms>)>;
     getAllSupportedServices(): string[];
     getDeviceClasses(peripheral: any, props?: {
         protocol?: BleProtocol;

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

@@ -3,28 +3,31 @@ import { BleComms } from "./comms";
 import BleInterface from "../ble-interface";
 import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from "../types";
 import { IAdapter, IncyclistBikeData, IncyclistAdapterData, DeviceProperties } from "../../types";
-export default class BleAdapter extends IncyclistDevice<BleDeviceProperties> {
-    ble: BleInterface;
-    deviceData: any;
-    data: IncyclistAdapterData;
-    dataMsgCount: number;
-    lastDataTS: number;
-    device: BleComms;
+import { BleDeviceData } from "./types";
+import { LegacyProfile } from "../../antv2/types";
+export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice extends BleComms> extends IncyclistDevice<BleDeviceProperties> {
+    protected ble: BleInterface;
+    protected deviceData: TDeviceData;
+    protected data: IncyclistAdapterData;
+    protected dataMsgCount: number;
+    protected lastDataTS: number;
+    protected device: TDevice;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     getUniqueName(): string;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
-    getComms(): BleComms;
+    getComms(): TDevice;
     isEqual(settings: BleDeviceSettings): boolean;
     isSame(adapter: IAdapter): boolean;
     isConnected(): boolean;
     resetData(): void;
     getInterface(): string;
+    getProfile(): LegacyProfile;
     getProtocolName(): string;
     getID(): string;
     getName(): string;
-    onDeviceData(deviceData: any): void;
-    mapData(deviceData: any): IncyclistAdapterData | IncyclistBikeData;
+    onDeviceData(deviceData: TDeviceData): void;
+    mapData(deviceData: TDeviceData): IncyclistAdapterData | IncyclistBikeData;
     transformData(data: IncyclistBikeData): IncyclistAdapterData;
     getSettings(): BleDeviceSettings;
     setProperties(props: BleDeviceProperties): void;

package/lib/ble/base/adapter.js

@@ -27,9 +27,10 @@ class BleAdapter extends adpater_1.default {
         this.ble = ble_interface_1.default.getInstance();
     }
     getUniqueName() {
+        var _a;
         const settings = this.settings;
-        if (settings.name.match(/[0-9]/g) || settings.address === undefined)
-            return this.settings.name;
+        if (((_a = settings.name) === null || _a === void 0 ? void 0 : _a.match(/[0-9]/g)) || settings.address === undefined)
+            return this.getName();
         else {
             const addressHash = settings.address.substring(0, 2) + settings.address.slice(-2);
             return `${this.getName()} ${addressHash}`;
@@ -56,11 +57,7 @@ class BleAdapter extends adpater_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.device || !this.isConnected())
                 return true;
-            if (this.device) {
-                yield this.device.disconnect();
-                this.ble.removeConnectedDevice(this);
-                return true;
-            }
+            return yield this.device.disconnect();
         });
     }
     getComms() {
@@ -94,13 +91,17 @@ class BleAdapter extends adpater_1.default {
     getInterface() {
         return INTERFACE_NAME;
     }
+    getProfile() {
+        const C = this.constructor;
+        return C['INCYCLIST_PROFILE_NAME'];
+    }
     getProtocolName() {
         const settings = this.settings;
         return settings.protocol;
     }
     getID() {
         const settings = this.settings;
-        return settings.id;
+        return settings.id || settings.address;
     }
     getName() {
         const settings = this.settings;

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

@@ -0,0 +1,2 @@
+export interface BleDeviceData {
+}

package/lib/ble/base/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -5,7 +5,6 @@ import BleAdapterFactory from './adapter-factory';
 import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic } from './types';
 import { BleComms } from './base/comms';
 import { IncyclistInterface, IncyclistScanProps } from '../types';
-import BleAdapter from './base/adapter';
 import BlePeripheralCache from './peripheral-cache';
 import EventEmitter from 'events';
 export interface ScanState {
@@ -39,7 +38,6 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     logger: EventLogger;
     props: BleInterfaceProps;
     binding: BleBinding;
-    connectedDevices: Array<BleAdapter>;
     sensorIsConnecting: boolean;
     emittingAdapters: {
         comms: BleComms;
@@ -78,6 +76,4 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     scan(props?: BleScanProps): Promise<BleDeviceSettings[]>;
     stopScan(): Promise<boolean>;
     isScanning(): boolean;
-    addConnectedDevice(device: BleAdapter): void;
-    removeConnectedDevice(device: BleAdapter): void;
 }

package/lib/ble/ble-interface.js

@@ -47,7 +47,6 @@ class BleInterface extends events_1.default {
         if (props.binding)
             this.setBinding(props.binding);
         this.peripheralCache = new peripheral_cache_1.default();
-        this.connectedDevices = [];
         if (props.logger)
             this.logger = props.logger;
         else
@@ -542,15 +541,5 @@ class BleInterface extends events_1.default {
     isScanning() {
         return this.scanState.isScanning === true;
     }
-    addConnectedDevice(device) {
-        const idx = this.connectedDevices.findIndex(d => d.isSame(device));
-        if (idx === -1)
-            this.connectedDevices.push(device);
-    }
-    removeConnectedDevice(device) {
-        const idx = this.connectedDevices.findIndex(d => d.isSame(device));
-        if (idx !== -1)
-            this.connectedDevices.splice(idx);
-    }
 }
 exports.default = BleInterface;

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

@@ -1,17 +1,19 @@
+import BleCyclingPowerDevice from './comm';
 import BleAdapter from '../base/adapter';
 import { PowerData } from './types';
 import { BleDeviceSettings } from '../types';
 import { DeviceProperties, IncyclistBikeData, IncyclistAdapterData, ControllerConfig, IAdapter } from '../../types';
-export default class PwrAdapter extends BleAdapter {
+import { LegacyProfile } from '../../antv2/types';
+export default class PwrAdapter extends BleAdapter<PowerData, BleCyclingPowerDevice> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     protected static controllers: ControllerConfig;
     distanceInternal: number;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     isSame(device: IAdapter): boolean;
-    getProfile(): string;
+    getProfile(): LegacyProfile;
     getName(): string;
     getDisplayName(): string;
     mapData(deviceData: PowerData): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
-    sendUpdate(request: any): Promise<void>;
     stop(): Promise<boolean>;
 }

package/lib/ble/cp/adapter.js

@@ -82,13 +82,6 @@ class PwrAdapter extends adapter_1.default {
         };
         return data;
     }
-    sendUpdate(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused)
-                return;
-            this.getCyclingMode().sendBikeUpdate(request);
-        });
-    }
     stop() {
         const _super = Object.create(null, {
             stop: { get: () => super.stop }
@@ -101,6 +94,7 @@ class PwrAdapter extends adapter_1.default {
         });
     }
 }
+PwrAdapter.INCYCLIST_PROFILE_NAME = 'Power Meter';
 PwrAdapter.controllers = {
     modes: [power_meter_1.default],
     default: power_meter_1.default

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

@@ -1,19 +1,21 @@
 import BleAdapter from '../base/adapter';
+import BleEliteDevice from './comms';
 import ICyclingMode from '../../modes/types';
 import { PowerData } from '../cp';
 import { DeviceProperties, IncyclistAdapterData, IncyclistBikeData, ControllerConfig, IAdapter } from '../../types';
 import { BleDeviceSettings } from '../types';
-export default class BleEliteAdapter extends BleAdapter {
+import { LegacyProfile } from '../../antv2/types';
+export default class BleEliteAdapter extends BleAdapter<PowerData, BleEliteDevice> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     protected static controllers: ControllerConfig;
     distanceInternal: number;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     isSame(device: IAdapter): boolean;
-    getProfile(): string;
+    getProfile(): LegacyProfile;
     getName(): string;
     getDefaultCyclingMode(): ICyclingMode;
     getSupportedCyclingModes(): any[];
     mapData(deviceData: PowerData): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
     start(props?: any): Promise<any>;
-    sendUpdate(request: any): Promise<void>;
 }

package/lib/ble/elite/adapter.js

@@ -109,14 +109,8 @@ class BleEliteAdapter extends adapter_1.default {
             }
         });
     }
-    sendUpdate(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused)
-                return;
-            this.getCyclingMode().sendBikeUpdate(request);
-        });
-    }
 }
+BleEliteAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
 BleEliteAdapter.controllers = {
     modes: [power_meter_1.default],
     default: power_meter_1.default

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

@@ -1,16 +1,17 @@
+import BleFitnessMachineDevice from './comms';
 import BleAdapter from '../base/adapter';
 import ICyclingMode, { CyclingMode } from '../../modes/types';
 import { IndoorBikeData } from './types';
 import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from '../types';
 import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../../types';
-export default class BleFmAdapter extends BleAdapter {
+import { LegacyProfile } from '../../antv2/types';
+export default class BleFmAdapter extends BleAdapter<IndoorBikeData, BleFitnessMachineDevice> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     distanceInternal: number;
     connectPromise: Promise<boolean>;
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
     isSame(device: IAdapter): boolean;
-    getProfile(): string;
     getName(): string;
-    getDisplayName(): string;
     isControllable(): boolean;
     getSupportedCyclingModes(): Array<typeof CyclingMode>;
     getDefaultCyclingMode(): ICyclingMode;

package/lib/ble/fm/adapter.js

@@ -40,15 +40,9 @@ class BleFmAdapter extends adapter_1.default {
             return false;
         return this.isEqual(device.settings);
     }
-    getProfile() {
-        return 'Smart Trainer';
-    }
     getName() {
         return `${this.device.name}`;
     }
-    getDisplayName() {
-        return this.getName();
-    }
     isControllable() {
         return true;
     }
@@ -258,4 +252,5 @@ class BleFmAdapter extends adapter_1.default {
         });
     }
 }
+BleFmAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
 exports.default = BleFmAdapter;

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

@@ -1,12 +1,14 @@
 import BleAdapter from '../base/adapter';
+import BleHrmDevice from './comm';
 import { IncyclistAdapterData, IAdapter, DeviceProperties } from '../../types';
 import { BleDeviceSettings } from '../types';
 import { HrmData } from './types';
-export default class HrmAdapter extends BleAdapter {
+import { LegacyProfile } from '../../antv2/types';
+export default class HrmAdapter extends BleAdapter<HrmData, BleHrmDevice> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     ignore: boolean;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     isSame(device: IAdapter): boolean;
-    getProfile(): string;
     getName(): string;
     getDisplayName(): string;
     mapData(deviceData: HrmData): IncyclistAdapterData;

package/lib/ble/hr/adapter.js

@@ -25,9 +25,6 @@ class HrmAdapter extends adapter_1.default {
             return false;
         return this.isEqual(device.settings);
     }
-    getProfile() {
-        return 'Heartrate Monitor';
-    }
     getName() {
         return `${this.device.name}`;
     }
@@ -42,4 +39,5 @@ class HrmAdapter extends adapter_1.default {
         return { heartrate };
     }
 }
+HrmAdapter.INCYCLIST_PROFILE_NAME = 'Heartrate Monitor';
 exports.default = HrmAdapter;

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

@@ -1,4 +1,6 @@
 import BleAdapter from "./base/adapter";
+import { BleComms } from "./base/comms";
+import { BleDeviceData } from "./base/types";
 import BlePeripheralConnector from "./ble-peripheral";
 import { BleCharacteristic, BlePeripheral } from "./types";
 export interface PeripheralState {
@@ -18,7 +20,7 @@ export interface PeripheralCacheItem {
 }
 export default class BlePeripheralCache {
     peripherals: PeripheralCacheItem[];
-    findAdapter(adapter: BleAdapter): PeripheralCacheItem;
+    findAdapter(adapter: BleAdapter<BleDeviceData, BleComms>): PeripheralCacheItem;
     getConnector(peripheral: BlePeripheral): BlePeripheralConnector;
     getPeripheral(query: {
         id?: string;

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

@@ -1,9 +1,11 @@
 import { BleFmAdapter } from '../fm';
 import { BleDeviceSettings, BleStartProperties } from '../types';
 import { DeviceProperties, IAdapter } from '../../types';
+import { LegacyProfile } from '../../antv2/types';
 export default class BleTacxFEAdapter extends BleFmAdapter {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     isSame(device: IAdapter): boolean;
-    getProfile(): string;
+    getProfile(): LegacyProfile;
     start(props?: BleStartProperties): Promise<any>;
 }

package/lib/ble/tacx/adapter.js

@@ -102,4 +102,5 @@ class BleTacxFEAdapter extends fm_1.BleFmAdapter {
         });
     }
 }
+BleTacxFEAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
 exports.default = BleTacxFEAdapter;

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

@@ -1,9 +1,11 @@
 import { BleFmAdapter } from '../fm';
 import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from '../types';
 import { IAdapter } from '../../types';
+import { LegacyProfile } from '../../antv2/types';
 export default class BleWahooAdapter extends BleFmAdapter {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
     isSame(device: IAdapter): boolean;
-    getProfile(): string;
+    getProfile(): LegacyProfile;
     start(props?: BleStartProperties): Promise<any>;
 }

package/lib/ble/wahoo/adapter.js

@@ -97,4 +97,5 @@ class BleWahooAdapter extends fm_1.BleFmAdapter {
         });
     }
 }
+BleWahooAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
 exports.default = BleWahooAdapter;

package/lib/modes/power-base.js

@@ -22,10 +22,7 @@ class PowerBasedCyclingModeBase extends base_1.CyclingModeBase {
         return slope || 0;
     }
     initLogger(defaultLogName) {
-        const a = this.adapter;
-        this.logger = a.getLogger();
-        if (!this.logger)
-            this.logger = new gd_eventlog_1.EventLogger(defaultLogName);
+        this.logger = new gd_eventlog_1.EventLogger(defaultLogName);
     }
     getWeight() {
         const a = this.adapter;

package/lib/simulator/Simulator.js

@@ -36,7 +36,7 @@ class Simulator extends adpater_1.default {
         this.setCyclingMode(name, modeSettings);
         this.capabilities = [
             types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Gear,
-            types_1.IncyclistCapability.Control
+            types_1.IncyclistCapability.Control, types_1.IncyclistCapability.HeartRate
         ];
     }
     isEqual(settings) {
@@ -53,12 +53,13 @@ class Simulator extends adpater_1.default {
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.startProps = props;
+            this.stopped = false;
             this.paused = false;
             if (props)
                 this.setBikeProps(props);
             return new Promise((resolve) => {
                 if (!this.isBot)
-                    this.logger.logEvent({ message: 'start', iv: this.iv });
+                    this.logEvent({ message: 'starting device', device: this.getName(), props });
                 if (this.started) {
                     return resolve(true);
                 }
@@ -94,32 +95,31 @@ class Simulator extends adpater_1.default {
         });
     }
     pause() {
-        return new Promise((resolve, reject) => {
-            if (!this.started)
-                return reject(new Error('illegal state - pause() has been called before start()'));
-            if (!this.isBot)
-                this.logger.logEvent({ message: 'pause', iv: this.iv });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isBot && this.isStarted())
+                this.logEvent({ message: 'pausing device', device: this.getName() });
             this.paused = true;
-            resolve(true);
+            return true;
         });
     }
     resume() {
-        return new Promise((resolve, reject) => {
-            if (!this.started)
-                reject(new Error('illegal state - resume() has been called before start()'));
-            if (!this.isBot)
-                this.logger.logEvent({ message: 'resume', iv: this.iv });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isBot && this.isStarted())
+                this.logger.logEvent({ message: 'resuming device', device: this.getName() });
             this.paused = false;
-            resolve(true);
+            return true;
         });
     }
     toggle() {
-        if (this.started) {
-            return this.stop();
-        }
-        else {
-            return this.start().then(() => { return true; });
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.started) {
+                return yield this.stop();
+            }
+            else {
+                yield this.start();
+                return true;
+            }
+        });
     }
     faster() {
         if (this.speed < 15)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",