incyclist-services 1.0.64 → 1.0.66

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

@@ -1,10 +1,13 @@
 /// <reference types="node" />
 import { DeviceProperties } from "incyclist-devices/lib/types/device";
 import { AdapterInfo, ExtendedIncyclistCapability } from "../configuration";
+export type HealthStatus = 'green' | 'amber' | 'red';
 export interface AdapterRideInfo extends AdapterInfo {
     isStarted: boolean;
     tsLastData?: number;
     isHealthy?: boolean;
+    isRestarting?: boolean;
+    dataStatus?: HealthStatus;
     ivToCheck?: NodeJS.Timeout;
 }
 export interface AdapterStateInfo {

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

@@ -39,6 +39,7 @@ export declare class DeviceRideService extends EventEmitter {
     startAdapters(adapters: AdapterRideInfo[], startType: 'start' | 'check' | 'pair', props?: RideServiceDeviceProperties): Promise<boolean>;
     startHealthCheck(ai: AdapterRideInfo): void;
     stopHealthCheck(ai: AdapterRideInfo): void;
+    prepareReconnect(ai: AdapterRideInfo): Promise<void>;
     start(props: RideServiceDeviceProperties): Promise<boolean>;
     startRetry(props: RideServiceDeviceProperties): Promise<boolean>;
     cancelStart(): Promise<boolean>;

package/lib/devices/ride/service.js

@@ -23,7 +23,8 @@ const gd_eventlog_1 = require("gd-eventlog");
 const logging_1 = require("../../utils/logging");
 const incyclist_devices_1 = require("incyclist-devices");
 const timers_1 = require("timers");
-const NO_DATA_THRESHOLD = 5000;
+const NO_DATA_THRESHOLD = 10000;
+const UNHEALTHY_THRESHOLD = 60000;
 class DeviceRideService extends events_1.default {
     static getInstance() {
         if (!DeviceRideService._instance)
@@ -479,18 +480,28 @@ class DeviceRideService extends events_1.default {
                 ai.tsLastData = tsNow;
                 return;
             }
-            const isHealthy = (tsNow - ai.tsLastData) < NO_DATA_THRESHOLD;
-            if (ai.isHealthy && !isHealthy) {
+            const prevStatus = ai.dataStatus;
+            const isAmber = (tsNow - ai.tsLastData) < NO_DATA_THRESHOLD;
+            const isRed = (tsNow - ai.tsLastData) < UNHEALTHY_THRESHOLD;
+            ai.dataStatus = 'green';
+            if (isAmber)
+                ai.dataStatus = 'amber';
+            if (isRed)
+                ai.dataStatus = 'red';
+            if (ai.isHealthy && !isAmber) {
                 ai.isHealthy = false;
                 this.logEvent({ message: 'device unhealthy', device: ai.adapter.getUniqueName(), udid: ai.udid });
                 const { enabledCapabilities } = this.getEnabledCapabilities(ai);
-                this.emit('unhealthy', ai.udid, enabledCapabilities);
+                this.emit('unhealthy', ai.udid, ai.dataStatus, enabledCapabilities);
             }
-            else if (!ai.isHealthy && isHealthy) {
+            else if (!ai.isHealthy && isAmber) {
                 const { enabledCapabilities } = this.getEnabledCapabilities(ai);
                 ai.isHealthy = true;
                 this.logEvent({ message: 'device healthy', device: ai.adapter.getUniqueName(), udid: ai.udid });
-                this.emit('healthy', ai.udid, enabledCapabilities);
+                this.emit('healthy', ai.udid, ai.dataStatus, enabledCapabilities);
+            }
+            if (isAmber && prevStatus === 'green') {
+                this.prepareReconnect(ai);
             }
         };
         ai.ivToCheck = (0, timers_1.setInterval)(check, 1000);
@@ -503,6 +514,61 @@ class DeviceRideService extends events_1.default {
             delete ai.isHealthy;
         }
     }
+    prepareReconnect(ai) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ai.isRestarting)
+                return;
+            yield (0, sleep_1.sleep)(UNHEALTHY_THRESHOLD - NO_DATA_THRESHOLD - 5000);
+            if (ai.isHealthy || ai.isRestarting)
+                return;
+            const ifName = ai.adapter.getInterface();
+            const adapters = this.getAdapterList().filter(ai => ai.adapter.getInterface() === ifName);
+            ai.isRestarting = true;
+            if (!adapters.find(ai => ai.isHealthy)) {
+                this.logger.logEvent({ message: 'restart interface', interface: ifName });
+                const i = incyclist_devices_1.InterfaceFactory.create(ifName);
+                try {
+                    const promisesStop = [];
+                    adapters.map(ai => {
+                        ai.isRestarting = true;
+                        ai.adapter.off('data', this.deviceDataHandler);
+                        promisesStop.push(ai.adapter.stop());
+                    });
+                    if (promisesStop.length > 0) {
+                        yield Promise.allSettled(promisesStop);
+                    }
+                    yield i.disconnect();
+                    yield (0, sleep_1.sleep)(1000);
+                    yield i.connect;
+                    const promisesStart = [];
+                    adapters.map(ai => { promisesStart.push(ai.adapter.start()); });
+                    if (promisesStart.length > 0) {
+                        yield Promise.allSettled(promisesStart);
+                    }
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'restart interface failed', interface: ifName, reason: err.message });
+                }
+                adapters.map(ai => {
+                    ai.adapter.on('data', this.deviceDataHandler);
+                    ai.isRestarting = false;
+                });
+            }
+            else {
+                this.logger.logEvent({ message: 'restart adapter', device: ai.udid });
+                ai.adapter.off('data', this.deviceDataHandler);
+                const adapter = ai.adapter;
+                try {
+                    yield adapter.restart();
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'restart adapter failed', device: ai.udid, reason: err.message });
+                }
+                ai.adapter.on('data', this.deviceDataHandler);
+            }
+            ai.isRestarting = false;
+        });
+    }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.lazyInit();
@@ -567,6 +633,7 @@ class DeviceRideService extends events_1.default {
     pause() {
         const adapters = this.getAdapterList();
         adapters === null || adapters === void 0 ? void 0 : adapters.forEach(ai => {
+            ai.tsLastData = Date.now();
             ai.adapter.pause();
             ai.adapter.off('data', this.deviceDataHandler);
         });
@@ -574,6 +641,7 @@ class DeviceRideService extends events_1.default {
     resume() {
         const adapters = this.getAdapterList();
         adapters === null || adapters === void 0 ? void 0 : adapters.forEach(ai => {
+            ai.tsLastData = Date.now();
             ai.adapter.resume();
             ai.adapter.on('data', this.deviceDataHandler);
         });
@@ -599,7 +667,7 @@ class DeviceRideService extends events_1.default {
         const adapterInfo = adapters === null || adapters === void 0 ? void 0 : adapters.find(ai => ai.adapter.isEqual(deviceSettings));
         if (!adapterInfo)
             return;
-        adapterInfo.tsLastData = Date.now();
+        adapterInfo.tsLastData = data.timestamp || Date.now();
         adapters === null || adapters === void 0 ? void 0 : adapters.forEach(ai => ai.capabilities = ai.adapter.getCapabilities());
         const selectedDevices = this.configurationService.getSelectedDevices();
         this.verifySelected(selectedDevices, incyclist_devices_1.IncyclistCapability.Speed);

package/lib/routes/base/parsers/gpx.d.ts

@@ -0,0 +1,14 @@
+import { FileInfo, IFileLoader } from "../../../api";
+import { RouteApiDetail } from "../api/types";
+import { ParseResult, RouteInfo, RoutePoint } from "../types";
+import { XmlJSON } from "../utils/xml";
+import { XMLParser, XmlParserContext } from "./xml";
+export declare class GPXParser extends XMLParser {
+    protected loader: IFileLoader;
+    import(file: FileInfo, xml: XmlJSON, loader?: IFileLoader): Promise<ParseResult<RouteApiDetail>>;
+    protected loadDescription(context: XmlParserContext): Promise<void>;
+    protected loadPoints(context: XmlParserContext): Promise<void>;
+    protected caclulateDistance(point: RoutePoint, prev: RoutePoint): boolean;
+    protected parseVideo(context: XmlParserContext): Promise<void>;
+    protected buildInfo(context: XmlParserContext): Promise<RouteInfo>;
+}

package/lib/routes/base/parsers/gpx.js

@@ -0,0 +1,126 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GPXParser = void 0;
+const utils_1 = require("../../../utils");
+const route_1 = require("../utils/route");
+const xml_1 = require("./xml");
+const MIN_DISTANCE = 1;
+class GPXParser extends xml_1.XMLParser {
+    import(file, xml, loader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            xml.expectScheme('gpx');
+            this.loader = loader;
+            return yield this.parse(file, xml);
+        });
+    }
+    loadDescription(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = context.data;
+            const metadata = data['metadata'];
+            const track = Array.isArray(data['trk']) ? data['trk'][0] : data['trk'];
+            if (!track) {
+                throw new Error('no track found');
+            }
+            context.route = {
+                title: metadata['name'] || context.fileInfo.name,
+                localizedTitle: track['title'] || track['name'],
+                country: undefined,
+                id: undefined,
+                previewUrl: undefined,
+                distance: 0,
+                elevation: 0,
+                points: [],
+                description: track['desc']
+            };
+            if (typeof context.route.localizedTitle === 'string') {
+                const lt = context.route.localizedTitle;
+                context.route.localizedTitle = { en: lt };
+            }
+        });
+    }
+    loadPoints(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = context.data;
+            const track = Array.isArray(data['trk']) ? data['trk'][0] : data['trk'];
+            const segments = track.trkseg;
+            let prev;
+            segments.forEach(segment => {
+                var _a;
+                (_a = segment.trkpt) === null || _a === void 0 ? void 0 : _a.forEach(gpxPt => {
+                    const point = {
+                        lat: gpxPt.lat,
+                        lng: gpxPt.lon,
+                        elevation: 0,
+                        routeDistance: 0,
+                        distance: 0
+                    };
+                    if (prev) {
+                        const ignore = this.caclulateDistance(point, prev);
+                        if (ignore) {
+                            return;
+                        }
+                    }
+                    context.route.points.push(point);
+                    prev = point;
+                });
+            });
+        });
+    }
+    caclulateDistance(point, prev) {
+        if (prev) {
+            const s = Math.abs(utils_1.geo.calculateDistance(prev.lat, prev.lng, point.lat, point.lng));
+            point.distance += s;
+            point.distance = s;
+            point.routeDistance = prev.routeDistance + s;
+            if (s < MIN_DISTANCE) {
+                return true;
+            }
+        }
+        else {
+            point.distance = 0;
+            point.routeDistance = 0;
+        }
+        return false;
+    }
+    parseVideo(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    buildInfo(context) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { route } = context;
+            const info = {
+                id: route.id,
+                title: route.title,
+                localizedTitle: route.localizedTitle,
+                category: route.category,
+                country: route.country,
+                distance: route.distance,
+                elevation: route.elevation,
+                points: route.points,
+                segments: (_a = route.video) === null || _a === void 0 ? void 0 : _a.selectableSegments,
+                requiresDownload: false,
+                hasGpx: ((_b = route.points) === null || _b === void 0 ? void 0 : _b.length) > 0,
+                hasVideo: true,
+                isDemo: false,
+                isLocal: true,
+                isLoop: (0, route_1.checkIsLoop)(route.points),
+                videoFormat: undefined,
+                videoUrl: undefined,
+                previewUrl: undefined
+            };
+            return info;
+        });
+    }
+}
+exports.GPXParser = GPXParser;

