@wemap/positioning 2.3.6 → 2.3.8

package/src/providers/Provider.js

@@ -3,9 +3,10 @@ import noop from 'lodash.noop';
 import EventType from '../events/EventType';
 import ProviderEvent from '../events/ProviderEvent';
 import Logger from '@wemap/logger';
-import ProviderError from '../events/ProviderError';
 import ProvidersLogger from './ProvidersLogger';
-import MissingNativeInterfaceError from '../errors/MissingNativeInterfaceError';
+import Availability from '../events/Availability';
+import PositioningOptions from '../PositioningOptions';
+import ContainsIgnoredProviderError from '../errors/ContainsIgnoredProviderError';
 
 let uniqueId = 1;
 
@@ -16,10 +17,14 @@ let uniqueId = 1;
 class Provider {
 
     static DEFAULT_NAME = 'Unknown';
-    static DEFAULT_OPTIONS = {
-        stopOnError: true,
-        checkAvailabilityOnStart: true
-    };
+    static DEFAULT_OPTIONS = Object.assign(
+        {},
+        PositioningOptions,
+        {
+            stopOnError: true,
+            checkAvailabilityOnStart: true
+        }
+    );
 
     static State = {
         STARTING: 0,
@@ -43,7 +48,7 @@ class Provider {
     constructor(onEvent, onError, options) {
         this.onEvent = onEvent || noop;
         this.onError = onError || noop;
-        this.options = Object.assign(this.constructor.DEFAULT_OPTIONS, options);
+        this.options = Object.assign({}, Provider.DEFAULT_OPTIONS, PositioningOptions, options);
         this.id = uniqueId++;
         ProvidersLogger.addEvent(this, 'constructor');
     }
@@ -68,21 +73,47 @@ class Provider {
     }
 
     /**
-     * @override
+     * //TODO
      */
-    static checkAvailabilityErrors() {
-        return this.requiredProviders.reduce(
-            (acc, val) => acc.concat(val.checkAvailabilityErrors()), []
-        );
+    static checkAvailability(options) {
+
+        if (this.containsIgnoredProviders(options)) {
+            return Availability.no(new ContainsIgnoredProviderError());
+        }
+
+        return this
+            .getRequiredProviders(options)
+            .reduce((acc, val) =>
+                Availability.merge(acc, val.checkAvailability(options)), Availability.yes()
+            );
     }
 
     /**
      * Return the list of required providers
      */
-    static get requiredProviders() {
+    static getRequiredProviders() {
         return [];
     }
 
+    static containsIgnoredProviders(options) {
+        return this
+            .getRequiredProvidersRecursively(options)
+            .some(elem => options.ignoreProviders.includes(elem.name));
+    }
+
+
+    /**
+     * Return the list of required providers
+     */
+    static getRequiredProvidersRecursively(options) {
+        if (this.getRequiredProviders(options).length === 0) {
+            return [this];
+        }
+        return this.getRequiredProviders().reduce(
+            (acc, val) => acc.concat(val.getRequiredProvidersRecursively(options)), [this]
+        );
+    }
+
     /**
      * Start the Provider
      * @public
@@ -96,9 +127,9 @@ class Provider {
         this.state = Provider.State.STARTING;
 
         if (this.options.checkAvailabilityOnStart) {
-            const availabilityErrors = this.constructor.checkAvailabilityErrors();
-            if (availabilityErrors.length !== 0) {
-                this.notifyError(...availabilityErrors);
+            const availibility = this.constructor.checkAvailability(this.options);
+            if (!availibility.isSupported) {
+                this.notifyError(availibility.reason);
                 return;
             }
         }
@@ -152,10 +183,10 @@ class Provider {
 
     /**
      * Notify the subscriber defined in {@link constructor}
-     * @param {ProviderError[]} errors The error raised
+     * @param {Error[]} errors The error raised
      */
-    notifyError(...errors) {
-        this.onError(errors);
+    notifyError(error) {
+        this.onError(error);
         if (this.options.stopOnError && this.state === Provider.State.STARTED) {
             this.stop();
         }
@@ -187,33 +218,6 @@ class Provider {
         return this.constructor.createEvent(dataType, data, timestamp);
     }
 
-    /**
-     * Create an event error from current provider
-     * @param {EventType} dataType type of ProviderError
-     * @param {ProviderError} error error raised by the problem exported to ProviderError
-     * @param {Number} timestamp event timestamp
-     * @protected
-     */
-    static createError(dataType, error, timestamp) {
-        const event = new ProviderError(this.name, dataType, error);
-        if (timestamp) {
-            event.timestamp = timestamp;
-        }
-        return event;
-    }
-
-    /**
-     * Create an event error from current provider
-     * @param {EventType} dataType type of ProviderError
-     * @param {ProviderError} error error raised by the problem exported to ProviderError
-     * @param {Number} timestamp event timestamp
-     * @protected
-     */
-    createError(dataType, error, timestamp) {
-        return this.constructor.createError(dataType, error, timestamp);
-    }
-
-
     static hasNativeInterface() {
         return Boolean(Provider.nativeInterface);
     }
@@ -221,10 +225,6 @@ class Provider {
     static get nativeInterface() {
         return global.WemapProvidersAndroid;
     }
-
-    static createMissingNativeInterfaceError(dataType) {
-        return this.createError(dataType, new MissingNativeInterfaceError());
-    }
 }
 
 export default Provider;

package/src/providers/attitude/AbsoluteAttitudeProvider.js

@@ -16,6 +16,7 @@ import AskImuOnDesktopError from '../../errors/AskImuOnDesktopError';
 import MissingMagnetometerError from '../../errors/MissingMagnetometerError';
 import MissingSensorError from '../../errors/MissingSensorError';
 import Logger from '@wemap/logger';
+import Availability from '../../events/Availability';
 
 
 /**
@@ -54,18 +55,13 @@ class AbsoluteAttitudeProvider extends Provider {
     /**
      * @override
      */
-    static checkAvailabilityErrors() {
-
-        if (BrowserUtils.isMobile) {
-            return [];
-        }
-
-        return [
-            AbsoluteAttitudeProvider.createError(
-                EventType.AbsoluteAttitude,
-                new AskImuOnDesktopError()
-            )
-        ];
+    static checkAvailability(options) {
+        return Availability.merge(
+            super.checkAvailability(options),
+            BrowserUtils.isMobile
+                ? Availability.yes()
+                : Availability.no(new AskImuOnDesktopError())
+        );
     }
 
     /**
@@ -108,11 +104,7 @@ class AbsoluteAttitudeProvider extends Provider {
         const timestamp = e.timeStamp / 1e3;
 
         if (!e.alpha || !e.beta || !e.gamma) {
-            super.notifyError(this.createError(
-                EventType.AbsoluteAttitude,
-                new MissingSensorError().from('deviceorientationabsolute'),
-                timestamp
-            ));
+            this.notifyError(new MissingSensorError().from('deviceorientationabsolute'));
             return;
         }
         this.onDeviceOrientationCommonEvent(timestamp,
@@ -125,20 +117,12 @@ class AbsoluteAttitudeProvider extends Provider {
         const timestamp = e.timeStamp / 1e3;
 
         if (!e.beta || !e.gamma) {
-            super.notifyError(this.createError(
-                EventType.AbsoluteAttitude,
-                new MissingSensorError().from('deviceorientation'),
-                timestamp
-            ));
+            this.notifyError(new MissingSensorError().from('deviceorientation'));
             return;
         }
 
         if (!e.webkitCompassHeading) {
-            super.notifyError(this.createError(
-                EventType.AbsoluteAttitude,
-                new MissingMagnetometerError().from('deviceorientation'),
-                timestamp
-            ));
+            super.notifyError(new MissingMagnetometerError().from('deviceorientation'));
             return;
         }
 

package/src/providers/attitude/RelativeAttitudeProvider.js

@@ -4,7 +4,6 @@ import EkfAttitude from './EkfAttitude';
 import ImuProvider from '../others/ImuProvider';
 import { Attitude } from '@wemap/geo';
 import { deg2rad } from '@wemap/maths';
-import ProviderError from '../../events/ProviderError';
 
 
 /**
@@ -26,7 +25,7 @@ class RelativeAttitudeProvider extends Provider {
         this.relativeOffsetQuaternion = [1, 0, 0, 0];
 
         this.imuProvider = new ImuProvider(this.onImuEvent,
-            this.onImuError, { require: [EventType.Acceleration, EventType.AngularRate] });
+            onError, { require: [EventType.Acceleration, EventType.AngularRate] });
 
     }
 
@@ -47,7 +46,7 @@ class RelativeAttitudeProvider extends Provider {
     /**
      * @override
      */
-    static get requiredProviders() {
+    static getRequiredProviders() {
         return [ImuProvider];
     }
 
@@ -110,20 +109,6 @@ class RelativeAttitudeProvider extends Provider {
 
         this.ekfAttitude.setOrientationYaw(heading);
     }
-
-    onImuError = imuErrors => {
-        this.notifyError(...ProviderError.modifyArrayDataType(imuErrors, EventType.RelativeAttitude));
-    }
-
-    /**
-     * @override
-     */
-    static checkAvailabilityErrors() {
-        return ProviderError.modifyArrayDataType(
-            super.checkAvailabilityErrors(),
-            EventType.RelativeAttitude
-        );
-    }
 }
 
 export default RelativeAttitudeProvider;

package/src/providers/others/ImuProvider.js

@@ -9,6 +9,7 @@ import EventType from '../../events/EventType';
 import MissingAccelerometerError from '../../errors/MissingAccelerometerError';
 import MissingGyroscopeError from '../../errors/MissingGyroscopeError';
 import AskImuOnDesktopError from '../../errors/AskImuOnDesktopError';
+import Availability from '../../events/Availability';
 
 /**
  * Imu (Inertial Measurement Unit) provider retrieve acceleration data
@@ -78,22 +79,13 @@ class ImuProvider extends Provider {
     /**
      * @override
      */
-    static checkAvailabilityErrors() {
-
-        if (BrowserUtils.isMobile) {
-            return [];
-        }
-
-        return [
-            ImuProvider.createError(
-                EventType.AngularRate,
-                new AskImuOnDesktopError()
-            ),
-            ImuProvider.createError(
-                EventType.Acceleration,
-                new AskImuOnDesktopError()
-            )
-        ];
+    static checkAvailability(options) {
+        return Availability.merge(
+            super.checkAvailability(options),
+            BrowserUtils.isMobile
+                ? Availability.yes()
+                : Availability.no(new AskImuOnDesktopError())
+        );
     }
 
     /**
@@ -142,11 +134,7 @@ class ImuProvider extends Provider {
             }
 
             if (!acc) {
-                super.notifyError(this.createError(
-                    EventType.AngularRate,
-                    new MissingAccelerometerError().from('devicemotion'),
-                    timestamp
-                ));
+                this.notifyError(new MissingAccelerometerError().from('devicemotion'));
                 return;
             }
 
@@ -168,9 +156,7 @@ class ImuProvider extends Provider {
             }
 
             if (!gyr) {
-                super.notifyError(this.createError(EventType.AngularRate,
-                    new MissingGyroscopeError().from('devicemotion'),
-                    timestamp));
+                this.notifyError(new MissingGyroscopeError().from('devicemotion'));
                 return;
             }
 
@@ -178,7 +164,7 @@ class ImuProvider extends Provider {
         }
 
         if (events.length !== 0) {
-            super.notify(...events);
+            this.notify(...events);
         }
     }
 

package/src/providers/others/InclinationProvider.js

@@ -1,7 +1,6 @@
 import Provider from '../Provider';
 import EventType from '../../events/EventType';
 import ImuProvider from './ImuProvider';
-import ProviderError from '../../events/ProviderError';
 
 /**
  * Inclination provider gives the inclination of the device using Imu Sensor
@@ -19,7 +18,7 @@ class InclinationProvider extends Provider {
 
         this.imuProvider = new ImuProvider(
             this.onImuEvent,
-            this.onImuError,
+            onError,
             { require: [EventType.Acceleration] }
         );
     }
@@ -41,7 +40,7 @@ class InclinationProvider extends Provider {
     /**
      * @override
      */
-    static get requiredProviders() {
+    static getRequiredProviders() {
         return [ImuProvider];
     }
 
@@ -88,20 +87,6 @@ class InclinationProvider extends Provider {
 
         this.notify(this.createEvent(EventType.Inclination, inclination));
     };
-
-    onImuError = imuErrors => {
-        this.notifyError(...ProviderError.modifyArrayDataType(imuErrors, EventType.Inclination));
-    }
-
-    /**
-     * @override
-     */
-    static checkAvailabilityErrors() {
-        return ProviderError.modifyArrayDataType(
-            super.checkAvailabilityErrors(),
-            EventType.Inclination
-        );
-    }
 }
 
 export default InclinationProvider;

package/src/providers/pose/ArCoreAbsoluteProvider.js

@@ -8,7 +8,6 @@ import {
     Quaternion, Vector3
 } from '@wemap/maths';
 import ImuProvider from '../others/ImuProvider';
-import ProviderError from '../../events/ProviderError';
 
 /**
  * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
@@ -24,13 +23,13 @@ class ArCoreAbsoluteProvider extends Provider {
 
         this.arCoreProvider = new ArCoreProvider(
             e => this.onArCoreEvent(e),
-            e => this.onArCoreError(e),
+            onError,
             options);
 
         this.imuProvider = new ImuProvider(
             this.onImuEvent,
-            this.onImuError,
-            Object.assign(options || {}, { require: [EventType.AngularRate] })
+            onError,
+            Object.assign({}, options || {}, { require: [EventType.AngularRate] })
         );
     }
 
@@ -51,7 +50,7 @@ class ArCoreAbsoluteProvider extends Provider {
     /**
      * Return the list of required providers
      */
-    static get requiredProviders() {
+    static getRequiredProviders() {
         return [ArCoreProvider, ImuProvider];
     }
 
@@ -71,15 +70,6 @@ class ArCoreAbsoluteProvider extends Provider {
         this.imuProvider.stop();
     }
 
-    /**
-     * @override
-     */
-    static checkAvailabilityErrors() {
-        return ArCoreProvider.checkAvailabilityErrors().concat(
-            ImuProvider.checkAvailabilityErrors()
-        );
-    }
-
     onArCoreEvent = events => {
         events.forEach(event => {
             if (event.dataType === EventType.RelativeAttitude) {
@@ -145,26 +135,10 @@ class ArCoreAbsoluteProvider extends Provider {
         return pos1[0] === pos2[0] && pos1[1] === pos2[1] && pos1[2] === pos2[2];
     }
 
-    onArCoreError = arCoreErrors => {
-        this.notifyError(...(
-            ProviderError.modifyArrayDataType(arCoreErrors, EventType.AbsoluteAttitude).concat(
-                ProviderError.modifyArrayDataType(arCoreErrors, EventType.AbsolutePosition)
-            ))
-        );
-    };
-
     onImuEvent = events => {
         this.angularRate = events[0].data;
     }
 
-    onImuError = imuErrors => {
-        this.notifyError(...(
-            ProviderError.modifyArrayDataType(imuErrors, EventType.AbsoluteAttitude).concat(
-                ProviderError.modifyArrayDataType(imuErrors, EventType.AbsolutePosition)
-            ))
-        );
-    }
-
     setHeading(heading) {
 
         if (!this.relativeAttitude) {

package/src/providers/pose/ArCoreProvider.js

@@ -4,6 +4,7 @@ import Provider from '../Provider';
 import EventType from '../../events/EventType';
 import MissingArCoreError from '../../errors/MissingArCoreError';
 import MissingNativeInterfaceError from '../../errors/MissingNativeInterfaceError';
+import Availability from '../../events/Availability';
 
 /**
  * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
@@ -28,7 +29,7 @@ class ArCoreProvider extends Provider {
     /**
      * Return the list of required providers
      */
-    static get requiredProviders() {
+    static getRequiredProviders() {
         return [];
     }
 
@@ -92,23 +93,25 @@ class ArCoreProvider extends Provider {
     /**
      * @override
      */
-    static checkAvailabilityErrors() {
+    static checkAvailability(options) {
+
+        const supAvailability = super.checkAvailability(options);
+        if (!supAvailability.isSupported) {
+            return supAvailability;
+        }
 
         try {
             const nativeProvider = this.nativeProvider;
 
             if (!nativeProvider.checkAvailability()) {
-                throw new MissingArCoreError();
+                return Availability.no(new MissingArCoreError());
             }
 
         } catch (e) {
-            return [
-                this.createError(EventType.RelativeAttitude, e),
-                this.createError(EventType.RelativePosition, e)
-            ];
+            return Availability.no(e);
         }
 
-        return [];
+        return Availability.yes();
     }
 }
 

package/src/providers/pose/GnssWifiPdrProvider.js

@@ -8,7 +8,6 @@ import GnssWifiProvider from '../position/GnssWifiProvider';
 import EventType from '../../events/EventType';
 import AbsoluteAttitudeProvider from '../attitude/AbsoluteAttitudeProvider';
 import Constants from '../Constants';
-import ProviderError from '../../events/ProviderError';
 
 const GPF_ACCURACY = 25;
 const GPF_DISTANCE = 25;
@@ -24,11 +23,11 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
     constructor(onEvent, onError, options) {
         super(onEvent, onError, options);
 
-        this.pdrProvider = new PdrProvider(e => this.onPdrEvent(e), e => this.onProviderError(e), options);
-        this.gnssWifiProvider = new GnssWifiProvider(e => this.onGnssWifiEvent(e), e => this.onProviderError(e), options);
+        this.pdrProvider = new PdrProvider(e => this.onPdrEvent(e), onError, options);
+        this.gnssWifiProvider = new GnssWifiProvider(e => this.onGnssWifiEvent(e), onError, options);
         this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(
             e => this.onAbsoluteAttitudeEvent(e),
-            e => this.onProviderError(e),
+            onError,
             options
         );
 
@@ -55,7 +54,7 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
     /**
      * @override
      */
-    static get requiredProviders() {
+    static getRequiredProviders() {
         return [PdrProvider, GnssWifiProvider, AbsoluteAttitudeProvider];
     }
 
@@ -158,27 +157,6 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
         this.lastAttitude = attitude;
     }
 
-    onProviderError(errors) {
-        this.notifyError(...ProviderError.modifyArrayDataType(errors, EventType.AbsoluteAttitude));
-        this.notifyError(...ProviderError.modifyArrayDataType(errors, EventType.AbsolutePosition));
-    }
-
-    /**
-     * @override
-     */
-    static checkAvailabilityErrors() {
-        const errors = super.checkAvailabilityErrors();
-        return ProviderError.modifyArrayDataType(
-            errors,
-            EventType.AbsolutePosition
-        ).concat(
-            ProviderError.modifyArrayDataType(
-                errors,
-                EventType.AbsoluteAttitude
-            )
-        );
-    }
-
     /**
      * MapMatching
      */

package/src/providers/pose/PoseProvider.js

@@ -3,7 +3,6 @@ import EventType from '../../events/EventType';
 
 import GnssWifiProvider from '../position/GnssWifiProvider';
 import AbsoluteAttitudeProvider from '../attitude/AbsoluteAttitudeProvider';
-import ProviderError from '../../events/ProviderError';
 
 /**
  * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
@@ -17,11 +16,11 @@ class PoseProvider extends Provider {
     constructor(onEvent, onError, options) {
         super(onEvent, onError, options);
 
-        this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(onEvent, e => this.onAbsoluteAttitudeError(e));
+        this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(onEvent, onError);
         this.gnssWifiProvider = new GnssWifiProvider((events) => {
             this.absoluteAttitudeProvider.setPosition(events[0].data);
             onEvent(events);
-        }, e => this.onGnssWifiError(e));
+        }, onError);
     }
 
     /**
@@ -41,7 +40,7 @@ class PoseProvider extends Provider {
     /**
      * Return the list of required providers
      */
-    static get requiredProviders() {
+    static getRequiredProviders() {
         return [AbsoluteAttitudeProvider, GnssWifiProvider];
     }
 
@@ -60,31 +59,6 @@ class PoseProvider extends Provider {
         this.absoluteAttitudeProvider.stop();
         this.gnssWifiProvider.stop();
     }
-
-    onAbsoluteAttitudeError(errors) {
-        this.notifyError(...ProviderError.modifyArrayDataType(errors, EventType.AbsoluteAttitude));
-    }
-
-    onGnssWifiError(errors) {
-        this.notifyError(...ProviderError.modifyArrayDataType(errors, EventType.AbsolutePosition));
-    }
-
-    /**
-     * @override
-     */
-    static checkAvailabilityErrors() {
-        const errorsAttitude = AbsoluteAttitudeProvider.checkAvailabilityErrors();
-        const errorsGnssWifi = GnssWifiProvider.checkAvailabilityErrors();
-        return ProviderError.modifyArrayDataType(
-            errorsGnssWifi,
-            EventType.AbsolutePosition
-        ).concat(
-            ProviderError.modifyArrayDataType(
-                errorsAttitude,
-                EventType.AbsoluteAttitude
-            )
-        );
-    }
 }
 
 export default PoseProvider;