incyclist-devices 2.1.0 → 2.1.1

package/lib/adapters.d.ts

@@ -1,4 +1,4 @@
-import { IncyclistDeviceAdapter } from "./types/adapter";
+import { IncyclistDeviceAdapter } from "./base/adpater";
 import { DeviceProperties, DeviceSettings } from "./types/device";
 export default class AdapterFactory {
     static adapters: IncyclistDeviceAdapter[];

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

@@ -1,24 +1,13 @@
 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<Controllable<DeviceProperties>, BaseDeviceData, DeviceData>;
-};
-export type AdapterQuery = {
-    antProfile?: Profile;
-    incyclistProfile?: LegacyProfile;
-};
+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, TData>(antProfile: Profile, incyclistProfile: LegacyProfile, Adapter: typeof AntAdapter<Controllable<DeviceProperties>, TDeviceData, TData>): void;
+    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/adapter.d.ts

@@ -2,17 +2,11 @@
 import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
 import AntInterface from './ant-interface';
 import IncyclistDevice from '../base/adpater';
-import { AntDeviceProperties, AntDeviceSettings } from './types';
-import { Controllable, IncyclistDeviceAdapter } from '../types/adapter';
-export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
-export type BaseDeviceData = {
-    DeviceID: number;
-    ManId?: number;
-};
-export default class AntAdapter<DC extends Controllable<AntDeviceProperties>, TDeviceData extends BaseDeviceData, TData> extends IncyclistDevice<DC, AntDeviceProperties> {
+import { AntDeviceProperties, AntDeviceSettings, BaseDeviceData } from './types';
+import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../types';
+export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
     sensor: ISensor;
-    lastUpdate?: number;
-    data: TData;
+    data: IncyclistAdapterData;
     deviceData: TDeviceData;
     updateFrequency: number;
     channel: IChannel;
@@ -23,32 +17,38 @@ export default class AntAdapter<DC extends Controllable<AntDeviceProperties>, TD
     bikeSettings: {
         weight?: number;
     };
-    onDataFn: (data: TData) => void;
+    onDataFn: (data: IncyclistAdapterData) => void;
     startupRetryPause: number;
     protected ivDataTimeout: NodeJS.Timeout;
     protected lastDataTS: number;
     protected dataMsgCount: number;
     protected ivWaitForData: NodeJS.Timeout;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    logEvent(event: any): void;
     createSensor(settings: AntDeviceSettings): ISensor;
     isEqual(settings: AntDeviceSettings): boolean;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     resetData(): void;
-    isSame(device: IncyclistDeviceAdapter): boolean;
+    isSame(device: IAdapter): boolean;
     hasData(): boolean;
-    onDeviceData(deviceData: any): void;
-    waitForData(timeout: number): Promise<unknown>;
+    mapData(deviceData: TDeviceData): IncyclistBikeData;
+    transformData(data: IncyclistBikeData): void;
+    mapToAdapterData(deviceData: any): void;
+    onDeviceData(deviceData: TDeviceData): void;
+    isWaitingForData(): boolean;
+    waitForData(timeout: number): Promise<boolean>;
     getID(): string;
     getName(): string;
     getInterface(): string;
     getProfile(): Profile;
+    getLogData(data: any, excludeList: any): any;
+    triggerTimeoutCheck(): void;
     startDataTimeoutCheck(): void;
     stopDataTimeoutCheck(): void;
     check(): Promise<boolean>;
     checkCapabilities(): Promise<void>;
     initControl(): Promise<void>;
+    sendUpdate(request: any): void;
     start(props?: AntDeviceProperties): Promise<boolean>;
     stop(): Promise<boolean>;
 }

package/lib/antv2/adapter.js

@@ -12,15 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_UPDATE_FREQUENCY = void 0;
 const ant_interface_1 = __importDefault(require("./ant-interface"));
 const adpater_1 = __importDefault(require("../base/adpater"));
 const types_1 = require("./types");
+const types_2 = require("../types");
 const utils_1 = require("../utils/utils");
-const capabilities_1 = require("../types/capabilities");
 const utils_2 = require("./utils");