package/lib/routes/base/parsers/xml.d.ts

@@ -15,8 +15,9 @@ export declare class XMLParser implements Parser<XmlJSON, RouteApiDetail> {
     supportsContent(xmljson: XmlJSON): boolean;
     protected loadDescription(context: XmlParserContext): Promise<void>;
     protected parse(file: FileInfo, xmljson: XmlJSON): Promise<ParseResult<RouteApiDetail>>;
+    protected loadPoints(context: XmlParserContext): Promise<void>;
     protected buildInfo(context: XmlParserContext): Promise<RouteInfo>;
-    parseVideo(context: XmlParserContext): Promise<void>;
+    protected parseVideo(context: XmlParserContext): Promise<void>;
     loadElevationFromAltitudes(context: XmlParserContext, tagName?: string): Promise<void>;
     loadElevationFromPositions(context: XmlParserContext, tags?: {
         altitudes?: string;

package/lib/routes/base/parsers/xml.js

@@ -60,13 +60,7 @@ class XMLParser {
             const data = xmljson.json;
             const context = { fileInfo: file, data };
             yield this.loadDescription(context);
-            const positions = data.positions;
-            if ((positions === null || positions === void 0 ? void 0 : positions.length) > 0) {
-                yield this.loadElevationFromPositions(context);
-            }
-            else {
-                yield this.loadElevationFromAltitudes(context);
-            }
+            yield this.loadPoints(context);
             yield this.parseVideo(context);
             const res = {
                 data: yield this.buildInfo(context),
@@ -75,6 +69,18 @@ class XMLParser {
             return res;
         });
     }
+    loadPoints(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = context;
+            const positions = data['positions'];
+            if ((positions === null || positions === void 0 ? void 0 : positions.length) > 0) {
+                yield this.loadElevationFromPositions(context);
+            }
+            else {
+                yield this.loadElevationFromAltitudes(context);
+            }
+        });
+    }
     buildInfo(context) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {

package/lib/routes/base/utils/xml.js

@@ -48,8 +48,11 @@ class XmlJSON {
     }
     expectScheme(scheme) {
         this.detectScheme();
-        if (scheme !== this.scheme)
-            throw new Error(`cannot parse <${this.scheme}>`);
+        if (scheme !== this.scheme) {
+            if (!this._json[scheme])
+                throw new Error(`cannot parse <${this.scheme}>`);
+            this.scheme = scheme;
+        }
     }
     getSchemeData() {
         if (!this.scheme)
@@ -71,9 +74,6 @@ class XmlJSON {
         return this.map(key, item);
     }
     map(key, item) {
-        if (typeof (item) === 'object' && item.$) {
-            return this.map(key, item.$);
-        }
         if (typeof (item) === 'object') {
             const keys = Object.keys(item);
             if (keys.length === 1 && keys[0] === '0') {
@@ -84,7 +84,12 @@ class XmlJSON {
             }
             else {
                 const obj = {};
-                keys.forEach(key => { obj[key] = this.map(key, item[key]); });
+                keys.forEach(key => {
+                    if (key === '$')
+                        Object.assign(obj, this.map(key, item.$));
+                    else
+                        obj[key] = this.map(key, item[key]);
+                });
                 return obj;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.1.26",
+    "incyclist-devices": "^2.1.28",
     "uuid": "^9.0.0",
     "xml2js": "^0.6.2"
   }