@wemap/positioning 2.0.0 → 2.1.0

package/src/components/Utils.js

@@ -0,0 +1,74 @@
+import React from 'react'; // eslint-disable-line no-unused-vars
+import { rad2deg } from '@wemap/maths';
+
+const NOT_AVAILABLE_STR = 'Not available';
+
+class Utils {
+
+    static renderAttitude(attitude) {
+
+        if (!attitude) {
+            return <p>Waiting</p>;
+        }
+
+        if (attitude instanceof Error) {
+            return Utils.renderError(attitude);
+        }
+
+        const quaternion = attitude.quaternion;
+
+        const w = quaternion[0].toFixed(3);
+        const x = quaternion[1].toFixed(3);
+        const y = quaternion[2].toFixed(3);
+        const z = quaternion[3].toFixed(3);
+
+        const euler = attitude.eulerAnglesDegrees;
+        const yaw = euler[0].toFixed(2);
+        const pitch = euler[1].toFixed(2);
+        const roll = euler[2].toFixed(2);
+        const heading = attitude.headingDegrees.toFixed(2);
+
+        return <p>Quaternion: [{w}, {x}, {y}, {z}]<br />
+            Eulers: [{yaw}, {pitch}, {roll}]<br />
+            Heading: {heading}</p>;
+    }
+
+    static renderPosition(position) {
+
+        if (!position) {
+            return <p>Waiting</p>;
+        }
+        if (position instanceof Error) {
+            return Utils.renderError(position);
+        }
+        return (
+            <p>
+                Latitude: {position.lat.toFixed(7)}<br />
+                Longitude: {position.lng.toFixed(7)}<br />
+                Altitude: {position.alt ? position.alt.toFixed(2) : NOT_AVAILABLE_STR}<br />
+                Bearing: {position.bearing ? position.bearing.toFixed(2) : NOT_AVAILABLE_STR}<br />
+                Accuracy: {position.accuracy ? position.accuracy.toFixed(2) : NOT_AVAILABLE_STR}<br />
+                Time: {position.time ? position.time.toFixed(2) : NOT_AVAILABLE_STR}<br />
+                Provider: {position.provider ? position.provider : NOT_AVAILABLE_STR}
+            </p>
+        );
+
+    }
+
+    static renderInclination(inclination) {
+        if (inclination === null) {
+            return 'Waiting';
+        }
+        if (inclination instanceof Error) {
+            return Utils.renderError(inclination);
+        }
+        return rad2deg(inclination).toFixed(2);
+    }
+
+    static renderError(error) {
+        return (<span><strong>[{error.constructor.name}]</strong> {error.message}</span>);
+    }
+
+}
+
+export default Utils;

package/src/components/index.js

@@ -0,0 +1,30 @@
+import React from 'react';
+import ReactDOM from 'react-dom';
+
+import AbsoluteAttitudeComponent from './AbsoluteAttitudeComponent';
+import GnssWifiComponent from './GnssWifiComponent';
+import GnssWifiPdrComponent from './GnssWifiPdrComponent';
+import ImuComponent from './ImuComponent';
+import InclinationComponent from './InclinationComponent';
+import PdrComponent from './PdrComponent';
+import PoseComponent from './PoseComponent';
+import PositioningComponent from './PositioningComponent';
+import RelativeAttitudeComponent from './RelativeAttitudeComponent';
+
+const createReactElement = (component, container) => ReactDOM.render(
+    React.createElement(component, {}, null),
+    container
+);
+
+export {
+    AbsoluteAttitudeComponent,
+    ImuComponent,
+    InclinationComponent,
+    GnssWifiComponent,
+    GnssWifiPdrComponent,
+    PdrComponent,
+    PoseComponent,
+    PositioningComponent,
+    RelativeAttitudeComponent,
+    createReactElement
+};

package/src/errors/AskImuOnDesktopError.js

@@ -0,0 +1,9 @@
+const DEFAULT_MESSAGE = 'It seems that you ask for IMU events on a desktop browser';
+
+class AskImuOnDesktopError extends Error {
+    constructor(message) {
+        super(message || DEFAULT_MESSAGE);
+    }
+}
+
+export default AskImuOnDesktopError;

