npm - @wemap/positioning - Versions diffs - 2.2.0 → 2.3.1 - Mend

@wemap/positioning 2.2.0 → 2.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/debug/arcore-absolute.html +16 -0
package/package.json +1 -1
package/src/PositioningHandler.js +45 -14
package/src/PositioningHandler.spec.js +218 -0
package/src/components/AbsoluteAttitudeComponent.jsx +2 -2
package/src/components/ArCoreAbsoluteComponent.jsx +100 -0
package/src/components/ArCoreComponent.jsx +3 -3
package/src/components/GnssWifiPdrComponent.jsx +2 -2
package/src/components/MapComponent.jsx +29 -18
package/src/components/PdrComponent.jsx +3 -3
package/src/components/PositioningPoseComponent.jsx +3 -3
package/src/components/index.js +2 -0
package/src/index.js +2 -1
package/src/providers/Provider.js +2 -2
package/src/providers/ProviderOptions.js +8 -2
package/src/providers/attitude/AbsoluteAttitudeProvider.js +6 -6
package/src/providers/others/MapMatchingProvider.js +19 -19
package/src/providers/pose/ArCoreAbsoluteProvider.js +186 -0
package/src/providers/pose/ArCoreProvider.js +31 -43
package/src/providers/pose/GnssWifiPdrProvider.js +20 -20
package/src/providers/pose/PoseProvider.js +1 -1
package/src/providers/pose/pdr/PdrProvider.js +38 -38
package/src/providers/pose/pdr/helpers/Smoother.js +33 -33
package/src/providers/pose/pdr/helpers/Smoother.spec.js +7 -7
package/src/providers/position/GnssWifiProvider.js +5 -5
package/src/providers/position/IpProvider.js +2 -2

package/debug/arcore-absolute.html ADDED Viewed

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, user-scalable=no">
+  <title>Debug ARCore Absolute</title>
+  <script src="/js/positioning-components.js"></script>
+</head>
+<body>
+  <div id="app"></div>
+  <script>createReactElement(ArCoreAbsoluteComponent, document.getElementById('app'));</script>
+</body>
+</html>

package/package.json CHANGED Viewed

@@ -81,5 +81,5 @@
     "lint": "eslint --ext .js,.jsx --quiet src",
     "test": "mocha -r esm \"src/**/*.spec.js\""
   },
-  "version": "2.2.0"
+  "version": "2.3.1"
 }

package/src/PositioningHandler.js CHANGED Viewed

@@ -5,6 +5,9 @@ import PoseProvider from './providers/pose/PoseProvider';
 import ProviderOptions from './providers/ProviderOptions';
 import InclinationProvider from './providers/others/InclinationProvider';
 import Logger from '@wemap/logger';
