incyclist-services 1.0.70 → 1.0.72

package/lib/devices/pairing/service.js

@@ -823,7 +823,7 @@ class DevicePairingService extends service_2.IncyclistService {
             this.state.tsPrevStart = Date.now();
             this.processConnectedDevices(adapters);
             const selected = this.state.capabilities.map(c => c.selected);
-            const target = adapters.filter(ai => !ai.adapter.isStarted() && selected.includes(ai.udid));
+            const target = adapters.filter(ai => selected.includes(ai.udid));
             if (this.isPairing() && this.state.check.preparing !== preparing) {
                 return;
             }

package/lib/devices/ride/service.js

@@ -340,29 +340,35 @@ class DeviceRideService extends events_1.default {
         }
     }
     checkAntSameDeviceID(adapters) {
-        const antDevices = adapters.map((ai, idx) => (Object.assign(Object.assign({}, ai), { idx })))
-            .filter(ai => ai.adapter.getInterface() === 'ant')
-            .map(ai => ({ idx: ai.idx, deviceID: ai.adapter.getID(), capabilities: ai.capabilities, udid: ai.udid }));
-        const antDeviceIds = antDevices.map(di => di.deviceID);
-        const duplicateIds = antDeviceIds.filter((item, index) => antDeviceIds.indexOf(item) !== index);
-        const score = (capabilities) => {
-            let value = 0;
-            if (capabilities.includes(incyclist_devices_1.IncyclistCapability.Control))
-                value += 100;
-            if (capabilities.includes(incyclist_devices_1.IncyclistCapability.Power))
-                value += 50;
-            value += capabilities.length;
-            return value;
-        };
-        const duplicateDevices = antDevices.filter(di => duplicateIds.includes(di.deviceID)).sort((a, b) => score(b.capabilities) - score(a.capabilities));
-        const leading = duplicateDevices[0];
-        const duplicateAdapters = [];
-        duplicateDevices.forEach((di, i) => {
-            if (i == 0)
-                return;
-            duplicateAdapters.push({ udid: leading.udid, info: adapters[di.idx] });
-        });
-        return duplicateAdapters;
+        try {
+            const antDevices = adapters.map((ai, idx) => (Object.assign(Object.assign({}, ai), { idx })))
+                .filter(ai => ai.adapter.getInterface() === 'ant')
+                .map(ai => ({ idx: ai.idx, deviceID: ai.adapter.getID(), capabilities: ai.capabilities, udid: ai.udid }));
+            const antDeviceIds = antDevices.map(di => di.deviceID);
+            const duplicateIds = antDeviceIds.filter((item, index) => antDeviceIds.indexOf(item) !== index);
+            const score = (capabilities) => {
+                let value = 0;
+                if (capabilities.includes(incyclist_devices_1.IncyclistCapability.Control))
+                    value += 100;
+                if (capabilities.includes(incyclist_devices_1.IncyclistCapability.Power))
+                    value += 50;
+                value += capabilities.length;
+                return value;
+            };
+            const duplicateDevices = antDevices.filter(di => duplicateIds.includes(di.deviceID)).sort((a, b) => score(b.capabilities) - score(a.capabilities));
+            const leading = duplicateDevices[0];
+            const duplicateAdapters = [];
+            duplicateDevices.forEach((di, i) => {
+                if (i == 0)
+                    return;
+                duplicateAdapters.push({ udid: leading.udid, info: adapters[di.idx] });
+            });
+            return duplicateAdapters;
+        }
+        catch (err) {
+            console.log('~~~~ ERROR', err);
+            return [];
+        }
     }
     startAdapters(adapters, startType, props) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -474,6 +480,8 @@ class DeviceRideService extends events_1.default {
     }
     startHealthCheck(ai) {
         const check = () => {
+            if (!ai.ivToCheck)
+                return;
             const tsNow = Date.now();
             const isPaused = ai.adapter.isPaused();
             const prevStatus = ai.dataStatus;
@@ -492,7 +500,6 @@ class DeviceRideService extends events_1.default {
             if (ai.isHealthy && (isAmber || isRed)) {
                 ai.isHealthy = false;
                 this.logEvent({ message: 'device unhealthy', device: ai.adapter.getUniqueName(), udid: ai.udid });
-                console.log('~~~~ health check: prepare reconnect');
                 this.prepareReconnect(ai);
             }
             else if (!ai.isHealthy && !isAmber && !isRed) {
@@ -504,7 +511,10 @@ class DeviceRideService extends events_1.default {
                 this.emit('health', ai.udid, ai.dataStatus, enabledCapabilities);
             }
         };
-        ai.ivToCheck = (0, timers_1.setInterval)(check, 1000);
+        if (ai.ivToCheck) {
+            this.stopHealthCheck(ai);
+        }
+        ai.ivToCheck = (0, timers_1.setInterval)(() => { check(); }, 1000);
         ai.isHealthy = true;
     }
     stopHealthCheck(ai) {
@@ -518,12 +528,9 @@ class DeviceRideService extends events_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (unhealthy.isRestarting)
                 return;
-            console.log('~~~~ health check: wait 45s', unhealthy.udid);
             yield (0, sleep_1.sleep)(UNHEALTHY_THRESHOLD - NO_DATA_THRESHOLD - 5000);
             if (unhealthy.isHealthy || unhealthy.isRestarting)
                 return;
-            console.log('~~~~ health check: still unhealthy', unhealthy.udid, unhealthy.isHealthy, unhealthy.isRestarting);
-            unhealthy.isRestarting = true;
             const ifName = unhealthy.adapter.getInterface();
             const adapters = this.getAdapterList().filter(ai => ai.adapter.getInterface() === ifName);
             if (!adapters.find(ai => ai.isHealthy)) {
@@ -537,52 +544,50 @@ class DeviceRideService extends events_1.default {
     }
     reconnectInterface(ifName, adapters) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log('~~~~ health check: restart interface', ifName);
             this.logger.logEvent({ message: 'restart interface', interface: ifName });
             let stopRequested = false;
             this.once('stop-ride', () => { stopRequested = true; });
-            const i = incyclist_devices_1.InterfaceFactory.create(ifName);
             try {
-                console.log('~~~~ health check: stop Adapters', ifName);
+                const i = incyclist_devices_1.InterfaceFactory.create(ifName);
                 const promisesStop = [];
                 adapters.map(ai => {
-                    if (ai.isRestarting) {
-                        promisesStop.push(this.stopAfterRestart(ai));
-                    }
-                    else {
-                        promisesStop.push(ai.adapter.stop());
-                    }
-                    ai.isRestarting = true;
-                    ai.adapter.off('data', this.deviceDataHandler);
+                    promisesStop.push(this.stopAfterRestart(ai));
                 });
                 if (promisesStop.length > 0) {
-                    yield Promise.allSettled(promisesStop);
+                    yield Promise.race([(0, sleep_1.sleep)(66000), Promise.allSettled(promisesStop)]);
                 }
-                console.log('~~~~ health check: reconnect interface', ifName);
                 if (!stopRequested) {
                     yield i.disconnect();
                     yield (0, sleep_1.sleep)(1000);
                     yield i.connect();
                 }
-                console.log('~~~~ health check: start adapters', ifName);
                 if (!stopRequested) {
                     const promisesStart = [];
                     adapters.map(ai => { promisesStart.push(ai.adapter.start()); });
                     if (promisesStart.length > 0) {
-                        yield Promise.allSettled(promisesStart);
+                        if (ifName === 'ant') {
+                            for (let i = 0; i < promisesStart.length; i++) {
+                                try {
+                                    yield promisesStart[i];
+                                }
+                                catch (_a) {
+                                }
+                            }
+                        }
+                        else {
+                            yield Promise.allSettled(promisesStart);
+                        }
                     }
                 }
             }
             catch (err) {
                 this.logger.logEvent({ message: 'restart interface failed', interface: ifName, reason: err.message });
-                console.log('~~~~ health check: restart interface error', ifName, err);
             }
             adapters.map(ai => {
                 if (ai.adapter.isStarted()) {
                     ai.tsLastData = Date.now();
                 }
                 else {
-                    console.log('~~~~ health check: adapter still not healthy', ifName, ai.udid);
                     ai.isRestarting = false;
                     this.prepareReconnect(ai);
                 }
@@ -593,19 +598,26 @@ class DeviceRideService extends events_1.default {
     }
     stopAfterRestart(unhealthy) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.emit('stop-adapter', unhealthy.udid);
             if (unhealthy.isRestarting) {
                 yield new Promise(done => {
+                    const to = setTimeout(done, 65000);
                     this.once('stop-adapter-confirmed', (udid) => {
-                        if (udid === unhealthy.udid)
+                        if (udid === unhealthy.udid) {
+                            clearTimeout(to);
                             done();
+                        }
                     });
                 });
             }
+            unhealthy.isRestarting = true;
+            unhealthy.adapter.off('data', this.deviceDataHandler);
             yield unhealthy.adapter.stop();
         });
     }
     reconnectSingle(unhealthy) {
         return __awaiter(this, void 0, void 0, function* () {
+            unhealthy.isRestarting = true;
             let stopRequested = false;
             this.once('stop-ride', () => { stopRequested = true; });
             this.once('stop-adapter', (udid) => {
@@ -614,7 +626,6 @@ class DeviceRideService extends events_1.default {
             });
             let success = false;
             do {
-                console.log('~~~~ health check: restart adapter', unhealthy.udid);
                 this.logger.logEvent({ message: 'restart adapter', device: unhealthy.udid });
                 unhealthy.adapter.off('data', this.deviceDataHandler);
                 const adapter = unhealthy.adapter;
@@ -677,7 +688,7 @@ class DeviceRideService extends events_1.default {
     startRide(_props) {
         const adapters = this.getAdapterList();
         adapters === null || adapters === void 0 ? void 0 : adapters.forEach(ai => {
-            ai.adapter.removeAllListeners('data');
+            ai.adapter.off('data', this.deviceDataHandler);
             ai.adapter.on('data', this.deviceDataHandler);
         });
     }
@@ -705,6 +716,7 @@ class DeviceRideService extends events_1.default {
             ai.tsLastData = Date.now();
             ai.adapter.pause();
             ai.adapter.off('data', this.deviceDataHandler);
+            this.stopHealthCheck(ai);
         });
     }
     resume() {
@@ -713,6 +725,7 @@ class DeviceRideService extends events_1.default {
             ai.tsLastData = Date.now();
             ai.adapter.resume();
             ai.adapter.on('data', this.deviceDataHandler);
+            this.startHealthCheck(ai);
         });
     }
     verifySelected(selectedDevices, capability) {

package/lib/routes/list/service.js

@@ -222,7 +222,7 @@ class RouteListService extends service_1.IncyclistService {
                 }
                 console.log('~~~ DATA', content);
                 const parser = parsers.findMatching(file.ext, content);
-                const res = yield parser.import(file, content);
+                const res = yield parser.import(file, content, this.loader);
                 const data = res.data;
                 data.state = 'loaded';
                 const details = res.data;

package/lib/settings/user/service.d.ts

@@ -2,15 +2,19 @@ import { EventLogger } from 'gd-eventlog';
 import { IUserSettingsBinding } from './bindings';
 export declare class UserSettingsService {
     static _instance: UserSettingsService;
+    static _defaultBinding: IUserSettingsBinding;
     settings: any;
     binding: IUserSettingsBinding;
     logger: EventLogger;
     isInitialized: boolean;
     isDirty: boolean;
     savePromise: Promise<boolean> | null;
+    instanceId: number;
+    initPromise: Promise<boolean>;
     static getInstance(): UserSettingsService;
     constructor(binding?: IUserSettingsBinding);
     setBinding(binding: IUserSettingsBinding): void;
+    static setDefaultBinding(binding: IUserSettingsBinding): void;
     init(): Promise<boolean>;
     getAll(): any;
     get(key: string, defValue: any): any;

package/lib/settings/user/service.js

@@ -30,19 +30,29 @@ class UserSettingsService {
         this.isInitialized = false;
         this.isDirty = false;
         this.savePromise = null;
+        this.instanceId = Date.now();
+        this.initPromise = undefined;
         this.setBinding(binding);
     }
     setBinding(binding) {
         this.binding = binding;
+        UserSettingsService.setDefaultBinding(binding);
+    }
+    static setDefaultBinding(binding) {
+        UserSettingsService._defaultBinding = binding;
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isInitialized)
                 return true;
-            if (!this.binding)
+            if (this.initPromise)
+                return yield this.initPromise;
+            const binding = this.binding || UserSettingsService._defaultBinding;
+            if (!binding)
                 return false;
             try {
-                this.settings = yield this.binding.getAll();
+                this.initPromise = binding.getAll();
+                this.settings = yield this.initPromise;
                 this.logger.logEvent({ message: 'settings loaded' });
                 this.isInitialized = true;
                 return true;
@@ -175,6 +185,7 @@ exports.useUserSettings = useUserSettings;
 const initUserSettings = (binding) => {
     const us = UserSettingsService.getInstance();
     us.setBinding(binding);
+    us.init();
     return us;
 };
 exports.initUserSettings = initUserSettings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.0.70",
+  "version": "1.0.72",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.1.29",
+    "incyclist-devices": "^2.1.31",
     "uuid": "^9.0.0",
     "xml2js": "^0.6.2"
   }