incyclist-devices 2.1.0 → 2.1.1

package/lib/antv2/fe/adapter.js

@@ -12,47 +12,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AntFeControl = void 0;
-const adapter_1 = __importDefault(require("../adapter"));
-const utils_1 = require("../utils");
-const gd_eventlog_1 = require("gd-eventlog");
+const adapter_1 = __importDefault(require("../base/adapter"));
 const ant_fe_adv_st_mode_1 = __importDefault(require("../../modes/ant-fe-adv-st-mode"));
-const utils_2 = require("../../utils/utils");
-const sensor_factory_1 = __importDefault(require("../sensor-factory"));
+const utils_1 = require("../../utils/utils");
 const capabilities_1 = require("../../types/capabilities");
-const adpater_1 = require("../../base/adpater");
+const consts_1 = require("../../base/consts");
 const antble_erg_1 = __importDefault(require("../../modes/antble-erg"));
 const antble_smarttrainer_1 = __importDefault(require("../../modes/antble-smarttrainer"));
 const DEFAULT_BIKE_WEIGHT_MOUNTAIN = 14.5;
 const MAX_RETRIES = 3;
-class AntFeControl extends adpater_1.ControllableDevice {
-    getSupportedCyclingModes() {
-        return [antble_smarttrainer_1.default, antble_erg_1.default, ant_fe_adv_st_mode_1.default];
-    }
-    getDefaultCyclingMode() {
-        return new antble_smarttrainer_1.default(this.adapter);
-    }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
-    }
-}
-exports.AntFeControl = AntFeControl;
 class AntFEAdapter extends adapter_1.default {
     constructor(settings, props) {
-        if (settings.protocol && settings.profile !== AntFEAdapter.INCYCLIST_PROFILE_NAME)
-            throw new Error('Incorrect Profile');
-        if (!settings.protocol && settings.profile !== AntFEAdapter.ANT_PROFILE_NAME)
-            throw new Error('Incorrect Profile');
         super(settings, props);
-        this.setControl(new AntFeControl(this, props));
-        this.deviceData = {
-            DeviceID: this.sensor.getDeviceID()
-        };
-        this.dataMsgCount = 0;
-        this.logger = new gd_eventlog_1.EventLogger('Ant+FE');
-        this.isReconnecting = false;
         this.startProps = {};
         this.sensorConnected = false;
         this.capabilities = [
@@ -60,46 +31,23 @@ class AntFEAdapter extends adapter_1.default {
             capabilities_1.IncyclistCapability.Control
         ];
     }
-    createSensor(settings) {
-        const sensor = sensor_factory_1.default.create(AntFEAdapter.ANT_PROFILE_NAME, Number(settings.deviceID));
-        return sensor;
-    }
-    getName() {
-        if (this.settings.name)
-            return this.settings.name;
-        const deviceID = this.sensor.getDeviceID();
-        return `Ant+FE ${deviceID}`;
-    }
-    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}`;
-        else
-            return `${this.getName()}`;
-    }
     getDisplayName() {
         const { InstantaneousPower } = this.deviceData;
         const pwrStr = InstantaneousPower ? ` (${InstantaneousPower})` : '';
         return `${this.getUniqueName()}${pwrStr}`;
     }
-    getLogData(data, excludeList) {
-        const logData = JSON.parse(JSON.stringify(data));
-        excludeList.forEach((key) => {
-            delete logData[key];
-        });
-        return logData;
+    getDefaultReconnectDelay() {
+        return 2000;
+    }
+    isReconnecting() {
+        return this.promiseReconnect !== null && this.promiseReconnect !== undefined;
     }
     sendUpdate(request, forced = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if ((this.paused || this.isReconnecting) && !forced)
+            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;
             this.logEvent({ message: 'send bike update requested', update, request });
             try {
                 const fe = this.sensor;
@@ -122,200 +70,226 @@ class AntFEAdapter extends adapter_1.default {
         });
     }
     onDeviceData(deviceData) {
-        this.dataMsgCount++;
-        this.lastDataTS = Date.now();
         super.onDeviceData(deviceData);
-        if (!this.started || this.isStopped())
-            return;
-        if (!this.ivDataTimeout && this.dataMsgCount > 0) {
-            this.startDataTimeoutCheck();
-        }
-        try {
-            const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
-            this.logEvent({ message: 'onDeviceData', data: logData, paused: this.paused });
-            if (!this.canSendUpdate())
-                return;
-            let incyclistData = this.mapToCycleModeData(deviceData);
-            incyclistData = this.getCyclingMode().updateData(incyclistData);
-            this.data = this.transformData(incyclistData);
-            this.emitData(this.data);
+        if (deviceData.HeartRate && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
+            this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
+            this.emit('device-info', this.getSettings(), { capabilities: this.capabilities });
         }
-        catch (err) {
-            this.logEvent({ message: 'error', fn: 'onDeviceData()', error: err.message || err, stack: err.stack });
-        }
-    }
-    canSendUpdate() {
-        if (!this.hasDataListeners() || this.paused)
-            return false;
-        return super.canSendUpdate();
     }
-    mapToCycleModeData(deviceData) {
+    mapData(deviceData) {
         const data = {
             isPedalling: false,
             power: 0,
-            pedalRpm: undefined,
+            pedalRpm: 0,
             speed: 0,
-            heartrate: 0,
-            distanceInternal: 0,
-            slope: undefined,
-            time: undefined
         };
         data.speed = (deviceData.VirtualSpeed !== undefined ? deviceData.VirtualSpeed : (deviceData.RealSpeed || 0)) * 3.6;
         data.slope = (deviceData.Incline !== undefined ? deviceData.Incline : data.slope);
         data.power = (deviceData.InstantaneousPower !== undefined ? deviceData.InstantaneousPower : data.power);
-        data.time = (deviceData.ElapsedTime !== undefined ? deviceData.ElapsedTime : data.time);
         data.pedalRpm = (deviceData.Cadence !== undefined ? deviceData.Cadence : data.pedalRpm);
-        data.isPedalling = data.pedalRpm > 0 || (data.pedalRpm === undefined && data.power > 0);
+        data.isPedalling = data.pedalRpm > 0 || data.power > 0;
+        if (deviceData.HeartRate !== undefined)
+            data.heartrate = deviceData.HeartRate;
+        if (deviceData.Distance !== undefined)
+            data.distanceInternal = deviceData.Distance;
+        if (deviceData.ElapsedTime !== undefined)
+            data.time = deviceData.ElapsedTime;
         return data;
     }
-    transformData(bikeData) {
-        if (bikeData === undefined)
-            return;
-        let distance = 0;
-        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
-            distance = bikeData.distanceInternal - this.distanceInternal;
-        }
-        if (bikeData.distanceInternal !== undefined)
-            this.distanceInternal = bikeData.distanceInternal;
-        const data = {
-            speed: bikeData.speed,
-            slope: bikeData.slope,
-            power: bikeData.power !== undefined ? Math.round(bikeData.power) : undefined,
-            cadence: bikeData.pedalRpm !== undefined ? Math.round(bikeData.pedalRpm) : undefined,
-            heartrate: bikeData.heartrate !== undefined ? Math.round(bikeData.heartrate) : undefined,
-            distance,
+    transformData(adapterData, deviceData) {
+        const data = Object.assign(this.data, {
+            power: adapterData.power,
+            speed: adapterData.speed,
+            cadence: adapterData.pedalRpm,
             timestamp: Date.now()
-        };
-        return data;
+        });
+        if (adapterData.distanceInternal !== undefined) {
+            if (data.internalDistanceCounter !== undefined)
+                data.distance = adapterData.distanceInternal - data.internalDistanceCounter;
+            data.internalDistanceCounter = adapterData.distanceInternal;
+        }
+        if (deviceData.Distance)
+            data.deviceDistanceCounter = deviceData.Distance;
+        if (adapterData.heartrate)
+            data.heartrate = adapterData.heartrate;
+        if (adapterData.slope)
+            data.slope = adapterData.slope;
+        if (adapterData.time)
+            data.deviceTime = adapterData.time;
+        this.data = data;
     }
     start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isReconnect = (props === null || props === void 0 ? void 0 : props.reconnect) || false;
+            const startProps = Object.assign({}, props || {});
+            delete startProps.reconnect;
+            return yield this.performStart(props, isReconnect);
+        });
+    }
+    performStart(props, isReconnect) {
         return __awaiter(this, void 0, void 0, function* () {
             const wasPaused = this.paused;
             const wasStopped = this.stopped;
-            this.startProps = props || {};
+            this.startProps = props;
             if (wasPaused)
                 this.resume();
-            if (wasStopped)
-                this.stopped = false;
+            this.stopped = false;
             if (this.started && !wasPaused && !wasStopped) {
                 return true;
             }
             const connected = yield this.connect();
             if (!connected)
                 throw new Error(`could not start device, reason:could not connect`);
-            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* () {
-                const { startupTimeout = 20000, reconnectTimeout = 2000 } = props || {};
-                const totalTimeout = Math.min(startupTimeout + 10000, startupTimeout * 2);
-                let to, timeoutOccured = false;
-                const stopTimeoutCheck = () => {
-                    if (to) {
-                        clearTimeout(to);
-                        to = null;
-                    }
-                };
-                to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    reject(new Error(`could not start device, reason:timeout`));
-                    this.started = false;
-                    to = null;
-                    timeoutOccured = true;
-                }), totalTimeout);
+            this.logEvent({ message: 'starting device', props, isStarted: this.started, isReconnecting: isReconnect });
+            const { startupTimeout = this.getDefaultStartupTimeout(), reconnectTimeout = this.getDefaultReconnectDelay() } = props || {};
+            const totalTimeout = Math.min(startupTimeout + 10000, startupTimeout * 2);
+            let status = { timeout: false, sensorStarted: false, hasData: false, userSent: false, slopeSent: false };
+            const doStart = () => __awaiter(this, void 0, void 0, function* () {
                 this.setFEDefaultTimeout();
                 let success = false;
-                let status = { userSent: false, slopeSent: false };
                 let retry = 0;
-                let hasData = false;
-                while (!success && retry < MAX_RETRIES && !timeoutOccured) {
-                    retry++;
-                    if (!this.sensorConnected) {
-                        this.logEvent({ message: 'start sensor', props });
-                        this.sensorConnected = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
-                        if (this.sensorConnected) {
-                            this.logEvent({ message: 'sensor started', props });
-                        }
-                    }
-                    if (this.sensorConnected && !hasData) {
-                        try {
-                            yield this.waitForData(startupTimeout);
-                            hasData = true;
-                        }
-                        catch (err) {
-                            stopTimeoutCheck();
-                            try {
-                                yield yield this.ant.stopSensor(this.sensor);
-                                this.sensorConnected = false;
-                            }
-                            catch (_a) { }
-                            this.started = false;
-                            return reject(new Error('could not start device, reason:no data received'));
-                        }
+                if (isReconnect) {
+                    status.userSent = true;
+                    status.slopeSent = true;
+                }
+                while (!success && retry < MAX_RETRIES && !status.timeout) {
+                    if (retry !== 0) {
+                        console.log('~~~ RETRY', status);
                     }
-                    status = { userSent: false, slopeSent: false };
-                    if (!hasData) {
-                        yield (0, utils_2.sleep)(reconnectTimeout);
+                    retry++;
+                    yield this.initSensor(status, props);
+                    yield this.waitForInitialData(status, startupTimeout);
+                    yield this.sendInititalUserMessage(status, props);
+                    yield this.sendInitialRequest(status, props);
+                    if (!status.hasData) {
+                        yield this.stopSensor();
+                        yield (0, utils_1.sleep)(reconnectTimeout);
                         continue;
                     }
-                    if (!this.isReconnecting) {
-                        try {
-                            const fe = this.sensor;
-                            const mode = this.getCyclingMode();
-                            const bikeType = mode ? mode.getSetting('bikeType').toLowerCase() : 'race';
-                            const defaultBikeWeight = bikeType === 'mountain' ? DEFAULT_BIKE_WEIGHT_MOUNTAIN : adpater_1.DEFAULT_BIKE_WEIGHT;
-                            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));
-                            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.logEvent({ message: 'sending FE message error', error: err.message });
-                            this.started = false;
-                        }
-                        success = status.userSent && status.slopeSent;
-                    }
-                    else {
-                        success = true;
-                    }
+                    success = status.sensorStarted && status.hasData && status.userSent && status.slopeSent;
                 }
                 if (success) {
                     this.logEvent({ message: 'ANT FE start success' });
                     this.started = true;
                     this.paused = false;
-                    stopTimeoutCheck();
-                    resolve(true);
+                    return true;
                 }
                 else {
-                    this.logEvent({ message: 'ANT FE start failed' });
-                    stopTimeoutCheck();
-                    if (!hasData) {
-                        reject(new Error('could not start device, reason: no data received'));
+                    this.started = false;
+                    if (!status.sensorStarted) {
+                        this.logEvent({ message: 'ANT FE start failed', reason: 'could not connect' });
+                        throw new Error('could not start device, reason:could not connect');
                     }
-                    else if (this.sensorConnected) {
-                        reject(new Error('could not start device, reason: could not send FE commands'));
+                    else if (!status.hasData) {
+                        this.logEvent({ message: 'ANT FE start failed', reason: 'no data received' });
+                        throw new Error('could not start device, reason:no data received');
                     }
                     else {
-                        reject(new Error('could not start device, reason: could not connect'));
+                        this.logEvent({ message: 'ANT FE start failed', reason: 'could not send FE commands' });
+                        throw new Error('could not start device, reason:could not send FE commands');
                     }
+                }
+            });
+            try {
+                yield (0, utils_1.runWithTimeout)(doStart(), totalTimeout);
+            }
+            catch (err) {
+                if (err.message === 'Timeout') {
                     this.started = false;
+                    status.timeout = true;
+                    throw new Error(`could not start device, reason:timeout`);
                 }
-            }));
+                throw err;
+            }
+            return true;
+        });
+    }
+    waitForInitialData(status, startupTimeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((status.sensorStarted && status.hasData) || !status.sensorStarted || status.timeout)
+                return;
+            this.logEvent({ message: 'wait for sensor data', });
+            status.hasData = yield this.waitForData(startupTimeout);
+            if (status.hasData)
+                this.logEvent({ message: 'sensor data received', });
+        });
+    }
+    stopSensor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sensorConnected)
+                return;
+            try {
+                yield yield this.ant.stopSensor(this.sensor);
+                this.sensorConnected = false;
+            }
+            catch (_a) { }
+        });
+    }
+    initSensor(status, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            status.sensorStarted = this.sensorConnected;
+            if (status.sensorStarted || status.timeout)
+                return;
+            this.logEvent({ message: 'start sensor', props });
+            try {
+                this.sensorConnected = yield this.startSensor();
+                if (this.sensorConnected) {
+                    this.logEvent({ message: 'sensor started', props });
+                    status.sensorStarted = true;
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'start sensor failed', reason: err.message, props });
+            }
+        });
+    }
+    sendInititalUserMessage(status, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!status.sensorStarted || !status.hasData || status.userSent || status.timeout)
+                return;
+            const opts = props || {};
+            const { args = {}, user = {} } = opts;
+            const fe = this.sensor;
+            try {
+                const mode = this.getCyclingMode();
+                const bikeType = mode ? mode.getSetting('bikeType').toLowerCase() : 'race';
+                const defaultBikeWeight = bikeType === 'mountain' ? DEFAULT_BIKE_WEIGHT_MOUNTAIN : consts_1.DEFAULT_BIKE_WEIGHT;
+                const userWeight = args.userWeight || user.weight || consts_1.DEFAULT_USER_WEIGHT;
+                const bikeWeight = args.bikeWeight || defaultBikeWeight;
+                status.userSent = status.userSent || (yield fe.sendUserConfiguration(userWeight, bikeWeight, args.wheelDiameter, args.gearRatio));
+            }
+            catch (err) {
+                this.logEvent({ message: 'sending FE message error', error: err.message });
+                status.userSent = false;
+            }
+        });
+    }
+    sendInitialRequest(status, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!status.sensorStarted || !status.hasData || status.slopeSent || status.timeout)
+                return;
+            const fe = this.sensor;
+            try {
+                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.logEvent({ message: 'sending FE message error', error: err.message });
+                status.slopeSent = false;
+            }
         });
     }
     setFEDefaultTimeout() {
@@ -330,20 +304,26 @@ class AntFEAdapter extends adapter_1.default {
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'reconnect to device' });
-            this.isReconnecting = true;
-            try {
-                yield this.stop();
-                yield this.start(this.startProps);
-                this.started = true;
-                this.isReconnecting = false;
-                this.logEvent({ message: 'reconnect success' });
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'reconnect failed' });
-                this.isReconnecting = false;
-                return false;
+            if (this.promiseReconnect) {
+                return yield this.promiseReconnect;
             }
+            const doReconnect = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.stop();
+                    yield this.performStart(this.startProps, true);
+                    this.started = true;
+                    this.logEvent({ message: 'reconnect success' });
+                    return true;
+                }
+                catch (err) {
+                    this.logEvent({ message: 'reconnect failed' });
+                    return false;
+                }
+            });
+            this.promiseReconnect = doReconnect();
+            const res = yield this.promiseReconnect;
+            this.promiseReconnect = null;
+            return res;
         });
     }
     sendInitCommands() {
@@ -357,16 +337,19 @@ class AntFEAdapter extends adapter_1.default {
                         return true;
                     }
                 }
-                catch (_a) {
+                catch (err) {
+                    console.log(err);
                     return false;
                 }
             }
-            else {
-                return false;
-            }
+            return false;
         });
     }
 }
 AntFEAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
 AntFEAdapter.ANT_PROFILE_NAME = 'FE';
+AntFEAdapter.controllers = {
+    modes: [antble_smarttrainer_1.default, antble_erg_1.default, ant_fe_adv_st_mode_1.default],
+    default: antble_smarttrainer_1.default
+};
 exports.default = AntFEAdapter;

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

@@ -1,20 +1,11 @@
-import { HeartRateSensorState, ISensor, Profile } from "incyclist-ant-plus";
-import AntAdapter from "../adapter";
+import { HeartRateSensorState, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
-import { NonControllableDevice } from "../../base/adpater";
-type HeartRateSensorData = {
-    heartrate: number;
-};
-export default class AntHrAdapter extends AntAdapter<NonControllableDevice<AntDeviceProperties>, HeartRateSensorState, HeartRateSensorData> {
-    static INCYCLIST_PROFILE_NAME: LegacyProfile;
-    static ANT_PROFILE_NAME: Profile;
+export default class AntHrAdapter extends AntAdapter<HeartRateSensorState> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static ANT_PROFILE_NAME: Profile;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    createSensor(settings: AntDeviceSettings): ISensor;
-    getName(): string;
-    getUniqueName(): string;
     getDisplayName(): string;
-    onDeviceData(deviceData: HeartRateSensorState): void;
-    mapData(deviceData: HeartRateSensorState): void;
+    mapToAdapterData(deviceData: HeartRateSensorState): void;
     hasData(): boolean;
 }
-export {};

package/lib/antv2/hr/adapter.js

@@ -3,71 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const adapter_1 = __importDefault(require("../adapter"));
-const utils_1 = require("../utils");
-const gd_eventlog_1 = require("gd-eventlog");
-const sensor_factory_1 = __importDefault(require("../sensor-factory"));
-const capabilities_1 = require("../../types/capabilities");
+const adapter_1 = __importDefault(require("../base/adapter"));
+const types_1 = require("../../types");
 class AntHrAdapter extends adapter_1.default {
     constructor(settings, props) {
-        if (settings.protocol && settings.profile !== AntHrAdapter.INCYCLIST_PROFILE_NAME)
-            throw new Error('Incorrect Profile');
-        if (!settings.protocol && settings.profile !== AntHrAdapter.ANT_PROFILE_NAME)
-            throw new Error('Incorrect Profile');
         super(settings, props);
-        this.deviceData = {
-            DeviceID: this.sensor.getDeviceID()
-        };
-        this.logger = new gd_eventlog_1.EventLogger('Ant+Hrm');
-        this.capabilities = [capabilities_1.IncyclistCapability.HeartRate];
-    }
-    createSensor(settings) {
-        return sensor_factory_1.default.create(AntHrAdapter.ANT_PROFILE_NAME, Number(settings.deviceID));
-    }
-    getName() {
-        if (this.settings.name)
-            return this.settings.name;
-        const deviceID = this.sensor.getDeviceID();
-        return `Ant+HR ${deviceID}`;
-    }
-    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} HR ${DeviceID}`;
-        else
-            return `${this.getName()}`;
+        this.capabilities = [types_1.IncyclistCapability.HeartRate];
     }
     getDisplayName() {
         const { ComputedHeartRate } = this.deviceData;
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
         return `${this.getUniqueName()}${hrmStr}`;
     }