+import ArCoreAbsoluteProvider from './providers/pose/ArCoreAbsoluteProvider';
+import ArCoreProvider from './providers/pose/ArCoreProvider';
+import GnssWifiProvider from './providers/position/GnssWifiProvider';
 /**
  * @private
@@ -31,9 +34,9 @@ class PositioningHandler {
      */
     start(eventsType, onEvent, onError, options) {
-        this.options = Object.assign(ProviderOptions, options);
+        this.options = Object.assign({}, ProviderOptions, options);
-        const providerClass = this.findProvider(eventsType, this.options);
+        const providerClass = PositioningHandler.findProvider(eventsType, this.options);
         if (!providerClass) {
             throw new Error('No provider found');
@@ -49,23 +52,51 @@ class PositioningHandler {
     /**
      * @private
      */
-    findProvider(eventsType, options) {
+    static findProvider(eventsType, _options) {
+        const options = Object.assign({}, ProviderOptions, _options);
+        const canUse = (provider, others = []) => {
+            return !options.ignoreProviders.includes(provider)
+                && !others.some(elem => options.ignoreProviders.includes(elem))
+                && provider.checkAvailabilityErrors().length === 0;
+        };
+        if (eventsType.length === 1
+            && eventsType.includes(EventType.Inclination)
+            && InclinationProvider.checkAvailabilityErrors().length === 0) {
+            return InclinationProvider;
+        }
         const wantPoseProvider = [EventType.AbsolutePosition, EventType.AbsoluteAttitude]
-            .every(elem => eventsType.includes(elem));
+            .every(elem => eventsType.includes(elem)) && eventsType.length === 2;
         if (wantPoseProvider) {
-            if (options.ignoreProviders.includes(PdrProvider)) {
+            if (options.waitInputPosition) {
+                if (canUse(ArCoreAbsoluteProvider, [ArCoreProvider])) {
+                    return ArCoreAbsoluteProvider;
+                }
+                if (canUse(PdrProvider)) {
+                    return PdrProvider;
+                }
+                return null;
+            }
+            if (canUse(GnssWifiPdrProvider, [PdrProvider])) {
+                return GnssWifiPdrProvider;
+            }
+            if (canUse(PoseProvider)) {
                 return PoseProvider;
             }
-            if (options.waitInputPosition) {
-                return PdrProvider;
+            if (options.optionalEvents.includes(EventType.AbsoluteAttitude)
+                && canUse(GnssWifiProvider)) {
+                return GnssWifiProvider;
             }
-            return GnssWifiPdrProvider;
-        }
-        if (eventsType.includes(EventType.Inclination)) {
-            return InclinationProvider;
         }
         return null;
     }
@@ -85,10 +116,10 @@ class PositioningHandler {
         if (!provider) {
             throw new Error('Unknown provider');
         }
-        if (!provider.setLocation) {
-            Logger.warn('Cannot set location to ' + provider.constructor.name);
+        if (!provider.setPosition) {
+            Logger.warn('Cannot set position to ' + provider.constructor.name);
         }
-        provider.setLocation(position);
+        provider.setPosition(position);
     }
     /**

package/src/PositioningHandler.spec.js ADDED Viewed

@@ -0,0 +1,218 @@
+import chai from 'chai';
+import 'jsdom-global/register';
+import PositioningHandler from './PositioningHandler';
+import EventType from './events/EventType';
+import InclinationProvider from './providers/others/InclinationProvider';
+import GnssWifiPdrProvider from './providers/pose/GnssWifiPdrProvider';
+import PoseProvider from './providers/pose/PoseProvider';
+import PdrProvider from './providers/pose/pdr/PdrProvider';
+import ArCoreAbsoluteProvider from './providers/pose/ArCoreAbsoluteProvider';
+import GnssWifiProvider from './providers/position/GnssWifiProvider';
+import ArCoreProvider from './providers/pose/ArCoreProvider';
+const expect = chai.expect;
+function fakeUserAgent(userAgent) {
+    navigator.__defineGetter__('userAgent', () => userAgent);
+}
+function fakeNativeInterface(arcore = true) {
+    // We have to clear the cache here
+    ArCoreProvider._nativeProvider = null;
+    global.WemapProvidersAndroid = {getArCoreProvider: () => {
+        return { checkAvailability: () => arcore };
+    }};
+}
+function fakeGeolocation() {
+    navigator.__defineGetter__('geolocation', () => {
+        return {watchPosition: () => {}};
+    });
+}
+function config(userAgent, nativeInterface = false, arcore = false) {
+    if (userAgent) {
+        fakeUserAgent(userAgent);
+    }
+    if (nativeInterface) {
+        fakeNativeInterface(arcore);
+    } else {
+        delete global.WemapProvidersAndroid;
+    }
+    fakeGeolocation();
+}
+const CHROME_ANDROID_USER_AGENT = 'Mozilla/5.0 (Linux; Android 9; SM-G960F Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.157 Mobile Safari/537.36';
+const CHROME_DESKTOP_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36';
+describe('PositioningHandler#findProvider', () => {
+    it('Inclination Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider([EventType.Inclination]);
+        expect(provider).to.be.null;
+    });
+    it('Inclination Mobile', () => {
+        config(CHROME_ANDROID_USER_AGENT);
+        const provider = PositioningHandler.findProvider([EventType.Inclination]);
+        expect(provider).to.be.equals(InclinationProvider);
+    });
+    it('Pose Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider([EventType.AbsolutePosition, EventType.AbsoluteAttitude]);
+        expect(provider).to.be.null;
+    });
+    it('Pose without PDR Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            { ignoreProviders: [PdrProvider] }
+        );
+        expect(provider).to.be.null;
+    });
+    it('Pose without ArCore Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            { ignoreProviders: [ArCoreProvider] }
+        );
+        expect(provider).to.be.null;
+    });
+    it('Pose with optional attitude Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider([EventType.AbsolutePosition, EventType.AbsoluteAttitude]);
+        expect(provider).to.be.null;
+    });
+    it('Pose with optional attitude without PDR Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            {
+                ignoreProviders: [PdrProvider],
+                optionalEvents: [EventType.AbsoluteAttitude]
+            }
+        );
+        expect(provider).to.be.equals(GnssWifiProvider);
+    });
+    it('Pose with optional attitude without ArCore Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            {
+                ignoreProviders: [ArCoreProvider],
+                optionalEvents: [EventType.AbsoluteAttitude]
+            }
+        );
+        expect(provider).to.be.equals(GnssWifiProvider);
+    });
+    it('Pose with optional attitude without PDR and ArCore Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            {
+                ignoreProviders: [PdrProvider, ArCoreProvider],
+                optionalEvents: [EventType.AbsoluteAttitude]
+            }
+        );
+        expect(provider).to.be.equals(GnssWifiProvider);
+    });
+    it('Pose Mobile Web', () => {
+        config(CHROME_ANDROID_USER_AGENT);
+        const provider = PositioningHandler.findProvider([EventType.AbsolutePosition, EventType.AbsoluteAttitude]);
+        expect(provider).to.be.equals(GnssWifiPdrProvider);
+    });
+    it('Pose without PDR Mobile Web', () => {
+        config(CHROME_ANDROID_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            { ignoreProviders: [PdrProvider] }
+        );
+        expect(provider).to.be.equals(PoseProvider);
+    });
+    it('Pose without ArCore Mobile Web', () => {
+        config(CHROME_ANDROID_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            { ignoreProviders: [ArCoreProvider] }
+        );
+        expect(provider).to.be.equals(GnssWifiPdrProvider);
+    });
+    it('Pose without PDR and ArCore Mobile Web', () => {
+        config(CHROME_ANDROID_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            { ignoreProviders: [PdrProvider, ArCoreProvider] }
+        );
+        expect(provider).to.be.equals(PoseProvider);
+    });
+    it('Pose with waitInputPosition Mobile Web', () => {
+        config(CHROME_ANDROID_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            { waitInputPosition: true }
+        );
+        expect(provider).to.be.equals(PdrProvider);
+    });
+    it('Pose with waitInputPosition Mobile Native with ArCore', () => {
+        config(CHROME_ANDROID_USER_AGENT, true, true);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            { waitInputPosition: true }
+        );
+        expect(provider).to.be.equals(ArCoreAbsoluteProvider);
+    });
+    it('Pose with waitInputPosition Mobile Native without ArCore', () => {
+        config(CHROME_ANDROID_USER_AGENT, true, false);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            {
+                waitInputPosition: true,
+                ignoreProviders: [ArCoreProvider]
+            }
+        );
+        expect(provider).to.be.equals(PdrProvider);
+    });
+    it('Pose with waitInputPosition without PDR Mobile Web', () => {
+        config(CHROME_ANDROID_USER_AGENT, false);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            {
+                waitInputPosition: true,
+                ignoreProviders: [PdrProvider]
+            }
+        );
+        expect(provider).to.be.null;
+    });
+    it('Pose with waitInputPosition without ArCore Mobile Native', () => {
+        config(CHROME_ANDROID_USER_AGENT, true, true);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            {
+                waitInputPosition: true,
+                ignoreProviders: [ArCoreProvider]
+            }
+        );
+        expect(provider).to.be.equals(PdrProvider);
+    });
+});

package/src/components/AbsoluteAttitudeComponent.jsx CHANGED Viewed

@@ -6,7 +6,7 @@ import AbsoluteAttitudeProvider from '../providers/attitude/AbsoluteAttitudeProv
 import Utils from './Utils';
 import EventType from '../events/EventType';
-const userLocation = new WGS84(43.609275, 3.884236);
+const userPosition = new WGS84(43.609275, 3.884236);
 class AbsoluteAttitudeComponent extends React.Component {
@@ -20,7 +20,7 @@ class AbsoluteAttitudeComponent extends React.Component {
         };
         this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(this.onEvent, this.onError);
-        this.absoluteAttitudeProvider.setLocation(userLocation);
+        this.absoluteAttitudeProvider.setPosition(userPosition);
     }
     componentDidMount() {

package/src/components/ArCoreAbsoluteComponent.jsx ADDED Viewed

@@ -0,0 +1,100 @@
+import React from 'react';
+import isEmpty from 'lodash.isempty';
+import EventType from '../events/EventType';
+import Utils from './Utils';
+import ArCoreAbsoluteProvider from '../providers/pose/ArCoreAbsoluteProvider';
+import { deg2rad } from '@wemap/maths';
+import {
+    WGS84UserPosition, Itinerary
+} from '@wemap/geo';
+import MapComponent from './MapComponent';
+const INITIAL_POSITION = new WGS84UserPosition(43.6091955, 3.8841255);
+const INITIAL_HEADING = 191.9;
+const ITINERARY = Itinerary.fromPoints([
+    [INITIAL_POSITION.lat, INITIAL_POSITION.lng],
+    [43.6091883, 3.8841242],
+    [43.6091709, 3.8842382],
+    [43.6091288, 3.884226],
+    [43.6091461, 3.884112]
+], false);
+class ArCoreAbsoluteComponent extends React.Component {
+    constructor(props, context) {
+        super(props, context);
+        this.state = {
+            position: null,
+            attitude: null
+        };
+        this.arCoreAbsoluteProvider = new ArCoreAbsoluteProvider(this.onEvent, this.onError);
+        this.arCoreAbsoluteProvider.setPosition(INITIAL_POSITION);
+        this.arCoreAbsoluteProvider.setHeading(deg2rad(INITIAL_HEADING));
+    }
+    componentDidMount() {
+        this.arCoreAbsoluteProvider.start();
+    }
+    componentWillUnmount() {
+        this.arCoreAbsoluteProvider.stop();
+    }
+    onEvent = events => {
+        const newState = {};
+        events.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                newState.position = event.data;
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                newState.attitude = event.data;
+            }
+        });
+        if (!isEmpty(newState)) {
+            this.setState(newState);
+        }
+        if (this.map) {
+            this.map.parseEvents(events);
+        }
+    };
+    onError = events => {
+        const newState = {};
+        events.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                newState.position = event.error;
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                newState.attitude = event.error;
+            }
+        });
+        if (!isEmpty(newState)) {
+            this.setState(newState);
+        }
+    }
+    render() {
+        const attitudeRender = Utils.renderAttitude(this.state.attitude);
+        const positionRender = Utils.renderPosition(this.state.position);
+        return (
+            <div>
+                <h3>Position</h3>
+                {positionRender}
+                <h3>Attitude</h3>
+                {attitudeRender}
+                <h3>Map</h3>
+                <MapComponent
+                    ref={map => (this.map = map)}
+                    defaultZoom={21}
+                    network={ITINERARY} />
+            </div>
+        );
+    }
+}
+export default ArCoreAbsoluteComponent;

package/src/components/ArCoreComponent.jsx CHANGED Viewed

@@ -14,16 +14,16 @@ class ArCoreComponent extends React.Component {
             attitude: null
         };
-        this.poseProvider = new ArCoreProvider(this.onEvent, this.onError);
+        this.arCoreProvider = new ArCoreProvider(this.onEvent, this.onError);
     }
     componentDidMount() {
-        this.poseProvider.start();
+        this.arCoreProvider.start();
     }
     componentWillUnmount() {
-        this.poseProvider.stop();
+        this.arCoreProvider.stop();
     }
     onEvent = events => {

package/src/components/GnssWifiPdrComponent.jsx CHANGED Viewed

@@ -10,9 +10,9 @@ import EventType from '../events/EventType';
 import GnssWifiPdrProvider from '../providers/pose/GnssWifiPdrProvider';
 import MapComponent from './MapComponent';
-const INITIAL_LOCATION = new WGS84UserPosition(43.6091955, 3.8841255);
+const INITIAL_POSITION = new WGS84UserPosition(43.6091955, 3.8841255);
 const ITINERARY = Itinerary.fromPoints([
-    [INITIAL_LOCATION.lat, INITIAL_LOCATION.lng],
+    [INITIAL_POSITION.lat, INITIAL_POSITION.lng],
     [43.6091883, 3.8841242],
     [43.6091709, 3.8842382],
     [43.6091288, 3.884226],

package/src/components/MapComponent.jsx CHANGED Viewed

@@ -25,7 +25,7 @@ const COMPASS_STYLE = {
     'opacity': 0.5
 };
-const LOCATION_STYLE = {
+const POSITION_STYLE = {
     'width': '15px',
     'height': '15px',
     'top': '-7px',
@@ -38,14 +38,19 @@ const LOCATION_STYLE = {
 class MapComponent extends React.Component {
-    static propTypes = { network: PropTypes.instanceOf(Network) };
+    static propTypes = {
+        network: PropTypes.instanceOf(Network),
+        defaultZoom: PropTypes.number
+    };
+    static defaultProps = {defaultZoom: 19};
     componentDidMount() {
         this.map = new mapboxgl.Map({
             container: this.mapContainer,
             style: 'mapbox://styles/mapbox/streets-v9'
         });
+        this.renderNetwork();
     }
     componentWillUnmount() {
@@ -67,28 +72,28 @@ class MapComponent extends React.Component {
         return marker;
     }
-    createLocationMarker(location) {
+    createPositionMarker(position) {
         const coreIcon = document.createElement('div');
-        this.applyStyleToDomElement(coreIcon, LOCATION_STYLE);
+        this.applyStyleToDomElement(coreIcon, POSITION_STYLE);
-        this.locationIcon = document.createElement('div');
-        this.locationIcon.appendChild(coreIcon);
+        this.positionIcon = document.createElement('div');
+        this.positionIcon.appendChild(coreIcon);
         return this.createMarker({
-            dom: this.locationIcon,
+            dom: this.positionIcon,
             iconAnchor: [0, 0],
-            latitude: location[1],
-            longitude: location[0]
+            latitude: position[1],
+            longitude: position[0]
         });
     }
     createCompassElement() {
-        if (!this.locationIcon) {
-            throw new Error('createLocationMarker() should be called before');
+        if (!this.positionIcon) {
+            throw new Error('createPositionMarker() should be called before');
         }
         this.compassIcon = document.createElement('div');
         this.applyStyleToDomElement(this.compassIcon, COMPASS_STYLE);
-        this.locationIcon.appendChild(this.compassIcon);
+        this.positionIcon.appendChild(this.compassIcon);
     }
     applyStyleToDomElement(domElement, style) {
@@ -123,7 +128,7 @@ class MapComponent extends React.Component {
             if (this.mapMarker) {
                 this.mapMarker.remove();
                 this.mapMarker = null;
-                this.locationIcon = null;
+                this.positionIcon = null;
             }
             return;
         }
@@ -131,11 +136,11 @@ class MapComponent extends React.Component {
         const lngLat = [position.lng, position.lat];
         if (!this.mapMarker) {
-            this.mapMarker = this.createLocationMarker(lngLat)
+            this.mapMarker = this.createPositionMarker(lngLat)
                 .addTo(this.map);
             this.map.jumpTo({
                 center: lngLat,
-                zoom: 19
+                zoom: this.props.defaultZoom
             });
         } else {
             this.mapMarker.setLngLat(lngLat);
@@ -145,13 +150,13 @@ class MapComponent extends React.Component {
     updateAttitude(attitude) {
-        if (!this.locationIcon) {
+        if (!this.positionIcon) {
             return;
         }
         if (!(attitude instanceof Attitude)) {
             if (this.compassIcon) {
-                this.locationIcon.removeChild(this.compassIcon);
+                this.positionIcon.removeChild(this.compassIcon);
             }
             return;
         }
@@ -160,7 +165,7 @@ class MapComponent extends React.Component {
             this.createCompassElement();
         }
-        this.locationIcon.style.transform = 'rotate(' + attitude.headingDegrees + 'deg)';
+        this.positionIcon.style.transform = 'rotate(' + attitude.headingDegrees + 'deg)';
     }
     renderNetwork() {
@@ -171,6 +176,11 @@ class MapComponent extends React.Component {
         const network = this.props.network;
+        if (network === this.previousNetwork) {
+            return;
+        }
+        this.previousNetwork = network;
         if (!network) {
             if (this.networkLayer) {
                 this.map.removeLayer(this.networkLayer);
@@ -207,6 +217,7 @@ class MapComponent extends React.Component {
                 ]
             );
         }
         this.map.on('load', () => {
             this.networkLayer = this.map.addLayer(layer);
         });

package/src/components/PdrComponent.jsx CHANGED Viewed

@@ -10,10 +10,10 @@ import PdrProvider from '../providers/pose/pdr/PdrProvider';
 import EventType from '../events/EventType';
 import MapComponent from './MapComponent';
-const INITIAL_LOCATION = new WGS84UserPosition(43.6091955, 3.8841255);
+const INITIAL_POSITION = new WGS84UserPosition(43.6091955, 3.8841255);
 const INITIAL_HEADING = 191.9;
 const ITINERARY = Itinerary.fromPoints([
-    [INITIAL_LOCATION.lat, INITIAL_LOCATION.lng],
+    [INITIAL_POSITION.lat, INITIAL_POSITION.lng],
     [43.6091883, 3.8841242],
     [43.6091709, 3.8842382],
     [43.6091288, 3.884226],
@@ -31,7 +31,7 @@ class PdrComponent extends React.Component {
     componentDidMount() {
-        this.pdrProvider.setLocation(INITIAL_LOCATION);
+        this.pdrProvider.setPosition(INITIAL_POSITION);
         this.pdrProvider.setHeading(INITIAL_HEADING);
         this.pdrProvider.enableMapMatching(ITINERARY);
         this.pdrProvider.start();

package/src/components/PositioningPoseComponent.jsx CHANGED Viewed

@@ -11,10 +11,10 @@ import {
 } from '@wemap/geo';
 import MapComponent from './MapComponent';
-const INITIAL_LOCATION = new WGS84UserPosition(43.6091955, 3.8841255);
+const INITIAL_POSITION = new WGS84UserPosition(43.6091955, 3.8841255);
 const INITIAL_HEADING = 191.9;
 const ITINERARY = Itinerary.fromPoints([
-    [INITIAL_LOCATION.lat, INITIAL_LOCATION.lng],
+    [INITIAL_POSITION.lat, INITIAL_POSITION.lng],
     [43.6091883, 3.8841242],
     [43.6091709, 3.8842382],
     [43.6091288, 3.884226],
@@ -47,7 +47,7 @@ class PositioningPoseComponent extends React.Component {
         );
         setTimeout(() => {
-            this.props.positioningHandler.setPosition(this.id, INITIAL_LOCATION);
+            this.props.positioningHandler.setPosition(this.id, INITIAL_POSITION);
             this.props.positioningHandler.setHeading(this.id, INITIAL_HEADING);
             this.props.positioningHandler.setItinerary(this.id, ITINERARY);
         }, 3000);