@wemap/positioning 2.7.13 → 14.0.0-0

package/src/errors/MissingSensorError.js

@@ -1,14 +0,0 @@
-const DEFAULT_MESSAGE = 'Impossible to retrieve events, a sensor is missing';
-
-class MissingSensorError extends Error {
-    constructor(message) {
-        super(message || DEFAULT_MESSAGE);
-    }
-
-    from(fromMessage) {
-        this.message += ' from ' + fromMessage;
-        return this;
-    }
-}
-
-export default MissingSensorError;

package/src/errors/NoProviderFoundError.js

@@ -1,9 +0,0 @@
-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/events/Availability.js

@@ -1,30 +0,0 @@
-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;

package/src/events/EventType.js

@@ -1,22 +0,0 @@
-/**
- * Event data types handled by {@link ProviderEvent}
- */
-export default {
-    Unknown: 'UNKNOWN',
-    MagneticField: 'MAGNETIC_FIELD',
-    AngularRate: 'ANGULAR_RATE',
-    Acceleration: 'ACCELERATION',
-    Inclination: 'INCLINATION',
-    RelativeAttitude: 'RELATIVE_ATTITUDE',
-    AbsoluteAttitude: 'ABSOLUTE_ATTITUDE',
-    RelativePosition: 'RELATIVE_POSITION',
-    AbsolutePosition: 'ABSOLUTE_POSITION',
-    Pressure: 'PRESSURE',
-    BluetoothSignals: 'BLUETOOTH_SIGNALS',
-    WifiSignals: 'WIFI_SIGNALS',
-    ScanId: 'SCAN_ID',
-    Barcode: 'BARCODE',
-    ProjectionMatrix: 'PROJECTION_MATRIX',
-    Itinerary: 'ITINERARY',
-    Network: 'NETWORK'
-};

package/src/events/ProviderEvent.js

@@ -1,35 +0,0 @@
-import EventType from './EventType';
-
-/**
- * A provider event is an event which can be triggered by device sensors
- * or can be computed from raw providers.
- */
-class ProviderEvent {
-
-    timestamp = -1;
-    dataType = EventType.Unknown;
-    providerName = '';
-    isFromNative = false;
-    data = null;
-
-    /**
-     * Create a Provider Event with the minimum information
-     * @param {String} providerName the provider name
-     * @param {EventType} dataType the type of event
-     * @param {Object} data the event data
-     */
-    constructor(providerName, dataType, data) {
-        this.providerName = providerName;
-        this.dataType = dataType;
-        this.data = data;
-    }
-
-    clone() {
-        const evt = new ProviderEvent(this.providerName, this.dataType, this.data);
-        evt.timestamp = this.timestamp;
-        evt.isFromNative = this.isFromNative;
-        return evt;
-    }
-}
-
-export default ProviderEvent;

package/src/providers/Constants.js

@@ -1,5 +0,0 @@
-const Constants = {
-    DEFAULT_ALTITUDE: 1.6
-};
-
-export default Constants;

package/src/providers/Provider.js

