@wemap/positioning 2.0.0 → 2.2.0

package/src/components/PositioningInclinationComponent.jsx

@@ -0,0 +1,76 @@
+import React from 'react';
+import isEmpty from 'lodash.isempty';
+import PropTypes from 'prop-types';
+
+import EventType from '../events/EventType';
+import Utils from './Utils';
+import PositioningHandler from '../PositioningHandler';
+import StartStopComponent from './StartStopComponent';
+
+class PositioningInclinationComponent extends React.Component {
+
+    static propTypes = { positioningHandler: PropTypes.instanceOf(PositioningHandler).isRequired };
+
+    constructor(props, context) {
+        super(props, context);
+        this.state = {
+            inclination: null,
+            errored: false
+        };
+    }
+
+
+    start() {
+        this.id = this.props.positioningHandler.start(
+            [EventType.Inclination],
+            this.onEvents,
+            this.onErrors
+        );
+    }
+
+
+    stop() {
+        this.props.positioningHandler.stop(this.id);
+        this.setState({
+            inclination: null,
+            errored: false
+        });
+    }
+
+    onEvents = (events) => {
+        const newState = {};
+        events.forEach(event => {
+            if (event.dataType === EventType.Inclination) {
+                newState.inclination = event.data;
+            }
+        });
+        if (!isEmpty(newState)) {
+            this.setState(newState);
+        }
+    };
+
+    onErrors = events => {
+        const newState = { errored: true };
+        events.forEach(event => {
+            if (event.dataType === EventType.Inclination) {
+                newState.inclination = event.error;
+            }
+        });
+        this.setState(newState);
+    }
+
+    render() {
+        return (
+            <div>
+                <StartStopComponent
+                    onStart={() => this.start()}
+                    onStop={() => this.stop()}
+                    errored={this.state.errored} />
+
+                <p>{Utils.renderInclination(this.state.inclination)}</p>
+            </div>
+        );
+    }
+}
+
+export default PositioningInclinationComponent;

package/src/components/PositioningPoseComponent.jsx

@@ -0,0 +1,120 @@
+import React from 'react';
+import isEmpty from 'lodash.isempty';
+import PropTypes from 'prop-types';
+
+import EventType from '../events/EventType';
+import Utils from './Utils';
+import PositioningHandler from '../PositioningHandler';
+import StartStopComponent from './StartStopComponent';
+import {
+    WGS84UserPosition, Itinerary
+} from '@wemap/geo';
+import MapComponent from './MapComponent';
+
+const INITIAL_LOCATION = new WGS84UserPosition(43.6091955, 3.8841255);
+const INITIAL_HEADING = 191.9;
+const ITINERARY = Itinerary.fromPoints([
+    [INITIAL_LOCATION.lat, INITIAL_LOCATION.lng],
+    [43.6091883, 3.8841242],
+    [43.6091709, 3.8842382],
+    [43.6091288, 3.884226],
+    [43.6091461, 3.884112]
+], false);
+
+class PositioningPoseComponent extends React.Component {
+
+    static propTypes = { positioningHandler: PropTypes.instanceOf(PositioningHandler).isRequired };
+
+    constructor(props, context) {
+        super(props, context);
+        this.state = {
+            position: null,
+            attitude: null,
+            errored: false
+        };
+    }
+
+
+    start() {
+        this.id = this.props.positioningHandler.start(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            this.onEvents,
+            this.onErrors,
+            {
+                waitInputPosition: true,
+                useMapMatching: true
+            }
+        );
+
+        setTimeout(() => {
+            this.props.positioningHandler.setPosition(this.id, INITIAL_LOCATION);
+            this.props.positioningHandler.setHeading(this.id, INITIAL_HEADING);
+            this.props.positioningHandler.setItinerary(this.id, ITINERARY);
+        }, 3000);
+    }
+
+
+    stop() {
+        this.props.positioningHandler.stop(this.id);
+        this.setState({
+            position: null,
+            attitude: null,
+            errored: false
+        });
+    }
+
+    onEvents = (events) => {
+        const newState = {};
+        events.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                newState.position = event.data;
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                newState.attitude = event.data;
+            }
+        });
+        if (!isEmpty(newState)) {
+            this.setState(newState);
+        }
+
+        if (this.map) {
+            this.map.parseEvents(events);
+        }
+    };
+
+    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;
+            }
+        });
+        this.setState(newState);
+    }
+
+    render() {
+        const attitudeRender = Utils.renderAttitude(this.state.attitude);
+        const positionRender = Utils.renderPosition(this.state.position);
+
+        return (
+            <div>
+                <StartStopComponent
+                    onStart={() => this.start()}
+                    onStop={() => this.stop()}
+                    errored={this.state.errored} />
+
+                <h3>Position</h3>
+                {positionRender}
+                <h3>Attitude</h3>
+                {attitudeRender}
+                <h3>Map</h3>
+                <MapComponent
+                    ref={map => (this.map = map)}
+                    network={ITINERARY} />
+            </div>
+        );
+    }
+}
+
+export default PositioningPoseComponent;

