incyclist-services 1.0.62 → 1.0.63

package/lib/api/repository/types.d.ts

@@ -27,7 +27,7 @@ export interface FileLoaderResult {
 }
 export interface FileInfo {
     type: 'url' | 'file';
-    url: string;
+    url?: string;
     name: string;
     dir: string;
     ext: string;

package/lib/devices/access/service.js

@@ -175,7 +175,6 @@ class DeviceAccessService extends events_1.default {
                         this.connect(name); });
                     return;
                 }
-                console.log('~~~ DEBUG:connect if', ifaceName, this.interfaces[ifaceName]);
                 if (((_a = this.interfaces[ifaceName]) === null || _a === void 0 ? void 0 : _a.enabled) === false)
                     return;
                 const impl = this.getInterface(ifaceName);
@@ -189,6 +188,7 @@ class DeviceAccessService extends events_1.default {
                     return true;
                 this.interfaces[ifaceName].state = 'connecting';
                 this.emit('interface-changed', ifaceName, Object.assign(Object.assign({}, this.interfaces[ifaceName]), { state: 'connecting' }));
+                yield impl.disconnect();
                 const connected = yield impl.connect();
                 const state = connected ? 'connected' : 'disconnected';
                 this.interfaces[ifaceName].state = state;

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

@@ -54,6 +54,7 @@ export interface InternalPairingState extends PairingState {
     check?: {
         preparing?: number;
         promise?: Promise<boolean>;
+        to?: NodeJS.Timeout;
     };
     scan?: {
         preparing?: number;

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { DeviceAccessService } from "../access/service";
 import { AdapterInfo, CapabilityInformation, DeviceConfigurationInfo, DeviceConfigurationService, IncyclistDeviceSettings, InterfaceSetting } from "../configuration";
 import { CapabilityData, DevicePairingData, DevicePairingStatus, DeviceSelectState, InternalPairingState, PairingProps, PairingSettings, PairingState } from "./model";
@@ -32,6 +33,7 @@ export declare class DevicePairingService extends IncyclistService {
     static getInstance(): DevicePairingService;
     constructor(services?: Services);
     start(onStateChanged: (newState: PairingState) => void): Promise<void>;
+    protected loadConfiguration(): Promise<void>;
     protected initConfigHandlers(): void;
     protected removeConfigHandlers(): void;
     stop(): Promise<void>;
@@ -41,6 +43,7 @@ export declare class DevicePairingService extends IncyclistService {
     deleteDevice(capability: IncyclistCapability, udid: string, deleteAll?: boolean): Promise<void>;
     unselectDevices(capability: IncyclistCapability): Promise<void>;
     changeInterfaceSettings(name: string, settings: InterfaceSetting): Promise<void>;
+    protected restartPair(): Promise<void>;
     protected restart(): Promise<void>;
     protected _stop(): Promise<void>;
     protected getCapability(capability: IncyclistCapability | CapabilityData): CapabilityData;
@@ -77,6 +80,7 @@ export declare class DevicePairingService extends IncyclistService {
     private stopPairing;
     protected run(props?: PairingProps): Promise<void>;
     private startPairing;
+    private isReadyToPair;
     private processConnectedDevices;
     private startScanning;
     protected deregisterScanningDataHandlers(): void;
@@ -105,6 +109,7 @@ export declare class DevicePairingService extends IncyclistService {
     protected deleteCapabilityDevice(capability: IncyclistCapability, udid: string, shouldEmit?: boolean): void;
     protected isScanning(): boolean;
     protected isPairing(): boolean;
+    protected isPairingWaiting(): NodeJS.Timeout;
     protected _stopDeviceSelection(changed: boolean): Promise<void>;
     private numberOfSelectedCababilities;
     protected addToDeletedList(capability: IncyclistCapability | CapabilityData, udid: string): void;

package/lib/devices/pairing/service.js

@@ -69,16 +69,7 @@ class DevicePairingService extends service_2.IncyclistService {
                     this.emitStateChange(this.state);
                     return;
                 }
-                yield this.waitForInit();
-                const { capabilities, interfaces } = this.configuration.load();
-                const state = Object.assign({}, this.state);
-                delete state.adapters;
-                this.state.capabilities = this.mappedCapabilities(capabilities);
-                this.state.interfaces = this.access.enrichWithAccessState(interfaces);
-                this.state.canStartRide = this.configuration.canStartRide();
-                this.state.stopRequested = false;
-                this.state.stopped = false;
-                this.logCapabilities();
+                yield this.loadConfiguration();
                 this.state.interfaces.forEach(i => {
                     if (!this.isInterfaceEnabled(i.name))
                         this.unselectOnInterface(i.name);
@@ -93,6 +84,20 @@ class DevicePairingService extends service_2.IncyclistService {
             }
         });
     }
+    loadConfiguration() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForInit();
+            const { capabilities, interfaces } = this.configuration.load();
+            const state = Object.assign({}, this.state);
+            delete state.adapters;
+            this.state.capabilities = this.mappedCapabilities(capabilities);
+            this.state.interfaces = this.access.enrichWithAccessState(interfaces);
+            this.state.canStartRide = this.configuration.canStartRide();
+            this.state.stopRequested = false;
+            this.state.stopped = false;
+            this.logCapabilities();
+        });
+    }
     initConfigHandlers() {
         this.configuration.on('interface-changed', this.onInterfaceConfigChangedHandler);
         this.configuration.on('capability-changed', this.onConfigurationUpdateHandler);
@@ -242,6 +247,17 @@ class DevicePairingService extends service_2.IncyclistService {
             }
         });
     }
+    restartPair() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isPairing())
+                return;
+            if ((_a = this.state.check) === null || _a === void 0 ? void 0 : _a.to)
+                clearTimeout((_b = this.state.check) === null || _b === void 0 ? void 0 : _b.to);
+            delete this.state.check;
+            this.run();
+        });
+    }
     restart() {
         return __awaiter(this, void 0, void 0, function* () {
             const wasActive = this.isPairing() || this.isScanning();
@@ -437,6 +453,7 @@ class DevicePairingService extends service_2.IncyclistService {
             this.logEvent({ message: 'interface state changed', interface: ifName, state: ifDetails.state });
             try {
                 let restartScan = false;
+                let restartPair = false;
                 if (interfacesNew) {
                     const getData = (i) => ({ name: i.name, enabled: i.enabled, state: i.state });
                     if (!prev)
@@ -449,6 +466,20 @@ class DevicePairingService extends service_2.IncyclistService {
                     const changedIdx = prev.findIndex(i => i.name === ifName);
                     if (ifDetails.state === 'disconnected' && current.state !== 'disconnected') {
                         this.failAdaptersOnInterface(ifName);
+                        if (this.isPairing()) {
+                            const pairing = this.getPairingInterfaces();
+                            if (pairing.includes(ifName)) {
+                                try {
+                                    current.state = 'disconnected';
+                                    this.emitStateChange({ interfaces: this.state.interfaces });
+                                    yield (0, utils_1.sleep)(1000);
+                                    this.access.connect(ifName);
+                                }
+                                catch (err) {
+                                    this.logError(err, 'reconnect');
+                                }
+                            }
+                        }
                     }
                     else if (ifDetails.state === 'unavailable' && current.state !== 'unavailable') {
                         this.disableAdaptersOnInterface(ifName);
@@ -460,12 +491,18 @@ class DevicePairingService extends service_2.IncyclistService {
                     else if (ifDetails.state === 'connected' && current.state !== 'connected' && !this.isPairing()) {
                         restartScan = true;
                     }
+                    else if (ifDetails.state === 'connected' && current.state !== 'connected' && this.isPairingWaiting()) {
+                        restartPair = true;
+                    }
                     if (changedIdx !== -1) {
                         prev[changedIdx].isScanning = ifDetails.isScanning;
                         prev[changedIdx].state = ifDetails.state;
                     }
                     if (restartScan)
                         this.restart();
+                    if (restartPair) {
+                        this.restartPair();
+                    }
                     this.emitStateChange({ interfaces: this.state.interfaces });
                 }
             }
@@ -770,16 +807,15 @@ class DevicePairingService extends service_2.IncyclistService {
             const preparing = DevicePairingService.checkCounter++;
             this.state.check = { preparing };
             this.emit('pairing-start');
-            const requiredInterfaces = this.getPairingInterfaces();
-            const busyRequired = this.state.interfaces
-                .filter(i => requiredInterfaces.includes(i.name))
-                .find(i => i.enabled && i.state !== 'connected' && i.state !== 'unavailable');
-            const isReady = busyRequired === undefined;
+            const { isReady, busyRequired } = this.isReadyToPair();
             if (!isReady) {
-                setTimeout(() => {
+                this.logEvent({ message: 'Pairing: waiting for interfaces', interfaces: busyRequired === null || busyRequired === void 0 ? void 0 : busyRequired.name });
+                this.state.check.to = setTimeout(() => {
                     if ((!this.isPairing() || this.state.check.preparing === preparing) && !this.isScanning()) {
-                        delete this.state.check;
-                        this.run();
+                        const { isReady } = this.isReadyToPair();
+                        if (isReady) {
+                            delete this.state.check;
+                        }
                     }
                 }, 1000);
                 return;
@@ -810,6 +846,14 @@ class DevicePairingService extends service_2.IncyclistService {
             }
         });
     }
+    isReadyToPair() {
+        const requiredInterfaces = this.getPairingInterfaces();
+        const busyRequired = this.state.interfaces
+            .filter(i => requiredInterfaces.includes(i.name))
+            .find(i => i.enabled && i.state !== 'connected' && i.state !== 'unavailable');
+        const isReady = busyRequired === undefined;
+        return { isReady, busyRequired };
+    }
     processConnectedDevices(adapters) {
         const started = adapters.filter(ai => ai.adapter.isStarted());
         started.forEach(ai => {
@@ -1105,6 +1149,9 @@ class DevicePairingService extends service_2.IncyclistService {
         var _a;
         return this.state.check !== undefined && ((_a = this.state) === null || _a === void 0 ? void 0 : _a.check) !== null;
     }
+    isPairingWaiting() {
+        return this.isPairing() && this.state.check.to;
+    }
     _stopDeviceSelection(changed) {
         return __awaiter(this, void 0, void 0, function* () {
             this.deviceSelectState = null;

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

@@ -0,0 +1,5 @@
+import { XMLParser } from './xml';
+export declare class IncyclistXMLParser extends XMLParser {
+    static SCHEME: string;
+    protected getGPXFileContent(url: any): Promise<any>;
+}

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

@@ -0,0 +1,27 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncyclistXMLParser = void 0;
+const axios_1 = __importDefault(require("axios"));
+const xml_1 = require("./xml");
+class IncyclistXMLParser extends xml_1.XMLParser {
+    getGPXFileContent(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield axios_1.default.get(url);
+            return res.data;
+        });
+    }
+}
+exports.IncyclistXMLParser = IncyclistXMLParser;
+IncyclistXMLParser.SCHEME = 'gpx-import';

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

@@ -17,11 +17,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useParsers = void 0;
 __exportStar(require("./kwt"), exports);
 const factory_1 = require("./factory");
+const incyclist_xml_1 = require("./incyclist-xml");
 const kwt_1 = require("./kwt");
+const multixml_1 = require("./multixml");
 const useParsers = () => {
     const parsers = factory_1.ParserFactory.getInstance();
     if (!parsers.isInitialized()) {
-        parsers.add(new kwt_1.KWTParser());
+        parsers.add(new multixml_1.MultipleXMLParser([kwt_1.KWTParser, incyclist_xml_1.IncyclistXMLParser]));
         parsers.setInitialized(true);
     }
     return parsers;

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { FileInfo, IFileLoader } from "../../../api";
+import { RouteApiDetail } from "../api/types";
+import { ParseResult, Parser } from "../types";
+import { XMLParser } from "./xml";
+export declare class MultipleXMLParser implements Parser<string | Buffer, RouteApiDetail> {
+    protected parsers: any;
+    constructor(classes: Array<typeof XMLParser>);
+    import(file: FileInfo, data: string | Buffer, loader?: IFileLoader): Promise<ParseResult<RouteApiDetail>>;
+    supportsExtension(extension: string): boolean;
+    supportsContent(): boolean;
+}

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

@@ -0,0 +1,37 @@
+"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.MultipleXMLParser = void 0;
+const xml_1 = require("../utils/xml");
+class MultipleXMLParser {
+    constructor(classes) {
+        this.parsers = [];
+        classes.forEach(C => {
+            const parser = new C();
+            this.parsers.push(parser);
+        });
+    }
+    import(file, data, loader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const str = Buffer.isBuffer(data) ? data.toString() : data;
+            const xmlJson = yield (0, xml_1.parseXml)(str);
+            const parser = this.parsers.find(p => p.supportsContent(xmlJson));
+            return yield parser.import(file, xmlJson, loader);
+        });
+    }
+    supportsExtension(extension) {
+        return (extension === null || extension === void 0 ? void 0 : extension.toLowerCase()) === 'xml';
+    }
+    supportsContent() {
+        return true;
+    }
+}
+exports.MultipleXMLParser = MultipleXMLParser;

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

@@ -4,6 +4,4 @@ export declare const addVideoSpeed: (points: Array<RoutePoint>, video: any) => A
 export declare const getReferencedFileInfo: (info: FileInfo, referenced: {
     file?: string;
     url?: string;
-}, scheme?: string) => {
-    url: string;
-};
+}, scheme?: string) => string;

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

@@ -35,23 +35,23 @@ const addVideoSpeed = (points, video) => {
 exports.addVideoSpeed = addVideoSpeed;
 const getReferencedFileInfo = (info, referenced, scheme = 'file') => {
     if (info.type !== 'url')
-        return;
+        return info.url;
     const target = {};
     let fileName = referenced.file;
     if (referenced.url) {
-        return { url: referenced.url };
+        return referenced.url;
     }
     if (fileName) {
         const inputUrl = info.url;
         const regex = /(\\|\/)/g;
         if (fileName.startsWith('http://') || fileName.startsWith('https://')) {
-            return { url: fileName };
+            return fileName;
         }
         else if (fileName.search(regex) === -1) {
             if (inputUrl.startsWith('incyclist:') || inputUrl.startsWith('file:')) {
                 const parts = inputUrl.split('://');
                 const targetPath = parts[1].replace(info.name, fileName);
-                return { url: `${scheme}://${targetPath}` };
+                return `${scheme}://${targetPath}`;
             }
         }
         else {
@@ -61,8 +61,9 @@ const getReferencedFileInfo = (info, referenced, scheme = 'file') => {
                 target.url = `${scheme}:///${fileName}`;
             }
             else {
-                referenced.url = `${scheme}:///${fileName}`;
+                target.url = `${scheme}:///${fileName}`;
             }
+            return target.url;
         }
     }
 };

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

@@ -1,10 +1,25 @@
 import { XmlJSON } from '../utils/xml';
 import { RouteApiDetail } from '../api/types';
-import { ParseResult, Parser } from '../types';
-export declare abstract class XMLParser implements Parser<XmlJSON, RouteApiDetail> {
-    import(xml: XmlJSON): Promise<ParseResult<RouteApiDetail>>;
+import { ParseResult, Parser, RouteInfo } from '../types';
+import { FileInfo, IFileLoader, JSONObject } from '../../../api';
+export type XmlParserContext = {
+    fileInfo: FileInfo;
+    data: JSONObject;
+    route?: RouteApiDetail;
+};
+export declare class XMLParser implements Parser<XmlJSON, RouteApiDetail> {
+    protected loader: IFileLoader;
+    import(file: FileInfo, xml: XmlJSON, loader?: IFileLoader): Promise<ParseResult<RouteApiDetail>>;
     getSupportedSheme(): string;
     supportsExtension(extension: string): boolean;
     supportsContent(xmljson: XmlJSON): boolean;
-    protected parse(xmljson: XmlJSON): ParseResult<RouteApiDetail>;
+    protected loadDescription(context: XmlParserContext): Promise<void>;
+    protected parse(file: FileInfo, xmljson: XmlJSON): Promise<ParseResult<RouteApiDetail>>;
+    protected buildInfo(context: XmlParserContext): Promise<RouteInfo>;
+    parseVideo(context: XmlParserContext): Promise<void>;
+    loadElevationFromAltitudes(context: XmlParserContext, tagName?: string): Promise<void>;
+    loadElevationFromPositions(context: XmlParserContext, tags?: {
+        altitudes?: string;
+        positions?: string;
+    }): Promise<void>;
 }

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

@@ -13,12 +13,14 @@ exports.XMLParser = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const xml_1 = require("../utils/xml");
 const route_1 = require("../utils/route");
+const utils_1 = require("./utils");
 let _logger;
 class XMLParser {
-    import(xml) {
+    import(file, xml, loader) {
         return __awaiter(this, void 0, void 0, function* () {
             xml.expectScheme(this.getSupportedSheme());
-            return this.parse(xml);
+            this.loader = loader;
+            return yield this.parse(file, xml);
         });
     }
     getSupportedSheme() {
@@ -30,174 +32,202 @@ class XMLParser {
     }
     supportsContent(xmljson) {
         const json = xmljson.json;
-        return json.kwt !== undefined && json.kwt !== null;
+        const scheme = this.getSupportedSheme();
+        return json[scheme] !== undefined && json[scheme] !== null;
     }
-    parse(xmljson) {
-        const data = xmljson.json;
-        const route = {
-            title: data.name,
-            localizedTitle: data.title || data.name,
-            country: data.country,
-            id: data.id,
-            category: 'personal',
-            previewUrl: data.previewURL,
-            distance: 0,
-            elevation: 0,
-            points: [],
-            description: data.description1
-        };
-        const positions = data.positions;
-        if ((positions === null || positions === void 0 ? void 0 : positions.length) > 0) {
-            loadElevationFromPositions(data, route);
-        }
-        else {
-            loadElevationFromAltitudes(data, route);
-        }
-        parseVideo(data, route);
-        const res = {
-            data: buildInfo(route),
-            details: route
-        };
-        return res;
+    loadDescription(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = context.data;
+            context.route = {
+                title: data['name'],
+                localizedTitle: data['title'] || data['name'],
+                country: data['country'],
+                id: data['id'],
+                previewUrl: data['previewURL'],
+                distance: 0,
+                elevation: 0,
+                points: [],
+                description: data['description1']
+            };
+            if (typeof context.route.localizedTitle === 'string') {
+                const lt = context.route.localizedTitle;
+                context.route.localizedTitle = { en: lt };
+            }
+        });
     }
-}
-exports.XMLParser = XMLParser;
-const buildInfo = (route) => {
-    var _a, _b;
-    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: route.video.format,
-        videoUrl: getVideoUrl(route),
-        previewUrl: getPreviewUrl(route)
-    };
-    return info;
-};
-const getVideoUrl = (route) => {
-    return 'url';
-};
-const getPreviewUrl = (route) => {
-    return 'url';
-};
-const parseVideo = (json, route) => {
-    route.video = {
-        file: json['video-file-path'],
-        url: undefined,
-        framerate: parseFloat(json['framerate']),
-        next: json['next-video'],
-        mappings: [],
-        format: undefined,
-        selectableSegments: json['segments'],
-        infoTexts: json['informations'],
-    };
-    console.log(route.video);
-    const fileParts = route.video.file.split('.');
-    const extension = fileParts[fileParts.length - 1];
-    route.video.format = extension.toLowerCase();
-    const mappings = json['mappings'];
-    if (mappings) {
-        let prev;
-        let prevTime = 0;
-        const startFrame = parseInt(json['start-frame'] || 0);
-        const endFrame = json['end-frame'] ? parseInt(json['end-frame']) : undefined;
-        try {
-            const getDistance = (mapping, prevMapping, idx) => {
-                const prevDist = prevMapping.distance || 0;
-                const prevFrame = prevMapping.frame || startFrame;
-                if (mapping.distance !== undefined)
-                    return mapping.distance;
-                if (prev.dpf !== undefined && mapping.frame !== undefined)
-                    return prev.dpf * (mapping.frame - prevFrame) + prevDist;
-                throw new Error(`mapping #${idx || 'total'}: one of [distance], [dpf or frame] is missing: <mapping ${(0, xml_1.toXml)(mapping)}/>`);
+    parse(file, xmljson) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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.parseVideo(context);
+            const res = {
+                data: yield this.buildInfo(context),
+                details: context.route
+            };
+            return res;
+        });
+    }
+    buildInfo(context) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { fileInfo, 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: route.video.format,
+                videoUrl: getVideoUrl(fileInfo, route),
+                previewUrl: getPreviewUrl(fileInfo, route)
+            };
+            return info;
+        });
+    }
+    parseVideo(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, route } = context;
+            route.video = {
+                file: data['video-file-path'],
+                url: undefined,
+                framerate: parseFloat(data['framerate']),
+                next: data['next-video'],
+                mappings: [],
+                format: undefined,
+                selectableSegments: data['segments'],
+                infoTexts: data['informations'],
             };
-            mappings.forEach((mapping, idx) => {
-                if (idx !== 0) {
-                    mapping.distance = (mapping.distance !== undefined && mapping.distance !== null) ? parseInt(mapping.distance) : undefined;
-                    mapping.dpf = (mapping.dpf !== undefined && mapping.dpf !== null) ? parseFloat(mapping.dpf) : undefined;
-                    mapping.frame = (mapping.frame !== undefined && mapping.frame !== null) ? parseInt(mapping.frame) : undefined;
-                    const distance = getDistance(mapping, prev, idx);
-                    route.distance = mapping.distance = distance;
-                    const frames = mapping.frame - (prev.frame || startFrame);
-                    const videoSpeed = (prev.distance === undefined && mapping.dpf !== undefined) ? 3.6 * mapping.dpf * route.video.framerate : 3.6 * (distance - prev.distance) / frames * route.video.framerate;
-                    const time = prevTime + frames / route.video.framerate;
-                    route.video.mappings.push(Object.assign({ videoSpeed, time: prevTime }, prev));
-                    prev = mapping;
-                    prevTime = time;
-                    if (idx === mappings.length - 1) {
-                        route.video.mappings.push(Object.assign({ videoSpeed, time }, mapping));
+            console.log(route.video);
+            const fileParts = route.video.file.split('.');
+            const extension = fileParts[fileParts.length - 1];
+            route.video.format = extension.toLowerCase();
+            const mappings = data['mappings'];
+            if (mappings) {
+                let prev;
+                let prevTime = 0;
+                const startFrame = parseInt(data['start-frame'] || 0);
+                const endFrame = data['end-frame'] ? parseInt(data['end-frame']) : undefined;
+                try {
+                    const getDistance = (mapping, prevMapping, idx) => {
+                        const prevDist = prevMapping.distance || 0;
+                        const prevFrame = prevMapping.frame || startFrame;
+                        if (mapping.distance !== undefined)
+                            return mapping.distance;
+                        if (prev.dpf !== undefined && mapping.frame !== undefined)
+                            return prev.dpf * (mapping.frame - prevFrame) + prevDist;
+                        throw new Error(`mapping #${idx || 'total'}: one of [distance], [dpf or frame] is missing: <mapping ${(0, xml_1.toXml)(mapping)}/>`);
+                    };
+                    mappings.forEach((mapping, idx) => {
+                        if (idx !== 0) {
+                            mapping.distance = (mapping.distance !== undefined && mapping.distance !== null) ? parseInt(mapping.distance) : undefined;
+                            mapping.dpf = (mapping.dpf !== undefined && mapping.dpf !== null) ? parseFloat(mapping.dpf) : undefined;
+                            mapping.frame = (mapping.frame !== undefined && mapping.frame !== null) ? parseInt(mapping.frame) : undefined;
+                            const distance = getDistance(mapping, prev, idx);
+                            route.distance = mapping.distance = distance;
+                            const frames = mapping.frame - (prev.frame || startFrame);
+                            const videoSpeed = (prev.distance === undefined && mapping.dpf !== undefined) ? 3.6 * mapping.dpf * route.video.framerate : 3.6 * (distance - prev.distance) / frames * route.video.framerate;
+                            const time = prevTime + frames / route.video.framerate;
+                            route.video.mappings.push(Object.assign({ videoSpeed, time: prevTime }, prev));
+                            prev = mapping;
+                            prevTime = time;
+                            if (idx === mappings.length - 1) {
+                                route.video.mappings.push(Object.assign({ videoSpeed, time }, mapping));
+                            }
+                        }
+                        else {
+                            mapping.distance = (mapping.distance !== undefined && mapping.distance !== null) ? parseInt(mapping.distance) : undefined;
+                            mapping.dpf = (mapping.dpf !== undefined && mapping.dpf !== null) ? parseFloat(mapping.dpf) : undefined;
+                            mapping.frame = (mapping.frame !== undefined && mapping.frame !== null) ? parseInt(mapping.frame) : undefined;
+                            prev = mapping;
+                            prevTime = 0;
+                        }
+                    });
+                    if (endFrame && prev.dpf !== undefined) {
+                        const mapping = { frame: endFrame, dpf: prev.dpf };
+                        route.distance = getDistance(mapping, prev);
                     }
                 }
-                else {
-                    mapping.distance = (mapping.distance !== undefined && mapping.distance !== null) ? parseInt(mapping.distance) : undefined;
-                    mapping.dpf = (mapping.dpf !== undefined && mapping.dpf !== null) ? parseFloat(mapping.dpf) : undefined;
-                    mapping.frame = (mapping.frame !== undefined && mapping.frame !== null) ? parseInt(mapping.frame) : undefined;
-                    prev = mapping;
-                    prevTime = 0;
+                catch (err) {
+                    if (!_logger)
+                        _logger = new gd_eventlog_1.EventLogger('XmlParser');
+                    _logger.logEvent({ message: 'xml details', error: err.message, mappings });
+                    throw new Error('Could not parse XML File');
                 }
-            });
-            if (endFrame && prev.dpf !== undefined) {
-                const mapping = { frame: endFrame, dpf: prev.dpf };
-                route.distance = getDistance(mapping, prev);
             }
-        }
-        catch (err) {
-            if (!_logger)
-                _logger = new gd_eventlog_1.EventLogger('XmlParser');
-            _logger.logEvent({ message: 'xml details', error: err.message, mappings });
-            throw new Error('Could not parse XML File');
-        }
+        });
     }
-};
-const loadElevationFromAltitudes = (json, route) => {
-    const altitudes = json['altitudes'];
-    if (!altitudes)
-        return;
-    route.points = altitudes.map(a => ({
-        routeDistance: Number(a.distance),
-        elevation: Number(a.height),
-    }));
-    const points = route.points;
-    if ((points === null || points === void 0 ? void 0 : points.length) > 0) {
-        route.distance = points[points.length - 1].routeDistance;
+    loadElevationFromAltitudes(context, tagName = 'altitudes') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, route } = context;
+            const altitudes = data[tagName];
+            if (!altitudes)
+                return;
+            route.points = altitudes.map(a => ({
+                routeDistance: Number(a.distance),
+                elevation: Number(a.height),
+            }));
+            const points = route.points;
+            if ((points === null || points === void 0 ? void 0 : points.length) > 0) {
+                route.distance = points[points.length - 1].routeDistance;
+            }
+            (0, route_1.updateSlopes)(points);
+        });
+    }
+    loadElevationFromPositions(context, tags) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, route } = context;
+            const altitudes = data[(tags === null || tags === void 0 ? void 0 : tags.altitudes) || 'altitudes'];
+            const positions = data[(tags === null || tags === void 0 ? void 0 : tags.positions) || 'positions'];
+            if (!positions)
+                return;
+            let prevAltitude = undefined;
+            let prevDistance = 0;
+            route.elevation = 0;
+            const points = [];
+            positions.forEach((pos, i) => {
+                const altitude = getAltitude(altitudes, positions, i, prevAltitude);
+                const elevationGain = altitude - prevAltitude;
+                const pi = createPoint(pos, altitude, prevDistance);
+                points.push(pi.point);
+                route.distance = pi.point.routeDistance;
+                if (elevationGain > 0)
+                    route.elevation += elevationGain;
+                prevDistance = pi.prevDistance;
+                prevAltitude = altitude;
+            });
+            route.points = points;
+            route.distance = prevDistance;
+            (0, route_1.updateSlopes)(route.points);
+        });
     }
-    (0, route_1.updateSlopes)(points);
+}
+exports.XMLParser = XMLParser;
+const getVideoUrl = (info, route) => {
+    const { file, url } = (route === null || route === void 0 ? void 0 : route.video) || {};
+    return (0, utils_1.getReferencedFileInfo)(info, { file, url }, 'video');
 };
-const loadElevationFromPositions = (json, route) => {
-    const altitudes = json['altitudes'];
-    const positions = json['positions'];
-    if (!positions)
-        return;
-    let prevAltitude = undefined;
-    let prevDistance = 0;
-    route.elevation = 0;
-    const points = [];
-    positions.forEach((pos, i) => {
-        const altitude = getAltitude(altitudes, positions, i, prevAltitude);
-        const elevationGain = altitude - prevAltitude;
-        const pi = createPoint(pos, altitude, prevDistance);
-        points.push(pi.point);
-        route.distance = pi.point.routeDistance;
-        if (elevationGain > 0)
-            route.elevation += elevationGain;
-        prevDistance = pi.prevDistance;
-        prevAltitude = altitude;
-    });
-    route.points = points;
-    route.distance = prevDistance;
-    (0, route_1.updateSlopes)(route.points);
+const getPreviewUrl = (info, route) => {
+    const url = route === null || route === void 0 ? void 0 : route.previewUrl;
+    const file = route === null || route === void 0 ? void 0 : route.previewUrlLocal;
+    return (0, utils_1.getReferencedFileInfo)(info, { file, url }, 'file');
 };
 function createPoint(pos, altitude, prevDistance) {
     const point = {

package/lib/routes/base/types/index.d.ts

@@ -1,3 +1,4 @@
+import { FileInfo, IFileLoader } from "../../../api";
 export type RouteType = 'gpx' | 'video';
 export type RouteCategory = 'Free' | 'Demo' | 'personal';
 export type RouteState = 'prepared' | 'loading' | 'loaded' | 'error';
@@ -79,7 +80,7 @@ export interface ParseResult<T extends RouteBase> {
     details: T;
 }
 export interface Parser<In, Out extends RouteBase> {
-    import(data: In): Promise<ParseResult<Out>>;
+    import(file: FileInfo, data: In, loader?: IFileLoader): Promise<ParseResult<Out>>;
     supportsExtension(extension: string): boolean;
     supportsContent(data: In): boolean;
 }

package/lib/routes/list/service.d.ts

@@ -72,7 +72,7 @@ export declare class RouteListService extends IncyclistService {
     protected initRouteLists(): void;
     protected getPageState(pageId: string, lang?: string): RouteListData;
     protected registerPage(pageId: string, props: RouteListStartProps): Page;
-    protected sort(routes: RouteInfo[] | Route[]): void;
+    protected sort(list: List, routes: RouteInfo[] | Route[]): void;
     protected getRouteListDataEntry(list: List, entry: Array<Route>, language: string, listHeader: string): {
         list: List;
         listHeader: string;
@@ -96,6 +96,7 @@ export declare class RouteListService extends IncyclistService {
     protected addDescriptionsFromDB(descriptions: RoutesDB): void;
     protected addDescriptionsFromRepo(descriptions: Array<RouteApiDescription>, repo?: JsonRepository): void;
     protected addDescriptionsFromServer(descriptions: Array<RouteApiDescription>): void;
+    protected addDescriptionFromFile(data: RouteInfo, details: RouteApiDetail): void;
     protected updateRouteTitle(data: RouteInfo, route: {
         descr?: RouteApiDescription;
     }): void;

package/lib/routes/list/service.js

@@ -216,30 +216,23 @@ class RouteListService extends service_1.IncyclistService {
         const parsers = (0, parsers_1.useParsers)();
         files.forEach((file) => __awaiter(this, void 0, void 0, function* () {
             try {
-                const { data, error } = yield this.loader.open(file);
+                const { data: content, error } = yield this.loader.open(file);
                 if (error) {
                     return;
                 }
-                console.log('~~~ DATA', data);
-                const parser = parsers.findMatching(file.ext, data);
-                const route = parser.import(data);
-                console.log('~~~ ROUTE', route);
+                console.log('~~~ DATA', content);
+                const parser = parsers.findMatching(file.ext, content);
+                const res = yield parser.import(file, content);
+                const data = res.data;
+                data.state = 'loaded';
+                const details = res.data;
+                this.addDescriptionFromFile(data, details);
+                console.log('~~~ ROUTES', this.getRouteList('myRoutes'));
             }
             catch (err) {
                 console.log(err);
             }
         }));
-        const route = {
-            id: Date.now().toString(),
-            data: {
-                type: 'route',
-                id: Date.now().toString(),
-                state: 'prepared',
-                title: 'Test'
-            }
-        };
-        this.addRouteToList('myRoutes', route);
-        this.emitPageUpdate();
     }
     setCardUpdateHandler(pageId, r, list, idx, onRouteStateChanged, onCarouselStateChanged) {
         const route = this.getRouteFromStartProps(r);
@@ -362,7 +355,6 @@ class RouteListService extends service_1.IncyclistService {
             const promises = [];
             const rle = this.lists.find(l => l.list === list);
             if (((_a = rle.routes) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                this.sort(rle.routes);
                 let cntApi = 0;
                 rle.routes.forEach((r) => {
                     if (!r.data.isLocal) {
@@ -491,27 +483,36 @@ class RouteListService extends service_1.IncyclistService {
         this.state.pages.push(page);
         return page;
     }
-    sort(routes) {
+    sort(list, routes) {
         const isRouteArray = (a) => a[0].data !== undefined;
         let val = (route) => route;
         if (isRouteArray(routes)) {
-            val = (route) => route.data;
+            val = (route) => (Object.assign(Object.assign({}, route.data), { type: route.type, created: route.created }));
         }
         const score = (route) => {
+            if (route.type === 'import')
+                return 1000;
+            if (route.type === 'free-ride')
+                return 1.2;
             let val = 0;
+            if (route.created) {
+                const tDelta = (Date.now() - route.created) / 1000;
+                const DAY = 60 * 60 * 24;
+                val += Math.min((1 - (DAY - tDelta) / DAY), 1);
+            }
             if (route.hasVideo)
-                val += 1000;
+                val += 1.000;
             if (route.hasGpx)
-                val += 100;
+                val += 0.100;
             if (route.isDemo)
-                val -= 150;
+                val -= 0.150;
             return val;
         };
         routes.sort((a, b) => score(val(b)) - score(val(a)));
     }
     getRouteListDataEntry(list, entry, language, listHeader) {
         const routes = entry.map(r => (0, localization_1.getLocalizedData)(r.data, language));
-        this.sort(routes);
+        this.sort(list, routes);
         return { list, listHeader, routes };
     }
     getPage(pageId, byIndex) {
@@ -702,6 +703,25 @@ class RouteListService extends service_1.IncyclistService {
             }
         });
     }
+    addDescriptionFromFile(data, details) {
+        const existing = this.getRoute(data.id);
+        if (existing) {
+            return;
+        }
+        const list = 'myRoutes';
+        const local = this.getRouteDescription(list, data.id);
+        if (local) {
+            this.mergeDescription(local, data);
+        }
+        else {
+            data.state = 'loaded';
+            data.isLocal = true;
+            const item = { id: data.id, data, details, created: Date.now() };
+            this.addRouteToList(list, item);
+            this.routeDescriptions[data.id] = Object.assign(Object.assign({}, data), { list });
+            this.emitPageUpdate();
+        }
+    }
     updateRouteTitle(data, route) {
         const { descr } = route;
         if (descr && !data.title) {

package/lib/routes/list/types.d.ts

@@ -118,6 +118,7 @@ export type Card<T> = {
     id: string;
     data: T;
     details?: RouteApiDetail;
+    created?: number;
     startSettings?: RouteStartSettings;
     startState?: RouteStartState;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.0.62",
+  "version": "1.0.63",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.1.26",
+    "incyclist-devices": "file:../devices",
     "uuid": "^9.0.0",
     "xml2js": "^0.6.2"
   }