incyclist-devices 1.5.38 → 2.0.0

package/lib/{daum/premium/DaumPremiumAdapter.js → serial/daum/premium/adapter.js}

@@ -13,19 +13,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("../../utils");
+const device_1 = require("../../../types/device");
+const __1 = require("../..");
+const serial_interface_1 = require("../../serial-interface");
+const utils_1 = require("../../../utils/utils");
 const DaumAdapter_1 = __importDefault(require("../DaumAdapter"));
-const DaumClassicCyclingMode_1 = __importDefault(require("./DaumClassicCyclingMode"));
+const comms_1 = __importDefault(require("./comms"));
+const daum_classic_1 = __importDefault(require("./modes/daum-classic"));
 const PROTOCOL_NAME = "Daum Premium";
-class DaumPremiumDevice extends DaumAdapter_1.default {
-    constructor(protocol, bike) {
-        super(protocol, bike);
+const DAUM_PREMIUM_DEFAULT_PORT = 51955;
+const START_RETRY_TIMEOUT = 1500;
+const DEFAULT_GEAR = 10;
+const getBikeProps = (props) => {
+    const { host, port = DAUM_PREMIUM_DEFAULT_PORT, interface: ifaceName } = props;
+    let serial;
+    if (ifaceName && typeof ifaceName === 'string') {
+        serial = __1.SerialInterface.getInstance({ ifaceName });
+    }
+    else {
+        serial = props.interface;
+    }
+    if (!serial || !serial.binding)
+        throw new Error(`unknonwn interface: ${ifaceName}`);
+    if (serial.getName() === serial_interface_1.SerialInterfaceType.TCPIP) {
+        const path = `${host}:${port}`;
+        return { serial, path };
+    }
+    else {
+        const path = `${port}`;
+        return { serial, path };
+    }
+};
+class DaumPremiumAdapter extends DaumAdapter_1.default {
+    constructor(settings, props) {
+        const logger = new gd_eventlog_1.EventLogger('DaumPremium');
+        const commProps = Object.assign(Object.assign({}, getBikeProps(settings)), { logger });
+        const bike = new comms_1.default(commProps);
+        super(settings, props);
+        this._startRetryTimeout = START_RETRY_TIMEOUT;
         this.bike = bike;
-        this.logger = new gd_eventlog_1.EventLogger('DaumPremium');
+        this.logger = logger;
         this.ignoreHrm = false;
         this.ignorePower = false;
         this.ignoreBike = false;
-        this.paused = undefined;
         this.iv = undefined;
         this.distanceInternal = undefined;
         this.initData();
@@ -33,34 +63,62 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
     getName() {
         return 'Daum8i';
     }
+    getUniqueName() {
+        if (this.getInterface() === 'tcpip') {
+            const port = this.getPort();
+            const [host] = port.split(':');
+            return `${this.getName()} (${host})`;
+        }
+        return super.getUniqueName();
+    }
     getPort() {
         return this.bike.getPort();
     }
     getInterface() {
-        return this.bike.getInterface();
+        var _a;
+        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.getInterface();
+    }
+    getProtocolName() {
+        return PROTOCOL_NAME;
+    }
+    isEqual(settings) {
+        if (this.getInterface() === device_1.INTERFACE.TCPIP) {
+            const equal = super.isEqual(settings);
+            if (!equal)
+                return false;
+            const as = this.settings;
+            return (settings.host === as.host);
+        }
+        else {
+            return super.isEqual(settings);
+        }
     }
     getSupportedCyclingModes() {
         const supported = super.getSupportedCyclingModes();
-        supported.push(DaumClassicCyclingMode_1.default);
+        supported.push(daum_classic_1.default);
         return supported;
     }
     check() {
-        var info = {};
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: "check()", port: this.getPort() });
-            if (this.isStopped())
-                reject(new Error("device is stopped"));
-            try {
-                if (!this.bike.isConnected())
-                    yield this.bike.saveConnect();
-                info.deviceType = yield this.bike.getDeviceType();
-                info.version = yield this.bike.getProtocolVersion();
-                resolve(info);
-            }
-            catch (err) {
-                reject(err);
-            }
-        }));
+        return __awaiter(this, void 0, void 0, function* () {
+            var info = {};
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.logger.logEvent({ message: "checking device", port: this.getPort() });
+                try {
+                    const connected = yield this.connect();
+                    if (!connected)
+                        resolve(false);
+                    info.deviceType = yield this.bike.getDeviceType();
+                    info.version = yield this.bike.getProtocolVersion();
+                    yield this.bike.close();
+                    this.logger.logEvent({ message: "checking device success", port: this.getPort(), info });
+                    resolve(true);
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: "checking device failed", port: this.getPort(), reason: err.message || err });
+                    resolve(false);
+                }
+            }));
+        });
     }
     pause() {
         const _super = Object.create(null, {
@@ -82,7 +140,7 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             return resumed;
         });
     }
