incyclist-devices 1.5.37 → 2.0.0-beta.1

package/lib/antv2/{fe.js → fe/adapter.js}

@@ -12,64 +12,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ant_device_1 = __importDefault(require("./ant-device"));
-const utils_1 = require("../ant/utils");
+const adapter_1 = require("../adapter");
+const utils_1 = require("../utils");
 const gd_eventlog_1 = require("gd-eventlog");
-const ant_fe_st_mode_1 = __importDefault(require("../ant/antfe/ant-fe-st-mode"));
-const ant_fe_erg_mode_1 = __importDefault(require("../ant/antfe/ant-fe-erg-mode"));
-const ant_fe_adv_st_mode_1 = __importDefault(require("../ant/antfe/ant-fe-adv-st-mode"));
-const utils_2 = require("../utils");
-const DEFAULT_USER_WEIGHT = 75;
-const DEFAULT_BIKE_WEIGHT = 10;
+const ant_fe_st_mode_1 = __importDefault(require("../modes/ant-fe-st-mode"));
+const ant_fe_erg_mode_1 = __importDefault(require("../modes/ant-fe-erg-mode"));
+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 capabilities_1 = require("../../types/capabilities");
+const adpater_1 = require("../../base/adpater");
 const DEFAULT_BIKE_WEIGHT_MOUNTAIN = 14.5;
 const MAX_RETRIES = 3;
-class AntFEAdapter extends ant_device_1.default {
-    constructor(sensor, protocol) {
-        super(sensor, protocol);
-        this.started = false;
+class AntFEAdapter extends adapter_1.ControllableAntAdapter {
+    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.deviceData = {
-            DeviceID: sensor.getDeviceID()
+            DeviceID: this.sensor.getDeviceID()
         };
         this.dataMsgCount = 0;
         this.logger = new gd_eventlog_1.EventLogger('Ant+FE');
         this.isReconnecting = false;
+        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));
     }
-    isBike() { return true; }
-    isHrm() { return false; }
-    isPower() { return true; }
     getName() {
+        if (this.settings.name)
+            return this.settings.name;
         const deviceID = this.sensor.getDeviceID();
         return `Ant+FE ${deviceID}`;
     }
     getDisplayName() {
-        const { DeviceID, ManId } = this.deviceData;
-        return `${(0, utils_1.getBrand)(ManId)} FE ${DeviceID}`;
+        const { DeviceID, ManId, InstantaneousPower } = this.deviceData;
+        const pwrStr = InstantaneousPower ? ` (${InstantaneousPower})` : '';
+        const brand = (0, utils_1.getBrand)(ManId);
+        if (brand)
+            return `${brand} FE ${DeviceID}${pwrStr}`;
+        else
+            return `${this.getName()}${pwrStr}`;
     }
     getSupportedCyclingModes() {
         return [ant_fe_st_mode_1.default, ant_fe_erg_mode_1.default, ant_fe_adv_st_mode_1.default];
     }