package/src/errors/GeolocationApiMissingError.js

@@ -0,0 +1,9 @@
+const DEFAULT_MESSAGE = 'Geolocation api is missing';
+
+class GeolocationApiMissingError extends Error {
+    constructor(message) {
+        super(message || DEFAULT_MESSAGE);
+    }
+}
+
+export default GeolocationApiMissingError;

package/src/errors/GeolocationPermissionDeniedError.js

@@ -0,0 +1,9 @@
+const DEFAULT_MESSAGE = 'Geolocation permission denied';
+
+class GeolocationPermissionDeniedError extends Error {
+    constructor(message) {
+        super(message || DEFAULT_MESSAGE);
+    }
+}
+
+export default GeolocationPermissionDeniedError;

package/src/errors/GeolocationPositionUnavailableError.js

@@ -0,0 +1,9 @@
+const DEFAULT_MESSAGE = 'Geolocation position unavailable';
+
+class GeolocationPositionUnavailableError extends Error {
+    constructor(message) {
+        super(message || DEFAULT_MESSAGE);
+    }
+}
+
+export default GeolocationPositionUnavailableError;

package/src/errors/IpResolveServerError.js

@@ -0,0 +1,9 @@
+const DEFAULT_MESSAGE = 'IP Resolver failed';
+
+class IpResolveServerError extends Error {
+    constructor(message) {
+        super(message || DEFAULT_MESSAGE);
+    }
+}
+
+export default IpResolveServerError;

package/src/errors/MissingAccelerometerError.js

@@ -0,0 +1,11 @@
+const DEFAULT_MESSAGE = 'Impossible to retrieve Acceleration data';
+
+import MissingSensorError from './MissingSensorError';
+
+class MissingAccelerometerError extends MissingSensorError {
+    constructor(message) {
+        super(message || DEFAULT_MESSAGE);
+    }
+}
+
+export default MissingAccelerometerError;

package/src/errors/MissingGyroscopeError.js

@@ -0,0 +1,11 @@
+const DEFAULT_MESSAGE = 'Impossible to retrieve Angular Rate data';
+
+import MissingSensorError from './MissingSensorError';
+
+class MissingGyroscopeError extends MissingSensorError {
+    constructor(message) {
+        super(message || DEFAULT_MESSAGE);
+    }
+}
+
+export default MissingGyroscopeError;

package/src/errors/MissingMagnetometerError.js

@@ -0,0 +1,9 @@
+import MissingSensorError from './MissingSensorError';
+
+class MissingMagnetometerError extends MissingSensorError {
+    constructor(message) {
+        super(message);
+    }
+}
+
+export default MissingMagnetometerError;

package/src/errors/MissingSensorError.js

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

@@ -0,0 +1,20 @@
+/**
+ * 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',
+    Itinerary: 'ITINERARY',
+    Network: 'NETWORK'
+};

package/src/events/ProviderError.js

@@ -0,0 +1,52 @@
+import EventType from './EventType';
+import ProviderEvent from './ProviderEvent';
+
+/**
+ * A provider error is an error event which is triggered by device sensors
+ * in case of problem
+ */
+class ProviderError extends ProviderEvent {
+
+    error = null;
+
+    /**
+     * Create a Provider Error with the minimum information
+     * @param {String} providerName the provider name
+     * @param {EventType} dataType the type of event
+     * @param {Error} error the event error
+     */
+    constructor(providerName, dataType, error) {
+        super(providerName, dataType, null);
+        this.error = error;
+    }
+
+    clone() {
+        const evt = new ProviderError(this.providerName, this.dataType, this.error);
+        evt.timestamp = this.timestamp;
+        evt.isFromNative = this.isFromNative;
+        return evt;
+    }
+
+    /**
+     * Remove the same error in array
+     * @param {ProviderError[]} errorsArray
+     */
+    static removeArrayDuplicates(errorsArray) {
+        return errorsArray.reduce((acc, current) => {
+            const found = acc.find(item => typeof item.error === typeof current.error && item.dataType === current.dataType);
+            return !found ? acc.concat([current]) : acc;
+        }, []);
+    }
+
+    static modifyArrayDataType(errorsArray, newDataType) {
+        const output = [];
+        errorsArray.forEach(error => {
+            const newError = error.clone();
+            newError.dataType = newDataType;
+            output.push(newError);
+        });
+        return ProviderError.removeArrayDuplicates(output);
+    }
+}
+
+export default ProviderError;