@@ -1,247 +0,0 @@
-import noop from 'lodash.noop';
-
-import EventType from '../events/EventType';
-import ProviderEvent from '../events/ProviderEvent';
-import Logger from '@wemap/logger';
-import ProvidersLogger from './ProvidersLogger';
-import Availability from '../events/Availability';
-import PositioningOptions from '../PositioningOptions';
-import ContainsIgnoredProviderError from '../errors/ContainsIgnoredProviderError';
-
-let uniqueId = 1;
-
-/**
- * A provider is a meta class to define an entity which can be
- * started / stopped and provides a data of {@link ProviderEvent#DataType}
- */
-class Provider {
-
-    static DEFAULT_NAME = 'Unknown';
-    static DEFAULT_OPTIONS = Object.assign(
-        {},
-        PositioningOptions,
-        {
-            stopOnError: true,
-            checkAvailabilityOnStart: true
-        }
-    );
-
-    static State = {
-        STARTING: 0,
-        STARTED: 1,
-        STOPPPED: 2
-    };
-
-    static Warnings = {
-        ALREADY_STARTED: 'Provider already started',
-        ALREADY_STOPPED: 'Provider already stopped'
-    }
-
-    state = Provider.State.STOPPPED;
-
-    /**
-     * Provider constructor
-     * @param {Function} onEvent a callback which will receive events
-     * @param {Function} onError a callback when an error happen
-     * @param {Object} options provider options
-     */
-    constructor(onEvent, onError, options) {
-        this.onEvent = onEvent || noop;
-        this.onError = onError || noop;
-        this.options = Object.assign({}, Provider.DEFAULT_OPTIONS, PositioningOptions, options);
-        this.id = uniqueId++;
-        ProvidersLogger.addEvent(this, 'constructor');
-    }
-
-    /**
-     * Get the provider display name
-     * @public
-     * @abstract
-     */
-    static get name() {
-        return this.DEFAULT_NAME;
-    }
-
-    /**
-     * Get the provider name
-     * @public
-     * @abstract
-     */
-    static get displayName() {
-        return this.constructor.DEFAULT_NAME;
-    }
-
-    /**
-     * Get the list of events type which can be returned by the provider
-     * @returns {EventType[]} the list of events type
-     * @public
-     * @abstract
-     */
-    static get eventsType() {
-        return [];
-    }
-
-    /**
-     * //TODO
-     */
-    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 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
-     */
-    start() {
-        if (this.state === Provider.State.STARTING
-            || this.state === Provider.State.STARTED) {
-            Logger.warn(Provider.Warnings.ALREADY_STARTED);
-            return;
-        }
-        this.state = Provider.State.STARTING;
-
-        if (this.options.checkAvailabilityOnStart) {
-            const availibility = this.constructor.checkAvailability(this.options);
-            if (!availibility.isSupported) {
-                this.notifyError(availibility.reason);
-                return;
-            }
-        }
-
-        ProvidersLogger.addEvent(this, 'start');
-        this.state = Provider.State.STARTED;
-        this.startInternal();
-    }
-
-    /**
-     * @abstract
-     */
-    startInternal() {
-        throw new Error('Provider "' + this.constructor.name
-            + '" does not @override startInternal()');
-    }
-
-    /**
-     * Stop the Provider
-     * @public
-     */
-    stop() {
-
-        if (this.state === Provider.State.STOPPPED) {
-            Logger.warn(Provider.Warnings.ALREADY_STOPPED);
-            return;
-        }
-
-        ProvidersLogger.addEvent(this, 'stop');
-        this.state = Provider.State.STOPPPED;
-        this.stopInternal();
-    }
-
-    /**
-     * @abstract
-     */
-    stopInternal() {
-        throw new Error('Provider "' + this.constructor.name
-            + '" does not @override stopInternal()');
-    }
-
-
-    /**
-     * Notify the subscriber defined in {@link constructor}
-     * @param {ProviderEvent[]} events events to send to subscriber
-     */
-    notify(...events) {
-        ProvidersLogger.incrementNotifications(this);
-        this.onEvent(events);
-    }
-
-    /**
-     * Notify the subscriber defined in {@link constructor}
-     * @param {Error[]} errors The error raised
-     */
-    notifyError(error) {
-        this.onError(error);
-        if (this.options.stopOnError && this.state === Provider.State.STARTED) {
-            this.stop();
-        }
-    }
-
-    /**
-     * Create an event from current provider
-     * @param {ProviderEvent#DataType} dataType type of ProviderEvent
-     * @param {Object} data data exported to ProviderEvent
-     * @param {Number} timestamp event timestamp
-     * @protected
-     */
-    static createEvent(dataType, data, timestamp) {
-        const event = new ProviderEvent(this.constructor.name, dataType, data);
-        if (timestamp) {
-            event.timestamp = timestamp;
-        }
-        return event;
-    }
-
-    /**
-     * Create an event from current provider
-     * @param {EventType} dataType type of ProviderEvent
-     * @param {Object} data data exported to ProviderEvent
-     * @param {Number} timestamp event timestamp
-     * @protected
-     */
-    createEvent(dataType, data, timestamp) {
-        return this.constructor.createEvent(dataType, data, timestamp);
-    }
-
-    static hasNativeInterface() {
-        return Boolean(Provider.nativeInterface);
-    }
-
-    static get nativeInterface() {
-        return global.WemapProvidersAndroid;
-    }
-
-    static get useCameraNatively() {
-        return false;
-    }
-
-    get useCameraNatively() {
-        return this.constructor.useCameraNatively;
-    }
-}
-
-export default Provider;

