@wemap/positioning 2.3.6 → 2.3.8

package/package.json

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

package/src/PositioningHandler.js

@@ -7,10 +7,9 @@ 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';
+import Availability from './events/Availability';
 
 /**
  * @private
@@ -39,17 +38,17 @@ class PositioningHandler {
 
         this.options = Object.assign({}, PositioningOptions, options);
 
-        const providerClass = PositioningHandler.findProvider(eventsType, this.options);
-        if (Array.isArray(providerClass)) {
-            onError(providerClass);
+        try {
+            const providerClass = PositioningHandler.findProvider(eventsType, this.options);
+            const provider = Reflect.construct(providerClass, [onEvent, onError, this.options]);
+            this.providerInstances[provider.id] = provider;
+            provider.start();
+
+            return provider.id;
+        } catch (e) {
+            onError(e);
             return null;
         }
-        const provider = Reflect.construct(providerClass, [onEvent, onError, this.options]);
-        this.providerInstances[provider.id] = provider;
-        provider.start();
-
-        return provider.id;
-
     }
 
     /**
@@ -59,14 +58,10 @@ class PositioningHandler {
 
         const options = Object.assign({}, PositioningOptions, _options);
 
-        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;
+        let availability = Availability.yes();
+        const canUse = (provider) => {
+            availability = provider.checkAvailability(options);
+            return availability.isSupported;
         };
 
         const wantInclination = eventsType.length === 1
@@ -76,10 +71,7 @@ class PositioningHandler {
             if (canUse(InclinationProvider)) {
                 return InclinationProvider;
             }
-            if (errors.length !== 0) {
-                return errors;
-            }
-            return [new ProviderError(null, EventType.Inclination, new NoProviderFoundError())];
+            throw availability.reason;
         }
 
         const wantPoseProvider = [EventType.AbsolutePosition, EventType.AbsoluteAttitude]
@@ -88,20 +80,17 @@ class PositioningHandler {
         if (wantPoseProvider) {
 
             if (options.waitInputPosition) {
-                if (canUse(ArCoreAbsoluteProvider, [ArCoreProvider])) {
+                if (canUse(ArCoreAbsoluteProvider)) {
                     return ArCoreAbsoluteProvider;
                 }
                 if (canUse(PdrProvider)) {
                     return PdrProvider;
                 }
 
-                return [
-                    new ProviderError(null, EventType.AbsoluteAttitude, new NoProviderFoundError()),
-                    new ProviderError(null, EventType.AbsolutePosition, new NoProviderFoundError())
-                ];
+                throw availability.reason;
             }
 
-            if (canUse(GnssWifiPdrProvider, [PdrProvider])) {
+            if (canUse(GnssWifiPdrProvider)) {
                 return GnssWifiPdrProvider;
             }
 
@@ -109,26 +98,18 @@ class PositioningHandler {
                 return PoseProvider;
             }
 
-            if (options.optionalEvents.includes(EventType.AbsoluteAttitude)
-                && canUse(GnssWifiProvider)) {
-                return GnssWifiProvider;
-            }
-
-            if (errors.length !== 0) {
-                return errors;
+            if (!options.optionalEvents.includes(EventType.AbsoluteAttitude)) {
+                throw availability.reason;
             }
 
-            if (options.optionalEvents.includes(EventType.AbsoluteAttitude)) {
-                return [new ProviderError(null, EventType.AbsolutePosition, new NoProviderFoundError())];
+            if (canUse(GnssWifiProvider)) {
+                return GnssWifiProvider;
             }
 
-            return [
-                new ProviderError(null, EventType.AbsoluteAttitude, new NoProviderFoundError()),
-                new ProviderError(null, EventType.AbsolutePosition, new NoProviderFoundError())
-            ];
+            throw availability.reason;
         }
 
-        return [];
+        throw new NoProviderFoundError();
     }
 
     /**
@@ -149,6 +130,7 @@ class PositioningHandler {
         }
         if (!provider.setPosition) {
             Logger.warn('Cannot set position to ' + provider.constructor.name);
+            return;
         }
         provider.setPosition(position);
     }
@@ -163,6 +145,7 @@ class PositioningHandler {
         }
         if (!provider.setHeading) {
             Logger.warn('Cannot set heading to ' + provider.constructor.name);
+            return;
         }
         provider.setHeading(heading);
     }
@@ -177,10 +160,42 @@ class PositioningHandler {
         }
         if (!provider.setItinerary) {
             Logger.warn('Cannot set itinerary to ' + provider.constructor.name);
+            return;
         }
         provider.setItinerary(itinerary);
     }
 
+    /**
+     * @public
+     */
+    setNetwork(id, network) {
+        const provider = this.providerInstances[id];
+        if (!provider) {
+            throw new Error('Unknown provider');
+        }
+        if (!provider.setNetwork) {
+            Logger.warn('Cannot set network to ' + provider.constructor.name);
+            return;
+        }
+        provider.setNetwork(network);
+    }
+
+
+    /**
+     * @public
+     */
+    getItineraryInfo(id) {
+        const provider = this.providerInstances[id];
+        if (!provider) {
+            throw new Error('Unknown provider');
+        }
+        if (!provider.getItineraryInfo) {
+            Logger.warn('Cannot getItineraryInfo from ' + provider.constructor.name);
+            return null;
+        }
+        return provider.getItineraryInfo();
+    }
+
 }
 
 export default PositioningHandler;

