@igo2/geo 1.14.2 → 1.14.3

package/esm2020/lib/map/shared/controllers/geolocation.mjs

@@ -1,308 +1,308 @@
-import olGeolocation from 'ol/Geolocation';
-import { BehaviorSubject, interval } from 'rxjs';
-import olFeature from 'ol/Feature';
-import { MapController } from './controller';
-import { Point } from 'ol/geom';
-import { fromCircle } from 'ol/geom/Polygon';
-import OlCircle from 'ol/geom/Circle';
-import * as olstyle from 'ol/style';
-import { Overlay } from '../../../overlay/shared/overlay';
-import { FeatureMotion } from '../../../feature/shared/feature.enums';
-import { switchMap } from 'rxjs/operators';
-var GeolocationOverlayType;
-(function (GeolocationOverlayType) {
-    GeolocationOverlayType["Position"] = "position";
-    GeolocationOverlayType["Accuracy"] = "accuracy";
-    GeolocationOverlayType["Buffer"] = "buffer";
-})(GeolocationOverlayType || (GeolocationOverlayType = {}));
-/**
- * Controller to handle map view interactions
- */
-export class MapGeolocationController extends MapController {
-    constructor(map, options, storageService, configService) {
-        super();
-        this.map = map;
-        this.options = options;
-        this.storageService = storageService;
-        this.configService = configService;
-        this.subscriptions$$ = [];
-        this.positionFeatureStyle = new olstyle.Style({
-            image: new olstyle.Circle({
-                radius: 6,
-                fill: new olstyle.Fill({
-                    color: '#3399CC',
-                }),
-                stroke: new olstyle.Stroke({
-                    color: '#fff',
-                    width: 2,
-                }),
-            }),
-        });
-        this.accuracyFeatureStyle = new olstyle.Style({
-            stroke: new olstyle.Stroke({
-                color: 'rgba(120, 120, 120, 0.4)',
-                width: 1,
-            }),
-            fill: new olstyle.Fill({
-                color: 'rgba(120, 120, 120, 0.4)',
-            }),
-        });
-        /**
-         * Observable of the current emission interval of the position. In seconds
-         */
-        this.emissionIntervalSeconds$ = new BehaviorSubject(5);
-        /**
-         * Observable of the current position
-         */
-        this.position$ = new BehaviorSubject(undefined);
-        /**
-         * Observable of the tracking state
-         */
-        this.tracking$ = new BehaviorSubject(undefined);
-        /**
-         * Observable of the follow position state
-         */
-        this.followPosition$ = new BehaviorSubject(undefined);
-        this._buffer = this.options && this.options.buffer ? this.options.buffer : undefined;
-        this._accuracyThreshold = this.options && this.options.accuracyThreshold ? this.options.accuracyThreshold : 5000;
-        this._followPosition = this.options && this.options.followPosition ? this.options.followPosition : false;
-        this.geolocationOverlay = new Overlay(this.map);
-    }
-    /**
-     * History of positions
-     */
-    // private positions: MapGeolocationState[] = [];
-    /**
-     * Whether the geolocate controller should keep the position history
-     */
-    /*
-    // todo: refine this method
-    set keepPositionHistory(value) {
-      this._keepPositionHistory = value;
-    }
-    get keepPositionHistory(): boolean {
-      return this._keepPositionHistory;
-    }
-    private _keepPositionHistory: boolean = this.options && this.options.keepPositionHistory ? this.options.keepPositionHistory : true;
-  */
-    /**
-     * Whether the geolocate should show a buffer around the current position
-     */
-    set buffer(value) {
-        this._buffer = value;
-        this.handleFeatureCreation(this.position$.value);
-    }
-    get buffer() {
-        return this._buffer;
-    }
-    /**
-     * Whether the geolocate controller accuracy threshold to store/show the position.
-     */
-    set accuracyThreshold(value) {
-        this._accuracyThreshold = value;
-        this.handleFeatureCreation(this.position$.value);
-    }
-    get accuracyThreshold() {
-        return this._accuracyThreshold;
-    }
-    /**
-     * Whether the activate the geolocation.
-     */
-    get tracking() {
-        return this.geolocation.getTracking();
-    }
-    set tracking(value) {
-        this.geolocation.setTracking(value || false);
-        this.tracking$.next(value);
-        if (this.storageService && value !== undefined) {
-            this.storageService.set('geolocation.tracking', value);
-        }
-        if (!value) {
-            this.position$.next(undefined);
-        }
-    }
-    /**
-   * Whether the activate the view tracking of the current position
-   */
-    set followPosition(value) {
-        this._followPosition = value;
-        this.followPosition$.next(value);
-        if (this.configService?.getConfig('geolocate.followPosition') === false) {
-            this._followPosition = false;
-            this.followPosition$.next(false);
-        }
-        this.handleFeatureCreation(this.position$.value);
-        if (this.storageService && value !== undefined) {
-            this.storageService.set('geolocation.followPosition', value);
-        }
-    }
-    get followPosition() {
-        return this._followPosition;
-    }
-    /**
-     * Add or remove this controller to/from a map.
-     * @param map OL Map
-     */
-    setOlMap(olMap) {
-        super.setOlMap(olMap);
-        this.setupObservers();
-    }
-    deleteGeolocationFeatures() {
-        this.deleteFeatureByType(GeolocationOverlayType.Position);
-        this.deleteFeatureByType(GeolocationOverlayType.Accuracy);
-        this.deleteFeatureByType(GeolocationOverlayType.Buffer);
-    }
-    setupObservers() {
-        this.tracking$.subscribe(tracking => {
-            if (tracking) {
-                this.onPositionChange(true, true);
-            }
-            else {
-                this.deleteGeolocationFeatures();
-            }
-        });
-        this.geolocation = new olGeolocation({
-            // enableHighAccuracy must be set to true to have the heading value.
-            trackingOptions: {
-                enableHighAccuracy: true,
-                maximumAge: 10000,
-                timeout: 600000
-            },
-            projection: this.options.projection,
-        });
-        let tracking = false;
-        this.subscriptions$$.push(this.emissionIntervalSeconds$
-            .pipe(switchMap(value => interval(value * 1000)))
-            .subscribe(() => {
-            if (tracking === this.tracking) {
-                this.onPositionChange(true);
-            }
-            else {
-                tracking = this.tracking;
-                this.onPositionChange(true, true);
-            }
-        }));
-    }
-    updateGeolocationOptions(options) {
-        if (!options) {
-            return;
-        }
-        // todo maybe a dedicated interface for geolocation should be defined instead of putting these inside the mapviewoptions?
-        let tracking = options.geolocate;
-        let followPosition = options.alwaysTracking;
-        if (this.storageService) {
-            const storedTracking = this.storageService.get('geolocation.tracking');
-            if (storedTracking !== null && storedTracking !== undefined) {
-                tracking = storedTracking;
-            }
-            const storedFollowPosition = this.storageService.get('geolocation.followPosition');
-            if (storedFollowPosition !== null && storedFollowPosition !== undefined) {
-                followPosition = storedFollowPosition;
-            }
-        }
-        this.tracking = tracking;
-        this.followPosition = followPosition;
-        this.buffer = options.buffer;
-    }
-    /**
-     * Teardown any observers
-     */
-    teardownObservers() {
-        if (this.subscriptions$$.length) {
-            this.subscriptions$$.map(s => s.unsubscribe());
-        }
-        super.teardownObservers();
-    }
-    /**
-     * Clear the position  history
-     */
-    /*
-    // todo
-    clearPositionsHistory() {
-      this.positions = [];
-    }*/
-    /**
-     * On position change, get the position, show it on the map and record it.
-     * @param emitEvent Map event
-     */
-    onPositionChange(emitEvent = false, zoomTo = false) {
-        if (!this.tracking) {
-            return;
-        }
-        const geolocateProperties = this.geolocation.getProperties();
-        if (geolocateProperties.accuracy > this.accuracyThreshold) {
-            console.warn('Poor geolocation accuracy. No position are stored/shown');
-            this.position$.next(undefined);
-            return;
-        }
-        const position = {
-            position: geolocateProperties.position,
-            projection: this.geolocation.getProjection().getCode(),
-            accuracy: geolocateProperties.accuracy,
-            altitude: geolocateProperties.altitude,
-            altitudeAccuracy: geolocateProperties.altitudeAccuracy,
-            heading: geolocateProperties.heading,
-            speed: geolocateProperties.speed,
-            enableHighAccuracy: geolocateProperties.trackingOptions?.enableHighAccuracy ? true : false,
-            timestamp: new Date()
-        };
-        this.handleFeatureCreation(position, zoomTo);
-        if (emitEvent) {
-            this.position$.next(position);
-            /*if (this.keepPositionHistory === true) {
-              // handle position diff to store only true diff;
-              this.positions.push(position);
-            }*/
-        }
-    }
-    deleteFeatureByType(type) {
-        const featureById = this.geolocationOverlay.dataSource.ol.getFeatureById(type);
-        if (featureById) {
-            this.geolocationOverlay.dataSource.ol.removeFeature(featureById);
-        }
-    }
-    handleFeatureCreation(position, zoomTo = false) {
-        if (!position || !position.position) {
-            return;
-        }
-        this.deleteGeolocationFeatures();
-        const positionGeometry = new Point(position.position);
-        const accuracyGeometry = fromCircle(new OlCircle(position.position, position.accuracy || 0));
-        const positionFeature = new olFeature({ geometry: positionGeometry });
-        const accuracyFeature = new olFeature({ geometry: accuracyGeometry });
-        if (positionGeometry) {
-            let motion = this.followPosition ? FeatureMotion.Move : FeatureMotion.None;
-            if (zoomTo) {
-                motion = FeatureMotion.Zoom;
-            }
-            positionFeature.setId(GeolocationOverlayType.Position);
-            positionFeature.setStyle(this.positionFeatureStyle);
-            this.geolocationOverlay.addOlFeature(positionFeature, motion);
-            if (accuracyGeometry) {
-                accuracyFeature.setId(GeolocationOverlayType.Accuracy);
-                accuracyFeature.setStyle(this.accuracyFeatureStyle);
-                this.geolocationOverlay.addOlFeature(accuracyFeature, motion);
-            }
-            if (this.buffer) {
-                const bufferFeature = new olFeature(new OlCircle(position.position, this.buffer.bufferRadius));
-                const bufferStyle = new olstyle.Style({
-                    stroke: new olstyle.Stroke({ width: 2, color: this.buffer.bufferStroke }),
-                    fill: new olstyle.Fill({ color: this.buffer.bufferFill }),
-                    text: new olstyle.Text({
-                        textAlign: 'left',
-                        offsetX: 10,
-                        offsetY: -10,
-                        font: '12px Calibri,sans-serif',
-                        text: this.buffer.showBufferRadius ? `${this.buffer.bufferRadius}m` : '',
-                        fill: new olstyle.Fill({ color: '#000' }),
-                        stroke: new olstyle.Stroke({ color: '#fff', width: 3 })
-                    })
-                });
-                bufferFeature.setId(GeolocationOverlayType.Buffer);
-                bufferFeature.setStyle(bufferStyle);
-                this.geolocationOverlay.addOlFeature(bufferFeature, motion);
-            }
-        }
-    }
-}
+import olGeolocation from 'ol/Geolocation';
+import { BehaviorSubject, interval } from 'rxjs';
+import olFeature from 'ol/Feature';
+import { MapController } from './controller';
+import { Point } from 'ol/geom';
+import { fromCircle } from 'ol/geom/Polygon';
+import OlCircle from 'ol/geom/Circle';
+import * as olstyle from 'ol/style';
+import { Overlay } from '../../../overlay/shared/overlay';
+import { FeatureMotion } from '../../../feature/shared/feature.enums';
+import { switchMap } from 'rxjs/operators';
+var GeolocationOverlayType;
+(function (GeolocationOverlayType) {
+    GeolocationOverlayType["Position"] = "position";
+    GeolocationOverlayType["Accuracy"] = "accuracy";
+    GeolocationOverlayType["Buffer"] = "buffer";
+})(GeolocationOverlayType || (GeolocationOverlayType = {}));
+/**
+ * Controller to handle map view interactions
+ */
+export class MapGeolocationController extends MapController {
+    constructor(map, options, storageService, configService) {
+        super();
+        this.map = map;
+        this.options = options;
+        this.storageService = storageService;
+        this.configService = configService;
+        this.subscriptions$$ = [];
+        this.positionFeatureStyle = new olstyle.Style({
+            image: new olstyle.Circle({
+                radius: 6,
+                fill: new olstyle.Fill({
+                    color: '#3399CC',
+                }),
+                stroke: new olstyle.Stroke({
+                    color: '#fff',
+                    width: 2,
+                }),
+            }),
+        });
+        this.accuracyFeatureStyle = new olstyle.Style({
+            stroke: new olstyle.Stroke({
+                color: 'rgba(120, 120, 120, 0.4)',
+                width: 1,
+            }),
+            fill: new olstyle.Fill({
+                color: 'rgba(120, 120, 120, 0.4)',
+            }),
+        });
+        /**
+         * Observable of the current emission interval of the position. In seconds
+         */
+        this.emissionIntervalSeconds$ = new BehaviorSubject(5);
+        /**
+         * Observable of the current position
+         */
+        this.position$ = new BehaviorSubject(undefined);
+        /**
+         * Observable of the tracking state
+         */
+        this.tracking$ = new BehaviorSubject(undefined);
+        /**
+         * Observable of the follow position state
+         */
+        this.followPosition$ = new BehaviorSubject(undefined);
+        this._buffer = this.options && this.options.buffer ? this.options.buffer : undefined;
+        this._accuracyThreshold = this.options && this.options.accuracyThreshold ? this.options.accuracyThreshold : 5000;
+        this._followPosition = this.options && this.options.followPosition ? this.options.followPosition : false;
+        this.geolocationOverlay = new Overlay(this.map);
+    }
+    /**
+     * History of positions
+     */
+    // private positions: MapGeolocationState[] = [];
+    /**
+     * Whether the geolocate controller should keep the position history
+     */
+    /*
+    // todo: refine this method
+    set keepPositionHistory(value) {
+      this._keepPositionHistory = value;
+    }
+    get keepPositionHistory(): boolean {
+      return this._keepPositionHistory;
+    }
+    private _keepPositionHistory: boolean = this.options && this.options.keepPositionHistory ? this.options.keepPositionHistory : true;
+  */
+    /**
+     * Whether the geolocate should show a buffer around the current position
+     */
+    set buffer(value) {
+        this._buffer = value;
+        this.handleFeatureCreation(this.position$.value);
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    /**
+     * Whether the geolocate controller accuracy threshold to store/show the position.
+     */
+    set accuracyThreshold(value) {
+        this._accuracyThreshold = value;
+        this.handleFeatureCreation(this.position$.value);
+    }
+    get accuracyThreshold() {
+        return this._accuracyThreshold;
+    }
+    /**
+     * Whether the activate the geolocation.
+     */
+    get tracking() {
+        return this.geolocation.getTracking();
+    }
+    set tracking(value) {
+        this.geolocation.setTracking(value || false);
+        this.tracking$.next(value);
+        if (this.storageService && value !== undefined) {
+            this.storageService.set('geolocation.tracking', value);
+        }
+        if (!value) {
+            this.position$.next(undefined);
+        }
+    }
+    /**
+   * Whether the activate the view tracking of the current position
+   */
+    set followPosition(value) {
+        this._followPosition = value;
+        this.followPosition$.next(value);
+        if (this.configService?.getConfig('geolocate.followPosition') === false) {
+            this._followPosition = false;
+            this.followPosition$.next(false);
+        }
+        this.handleFeatureCreation(this.position$.value);
+        if (this.storageService && value !== undefined) {
+            this.storageService.set('geolocation.followPosition', value);
+        }
+    }
+    get followPosition() {
+        return this._followPosition;
+    }
+    /**
+     * Add or remove this controller to/from a map.
+     * @param map OL Map
+     */
+    setOlMap(olMap) {
+        super.setOlMap(olMap);
+        this.setupObservers();
+    }
+    deleteGeolocationFeatures() {
+        this.deleteFeatureByType(GeolocationOverlayType.Position);
+        this.deleteFeatureByType(GeolocationOverlayType.Accuracy);
+        this.deleteFeatureByType(GeolocationOverlayType.Buffer);
+    }
+    setupObservers() {
+        this.tracking$.subscribe(tracking => {
+            if (tracking) {
+                this.onPositionChange(true, true);
+            }
+            else {
+                this.deleteGeolocationFeatures();
+            }
+        });
+        this.geolocation = new olGeolocation({
+            // enableHighAccuracy must be set to true to have the heading value.
+            trackingOptions: {
+                enableHighAccuracy: true,
+                maximumAge: 10000,
+                timeout: 600000
+            },
+            projection: this.options.projection,
+        });
+        let tracking = false;
+        this.subscriptions$$.push(this.emissionIntervalSeconds$
+            .pipe(switchMap(value => interval(value * 1000)))
+            .subscribe(() => {
+            if (tracking === this.tracking) {
+                this.onPositionChange(true);
+            }
+            else {
+                tracking = this.tracking;
+                this.onPositionChange(true, true);
+            }
+        }));
+    }
+    updateGeolocationOptions(options) {
+        if (!options) {
+            return;
+        }
+        // todo maybe a dedicated interface for geolocation should be defined instead of putting these inside the mapviewoptions?
+        let tracking = options.geolocate;
+        let followPosition = options.alwaysTracking;
+        if (this.storageService) {
+            const storedTracking = this.storageService.get('geolocation.tracking');
+            if (storedTracking !== null && storedTracking !== undefined) {
+                tracking = storedTracking;
+            }
+            const storedFollowPosition = this.storageService.get('geolocation.followPosition');
+            if (storedFollowPosition !== null && storedFollowPosition !== undefined) {
+                followPosition = storedFollowPosition;
+            }
+        }
+        this.tracking = tracking;
+        this.followPosition = followPosition;
+        this.buffer = options.buffer;
+    }
+    /**
+     * Teardown any observers
+     */
+    teardownObservers() {
+        if (this.subscriptions$$.length) {
+            this.subscriptions$$.map(s => s.unsubscribe());
+        }
+        super.teardownObservers();
+    }
+    /**
+     * Clear the position  history
+     */
+    /*
+    // todo
+    clearPositionsHistory() {
+      this.positions = [];
+    }*/
+    /**
+     * On position change, get the position, show it on the map and record it.
+     * @param emitEvent Map event
+     */
+    onPositionChange(emitEvent = false, zoomTo = false) {
+        if (!this.tracking) {
+            return;
+        }
+        const geolocateProperties = this.geolocation.getProperties();
+        if (geolocateProperties.accuracy > this.accuracyThreshold) {
+            console.warn('Poor geolocation accuracy. No position are stored/shown');
+            this.position$.next(undefined);
+            return;
+        }
+        const position = {
+            position: geolocateProperties.position,
+            projection: this.geolocation.getProjection().getCode(),
+            accuracy: geolocateProperties.accuracy,
+            altitude: geolocateProperties.altitude,
+            altitudeAccuracy: geolocateProperties.altitudeAccuracy,
+            heading: geolocateProperties.heading,
+            speed: geolocateProperties.speed,
+            enableHighAccuracy: geolocateProperties.trackingOptions?.enableHighAccuracy ? true : false,
+            timestamp: new Date()
+        };
+        this.handleFeatureCreation(position, zoomTo);
+        if (emitEvent) {
+            this.position$.next(position);
+            /*if (this.keepPositionHistory === true) {
+              // handle position diff to store only true diff;
+              this.positions.push(position);
+            }*/
+        }
+    }
+    deleteFeatureByType(type) {
+        const featureById = this.geolocationOverlay.dataSource.ol.getFeatureById(type);
+        if (featureById) {
+            this.geolocationOverlay.dataSource.ol.removeFeature(featureById);
+        }
+    }
+    handleFeatureCreation(position, zoomTo = false) {
+        if (!position || !position.position) {
+            return;
+        }
+        this.deleteGeolocationFeatures();
+        const positionGeometry = new Point(position.position);
+        const accuracyGeometry = fromCircle(new OlCircle(position.position, position.accuracy || 0));
+        const positionFeature = new olFeature({ geometry: positionGeometry });
+        const accuracyFeature = new olFeature({ geometry: accuracyGeometry });
+        if (positionGeometry) {
+            let motion = this.followPosition ? FeatureMotion.Move : FeatureMotion.None;
+            if (zoomTo) {
+                motion = FeatureMotion.Zoom;
+            }
+            positionFeature.setId(GeolocationOverlayType.Position);
+            positionFeature.setStyle(this.positionFeatureStyle);
+            this.geolocationOverlay.addOlFeature(positionFeature, motion);
+            if (accuracyGeometry) {
+                accuracyFeature.setId(GeolocationOverlayType.Accuracy);
+                accuracyFeature.setStyle(this.accuracyFeatureStyle);
+                this.geolocationOverlay.addOlFeature(accuracyFeature, motion);
+            }
+            if (this.buffer) {
+                const bufferFeature = new olFeature(new OlCircle(position.position, this.buffer.bufferRadius));
+                const bufferStyle = new olstyle.Style({
+                    stroke: new olstyle.Stroke({ width: 2, color: this.buffer.bufferStroke }),
+                    fill: new olstyle.Fill({ color: this.buffer.bufferFill }),
+                    text: new olstyle.Text({
+                        textAlign: 'left',
+                        offsetX: 10,
+                        offsetY: -10,
+                        font: '12px Calibri,sans-serif',
+                        text: this.buffer.showBufferRadius ? `${this.buffer.bufferRadius}m` : '',
+                        fill: new olstyle.Fill({ color: '#000' }),
+                        stroke: new olstyle.Stroke({ color: '#fff', width: 3 })
+                    })
+                });
+                bufferFeature.setId(GeolocationOverlayType.Buffer);
+                bufferFeature.setStyle(bufferStyle);
+                this.geolocationOverlay.addOlFeature(bufferFeature, motion);
+            }
+        }
+    }
+}
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geolocation.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/map/shared/controllers/geolocation.ts"],"names":[],"mappings":"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","sourcesContent":["import OlMap from 'ol/Map';\nimport olGeolocation from 'ol/Geolocation';\nimport { BehaviorSubject, interval, Subscription } from 'rxjs';\n\nimport * as olproj from 'ol/proj';\nimport olFeature from 'ol/Feature';\nimport { MapController } from './controller';\nimport { Point, Polygon } from 'ol/geom';\nimport { fromCircle } from 'ol/geom/Polygon';\nimport OlCircle from 'ol/geom/Circle';\nimport { IgoMap } from '../map';\nimport * as olstyle from 'ol/style';\nimport { Overlay } from '../../../overlay/shared/overlay';\nimport { FeatureMotion } from '../../../feature/shared/feature.enums';\nimport { StorageService, ConfigService } from '@igo2/core';\nimport { MapViewOptions } from '../map.interface';\nimport { switchMap } from 'rxjs/operators';\nexport interface MapGeolocationControllerOptions {\n  //  todo keepPositionHistory?: boolean;\n  projection: olproj.ProjectionLike\n  accuracyThreshold?: number;\n  followPosition?: boolean;\n  buffer?: GeolocationBuffer;\n}\nexport interface MapGeolocationState {\n  position: number[];\n  projection: string;\n  accuracy: number;\n  altitude: number;\n  altitudeAccuracy: number;\n  heading: number;\n  speed: number;\n  enableHighAccuracy: boolean;\n  timestamp: Date;\n}\nexport interface GeolocationBuffer {\n  bufferRadius?: number;\n  bufferStroke?: [number, number, number, number];\n  bufferFill?: [number, number, number, number];\n  showBufferRadius?: boolean;\n}\n\n\nenum GeolocationOverlayType {\n  Position = 'position',\n  Accuracy = 'accuracy',\n  Buffer= 'buffer'\n}\n\n/**\n * Controller to handle map view interactions\n */\nexport class MapGeolocationController extends MapController {\n\n  private subscriptions$$: Subscription[] = [];\n  private geolocationOverlay: Overlay;\n  private positionFeatureStyle: olstyle.Style | olstyle.Style[] = new olstyle.Style({\n    image: new olstyle.Circle({\n      radius: 6,\n      fill: new olstyle.Fill({\n        color: '#3399CC',\n      }),\n      stroke: new olstyle.Stroke({\n        color: '#fff',\n        width: 2,\n      }),\n    }),\n  });\n  private accuracyFeatureStyle: olstyle.Style | olstyle.Style[] = new olstyle.Style({\n    stroke: new olstyle.Stroke({\n      color: 'rgba(120, 120, 120, 0.4)',\n      width: 1,\n    }),\n    fill: new olstyle.Fill({\n      color: 'rgba(120, 120, 120, 0.4)',\n    }),\n  });\n\n  private geolocation: olGeolocation;\n\n  /**\n   * Observable of the current emission interval of the position. In seconds\n   */\n   public readonly emissionIntervalSeconds$: BehaviorSubject<number> = new BehaviorSubject(5);\n\n  /**\n   * Observable of the current position\n   */\n  public readonly position$ = new BehaviorSubject<MapGeolocationState>(undefined);\n  /**\n   * Observable of the tracking state\n   */\n  public readonly tracking$ = new BehaviorSubject<boolean>(undefined);\n  /**\n   * Observable of the follow position state\n   */\n  public readonly followPosition$ = new BehaviorSubject<boolean>(undefined);\n\n\n  /**\n   * History of positions\n   */\n  // private positions: MapGeolocationState[] = [];\n\n  /**\n   * Whether the geolocate controller should keep the position history\n   */\n  /*\n  // todo: refine this method\n  set keepPositionHistory(value) {\n    this._keepPositionHistory = value;\n  }\n  get keepPositionHistory(): boolean {\n    return this._keepPositionHistory;\n  }\n  private _keepPositionHistory: boolean = this.options && this.options.keepPositionHistory ? this.options.keepPositionHistory : true;\n*/\n  /**\n   * Whether the geolocate should show a buffer around the current position\n   */\n   set buffer(value: GeolocationBuffer) {\n    this._buffer = value;\n    this.handleFeatureCreation(this.position$.value);\n  }\n   get buffer(): GeolocationBuffer {\n    return this._buffer;\n  }\n  private _buffer: GeolocationBuffer = this.options && this.options.buffer ? this.options.buffer : undefined;\n\n  /**\n   * Whether the geolocate controller accuracy threshold to store/show the position.\n   */\n  set accuracyThreshold(value: number) {\n    this._accuracyThreshold = value;\n    this.handleFeatureCreation(this.position$.value);\n  }\n\n  get accuracyThreshold(): number {\n    return this._accuracyThreshold;\n  }\n  private _accuracyThreshold = this.options && this.options.accuracyThreshold ? this.options.accuracyThreshold : 5000;\n\n\n  /**\n   * Whether the activate the geolocation.\n   */\n  get tracking() {\n    return this.geolocation.getTracking();\n  }\n\n  set tracking(value: boolean) {\n    this.geolocation.setTracking(value || false);\n    this.tracking$.next(value);\n    if (this.storageService && value !== undefined) {\n      this.storageService.set('geolocation.tracking', value);\n    }\n    if (!value) {\n      this.position$.next(undefined);\n    }\n  }\n\n    /**\n   * Whether the activate the view tracking of the current position\n   */\n  set followPosition(value: boolean) {\n    this._followPosition = value;\n    this.followPosition$.next(value);\n    if (this.configService?.getConfig('geolocate.followPosition') === false) {\n      this._followPosition = false;\n      this.followPosition$.next(false);\n    }\n    this.handleFeatureCreation(this.position$.value);\n    if (this.storageService && value !== undefined) {\n      this.storageService.set('geolocation.followPosition', value);\n    }\n  }\n\n  get followPosition() {\n    return this._followPosition;\n  }\n\n\n  private _followPosition = this.options && this.options.followPosition ? this.options.followPosition : false;\n\n\n  constructor(\n    private map: IgoMap,\n    private options?: MapGeolocationControllerOptions,\n    private storageService?: StorageService,\n    private configService?: ConfigService) {\n    super();\n    this.geolocationOverlay = new Overlay(this.map);\n  }\n\n  /**\n   * Add or remove this controller to/from a map.\n   * @param map OL Map\n   */\n  setOlMap(olMap: OlMap | undefined) {\n    super.setOlMap(olMap);\n    this.setupObservers();\n  }\n\n  private deleteGeolocationFeatures() {\n    this.deleteFeatureByType(GeolocationOverlayType.Position);\n    this.deleteFeatureByType(GeolocationOverlayType.Accuracy);\n    this.deleteFeatureByType(GeolocationOverlayType.Buffer);\n  }\n\n  setupObservers() {\n    this.tracking$.subscribe(tracking => {\n      if (tracking) {\n        this.onPositionChange(true, true);\n      } else {\n        this.deleteGeolocationFeatures();\n      }\n    });\n\n    this.geolocation = new olGeolocation({\n      // enableHighAccuracy must be set to true to have the heading value.\n      trackingOptions: {\n        enableHighAccuracy: true,\n        maximumAge: 10000,\n        timeout: 600000\n      },\n      projection: this.options.projection,\n    });\n    let tracking = false;\n    this.subscriptions$$.push(this.emissionIntervalSeconds$\n      .pipe(switchMap(value => interval(value * 1000)))\n      .subscribe(() => {\n        if (tracking === this.tracking) {\n          this.onPositionChange(true);\n        } else {\n          tracking = this.tracking;\n          this.onPositionChange(true, true);\n        }\n      }));\n  }\n\n  public updateGeolocationOptions(options: MapViewOptions) {\n    if (!options) { return;}\n    // todo maybe a dedicated interface for geolocation should be defined instead of putting these inside the mapviewoptions?\n    let tracking = options.geolocate;\n    let followPosition = options.alwaysTracking;\n    if (this.storageService) {\n      const storedTracking = this.storageService.get('geolocation.tracking') as boolean;\n      if (storedTracking !== null && storedTracking !== undefined) {\n        tracking = storedTracking;\n      }\n\n      const storedFollowPosition = this.storageService.get('geolocation.followPosition') as boolean;\n      if (storedFollowPosition !== null && storedFollowPosition !== undefined) {\n        followPosition = storedFollowPosition;\n      }\n    }\n    this.tracking = tracking;\n    this.followPosition = followPosition;\n    this.buffer = options.buffer;\n  }\n\n  /**\n   * Teardown any observers\n   */\n  teardownObservers() {\n    if (this.subscriptions$$.length) {\n      this.subscriptions$$.map(s => s.unsubscribe());\n    }\n    super.teardownObservers();\n  }\n\n  /**\n   * Clear the position  history\n   */\n  /*\n  // todo\n  clearPositionsHistory() {\n    this.positions = [];\n  }*/\n\n  /**\n   * On position change, get the position, show it on the map and record it.\n   * @param emitEvent Map event\n   */\n  private onPositionChange(emitEvent: boolean = false, zoomTo: boolean = false) {\n    if (!this.tracking) {\n      return;\n    }\n    const geolocateProperties = this.geolocation.getProperties();\n\n    if (geolocateProperties.accuracy > this.accuracyThreshold) {\n      console.warn('Poor geolocation accuracy. No position are stored/shown');\n      this.position$.next(undefined);\n      return;\n    }\n\n    const position: MapGeolocationState = {\n      position: geolocateProperties.position,\n      projection: this.geolocation.getProjection().getCode(),\n      accuracy: geolocateProperties.accuracy,\n      altitude: geolocateProperties.altitude,\n      altitudeAccuracy: geolocateProperties.altitudeAccuracy,\n      heading: geolocateProperties.heading,\n      speed: geolocateProperties.speed,\n      enableHighAccuracy: geolocateProperties.trackingOptions?.enableHighAccuracy ? true : false,\n      timestamp: new Date()\n    };\n    this.handleFeatureCreation(position, zoomTo);\n    if (emitEvent) {\n      this.position$.next(position);\n      /*if (this.keepPositionHistory === true) {\n        // handle position diff to store only true diff;\n        this.positions.push(position);\n      }*/\n    }\n  }\n\n  private deleteFeatureByType(type: GeolocationOverlayType) {\n    const featureById = this.geolocationOverlay.dataSource.ol.getFeatureById(type);\n    if (featureById) {\n      this.geolocationOverlay.dataSource.ol.removeFeature(featureById);\n    }\n\n  }\n\n  private handleFeatureCreation(position: MapGeolocationState, zoomTo: boolean = false) {\n    if (!position || !position.position) {\n      return;\n    }\n    this.deleteGeolocationFeatures();\n    const positionGeometry = new Point(position.position);\n    const accuracyGeometry = fromCircle(new OlCircle(position.position, position.accuracy || 0));\n\n    const positionFeature = new olFeature<Point>({ geometry: positionGeometry });\n    const accuracyFeature = new olFeature<Polygon>({ geometry: accuracyGeometry });\n\n    if (positionGeometry) {\n      let motion = this.followPosition ? FeatureMotion.Move : FeatureMotion.None;\n      if (zoomTo) {\n        motion = FeatureMotion.Zoom;\n      }\n      positionFeature.setId(GeolocationOverlayType.Position);\n      positionFeature.setStyle(this.positionFeatureStyle);\n      this.geolocationOverlay.addOlFeature(positionFeature, motion);\n      if (accuracyGeometry) {\n        accuracyFeature.setId(GeolocationOverlayType.Accuracy);\n        accuracyFeature.setStyle(this.accuracyFeatureStyle);\n        this.geolocationOverlay.addOlFeature(accuracyFeature, motion);\n      }\n      if (this.buffer) {\n        const bufferFeature = new olFeature(new OlCircle(position.position, this.buffer.bufferRadius));\n        const bufferStyle = new olstyle.Style({\n          stroke: new olstyle.Stroke({ width: 2, color: this.buffer.bufferStroke }),\n          fill: new olstyle.Fill({ color: this.buffer.bufferFill }),\n          text: new olstyle.Text({\n            textAlign: 'left',\n            offsetX: 10,\n            offsetY: -10,\n            font: '12px Calibri,sans-serif',\n            text: this.buffer.showBufferRadius ? `${this.buffer.bufferRadius}m` : '',\n            fill: new olstyle.Fill({ color: '#000' }),\n            stroke: new olstyle.Stroke({ color: '#fff', width: 3 })\n          })\n        });\n        bufferFeature.setId(GeolocationOverlayType.Buffer);\n        bufferFeature.setStyle(bufferStyle);\n        this.geolocationOverlay.addOlFeature(bufferFeature, motion);\n      }\n\n    }\n\n  }\n}\n"]}