@wemap/positioning 2.3.0 → 2.3.1

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.1"
 }

package/src/PositioningHandler.js

@@ -6,6 +6,8 @@ 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
@@ -32,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');
@@ -50,36 +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) {
 
-            const arCoreAvailable = ArCoreAbsoluteProvider.checkAvailabilityErrors().length === 0;
-
-            if ((options.ignoreProviders.includes(PdrProvider)
-                && options.ignoreProviders.includes(ArCoreAbsoluteProvider))
-                || (!options.ignoreProviders.includes(ArCoreAbsoluteProvider)
-                    && !arCoreAvailable)) {
-                return PoseProvider;
-            }
-
             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 null;
             }
 
-            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;
+            }
         }
+
         return null;
     }
 

package/src/PositioningHandler.spec.js

@@ -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/index.js

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

package/src/providers/ProviderOptions.js

@@ -22,7 +22,13 @@ const ProviderOptions = {
      * Providers listed here will not be used by PositioningHandler
      * List of {@link Provider}
      */
-    ignoreProviders: []
+    ignoreProviders: [],
+
+    /**
+     * Define the list of EventType that are optionals
+     * List of {@link EventType}
+     */
+    optionalEvents: []
 };
 
 export default ProviderOptions;