@wemap/providers 3.0.0

package/src/events/ProvidersLogger.js

@@ -0,0 +1,83 @@
+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 get enabled() {
+        return this._enabled;
+    }
+
+    static set enabled(_newVal) {
+        this._enabled = _newVal;
+    }
+
+    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/Constants.js

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

package/src/providers/FakeProvider.spec.js

@@ -0,0 +1,57 @@
+import { UserPosition } from '@wemap/geo';
+
+import Provider from './Provider';
+import Availability from '../events/Availability';
+
+import EventType from '../events/EventType';
+import { TimeUtils } from '@wemap/utils';
+
+class FakeProvider1 extends Provider { }
+
+class FakeProvider5 extends Provider {
+    start() {}
+}
+
+class FakeProvider2 extends Provider {
+    get _availability() {
+        return Availability.no(new Error());
+    }
+    start() { }
+    stop() { }
+}
+
+class FakeProvider3 extends Provider {
+    start() {
+        this.intervalId = setInterval(() => {
+            const fakePosition = new UserPosition(Math.random() * 45, Math.random() * 180);
+            this.notify(this.createEvent(EventType.AbsolutePosition, fakePosition));
+            this.notify(this.createEvent(EventType.AbsolutePosition, fakePosition, TimeUtils.preciseTime));
+        }, 1);
+    }
+    stop() {
+        clearInterval(this.intervalId);
+    }
+}
+
+class FakeProvider4 extends Provider {
+    constructor() {
+        super();
+        this.fp3 = FakeProvider3.instance;
+    }
+    get _availability() {
+        return this.fp3.availability;
+    }
+    start() {
+        this.fp3id = this.fp3.addEventListener(
+            events => this.notify(events[0].clone()),
+            this.notifyError.bind(this),
+            this.name);
+    }
+    stop() {
+        this.fp3.removeEventListener(this.fp3id);
+    }
+}
+
+export {
+    FakeProvider1, FakeProvider2, FakeProvider3, FakeProvider4, FakeProvider5
+};

package/src/providers/MetaProvider.js

@@ -0,0 +1,42 @@
+import Provider from './Provider';
+import ProviderEvent from '../events/ProviderEvent';
+
+class MetaProvider extends Provider {
+
+    _lastEvent = null;
+
+    /**
+     * Singleton pattern using reflection.
+     * @returns {MetaProvider}
+     */
+    static get instance() {
+        if (!this._instance) {
+            this._instance = Reflect.construct(this, []);
+        }
+        return this._instance;
+    }
+
+    /**
+     * @override
+     * @param {ProviderEvent} event
+     */
+    notify(event) {
+        super.notify(event);
+        this._lastEvent = event;
+    }
+
+    get lastEvent() {
+        return this._lastEvent;
+    }
+
+    /**
+     * Input data from external interface
+     * @param {ProviderEvent} event
+     */
+    // eslint-disable-next-line no-unused-vars
+    feed(event) {
+        throw new Error('Not implemented');
+    }
+}
+
+export default MetaProvider;

package/src/providers/Provider.js

