incyclist-devices 2.1.1 → 2.1.3

package/lib/antv2/fe/adapter.js

@@ -13,22 +13,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const adapter_1 = __importDefault(require("../base/adapter"));
+const types_1 = require("../../types");
 const ant_fe_adv_st_mode_1 = __importDefault(require("../../modes/ant-fe-adv-st-mode"));
-const utils_1 = require("../../utils/utils");
-const capabilities_1 = require("../../types/capabilities");
 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 AntFEAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.startProps = {};
-        this.sensorConnected = false;
         this.capabilities = [
-            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence,
-            capabilities_1.IncyclistCapability.Control
+            types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence,
+            types_1.IncyclistCapability.Control
         ];
     }
     getDisplayName() {
@@ -36,9 +33,6 @@ class AntFEAdapter extends adapter_1.default {
         const pwrStr = InstantaneousPower ? ` (${InstantaneousPower})` : '';
         return `${this.getUniqueName()}${pwrStr}`;
     }
-    getDefaultReconnectDelay() {
-        return 2000;
-    }
     isReconnecting() {
         return this.promiseReconnect !== null && this.promiseReconnect !== undefined;
     }
@@ -48,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) {
@@ -65,14 +59,14 @@ 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 });
             }
         });
     }
     onDeviceData(deviceData) {
         super.onDeviceData(deviceData);
-        if (deviceData.HeartRate && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
-            this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
+        if (deviceData.HeartRate && !this.hasCapability(types_1.IncyclistCapability.HeartRate)) {
+            this.capabilities.push(types_1.IncyclistCapability.HeartRate);
             this.emit('device-info', this.getSettings(), { capabilities: this.capabilities });
         }
     }
@@ -118,134 +112,45 @@ class AntFEAdapter extends adapter_1.default {
             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);
+    start(props = {}) {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
         });
-    }
-    performStart(props, isReconnect) {
         return __awaiter(this, void 0, void 0, function* () {
-            const wasPaused = this.paused;
-            const wasStopped = this.stopped;
-            this.startProps = props;
-            if (wasPaused)
-                this.resume();
-            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: 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 retry = 0;
-                if (isReconnect) {
-                    status.userSent = true;
-                    status.slopeSent = true;
-                }
-                while (!success && retry < MAX_RETRIES && !status.timeout) {
-                    if (retry !== 0) {
-                        console.log('~~~ RETRY', status);
-                    }
-                    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;
-                    }
-                    success = status.sensorStarted && status.hasData && status.userSent && status.slopeSent;
-                }
-                if (success) {
-                    this.logEvent({ message: 'ANT FE start success' });
-                    this.started = true;
-                    this.paused = false;
-                    return true;
-                }
-                else {
-                    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 (!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 {
-                        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;
+            return yield _super.start.call(this, props);
         });
     }
-    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', });
-        });
+    resetStartStatus() {
+        const props = this.startProps;
+        const isReconnect = props.reconnect || false;
+        super.resetStartStatus();
+        if (isReconnect) {
+            delete props.reconnect;
+            this.startStatus.userInitialized = true;
+            this.startStatus.controlInitialized = true;
+        }
     }
-    stopSensor() {
+    startPreChecks(props) {
+        const _super = Object.create(null, {
+            startPreChecks: { get: () => super.startPreChecks }
+        });
         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) { }
+            this.startProps = props;
+            this.setFEDefaultTimeout();
+            return yield _super.startPreChecks.call(this, props);
         });
     }
-    initSensor(status, props) {
+    initControl() {
         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 });
-            }
+            yield this.sendInititalUserMessage();
+            yield this.sendInitialRequest();
         });
     }
-    sendInititalUserMessage(status, props) {
+    sendInititalUserMessage() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!status.sensorStarted || !status.hasData || status.userSent || status.timeout)
+            const props = this.startProps;
+            const { sensorStarted, hasData, userInitialized, timeout } = this.startStatus;
+            if (!sensorStarted || !hasData || userInitialized || timeout)
                 return;
             const opts = props || {};
             const { args = {}, user = {} } = opts;
