@wemap/providers 3.2.1 → 3.2.2

package/debug/map/helpers/UserOnMapHandler.js

@@ -1,5 +1,6 @@
 import { Map } from 'mapbox-gl';
 import { GeolocationLayer } from '@wemap/map';
+import { TimeUtils } from '@wemap/utils';
 
 import {
     PositionSmoother, ProvidersInterface, EventType
@@ -32,25 +33,39 @@ class UserOnMapHandler {
          */
         this.attitudeProviderId = ProvidersInterface.addEventListener(
             EventType.AbsoluteAttitude,
-            attitude => this.geolocationLayer.updateAttitude(attitude)
+            attitude => this.geolocationLayer.updateHeading(attitude.headingDegrees)
         );
 
         // There is no sense to show the last known attitude on the map
-        // this.updateAttitude(ProvidersInterface.getLastKnown(EventType.AbsoluteAttitude));
+        // this.geolocationLayer.updateHeading(ProvidersInterface.getLastKnown(EventType.AbsoluteAttitude));
 
 
         /**
          * Position
          */
 
-        this.smoother = new PositionSmoother(position => this.geolocationLayer.updatePosition(position));
+        const positionTransform = input => {
+            if (input === null) {
+                return null;
+            }
+            const output = input.clone();
+            output.timestamp = TimeUtils.preciseTimeToUnixTimestamp(input.time * 1e3);
+            return output;
+        };
+
+        this.smoother = new PositionSmoother(position => {
+            this.geolocationLayer.updatePosition(positionTransform(position));
+        });
 
         this.positionProviderId = ProvidersInterface.addEventListener(
             EventType.AbsolutePosition,
             position => this.smoother.feed(position)
         );
 
-        this.geolocationLayer.updatePosition(ProvidersInterface.getLastKnown(EventType.AbsolutePosition));
+        const lastKnownPosition = ProvidersInterface.getLastKnown(EventType.AbsolutePosition);
+        if (lastKnownPosition) {
+            this.geolocationLayer.updatePosition(positionTransform(lastKnownPosition));
+        }
     }
 
     stop() {

package/package.json

@@ -8,12 +8,12 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/geo": "^3.2.1",
-    "@wemap/graph": "^3.2.1",
+    "@wemap/geo": "^3.2.2",
+    "@wemap/graph": "^3.2.2",
     "@wemap/logger": "^3.2.1",
     "@wemap/maths": "^3.2.1",
-    "@wemap/osm": "^3.2.1",
-    "@wemap/utils": "^3.2.1",
+    "@wemap/osm": "^3.2.2",
+    "@wemap/utils": "^3.2.2",
     "browser-cookies": "^1.2.0",
     "geomagnetism": "^0.1.0",
     "lodash.isempty": "^4.4.0",
@@ -26,7 +26,7 @@
     "@babel/plugin-proposal-class-properties": "^7.10.4",
     "@babel/preset-env": "^7.11.0",
     "@babel/preset-react": "^7.10.4",
-    "@wemap/map": "^3.2.1",
+    "@wemap/map": "^3.2.2",
     "babel-loader": "^8.0.6",
     "css-loader": "^3.2.0",
     "file-loader": "^5.0.2",
@@ -68,6 +68,6 @@
     "lint": "eslint --ext .js,.jsx --quiet src"
   },
   "type": "module",
-  "version": "3.2.1",
-  "gitHead": "0d430815358a23068c8473b2c310b2945667b2c1"
+  "version": "3.2.2",
+  "gitHead": "6ff8c054aed5ccbf0f456aad752c43f46fe6b278"
 }

package/src/logger/NavigationLogger.js

@@ -44,6 +44,7 @@ class NavigationLogger {
             }
         }
         this._sendConfig(config);
