@wemap/positioning 2.1.0 → 2.2.0

package/src/providers/pose/ArCoreProvider.js

@@ -0,0 +1,127 @@
+import { Attitude } from '@wemap/geo';
+
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import MissingArCoreError from '../../errors/MissingArCoreError';
+
+/**
+ * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
+ * of what he can and provides an AbsoluteAttitude and an AbsolutePosition as an output.
+ */
+class ArCoreProvider extends Provider {
+
+    /**
+    * @override
+    */
+    constructor(onEvent, onError, options) {
+        super(onEvent, onError, options);
+
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'ArCore provider';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.RelativeAttitude, EventType.RelativePosition];
+    }
+
+    /**
+     * Return the list of required providers
+     */
+    static get requiredProviders() {
+        return [];
+    }
+
+    /**
+     * @override
+     */
+    startInternal() {
+        const nativeProvider = this.constructor.getNativeProvider();
+        if (Array.isArray(nativeProvider)) {
+            this.notifyError(nativeProvider);
+            return;
+        }
+        nativeProvider.start();
+
+        this.pullDataLoop();
+    }
+
+    /**
+     * @override
+     */
+    stopInternal() {
+        const nativeProvider = this.constructor.getNativeProvider();
+        if (Array.isArray(nativeProvider)) {
+            this.notifyError(nativeProvider);
+            return;
+        }
+        nativeProvider.stop();
+    }
+
+    pullDataLoop = () => {
+
+        if (this.state !== Provider.State.STARTED) {
+            return;
+        }
+
+        const nativeProvider = this.constructor.getNativeProvider();
+        if (Array.isArray(nativeProvider)) {
+            this.notifyError(...nativeProvider);
+            return;
+        }
+
+        const pose = JSON.parse(nativeProvider.getInfo());
+        if (pose.length !== 0) {
+            const attitude = new Attitude(pose.slice(0, 4));
+            const position = pose.slice(4, 7);
+            this.notify(
+                this.createEvent(EventType.RelativeAttitude, attitude),
+                this.createEvent(EventType.RelativePosition, position)
+            );
+        }
+
+        requestAnimationFrame(this.pullDataLoop);
+    }
+
+    static getNativeProvider() {
+        const nativeInterface = this.getNativeInterface();
+
+        if (!nativeInterface) {
+            return [
+                this.createMissingNativeInterfaceError(EventType.RelativeAttitude),
+                this.createMissingNativeInterfaceError(EventType.RelativePosition)
+            ];
+        }
+
+        return nativeInterface.getArCoreProvider();
+    }
+
+    /**
+     * @override
+     */
+    static checkAvailabilityErrors() {
+
+        const nativeProvider = this.getNativeProvider();
+        if (Array.isArray(nativeProvider)) {
+            return nativeProvider;
+        }
+
+        if (nativeProvider.checkAvailability()) {
+            return [];
+        }
+
+        return [
+            this.createError(EventType.RelativeAttitude, new MissingArCoreError()),
+            this.createError(EventType.RelativePosition, new MissingArCoreError())
+        ];
+    }
+}
+
+export default ArCoreProvider;

package/src/providers/pose/pdr/PdrProvider.js

@@ -61,7 +61,7 @@ class PdrProvider extends MapMatchingProvider {
         this.smoother = new Smoother();
         this.thugDetector = new ThugDetector();
 
-        if (options.useMapMatching) {
+        if (this.options.useMapMatching) {
             this.enableMapMatching();
         }
     }

package/webpack/webpack.common.js

@@ -12,7 +12,7 @@ module.exports = {
             },
             {
                 test: /\.css$/,
-                use: { loader: 'css-loader' }
+                use: ['style-loader', 'css-loader']
             }
         ]
     },

package/src.old/Constants.js