package/src/components/RelativeAttitudeComponent.jsx

@@ -0,0 +1,82 @@
+import React from 'react';
+
+import RelativeAttitudeProvider from '../providers/attitude/RelativeAttitudeProvider';
+import Utils from './Utils';
+import EventType from '../events/EventType';
+
+class RelativeAttitudeComponent extends React.Component {
+
+    constructor(props, context) {
+        super(props, context);
+
+        this.state = {
+            attitude: null,
+            deviceorientation: null
+        };
+
+        this.relativeAttitudeProvider = new RelativeAttitudeProvider(this.onEvent, this.onError);
+    }
+
+    componentDidMount() {
+        this.relativeAttitudeProvider.start();
+        window.addEventListener('deviceorientation', this.onDeviceOrientationEventListener, true);
+    }
+
+    componentWillUnmount() {
+        this.relativeAttitudeProvider.stop();
+        window.removeEventListener('deviceorientation', this.onDeviceOrientationEventListener, true);
+    }
+
+    onEvent = events => {
+        events.forEach(event => {
+            if (event.dataType === EventType.RelativeAttitude) {
+                this.setState({ attitude: event.data });
+            }
+        });
+    };
+
+    onError = events => {
+        events.forEach(event => {
+            if (event.dataType === EventType.RelativeAttitude) {
+                this.setState({ attitude: event.error });
+            }
+        });
+    }
+
+    onDeviceOrientationEventListener = (e) => this.setState({ deviceorientation: e });
+
+    setOffset(offset) {
+        this.relativeAttitudeProvider.setOffset(offset);
+    }
+
+    render() {
+
+        let rawRender = <span>Not available</span>;
+
+        if (this.state.deviceorientation) {
+            const alpha = this.state.deviceorientation.alpha;
+            const beta = this.state.deviceorientation.beta;
+            const gamma = this.state.deviceorientation.gamma;
+
+            if (alpha && beta && gamma) {
+                rawRender = <p>alpha: {alpha.toFixed(2)}, <br />
+                    beta: {beta.toFixed(2)}, <br />
+                    gamma: {gamma.toFixed(2)}</p>;
+            }
+        }
+
+        const browserRender = Utils.renderAttitude(this.state.attitude);
+
+        return (
+            <div>
+                <h3>Raw:</h3>
+                {rawRender}
+                <h3>From browser:</h3>
+                {browserRender}
+            </div>
+        );
+    }
+}
+
+export default RelativeAttitudeComponent;
+

package/src/components/StartStopComponent.jsx

@@ -0,0 +1,50 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+class StartStopComponent extends React.Component {
+
+    static propTypes = {
+        onStart: PropTypes.func.isRequired,
+        onStop: PropTypes.func.isRequired,
+        errored: PropTypes.bool.isRequired
+    };
+
+    constructor(props, context) {
+        super(props, context);
+        this.state = { started: false };
+    }
+
+    start() {
+        this.setState({started: true});
+        this.props.onStart();
+    }
+
+    componentWillUnmount() {
+        stop();
+    }
+
+    stop() {
+        this.setState({started: false});
+        this.props.onStop();
+    }
+
+
+    render() {
+        return (
+            <div>
+                <button onClick={() => this.start()}
+                    disabled={(this.state.started && !this.props.errored)}>
+                    Start
+                </button>
+                <button onClick={() => this.stop()}
+                    disabled={!(this.state.started && !this.props.errored)}>
+                    Stop
+                </button>
+            </div>
+
+        );
+    }
+
+}
+
+export default StartStopComponent;

package/src/components/Utils.js

@@ -0,0 +1,92 @@
+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 renderRelativePosition(position) {
+
+        if (!position) {
+            return <p>Waiting</p>;
+        }
+        if (position instanceof Error) {
+            return Utils.renderError(position);
+        }
+        return (
+            <p>
+                x: {position[0].toFixed(2)}<br />
+                y: {position[1].toFixed(2)}<br />
+                z: {position[2].toFixed(2)}
+            </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,32 @@
+import React from 'react';
+import ReactDOM from 'react-dom';
+
+import AbsoluteAttitudeComponent from './AbsoluteAttitudeComponent';
+import ArCoreComponent from './ArCoreComponent';
+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,
+    ArCoreComponent,
+    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/MissingArCoreError.js

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

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/MissingNativeInterfaceError.js

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

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;