+        this._feed(NavigationLoggerConverter.configToLog(config));
 
         // Dispatch started event
         if (typeof document !== 'undefined') {
@@ -66,18 +67,25 @@ class NavigationLogger {
         this.isRecording = false;
     }
 
-    static feedRawData(eventName, data) {
+    static feedImuData(event) {
         if (!this.isRecording) {
             return;
         }
-        this._feed(NavigationLoggerConverter.rawDataToArray(eventName, TimeUtils.preciseTime, data));
+        this._feed(NavigationLoggerConverter.imuDataToLog(TimeUtils.preciseTime, event));
+    }
+
+    static feedGeolocation(geolocationEvent) {
+        if (!this.isRecording) {
+            return;
+        }
+        this._feed(NavigationLoggerConverter.geolocationToLog(TimeUtils.preciseTime, geolocationEvent));
     }
 
     static feedExternalData(eventType, data) {
         if (!this.isRecording) {
             return;
         }
-        this._feed(NavigationLoggerConverter.externalDataToArray(eventType, TimeUtils.preciseTime, data));
+        this._feed(NavigationLoggerConverter.externalDataToLog(TimeUtils.preciseTime, eventType, data));
     }
 
 
@@ -107,9 +115,9 @@ class NavigationLogger {
 
     static _sendLogs(logs) {
         const xmlhttp = new XMLHttpRequest();
-        xmlhttp.open('POST', this.serverUrl + '/logs/' + this.sessionId);
-        xmlhttp.setRequestHeader('Content-Type', 'application/json');
-        xmlhttp.send(JSON.stringify(logs));
+        xmlhttp.open('POST', this.serverUrl + '/logs/' + this.sessionId, true);
+        xmlhttp.setRequestHeader('Content-Type', 'text/plain');
+        xmlhttp.send(logs.join('\n'));
     }
 }
 
@@ -121,7 +129,6 @@ if (typeof document !== 'undefined') {
         if (!('serverUrl' in event.detail)) {
             throw new Error('[providers.logger.start] did not find serverUrl');
         }
-        console.log(event.detail.serverUrl, event.detail.logsSize);
         NavigationLogger.start(event.detail.serverUrl, event.detail.logsSize);
     });
     document.addEventListener('providers.logger.stop', () => NavigationLogger.stop());

package/src/logger/NavigationLoggerConverter.js

@@ -1,227 +1,262 @@
 /* eslint-disable complexity */
-import { UserPosition } from '@wemap/geo';
+import {
+    UserPosition, AbsoluteHeading, Attitude
+} from '@wemap/geo';
 import { Network } from '@wemap/graph';
 
 import EventType from '../events/EventType.js';
 
+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 NavigationLoggerConverter {
 
-    static externalDataToArray(eventType, time, data) {
-        switch (eventType) {
-        case EventType.Network:
-            return [0, 'network', round(time), data === null ? null : JSON.stringify(data.toCompressedJson())];
-        case EventType.AbsolutePosition:
-            return [0, 'absolute-position', round(time), JSON.stringify(data.toJson())];
-        case EventType.AbsoluteHeading:
-            return [0, 'absolute-heading', round(time), JSON.stringify(data.toJson())];
-        case EventType.AbsoluteAttitude:
-            return [0, 'absolute-attitude', round(time), JSON.stringify(data.toJson())];
-        }
-        return [0, 'unknown', eventType];
+    static configToLog(config) {
+        return [1, JSON.stringify(config)].join(SEPARATOR);
     }
 
-    static rawDataToArray(eventName, time, data) {
-        switch (eventName) {
+    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);
+    }
 
-        case 'devicemotion':
-            const acc = data.accelerationIncludingGravity;
-            const gyr = data.rotationRate;
-            const linearAcc = data.acceleration;
+    static imuDataToLog(time, event) {
+        switch (event.type) {
 
+        case 'devicemotion':
+            const acc = event.accelerationIncludingGravity;
+            const gyr = event.rotationRate;
+            const linearAcc = event.acceleration;
             return [
-                1,
+                3,
+                event.type,
                 round(time),
-                round(data.timeStamp),
-                acc && typeof acc.x === 'number' ? round(acc.x) : Number.MIN_VALUE,
-                acc && typeof acc.y === 'number' ? round(acc.y) : Number.MIN_VALUE,
-                acc && typeof acc.z === 'number' ? round(acc.z) : Number.MIN_VALUE,
-                gyr && typeof gyr.alpha === 'number' ? round(gyr.alpha) : Number.MIN_VALUE,
-                gyr && typeof gyr.beta === 'number' ? round(gyr.beta) : Number.MIN_VALUE,
-                gyr && typeof gyr.gamma === 'number' ? round(gyr.gamma) : Number.MIN_VALUE,
-                linearAcc && typeof linearAcc.x === 'number' ? round(linearAcc.x) : Number.MIN_VALUE,
-                linearAcc && typeof linearAcc.y === 'number' ? round(linearAcc.y) : Number.MIN_VALUE,
-                linearAcc && typeof linearAcc.z === 'number' ? round(linearAcc.z) : Number.MIN_VALUE,
-                round(data.interval)
-            ];
+                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 [
-                2,
+                3,
+                event.type,
                 round(time),
-                round(data.timeStamp),
-                round(data.alpha),
-                round(data.beta),
-                round(data.gamma),
-                round(data.webkitCompassHeading),
-                data.absolute ? 1 : 0
-            ];
+                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(data.timeStamp),
-                round(data.alpha),
-                round(data.beta),
-                round(data.gamma),
-                data.absolute ? 1 : 0
-            ];
-
-        case 'geolocation':
-            return [
-                4,
-                round(time),
-                round(data.timestamp),
-                data.coords.latitude,
-                data.coords.longitude,
-                typeof data.coords.altitude === 'number' ? round(data.coords.altitude) : Number.MIN_VALUE,
-                round(data.coords.accuracy),
-                typeof data.coords.altitudeAccuracy === 'number' ? round(data.coords.altitudeAccuracy) : Number.MIN_VALUE,
-                typeof data.coords.heading === 'number' ? round(data.coords.heading) : Number.MIN_VALUE,
-                typeof data.coords.speed === 'number' ? round(data.coords.speed) : Number.MIN_VALUE
-            ];
+                round(event.timeStamp),
+                round(event.alpha),
+                round(event.beta),
+                round(event.gamma),
+                event.absolute ? 1 : 0
+            ].join(SEPARATOR);
         }
 
-        throw new Error(`Cannot parse eventName: ${eventName}`);
+        throw new Error(`Cannot parse event: ${event.type}`, event);
     }
 
-    static _strToObj(str) {
+    static externalDataToLog(time, eventType, data) {
+        switch (eventType) {
+        case EventType.Network:
+            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);
+    }
 
-        const indexOfFirstComma = str.indexOf(',');
-        const rowType = parseInt(str.substring(0, indexOfFirstComma), 10);
 
-        let array;
+    static logToObj(str) {
+        const logType = parseInt(str[0], 10);
+        switch (logType) {
+        case 1:
+            return this.logToConfig(str);
+        case 2:
+            return this.logToGeolocation(str);
+        case 3:
+            return this.logToImu(str);
+        case 4:
+            return this.logToExternalData(str);
+        }
 
-        switch (rowType) {
+        throw new Error(`Cannot parse log: ${str}`);
+    }
 
-        case 1:
-            array = str.split(',').map(parseFloat);
-            return {
-                eventName: 'devicemotion',
-                time: array[1],
-                data: {
-                    timeStamp: array[2],
-                    accelerationIncludingGravity: {
-                        x: array[3] === Number.MIN_VALUE ? null : array[3],
-                        y: array[4] === Number.MIN_VALUE ? null : array[4],
-                        z: array[5] === Number.MIN_VALUE ? null : array[5]
-                    },
-                    rotationRate: {
-                        alpha: array[6] === Number.MIN_VALUE ? null : array[6],
-                        beta: array[7] === Number.MIN_VALUE ? null : array[7],
-                        gamma: array[8] === Number.MIN_VALUE ? null : array[8]
-                    },
-                    acceleration: {
-                        x: array[9] === Number.MIN_VALUE ? null : array[9],
-                        y: array[10] === Number.MIN_VALUE ? null : array[10],
-                        z: array[11] === Number.MIN_VALUE ? null : array[11]
-                    }
-                },
-                isExternal: false
-            };
+    static logToConfig(str) {
+        const config = JSON.parse(str.substring(2));
+        return {
+            type: 'config',
+            time: config.startTime,
+            data: config
+        };
+    }
 
-        case 2:
-            array = str.split(',').map(parseFloat);
-            return {
-                eventName: 'deviceorientation',
-                time: array[1],
-                data: {
-                    timeStamp: array[2],
-                    alpha: array[3],
-                    beta: array[4],
-                    gamma: array[5],
-                    webkitCompassHeading: array[6],
-                    absolute: array[7] === 1
-                },
-                isExternal: false
-            };
+    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]
+                }
+            }
+        };
+    }
 