@@ -1,11 +0,0 @@
-const Constants = {
-    LOCATION_SOURCE_PROVIDERS: {
-        IP: 'IP',
-        GNSS: 'GNSS/WIFI',
-        PDR: 'PDR',
-        GNSS_PDR: 'GNSS/WIFI-PDR',
-        FIXED_LOCATION: 'FIXED_LOCATION'
-    }
-};
-
-export default Constants;

package/src.old/NavigationHandler.js

@@ -1,244 +0,0 @@
-import noop from 'lodash.noop';
-
-import { WGS84UserPosition, Itinerary } from '@wemap/geo';
-
-import LocationSource from './providers/LocationSource';
-import IPLocationSource from './providers/IPLocationSource';
-import GnssLocationSource from './providers/GnssLocationSource';
-import PdrLocationSource from './providers/PdrLocationSource';
-import GnssPdrLocationSource from './providers/GnssPdrLocationSource';
-import FixedLocationImuLocationSource from './providers/FixedLocationImuLocationSource';
-import SensorsLogger from './sensors/SensorsLogger';
-
-const DEFAULT_ALTITUDE = 1.6;
-
-/**
- * @private
- */
-class NavigationHandler {
-
-    /**
-     * Constructor of NavigationHandler
-     * @param {Function} callbackOnStart callback when navigation starts
-     * @param {Function} callbackOnStop callback when navigation stops
-     * @param {Function} callbackOnNewPose callback on new pose
-     * @public
-     */
-    constructor(callbackOnStart, callbackOnStop, callbackOnNewPose) {
-        this.callback = this.callback.bind(this);
-
-        this.callbackOnStart = callbackOnStart || noop;
-        this.callbackOnStop = callbackOnStop || noop;
-        this.callbackOnNewPose = callbackOnNewPose || noop;
-    }
-
-
-    /**
-     * Starts navigation from an initial position an initial heading
-     * @param {*} initialPosition initial position {lat: xx, lng: xx}
-     * @param {Number} initialHeading initial heading in radians and clockwise: north: 0, east = PI/2
-     * @param {Array} path an optional itinerary (list of 2D points [lng, lat])
-     * @public
-     */
-    startRelative(initialPosition, initialHeading, path = null) {
-
-        const initialPositionWgs84 = new WGS84UserPosition(
-            initialPosition.lat,
-            initialPosition.lng,
-            initialPosition.alt || DEFAULT_ALTITUDE
-        );
-
-        // stop current location source if already started
-        if (this.locationSource) {
-            this.locationSource.stop();
-        }
-
-        this.locationSource = new PdrLocationSource(this.callback, {
-            'stepdetectionlocker': true,
-            'smoother': true
-        });
-        this.locationSource.setLogger(this.logger);
-
-        if (path) {
-            const itinerary = Itinerary.fromPoints(path);
-            this.locationSource.enableMapMatching(itinerary);
-            this.locationSource.setItinerary(itinerary);
-        }
-        this.locationSource.setLocation(initialPositionWgs84);
-        this.locationSource.setHeading(initialHeading);
-        const promise = this.locationSource.start();
-
-        this.callbackOnStart();
-        return promise;
-    }
-
-    /**
-     * Starts navigation handler without any knowledge on starting point
-     * @param {Array} path an optional itinerary (list of 2D points [lng, lat])
-     * @public
-     */
-    startAbsolute(path) {
-        // stop if already started
-        if (this.locationSource) {
-            this.locationSource.stop();
-        }
-
-        const itinerary = Itinerary.fromPoints(path);
-        this.locationSource = new GnssPdrLocationSource(this.callback);
-        this.locationSource.enableMapMatching(itinerary);
-        this.locationSource.setItinerary(itinerary);
-        this.locationSource.setLogger(this.logger);
-
-        const promise = this.locationSource.start();
-        this.callbackOnStart();
-        return promise;
-    }
-
-    locateme(
-        options = {
-            ip: true,
-            browser: true,
-            attitude: true
-        }
-    ) {
-        const useIPProvider = !options.hasOwnProperty('ip') || options.ip === true;
-        const useBrowserProvider = !options.hasOwnProperty('browser') || options.browser === true;
-        const useImu = !options.hasOwnProperty('attitude') || options.attitude === true;
-
-        return new Promise((resolve, reject) => {
-            const gnss = new GnssLocationSource(pose => {
-                resolve(pose);
-                this.callback(pose);
-            }, useImu);
-
-            const ip = new IPLocationSource(pose => {
-                resolve(pose);
-                this.callback(pose);
-            }, useImu);
-
-            if (
-                this.locationSource
-                && LocationSource.getMostAccurateLocationSource(this.locationSource, gnss) === this.locationSource
-            ) {
-                resolve(this.locationSource.getPose());
-            } else {
-                if (this.locationSource) {
-                    this.locationSource.stop();
-                }
-
-                if (useBrowserProvider) {
-                    this.locationSource = gnss;
-                    gnss.start().catch(e => {
-                        if (useIPProvider) {
-                            this.locationSource = ip;
-                            ip.start();
-                            return;
-                        }
-                        reject(e);
-                    });
-                } else if (useIPProvider) {
-                    this.locationSource = ip;
-                    ip.start();
-                }
-            }
-        });
-    }
-
-
-    /**
-     * Stop relative, absolute or locateme navigation if started
-     * @public
-     */
-    stop() {
-        if (
-            this.locationSource
-        ) {
-            this.locationSource.stop();
-            this.locationSource = null;
-        }
-        this.callbackOnStop();
-    }
-
-
-    /**
-     * @see LocationSource#getProjectionOnNetwork()
-     * @public
-     */
-    getProjectionOnNetwork(location) {
-        return this.locationSource.getProjectionOnNetwork(location);
-    }
-
-    /**
-     * @see LocationSource#getItineraryInfo()
-     * @public
-     */
-    getItineraryInfo(location) {
-        return this.locationSource.getItineraryInfo(location);
-    }
-
-    forceUserLocation(location) {
-        if (
-            this.locationSource
-            && (!(this.locationSource instanceof FixedLocationImuLocationSource) || !location)
-        ) {
-            this.locationSource.stop();
-        }
-
-        if (location) {
-            if (
-                !this.locationSource
-                || !(this.locationSource instanceof FixedLocationImuLocationSource)
-            ) {
-                this.locationSource = new FixedLocationImuLocationSource(this.callback);
-                this.locationSource.start(location);
-            } else {
-                this.locationSource.setLocation(location);
-            }
-        } else {
-            this.locationSource = null;
-        }
-    }
-
-    /**
-     * @private
-     */
-    callback(pose) {
-        this.callbackOnNewPose(pose);
-    }
-
-    /**
-     * Assign a SensorsLogger to LocationSource and start recording.
-     * This logger will be fed with sensors output.
-     * Logger is not working on locateme()
-     * @param {SensorsLogger} logger An instance of SensorsLogger.
-     * @public
-     */
-    startLogger(logger) {
-        if (!(logger instanceof SensorsLogger)) {
-            throw new Error('logger is not an instance of SensorsLogger');
-        }
-
-        this.logger = logger;
-
-        if (this.locationSource) {
-            this.locationSource.setLogger(this.logger);
-        }
-    }
-
-    /**
-    * Stop recording sensors
-     * @public
-    */
-    stopLogger() {
-        this.logger = null;
-        if (this.locationSource) {
-            this.locationSource.setLogger(this.logger);
-        }
-    }
-
-    static get DEFAULT_ALTITUDE() {
-        return DEFAULT_ALTITUDE;
-    }
-}
-
-export default NavigationHandler;

package/src.old/Pose.js

@@ -1,8 +0,0 @@
-class Pose {
-
-    attitude = null;
-    location = null;
-
-}
-
-export default Pose;