-    startRide(props) {
+    startRide(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'relaunch of device' });
             try {
@@ -95,7 +153,7 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             }
         });
     }
-    start(props) {
+    start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'initial start of device' });
             try {
@@ -108,15 +166,11 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             }
         });
     }
-    launch(props, isRelaunch = false) {
+    launch(props = {}, isRelaunch = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            const opts = props || {};
-            if (opts.user && opts.user.weight)
-                this.userSettings.weight = opts.user.weight;
-            if (opts.bikeSettings && opts.bikeSettings.weight)
-                this.bikeSettings.weight = opts.bikeSettings.weight;
-            const user = opts.user || this.userSettings;
-            const route = opts.route;
+            this.setBikeProps(props);
+            const user = this.user;
+            const { route, onStatusUpdate, gear } = props;
             var info = {};
             this.initData();
             if (isRelaunch) {
@@ -124,38 +178,42 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             }
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    if (!isRelaunch && !this.bike.isConnected()) {
-                        yield this.bike.saveConnect();
-                    }
+                    yield this.connect();
                     if (!info.deviceType) {
                         info.deviceType = yield this.bike.getDeviceType();
                     }
                     if (!info.version) {
                         info.version = yield this.bike.getProtocolVersion();
                     }
+                    console.log('~~~~ starting Daum8i', this.getCyclingMode().getName(), this.getCyclingMode().getModeProperty('eppSupport'));
                     if (this.getCyclingMode().getModeProperty('eppSupport')) {
                         const bikeType = this.getCyclingMode().getSetting('bikeType');
-                        if (!info.upload)
-                            info.upload = yield this.bike.programUpload(bikeType, route, props.onStatusUpdate);
+                        if (!info.upload) {
+                            info.upload = yield this.bike.programUpload(bikeType, route, onStatusUpdate);
+                            if (!info.upload)
+                                throw new Error('Epp Upload failed');
+                        }
                         if (!info.started) {
                             const programId = route ? route.programId : 0;
                             info.started = yield this.bike.startProgram(programId);
+                            if (!info.started) {
+                                throw new Error('Epp start failed');
+                            }
                         }
                     }
                     if (!info.person && this.getCyclingMode().getModeProperty('setPersonSupport')) {
                         info.person = yield this.bike.setPerson(user);
                     }
                     if (!this.getCyclingMode().getModeProperty('eppSupport')) {
-                        const gear = yield this.bike.setGear(this.cyclingData.gear || (opts.gear || 10));
-                        return gear;
+                        info.gear = yield this.bike.setGear(this.cyclingData.gear || gear || DEFAULT_GEAR);
                     }
                     return;
                 }
                 catch (err) {
                     throw (new Error(`could not start device, reason:${err.message}`));
                 }
-            }), 5, 1500)
-                .then(data => {
+            }), 5, this._startRetryTimeout)
+                .then(() => {
                 this.stopped = false;
                 this.paused = false;
                 this.startUpdatePull();
@@ -166,11 +224,13 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
     getCurrentBikeData() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.bike.isConnected()) {
-                yield this.bike.saveConnect();
+                const connected = yield this.bike.connect();
+                if (!connected)
+                    return;
             }
             return this.getBike().getTrainingData();
         });
     }
 }
-exports.default = DaumPremiumDevice;
-DaumPremiumDevice.NAME = PROTOCOL_NAME;
+exports.default = DaumPremiumAdapter;
+DaumPremiumAdapter.NAME = PROTOCOL_NAME;

package/lib/{daum/premium/bike.d.ts → serial/daum/premium/comms.d.ts}

@@ -1,23 +1,24 @@
 /// <reference types="node" />
 import { ReservedCommands } from './utils';
-import { Queue } from '../../utils';
+import { SerialInterface, SerialPortProvider } from '../..';
+import { Queue } from '../../../utils/utils';
 import { EventLogger } from 'gd-eventlog';