-    setCyclingMode(mode, settings) {
-        let selectedMode;
-        if (typeof mode === 'string') {
-            const supported = this.getSupportedCyclingModes();
-            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
-            if (CyclingModeClass) {
-                this.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.cyclingMode = selectedMode;
-        this.cyclingMode.setSettings(settings);
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.cyclingMode = this.getDefaultCyclingMode();
-        return this.cyclingMode;
-    }
     getDefaultCyclingMode() {
         return new ant_fe_st_mode_1.default(this);
     }
@@ -112,16 +105,16 @@ class AntFEAdapter extends ant_device_1.default {
     onDeviceData(deviceData) {
         this.dataMsgCount++;
         this.lastDataTS = Date.now();
+        super.onDeviceData(deviceData);
         if (!this.started || this.isStopped())
             return;
-        this.deviceData = deviceData;
-        if (this.dataMsgCount === 1) {
+        if (!this.ivDataTimeout && this.dataMsgCount > 0) {
             this.startDataTimeoutCheck();
         }
         try {
             const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
             this.logger.logEvent({ message: 'onDeviceData', data: logData });
-            if (this.onDataFn && !(this.ignoreHrm && this.ignoreBike && this.ignorePower) && !this.paused) {
+            if (this.onDataFn && !this.paused) {
                 if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
                     let incyclistData = this.mapData(deviceData);
                     incyclistData = this.getCyclingMode().updateData(incyclistData);
@@ -172,25 +165,17 @@ class AntFEAdapter extends ant_device_1.default {
             distance,
             timestamp: Date.now()
         };
-        if (this.ignorePower) {
-            delete data.power;
-            delete data.cadence;
-        }
-        if (this.ignoreBike) {
-            data = { heartrate: data.heartrate };
-        }
-        if (this.ignoreHrm || !this.isHrm())
-            delete data.heartrate;
         return data;
     }
     start(props) {
-        const _super = Object.create(null, {
-            start: { get: () => super.start }
-        });
         return __awaiter(this, void 0, void 0, function* () {
-            _super.start.call(this, props);
+            if (this.started)
+                return true;
+            const connected = yield this.connect();
+            if (!connected)
+                throw new Error(`could not start device, reason:could not connect`);
             this.startProps = props;
-            this.logger.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* () {
@@ -216,8 +201,10 @@ class AntFEAdapter extends ant_device_1.default {
                 while (!success && retry < MAX_RETRIES) {
                     retry++;
                     if (!this.started) {
+                        this.logger.logEvent({ message: 'start sensor', props });
                         this.started = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
                         if (this.started) {
+                            this.logger.logEvent({ message: 'sensor started', props });
                             startSuccess++;
                         }
                         if (this.started && startSuccess === 1) {
@@ -245,8 +232,8 @@ class AntFEAdapter extends ant_device_1.default {
                             const fe = this.sensor;
                             const mode = this.getCyclingMode();
                             const bikeType = mode ? mode.getSetting('bikeType').toLowerCase() : 'race';
-                            const defaultBikeWeight = bikeType === 'mountain' ? DEFAULT_BIKE_WEIGHT_MOUNTAIN : DEFAULT_BIKE_WEIGHT;
-                            const userWeight = args.userWeight || user.weight || DEFAULT_USER_WEIGHT;
+                            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));
                             status.slopeSent = status.slopeSent || (yield fe.sendTrackResistance(0.0));
@@ -288,19 +275,6 @@ class AntFEAdapter extends ant_device_1.default {
         const fe = this.sensor;
         fe.setSendTimeout(5000);
     }
-    stop() {
-        const _super = Object.create(null, {
-            stop: { get: () => super.stop }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stopping device' });
-            let stopped = yield this.ant.stopSensor(this.sensor);
-            this.started = false;
-            yield _super.stop.call(this);
-            this.logger.logEvent({ message: 'stopping device done', success: stopped });
-            return stopped;
-        });
-    }
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'reconnect to device' });
@@ -322,3 +296,5 @@ class AntFEAdapter extends ant_device_1.default {
     }
 }
 exports.default = AntFEAdapter;
+AntFEAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
+AntFEAdapter.ANT_PROFILE_NAME = 'FE';

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

@@ -0,0 +1,2 @@
+import AntFEAdapter from './adapter';
+export default AntFEAdapter;

package/lib/antv2/fe/index.js

@@ -0,0 +1,7 @@
+"use strict";
+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"));
+exports.default = adapter_1.default;

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

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

package/lib/antv2/hr/adapter.js

@@ -0,0 +1,73 @@
+"use strict";
+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");
+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}`;
+    }
+    getDisplayName() {
+        const { DeviceID, ManId, ComputedHeartRate } = this.deviceData;
+        const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
+        const brand = (0, utils_1.getBrand)(ManId);
+        if (brand)
+            return `${brand} Hrm ${DeviceID}${hrmStr}`;
+        else
+            return `${this.getName()}${hrmStr}`;
+    }
+    onDeviceData(deviceData) {
+        this.dataMsgCount++;
+        this.lastDataTS = Date.now();
+        super.onDeviceData(deviceData);
+        if (!this.started)
+            return;
+        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();
+                }
+            }
+        }
+        catch (err) {
+        }
+    }
+    updateData(data, deviceData) {
+        data.heartrate = deviceData.ComputedHeartRate;
+        return data;
+    }
+    hasData() {
+        return this.deviceData.ComputedHeartRate !== undefined && this.deviceData.ComputedHeartRate !== null;
+    }
+}
+exports.default = AntHrAdapter;
+AntHrAdapter.INCYCLIST_PROFILE_NAME = 'Heartrate Monitor';
+AntHrAdapter.ANT_PROFILE_NAME = 'HR';

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

@@ -0,0 +1,2 @@
+import AntHrAdapter from './adapter';
+export default AntHrAdapter;

package/lib/antv2/hr/index.js

@@ -0,0 +1,7 @@
+"use strict";
+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"));
+exports.default = adapter_1.default;

package/lib/antv2/index.d.ts

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

package/lib/antv2/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AntInterface = exports.AntPwrAdapter = exports.AntHrAdapter = exports.AntFEAdapter = exports.AntAdapterFactory = void 0;
+const pwr_1 = __importDefault(require("./pwr"));
+exports.AntPwrAdapter = pwr_1.default;
+const fe_1 = __importDefault(require("./fe"));
+exports.AntFEAdapter = fe_1.default;
+const hr_1 = __importDefault(require("./hr"));
+exports.AntHrAdapter = hr_1.default;
+const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+exports.AntAdapterFactory = adapter_factory_1.default;
+const ant_interface_1 = __importDefault(require("./ant-interface"));
+exports.AntInterface = ant_interface_1.default;
+const af = adapter_factory_1.default.getInstance();
+af.register('PWR', 'Power Meter', pwr_1.default);
+af.register('HR', 'Heartrate Monitor', hr_1.default);
+af.register('FE', 'Smart Trainer', fe_1.default);

package/lib/antv2/modes/ant-fe-adv-st-mode.d.ts

@@ -0,0 +1,9 @@
+import FtmsCyclingMode from "../../modes/ble-st-mode";
+import { UpdateRequest } from "../../modes/cycling-mode";
+import { IncyclistDeviceAdapter } from "../../types/adapter";
+export default class AntAdvSimCyclingMode extends FtmsCyclingMode {
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+}

package/lib/{ant/antfe → antv2/modes}/ant-fe-adv-st-mode.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ble_st_mode_1 = __importDefault(require("../../ble/ble-st-mode"));
+const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
 const MAX_DEVIATION = 10;
 class AntAdvSimCyclingMode extends ble_st_mode_1.default {
     constructor(adapter, props) {

package/lib/antv2/modes/ant-fe-erg-mode.d.ts

@@ -0,0 +1,6 @@
+import BleERGCyclingMode from "../../modes/ble-erg-mode";
+import { IncyclistDeviceAdapter } from "../../types/adapter";
+export default class AntFeERGCyclingMode extends BleERGCyclingMode {
+    static isERG: boolean;
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+}

package/lib/{ant/antfe → antv2/modes}/ant-fe-erg-mode.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ble_erg_mode_1 = __importDefault(require("../../ble/ble-erg-mode"));
+const ble_erg_mode_1 = __importDefault(require("../../modes/ble-erg-mode"));
 class AntFeERGCyclingMode extends ble_erg_mode_1.default {
     constructor(adapter, props) {
         super(adapter, props);

package/lib/antv2/modes/ant-fe-st-mode.d.ts

@@ -0,0 +1,5 @@
+import FtmsCyclingMode from "../../modes/ble-st-mode";
+import { IncyclistDeviceAdapter } from "../../types/adapter";
+export default class AntStCyclingMode extends FtmsCyclingMode {
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+}

package/lib/{ant/antfe → antv2/modes}/ant-fe-st-mode.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ble_st_mode_1 = __importDefault(require("../../ble/ble-st-mode"));
+const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
 class AntStCyclingMode extends ble_st_mode_1.default {
     constructor(adapter, props) {
         super(adapter, props);

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

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

package/lib/antv2/{pwr.js → pwr/adapter.js}

@@ -1,45 +1,46 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        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 });
-const ant_device_1 = __importDefault(require("./ant-device"));
-const utils_1 = require("../ant/utils");
+const adapter_1 = require("../adapter");
+const utils_1 = require("../utils");
 const gd_eventlog_1 = require("gd-eventlog");
-const power_meter_1 = __importDefault(require("../modes/power-meter"));
-class AntPwrAdapter extends ant_device_1.default {
-    constructor(sensor, protocol) {
-        super(sensor, protocol);
-        this.started = false;
+const power_meter_1 = __importDefault(require("../../modes/power-meter"));
+const sensor_factory_1 = __importDefault(require("../sensor-factory"));
+const capabilities_1 = require("../../types/capabilities");
+class AntPwrAdapter extends adapter_1.ControllableAntAdapter {
+    constructor(settings, props) {
+        if (settings.protocol && settings.profile !== AntPwrAdapter.INCYCLIST_PROFILE_NAME)
+            throw new Error('Incorrect Profile');
+        if (!settings.protocol && settings.profile !== AntPwrAdapter.ANT_PROFILE_NAME)
+            throw new Error('Incorrect Profile');
+        super(settings, props);
         this.deviceData = {
-            DeviceID: sensor.getDeviceID()
+            DeviceID: this.sensor.getDeviceID()
         };
         this.logger = new gd_eventlog_1.EventLogger('Ant+PWR');
+        this.capabilities = [
+            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Speed
+        ];
+    }
+    createSensor(settings) {
+        return sensor_factory_1.default.create(AntPwrAdapter.ANT_PROFILE_NAME, Number(settings.deviceID));
     }
-    isBike() { return true; }
-    isHrm() { return false; }
-    isPower() { return true; }
     getName() {
+        if (this.settings.name)
+            return this.settings.name;
         const deviceID = this.sensor.getDeviceID();
         return `Ant+PWR ${deviceID}`;
     }
     getDisplayName() {
-        const { DeviceID, ManId } = this.deviceData;
-        return `${(0, utils_1.getBrand)(ManId)} PWR ${DeviceID}`;
-    }
-    getCyclingMode() {
-        if (!this.mode)
-            this.mode = this.getDefaultCyclingMode();
-        return this.mode;
+        const { DeviceID, ManId, Power } = this.deviceData;
+        const pwrStr = Power ? ` (${Power})` : '';
+        const brand = (0, utils_1.getBrand)(ManId);
+        if (brand)
+            return `${brand} PWR ${DeviceID}${pwrStr}`;
+        else
+            return `${this.getName()}${pwrStr}`;
     }
     getDefaultCyclingMode() {
         return new power_meter_1.default(this);
@@ -57,13 +58,13 @@ class AntPwrAdapter extends ant_device_1.default {
     onDeviceData(deviceData) {
         this.dataMsgCount++;
         this.lastDataTS = Date.now();
+        super.onDeviceData(deviceData);
         if (!this.started)
             return;
-        this.deviceData = deviceData;
         if (!this.ivDataTimeout)
             this.startDataTimeoutCheck();
         try {
-            if (this.onDataFn && !(this.ignoreBike && this.ignorePower) && !this.paused) {
+            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 });
@@ -79,7 +80,7 @@ class AntPwrAdapter extends ant_device_1.default {
         }
     }
     sendUpdate(request) {
-        if (this.paused)
+        if (this.isPaused())
             return;
         this.getCyclingMode().sendBikeUpdate(request);
     }
@@ -118,54 +119,15 @@ class AntPwrAdapter extends ant_device_1.default {
             distance,
             timestamp: Date.now()
         };
-        if (this.ignorePower) {
-            delete data.power;
-            delete data.cadence;
-        }
-        if (this.ignoreBike) {
-            data = {};
-        }
         return data;
     }
-    start(props) {
-        const _super = Object.create(null, {
-            start: { get: () => super.start }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.started)
-                return true;
-            _super.start.call(this, props);
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                const { timeout = 20000 } = props || {};
-                let to;
-                if (timeout) {
-                    to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                        yield this.stop();
-                        reject(new Error(`could not start device, reason:timeout`));
-                    }), timeout);
-                }
-                this.started = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
-                try {
-                    yield this.waitForData(timeout - 100);
-                    if (to)
-                        clearTimeout(to);
-                    resolve(this.started);
-                }
-                catch (err) {
-                }
-            }));
-        });
-    }
-    stop() {
-        const _super = Object.create(null, {
-            stop: { get: () => super.stop }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const stopped = yield this.ant.stopSensor(this.sensor);
-            _super.stop.call(this);
-            this.started = false;
-            return stopped;
-        });
+    hasData() {
+        const { Power, Cadence, TimeStamp } = this.deviceData;
+        return Power !== undefined && Power !== null ||
+            Cadence !== undefined || Cadence !== null ||
+            TimeStamp !== undefined || TimeStamp !== null;
     }
 }
 exports.default = AntPwrAdapter;
+AntPwrAdapter.INCYCLIST_PROFILE_NAME = 'Power Meter';
+AntPwrAdapter.ANT_PROFILE_NAME = 'PWR';

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

@@ -0,0 +1,2 @@
+import AntPwrAdapter from './adapter';
+export default AntPwrAdapter;

package/lib/antv2/pwr/index.js

@@ -0,0 +1,7 @@
+"use strict";
+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"));
+exports.default = adapter_1.default;

package/lib/antv2/types.d.ts

@@ -0,0 +1,19 @@
+import IncyclistDevice from '../base/adpater';
+import { DeviceProperties, DeviceSettings, IncyclistScanProps } from '../types/device';
+export interface AntDeviceSettings extends DeviceSettings {
+    deviceID?: string;
+    profile: string;
+    protocol?: string;
+}
+export type DeviceFoundCallback = (device: IncyclistDevice, protocol: string) => void;
+export type ScanFinishedCallback = (id: number) => void;
+export interface AntScanProps extends IncyclistScanProps {
+    profiles?: string[];
+    id?: number;
+    onDeviceFound?: DeviceFoundCallback;
+    onScanFinished?: ScanFinishedCallback;
+}
+export interface AntDeviceProperties extends DeviceProperties {
+    startupTimeout?: number;
+    automaticReconnect?: boolean;
+}

package/lib/antv2/types.js

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

package/lib/antv2/utils.d.ts

@@ -0,0 +1 @@
+export declare const getBrand: (manId: number) => string;