package/src/PositioningHandler.spec.js

@@ -10,8 +10,9 @@ 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';
+import AskImuOnDesktopError from './errors/AskImuOnDesktopError';
+import ContainsIgnoredProviderError from './errors/ContainsIgnoredProviderError';
 
 const expect = chai.expect;
 
@@ -30,7 +31,7 @@ function fakeNativeInterface(arcore = true) {
 
 function fakeGeolocation() {
     navigator.__defineGetter__('geolocation', () => {
-        return {watchPosition: () => {}};
+        return { watchPosition: () => { } };
     });
 }
 
@@ -54,8 +55,10 @@ describe('PositioningHandler#findProvider', () => {
 
     it('Inclination Desktop', () => {
         config(CHROME_DESKTOP_USER_AGENT);
-        const provider = PositioningHandler.findProvider([EventType.Inclination]);
-        expect(provider[0]).to.be.instanceOf(ProviderError);
+
+        expect(
+            () => PositioningHandler.findProvider([EventType.Inclination])
+        ).to.throw(AskImuOnDesktopError);
     });
 
     it('Inclination Mobile', () => {
@@ -66,32 +69,36 @@ describe('PositioningHandler#findProvider', () => {
 
     it('Pose Desktop', () => {
         config(CHROME_DESKTOP_USER_AGENT);
-        const provider = PositioningHandler.findProvider([EventType.AbsolutePosition, EventType.AbsoluteAttitude]);
-        expect(provider[0]).to.be.instanceOf(ProviderError);
+        expect(
+            () => PositioningHandler.findProvider([EventType.AbsolutePosition, EventType.AbsoluteAttitude])
+        ).to.throw(AskImuOnDesktopError);
     });
 
     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);
+        expect(
+            () => PositioningHandler.findProvider(
+                [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+                { ignoreProviders: [PdrProvider] }
+            )
+        ).to.throw(AskImuOnDesktopError);
     });
 
     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);
+        expect(
+            () => PositioningHandler.findProvider(
+                [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+                { ignoreProviders: [ArCoreProvider] }
+            )
+        ).to.throw(AskImuOnDesktopError);
     });
 
     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);
+        expect(
+            () => PositioningHandler.findProvider([EventType.AbsolutePosition, EventType.AbsoluteAttitude])
+        ).to.throw(AskImuOnDesktopError);
     });
 
     it('Pose with optional attitude without PDR Desktop', () => {
@@ -195,15 +202,15 @@ describe('PositioningHandler#findProvider', () => {
 
     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);
+        expect(
+            () => PositioningHandler.findProvider(
+                [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+                {
+                    waitInputPosition: true,
+                    ignoreProviders: [ProvidersName.Pdr]
+                }
+            )
+        ).to.throw(ContainsIgnoredProviderError);
     });
 
     it('Pose with waitInputPosition without ArCore Mobile Native', () => {
@@ -218,4 +225,17 @@ describe('PositioningHandler#findProvider', () => {
         expect(provider).to.be.equals(PdrProvider);
     });
 
+    it('Pose without GnssWifi Desktop', () => {
+        config(CHROME_DESKTOP_USER_AGENT, false);
+        expect(
+            () => PositioningHandler.findProvider(
+                [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+                {
+                    ignoreProviders: [ProvidersName.GnssWifi],
+                    optionalEvents: [EventType.AbsoluteAttitude]
+                }
+            )
+        ).to.throw(ContainsIgnoredProviderError);
+    });
+
 });

package/src/components/AbsoluteAttitudeComponent.jsx

@@ -50,12 +50,8 @@ class AbsoluteAttitudeComponent extends React.Component {
         });
     };
 
-    onError = events => {
-        events.forEach(event => {
-            if (event.dataType === EventType.AbsoluteAttitude) {
-                this.setState({ attitudeBrowser: event.error });
-            }
-        });
+    onError = error => {
+        this.setState({ attitudeBrowser: error });
     }
 
     render() {

package/src/components/ArCoreAbsoluteComponent.jsx

@@ -61,18 +61,11 @@ class ArCoreAbsoluteComponent extends React.Component {
         }
     };
 
-    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;
-            }
+    onError = error => {
+        this.setState({
+            position: error,
+            attitude: error
         });
-        if (!isEmpty(newState)) {
-            this.setState(newState);
-        }
     }
 
     render() {

package/src/components/ArCoreComponent.jsx

@@ -40,18 +40,11 @@ class ArCoreComponent extends React.Component {
         }
     };
 
-    onError = events => {
-        const newState = {};
-        events.forEach(event => {
-            if (event.dataType === EventType.RelativePosition) {
-                newState.position = event.error;
-            } else if (event.dataType === EventType.RelativeAttitude) {
-                newState.attitude = event.error;
-            }
+    onError = error => {
+        this.setState({
+            position: error,
+            attitude: error
         });
-        if (!isEmpty(newState)) {
-            this.setState(newState);
-        }
     }
 
     render() {

package/src/components/GnssWifiComponent.jsx

@@ -35,12 +35,8 @@ class GnssWifiComponent extends React.Component {
         }
     };
 
-    onError = events => {
-        events.forEach(event => {
-            if (event.dataType === EventType.AbsolutePosition) {
-                this.setState({ position: event.error });
-            }
-        });
+    onError = error => {
+        this.setState({ position: error });
     }
 
     render() {

package/src/components/GnssWifiPdrComponent.jsx

@@ -56,18 +56,11 @@ class GnssWifiPdrComponent extends React.Component {
         }
     };
 
-    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;
-            }
+    onError = error => {
+        this.setState({
+            position: error,
+            attitude: error
         });
-        if (!isEmpty(newState)) {
-            this.setState(newState);
-        }
     }
 
     render() {

package/src/components/ImuComponent.jsx

@@ -42,19 +42,11 @@ class ImuComponent extends React.Component {
         this.setState(newState);
     };
 
-    onError = events => {
-        const newState = {};
-
-        events.forEach(event => {
-            if (event.dataType === EventType.Acceleration) {
-                newState.acc = event.error;
-            }
-            if (event.dataType === EventType.AngularRate) {
-                newState.gyr = event.error;
-            }
+    onError = error => {
+        this.setState({
+            acc: error,
+            gyr: error
         });
-
-        this.setState(newState);
     }
 
     render() {

package/src/components/InclinationComponent.jsx

@@ -30,12 +30,8 @@ class InclinationComponent extends React.Component {
         });
     };
 
-    onError = events => {
-        events.forEach(event => {
-            if (event.dataType === EventType.Inclination) {
-                this.setState({ inclination: event.error });
-            }
-        });
+    onError = error => {
+        this.setState({ inclination: error });
     }
 
     render() {

package/src/components/PdrComponent.jsx

@@ -27,13 +27,13 @@ class PdrComponent extends React.Component {
         this.state = { position: null };
 
         this.pdrProvider = new PdrProvider(this.onEvent, this.onError);
+        this.pdrProvider.enableMapMatching(ITINERARY);
     }
 
 
     componentDidMount() {
         this.pdrProvider.setPosition(INITIAL_POSITION);
         this.pdrProvider.setHeading(INITIAL_HEADING);
-        this.pdrProvider.enableMapMatching(ITINERARY);
         this.pdrProvider.start();
     }
 
@@ -59,18 +59,11 @@ class PdrComponent extends React.Component {
         }
     };
 
-    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;
-            }
+    onError = error => {
+        this.setState({
+            position: error,
+            attitude: error
         });
-        if (!isEmpty(newState)) {
-            this.setState(newState);
-        }
     }
 
     render() {

package/src/components/PoseComponent.jsx

@@ -45,18 +45,11 @@ class PoseComponent extends React.Component {
         }
     };
 
-    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;
-            }
+    onError = error => {
+        this.setState({
+            position: error,
+            attitude: error
         });
-        if (!isEmpty(newState)) {
-            this.setState(newState);
-        }
     }
 
     render() {

package/src/components/PositioningInclinationComponent.jsx

@@ -24,7 +24,7 @@ class PositioningInclinationComponent extends React.Component {
         this.id = this.props.positioningHandler.start(
             [EventType.Inclination],
             this.onEvents,
-            this.onErrors
+            this.onError
         );
     }
 
@@ -49,14 +49,11 @@ class PositioningInclinationComponent extends React.Component {
         }
     };
 
-    onErrors = events => {
-        const newState = { errored: true };
-        events.forEach(event => {
-            if (event.dataType === EventType.Inclination) {
-                newState.inclination = event.error;
-            }
+    onError = error => {
+        this.setState({
+            errorer: true,
+            inclination: error
         });
-        this.setState(newState);
     }
 
     render() {

package/src/components/PositioningPoseComponent.jsx

@@ -39,7 +39,7 @@ class PositioningPoseComponent extends React.Component {
         this.id = this.props.positioningHandler.start(
             [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
             this.onEvents,
-            this.onErrors,
+            this.onError,
             {
                 waitInputPosition: true,
                 useMapMatching: true
@@ -50,11 +50,10 @@ class PositioningPoseComponent extends React.Component {
             return;
         }
 
-        setTimeout(() => {
-            this.props.positioningHandler.setPosition(this.id, INITIAL_POSITION);
-            this.props.positioningHandler.setHeading(this.id, INITIAL_HEADING);
-            this.props.positioningHandler.setItinerary(this.id, ITINERARY);
-        }, 3000);
+        this.props.positioningHandler.setItinerary(this.id, ITINERARY);
+        this.props.positioningHandler.setNetwork(this.id, ITINERARY);
+        this.props.positioningHandler.setPosition(this.id, INITIAL_POSITION);
+        this.props.positioningHandler.setHeading(this.id, INITIAL_HEADING);
     }
 
 
@@ -85,16 +84,12 @@ class PositioningPoseComponent extends React.Component {
         }
     };
 
-    onErrors = events => {
-        const newState = { errored: true };
-        events.forEach(event => {
-            if (event.dataType === EventType.AbsolutePosition) {
-                newState.position = event.error;
-            } else if (event.dataType === EventType.AbsoluteAttitude) {
-                newState.attitude = event.error;
-            }
+    onError = error => {
+        this.setState({
+            position: error,
+            attitude: error,
+            errored: false
         });
-        this.setState(newState);
     }
 
     render() {

package/src/components/RelativeAttitudeComponent.jsx

@@ -15,6 +15,7 @@ class RelativeAttitudeComponent extends React.Component {
         };
 
         this.relativeAttitudeProvider = new RelativeAttitudeProvider(this.onEvent, this.onError);
+        this.setOffset(0);
     }
 
     componentDidMount() {
@@ -35,12 +36,8 @@ class RelativeAttitudeComponent extends React.Component {
         });
     };
 
-    onError = events => {
-        events.forEach(event => {
-            if (event.dataType === EventType.RelativeAttitude) {
-                this.setState({ attitude: event.error });
-            }
-        });
+    onError = error => {
+        this.setState({ attitude: error });
     }
 
     onDeviceOrientationEventListener = (e) => this.setState({ deviceorientation: e });

package/src/errors/ContainsIgnoredProviderError.js

@@ -0,0 +1,9 @@
+const DEFAULT_MESSAGE = 'Contains ignored provider';
+
+class ContainsIgnoredProviderError extends Error {
+    constructor(message) {
+        super(message || DEFAULT_MESSAGE);
+    }
+}
+
+export default ContainsIgnoredProviderError;

package/src/events/Availability.js

@@ -0,0 +1,30 @@
+class Availability {
+
+    isSupported = false;
+    reason = null;
+
+    static no(reason) {
+        const availability = new Availability();
+        availability.reason = reason;
+        availability.isSupported = false;
+        return availability;
+    }
+
+    static yes() {
+        const availability = new Availability();
+        availability.isSupported = true;
+        return availability;
+    }
+
+    static merge(...availabilities) {
+        for (let i = 0; i < availabilities.length; i++) {
+            const availability = availabilities[i];
+            if (!availability.isSupported) {
+                return availability;
+            }
+        }
+        return Availability.yes();
+    }
+}
+
+export default Availability;