-        case 3:
-            array = str.split(',').map(parseFloat);
-            return {
-                eventName: 'deviceorientationabsolute',
-                time: array[1],
-                data: {
-                    timeStamp: array[2],
-                    alpha: array[3],
-                    beta: array[4],
-                    gamma: array[5],
-                    absolute: array[6] === 1
-                },
-                isExternal: false
-            };
+    static logToImu(str) {
 
-        case 4:
-            array = str.split(',').map(parseFloat);
-            return {
-                eventName: 'geolocation',
-                time: array[1],
-                data: {
-                    timestamp: array[2],
-                    coords: {
-                        latitude: array[3],
-                        longitude: array[4],
-                        altitude: array[5] === Number.MIN_VALUE ? null : array[5],
-                        accuracy: array[6],
-                        altitudeAccuracy: array[7] === Number.MIN_VALUE ? null : array[7],
-                        heading: array[8] === Number.MIN_VALUE ? null : array[8],
-                        speed: array[9] === Number.MIN_VALUE ? null : array[9]
-                    }
+        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]
                 },
-                isExternal: false
-            };
+                rotationRate: {
+                    alpha: data[5],
+                    beta: data[6],
+                    gamma: data[7]
+                },
+                acceleration: {
+                    x: data[8],
+                    y: data[9],
+                    z: data[10]
+                }
+            });
+            break;
 
