incyclist-devices 2.0.0-beta.1 → 2.0.1

package/lib/antv2/fe/adapter.js

@@ -37,13 +37,15 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
         this.dataMsgCount = 0;
         this.logger = new gd_eventlog_1.EventLogger('Ant+FE');
         this.isReconnecting = false;
+        this.startProps = {};
         this.capabilities = [
             capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence,
             capabilities_1.IncyclistCapability.Control
         ];
     }
     createSensor(settings) {
-        return sensor_factory_1.default.create(AntFEAdapter.ANT_PROFILE_NAME, Number(settings.deviceID));
+        const sensor = sensor_factory_1.default.create(AntFEAdapter.ANT_PROFILE_NAME, Number(settings.deviceID));
+        return sensor;
     }
     getName() {
         if (this.settings.name)
@@ -51,14 +53,20 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
         const deviceID = this.sensor.getDeviceID();
         return `Ant+FE ${deviceID}`;
     }
-    getDisplayName() {
-        const { DeviceID, ManId, InstantaneousPower } = this.deviceData;
-        const pwrStr = InstantaneousPower ? ` (${InstantaneousPower})` : '';
+    getUniqueName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const { DeviceID, ManId } = this.deviceData;
         const brand = (0, utils_1.getBrand)(ManId);
         if (brand)
-            return `${brand} FE ${DeviceID}${pwrStr}`;
+            return `${brand} FE ${DeviceID}`;
         else
-            return `${this.getName()}${pwrStr}`;
+            return `${this.getName()}`;
+    }
+    getDisplayName() {
+        const { InstantaneousPower } = this.deviceData;
+        const pwrStr = InstantaneousPower ? ` (${InstantaneousPower})` : '';
+        return `${this.getUniqueName()}${pwrStr}`;
     }
     getSupportedCyclingModes() {
         return [ant_fe_st_mode_1.default, ant_fe_erg_mode_1.default, ant_fe_adv_st_mode_1.default];
@@ -73,17 +81,17 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
         });
         return logData;
     }
-    sendUpdate(request) {
+    sendUpdate(request, forced = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused || this.isReconnecting)
+            if ((this.paused || this.isReconnecting) && !forced)
+                return;
+            let isReset = request.reset && Object.keys(request).length === 1;
+            const update = isReset ? this.getCyclingMode().getBikeInitRequest() : this.getCyclingMode().sendBikeUpdate(request);
+            if (!update)
                 return;
-            const update = this.getCyclingMode().sendBikeUpdate(request);
             this.logger.logEvent({ message: 'send bike update requested', update, request });
             try {
                 const fe = this.sensor;
-                const isReset = (!update || update.reset || Object.keys(update).length === 0);
-                if (isReset)
-                    yield fe.sendTrackResistance(0);
                 if (update.slope !== undefined) {
                     yield fe.sendTrackResistance(update.slope);
                 }
@@ -106,7 +114,7 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
         this.dataMsgCount++;
         this.lastDataTS = Date.now();
         super.onDeviceData(deviceData);
-        if (!this.started || this.isStopped())
+        if (!this.started || this.isStopped() || this.paused)
             return;
         if (!this.ivDataTimeout && this.dataMsgCount > 0) {
             this.startDataTimeoutCheck();
@@ -114,21 +122,23 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
         try {
             const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
             this.logger.logEvent({ message: 'onDeviceData', data: logData });
-            if (this.onDataFn && !this.paused) {
-                if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
-                    let incyclistData = this.mapData(deviceData);
-                    incyclistData = this.getCyclingMode().updateData(incyclistData);
-                    const data = this.transformData(incyclistData);
-                    this.onDataFn(data);
-                    this.lastUpdate = Date.now();
-                }
-            }
+            if (!this.canSendUpdate())
+                return;
+            let incyclistData = this.mapToCycleModeData(deviceData);
+            incyclistData = this.getCyclingMode().updateData(incyclistData);
+            this.data = this.transformData(incyclistData);
+            this.emitData(this.data);
         }
         catch (err) {
             this.logger.logEvent({ message: 'error', fn: 'onDeviceData()', error: err.message || err, stack: err.stack });
         }
     }
-    mapData(deviceData) {
+    canSendUpdate() {
+        if (!this.hasDataListeners() || this.paused)
+            return false;
+        return super.canSendUpdate();
+    }
+    mapToCycleModeData(deviceData) {
         const data = {
             isPedalling: false,
             power: 0,
@@ -169,13 +179,16 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
     }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.started)
+            const wasPaused = this.paused;
+            this.paused = false;
+            if (this.started && !wasPaused) {
                 return true;
+            }
             const connected = yield this.connect();
             if (!connected)
                 throw new Error(`could not start device, reason:could not connect`);
             this.startProps = props;
-            this.logEvent({ message: 'starting device -', props, isStarted: this.started, isReconnecting: this.isReconnecting });
+            this.logEvent({ message: 'starting device', props, isStarted: this.started, isReconnecting: this.isReconnecting });
             const opts = props || {};
             const { args = {}, user = {} } = opts;
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -218,7 +231,7 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
                                 }
                                 catch (_a) { }
                                 this.started = false;
-                                return reject(new Error(`could not start device, reason: ${err.message}`));
+                                return reject(new Error('could not start device, reason:timeout'));
                             }
                         }
                         status = { userSent: false, slopeSent: false };