package/src/events/ProviderEvent.js

@@ -0,0 +1,35 @@
+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/index.js

@@ -1,6 +1,6 @@
+import InclinationProvider from './providers/computed/InclinationProvider';
 import PositioningHandler from './PositioningHandler';
-import AttitudeHandler from '../src.old/attitude/AttitudeHandler';
 
 export {
-    AttitudeHandler, PositioningHandler
+    InclinationProvider, PositioningHandler
 };

package/src/providers/Constants.js

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

package/src/providers/FakeAbsolutePositionProvider.js

@@ -0,0 +1,56 @@
+import {
+    WGS84, Attitude
+} from '@wemap/geo';
+import Provider from './Provider';
+import EventType from '../events/EventType';
+
+
+/**
+ * @private
+ */
+class FakeAbsolutePositionProvider extends Provider {
+
+    /**
+     * @override
+     */
+    static get displayName() {
+        return 'FakeAbsolutePosition';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    startInternal() {
+
+        this.interval = setInterval(() => {
+            this.notify(
+                this.createEvent(EventType.AbsoluteAttitude, new Attitude([1, 0, 0, 0])),
+                this.createEvent(EventType.AbsolutePosition, new WGS84(45, 5))
+            );
+        }, 1000);
+
+        return Promise.resolve();
+    }
+
+    /**
+     * @override
+     */
+    stopInternal() {
+
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        return Promise.resolve();
+    }
+
+}
+
+export default FakeAbsolutePositionProvider;

package/src/providers/Provider.js

@@ -0,0 +1,218 @@
+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';
+
+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 = {
+        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(this.constructor.DEFAULT_OPTIONS, options);
+        this.id = uniqueId++;
+        ProvidersLogger.addEvent(this, 'constructor');
+    }
+
+    /**
+     * 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 [];
+    }
+
+    /**
+     * @override
+     */
+    static checkAvailabilityErrors() {
+        return this.requiredProviders.reduce(
+            (acc, val) => acc.concat(val.checkAvailabilityErrors()), []
+        );
+    }
+
+    /**
+     * Return the list of required providers
+     */
+    static get requiredProviders() {
+        return [];
+    }
+
+    /**
+     * 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 availabilityErrors = this.constructor.checkAvailabilityErrors();
+            if (availabilityErrors.length !== 0) {
+                this.notifyError(...availabilityErrors);
+                return;
+            }
+        }
+
+        ProvidersLogger.addEvent(this, 'start');
+        this.startInternal();
+        this.state = Provider.State.STARTED;
+
+    }
+
+    /**
+     * @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.stopInternal();
+        this.state = Provider.State.STOPPPED;
+    }
+
+    /**
+     * @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 {ProviderError[]} errors The error raised
+     */
+    notifyError(...errors) {
+        this.onError(errors);
+        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);
+    }
+
+    /**
+     * 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);
+    }
+
+}
+
+export default Provider;

package/src/providers/ProviderOptions.js

@@ -0,0 +1,28 @@
+const ProviderOptions = {
+
+    /**
+     * Does provider have to wait an input position to start
+     * @see PositioningHandler#setLocation()
+     */
+    waitInputPosition: false,
+
+    /**
+     * Does provider have to wait an input heading to start
+     * @see PositioningHandler#setHeading()
+     */
+    waitInputHeading: false,
+
+    /**
+     * Does provider will use map to
+     * @see PositioningHandler#setItinerary()
+     */
+    useMapMatching: false,
+
+    /**
+     * Providers listed here will not be used by PositioningHandler
+     * List of {@link Provider}
+     */
+    ignoreProviders: []
+};
+
+export default ProviderOptions;