@@ -256,39 +161,40 @@ class AntFEAdapter extends adapter_1.default {
                 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));
+                this.startStatus.userInitialized = yield fe.sendUserConfiguration(userWeight, bikeWeight, args.wheelDiameter, args.gearRatio);
             }
             catch (err) {
-                this.logEvent({ message: 'sending FE message error', error: err.message });
-                status.userSent = false;
+                this.logEvent({ message: 'sending FE message error', device: this.getName(), error: err.message });
+                this.startStatus.userInitialized = false;
             }
         });
     }
-    sendInitialRequest(status, props) {
+    sendInitialRequest() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!status.sensorStarted || !status.hasData || status.slopeSent || status.timeout)
+            const { sensorStarted, hasData, controlInitialized, timeout } = this.startStatus;
+            if (!sensorStarted || !hasData || controlInitialized || 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);
+                        this.startStatus.controlInitialized = yield fe.sendTargetPower(startRequest.targetPower);
                     }
                     else if (startRequest.slope !== undefined && startRequest.slope !== null) {
-                        status.slopeSent = yield fe.sendTrackResistance(startRequest.slope);
+                        this.startStatus.controlInitialized = yield fe.sendTrackResistance(startRequest.slope);
                     }
                     else {
-                        status.slopeSent = true;
+                        this.startStatus.controlInitialized = true;
                     }
                 }
                 else {
-                    status.slopeSent = yield fe.sendTrackResistance(0.0);
+                    this.startStatus.controlInitialized = yield fe.sendTrackResistance(0.0);
                 }
             }
             catch (err) {
-                this.logEvent({ message: 'sending FE message error', error: err.message });
-                status.slopeSent = false;
+                this.logEvent({ message: 'sending FE message error', device: this.getName(), error: err.message });
+                this.startStatus.controlInitialized = false;
             }
         });
     }
@@ -303,20 +209,20 @@ 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;
             }
             const doReconnect = () => __awaiter(this, void 0, void 0, function* () {
                 try {
                     yield this.stop();
-                    yield this.performStart(this.startProps, true);
+                    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;
                 }
             });
@@ -338,7 +244,6 @@ class AntFEAdapter extends adapter_1.default {
                     }
                 }
                 catch (err) {
-                    console.log(err);
                     return false;
                 }
             }

package/lib/antv2/index.d.ts

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

package/lib/antv2/index.js

@@ -13,8 +13,8 @@ exports.AntHrAdapter = hr_1.default;
 const cad_1 = __importDefault(require("./cad"));
 const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
 exports.AntAdapterFactory = adapter_factory_1.default;
-const ant_interface_1 = __importDefault(require("./base/ant-interface"));
-exports.AntInterface = ant_interface_1.default;
+const interface_1 = __importDefault(require("./base/interface"));
+exports.AntInterface = 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);

package/lib/antv2/types.d.ts

@@ -4,6 +4,7 @@ import AntAdapter from './base/adapter';
 export interface AntDeviceSettings extends DeviceSettings {
     deviceID?: string;
     profile: Profile | LegacyProfile;
+    interface: string;
     protocol?: string;
 }
 export type LegacyProfile = 'Heartrate Monitor' | 'Power Meter' | 'Smart Trainer' | 'Speed Sensor' | 'Cadence Sensor' | 'Speed + Cadence Sensor';
@@ -40,3 +41,11 @@ export interface ConnectState {
     connected: boolean;
     connecting: boolean;
 }
+export interface AdapterStartStatus {
+    timeout: boolean;
+    sensorStarted: boolean;
+    hasData: boolean;
+    userInitialized?: boolean;
+    controlInitialized?: boolean;
+    interrupted?: boolean;
+}

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 {
@@ -42,7 +43,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 +63,14 @@ class IncyclistDevice extends events_1.default {
     stop() { throw new Error("Method not implemented."); }
     pause() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'pausing device', device: this.getName() });
             this.paused = true;
             return true;
         });
     }
     resume() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'resuming device', device: this.getName() });
             this.paused = false;
             return true;
         });
@@ -170,7 +173,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>;
 }