@wemap/providers 3.2.3 → 3.2.5

package/index.js

@@ -1,8 +1,10 @@
 import EventType from './src/events/EventType.js';
 import PositionSmoother from './src/smoothers/PositionSmoother.js';
 import ProvidersInterface from './src/ProvidersInterface.js';
+import ProvidersLogger from './src/logger/ProvidersLogger.js';
 import ProvidersOptions from './src/ProvidersOptions.js';
+import Utils from './src/utils/index.js';
 
 export {
-    EventType, PositionSmoother, ProvidersInterface, ProvidersOptions
+    EventType, PositionSmoother, ProvidersInterface, ProvidersLogger, ProvidersOptions, Utils
 };

package/package.json

@@ -9,10 +9,10 @@
   ],
   "dependencies": {
     "@wemap/geo": "^3.2.3",
-    "@wemap/graph": "^3.2.3",
+    "@wemap/graph": "^3.2.5",
     "@wemap/logger": "^3.2.3",
     "@wemap/maths": "^3.2.3",
-    "@wemap/navigation-logger": "^3.2.3",
+    "@wemap/navigation-logger": "^3.2.5",
     "@wemap/utils": "^3.2.3",
     "geomagnetism": "^0.1.0",
     "lodash.isempty": "^4.4.0",
@@ -20,8 +20,8 @@
   },
   "description": "A package using different geoloc systems",
   "devDependencies": {
-    "@wemap/map": "^3.2.3",
-    "@wemap/osm": "^3.2.3",
+    "@wemap/map": "^3.2.5",
+    "@wemap/osm": "^3.2.5",
     "mapbox-gl": "^1.11.1",
     "mapbox-gl-indoor": "0.0.4"
   },
@@ -44,6 +44,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "3.2.3",
-  "gitHead": "f7075f59fc3227c7f4cb7f1fa8cc69b98705364e"
+  "version": "3.2.5",
+  "gitHead": "e90b23e4265edc0073101a70c6300fa54cd3d379"
 }

package/src/ProvidersInterface.js

@@ -3,7 +3,6 @@ import {
     Attitude, AbsoluteHeading, UserPosition
 } from '@wemap/geo';
 import { Network } from '@wemap/graph';
-import { NavigationLogger } from '@wemap/navigation-logger';
 
 import EventType from './events/EventType.js';
 import MetaProvider from './providers/MetaProvider.js';
@@ -11,6 +10,7 @@ import {
     AbsoluteAttitude, AbsolutePosition, Barcode, CameraNative, CameraProjectionMatrix, Inclination
 } from './Providers.js';
 import ProvidersLoggerOld from './events/ProvidersLoggerOld.js';
