incyclist-devices 2.0.38 → 2.1.1

package/lib/antv2/base/binding.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AntDeviceBinding {
+    constructor(_props) { }
+    open() {
+        throw new Error('Method not implemented.');
+    }
+    close() {
+        throw new Error('Method not implemented.');
+    }
+    getMaxChannels() {
+        throw new Error('Method not implemented.');
+    }
+    getChannel() {
+        throw new Error('Method not implemented.');
+    }
+    freeChannel(channel) {
+        throw new Error('Method not implemented.');
+    }
+    getDeviceNumber() {
+        throw new Error('Method not implemented.');
+    }
+    write(data) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.default = AntDeviceBinding;

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

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

package/lib/antv2/cad/adapter.js

@@ -0,0 +1,25 @@
+"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("../base/adapter"));
+const types_1 = require("../../types");
+class AntHrAdapter extends adapter_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.capabilities = [types_1.IncyclistCapability.Cadence];
+    }
+    mapToAdapterData(deviceData) {
+        if (deviceData.CalculatedCadence) {
+            this.data.cadence = deviceData.CalculatedCadence;
+            this.data.timestamp = Date.now();
+        }
+    }
+    hasData() {
+        return this.deviceData.CalculatedCadence !== undefined && this.deviceData.CalculatedCadence !== null;
+    }
+}
+AntHrAdapter.INCYCLIST_PROFILE_NAME = 'Cadence Sensor';
+AntHrAdapter.ANT_PROFILE_NAME = 'CAD';
+exports.default = AntHrAdapter;

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

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

package/lib/antv2/cad/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/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
+export declare const NO_DATA_TIMEOUT = 5000;

package/lib/antv2/consts.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_DATA_TIMEOUT = exports.DEFAULT_UPDATE_FREQUENCY = void 0;
+exports.DEFAULT_UPDATE_FREQUENCY = 1000;
+exports.NO_DATA_TIMEOUT = 5000;

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

@@ -0,0 +1,14 @@
+import { Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData } from "../types";
+import { AntAdapterInfo, AdapterQuery } from "../types";
+export default class AntAdapterFactory {
+    static _instance: AntAdapterFactory;
+    adapters: AntAdapterInfo[];
+    static getInstance(): AntAdapterFactory;
+    constructor();
+    register<TDeviceData extends BaseDeviceData>(antProfile: Profile, incyclistProfile: LegacyProfile, Adapter: typeof AntAdapter<TDeviceData>): void;
+    getAdapter(query?: AdapterQuery): any;
+    createInstance(settings: AntDeviceSettings, props?: AntDeviceProperties): any;
+    createFromDetected(profile: Profile, deviceID: number, props?: AntDeviceProperties): any;
+}

package/lib/antv2/factories/adapter-factory.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AntAdapterFactory {
+    static getInstance() {
+        if (!AntAdapterFactory._instance)
+            AntAdapterFactory._instance = new AntAdapterFactory();
+        return AntAdapterFactory._instance;
+    }
+    constructor() {
+        this.adapters = [];
+    }
+    register(antProfile, incyclistProfile, Adapter) {
+        const info = Object.assign({}, { antProfile, incyclistProfile, Adapter });
+        const existing = this.adapters.findIndex(a => a.antProfile === antProfile);
+        if (existing !== -1)
+            this.adapters[existing] = info;
+        else
+            this.adapters.push(info);
+    }
+    getAdapter(query) {
+        const { antProfile, incyclistProfile } = query;
+        if (!antProfile && !incyclistProfile)
+            throw new Error('Illegal arguments: either "antProfile" or "incyclistProfile" must be set');
+        let found;
+        if (antProfile)
+            found = this.adapters.find(a => a.antProfile === antProfile);
+        if (incyclistProfile)
+            found = this.adapters.find(a => a.incyclistProfile === incyclistProfile);
+        return found;
+    }
+    createInstance(settings, props) {
+        let info;
+        const { profile, protocol } = settings;
+        let isLegacy = false;
+        if (protocol) {
+            try {
+                const incyclistProfile = profile;
+                info = this.getAdapter({ incyclistProfile });
+                isLegacy = true;
+            }
+            catch (_a) {
+                isLegacy = false;
+            }
+        }
+        if (!isLegacy) {
+            const antProfile = profile;
+            info = this.getAdapter({ antProfile });
+        }
+        if (info && info.Adapter)
+            return new info.Adapter(settings, props);
+    }
+    createFromDetected(profile, deviceID, props) {
+        const info = this.getAdapter({ antProfile: profile });
+        if (!info || !info.Adapter)
+            return;
+        const settings = Object.assign({}, {
+            profile: info.incyclistProfile,
+            deviceID: deviceID.toString(),
+            interface: 'ant',
+            protocol: 'Ant'
+        });
+        return new info.Adapter(settings, props);
+    }
+}
+exports.default = AntAdapterFactory;

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

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

