incyclist-devices 2.0.38 → 2.1.0

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

@@ -2,10 +2,12 @@ import { Profile } from "incyclist-ant-plus";
 import { DeviceData } from "../types/data";
 import AntAdapter, { BaseDeviceData } from "./adapter";
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "./types";
+import { Controllable } from "../types/adapter";
+import { DeviceProperties } from "../types/device";
 export type AntAdapterInfo = {
     antProfile: Profile;
     incyclistProfile: LegacyProfile;
-    Adapter: typeof AntAdapter<BaseDeviceData, DeviceData>;
+    Adapter: typeof AntAdapter<Controllable<DeviceProperties>, BaseDeviceData, DeviceData>;
 };
 export type AdapterQuery = {
     antProfile?: Profile;
@@ -16,7 +18,7 @@ export default class AntAdapterFactory {
     adapters: AntAdapterInfo[];
     static getInstance(): AntAdapterFactory;
     constructor();
-    register<TDeviceData extends BaseDeviceData, TData>(antProfile: Profile, incyclistProfile: LegacyProfile, Adapter: typeof AntAdapter<TDeviceData, TData>): void;
+    register<TDeviceData extends BaseDeviceData, TData>(antProfile: Profile, incyclistProfile: LegacyProfile, Adapter: typeof AntAdapter<Controllable<DeviceProperties>, TDeviceData, TData>): void;
     getAdapter(query?: AdapterQuery): any;
     createInstance(settings: AntDeviceSettings, props?: AntDeviceProperties): any;
     createFromDetected(profile: Profile, deviceID: number, props?: AntDeviceProperties): any;

package/lib/antv2/adapter.d.ts

@@ -3,16 +3,13 @@ import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
 import AntInterface from './ant-interface';
 import IncyclistDevice from '../base/adpater';
 import { AntDeviceProperties, AntDeviceSettings } from './types';
-import { DeviceProperties } from '../types/device';
-import { Bike, IncyclistDeviceAdapter } from '../types/adapter';
-import CyclingMode from '../modes/cycling-mode';
-import { User } from '../types/user';
+import { Controllable, IncyclistDeviceAdapter } from '../types/adapter';
 export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
 export type BaseDeviceData = {
     DeviceID: number;
     ManId?: number;
 };
-export default class AntAdapter<TDeviceData extends BaseDeviceData, TData> extends IncyclistDevice {
+export default class AntAdapter<DC extends Controllable<AntDeviceProperties>, TDeviceData extends BaseDeviceData, TData> extends IncyclistDevice<DC, AntDeviceProperties> {
     sensor: ISensor;
     lastUpdate?: number;
     data: TData;
@@ -32,7 +29,7 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData, TData> exten
     protected lastDataTS: number;
     protected dataMsgCount: number;
     protected ivWaitForData: NodeJS.Timeout;
-    constructor(settings: AntDeviceSettings, props?: DeviceProperties);
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
     logEvent(event: any): void;
     createSensor(settings: AntDeviceSettings): ISensor;
     isEqual(settings: AntDeviceSettings): boolean;
@@ -55,17 +52,3 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData, TData> exten
     start(props?: AntDeviceProperties): Promise<boolean>;
     stop(): Promise<boolean>;
 }
-export declare class ControllableAntAdapter<TDeviceData extends BaseDeviceData, TData> extends AntAdapter<TDeviceData, TData> implements Bike {
-    cyclingMode: CyclingMode;
-    user?: User;
-    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    isControllable(): boolean;
-    setUser(user: User): void;
-    setBikeProps(props: DeviceProperties): void;
-    getWeight(): number;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    sendInitCommands(): Promise<boolean>;
-    getCyclingMode(): CyclingMode;
-}

package/lib/antv2/adapter.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 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) {
@@ -35,13 +12,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControllableAntAdapter = exports.DEFAULT_UPDATE_FREQUENCY = void 0;
+exports.DEFAULT_UPDATE_FREQUENCY = void 0;
 const ant_interface_1 = __importDefault(require("./ant-interface"));
-const adpater_1 = __importStar(require("../base/adpater"));
+const adpater_1 = __importDefault(require("../base/adpater"));
 const types_1 = require("./types");
 const utils_1 = require("../utils/utils");
 const capabilities_1 = require("../types/capabilities");
-const adpater_2 = require("../base/adpater");
 const utils_2 = require("./utils");
 exports.DEFAULT_UPDATE_FREQUENCY = 1000;
 const NO_DATA_TIMEOUT = 5000;
@@ -267,69 +243,3 @@ class AntAdapter extends adpater_1.default {
     }
 }
 exports.default = AntAdapter;
-class ControllableAntAdapter extends AntAdapter {
-    constructor(settings, props) {
-        super(settings, props);
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.user = {};
-    }
-    isControllable() {
-        return true;
-    }
-    setUser(user) {
-        this.user = user;
-        if (!user.weight)
-            this.user.weight = adpater_2.DEFAULT_USER_WEIGHT;
-    }
-    setBikeProps(props) {
-        const { user, userWeight } = props || {};
-        if (user)
-            this.setUser(user);
-        if (userWeight)
-            this.user.weight = userWeight;
-        const keys = Object.keys(props);
-        keys.forEach(k => {
-            const p = props[k];
-            if (p === null)
-                delete this.props[k];
-            else if (p !== undefined)
-                this.props[k] = p;
-        });
-    }
-    getWeight() {
-        const { user = {}, props = adpater_2.DEFAULT_PROPS } = this;
-        const userWeight = user.weight || props.userWeight || adpater_2.DEFAULT_USER_WEIGHT;
-        const bikeWeight = props.bikeWeight || adpater_1.DEFAULT_BIKE_WEIGHT;
-        return userWeight + bikeWeight;
-    }
-    getSupportedCyclingModes() { throw new Error('not implemented'); }
-    getDefaultCyclingMode() { throw new Error('not implemented'); }
-    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);
-    }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.cyclingMode;
-    }
-}
-exports.ControllableAntAdapter = ControllableAntAdapter;

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