package/src/providers/ProvidersList.js

@@ -1,44 +0,0 @@
-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
-};

package/src/providers/ProvidersLogger.js

@@ -1,75 +0,0 @@
-import Logger from '@wemap/logger';
-
-let currentId = 0;
-const objectsIdMap = new WeakMap();
-
-let pushEvents = {};
-let pushEventsRef = {};
-
-let interval;
-let initDate;
-
-class ProvidersLogger {
-
-    static enabled = false;
-
-    static initializeInterval() {
-
-        if (interval) {
-            return;
-        }
-
-        interval = setInterval(() => {
-
-            for (const [key, value] of Object.entries(pushEvents)) {
-                Logger.debug('Received ' + value + ' notifications from ' + pushEventsRef[key].constructor.name + ' last second');
-            }
-
-            pushEvents = {};
-            pushEventsRef = {};
-        }, 1000);
-    }
-
-    static getObjectId(object) {
-        if (!objectsIdMap.has(object)) {
-            objectsIdMap.set(object, ++currentId);
-        }
-        return objectsIdMap.get(object);
-    }
-
-    static addEvent(object, method) {
-
-        if (!ProvidersLogger.enabled) {
-            return;
-        }
-
-        if (!initDate) {
-            initDate = Date.now();
-        }
-
-        ProvidersLogger.initializeInterval();
-
-        const objectId = ProvidersLogger.getObjectId(object);
-        const objectClassName = object.constructor.name;
-
-        Logger.debug(objectClassName + '[' + objectId + '].' + method);
-    }
-
-    static incrementNotifications(object) {
-
-        if (!ProvidersLogger.enabled) {
-            return;
-        }
-
-        const objectId = ProvidersLogger.getObjectId(object);
-
-        let counter = pushEvents[objectId];
-        if (!counter) {
-            counter = 0;
-            pushEventsRef[objectId] = object;
-        }
-        pushEvents[objectId] = counter + 1;
-    }
-
-}
-export default ProvidersLogger;

package/src/providers/attitude/AbsoluteAttitudeProvider.js