@@ -236,7 +249,22 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
                             const userWeight = args.userWeight || user.weight || adpater_1.DEFAULT_USER_WEIGHT;
                             const bikeWeight = args.bikeWeight || defaultBikeWeight;
                             status.userSent = status.userSent || (yield fe.sendUserConfiguration(userWeight, bikeWeight, args.wheelDiameter, args.gearRatio));
-                            status.slopeSent = status.slopeSent || (yield fe.sendTrackResistance(0.0));
+                            if (!status.slopeSent) {
+                                const startRequest = this.getCyclingMode().getBikeInitRequest();
+                                if (startRequest) {
+                                    if (startRequest.targetPower !== undefined && startRequest.targetPower !== null) {
+                                        status.slopeSent = yield fe.sendTargetPower(startRequest.targetPower);
+                                    }
+                                    else if (startRequest.slope !== undefined && startRequest.slope !== null) {
+                                        status.slopeSent = yield fe.sendTrackResistance(startRequest.slope);
+                                    }
+                                    else
+                                        status.slopeSent = true;
+                                }
+                                else {
+                                    status.slopeSent = yield fe.sendTrackResistance(0.0);
+                                }
+                            }
                         }
                         catch (err) {
                             this.logger.logEvent({ message: 'sending FE message error', error: err.message });
@@ -294,6 +322,18 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
             }
         });
     }
+    setCyclingMode(mode, settings) {
+        const modeChange = this.cyclingMode.getName() !== mode;
+        super.setCyclingMode(mode, settings);
+        console.log('~~~ setCyclingMode', mode, modeChange, this.started, this.stopped, this.paused, this.isReconnecting, this.data);
+        if (modeChange && this.started && !this.stopped) {
+            if (this.getCyclingMode() instanceof ant_fe_erg_mode_1.default) {
+                const power = this.data.power;
+                const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
+                this.sendUpdate(request, true);
+            }
+        }
+    }
 }
 exports.default = AntFEAdapter;
 AntFEAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';

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

@@ -1,14 +1,15 @@
-import { HeartRateSensorState, ISensor } from "incyclist-ant-plus";
+import { HeartRateSensorState, ISensor, Profile } from "incyclist-ant-plus";
 import AntAdapter from "../adapter";
-import { AntDeviceProperties, AntDeviceSettings } from "../types";
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
 export default class AntHrAdapter extends AntAdapter {
-    static INCYCLIST_PROFILE_NAME: string;
-    static ANT_PROFILE_NAME: string;
+    static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    static ANT_PROFILE_NAME: Profile;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
     createSensor(settings: AntDeviceSettings): ISensor;
     getName(): string;
+    getUniqueName(): string;
     getDisplayName(): string;
     onDeviceData(deviceData: HeartRateSensorState): void;
-    updateData(data: any, deviceData: any): any;
+    mapData(deviceData: HeartRateSensorState): void;
     hasData(): boolean;
 }

package/lib/antv2/hr/adapter.js

@@ -30,14 +30,20 @@ class AntHrAdapter extends adapter_1.default {
         const deviceID = this.sensor.getDeviceID();
         return `Ant+HR ${deviceID}`;
     }