package/lib/antv2/factories/sensor-factory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const incyclist_ant_plus_1 = require("incyclist-ant-plus");
+const incyclist_ant_plus_2 = require("incyclist-ant-plus");
+const profiles = [
+    { profile: 'PWR', Class: incyclist_ant_plus_2.BicyclePowerSensor },
+    { profile: 'HR', Class: incyclist_ant_plus_2.HeartRateSensor },
+    { profile: 'FE', Class: incyclist_ant_plus_2.FitnessEquipmentSensor },
+    { profile: 'CAD', Class: incyclist_ant_plus_1.CadenceSensor },
+];
+class SensorFactory {
+    static create(profile, deviceID) {
+        const info = profiles.find(i => i.profile === profile);
+        if (!info)
+            return;
+        return new info.Class(deviceID);
+    }
+    static createAll() {
+        return profiles.map(info => new info.Class());
+    }
+}
+exports.default = SensorFactory;

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

@@ -1,37 +1,36 @@
-import { FitnessEquipmentSensorState, ISensor, Profile } from "incyclist-ant-plus";
-import { ControllableAntAdapter } from "../adapter";
-import CyclingMode, { IncyclistBikeData, UpdateRequest } from '../../modes/cycling-mode';
+import { FitnessEquipmentSensorState, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
+import { UpdateRequest } from '../../modes/types';
+import { IncyclistBikeData } from "../../types/data";
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
-type FitnessEquipmentSensorData = {
-    speed: number;
-    slope: number;
-    power: number;
-    cadence: number;
-    heartrate: number;
-    distance: number;
-    timestamp: number;
-};
-export default class AntFEAdapter extends ControllableAntAdapter<FitnessEquipmentSensorState, FitnessEquipmentSensorData> {
-    static INCYCLIST_PROFILE_NAME: LegacyProfile;
-    static ANT_PROFILE_NAME: Profile;
+import { ControllerConfig } from "../../types/adapter";
+interface AntFEStartDeviceProperties extends AntDeviceProperties {
+    reconnect?: boolean;
+    reconnectTimeout?: number;
+}
+export default class AntFEAdapter extends AntAdapter<FitnessEquipmentSensorState> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static ANT_PROFILE_NAME: Profile;
+    protected static controllers: ControllerConfig;
     protected distanceInternal?: number;
     protected startProps: AntDeviceProperties;
-    protected isReconnecting: boolean;
+    protected promiseReconnect: Promise<boolean>;
     protected sensorConnected: boolean;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    createSensor(settings: AntDeviceSettings): ISensor;
-    getName(): string;
-    getUniqueName(): string;
     getDisplayName(): string;
-    getSupportedCyclingModes(): Array<any>;
-    getDefaultCyclingMode(): CyclingMode;
-    getLogData(data: any, excludeList: any): any;
+    getDefaultReconnectDelay(): number;
+    isReconnecting(): boolean;
     sendUpdate(request: UpdateRequest, forced?: boolean): Promise<void>;
     onDeviceData(deviceData: FitnessEquipmentSensorState): void;
-    canSendUpdate(): boolean;
-    mapToCycleModeData(deviceData: FitnessEquipmentSensorState): IncyclistBikeData;
-    transformData(bikeData: IncyclistBikeData): FitnessEquipmentSensorData;
-    start(props?: any): Promise<any>;
+    mapData(deviceData: FitnessEquipmentSensorState): IncyclistBikeData;
+    transformData(adapterData: IncyclistBikeData, deviceData: FitnessEquipmentSensorState): void;
+    start(props?: AntFEStartDeviceProperties): Promise<any>;
+    performStart(props: AntFEStartDeviceProperties, isReconnect: boolean): Promise<any>;
+    private waitForInitialData;
+    stopSensor(): Promise<void>;
+    initSensor(status: any, props: any): Promise<boolean>;
+    sendInititalUserMessage(status: any, props: any): Promise<void>;
+    sendInitialRequest(status: any, props: any): Promise<void>;
     setFEDefaultTimeout(): void;
     stop(): Promise<boolean>;
     reconnect(): Promise<boolean>;