@wemap/positioning 2.3.1 → 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.1"
+  "version": "2.3.2"
 }

package/src/PositioningHandler.js

@@ -1,13 +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
@@ -29,24 +32,24 @@ 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 = PositioningHandler.findProvider(eventsType, this.options);
-
-        if (!providerClass) {
-            throw new Error('No provider found');
+        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;
+
     }
 
     /**
@@ -54,17 +57,29 @@ class PositioningHandler {
      */
     static findProvider(eventsType, _options) {
 
-        const options = Object.assign({}, ProviderOptions, _options);
+        const options = Object.assign({}, PositioningOptions, _options);
+
+        let errors = [];
         const canUse = (provider, others = []) => {
-            return !options.ignoreProviders.includes(provider)
-                && !others.some(elem => options.ignoreProviders.includes(elem))
-                && provider.checkAvailabilityErrors().length === 0;
+            if (options.ignoreProviders.includes(provider.name)
+                || others.some(elem => options.ignoreProviders.includes(elem.name))) {
+                return false;
+            }
+            errors = provider.checkAvailabilityErrors();
+            return errors.length === 0;
         };
 
-        if (eventsType.length === 1
-            && eventsType.includes(EventType.Inclination)
-            && InclinationProvider.checkAvailabilityErrors().length === 0) {
-            return InclinationProvider;
+        const wantInclination = eventsType.length === 1
+            && eventsType.includes(EventType.Inclination);
+
+        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]
@@ -79,14 +94,17 @@ class PositioningHandler {
                 if (canUse(PdrProvider)) {
                     return PdrProvider;
                 }
-                return null;
+
+                return [
+                    new ProviderError(null, EventType.AbsoluteAttitude, new NoProviderFoundError()),
+                    new ProviderError(null, EventType.AbsolutePosition, new NoProviderFoundError())
+                ];
             }
 
             if (canUse(GnssWifiPdrProvider, [PdrProvider])) {
                 return GnssWifiPdrProvider;
             }
 
-
             if (canUse(PoseProvider)) {
                 return PoseProvider;
             }
@@ -95,9 +113,22 @@ class PositioningHandler {
                 && 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

@@ -10,6 +10,8 @@ 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;
 
@@ -53,7 +55,7 @@ describe('PositioningHandler#findProvider', () => {
     it('Inclination Desktop', () => {
         config(CHROME_DESKTOP_USER_AGENT);
         const provider = PositioningHandler.findProvider([EventType.Inclination]);
-        expect(provider).to.be.null;
+        expect(provider[0]).to.be.instanceOf(ProviderError);
     });
 
     it('Inclination Mobile', () => {
@@ -65,7 +67,7 @@ describe('PositioningHandler#findProvider', () => {
     it('Pose Desktop', () => {
         config(CHROME_DESKTOP_USER_AGENT);
         const provider = PositioningHandler.findProvider([EventType.AbsolutePosition, EventType.AbsoluteAttitude]);
-        expect(provider).to.be.null;
+        expect(provider[0]).to.be.instanceOf(ProviderError);
     });
 
     it('Pose without PDR Desktop', () => {
@@ -74,7 +76,7 @@ describe('PositioningHandler#findProvider', () => {
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
             { ignoreProviders: [PdrProvider] }
         );
-        expect(provider).to.be.null;
+        expect(provider[0]).to.be.instanceOf(ProviderError);
     });
 
     it('Pose without ArCore Desktop', () => {
@@ -83,13 +85,13 @@ describe('PositioningHandler#findProvider', () => {
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
             { ignoreProviders: [ArCoreProvider] }
         );
-        expect(provider).to.be.null;
+        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).to.be.null;
+        expect(provider[0]).to.be.instanceOf(ProviderError);
     });
 
     it('Pose with optional attitude without PDR Desktop', () => {
@@ -97,7 +99,7 @@ describe('PositioningHandler#findProvider', () => {
         const provider = PositioningHandler.findProvider(
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
             {
-                ignoreProviders: [PdrProvider],
+                ignoreProviders: [ProvidersName.Pdr],
                 optionalEvents: [EventType.AbsoluteAttitude]
             }
         );
@@ -109,7 +111,7 @@ describe('PositioningHandler#findProvider', () => {
         const provider = PositioningHandler.findProvider(
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
             {
-                ignoreProviders: [ArCoreProvider],
+                ignoreProviders: [ProvidersName.ArCore],
                 optionalEvents: [EventType.AbsoluteAttitude]
             }
         );
@@ -121,7 +123,7 @@ describe('PositioningHandler#findProvider', () => {
         const provider = PositioningHandler.findProvider(
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
             {
-                ignoreProviders: [PdrProvider, ArCoreProvider],
+                ignoreProviders: [ProvidersName.Pdr, ProvidersName.ArCore],
                 optionalEvents: [EventType.AbsoluteAttitude]
             }
         );
@@ -138,7 +140,7 @@ describe('PositioningHandler#findProvider', () => {
         config(CHROME_ANDROID_USER_AGENT);
         const provider = PositioningHandler.findProvider(
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
-            { ignoreProviders: [PdrProvider] }
+            { ignoreProviders: [ProvidersName.Pdr] }
         );
         expect(provider).to.be.equals(PoseProvider);
     });
@@ -147,7 +149,7 @@ describe('PositioningHandler#findProvider', () => {
         config(CHROME_ANDROID_USER_AGENT);
         const provider = PositioningHandler.findProvider(
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
-            { ignoreProviders: [ArCoreProvider] }
+            { ignoreProviders: [ProvidersName.ArCore] }
         );
         expect(provider).to.be.equals(GnssWifiPdrProvider);
     });
@@ -156,7 +158,7 @@ describe('PositioningHandler#findProvider', () => {
         config(CHROME_ANDROID_USER_AGENT);
         const provider = PositioningHandler.findProvider(
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
-            { ignoreProviders: [PdrProvider, ArCoreProvider] }
+            { ignoreProviders: [ProvidersName.Pdr, ProvidersName.ArCore] }
         );
         expect(provider).to.be.equals(PoseProvider);
     });
@@ -185,7 +187,7 @@ describe('PositioningHandler#findProvider', () => {
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
             {
                 waitInputPosition: true,
-                ignoreProviders: [ArCoreProvider]
+                ignoreProviders: [ProvidersName.ArCore]
             }
         );
         expect(provider).to.be.equals(PdrProvider);
@@ -197,10 +199,11 @@ describe('PositioningHandler#findProvider', () => {
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
             {
                 waitInputPosition: true,
-                ignoreProviders: [PdrProvider]
+                ignoreProviders: [ProvidersName.Pdr]
             }
         );
-        expect(provider).to.be.null;
+        expect(provider[0]).to.be.instanceOf(ProviderError);
+        expect(provider[1]).to.be.instanceOf(ProviderError);
     });
 
     it('Pose with waitInputPosition without ArCore Mobile Native', () => {
@@ -209,7 +212,7 @@ describe('PositioningHandler#findProvider', () => {
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
             {
                 waitInputPosition: true,
-                ignoreProviders: [ArCoreProvider]
+                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,7 +20,7 @@ const ProviderOptions = {
 
     /**
      * Providers listed here will not be used by PositioningHandler
-     * List of {@link Provider}
+     * List of {@link Provider#name}
      */
     ignoreProviders: [],
 
@@ -31,4 +31,4 @@ const ProviderOptions = {
     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,7 +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, EventType
+    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
+};