@wemap/positioning 2.3.0 → 2.3.2

package/package.json

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

package/src/PositioningHandler.js

@@ -1,11 +1,16 @@
+/* eslint-disable max-statements */
 import EventType from './events/EventType';
 import PdrProvider from './providers/pose/pdr/PdrProvider';
 import GnssWifiPdrProvider from './providers/pose/GnssWifiPdrProvider';
 import PoseProvider from './providers/pose/PoseProvider';
-import ProviderOptions from './providers/ProviderOptions';
+import PositioningOptions from './PositioningOptions';
 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';
+import NoProviderFoundError from './errors/NoProviderFoundError';
+import ProviderError from './events/ProviderError';
 
 /**
  * @private
@@ -27,60 +32,103 @@ class PositioningHandler {
      * @param {EventType[]} eventsType array of events to subscribe
      * @param {Function} onEvent Callback on events, first and only parameter is a: {@link ProviderEvent[]}.
      * @param {Function} onError Callback on errors, first and only parameter is a: {@link ProviderError[]}.
-     * @param {ProviderOptions} options
+     * @param {PositioningOptions} options
      * @returns {Number} an id to stop or interact with
      */
     start(eventsType, onEvent, onError, options) {
 
-        this.options = Object.assign(ProviderOptions, options);
+        this.options = Object.assign({}, PositioningOptions, options);
 
-        const providerClass = this.findProvider(eventsType, this.options);
-
-        if (!providerClass) {
-            throw new Error('No provider found');
+        const providerClass = PositioningHandler.findProvider(eventsType, this.options);
+        if (Array.isArray(providerClass)) {
+            onError(providerClass);
+            return null;
         }
-
         const provider = Reflect.construct(providerClass, [onEvent, onError, this.options]);
         this.providerInstances[provider.id] = provider;
         provider.start();
 
         return provider.id;
+
     }
 
     /**
      * @private
      */
-    findProvider(eventsType, options) {
+    static findProvider(eventsType, _options) {
 
-        const wantPoseProvider = [EventType.AbsolutePosition, EventType.AbsoluteAttitude]
-            .every(elem => eventsType.includes(elem));
+        const options = Object.assign({}, PositioningOptions, _options);
 
-        if (wantPoseProvider) {
+        let errors = [];
+        const canUse = (provider, others = []) => {
+            if (options.ignoreProviders.includes(provider.name)
+                || others.some(elem => options.ignoreProviders.includes(elem.name))) {
+                return false;
+            }
+            errors = provider.checkAvailabilityErrors();
+            return errors.length === 0;
+        };
 
-            const arCoreAvailable = ArCoreAbsoluteProvider.checkAvailabilityErrors().length === 0;
+        const wantInclination = eventsType.length === 1
+            && eventsType.includes(EventType.Inclination);
 
-            if ((options.ignoreProviders.includes(PdrProvider)
-                && options.ignoreProviders.includes(ArCoreAbsoluteProvider))
-                || (!options.ignoreProviders.includes(ArCoreAbsoluteProvider)
-                    && !arCoreAvailable)) {
-                return PoseProvider;
+        if (wantInclination) {
+            if (canUse(InclinationProvider)) {
+                return InclinationProvider;
             }
+            if (errors.length !== 0) {
+                return errors;
+            }
+            return [new ProviderError(null, EventType.Inclination, new NoProviderFoundError())];
+        }
+
+        const wantPoseProvider = [EventType.AbsolutePosition, EventType.AbsoluteAttitude]
+            .every(elem => eventsType.includes(elem)) && eventsType.length === 2;
+
+        if (wantPoseProvider) {
 
             if (options.waitInputPosition) {
-                if (!options.ignoreProviders.includes(ArCoreAbsoluteProvider) && arCoreAvailable) {
+                if (canUse(ArCoreAbsoluteProvider, [ArCoreProvider])) {
                     return ArCoreAbsoluteProvider;
                 }
-                if (!options.ignoreProviders.includes(PdrProvider)) {
+                if (canUse(PdrProvider)) {
                     return PdrProvider;
                 }
+
+                return [
+                    new ProviderError(null, EventType.AbsoluteAttitude, new NoProviderFoundError()),
+                    new ProviderError(null, EventType.AbsolutePosition, new NoProviderFoundError())
+                ];
             }
 
-            return GnssWifiPdrProvider;
-        }
-        if (eventsType.includes(EventType.Inclination)) {
-            return InclinationProvider;
+            if (canUse(GnssWifiPdrProvider, [PdrProvider])) {
+                return GnssWifiPdrProvider;
+            }
+
+            if (canUse(PoseProvider)) {
+                return PoseProvider;
+            }
+
+            if (options.optionalEvents.includes(EventType.AbsoluteAttitude)
+                && canUse(GnssWifiProvider)) {
+                return GnssWifiProvider;
+            }
+
+            if (errors.length !== 0) {
+                return errors;
+            }
+
+            if (options.optionalEvents.includes(EventType.AbsoluteAttitude)) {
+                return [new ProviderError(null, EventType.AbsolutePosition, new NoProviderFoundError())];
+            }
+
+            return [
+                new ProviderError(null, EventType.AbsoluteAttitude, new NoProviderFoundError()),
+                new ProviderError(null, EventType.AbsolutePosition, new NoProviderFoundError())
+            ];
         }
-        return null;
+
+        return [];
     }
 
     /**

package/src/PositioningHandler.spec.js

@@ -0,0 +1,221 @@
+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';
+import ProviderError from './events/ProviderError';
+import { ProvidersName } from './providers/ProvidersList';
+
+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[0]).to.be.instanceOf(ProviderError);
+    });
+
+    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[0]).to.be.instanceOf(ProviderError);
+    });
+
+    it('Pose without PDR Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            { ignoreProviders: [PdrProvider] }
+        );
+        expect(provider[0]).to.be.instanceOf(ProviderError);
+    });
+
+    it('Pose without ArCore Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            { ignoreProviders: [ArCoreProvider] }
+        );
+        expect(provider[0]).to.be.instanceOf(ProviderError);
+    });
+
+    it('Pose with optional attitude Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider([EventType.AbsolutePosition, EventType.AbsoluteAttitude]);
+        expect(provider[0]).to.be.instanceOf(ProviderError);
+    });
+
+    it('Pose with optional attitude without PDR Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT);
+        const provider = PositioningHandler.findProvider(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            {
+                ignoreProviders: [ProvidersName.Pdr],
+                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: [ProvidersName.ArCore],
+                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: [ProvidersName.Pdr, ProvidersName.ArCore],
+                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: [ProvidersName.Pdr] }
+        );
+        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: [ProvidersName.ArCore] }
+        );
+        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: [ProvidersName.Pdr, ProvidersName.ArCore] }
+        );
+        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: [ProvidersName.ArCore]
+            }
+        );
+        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: [ProvidersName.Pdr]
+            }
+        );
+        expect(provider[0]).to.be.instanceOf(ProviderError);
+        expect(provider[1]).to.be.instanceOf(ProviderError);
+    });
+
+    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: [ProvidersName.ArCore]
+            }
+        );
+        expect(provider).to.be.equals(PdrProvider);
+    });
+
+});

package/src/{providers/ProviderOptions.js → PositioningOptions.js}

@@ -1,4 +1,4 @@
-const ProviderOptions = {
+const PositioningOptions = {
 
     /**
      * Does provider have to wait an input position to start
@@ -20,9 +20,15 @@ const ProviderOptions = {
 
     /**
      * Providers listed here will not be used by PositioningHandler
-     * List of {@link Provider}
+     * List of {@link Provider#name}
      */
-    ignoreProviders: []
+    ignoreProviders: [],
+
+    /**
+     * Define the list of EventType that are optionals
+     * List of {@link EventType}
+     */
+    optionalEvents: []
 };
 
-export default ProviderOptions;
+export default PositioningOptions;

package/src/components/PositioningPoseComponent.jsx

@@ -46,6 +46,10 @@ class PositioningPoseComponent extends React.Component {
             }
         );
 
+        if (!this.id) {
+            return;
+        }
+
         setTimeout(() => {
             this.props.positioningHandler.setPosition(this.id, INITIAL_POSITION);
             this.props.positioningHandler.setHeading(this.id, INITIAL_HEADING);

package/src/errors/NoProviderFoundError.js

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

package/src/index.js

@@ -1,6 +1,8 @@
 import InclinationProvider from './providers/computed/InclinationProvider';
 import PositioningHandler from './PositioningHandler';
+import EventType from './events/EventType';
+import { ProvidersName } from './providers/ProvidersList';
 
 export {
-    InclinationProvider, PositioningHandler
+    InclinationProvider, PositioningHandler, EventType, ProvidersName
 };

package/src/providers/ProvidersList.js

@@ -0,0 +1,44 @@
+import GnssWifi from './position/GnssWifiProvider';
+import Ip from './position/IpProvider';
+import Pdr from './pose/pdr/PdrProvider';
+import ArCore from './pose/ArCoreProvider';
+import ArCoreAbsolute from './pose/ArCoreAbsoluteProvider';
+import Inclination from './others/InclinationProvider';
+import GnssWifiPdr from './pose/GnssWifiPdrProvider';
+import Imu from './others/ImuProvider';
+import AbsoluteAttitude from './attitude/AbsoluteAttitudeProvider';
+import RelativeAttitude from './attitude/RelativeAttitudeProvider';
+
+const ProvidersName = {
+    AbsoluteAttitude: AbsoluteAttitude.name,
+    ArCore: ArCore.name,
+    ArCoreAbsolute: ArCoreAbsolute.name,
+    GnssWifi: GnssWifi.name,
+    GnssWifiPdr: GnssWifiPdr.name,
+    Imu: Imu.name,
+    Inclination: Inclination.name,
+    Ip: Ip.name,
+    Pdr: Pdr.name,
+    RelativeAttitude: RelativeAttitude.name
+};
+
+const ProvidersModules = {
+    AbsoluteAttitude,
+    ArCore,
+    ArCoreAbsolute,
+    GnssWifi,
+    GnssWifiPdr,
+    Imu,
+    Inclination,
+    Ip,
+    Pdr,
+    RelativeAttitude
+};
+
+function getModuleFromName(name) {
+    return ProvidersModules[name];
+}
+
+export {
+    ProvidersName, getModuleFromName
+};