-exports.DEFAULT_UPDATE_FREQUENCY = 1000;
-const NO_DATA_TIMEOUT = 5000;
+const consts_1 = require("./consts");
 const INTERFACE_NAME = 'ant';
 class AntAdapter extends adpater_1.default {
     constructor(settings, props) {
@@ -35,20 +33,10 @@ class AntAdapter extends adpater_1.default {
         this.deviceData = {};
         this.data = {};
         this.dataMsgCount = 0;
-        this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
+        this.updateFrequency = consts_1.DEFAULT_UPDATE_FREQUENCY;
         this.channel = undefined;
         this.ant = ant_interface_1.default.getInstance();
     }
-    logEvent(event) {
-        if (!this.logger || this.paused)
-            return;
-        this.logger.logEvent(event);
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
-            const logText = '~~~ ANT:' + this.logger.getName();
-            console.log(logText, event);
-        }
-    }
     createSensor(settings) {
         throw new Error('Method not implemented.');
     }
@@ -86,13 +74,49 @@ class AntAdapter extends adpater_1.default {
     hasData() {
         return this.dataMsgCount > 0;
     }
+    mapData(deviceData) {
+        throw new Error('message not implemented');
+    }
+    transformData(data) {
+        throw new Error('message not implemented');
+    }
+    mapToAdapterData(deviceData) {
+        throw new Error('message not implemented');
+    }
     onDeviceData(deviceData) {
-        const { ManId } = this.deviceData;
-        this.deviceData = Object.assign({}, deviceData);
-        if (!ManId && deviceData.ManId) {
-            this.emit('device-info', { device: this.getSettings(), manufacturer: (0, utils_2.getBrand)(deviceData.ManId) });
+        this.dataMsgCount++;
+        this.lastDataTS = Date.now();
+        try {
+            const { ManId } = this.deviceData;
+            this.deviceData = Object.assign({}, deviceData);
+            if (!ManId && deviceData.ManId) {
+                this.emit('device-info', { device: this.getSettings(), manufacturer: (0, utils_2.getBrand)(deviceData.ManId) });
+            }
+            if (!this.started || this.isStopped())
+                return;
+            this.triggerTimeoutCheck();
+            if (!this.canEmitData())
+                return;
+            const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
+            this.logEvent({ message: 'onDeviceData', data: logData, paused: this.paused });
+            if (this.isControllable()) {
+                let incyclistData = this.mapData(deviceData);
+                incyclistData = this.getCyclingMode().updateData(incyclistData);
+                this.transformData(incyclistData);
+            }
+            else {
+                this.mapToAdapterData(deviceData);
+            }
+            this.emitData(this.data);
+        }
+        catch (err) {
+            console.log('~~~ERROR', err);
+            this.logEvent({ message: 'error', fn: 'onDeviceData()', error: err.message || err, stack: err.stack });
         }
     }
+    isWaitingForData() {
+        return this.ivWaitForData !== undefined && this.ivWaitForData !== null;
+    }
     waitForData(timeout) {
         return __awaiter(this, void 0, void 0, function* () {
             const startTs = Date.now();
@@ -138,13 +162,25 @@ class AntAdapter extends adpater_1.default {
             return (0, utils_2.mapLegacyProfile)(settings.profile);
         }
     }
+    getLogData(data, excludeList) {
+        const logData = JSON.parse(JSON.stringify(data));
+        excludeList.forEach((key) => {
+            delete logData[key];
+        });
+        return logData;
+    }
+    triggerTimeoutCheck() {
+        if (!this.ivDataTimeout && this.dataMsgCount > 0) {
+            this.startDataTimeoutCheck();
+        }
+    }
     startDataTimeoutCheck() {
         if (this.ivDataTimeout)
             return;
         this.ivDataTimeout = setInterval(() => {
             if (!this.lastDataTS)
                 return;
-            if (this.lastDataTS + NO_DATA_TIMEOUT < Date.now()) {
+            if (this.lastDataTS + consts_1.NO_DATA_TIMEOUT < Date.now()) {
                 this.emit('disconnected', Date.now() - this.lastDataTS);
             }
         }, 1000);
@@ -177,6 +213,16 @@ class AntAdapter extends adpater_1.default {
             return;
         });
     }
+    sendUpdate(request) {
+        if (!this.isControllable())
+            return;
+        if (this.isPaused() || this.isStopped())
+            return;
+        if (!this.hasCapability(types_2.IncyclistCapability.Control))
+            this.getCyclingMode().sendBikeUpdate(request);
+        else
+            throw new Error('method not implemented');
+    }
     start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.started && !this.stopped) {
@@ -212,7 +258,7 @@ class AntAdapter extends adpater_1.default {
                 try {
                     yield this.waitForData(startupTimeout - 100);
                     yield this.checkCapabilities();
-                    if (this.hasCapability(capabilities_1.IncyclistCapability.Control))
+                    if (this.hasCapability(types_2.IncyclistCapability.Control))
                         yield this.initControl();
                     this.started = true;
                     if (to)

package/lib/antv2/ant-interface.d.ts

@@ -2,17 +2,9 @@
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
 import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
-import { InterfaceProps } from "../types/interface";
-import AntDeviceBinding from "./binding";
-import { IncyclistInterface } from "../types/interface";
-import { AntDeviceSettings, AntScanProps } from "./types";
-export interface AntInterfaceProps extends InterfaceProps {
-    startupTimeout?: number;
-}
-export interface ConnectState {
-    connected: boolean;
-    connecting: boolean;
-}
+import { AntDeviceSettings, AntScanProps, AntInterfaceProps, ConnectState } from "./types";
+import { IncyclistInterface } from "../types";
+import AntDeviceBinding from "./base/binding";
 export default class AntInterface extends EventEmitter implements IncyclistInterface {
     static _instance: AntInterface;
     static INTERFACE_NAME: string;

package/lib/antv2/ant-interface.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = __importDefault(require("events"));
 const gd_eventlog_1 = require("gd-eventlog");
-const sensor_factory_1 = __importDefault(require("./sensor-factory"));
+const sensor_factory_1 = __importDefault(require("./factories/sensor-factory"));
 class AntInterface extends events_1.default {
     static getInstance(props = {}) {
         if (AntInterface._instance === undefined)

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

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
+import AntInterface from './ant-interface';
+import IncyclistDevice from '../../base/adpater';
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData } from '../types';
+import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../../types';
+export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
+    sensor: ISensor;
+    data: IncyclistAdapterData;
+    deviceData: TDeviceData;
+    updateFrequency: number;
+    channel: IChannel;
+    ant: AntInterface;
+    userSettings: {
+        weight?: number;
+    };
+    bikeSettings: {
+        weight?: number;
+    };
+    onDataFn: (data: IncyclistAdapterData) => void;
+    startupRetryPause: number;
+    protected ivDataTimeout: NodeJS.Timeout;
+    protected lastDataTS: number;
+    protected dataMsgCount: number;
+    protected ivWaitForData: NodeJS.Timeout;
+    protected promiseWaitForData: Promise<boolean>;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    getProfileName(): Profile;
+    getLegacyProfileName(): LegacyProfile;
+    createSensor(settings: AntDeviceSettings): ISensor;
+    isEqual(settings: AntDeviceSettings): boolean;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
+    resetData(): void;
+    isSame(device: IAdapter): boolean;
+    hasData(): boolean;
+    mapData(deviceData: TDeviceData): IncyclistBikeData;
+    transformData(data: IncyclistBikeData, deviceData: TDeviceData): void;
+    mapToAdapterData(deviceData: any): void;
+    onDeviceData(deviceData: TDeviceData): void;
+    isWaitingForData(): boolean;
+    _wait(): Promise<boolean>;
+    waitForData(timeout: number): Promise<boolean>;
+    getID(): string;
+    getName(): string;
+    getUniqueName(): string;
+    getDisplayName(): string;
+    getInterface(): string;
+    getProfile(): Profile;
+    getLogData(data: any, excludeList: any): any;
+    triggerTimeoutCheck(): void;
+    startDataTimeoutCheck(): void;
+    stopDataTimeoutCheck(): void;
+    check(): Promise<boolean>;
+    checkCapabilities(): Promise<void>;
+    initControl(): Promise<void>;
+    getDefaultStartupTimeout(): number;
+    sendUpdate(request: any): void;
+    start(props?: AntDeviceProperties): Promise<boolean>;
+    stop(): Promise<boolean>;
+    startSensor(): Promise<boolean>;
+}