+import ProvidersLogger from './logger/ProvidersLogger.js';
 
 class ProvidersInterface {
 
@@ -48,7 +48,7 @@ class ProvidersInterface {
      * @param {Object} data
      */
     static feed(eventType, data) {
-        NavigationLogger.feedExternalData(eventType, data, true);
+        ProvidersLogger.feedExternalData(eventType, data, true);
         this._checkEventTypeDataConsistency(eventType, data);
         this._getMetaProviderFromEventType(eventType).feed(data, eventType);
     }
@@ -136,7 +136,7 @@ class ProvidersInterface {
 
     static set mapMatchingMaxDistance(maxDistance) {
         AbsolutePosition.mapMatchingMaxDistance = maxDistance;
-        NavigationLogger.feedProvidersMM({ mapMatchingMaxDistance: maxDistance });
+        ProvidersLogger.feedProvidersMM({ mapMatchingMaxDistance: maxDistance });
     }
 
     static get mapMatchingMinDistance() {
@@ -145,7 +145,7 @@ class ProvidersInterface {
 
     static set mapMatchingMinDistance(minDistance) {
         AbsolutePosition.mapMatchingMinDistance = minDistance;
-        NavigationLogger.feedProvidersMM({ mapMatchingMinDistance: minDistance });
+        ProvidersLogger.feedProvidersMM({ mapMatchingMinDistance: minDistance });
     }
 
     static get mapMatchingMaxAngleBearing() {
@@ -154,7 +154,7 @@ class ProvidersInterface {
 
     static set mapMatchingMaxAngleBearing(maxAngleBearing) {
         AbsolutePosition.mapMatchingMaxAngleBearing = maxAngleBearing;
-        NavigationLogger.feedProvidersMM({ mapMatchingMaxAngleBearing: maxAngleBearing });
+        ProvidersLogger.feedProvidersMM({ mapMatchingMaxAngleBearing: maxAngleBearing });
     }
 }
 

package/src/logger/ProvidersLogger.js

@@ -0,0 +1,78 @@
+import ProvidersOptions from '../ProvidersOptions';
+import ProvidersLoggerConverter from './ProvidersLoggerConverter.js';
+
+import { NavigationLogger } from '@wemap/navigation-logger';
+import { TimeUtils } from '@wemap/utils';
+
+class ProvidersLogger {
+
+    static logs = [];
+    static currentLogIndex = 0;
+
+    static Converter = ProvidersLoggerConverter;
+
+    static feedImuData(event) {
+        if (!NavigationLogger.isRecording) {
+            return;
+        }
+        this._feed(ProvidersLoggerConverter.imuDataToLog(TimeUtils.preciseTime, event));
+    }
+
+    static feedGeolocation(geolocationEvent) {
+        if (!NavigationLogger.isRecording) {
+            return;
+        }
+        this._feed(ProvidersLoggerConverter.geolocationToLog(TimeUtils.preciseTime, geolocationEvent));
+    }
+
+    static feedExternalData(eventType, data) {
+        if (!NavigationLogger.isRecording) {
+            return;
+        }
+        this._feed(ProvidersLoggerConverter.externalDataToLog(TimeUtils.preciseTime, eventType, data));
+    }
+
+    static feedProvidersMM(obj) {
+        if (!NavigationLogger.isRecording) {
+            return;
+        }
+        this._feed(ProvidersLoggerConverter.providersMMToLog(TimeUtils.preciseTime, obj));
+    }
+
+    static _feed(line) {
+        this.logs[this.currentLogIndex++] = line;
+    }
+
+    static _onStart() {
+        fetch(NavigationLogger.apiUrl + '/providers-config', {
+            method: 'POST',
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ ProvidersOptions })
+        });
+    }
+
+    static _onFlush() {
+
+        if (this.logs.length === 0) {
+            return;
+        }
+
+        fetch(NavigationLogger.apiUrl + '/providers', {
+            method: 'POST',
+            headers: { 'Content-Type': 'text/plain' },
+            body: this.logs.join('\n')
+        });
+
+        this.logs = [];
+        this.currentLogIndex = 0;
+    }
+
+}
+
+NavigationLogger.on('started', () => ProvidersLogger._onStart());
+NavigationLogger.on('flush', () => ProvidersLogger._onFlush());
+
+export default ProvidersLogger;

package/src/logger/ProvidersLoggerConverter.js

@@ -0,0 +1,275 @@
+/* eslint-disable complexity */
+import {
+    UserPosition, AbsoluteHeading, Attitude
+} from '@wemap/geo';
+import {
+    Network, Itinerary
+} from '@wemap/graph';
+
+import { EventType } from '@wemap/providers';
+
+const SEPARATOR = ',';
+
+const PRECISION = 1e-6;
+const PRECISION_INV = 1 / PRECISION;
+const round = num => typeof num === 'number' ? Math.round(num * PRECISION_INV) / PRECISION_INV : num;
+
+class ProvidersLoggerConverter {
+
+    static geolocationToLog(time, event) {
+        return [
+            2,
+            round(time),
+            round(event.timestamp),
+            event.coords.latitude,
+            event.coords.longitude,
+            typeof event.coords.altitude === 'number' ? round(event.coords.altitude) : null,
+            round(event.coords.accuracy),
+            typeof event.coords.altitudeAccuracy === 'number' ? round(event.coords.altitudeAccuracy) : null,
+            typeof event.coords.heading === 'number' ? round(event.coords.heading) : null,
+            typeof event.coords.speed === 'number' ? round(event.coords.speed) : null
+        ].join(SEPARATOR);
+    }
+
+    static imuDataToLog(time, event) {
+        switch (event.type) {
+
+        case 'devicemotion':
+            const acc = event.accelerationIncludingGravity;
+            const gyr = event.rotationRate;
+            const linearAcc = event.acceleration;
+            return [
+                3,
+                event.type,
+                round(time),
+                round(event.timeStamp),
+                acc && typeof acc.x === 'number' ? round(acc.x) : null,
+                acc && typeof acc.y === 'number' ? round(acc.y) : null,
+                acc && typeof acc.z === 'number' ? round(acc.z) : null,
+                gyr && typeof gyr.alpha === 'number' ? round(gyr.alpha) : null,
+                gyr && typeof gyr.beta === 'number' ? round(gyr.beta) : null,
+                gyr && typeof gyr.gamma === 'number' ? round(gyr.gamma) : null,
+                linearAcc && typeof linearAcc.x === 'number' ? round(linearAcc.x) : null,
+                linearAcc && typeof linearAcc.y === 'number' ? round(linearAcc.y) : null,
+                linearAcc && typeof linearAcc.z === 'number' ? round(linearAcc.z) : null,
+                round(event.interval)
+            ].join(SEPARATOR);
+
+        case 'deviceorientation':
+            return [
+                3,
+                event.type,
+                round(time),
+                round(event.timeStamp),
+                round(event.alpha),
+                round(event.beta),
+                round(event.gamma),
+                round(event.webkitCompassHeading),
+                event.absolute ? 1 : 0
+            ].join(SEPARATOR);
+
+        case 'deviceorientationabsolute':
+            return [
+                3,
+                event.type,
+                round(time),
+                round(event.timeStamp),
+                round(event.alpha),
+                round(event.beta),
+                round(event.gamma),
+                event.absolute ? 1 : 0
+            ].join(SEPARATOR);
+        }
+
+        throw new Error(`Cannot parse event: ${event.type}`, event);
+    }
+
+    static externalDataToLog(time, eventType, data) {
+        switch (eventType) {
+        case EventType.Network:
+            if (data instanceof Itinerary) {
+                return [4, 'itinerary', round(time), data === null ? null : JSON.stringify(data.toCompressedJson())].join(SEPARATOR);
+            }
+            return [4, 'network', round(time), data === null ? null : JSON.stringify(data.toCompressedJson())].join(SEPARATOR);
+        case EventType.AbsolutePosition:
+            return [4, 'absolute-position', round(time), JSON.stringify(data.toJson())].join(SEPARATOR);
+        case EventType.AbsoluteHeading:
+            return [4, 'absolute-heading', round(time), JSON.stringify(data.toJson())].join(SEPARATOR);
+        case EventType.AbsoluteAttitude:
+            return [4, 'absolute-attitude', round(time), JSON.stringify(data.toJson())].join(SEPARATOR);
+        }
+        return [4, 'unknown', eventType].join(SEPARATOR);
+    }
+
+    static providersMMToLog(time, obj) {
+        return [5, time, JSON.stringify(obj)].join(SEPARATOR);
+    }
+
+
+    static logToObj(str) {
+        const logType = parseInt(str[0], 10);
+        switch (logType) {
+        case 2:
+            return this.logToGeolocation(str);
+        case 3:
+            return this.logToImu(str);
+        case 4:
+            return this.logToExternalData(str);
+        case 5:
+            return this.logToProvidersMM(str);
+        }
+
+        throw new Error(`Cannot parse log: ${str}`);
+    }
+
+    static logToGeolocation(str) {
+        const array = str.split(SEPARATOR).map(parseFloat);
+        return {
+            type: 'geolocation',
+            time: array[1],
+            data: {
+                timestamp: array[2],
+                coords: {
+                    latitude: array[3],
+                    longitude: array[4],
+                    altitude: array[5],
+                    accuracy: array[6],
+                    altitudeAccuracy: array[7],
+                    heading: array[8],
+                    speed: array[9]
+                }
+            }
+        };
+    }
+
+    static logToImu(str) {
+
+        const indexOfSecondComma = str.indexOf(SEPARATOR, 2);
+        const eventName = str.substring(2, indexOfSecondComma);
+        const data = str.substring(indexOfSecondComma + 1).split(SEPARATOR).map(parseFloat);
+
+        const event = new CustomEvent(eventName);
+        Object.defineProperties(event, { timeStamp: { writable: true } });
+
+        switch (eventName) {
+        case 'devicemotion':
+            Object.assign(event, {
+                timeStamp: data[1],
+                accelerationIncludingGravity: {
+                    x: data[2],
+                    y: data[3],
+                    z: data[4]
+                },
+                rotationRate: {
+                    alpha: data[5],
+                    beta: data[6],
+                    gamma: data[7]
+                },
+                acceleration: {
+                    x: data[8],
+                    y: data[9],
+                    z: data[10]
+                }
+            });
+            break;
+
+        case 'deviceorientation':
+            Object.assign(event, {
+                timeStamp: data[1],
+                alpha: data[2],
+                beta: data[3],
+                gamma: data[4],
+                webkitCompassHeading: data[5],
+                absolute: data[6] === 1
+            });
+            break;
+
+
+        case 'deviceorientationabsolute':
+            Object.assign(event, {
+                timeStamp: data[1],
+                alpha: data[2],
+                beta: data[3],
+                gamma: data[4],
+                absolute: data[5] === 1
+            });
+            break;
+        }
+
+        return {
+            type: 'imu',
+            time: data[0],
+            data: event
+        };
+    }
+
+    static logToExternalData(str) {
+
+        const indexOfSecondComma = str.indexOf(SEPARATOR, 2);
+        const eventTypeStr = str.substring(2, indexOfSecondComma);
+
+        const indexOfThirdComma = str.indexOf(SEPARATOR, indexOfSecondComma + 1);
+        const time = parseFloat(str.substring(indexOfSecondComma + 1, indexOfThirdComma));
+
+        const dataStr = str.substring(indexOfThirdComma + 1);
+
+        let data;
+        switch (eventTypeStr) {
+
+        case 'network':
+            data = {
+                eventType: EventType.Network,
+                data: dataStr === null ? null : Network.fromCompressedJson(JSON.parse(dataStr))
+            };
+            break;
+
+        case 'itinerary':
+            data = {
+                eventType: EventType.Network,
+                data: dataStr === null ? null : Itinerary.fromCompressedJson(JSON.parse(dataStr))
+            };
+            break;
+
+        case 'absolute-position':
+            data = {
+                eventType: EventType.AbsolutePosition,
+                data: dataStr === null ? null : UserPosition.fromJson(JSON.parse(dataStr))
+            };
+            break;
+
+        case 'absolute-attitude':
+            data = {
+                eventType: EventType.AbsoluteAttitude,
+                data: dataStr === null ? null : Attitude.fromJson(JSON.parse(dataStr))
+            };
+            break;
+
+        case 'absolute-heading':
+            data = {
+                eventType: EventType.AbsoluteHeading,
+                data: dataStr === null ? null : AbsoluteHeading.fromJson(JSON.parse(dataStr))
+            };
+            break;
+
+        default:
+            throw new Error(`Cannot parse eventType: ${eventTypeStr}`);
+        }
+
+        return {
+            type: 'external',
+            time,
+            data
+        };
+    }
+
+    static logToProvidersMM(str) {
+        const array = str.split(SEPARATOR);
+        return {
+            type: 'providersMM',
+            time: parseFloat(array[1]),
+            data: JSON.parse(array[2])
+        };
+    }
+}
+
+export default ProvidersLoggerConverter;

package/src/providers/attitude/absolute/AbsoluteAttitudeFromBrowserProvider.js

@@ -6,7 +6,6 @@ import {
 import {
     deg2rad, rad2deg, Quaternion, Rotations
 } from '@wemap/maths';
-import { NavigationLogger } from '@wemap/navigation-logger';
 import {
     Browser, BrowserUtils
 } from '@wemap/utils';
@@ -17,6 +16,7 @@ import AskImuOnDesktopError from '../../../errors/AskImuOnDesktopError.js';
 import MissingMagnetometerError from '../../../errors/MissingMagnetometerError.js';
 import MissingSensorError from '../../../errors/MissingSensorError.js';
 import { AbsolutePosition } from '../../../Providers.js';
+import ProvidersLogger from '../../../logger/ProvidersLogger.js';
 
 
 /**
@@ -136,7 +136,7 @@ class AbsoluteAttitudeFromBrowserProvider extends Provider {
 
 
     onDeviceOrientationChromeEvent = e => {
-        NavigationLogger.feedImuData(e);
+        ProvidersLogger.feedImuData(e);
 
         this.magQuaternionTimestamp = e.timeStamp / 1e3;
 
@@ -153,7 +153,7 @@ class AbsoluteAttitudeFromBrowserProvider extends Provider {
 
 
     onDeviceOrientationSafariEvent = e => {
-        NavigationLogger.feedImuData(e);
+        ProvidersLogger.feedImuData(e);
 
         this.magQuaternionTimestamp = e.timeStamp / 1e3;
 

package/src/providers/attitude/relative/RelativeAttitudeFromBrowserProvider.js

@@ -1,6 +1,5 @@
 import { Attitude } from '@wemap/geo';
 import { Rotations } from '@wemap/maths';
-import { NavigationLogger } from '@wemap/navigation-logger';
 import { BrowserUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
@@ -8,6 +7,7 @@ import EventType from '../../../events/EventType.js';
 import AskImuOnDesktopError from '../../../errors/AskImuOnDesktopError.js';
 import MissingSensorError from '../../../errors/MissingSensorError.js';
 import RelativeAttitudeFromInertialProvider from './RelativeAttitudeFromInertialProvider.js';
+import ProvidersLogger from '../../../logger/ProvidersLogger.js';
 
 
 /**
@@ -80,7 +80,7 @@ class RelativeAttitudeFromBrowserProvider extends Provider {
 
 
     onDeviceOrientationEvent = e => {
-        NavigationLogger.feedImuData(e);
+        ProvidersLogger.feedImuData(e);
 
         const timestamp = e.timeStamp / 1e3;
 

package/src/providers/imu/ImuProvider.js

@@ -1,5 +1,4 @@
 import { deg2rad } from '@wemap/maths';
-import { NavigationLogger } from '@wemap/navigation-logger';
 import {
     Browser, BrowserUtils
 } from '@wemap/utils';
@@ -7,6 +6,7 @@ import {
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType';
 import AskImuOnDesktopError from '../../errors/AskImuOnDesktopError.js';
+import ProvidersLogger from '../../logger/ProvidersLogger.js';
 
 /**
  * Imu (Inertial Measurement Unit) provider retrieve acceleration data
@@ -83,7 +83,7 @@ class ImuProvider extends Provider {
      * @private
      */
     parseDeviceMotionEvent = e => {
-        NavigationLogger.feedImuData(e);
+        ProvidersLogger.feedImuData(e);
 
         const events = [];
 

package/src/providers/position/absolute/GnssWifiProvider.js

@@ -1,6 +1,5 @@
 import { deg2rad } from '@wemap/maths';
 import { UserPosition } from '@wemap/geo';
-import { NavigationLogger } from '@wemap/navigation-logger';
 import { TimeUtils } from '@wemap/utils';
 
 import EventType from '../../../events/EventType.js';
@@ -9,6 +8,7 @@ import Provider from '../../Provider.js';
 import GeolocationPermissionDeniedError from '../../../errors/GeolocationPermissionDeniedError.js';
 import GeolocationPositionUnavailableError from '../../../errors/GeolocationPositionUnavailableError.js';
 import Constants from '../../Constants.js';
+import ProvidersLogger from '../../../logger/ProvidersLogger.js';
 
 const POSITION_OPTIONS = {
     enableHighAccuracy: true,
@@ -73,7 +73,7 @@ class GnssWifiProvider extends Provider {
      * @private
      */
     onNewPosition = geolocation => {
-        NavigationLogger.feedGeolocation(geolocation);
+        ProvidersLogger.feedGeolocation(geolocation);
 
         const { coords } = geolocation;
         if (!coords) {

package/src/utils/addGeolocationOnMap.js

@@ -0,0 +1,104 @@
+import { Map } from 'mapbox-gl';
+
+import { GeolocationLayer } from '@wemap/map';
+import {
+    PositionSmoother, ProvidersInterface, EventType
+} from '@wemap/providers';
+import { TimeUtils } from '@wemap/utils';
+
+
+/**
+ * Create map.geolocation object
+ * @param {Map} map
+ */
+function addGeolocationOnMap(map) {
+
+    let smoother;
+
+    let attitudeProviderId;
+    let positionProviderId;
+
+    let isStarted = false;
+
+    Object.assign(map, { geolocation: new GeolocationLayer(map) });
+
+    Object.assign(map.geolocation, {
+
+        start: () => {
+
+            if (isStarted) {
+                return;
+            }
+            isStarted = true;
+
+            /**
+             * Attitude
+             */
+            attitudeProviderId = ProvidersInterface.addEventListener(
+                EventType.AbsoluteAttitude,
+                attitude => map.geolocation.updateHeading(attitude.headingDegrees)
+            );
+
+            // There is no sense to show the last known attitude on the map
+            // map.geolocation.updateHeading(ProvidersInterface.getLastKnown(EventType.AbsoluteAttitude));
+
+
+            /**
+             * Position
+             */
+
+            const positionTransform = input => {
+                if (input === null) {
+                    return null;
+                }
+                return Object.assign(input.clone(),
+                    { timestamp: TimeUtils.preciseTimeToUnixTimestamp(input.time * 1e3) }
+                );
+            };
+
+            smoother = new PositionSmoother(position => {
+                map.geolocation.updatePosition(positionTransform(position));
+            });
+
+            positionProviderId = ProvidersInterface.addEventListener(
+                EventType.AbsolutePosition,
+                position => smoother.feed(position)
+            );
+
+            const lastKnownPosition = ProvidersInterface.getLastKnown(EventType.AbsolutePosition);
+            if (lastKnownPosition) {
+                map.geolocation.updatePosition(positionTransform(lastKnownPosition));
+            }
+        },
+
+        stop: () => {
+
+            if (!isStarted) {
+                return;
+            }
+
+            /**
+             * Attitude
+             */
+
+            ProvidersInterface.removeEventListener(attitudeProviderId);
+
+
+            /**
+             * Position
+             */
+
+            ProvidersInterface.removeEventListener(positionProviderId);
+            smoother.clear();
+            smoother = null;
+
+            isStarted = false;
+        }
+    });
+
+    map.geolocation.on('start.clicked', map.geolocation.start);
+    map.geolocation.on('stop.clicked', map.geolocation.stop);
+}
+
+
+export default addGeolocationOnMap;

package/src/utils/index.js

@@ -0,0 +1,3 @@
+import addGeolocationOnMap from './addGeolocationOnMap.js';
+
+export default { addGeolocationOnMap };