-        case 0:
+        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;
+        }
 
-            const indexOfSecondComma = str.indexOf(',', indexOfFirstComma + 1);
-            const eventTypeStr = str.substring(indexOfFirstComma + 1, indexOfSecondComma);
+        return {
+            type: 'imu',
+            time: data[0],
+            data: event
+        };
+    }
 
-            const indexOfThirdComma = str.indexOf(',', indexOfSecondComma + 1);
-            const time = str.substring(indexOfSecondComma + 1, indexOfThirdComma);
+    static logToExternalData(str) {
 
-            const dataStr = str.substring(indexOfThirdComma + 1);
-            const dataJson = JSON.parse(dataStr);
+        const indexOfSecondComma = str.indexOf(SEPARATOR, 2);
+        const eventTypeStr = str.substring(2, indexOfSecondComma);
 
-            let eventType, data;
-            switch (eventTypeStr) {
+        const indexOfThirdComma = str.indexOf(SEPARATOR, indexOfSecondComma + 1);
+        const time = parseFloat(str.substring(indexOfSecondComma + 1, indexOfThirdComma));
 
-            case 'network':
-                eventType = EventType.Network;
-                data = dataStr === null ? null : Network.fromCompressedJson(dataJson);
-                break;
+        const dataStr = str.substring(indexOfThirdComma + 1);
 
-            case 'absolute-position':
-                eventType = EventType.AbsolutePosition;
-                data = dataStr === null ? null : UserPosition.fromJson(dataJson);
-                break;
+        let data;
+        switch (eventTypeStr) {
 
-            case 'absolute-attitude':
-                eventType = EventType.AbsoluteAttitude;
-                data = dataStr === null ? null : UserPosition.fromJson(dataJson);
-                break;
+        case 'network':
+            data = {
+                eventType: EventType.Network,
+                data: dataStr === null ? null : Network.fromCompressedJson(JSON.parse(dataStr))
+            };
+            break;
 
-            case 'absolute-heading':
-                eventType = EventType.AbsoluteHeading;
-                data = dataStr === null ? null : UserPosition.fromJson(dataJson);
-                break;
+        case 'absolute-position':
+            data = {
+                eventType: EventType.AbsolutePosition,
+                data: dataStr === null ? null : UserPosition.fromJson(JSON.parse(dataStr))
+            };
+            break;
 
-            default:
-                throw new Error(`Cannot parse eventType: ${array[1]}`);
-            }
+        case 'absolute-attitude':
+            data = {
+                eventType: EventType.AbsoluteAttitude,
+                data: dataStr === null ? null : Attitude.fromJson(JSON.parse(dataStr))
+            };
+            break;
 
-            return {
-                eventType,
-                data,
-                time: round(time),
-                isExternal: true
+        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 null;
+        return {
+            type: 'external',
+            time,
+            data
+        };
     }
 }
 

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

@@ -136,7 +136,7 @@ class AbsoluteAttitudeFromBrowserProvider extends Provider {
 
 
     onDeviceOrientationChromeEvent = e => {
-        NavigationLogger.feedRawData('deviceorientationabsolute', e);
+        NavigationLogger.feedImuData(e);
 
         this.magQuaternionTimestamp = e.timeStamp / 1e3;
 
@@ -153,7 +153,7 @@ class AbsoluteAttitudeFromBrowserProvider extends Provider {
 
 
     onDeviceOrientationSafariEvent = e => {
-        NavigationLogger.feedRawData('deviceorientation', e);
+        NavigationLogger.feedImuData(e);
 
         this.magQuaternionTimestamp = e.timeStamp / 1e3;
 

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

@@ -7,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 NavigationLogger from '../../../logger/NavigationLogger.js';
 
 
 /**
@@ -79,6 +80,7 @@ class RelativeAttitudeFromBrowserProvider extends Provider {
 
 
     onDeviceOrientationEvent = e => {
+        NavigationLogger.feedImuData(e);
 
         const timestamp = e.timeStamp / 1e3;
 

package/src/providers/imu/ImuProvider.js

@@ -83,7 +83,7 @@ class ImuProvider extends Provider {
      * @private
      */
     parseDeviceMotionEvent = e => {
-        NavigationLogger.feedRawData('devicemotion', e);
+        NavigationLogger.feedImuData(e);
 
         const events = [];
 

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

@@ -73,7 +73,7 @@ class GnssWifiProvider extends Provider {
      * @private
      */
     onNewPosition = geolocation => {
-        NavigationLogger.feedRawData('geolocation', geolocation);
+        NavigationLogger.feedGeolocation(geolocation);
 
         const { coords } = geolocation;
         if (!coords) {