incyclist-services 1.0.3 → 1.0.5

package/lib/devices/ride/model.d.ts

@@ -1,3 +1,4 @@
+import { IncyclistCapability } from "incyclist-devices";
 import { DeviceProperties } from "incyclist-devices/lib/types/device";
 import { AdapterInfo } from "../configuration";
 export interface AdapterRideInfo extends AdapterInfo {
@@ -10,6 +11,12 @@ export interface RideServiceDeviceProperties extends DeviceProperties {
     rideMode?: string;
     route?: any;
 }
+export interface RideServiceCheckFilter {
+    interface?: string;
+    interfaces?: string[];
+    udid?: string;
+    capability?: IncyclistCapability;
+}
 export interface Point {
     elevation: number;
     distance: number;

package/lib/devices/ride/service.d.ts

@@ -4,7 +4,7 @@ import { DeviceData, DeviceSettings } from "incyclist-devices";
 import { DeviceAccessService } from "../access/service";
 import { AdapterInfo, DeviceConfigurationService } from "../configuration";
 import CyclingMode, { UpdateRequest } from "incyclist-devices/lib/modes/cycling-mode";
-import { AdapterRideInfo, PreparedRoute, RideServiceDeviceProperties } from "./model";
+import { AdapterRideInfo, PreparedRoute, RideServiceCheckFilter, RideServiceDeviceProperties } from "./model";
 import { UserSettingsService } from "../../settings";
 import { EventLogger } from 'gd-eventlog';
 export declare class DeviceRideService extends EventEmitter {
@@ -34,6 +34,10 @@ export declare class DeviceRideService extends EventEmitter {
     };
     protected getAdapterList(): AdapterRideInfo[];
     prepareEppRoute(props: RideServiceDeviceProperties): PreparedRoute;
+    protected waitForPreviousStartToFinish(): Promise<boolean>;
+    startCheck(filter: RideServiceCheckFilter): Promise<void>;
+    protected getAdapters(filter: RideServiceCheckFilter): AdapterRideInfo[];
+    protected startAdapters(adapters: AdapterRideInfo[], startType: 'start' | 'check', props?: RideServiceDeviceProperties): Promise<boolean>;
     start(props: RideServiceDeviceProperties): Promise<boolean>;
     cancelStart(): Promise<boolean>;
     startRide(_props: any): void;

package/lib/devices/ride/service.js

@@ -267,70 +267,115 @@ class DeviceRideService extends events_1.default {
         }
         return res;
     }
-    start(props) {
+    waitForPreviousStartToFinish() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.lazyInit();
-            const { forceErgMode, startPos, realityFactor, rideMode, route } = props;
-            while (this.startPromises) {
-                (0, sleep_1.sleep)(500);
-            }
-            const adapters = this.getAdapterList();
-            this.emit('start-request', adapters.map(this.getAdapterStateInfo));
+            const TIMEOUT = 3000;
+            if (!this.startPromises)
+                return true;
+            const prevStartState = yield Promise.race([
+                (0, sleep_1.sleep)(TIMEOUT).then(() => 'timeout'),
+                Promise.allSettled(this.startPromises)
+            ]).then(() => 'finished');
+            return (prevStartState === 'finished');
+        });
+    }
+    startCheck(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lazyInit();
+            const adapters = this.getAdapters(filter);
+            const goodToGo = yield this.waitForPreviousStartToFinish();
+            if (!goodToGo)
+                return;
+            this.emit('check-request', adapters.map(this.getAdapterStateInfo));
+            yield this.startAdapters(adapters, 'check');
+        });
+    }
+    getAdapters(filter) {
+        const { udid, interface: ifName, interfaces, capability } = filter;
+        let adapters = this.getAdapterList();
+        const getIf = (adapter) => {
+            var _a;
+            const i = (_a = adapter === null || adapter === void 0 ? void 0 : adapter.getSettings()) === null || _a === void 0 ? void 0 : _a.interface;
+            if (!i)
+                return;
+            if (typeof (i) === 'string')
+                return i;
+            return i.getName();
+        };
+        if (udid) {
+            adapters = adapters === null || adapters === void 0 ? void 0 : adapters.filter(ai => ai.udid === udid);
+        }
+        if (ifName) {
+            adapters = adapters === null || adapters === void 0 ? void 0 : adapters.filter(ai => getIf(ai.adapter) === ifName);
+        }
+        if (interfaces) {
+            adapters = adapters === null || adapters === void 0 ? void 0 : adapters.filter(ai => interfaces.includes(getIf(ai.adapter)));
+        }
+        return adapters || [];
+    }
+    startAdapters(adapters, startType, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { forceErgMode, startPos, realityFactor, rideMode, route } = props || {};
             this.startPromises = adapters.map(ai => {
-                const startProps = (0, clone_1.default)(props);
-                if (ai.adapter.isControllable()) {
-                    const d = ai.adapter;
-                    let mode, settings;
-                    if (!this.simulatorEnforced) {
-                        if (forceErgMode) {
-                            const modes = d.getSupportedCyclingModes().filter(C => C.isERG);
-                            if (modes.length > 0) {
-                                mode = new modes[0](d);
-                                const modeInfo = this.configurationService.getModeSettings(ai.udid, mode);
+                const startProps = (0, clone_1.default)(props || {});
+                if (startType === 'check') {
+                    startProps.timeout = 5000;
+                }
+                if (startType === 'start') {
+                    if (ai.adapter.isControllable()) {
+                        const d = ai.adapter;
+                        let mode, settings;
+                        if (!this.simulatorEnforced) {
+                            if (forceErgMode) {
+                                const modes = d.getSupportedCyclingModes().filter(C => C.isERG);
+                                if (modes.length > 0) {
+                                    mode = new modes[0](d);
+                                    const modeInfo = this.configurationService.getModeSettings(ai.udid, mode);
+                                    settings = modeInfo.settings;
+                                }
+                            }
+                            if (!mode) {
+                                const modeInfo = this.configurationService.getModeSettings(ai.udid);
+                                mode = modeInfo.mode;
                                 settings = modeInfo.settings;
                             }
                         }
-                        if (!mode) {
-                            const modeInfo = this.configurationService.getModeSettings(ai.udid);
-                            mode = modeInfo.mode;
-                            settings = modeInfo.settings;
+                        if (!mode)
+                            mode = d.getDefaultCyclingMode();
+                        d.setCyclingMode(mode, settings);
+                        if (d.getCyclingMode().getModeProperty('eppSupport')) {
+                            startProps.route = this.prepareEppRoute({ route, startPos, realityFactor, rideMode });
+                            startProps.onStatusUpdate = (completed, total) => {
+                                this.emit('start-update', this.getAdapterStateInfo(ai), completed, total);
+                            };
                         }
                     }
-                    if (!mode)
-                        mode = d.getDefaultCyclingMode();
-                    d.setCyclingMode(mode, settings);
-                    if (d.getCyclingMode().getModeProperty('eppSupport')) {
-                        startProps.route = this.prepareEppRoute({ route, startPos, realityFactor, rideMode });
-                        startProps.onStatusUpdate = (completed, total) => {
-                            this.emit('start-update', this.getAdapterStateInfo(ai), completed, total);
-                        };
-                    }
                 }
                 const sType = ai.adapter.hasCapability(incyclist_devices_1.IncyclistCapability.Control) ? 'bike' : 'sensor';
                 const logProps = {};
                 logProps[sType] = ai.adapter.getUniqueName();
                 logProps.cability = ai.adapter.getCapabilities().join('/');
                 logProps.interface = (0, logging_1.getLegacyInterface)(ai.adapter);
-                this.logEvent(Object.assign({ message: `start ${sType} request` }, logProps));
+                this.logEvent(Object.assign({ message: `${startType} ${sType} request` }, logProps));
                 return ai.adapter.start(startProps)
                     .then(success => {
                     if (success) {
-                        this.emit('start-success', this.getAdapterStateInfo(ai));
+                        this.emit(`${startType}-success`, this.getAdapterStateInfo(ai));
                     }
                     ai.isStarted = true;
-                    this.logEvent(Object.assign({ message: `start ${sType} request finished` }, logProps));
+                    this.logEvent(Object.assign({ message: `${startType} ${sType} request finished` }, logProps));
                     return success;
                 })
                     .catch(err => {
                     ai.isStarted = false;
-                    this.logEvent(Object.assign(Object.assign({ message: `start ${sType} request failed` }, logProps), { reason: err.message }));
-                    this.emit('start-error', this.getAdapterStateInfo(ai), err);
+                    this.logEvent(Object.assign(Object.assign({ message: `${startType} ${sType} request failed` }, logProps), { reason: err.message }));
+                    this.emit(`${startType}-error`, this.getAdapterStateInfo(ai), err);
                     return false;
                 });
             });
             const status = yield Promise.all(this.startPromises);
             const allOK = status.find(s => s === false) === undefined;
-            this.emit('start-result', allOK);
+            this.emit(`${startType}-result`, allOK);
             if (allOK) {
                 this.startRide(props);
             }
@@ -338,6 +383,17 @@ class DeviceRideService extends events_1.default {
             return allOK;
         });
     }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lazyInit();
+            const adapters = this.getAdapterList();
+            this.emit('start-request', adapters.map(this.getAdapterStateInfo));
+            const goodToGo = yield this.waitForPreviousStartToFinish();
+            if (!goodToGo)
+                return;
+            return this.startAdapters(adapters, 'start', props);
+        });
+    }
     cancelStart() {
         return __awaiter(this, void 0, void 0, function* () {
             const adapters = this.getAdapterList();
@@ -386,6 +442,8 @@ class DeviceRideService extends events_1.default {
         const hasControl = adapters.find(ai => ai.capabilities.includes(incyclist_devices_1.IncyclistCapability.Control)) !== undefined;
         const hasPower = adapters.find(ai => ai.capabilities.includes(incyclist_devices_1.IncyclistCapability.Power)) !== undefined;
         const adapterInfo = adapters.find(ai => ai.adapter.isEqual(deviceSettings));
+        if (!adapterInfo)
+            return;
         adapterInfo.capabilities.forEach(capability => {
             switch (capability) {
                 case incyclist_devices_1.IncyclistCapability.HeartRate:

package/lib/utils/clone.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 function clone(obj) {
+    if (obj === null || obj === undefined)
+        return obj;
     return JSON.parse(JSON.stringify(obj));
 }
 exports.default = clone;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "peerDependencies": {
     "gd-eventlog": "^0.1.22"
   },
@@ -36,7 +36,7 @@
     "lib": "./src"
   },
   "dependencies": {
-    "incyclist-devices": "^2.0.3",
+    "incyclist-devices": "^2.0.4",
     "uuid": "^9.0.0"
   }
 }