-    onDeviceData(deviceData) {
-        this.dataMsgCount++;
-        this.lastDataTS = Date.now();
-        super.onDeviceData(deviceData);
-        if (!this.started)
-            return;
-        if (!this.ivDataTimeout)
-            this.startDataTimeoutCheck();
-        try {
-            if (!this.canSendUpdate())
-                return;
-            this.logEvent({ message: 'onDeviceData', data: deviceData });
-            if (this.paused)
-                return;
-            this.mapData(deviceData);
-            this.emitData(this.data);
-        }
-        catch (err) {
-        }
-    }
-    mapData(deviceData) {
-        if (deviceData.ComputedHeartRate)
+    mapToAdapterData(deviceData) {
+        if (deviceData.ComputedHeartRate) {
             this.data.heartrate = deviceData.ComputedHeartRate;
+            this.data.timestamp = Date.now();
+        }
     }
     hasData() {
         return this.deviceData.ComputedHeartRate !== undefined && this.deviceData.ComputedHeartRate !== null;

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

@@ -0,0 +1,11 @@
+import { HeartRateSensorState, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
+export default class AntHrAdapter extends AntAdapter<HeartRateSensorState> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static ANT_PROFILE_NAME: Profile;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    getDisplayName(): string;
+    mapToAdapterData(deviceData: HeartRateSensorState): void;
+    hasData(): boolean;
+}