@@ -0,0 +1,314 @@
+import isNumber from 'lodash.isnumber';
+import noop from 'lodash.noop';
+
+import { TimeUtils } from '@wemap/utils';
+
+import EventType from '../events/EventType';
+import ProviderEvent from '../events/ProviderEvent';
+import ProvidersLogger from '../events/ProvidersLogger';
+import Availability from '../events/Availability';
+import ContainsIgnoredProviderError from '../errors/ContainsIgnoredProviderError';
+import ProvidersOptions from '../ProvidersOptions';
+import ProviderState from './ProviderState';
+
+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 _callbackUniqueId = 0;
+
+    state = ProviderState.STOPPPED;
+
+    _eventsCallbacks = [];
+    _monitoringCallbacks = [];
+
+
+    /**
+     * Singleton pattern using reflection.
+     * @returns {Provider}
+     */
+    static get instance() {
+        if (!this._instance) {
+            this._instance = Reflect.construct(this, []);
+        }
+        return this._instance;
+    }
+
+
+    /**
+     * Provider constructor
+     */
+    constructor() {
+
+        if (this.constructor === Provider) {
+            throw new Error('Can\'t instantiate Provider directly');
+        }
+
+        if (this._instance) {
+            throw new Error(`Cannot instantiate ${this.constructor.name} twice`);
+        }
+
+        this.id = uniqueId++;
+
+        ProvidersLogger.addEvent(this, 'constructor');
+    }
+
+    get name() {
+        return this.constructor.name;
+    }
+
+    /**
+     * Get the provider name
+     * @public
+     * @abstract
+     */
+    static get displayName() {
+        return this.name;
+    }
+
+    get displayName() {
+        return this.constructor.displayName;
+    }
+
+    /**
+     * Get the list of events type which can be returned by the provider
+     * @returns {EventType[]} the list of events type
+     * @public
+     * @abstract
+     */
+    get eventsType() {
+        return [];
+    }
+
+    /**
+     * @returns {Availability} returns an availability
+     */
+    get availability() {
+        if (ProvidersOptions.ignoreProviders.includes(this.name)) {
+            return Availability.no(new ContainsIgnoredProviderError());
+        }
+
+        return this._availability;
+    }
+
+    get _availability() {
+        return Availability.yes();
+    }
+
+    /**
+     * 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
+     * @returns {ProviderEvent}
+     * @protected
+     */
+    static createEvent(dataType, data, timestamp, fromEvents = []) {
+        const event = new ProviderEvent(dataType, data);
+        event.timestamp = isNumber(timestamp) ? timestamp : TimeUtils.preciseTime / 1e3;
+        const newStack = fromEvents.reduce((acc, _event) => acc.concat(_event.providersStack), []);
+        // Remove duplicates and keep lasts
+        event.providersStack = [...new Set(newStack.reverse())].reverse();
+        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
+     * @param {ProviderEvent[]} fromEvents events used for the creation of the new one
+     * @returns {ProviderEvent}
+     * @protected
+     */
+    createEvent(dataType, data, timestamp, fromEvents) {
+        return this.constructor.createEvent(dataType, data, timestamp, fromEvents);
+    }
+
+    get hasNativeInterface() {
+        return Boolean(this.nativeInterface);
+    }
+
+    get nativeInterface() {
+        return global.WemapProvidersAndroid || null;
+    }
+
+    get useCameraNatively() {
+        return false;
+    }
+
+    /**
+     *
+     * @param {Function} onEvents
+     * @param {Function} onError
+     * @param {Object} callerName
+     * @param {Boolean} startIfNecessary
+     * @returns {Number}
+     */
+    addEventListener(onEvents = noop, onError = noop, callerName = null, startIfNecessary = true) {
+        const id = ++Provider._callbackUniqueId;
+
+        /**
+         * Build callback
+         */
+        this._eventsCallbacks.push({
+            id,
+            onEvents,
+            onError,
+            optional: !startIfNecessary,
+            callerName
+        });
+
+
+        // The caller just want to have callbacks without starting the provider,
+        // the routine can be stopped here
+        if (!startIfNecessary) {
+            return id;
+        }
+
+
+        // If the provider is already started do not go further
+        if (this.state !== ProviderState.STOPPPED) {
+            return id;
+        }
+
+        // Check availability on start if defined in options
+        if (ProvidersOptions.checkAvailabilityOnStart) {
+            if (!this.availability.isSupported) {
+                this.notifyError(this.availability.reason);
+                return id;
+            }
+        }
+
+        this.state = ProviderState.STARTING;
+
+        ProvidersLogger.addEvent(this, 'start');
+        // Call the child start function
+        this.start();
+
+        this.state = ProviderState.STARTED;
+
+        this._monitoringCallbacks.forEach(({ onStarted }) => onStarted());
+
+        return id;
+    }
+
+    /**
+     *
+     * @param {Number} callbackUniqueId
+     */
+    removeEventListener(callbackUniqueId) {
+
+        // Search the caller object in callbacks list
+        const callback = this._eventsCallbacks.find(_callback => _callback.id === callbackUniqueId);
+        if (!callback) {
+            // The callback object is not found. Maybe it is already stopped.
+            return;
+        }
+
+        // Remove the current callback from the list of the callbacks
+        this._eventsCallbacks = this._eventsCallbacks.filter(_callback => _callback !== callback);
+
+        // If this callback was optional, do not go further to stop the provider
+        if (callback.optional) {
+            return;
+        }
+
+        // If there is callbacks that are not optionals for start, do not stop the provider
+        if (this._eventsCallbacks.find(_callback => !_callback.optional)) {
+            return;
+        }
+
+        // If the provider is already stopped, do not stop it again.
+        // This condition can be true if checkAvailabilityOnStart is true and returns an error
+        if (this.state === ProviderState.STOPPPED) {
+            return;
+        }
+
+        ProvidersLogger.addEvent(this, 'stop');
+        // Call the child stop function
+        this.stop();
+
+        this.state = ProviderState.STOPPPED;
+
+        this._monitoringCallbacks.forEach(({ onStopped }) => onStopped());
+    }
+
+
+    /**
+     *
+     * @param {Function} onStarted
+     * @param {Function} onStopped
+     * @returns {Number}
+     */
+    addMonitoringListener(onStarted = noop, onStopped = noop) {
+        const id = ++this.constructor._callbackUniqueId;
+        this._monitoringCallbacks.push({
+            id,
+            onStarted,
+            onStopped
+        });
+        return id;
+    }
+
+    /**
+     *
+     * @param {Number} callbackUniqueId
+     */
+    removeMonitoringListener(callbackUniqueId) {
+        this._monitoringCallbacks = this._monitoringCallbacks.filter(
+            _callback => _callback.id !== callbackUniqueId
+        );
+    }
+
+    /**
+     * @abstract
+     */
+    start() {
+        throw new Error('Provider "' + this.name + '" does not @override start()');
+    }
+
+    /**
+     * @abstract
+     */
+    stop() {
+        throw new Error('Provider "' + this.name + '" does not @override stop()');
+    }
+
+
+    /**
+     * Notify the subscriber defined in {@link addEventListener}
+     * @param {ProviderEvent[]} events events to send to subscriber
+     */
+    notify(...events) {
+        // Logging
+        ProvidersLogger.incrementNotifications(this);
+
+        // Add current provider to the list of providers for this event.
+        events.forEach(event => event.providersStack.unshift(this.name));
+
+        // Notify callbacks
+        this._eventsCallbacks.forEach(({ onEvents }) => onEvents(events));
+    }
+
+    /**
+     * Notify the subscriber defined in {@link addEventListener}
+     * @param {Error} error The error raised
+     */
+    notifyError(error) {
+        this._eventsCallbacks.forEach(({
+            id, onError
+        }) => {
+            if (ProvidersOptions.stopOnError) {
+                this.removeEventListener(id);
+            }
+            onError(error);
+        });
+    }
+}
+
+export default Provider;

