@wemap/providers 3.3.0 → 4.0.1

package/src/errors/MissingNativeInterfaceError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Native interface is missing';
-
 class MissingNativeInterfaceError extends Error {
+
+    static DEFAULT_MESSAGE = 'Native interface is missing';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || MissingNativeInterfaceError.DEFAULT_MESSAGE);
     }
 }
 

package/src/errors/MissingSensorError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Impossible to retrieve events, a sensor is missing';
-
 class MissingSensorError extends Error {
+
+    static DEFAULT_MESSAGE = 'Impossible to retrieve events, a sensor is missing';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || MissingSensorError.DEFAULT_MESSAGE);
     }
 
     from(fromMessage) {

package/src/errors/NoProviderFoundError.js

@@ -1,8 +1,9 @@
-const DEFAULT_MESSAGE = 'Unable to find a provider with your given parameters';
-
 class NoProviderFoundError extends Error {
+
+    static DEFAULT_MESSAGE = 'Unable to find a provider with your given parameters';
+
     constructor(message) {
-        super(message || DEFAULT_MESSAGE);
+        super(message || NoProviderFoundError.DEFAULT_MESSAGE);
     }
 }
 

package/src/events/ProviderEvent.js

@@ -6,7 +6,6 @@ import EventType from './EventType.js';
  */
 class ProviderEvent {
 
-    timestamp = -1;
     dataType = EventType.Unknown;
     providersStack = [];
     data = null;
@@ -23,7 +22,6 @@ class ProviderEvent {
 
     clone() {
         const evt = new ProviderEvent(this.dataType, this.data);
-        evt.timestamp = this.timestamp;
         evt.providersStack = this.providersStack.slice(0);
         return evt;
     }

package/src/events/ProvidersLoggerOld.js

@@ -1,83 +1,84 @@
 import Logger from '@wemap/logger';
 
-let currentId = 0;
-const objectsIdMap = new WeakMap();
+class ProvidersLoggerOld {
 
-let pushEvents = {};
-let pushEventsRef = {};
+    _enabled = false;
 
-let interval;
-let initDate;
+    currentId = 0;
+    objectsIdMap = new WeakMap();
 
-class ProvidersLoggerOld {
+    pushEvents = {};
+    pushEventsRef = {};
+
+    interval;
+    initDate;
 
-    static _enabled = false;
 
-    static get enabled() {
+    get enabled() {
         return this._enabled;
     }
 
-    static set enabled(_newVal) {
+    set enabled(_newVal) {
         this._enabled = _newVal;
     }
 
-    static initializeInterval() {
+    initializeInterval() {
 
-        if (interval) {
+        if (this.interval) {
             return;
         }
 
-        interval = setInterval(() => {
+        this.interval = setInterval(() => {
 
-            for (const [key, value] of Object.entries(pushEvents)) {
-                Logger.debug('Received ' + value + ' notifications from ' + pushEventsRef[key].pname + ' last second');
+            for (const [key, value] of Object.entries(this.pushEvents)) {
+                Logger.debug('Received ' + value + ' notifications from ' + this.pushEventsRef[key].pname + ' last second');
             }
 
-            pushEvents = {};
-            pushEventsRef = {};
+            this.pushEvents = {};
+            this.pushEventsRef = {};
         }, 1000);
     }
 
-    static getObjectId(object) {
-        if (!objectsIdMap.has(object)) {
-            objectsIdMap.set(object, ++currentId);
+    getObjectId(object) {
+        if (!this.objectsIdMap.has(object)) {
+            this.objectsIdMap.set(object, ++this.currentId);
         }
-        return objectsIdMap.get(object);
+        return this.objectsIdMap.get(object);
     }
 
-    static addEvent(object, method) {
+    addEvent(object, method) {
 
-        if (!ProvidersLoggerOld.enabled) {
+        if (!this.enabled) {
             return;
         }
 
-        if (!initDate) {
-            initDate = Date.now();
+        if (!this.initDate) {
+            this.initDate = Date.now();
         }
 
-        ProvidersLoggerOld.initializeInterval();
+        this.initializeInterval();
 
-        const objectId = ProvidersLoggerOld.getObjectId(object);
+        const objectId = this.getObjectId(object);
         const objectClassName = object.pname;
 
         Logger.debug(objectClassName + '[' + objectId + '].' + method);
     }
 
-    static incrementNotifications(object) {
+    incrementNotifications(object) {
 
-        if (!ProvidersLoggerOld.enabled) {
+        if (!this.enabled) {
             return;
         }
 
-        const objectId = ProvidersLoggerOld.getObjectId(object);
+        const objectId = this.getObjectId(object);
 
-        let counter = pushEvents[objectId];
+        let counter = this.pushEvents[objectId];
         if (!counter) {
             counter = 0;
-            pushEventsRef[objectId] = object;
+            this.pushEventsRef[objectId] = object;
         }
-        pushEvents[objectId] = counter + 1;
+        this.pushEvents[objectId] = counter + 1;
     }
 
 }
-export default ProvidersLoggerOld;
+export default new ProvidersLoggerOld();

package/src/mapmatching/MapMatchingHandler.js

@@ -0,0 +1,138 @@
+import {
+    MapMatching, Network, UserPosition
+} from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
+
+import AbsoluteAttitudeFused from '../providers/attitude/absolute/AbsoluteAttitudeFused.js';
+import AbsolutePosition from '../providers/position/absolute/AbsolutePosition.js';
+import ProvidersOptions from '../ProvidersOptions.js';
+
+class MapMatchingHandler {
+
+    static MM_MAX_ANGLE = deg2rad(20);
+    static MM_MAX_DIST = 30;
+    static MM_MIN_DIST = 0;
+
+    /** @type {MapMatching} */
+    _mapMatching;
+
+    /** @type {number} */
+    _mapMatchingMinDistance;
+
+
+    constructor() {
+
+        if (this.constructor._instance) {
+            throw new Error(`Cannot instantiate ${this.name} twice`);
+        }
+
+        this._mapMatching = new MapMatching();
+        this._mapMatching.maxDistance = MapMatchingHandler.MM_MAX_DIST;
+        this._mapMatching.maxAngleBearing = MapMatchingHandler.MM_MAX_ANGLE;
+        this._mapMatchingMinDistance = MapMatchingHandler.MM_MIN_DIST;
+    }
+
+    get enabled() {
+        return ProvidersOptions.useMapMatching;
+    }
+
+    /**
+     * @param {Network} network
+     */
+    set network(network) {
+        this._mapMatching.network = network;
+
+        if (!this.enabled) {
+            return;
+        }
+
+        const lastEvent = AbsolutePosition.lastEvent;
+        if (network !== null && lastEvent) {
+            const projectedPosition = this.calcProjection(lastEvent.data, true);
+            if (projectedPosition) {
+                const newEvent = lastEvent.clone();
+                newEvent.data = projectedPosition;
+                AbsolutePosition.notify(newEvent);
+            }
+        }
+    }
+
+    /**
+     * @param {UserPosition} position
+     * @param {boolean} shouldTryMmOnNodes
+     * @returns {UserPosition}
+     */
+    calcProjection(position, shouldTryMmOnNodes = false) {
+
+        let projection = null;
+        let bearingUsedForProjection = false;
+
+        if (!this.enabled || !this._mapMatching.network) {
+            return null;
+        }
+
+        // Firstly, if new position bearing is known, try to use map-matching with bearing
+        // That is not always the case, for e.g. the first position returned by the GnssWifi provider.
+        if (position.bearing !== null) {
+            projection = this._mapMatching.getProjection(position, true, true);
+            bearingUsedForProjection = true;
+        }
+
+        // Secondly, if map-matching with bearing did not work, try MM on nodes (without bearing).
+        // Note: this is not allowed for positions from AbsolutePositionFromRel to allow
+        //       user to leave the network.
+        if (!projection && shouldTryMmOnNodes) {
+            projection = this._mapMatching.getProjection(position, true, false);
+            bearingUsedForProjection = false;
+        }
+
+        // No projection found
+        if (!projection) {
+            return null;
+        }
+
+        if (bearingUsedForProjection) {
+            AbsoluteAttitudeFused.mapMatching(projection);
+        }
+
+        // Do not use projection if it too close from itinerary,
+        //  this allows left/right movements (ie with ArCore)
+        if (projection.distanceFromNearestElement < this._mapMatchingMinDistance) {
+            return null;
+        }
+
+        // Do not use projection.projection directly, because position has some specific properties like time, bearing and altitude
+        const projectedPosition = position.clone();
+        projectedPosition.lat = projection.projection.lat;
+        projectedPosition.lng = projection.projection.lng;
+        projectedPosition.level = projection.projection.level;
+
+        return projectedPosition;
+    }
+
+    get maxDistance() {
+        return this._mapMatching.maxDistance;
+    }
+
+    set maxDistance(maxDistance) {
+        this._mapMatching.maxDistance = maxDistance;
+    }
+
+    get minDistance() {
+        return this._mapMatchingMinDistance;
+    }
+
+    set minDistance(minDistance) {
+        this._mapMatchingMinDistance = minDistance;
+    }
+
+    get maxAngleBearing() {
+        return this._mapMatching.maxAngleBearing;
+    }
+
+    set maxAngleBearing(maxAngleBearing) {
+        this._mapMatching.maxAngleBearing = maxAngleBearing;
+    }
+}
+
+export default new MapMatchingHandler();

package/src/providers/FakeProvider.spec.js

@@ -1,16 +1,17 @@
 import { UserPosition } from '@wemap/geo';
-import { TimeUtils } from '@wemap/utils';
 
 import Provider from './Provider.js';
 import EventType from '../events/EventType.js';
 
-class FakeProvider1 extends Provider {
+class FakeProvider1Clazz extends Provider {
     static get pname() {
         return 'FakeProvider1';
     }
 }
+const FakeProvider1 = new FakeProvider1Clazz();
+export { FakeProvider1 };
 
-class FakeProvider2 extends Provider {
+class FakeProvider2Clazz extends Provider {
     static get pname() {
         return 'FakeProvider2';
     }
@@ -20,8 +21,10 @@ class FakeProvider2 extends Provider {
     start() { }
     stop() { }
 }
+const FakeProvider2 = new FakeProvider2Clazz();
+export { FakeProvider2 };
 
-class FakeProvider3 extends Provider {
+class FakeProvider3Clazz extends Provider {
     static get pname() {
         return 'FakeProvider3';
     }
@@ -29,38 +32,33 @@ class FakeProvider3 extends Provider {
         this.intervalId = setInterval(() => {
             const fakePosition = new UserPosition(Math.random() * 45, Math.random() * 180);
             this.notify(this.createEvent(EventType.AbsolutePosition, fakePosition));
-            this.notify(this.createEvent(EventType.AbsolutePosition, fakePosition, TimeUtils.preciseTime));
         }, 1);
     }
     stop() {
         clearInterval(this.intervalId);
     }
 }
+const FakeProvider3 = new FakeProvider3Clazz();
+export { FakeProvider3 };
 
-class FakeProvider4 extends Provider {
+class FakeProvider4Clazz extends Provider {
 
     static get pname() {
         return 'FakeProvider4';
     }
 
-    constructor() {
-        super();
-        this.fp3 = FakeProvider3.instance;
-    }
     get _availability() {
-        return this.fp3.availability;
+        return FakeProvider3.availability;
     }
     start() {
-        this.fp3id = this.fp3.addEventListener(
+        this.fp3id = FakeProvider3.addEventListener(
             events => this.notify(events[0].clone()),
             this.notifyError.bind(this)
         );
     }
     stop() {
-        this.fp3.removeEventListener(this.fp3id);
+        FakeProvider3.removeEventListener(this.fp3id);
     }
 }
-
-export {
-    FakeProvider1, FakeProvider2, FakeProvider3, FakeProvider4
-};
+const FakeProvider4 = new FakeProvider4Clazz();
+export { FakeProvider4 };

package/src/providers/Provider.js

@@ -1,7 +1,5 @@
 import noop from 'lodash.noop';
 
-import { TimeUtils } from '@wemap/utils';
-
 import EventType from '../events/EventType.js';
 import ProviderEvent from '../events/ProviderEvent.js';
 import ProvidersLoggerOld from '../events/ProvidersLoggerOld.js';
@@ -9,7 +7,6 @@ import ContainsIgnoredProviderError from '../errors/ContainsIgnoredProviderError
 import ProvidersOptions from '../ProvidersOptions.js';
 import ProviderState from './ProviderState.js';
 
-let uniqueId = 1;
 
 /**
  * A provider is a meta class to define an entity which can be
@@ -18,25 +15,13 @@ let uniqueId = 1;
 class Provider {
 
     static _callbackUniqueId = 0;
+    static _uniqueId = 1;
 
     state = ProviderState.STOPPPED;
 
     _eventsCallbacks = [];
     _monitoringCallbacks = [];
 
-
-    /**
-     * Singleton pattern using reflection.
-     * @returns {Provider}
-     */
-    static get instance() {
-        if (!this._instance) {
-            this._instance = Reflect.construct(this, []);
-        }
-        return this._instance;
-    }
-
-
     /**
      * Provider constructor
      */
@@ -46,11 +31,7 @@ class Provider {
             throw new Error('Can\'t instantiate Provider directly');
         }
 
-        if (this._instance) {
-            throw new Error(`Cannot instantiate ${this.pname} twice`);
-        }
-
-        this.id = uniqueId++;
+        this.id = Provider._uniqueId++;
 
         ProvidersLoggerOld.addEvent(this, 'constructor');
     }
@@ -96,13 +77,11 @@ class Provider {
      * Create an event from current provider
      * @param {ProviderEvent#DataType} dataType type of ProviderEvent
      * @param {Object} data data exported to ProviderEvent
-     * @param {Number} timestamp event timestamp
      * @returns {ProviderEvent}
      * @protected
      */
-    static createEvent(dataType, data, timestamp, fromEvents = []) {
+    static createEvent(dataType, data, fromEvents = []) {
         const event = new ProviderEvent(dataType, data);
-        event.timestamp = typeof timestamp === 'number' ? timestamp : TimeUtils.preciseTime / 1e3;
         const newStack = fromEvents.reduce((acc, _event) => acc.concat(_event.providersStack), []);
         // Remove duplicates and keep lasts
         event.providersStack = [...new Set(newStack.reverse())].reverse();
@@ -113,13 +92,12 @@ class Provider {
      * Create an event from current provider
      * @param {EventType} dataType type of ProviderEvent
      * @param {Object} data data exported to ProviderEvent
-     * @param {Number} timestamp event timestamp
      * @param {ProviderEvent[]} fromEvents events used for the creation of the new one
      * @returns {ProviderEvent}
      * @protected
      */
-    createEvent(dataType, data, timestamp, fromEvents) {
-        return this.constructor.createEvent(dataType, data, timestamp, fromEvents);
+    createEvent(dataType, data, fromEvents) {
+        return this.constructor.createEvent(dataType, data, fromEvents);
     }
 
     get hasNativeInterface() {

package/src/providers/Provider.spec.js

@@ -24,18 +24,11 @@ describe('Provider', () => {
 
     it('creation/singleton', () => {
         expect(() => new Provider()).throw(Error);
-        expect(() => Provider.instance).throw(Error);
-        expect(() => FakeProvider1.instance).not.throw(Error);
-        expect(() => FakeProvider2.instance).not.throw(Error);
-        expect(() => FakeProvider3.instance).not.throw(Error);
-        expect(() => FakeProvider4.instance).not.throw(Error);
-        expect(FakeProvider1.instance).equals(FakeProvider1.instance);
-        expect(FakeProvider4.instance).equals(FakeProvider4.instance);
     });
 
 
     it('default getter', () => {
-        const provider = FakeProvider1.instance;
+        const provider = FakeProvider1;
         expect(provider.pname).equals(FakeProvider1.pname);
         expect(provider.eventsType).is.empty;
         expect(provider.hasNativeInterface).is.false;
@@ -45,33 +38,30 @@ describe('Provider', () => {
 
     it('availability', async () => {
 
-        const fakeProvider1 = FakeProvider1.instance;
-        await expect(fakeProvider1.availability).to.be.fulfilled;
+        await expect(FakeProvider1.availability).to.be.fulfilled;
         ProvidersOptions.ignoreProviders.push(FakeProvider1.pname);
-        await expect(fakeProvider1.availability).to.be.rejectedWith(ContainsIgnoredProviderError);
+        await expect(FakeProvider1.availability).to.be.rejectedWith(ContainsIgnoredProviderError);
         ProvidersOptions.ignoreProviders = [];
 
-        await expect(FakeProvider2.instance.availability).to.be.rejectedWith(Error);
+        await expect(FakeProvider2.availability).to.be.rejectedWith(Error);
 
-        await expect(FakeProvider3.instance.availability).to.be.fulfilled;
-        await expect(FakeProvider4.instance.availability).to.be.fulfilled;
+        await expect(FakeProvider3.availability).to.be.fulfilled;
+        await expect(FakeProvider4.availability).to.be.fulfilled;
     });
 
     it('checkAvailability on start', async () => {
 
-        const fp2 = FakeProvider2.instance;
-
         /**
          * checkAvailabilityOnStart = true
          */
         let errored = false;
-        fp2.addEventListener(noop, () => (errored = true));
+        FakeProvider2.addEventListener(noop, () => (errored = true));
 
         await sleep(2);
 
         expect(errored).is.true;
-        expect(fp2.state).equals(ProviderState.STOPPPED);
-        expect(fp2._eventsCallbacks.length).equals(0);
+        expect(FakeProvider2.state).equals(ProviderState.STOPPPED);
+        expect(FakeProvider2._eventsCallbacks.length).equals(0);
 
         /**
          * checkAvailabilityOnStart = false
@@ -79,16 +69,16 @@ describe('Provider', () => {
         ProvidersOptions.checkAvailabilityOnStart = false;
 
         errored = false;
-        const id = fp2.addEventListener(noop, () => (errored = true));
+        const id = FakeProvider2.addEventListener(noop, () => (errored = true));
 
         await sleep(2);
 
         expect(errored).is.false;
-        expect(fp2.state).equals(ProviderState.STARTED);
+        expect(FakeProvider2.state).equals(ProviderState.STARTED);
 
-        fp2.removeEventListener(id);
-        expect(fp2.state).equals(ProviderState.STOPPPED);
-        expect(fp2._eventsCallbacks.length).equals(0);
+        FakeProvider2.removeEventListener(id);
+        expect(FakeProvider2.state).equals(ProviderState.STOPPPED);
+        expect(FakeProvider2._eventsCallbacks.length).equals(0);
 
         ProvidersOptions.checkAvailabilityOnStart = true;
     });
@@ -122,13 +112,13 @@ describe('Provider', () => {
 
     it('start/stop', async () => {
         let errored = false;
-        FakeProvider1.instance.addEventListener(noop, (errored = true));
+        FakeProvider1.addEventListener(noop, (errored = true));
         await sleep(2);
         expect(errored).is.true;
 
-        await expect(startStop(FakeProvider2.instance)).to.be.fulfilled;
-        await expect(startStop(FakeProvider3.instance)).to.be.fulfilled;
-        await expect(startStop(FakeProvider4.instance)).to.be.fulfilled;
+        await expect(startStop(FakeProvider2)).to.be.fulfilled;
+        await expect(startStop(FakeProvider3)).to.be.fulfilled;
+        await expect(startStop(FakeProvider4)).to.be.fulfilled;
 
     });
 });