-    getDisplayName() {
-        const { DeviceID, ManId, ComputedHeartRate } = this.deviceData;
-        const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
+    getUniqueName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const { DeviceID, ManId } = this.deviceData;
         const brand = (0, utils_1.getBrand)(ManId);
         if (brand)
-            return `${brand} Hrm ${DeviceID}${hrmStr}`;
+            return `${brand} HR ${DeviceID}`;
         else
-            return `${this.getName()}${hrmStr}`;
+            return `${this.getName()}`;
+    }
+    getDisplayName() {
+        const { ComputedHeartRate } = this.deviceData;
+        const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
+        return `${this.getUniqueName()}${hrmStr}`;
     }
     onDeviceData(deviceData) {
         this.dataMsgCount++;
@@ -48,21 +54,18 @@ class AntHrAdapter extends adapter_1.default {
         if (!this.ivDataTimeout)
             this.startDataTimeoutCheck();
         try {
-            if (this.onDataFn && !this.paused) {
-                if (this.lastUpdate === undefined || (Date.now() - this.lastUpdate) > this.updateFrequency) {
-                    this.logEvent({ message: 'onDeviceData', data: deviceData });
-                    const data = this.updateData(this.data, deviceData);
-                    this.onDataFn(data);
-                    this.lastUpdate = Date.now();
-                }
-            }
+            if (!this.canSendUpdate())
+                return;
+            this.logEvent({ message: 'onDeviceData', data: deviceData });
+            this.mapData(deviceData);
+            this.emitData(this.data);
         }
         catch (err) {
         }
     }
-    updateData(data, deviceData) {
-        data.heartrate = deviceData.ComputedHeartRate;
-        return data;
+    mapData(deviceData) {
+        if (deviceData.ComputedHeartRate)
+            this.data.heartrate = deviceData.ComputedHeartRate;
     }
     hasData() {
         return this.deviceData.ComputedHeartRate !== undefined && this.deviceData.ComputedHeartRate !== null;

package/lib/antv2/index.d.ts

@@ -2,6 +2,6 @@ import AntPwrAdapter from "./pwr";
 import AntFEAdapter from "./fe";
 import AntHrAdapter from "./hr";
 import AntAdapterFactory from "./adapter-factory";
-import AntInterface from "./ant-interface";
+import AntInterface, { AntInterfaceProps } from "./ant-interface";
 import { AntDeviceSettings, AntScanProps } from "./types";
-export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntDeviceSettings, AntScanProps, AntInterface };
+export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntDeviceSettings, AntScanProps, AntInterface, AntInterfaceProps };

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

@@ -1,20 +1,22 @@
-import { ISensor } from "incyclist-ant-plus";
+import { ISensor, Profile } from "incyclist-ant-plus";
 import { ControllableAntAdapter } from "../adapter";
 import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
-import { AntDeviceProperties, AntDeviceSettings } from "../types";
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
 import { DeviceData } from "../../types/data";
 export default class AntPwrAdapter extends ControllableAntAdapter {
-    static INCYCLIST_PROFILE_NAME: string;
-    static ANT_PROFILE_NAME: string;
+    static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    static ANT_PROFILE_NAME: Profile;
     protected distanceInternal?: number;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
     createSensor(settings: AntDeviceSettings): ISensor;
     getName(): string;
+    getUniqueName(): string;
     getDisplayName(): string;
     getDefaultCyclingMode(): CyclingMode;
     getSupportedCyclingModes(): any[];
     getLogData(data: any, excludeList: any): any;
     onDeviceData(deviceData: any): void;
+    canSendUpdate(): boolean;
     sendUpdate(request: any): void;
     mapData(deviceData: any): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): DeviceData;

package/lib/antv2/pwr/adapter.js

@@ -33,14 +33,20 @@ class AntPwrAdapter extends adapter_1.ControllableAntAdapter {
         const deviceID = this.sensor.getDeviceID();
         return `Ant+PWR ${deviceID}`;
     }
-    getDisplayName() {
-        const { DeviceID, ManId, Power } = this.deviceData;
-        const pwrStr = Power ? ` (${Power})` : '';
+    getUniqueName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const { DeviceID, ManId } = this.deviceData;
         const brand = (0, utils_1.getBrand)(ManId);
         if (brand)
-            return `${brand} PWR ${DeviceID}${pwrStr}`;
+            return `${brand} PWR ${DeviceID}`;
         else
-            return `${this.getName()}${pwrStr}`;
+            return `${this.getName()}`;
+    }
+    getDisplayName() {
+        const { Power } = this.deviceData;
+        const pwrStr = Power ? ` (${Power})` : '';
+        return `${this.getUniqueName()}${pwrStr}`;
     }
     getDefaultCyclingMode() {
         return new power_meter_1.default(this);
@@ -64,21 +70,23 @@ class AntPwrAdapter extends adapter_1.ControllableAntAdapter {
         if (!this.ivDataTimeout)
             this.startDataTimeoutCheck();
         try {
-            if (this.onDataFn && !this.paused) {
-                if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
-                    const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
-                    this.logger.logEvent({ message: 'onDeviceData', data: logData });
-                    let incyclistData = this.mapData(deviceData);
-                    incyclistData = this.getCyclingMode().updateData(incyclistData);
-                    const data = this.transformData(incyclistData);
-                    this.onDataFn(data);
-                    this.lastUpdate = Date.now();
-                }
-            }
+            if (!this.canSendUpdate())
+                return;
+            const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
+            this.logger.logEvent({ message: 'onDeviceData', data: logData });
+            let incyclistData = this.mapData(deviceData);
+            incyclistData = this.getCyclingMode().updateData(incyclistData);
+            const data = this.transformData(incyclistData);
+            this.emitData(data);
         }
         catch (err) {
         }
     }
+    canSendUpdate() {
+        if (!this.hasDataListeners() || this.paused)
+            return false;
+        return super.canSendUpdate();
+    }
     sendUpdate(request) {
         if (this.isPaused())
             return;

package/lib/antv2/sensor-factory.d.ts

@@ -1,5 +1,5 @@
-import { ISensor } from "incyclist-ant-plus";
+import { ISensor, Profile } from "incyclist-ant-plus";
 export default class SensorFactory {
-    static create(profile: string, deviceID?: number): ISensor;
+    static create(profile: Profile, deviceID?: number): ISensor;
     static createAll(): ISensor[];
 }

package/lib/antv2/types.d.ts

@@ -1,14 +1,17 @@
+import { Profile } from 'incyclist-ant-plus';
 import IncyclistDevice from '../base/adpater';
 import { DeviceProperties, DeviceSettings, IncyclistScanProps } from '../types/device';
 export interface AntDeviceSettings extends DeviceSettings {
     deviceID?: string;
-    profile: string;
+    profile: Profile | LegacyProfile;
     protocol?: string;
 }
+export type LegacyProfile = 'Heartrate Monitor' | 'Power Meter' | 'Smart Trainer' | 'Speed Sensor' | 'Cadence Sensor' | 'Speed + Cadence Sensor';
+export declare const isLegacyProfile: (o: unknown) => boolean;
 export type DeviceFoundCallback = (device: IncyclistDevice, protocol: string) => void;
 export type ScanFinishedCallback = (id: number) => void;
 export interface AntScanProps extends IncyclistScanProps {
-    profiles?: string[];
+    profiles?: Profile[];
     id?: number;
     onDeviceFound?: DeviceFoundCallback;
     onScanFinished?: ScanFinishedCallback;

package/lib/antv2/types.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLegacyProfile = void 0;
+const isLegacyProfile = (o) => o === 'Heartrate Monitor' || o === 'Power Meter' || o === 'Smart Trainer' || o === 'Speed Sensor' || o === 'Cadence Sensor' || o === 'Speed + Cadence Sensor';
+exports.isLegacyProfile = isLegacyProfile;

package/lib/antv2/utils.d.ts

@@ -1 +1,4 @@
+import { Profile } from "incyclist-ant-plus";
+import { LegacyProfile } from "./types";
 export declare const getBrand: (manId: number) => string;
+export declare const mapLegacyProfile: (legacy: LegacyProfile) => Profile;

package/lib/antv2/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBrand = void 0;
+exports.mapLegacyProfile = exports.getBrand = void 0;
 const brands = [
     'Garmin,1',
     'garmin_fr405_antfs,2',
@@ -179,3 +179,14 @@ const getBrand = (manId) => {
     return;
 };
 exports.getBrand = getBrand;
+const mapLegacyProfile = (legacy) => {
+    switch (legacy) {
+        case 'Heartrate Monitor': return 'HR';
+        case 'Power Meter': return 'PWR';
+        case 'Smart Trainer': return 'FE';
+        case 'Cadence Sensor': return 'CAD';
+        case 'Speed Sensor': return 'SPD';
+        case 'Speed + Cadence Sensor': return 'SC';
+    }
+};
+exports.mapLegacyProfile = mapLegacyProfile;

package/lib/base/adpater.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="node" />
-import { EventEmitter } from "stream";
 import CyclingMode from "../modes/cycling-mode";
 import { DeviceProperties, DeviceSettings } from "../types/device";
 import { Bike, IncyclistDeviceAdapter, OnDeviceDataCallback } from '../types/adapter';
 import { User } from "../types/user";
 import { IncyclistCapability } from "../types/capabilities";
 import { EventLogger } from "gd-eventlog";
+import { DeviceData } from "../types/data";
+import EventEmitter from "events";
 export declare const DEFAULT_BIKE_WEIGHT = 10;
 export declare const DEFAULT_USER_WEIGHT = 75;
 export declare const DEFAULT_PROPS: DeviceProperties;
@@ -13,6 +14,8 @@ export default class IncyclistDevice extends EventEmitter implements IncyclistDe
     onDataFn: OnDeviceDataCallback;
     settings: DeviceSettings;
     props: DeviceProperties;
+    lastUpdate?: number;
+    updateFrequency: number;
     capabilities: IncyclistCapability[];
     protected logger: EventLogger;
     started: boolean;
@@ -22,30 +25,39 @@ export default class IncyclistDevice extends EventEmitter implements IncyclistDe
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     check(): Promise<boolean>;
-    isEqual(settings: DeviceSettings): void;
+    isControllable(): boolean;
+    isEqual(settings: DeviceSettings): boolean;
     getCapabilities(): IncyclistCapability[];
     hasCapability(capability: IncyclistCapability): boolean;
+    addCapability(capability: IncyclistCapability): void;
     update(): void;
     start(props?: DeviceProperties): Promise<boolean>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
     logEvent(event: any): void;
+    getMaxUpdateFrequency(): number;
+    setMaxUpdateFrequency(value: number): void;
     sendUpdate(request: any): void;
     getID(): string;
     getDisplayName(): string;
     getName(): string;
+    getUniqueName(): string;
     getSettings(): DeviceSettings;
     getInterface(): string;
     onData(callback: OnDeviceDataCallback): void;
+    canSendUpdate(): boolean;
+    emitData(data: DeviceData): void;
     isStopped(): boolean;
     isStarted(): boolean;
     isPaused(): boolean;
+    hasDataListeners(): boolean | OnDeviceDataCallback;
 }
 export declare class ControllableDevice extends IncyclistDevice implements Bike {
     cyclingMode: CyclingMode;
     user?: User;
     constructor(settings: DeviceSettings, props?: DeviceProperties);
+    isControllable(): boolean;
     setUser(user: User): void;
     setBikeProps(props: DeviceProperties): void;
     getWeight(): number;

package/lib/base/adpater.js

@@ -8,16 +8,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllableDevice = exports.DEFAULT_PROPS = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
-const stream_1 = require("stream");
+const events_1 = __importDefault(require("events"));
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
 exports.DEFAULT_PROPS = {
     userWeight: exports.DEFAULT_USER_WEIGHT,
     bikeWeight: exports.DEFAULT_BIKE_WEIGHT
 };
-class IncyclistDevice extends stream_1.EventEmitter {
+class IncyclistDevice extends events_1.default {
     constructor(settings, props) {
         super();
         this.onDataFn = undefined;
@@ -31,11 +34,18 @@ class IncyclistDevice extends stream_1.EventEmitter {
     connect() { throw new Error('not implemented'); }
     close() { throw new Error('not implemented'); }
     check() { throw new Error("Method not implemented."); }
+    isControllable() {
+        return false;
+    }
     isEqual(settings) { throw new Error("Method not implemented."); }
     getCapabilities() { return this.capabilities; }
     hasCapability(capability) {
         return this.capabilities.find(c => c === capability) !== undefined;
     }
+    addCapability(capability) {
+        if (!this.capabilities.includes(capability))
+            this.capabilities.push(capability);
+    }
     update() { throw new Error("Method not implemented."); }
     start(props) { throw new Error("Method not implemented."); }
     stop() { throw new Error("Method not implemented."); }
@@ -52,10 +62,16 @@ class IncyclistDevice extends stream_1.EventEmitter {
         });
     }
     logEvent(event) {
-        if (!this.logger)
+        if (!this.logger || this.paused)
             return;
         this.logger.logEvent(event);
     }
+    getMaxUpdateFrequency() {
+        return this.updateFrequency;
+    }
+    setMaxUpdateFrequency(value) {
+        this.updateFrequency = value;
+    }
     sendUpdate(request) { throw new Error("Method not implemented."); }
     getID() { throw new Error('not implemented'); }
     getDisplayName() {
@@ -64,6 +80,9 @@ class IncyclistDevice extends stream_1.EventEmitter {
     getName() {
         return this.settings.name;
     }
+    getUniqueName() {
+        throw new Error("Method not implemented.");
+    }
     getSettings() {
         return this.settings;
     }
@@ -73,6 +92,20 @@ class IncyclistDevice extends stream_1.EventEmitter {
     onData(callback) {
         this.onDataFn = callback;
     }
+    canSendUpdate() {
+        const updateFrequency = this.getMaxUpdateFrequency();
+        if (updateFrequency === -1 || updateFrequency === undefined)
+            return true;
+        return (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+    }
+    emitData(data) {
+        if (!this.canSendUpdate())
+            return;
+        if (this.onDataFn)
+            this.onDataFn(data);
+        this.emit('data', this.getSettings(), data);
+        this.lastUpdate = Date.now();
+    }
     isStopped() {
         return this.stopped;
     }
@@ -82,6 +115,9 @@ class IncyclistDevice extends stream_1.EventEmitter {
     isPaused() {
         return this.paused;
     }
+    hasDataListeners() {
+        return this.onDataFn || this.listenerCount('data') > 0;
+    }
 }
 exports.default = IncyclistDevice;
 class ControllableDevice extends IncyclistDevice {
@@ -90,13 +126,16 @@ class ControllableDevice extends IncyclistDevice {
         this.cyclingMode = this.getDefaultCyclingMode();
         this.user = {};
     }
+    isControllable() {
+        return true;
+    }
     setUser(user) {
         this.user = user;
         if (!user.weight)
             this.user.weight = exports.DEFAULT_USER_WEIGHT;
     }
     setBikeProps(props) {
-        const { user, userWeight, bikeWeight } = props || {};
+        const { user, userWeight } = props || {};
         if (user)
             this.setUser(user);
         if (userWeight)

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

@@ -1,31 +1,33 @@
 import { DeviceProperties } from "../types/device";
-import { BleComms } from "./ble-comms";
-import BleAdapter from "./adapter";
-import { BleDeviceSettings } from "./types";
+import BleAdapter from "./base/adapter";
+import { BleDeviceSettings, BleProtocol } from "./types";
+import { BleComms } from "./base/comms";
 export interface BleAdapterInfo {
-    protocol: string;
-    profile: string;
+    protocol: BleProtocol;
     Adapter: typeof BleAdapter;
     Comm: typeof BleComms;
 }
-export declare function mapLegacyProfile(profile: any): {
-    profile: any;
-    protocol: string;
-};
 export default class BleAdapterFactory {
     static _instance: BleAdapterFactory;
-    adapters: BleAdapterInfo[];
+    implementations: BleAdapterInfo[];
+    instances: BleAdapter[];
     static getInstance(): BleAdapterFactory;
     constructor();
-    getAdapter(protocol: string): BleAdapterInfo;
-    getAllAdapters(): BleAdapterInfo[];
+    getAdapterInfo(protocol: BleProtocol): BleAdapterInfo;
+    getAll(): BleAdapterInfo[];
     createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter;
-    register(protocol: string, profile: string, Adapter: typeof BleAdapter, Comm: typeof BleComms): void;
-    getAllSupportedDeviceTypes(): (typeof BleComms)[];
+    removeInstance(query: {
+        settings?: BleDeviceSettings;
+        adapter?: BleAdapter;
+    }): void;
+    find(settings?: BleDeviceSettings): BleAdapter;
+    register(protocol: BleProtocol, Adapter: typeof BleAdapter, Comm: typeof BleComms): void;
+    getAllInstances(): BleAdapter[];
+    getAllSupportedComms(): (typeof BleComms)[];
+    getAllSupportedAdapters(): (typeof BleAdapter)[];
     getAllSupportedServices(): string[];
     getDeviceClasses(peripheral: any, props?: {
-        deviceTypes?: (typeof BleComms)[];
-        profile?: string;
+        protocol?: BleProtocol;
         services?: string[];
     }): (typeof BleComms)[];
 }