-import { User } from "../../types/user";
-import { Route } from "../../types/route";
-import { OnDeviceStartCallback } from "../../device";
-declare class Daum8i {
-    portName: string;
+import { User } from "../../../types/user";
+import { Route } from "../../../types/route";
+import { SerialCommProps } from "../../comm";
+import { SerialPortStream } from "@serialport/stream";
+import { OnDeviceStartCallback } from "./types";
+export default class Daum8i {
     logger: EventLogger;
-    serial: boolean;
-    tcpip: boolean;
+    serial: SerialInterface;
+    path: string;
     tcpipConnection: {
         host: string;
         port: string;
     };
     port: string;
     settings: any;
-    sendRetryDelay: number;
-    sp: any;
+    sp: SerialPortStream;
     props: any;
     connected: boolean;
     blocked: boolean;
@@ -29,26 +30,18 @@ declare class Daum8i {
     cmdCurrent: any;
     cmdStart: number;
     isLoggingPaused: boolean;
-    constructor(props: any);
-    static getClassName(): string;
-    getType(): string;
-    static setSerialPort(spClass: any): void;
-    static setNetImpl(netClass: any): void;
-    static getSupportedInterfaces(): string[];
+    spp: SerialPortProvider;
+    serialportProps: any;
+    constructor(props: SerialCommProps);
+    getInterface(): string;
     getPort(): string;
     isConnected(): boolean;
     pauseLogging(): void;
-    resumLogging(): void;
+    resumeLogging(): void;
     logEvent(e: any): void;
-    setUser(user: any, callback: any): void;
-    getUserWeight(): any;
-    getBikeWeight(): number;
-    unblock(): void;
-    connect(): Promise<void>;
-    reconnect(): Promise<void>;
-    saveConnect(): Promise<unknown>;
-    onPortOpen(): void;
-    onPortClose(): void;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
+    flush(): Promise<void>;
     getLogState(): {
         sending: any;
         busy: any;
@@ -60,24 +53,21 @@ declare class Daum8i {
         waitingForAck: any;
         retry: any;
     };
+    onPortClose(): Promise<void>;
     onPortError(error: any): Promise<void>;
-    errorHandler(): void;
-    saveClose(force?: any): Promise<void>;
     forceClose(updateState?: boolean): Promise<void>;
-    closePort(timeout: any): Promise<boolean>;
-    close(): Promise<void>;
     sendTimeout(message: any): void;
     checkForResponse(): boolean;
     getTimeoutValue(cmd?: any): number;
     onData(data: any, depth?: number): any;
-    sendDaum8iCommand(command: any, queryType: any, payload: any): Promise<unknown>;
+    sendDaum8iCommand(command: string, payload?: string | any[]): Promise<string>;
     writeDone(): void;
-    sendACK(): void;
-    sendNAK(): void;
-    sendReservedDaum8iCommand(command: ReservedCommands, cmdType: any, data?: Buffer): Promise<any[]>;
-    stopWorker(): void;
+    write(buffer: Buffer): Promise<void>;
+    sendACK(): Promise<void>;
+    sendNAK(): Promise<void>;
+    sendReservedDaum8iCommand(command: ReservedCommands, data?: Buffer): Promise<any[]>;
     getProtocolVersion(): Promise<string>;
-    getDashboardVersion(): Promise<unknown>;
+    getDashboardVersion(): Promise<string>;
     getDeviceType(): Promise<any>;
     getActualBikeType(): Promise<any>;
     setActualBikeType(actualBikeType: any): Promise<any>;
@@ -98,7 +88,6 @@ declare class Daum8i {
     }>;
     setLoadControl(enabled: any): Promise<boolean>;
     getLoadControl(): Promise<boolean>;
-    setSlope(slope: any): void;
     setPower(power: any): Promise<number>;
     getPower(power: any): Promise<number>;
     setPerson(person: User): Promise<boolean>;
@@ -111,20 +100,3 @@ declare class Daum8i {
     setGear(gear: any): Promise<number>;
     getGear(): Promise<number>;
 }
-export declare class Daum8iTcp extends Daum8i {
-    static getClassName(): string;
-    getType(): string;
-    static setSerialPort(spClass: any): void;
-    getInterface(): string;
-    static setNetImpl(netClass: any): void;
-    static getSupportedInterfaces(): string[];
-}
-export declare class Daum8iSerial extends Daum8i {
-    static getClassName(): string;
-    getType(): string;
-    getInterface(): string;
-    static setSerialPort(spClass: any): void;
-    static setNetImpl(netClass: any): void;
-    static getSupportedInterfaces(): string[];
-}
-export {};