@@ -1,199 +0,0 @@
-import geomagnetism from 'geomagnetism';
-
-import {
-    Attitude, WGS84
-} from '@wemap/geo';
-import {
-    deg2rad, rad2deg, Quaternion, Rotations
-} from '@wemap/maths';
-import {
-    Browser, BrowserUtils
-} from '@wemap/utils';
-
-import Provider from '../Provider';
-import EventType from '../../events/EventType';
-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';
-
-
-/**
- * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame using
- *  browser deviceorientation or deviceorientationabsolute
- * The provider does not work until an AbsolutePosition is given. This is necessary to
- *  calculate declination.
- *
- * -----------------------------------
- * Overview of compatibilities:
- * -----------------------------------
- *
- * Chrome Android (v72.0.3626): YES (via deviceorientationabsolute)
- * Safari iOS (v12.0): YES (via deviceorientation and event.webkitCompassHeading)
- * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/ondeviceorientation}
- * Firefox Android (v65.0.1): NO {@link https://www.fxsitecompat.com/en-CA/docs/2018/various-device-sensor-apis-are-now-deprecated/}
- *
- * -----------------------------------
- */
-class AbsoluteAttitudeProvider extends Provider {
-
-
-    /**
-     * @override
-     */
-    static get name() {
-        return 'AbsoluteAttitude';
-    }
-
-    /**
-    * @override
-    */
-    static get displayName() {
-        return 'Absolute Attitude from Browser';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsoluteAttitude];
-    }
-
-    /**
-     * @override
-     */
-    static checkAvailability(options) {
-        return Availability.merge(
-            super.checkAvailability(options),
-            BrowserUtils.isMobile
-                ? Availability.yes()
-                : Availability.no(new AskImuOnDesktopError())
-        );
-    }
-
-    /**
-     * @override
-     */
-    startInternal() {
-        switch (BrowserUtils.name) {
-        case Browser.CHROME:
-            window.addEventListener('deviceorientationabsolute',
-                this.onDeviceOrientationChromeEvent, true);
-            break;
-
-        case Browser.SAFARI:
-            window.addEventListener('deviceorientation',
-                this.onDeviceOrientationSafariEvent, true);
-            break;
-        }
-    }
-
-    /**
-     * @override
-     */
-    stopInternal() {
-        switch (BrowserUtils.name) {
-        case Browser.CHROME:
-            window.removeEventListener('deviceorientationabsolute',
-                this.onDeviceOrientationChromeEvent, true);
-            break;
-
-        case Browser.SAFARI:
-            window.removeEventListener('deviceorientation',
-                this.onDeviceOrientationSafariEvent, true);
-            break;
-        }
-    }
-
-
-    onDeviceOrientationChromeEvent = e => {
-
-        const timestamp = e.timeStamp / 1e3;
-
-        if (!e.alpha || !e.beta || !e.gamma) {
-            this.notifyError(new MissingSensorError().from('deviceorientationabsolute'));
-            return;
-        }
-        this.onDeviceOrientationCommonEvent(timestamp,
-            Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]));
-    };
-
-
-    onDeviceOrientationSafariEvent = e => {
-
-        const timestamp = e.timeStamp / 1e3;
-
-        if (!e.beta || !e.gamma) {
-            this.notifyError(new MissingSensorError().from('deviceorientation'));
-            return;
-        }
-
-        if (!e.webkitCompassHeading) {
-            super.notifyError(new MissingMagnetometerError().from('deviceorientation'));
-            return;
-        }
-
-        let webkitCompassHeading = -e.webkitCompassHeading;
-        // Be Careful: webkitCompassHeading is not continuous.
-        // Reference frame changes in function of beta with thresholds: beta > 30deg and beta < 62deg
-        // Below 30deg, East-North-Up (ENU) frame is used
-        // Above 62def, East-Up-South (EUS) frame is used
-        // Between 30deg and 62deg either ENU or EUS can be used
-        if (e.beta > 62) {
-            webkitCompassHeading = AbsoluteAttitudeProvider.headingEusToEnu(
-                180 - webkitCompassHeading, e.beta, e.gamma);
-        }
-        const quaternion = Rotations.eulerToQuaternionZXYDegrees(
-            [webkitCompassHeading, e.beta, e.gamma]);
-
-        this.onDeviceOrientationCommonEvent(timestamp, quaternion);
-    };
-
-
-    onDeviceOrientationCommonEvent = (timestamp, quaternion) => {
-
-        if (!this.declinationQuaternion) {
-            Logger.warn('Position of AbsoluteAttitude provider is not set yet. '
-                + 'Please call setPosition() before.');
-            return;
-        }
-        const trueQuaternion = Quaternion.multiply(this.declinationQuaternion, quaternion);
-
-        super.notify(
-            this.createEvent(
-                EventType.AbsoluteAttitude,
-                new Attitude(trueQuaternion),
-                timestamp
-            )
-        );
-    }
-
-    /**
-     * Initialized declination quaternion using current position.
-     * This method should be theoretically called every time the user moves.
-     * But in reality declination does not change as much.
-     * @param {WGS84} position user position
-     */
-    setPosition(position) {
-        const wmmResult = geomagnetism.model().point([position.lat, position.lng]);
-        // Declination is given in NED frame and our code use ENU, that is why we have: "-decl"
-        this.declinationQuaternion = Quaternion.fromAxisAngle([0, 0, 1], - deg2rad(wmmResult.decl));
-    }
-
-    /**
-     * {@link https://math.stackexchange.com/questions/3181981/solve-a-system-of-rotation-matrices-z-x-z-z-x-y}
-     */
-    static headingEusToEnu(_alpha, _beta, _gamma) {
-        const alpha = deg2rad(_alpha);
-        const beta = deg2rad(_beta);
-        const gamma = deg2rad(_gamma);
-
-        return rad2deg(Math.atan2(
-            Math.cos(alpha) * Math.sin(gamma) + Math.cos(gamma) * Math.sin(alpha) * Math.sin(beta),
-            Math.sin(alpha) * Math.sin(gamma) - Math.cos(alpha) * Math.cos(gamma) * Math.sin(beta)
-        ));
-    }
-}
-
-export default AbsoluteAttitudeProvider;