package/src/providers/Provider.spec.js

@@ -0,0 +1,136 @@
+/* eslint-disable max-nested-callbacks */
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import noop from 'lodash.noop';
+
+import Logger from '@wemap/logger';
+
+import Provider from './Provider';
+
+import ContainsIgnoredProviderError from '../errors/ContainsIgnoredProviderError';
+
+import {
+    FakeProvider1, FakeProvider2, FakeProvider3, FakeProvider4, FakeProvider5
+} from './FakeProvider.spec';
+import ProvidersOptions from '../ProvidersOptions';
+import ProviderState from './ProviderState';
+
+chai.use(chaiAsPromised);
+Logger.enable(false);
+
+const { expect } = chai;
+
+
+describe('Provider', () => {
+
+    it('creation/singleton', () => {
+        expect(() => new Provider()).throw(Error);
+        expect(() => Provider.instance).throw(Error);
+        expect(() => FakeProvider1.instance).not.throw(Error);
+        expect(() => FakeProvider2.instance).not.throw(Error);
+        expect(() => FakeProvider3.instance).not.throw(Error);
+        expect(() => FakeProvider4.instance).not.throw(Error);
+        expect(FakeProvider1.instance).equals(FakeProvider1.instance);
+        expect(FakeProvider4.instance).equals(FakeProvider4.instance);
+    });
+
+
+    it('default getter', () => {
+        const provider = FakeProvider1.instance;
+        expect(provider.name).equals(FakeProvider1.name);
+        expect(provider.displayName).equals(FakeProvider1.name);
+        expect(provider.eventsType).is.empty;
+        expect(provider.hasNativeInterface).is.false;
+        expect(provider.nativeInterface).is.null;
+        expect(provider.useCameraNatively).is.false;
+    });
+
+    it('availability', () => {
+
+        const fakeProvider1 = FakeProvider1.instance;
+        expect(fakeProvider1.availability.isSupported).is.true;
+        ProvidersOptions.ignoreProviders.push(FakeProvider1.name);
+        expect(fakeProvider1.availability.isSupported).is.false;
+        expect(fakeProvider1.availability.reason).instanceOf(ContainsIgnoredProviderError);
+        ProvidersOptions.ignoreProviders = [];
+
+        expect(FakeProvider2.instance.availability.isSupported).is.false;
+        expect(FakeProvider2.instance.availability.reason).instanceOf(Error);
+
+        expect(FakeProvider3.instance.availability.isSupported).is.true;
+        expect(FakeProvider4.instance.availability.isSupported).is.true;
+    });
+
+    it('checkAvailability on start', () => {
+
+        const fp2 = FakeProvider2.instance;
+
+        /**
+         * checkAvailabilityOnStart = true
+         */
+        let errored = false;
+        fp2.addEventListener(noop, () => (errored = true));
+
+        expect(errored).is.true;
+        expect(fp2.state).equals(ProviderState.STOPPPED);
+        expect(fp2._eventsCallbacks.length).equals(0);
+
+        /**
+         * checkAvailabilityOnStart = false
+         */
+        ProvidersOptions.checkAvailabilityOnStart = false;
+
+        errored = false;
+        const id = fp2.addEventListener(noop, () => (errored = true));
+
+        expect(errored).is.false;
+        expect(fp2.state).equals(ProviderState.STARTED);
+
+        fp2.removeEventListener(id);
+        expect(fp2.state).equals(ProviderState.STOPPPED);
+        expect(fp2._eventsCallbacks.length).equals(0);
+
+        ProvidersOptions.checkAvailabilityOnStart = true;
+    });
+
+    const startStop = (provider) => {
+        return new Promise((resolve, reject) => {
+            let isStopped = false;
+            let fail = false;
+
+            const listenerId = provider.addEventListener(() => {
+                if (isStopped) {
+                    fail = true;
+                }
+            });
+
+            setTimeout(() => {
+                isStopped = true;
+                provider.removeEventListener(listenerId);
+
+                setTimeout(() => {
+                    if (fail) {
+                        reject('Provider did not stop');
+                    } else {
+                        resolve();
+                    }
+                }, 5);
+            }, 7);
+        });
+    };
+
+
+    it('start/stop', () => {
+        expect(() => FakeProvider1.instance.addEventListener()).throw(Error);
+
+        const idFp5 = FakeProvider5.instance.addEventListener();
+        expect(() => FakeProvider5.instance.removeEventListener(idFp5)).throw(Error);
+
+        return Promise.all([
+            expect(startStop(FakeProvider2.instance)).to.be.fulfilled,
+            expect(startStop(FakeProvider3.instance)).to.be.fulfilled,
+            expect(startStop(FakeProvider4.instance)).to.be.fulfilled
+        ]);
+    });
+
+});

package/src/providers/ProviderState.js

@@ -0,0 +1,5 @@
+export default {
+    STARTING: 0,
+    STARTED: 1,
+    STOPPPED: 2
+};

package/src/providers/attitude/AttitudeProvider.js

@@ -0,0 +1,63 @@
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import Availability from '../../events/Availability';
+import {
+    RelativeAttitude, AbsoluteAttitude
+} from '../../Providers';
+
+class AttitudeProvider extends Provider {
+
+    constructor() {
+        super();
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Attitude';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.Attitude];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Availability.union(
+            RelativeAttitude.availability,
+            AbsoluteAttitude.availability
+        );
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        if (RelativeAttitude.availability.isSupported) {
+            this.provider = RelativeAttitude;
+        } else {
+            this.provider = AbsoluteAttitude;
+        }
+
+        this.providerId = this.provider.addEventListener(
+            events => this.notify(events[0].clone()),
+            this.notifyError,
+            this.name);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        this.provider.removeEventListener(this.providerId);
+    }
+}
+
+export default AttitudeProvider;