@@ -1,7 +1,8 @@
 import { FitnessEquipmentSensorState, ISensor, Profile } from "incyclist-ant-plus";
-import { ControllableAntAdapter } from "../adapter";
-import CyclingMode, { IncyclistBikeData, UpdateRequest } from '../../modes/cycling-mode';
+import AntAdapter from "../adapter";
+import ICyclingMode, { CyclingMode, IncyclistBikeData, UpdateRequest } from '../../modes/types';
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
+import { ControllableDevice } from "../../base/adpater";
 type FitnessEquipmentSensorData = {
     speed: number;
     slope: number;
@@ -11,7 +12,12 @@ type FitnessEquipmentSensorData = {
     distance: number;
     timestamp: number;
 };
-export default class AntFEAdapter extends ControllableAntAdapter<FitnessEquipmentSensorState, FitnessEquipmentSensorData> {
+export declare class AntFeControl extends ControllableDevice<AntDeviceProperties> {
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getDefaultCyclingMode(): ICyclingMode;
+    sendInitCommands(): Promise<boolean>;
+}
+export default class AntFEAdapter extends AntAdapter<AntFeControl, FitnessEquipmentSensorState, FitnessEquipmentSensorData> {
     static INCYCLIST_PROFILE_NAME: LegacyProfile;
     static ANT_PROFILE_NAME: Profile;
     protected distanceInternal?: number;
@@ -23,8 +29,6 @@ export default class AntFEAdapter extends ControllableAntAdapter<FitnessEquipmen
     getName(): string;
     getUniqueName(): string;
     getDisplayName(): string;
-    getSupportedCyclingModes(): Array<any>;
-    getDefaultCyclingMode(): CyclingMode;
     getLogData(data: any, excludeList: any): any;
     sendUpdate(request: UpdateRequest, forced?: boolean): Promise<void>;
     onDeviceData(deviceData: FitnessEquipmentSensorState): void;

package/lib/antv2/fe/adapter.js

@@ -12,25 +12,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const adapter_1 = require("../adapter");
+exports.AntFeControl = void 0;
+const adapter_1 = __importDefault(require("../adapter"));
 const utils_1 = require("../utils");
 const gd_eventlog_1 = require("gd-eventlog");
-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 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 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.ControllableAntAdapter {
+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()
         };
@@ -69,12 +85,6 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
         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];
-    }
-    getDefaultCyclingMode() {
-        return new ant_fe_st_mode_1.default(this);
-    }
     getLogData(data, excludeList) {
         const logData = JSON.parse(JSON.stringify(data));
         excludeList.forEach((key) => {
@@ -199,7 +209,7 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
             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;
+                let to, timeoutOccured = false;
                 const stopTimeoutCheck = () => {
                     if (to) {
                         clearTimeout(to);
@@ -210,13 +220,14 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
                     reject(new Error(`could not start device, reason:timeout`));
                     this.started = false;
                     to = null;
+                    timeoutOccured = true;
                 }), totalTimeout);
                 this.setFEDefaultTimeout();
                 let success = false;
                 let status = { userSent: false, slopeSent: false };
                 let retry = 0;
                 let hasData = false;
-                while (!success && retry < MAX_RETRIES) {
+                while (!success && retry < MAX_RETRIES && !timeoutOccured) {
                     retry++;
                     if (!this.sensorConnected) {
                         this.logEvent({ message: 'start sensor', props });
@@ -339,7 +350,7 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.started && !this.stopped) {
                 try {
-                    if (this.getCyclingMode() instanceof ant_fe_erg_mode_1.default) {
+                    if (this.getCyclingMode() instanceof antble_erg_1.default) {
                         const power = this.data.power;
                         const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
                         yield this.sendUpdate(request, true);

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

@@ -1,10 +1,11 @@
 import { HeartRateSensorState, ISensor, Profile } from "incyclist-ant-plus";
 import AntAdapter from "../adapter";
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
+import { NonControllableDevice } from "../../base/adpater";
 type HeartRateSensorData = {
     heartrate: number;
 };
-export default class AntHrAdapter extends AntAdapter<HeartRateSensorState, HeartRateSensorData> {
+export default class AntHrAdapter extends AntAdapter<NonControllableDevice<AntDeviceProperties>, HeartRateSensorState, HeartRateSensorData> {
     static INCYCLIST_PROFILE_NAME: LegacyProfile;
     static ANT_PROFILE_NAME: Profile;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);

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

@@ -1,7 +1,8 @@
 import { BicyclePowerSensorState, ISensor, Profile } from "incyclist-ant-plus";
-import { ControllableAntAdapter } from "../adapter";
-import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
+import AntAdapter from "../adapter";
+import ICyclingMode, { CyclingMode, IncyclistBikeData } from '../../modes/types';
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
+import { ControllableDevice } from "../../base/adpater";
 type PowerSensorData = {
     speed: number;
     slope: number;
@@ -10,7 +11,12 @@ type PowerSensorData = {
     distance: number;
     timestamp: number;
 };
-export default class AntPwrAdapter extends ControllableAntAdapter<BicyclePowerSensorState, PowerSensorData> {
+export declare class AntPwrControl extends ControllableDevice<AntDeviceProperties> {
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getDefaultCyclingMode(): ICyclingMode;
+    sendInitCommands(): Promise<boolean>;
+}
+export default class AntPwrAdapter extends AntAdapter<AntPwrControl, BicyclePowerSensorState, PowerSensorData> {
     static INCYCLIST_PROFILE_NAME: LegacyProfile;
     static ANT_PROFILE_NAME: Profile;
     protected distanceInternal?: number;
@@ -19,8 +25,6 @@ export default class AntPwrAdapter extends ControllableAntAdapter<BicyclePowerSe
     getName(): string;
     getUniqueName(): string;
     getDisplayName(): string;
-    getDefaultCyclingMode(): CyclingMode;
-    getSupportedCyclingModes(): any[];
     getLogData(data: any, excludeList: any): any;
     onDeviceData(deviceData: any): void;
     canSendUpdate(): boolean;

package/lib/antv2/pwr/adapter.js

@@ -12,19 +12,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const adapter_1 = require("../adapter");
+exports.AntPwrControl = void 0;
+const adapter_1 = __importDefault(require("../adapter"));
 const utils_1 = require("../utils");
 const gd_eventlog_1 = require("gd-eventlog");
 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 {
+const adpater_1 = require("../../base/adpater");
+class AntPwrControl extends adpater_1.ControllableDevice {
+    getSupportedCyclingModes() {
+        return [power_meter_1.default];
+    }
+    getDefaultCyclingMode() {
+        return new power_meter_1.default(this.adapter);
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+}
+exports.AntPwrControl = AntPwrControl;
+class AntPwrAdapter extends adapter_1.default {
     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.setControl(new AntPwrControl(this, props));
         this.deviceData = {
             DeviceID: this.sensor.getDeviceID()
         };
@@ -57,12 +74,6 @@ class AntPwrAdapter extends adapter_1.ControllableAntAdapter {
         const pwrStr = Power ? ` (${Power})` : '';
         return `${this.getUniqueName()}${pwrStr}`;
     }
-    getDefaultCyclingMode() {
-        return new power_meter_1.default(this);
-    }
-    getSupportedCyclingModes() {
-        return [power_meter_1.default];
-    }
     getLogData(data, excludeList) {
         const logData = JSON.parse(JSON.stringify(data));
         excludeList.forEach((key) => {

package/lib/antv2/types.d.ts

@@ -1,6 +1,7 @@
 import { Profile } from 'incyclist-ant-plus';
 import IncyclistDevice from '../base/adpater';
 import { DeviceProperties, DeviceSettings, IncyclistScanProps } from '../types/device';
+import { Controllable } from '../types/adapter';
 export interface AntDeviceSettings extends DeviceSettings {
     deviceID?: string;
     profile: Profile | LegacyProfile;
@@ -8,7 +9,7 @@ export interface AntDeviceSettings extends DeviceSettings {
 }
 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 DeviceFoundCallback = (device: IncyclistDevice<Controllable<DeviceProperties>, DeviceProperties>, protocol: string) => void;
 export type ScanFinishedCallback = (id: number) => void;
 export interface AntScanProps extends IncyclistScanProps {
     profiles?: Profile[];

package/lib/base/adpater.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import CyclingMode from "../modes/cycling-mode";
+import ICyclingMode, { CyclingMode } from "../modes/types";
 import { DeviceProperties, DeviceSettings } from "../types/device";
-import { Bike, IncyclistDeviceAdapter, OnDeviceDataCallback } from '../types/adapter';
+import { Controllable, IncyclistDeviceAdapter, OnDeviceDataCallback } from '../types/adapter';
 import { User } from "../types/user";
 import { IncyclistCapability } from "../types/capabilities";
 import { EventLogger } from "gd-eventlog";
@@ -10,10 +10,9 @@ import EventEmitter from "events";
 export declare const DEFAULT_BIKE_WEIGHT = 10;
 export declare const DEFAULT_USER_WEIGHT = 75;
 export declare const DEFAULT_PROPS: DeviceProperties;
-export default class IncyclistDevice extends EventEmitter implements IncyclistDeviceAdapter {
+export default class IncyclistDevice<B extends Controllable<P>, P extends DeviceProperties> extends EventEmitter implements IncyclistDeviceAdapter {
     onDataFn: OnDeviceDataCallback;
     settings: DeviceSettings;
-    props: DeviceProperties;
     lastUpdate?: number;
     updateFrequency: number;
     capabilities: IncyclistCapability[];
@@ -21,7 +20,10 @@ export default class IncyclistDevice extends EventEmitter implements IncyclistDe
     started: boolean;
     stopped: boolean;
     paused: boolean;
+    bikeControl: B;
+    props: DeviceProperties;
     constructor(settings: DeviceSettings, props?: DeviceProperties);
+    setControl(control: B): void;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     check(): Promise<boolean>;
@@ -53,18 +55,34 @@ export default class IncyclistDevice extends EventEmitter implements IncyclistDe
     isStarted(): boolean;
     isPaused(): boolean;
     hasDataListeners(): boolean | OnDeviceDataCallback;
+    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
+    getSupportedCyclingModes(): any[];
+    getCyclingMode(): ICyclingMode;
+    getDefaultCyclingMode(): ICyclingMode;
+    setBikeProps(props: P): void;
+    setUser(user: User): void;
+    getUser(): User;
+    getWeight(): number;
+    sendInitCommands(): Promise<boolean>;
 }
-export declare class ControllableDevice extends IncyclistDevice implements Bike {
-    cyclingMode: CyclingMode;
-    user?: User;
-    constructor(settings: DeviceSettings, props?: DeviceProperties);
+export declare class NonControllableDevice<P extends DeviceProperties> extends Controllable<P> {
     isControllable(): boolean;
-    setUser(user: User): void;
+    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getCyclingMode(): ICyclingMode;
+    getDefaultCyclingMode(): ICyclingMode;
     setBikeProps(props: DeviceProperties): void;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    setUser(user: User): void;
+    sendInitCommands(): Promise<boolean>;
+}
+export declare class ControllableDevice<P extends DeviceProperties> extends Controllable<P> {
+    protected cyclingMode: ICyclingMode;
+    constructor(adapter: IncyclistDeviceAdapter, props?: P);
+    isControllable(): boolean;
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getDefaultCyclingMode(): ICyclingMode;
+    setCyclingMode(mode: ICyclingMode | string, settings?: any): void;
     sendInitCommands(): Promise<boolean>;
-    getCyclingMode(): CyclingMode;
+    getCyclingMode(): ICyclingMode;
     getWeight(): number;
 }

package/lib/base/adpater.js

@@ -12,7 +12,8 @@ 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;
+exports.ControllableDevice = exports.NonControllableDevice = exports.DEFAULT_PROPS = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
+const adapter_1 = require("../types/adapter");
 const events_1 = __importDefault(require("events"));
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
@@ -30,13 +31,18 @@ class IncyclistDevice extends events_1.default {
         this.started = false;
         this.stopped = false;
         this.paused = false;
+        this.bikeControl = new NonControllableDevice(this, props);
+    }
+    setControl(control) {
+        this.bikeControl = control;
     }
     connect() { throw new Error('not implemented'); }
     close() { throw new Error('not implemented'); }
     check() { throw new Error("Method not implemented."); }
-    getLogger() { return undefined; }
+    getLogger() { return this.logger; }
     isControllable() {
-        return false;
+        var _a;
+        return (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.isControllable();
     }
     isEqual(settings) { throw new Error("Method not implemented."); }
     getCapabilities() { return this.capabilities; }
@@ -124,46 +130,96 @@ class IncyclistDevice extends events_1.default {
     hasDataListeners() {
         return this.onDataFn || this.listenerCount('data') > 0;
     }
+    setCyclingMode(mode, settings, sendInitCommands) {
+        var _a;
+        if (this.isControllable())
+            (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.setCyclingMode(mode, settings, sendInitCommands);
+    }
+    getSupportedCyclingModes() {
+        var _a;
+        if (!this.isControllable())
+            return [];
+        return (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.getSupportedCyclingModes();
+    }
+    getCyclingMode() {
+        if (this.isControllable())
+            return this.bikeControl.getCyclingMode();
+    }
+    getDefaultCyclingMode() {
+        if (this.isControllable())
+            return this.bikeControl.getDefaultCyclingMode();
+    }
+    setBikeProps(props) {
+        if (this.isControllable())
+            this.bikeControl.setBikeProps(props);
+    }
+    setUser(user) {
+        if (this.isControllable())
+            this.bikeControl.setUser(user);
+    }
+    getUser() {
+        var _a;
+        return ((_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.getUser()) || {};
+    }
+    getWeight() {
+        var _a;
+        return (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.getWeight();
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isControllable())
+                return yield this.bikeControl.sendInitCommands();
+            return false;
+        });
+    }
 }
 exports.default = IncyclistDevice;
-class ControllableDevice extends IncyclistDevice {
-    constructor(settings, props) {
-        super(settings, props);
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.user = {};
-    }
+class NonControllableDevice extends adapter_1.Controllable {
     isControllable() {
-        return true;
+        return false;
     }
-    setUser(user) {
-        this.user = user;
-        if (!user.weight)
-            this.user.weight = exports.DEFAULT_USER_WEIGHT;
+    setCyclingMode(mode, settings, sendInitCommands) {
+        throw new Error("Method not implemented.");
+    }
+    getSupportedCyclingModes() {
+        throw new Error("Method not implemented.");
+    }
+    getCyclingMode() {
+        throw new Error("Method not implemented.");
+    }
+    getDefaultCyclingMode() {
+        throw new Error("Method not implemented.");
     }
     setBikeProps(props) {
-        const { user, userWeight } = props || {};
-        if (user)
-            this.setUser(user);
-        if (userWeight)
-            this.user.weight = userWeight;
-        const keys = Object.keys(props);
-        keys.forEach(k => {
-            const p = props[k];
-            if (p === null)
-                delete this.props[k];
-            else if (p !== undefined)
-                this.props[k] = p;
+        throw new Error("Method not implemented.");
+    }
+    setUser(user) {
+        throw new Error("Method not implemented.");
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
         });
     }
+}
+exports.NonControllableDevice = NonControllableDevice;
+class ControllableDevice extends adapter_1.Controllable {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.cyclingMode = this.getDefaultCyclingMode();
+    }
+    isControllable() {
+        return true;
+    }
     getSupportedCyclingModes() { throw new Error('not implemented'); }
     getDefaultCyclingMode() { throw new Error('not implemented'); }
     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; });
+            const CyclingModeClass = supported.find(M => { const m = new M(this.adapter); return m.getName() === mode; });
             if (CyclingModeClass) {
-                this.cyclingMode = new CyclingModeClass(this, settings);
+                this.cyclingMode = new CyclingModeClass(this.adapter, settings);
                 return;
             }
             selectedMode = this.getDefaultCyclingMode();