@maplibre/maplibre-react-native 8.6.0-beta.0

package/javascript/index.js

@@ -0,0 +1,153 @@
+import {isAndroid} from './utils';
+import MapView from './components/MapView';
+import Light from './components/Light';
+import PointAnnotation from './components/PointAnnotation';
+import Annotation from './components/annotations/Annotation';
+import Callout from './components/Callout';
+import UserLocation from './components/UserLocation';
+import Camera from './components/Camera';
+import VectorSource from './components/VectorSource';
+import ShapeSource from './components/ShapeSource';
+import RasterSource from './components/RasterSource';
+import ImageSource from './components/ImageSource';
+import Images from './components/Images';
+import FillLayer from './components/FillLayer';
+import FillExtrusionLayer from './components/FillExtrusionLayer';
+import HeatmapLayer from './components/HeatmapLayer';
+import LineLayer from './components/LineLayer';
+import CircleLayer from './components/CircleLayer';
+import SymbolLayer from './components/SymbolLayer';
+import RasterLayer from './components/RasterLayer';
+import BackgroundLayer from './components/BackgroundLayer';
+import locationManager from './modules/location/locationManager';
+import offlineManager from './modules/offline/offlineManager';
+import snapshotManager from './modules/snapshot/snapshotManager';
+import MarkerView from './components/MarkerView';
+import Animated from './utils/animated/Animated';
+import AnimatedMapPoint from './utils/animated/AnimatedPoint';
+import AnimatedShape from './utils/animated/AnimatedShape';
+import AnimatedCoordinatesArray from './utils/animated/AnimatedCoordinatesArray';
+import AnimatedExtractCoordinateFromArray from './utils/animated/AnimatedExtractCoordinateFromArray';
+import AnimatedRouteCoordinatesArray from './utils/animated/AnimatedRouteCoordinatesArray';
+import Style from './components/Style';
+import Logger from './utils/Logger';
+
+import {
+  Animated as RNAnimated,
+  NativeModules,
+  PermissionsAndroid,
+} from 'react-native';
+
+const MapboxGL = {...NativeModules.MGLModule};
+
+// static methods
+MapboxGL.requestAndroidLocationPermissions = async function () {
+  if (isAndroid()) {
+    const res = await PermissionsAndroid.requestMultiple([
+      PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+      PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
+    ]);
+
+    if (!res) {
+      return false;
+    }
+
+    const permissions = Object.keys(res);
+    for (const permission of permissions) {
+      if (res[permission] === PermissionsAndroid.RESULTS.GRANTED) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  throw new Error('You should only call this method on Android!');
+};
+
+MapboxGL.UserTrackingModes = Camera.UserTrackingModes;
+
+// components
+MapboxGL.MapView = MapView;
+MapboxGL.Light = Light;
+MapboxGL.PointAnnotation = PointAnnotation;
+MapboxGL.Callout = Callout;
+MapboxGL.UserLocation = UserLocation;
+MapboxGL.Camera = Camera;
+MapboxGL.Style = Style;
+
+// annotations
+MapboxGL.Annotation = Annotation;
+MapboxGL.MarkerView = MarkerView;
+
+// sources
+MapboxGL.VectorSource = VectorSource;
+MapboxGL.ShapeSource = ShapeSource;
+MapboxGL.RasterSource = RasterSource;
+MapboxGL.ImageSource = ImageSource;
+MapboxGL.Images = Images;
+
+// layers
+MapboxGL.FillLayer = FillLayer;
+MapboxGL.FillExtrusionLayer = FillExtrusionLayer;
+MapboxGL.HeatmapLayer = HeatmapLayer;
+MapboxGL.LineLayer = LineLayer;
+MapboxGL.CircleLayer = CircleLayer;
+MapboxGL.SymbolLayer = SymbolLayer;
+MapboxGL.RasterLayer = RasterLayer;
+MapboxGL.BackgroundLayer = BackgroundLayer;
+
+// modules
+MapboxGL.locationManager = locationManager;
+MapboxGL.offlineManager = offlineManager;
+MapboxGL.snapshotManager = snapshotManager;
+
+// animated
+MapboxGL.Animated = Animated;
+
+// utils
+MapboxGL.AnimatedPoint = AnimatedMapPoint;
+MapboxGL.AnimatedCoordinatesArray = AnimatedCoordinatesArray;
+MapboxGL.AnimatedExtractCoordinateFromArray =
+  AnimatedExtractCoordinateFromArray;
+MapboxGL.AnimatedRouteCoordinatesArray = AnimatedRouteCoordinatesArray;
+MapboxGL.AnimatedShape = AnimatedShape;
+MapboxGL.Logger = Logger;
+
+const {LineJoin} = MapboxGL;
+
+export {
+  MapView,
+  Light,
+  PointAnnotation,
+  Callout,
+  UserLocation,
+  Camera,
+  Annotation,
+  MarkerView,
+  VectorSource,
+  ShapeSource,
+  RasterSource,
+  ImageSource,
+  Images,
+  FillLayer,
+  FillExtrusionLayer,
+  HeatmapLayer,
+  LineLayer,
+  CircleLayer,
+  SymbolLayer,
+  RasterLayer,
+  BackgroundLayer,
+  locationManager,
+  offlineManager,
+  snapshotManager,
+  AnimatedMapPoint,
+  AnimatedCoordinatesArray,
+  AnimatedShape,
+  Animated,
+  LineJoin,
+  Logger,
+  Style,
+};
+
+export default MapboxGL;

package/javascript/modules/location/locationManager.js

@@ -0,0 +1,101 @@
+import {NativeModules, NativeEventEmitter} from 'react-native';
+
+const MapboxGL = NativeModules.MGLModule;
+const MapboxGLLocationManager = NativeModules.MGLLocationModule;
+
+export const LocationModuleEventEmitter = new NativeEventEmitter(
+  MapboxGLLocationManager,
+);
+
+class LocationManager {
+  constructor() {
+    this._listeners = [];
+    this._lastKnownLocation = null;
+    this._isListening = false;
+    this.onUpdate = this.onUpdate.bind(this);
+    this.subscription = null;
+  }
+
+  async getLastKnownLocation() {
+    if (!this._lastKnownLocation) {
+      let lastKnownLocation;
+
+      // as location can be brittle it might happen,
+      // that we get an exception from native land
+      // let's silently catch it and simply log out
+      // instead of throwing an exception
+      try {
+        lastKnownLocation =
+          await MapboxGLLocationManager.getLastKnownLocation();
+      } catch (error) {
+        console.log('locationManager Error: ', error);
+      }
+
+      if (!this._lastKnownLocation && lastKnownLocation) {
+        this._lastKnownLocation = lastKnownLocation;
+      }
+    }
+
+    return this._lastKnownLocation;
+  }
+
+  addListener(listener) {
+    if (!this._isListening) {
+      this.start();
+    }
+    if (!this._listeners.includes(listener)) {
+      this._listeners.push(listener);
+
+      if (this._lastKnownLocation) {
+        listener(this._lastKnownLocation);
+      }
+    }
+  }
+
+  removeListener(listener) {
+    this._listeners = this._listeners.filter(l => l !== listener);
+    if (this._listeners.length === 0) {
+      this.stop();
+    }
+  }
+
+  removeAllListeners() {
+    this._listeners = [];
+    this.stop();
+  }
+
+  start(displacement = 0) {
+    if (!this._isListening) {
+      MapboxGLLocationManager.start(displacement);
+
+      this.subscription = LocationModuleEventEmitter.addListener(
+        MapboxGL.LocationCallbackName.Update,
+        this.onUpdate,
+      );
+
+      this._isListening = true;
+    }
+  }
+
+  stop() {
+    MapboxGLLocationManager.stop();
+
+    if (this._isListening) {
+      this.subscription.remove();
+    }
+
+    this._isListening = false;
+  }
+
+  setMinDisplacement(minDisplacement) {
+    MapboxGLLocationManager.setMinDisplacement(minDisplacement);
+  }
+
+  onUpdate(location) {
+    this._lastKnownLocation = location;
+
+    this._listeners.forEach(l => l(location));
+  }
+}
+
+export default new LocationManager();

package/javascript/modules/offline/OfflineCreatePackOptions.js

@@ -0,0 +1,46 @@
+import {makeLatLngBounds} from '../../utils/geoUtils';
+import {toJSONString} from '../../utils';
+
+class OfflineCreatePackOptions {
+  constructor(options = {}) {
+    this._assert(options);
+
+    this.name = options.name;
+    this.styleURL = options.styleURL;
+    this.bounds = this._makeLatLngBounds(options.bounds);
+    this.minZoom = options.minZoom;
+    this.maxZoom = options.maxZoom;
+    this.metadata = this._makeMetadata(options.metadata);
+  }
+
+  _assert(options) {
+    if (!options.styleURL) {
+      throw new Error(
+        'Style URL must be provided for creating an offline pack',
+      );
+    }
+
+    if (!options.name) {
+      throw new Error('Name must be provided for creating an offline pack');
+    }
+
+    if (!options.bounds) {
+      throw new Error('Bounds must be provided for creating an offline pack');
+    }
+  }
+
+  _makeLatLngBounds(bounds) {
+    const ne = bounds[0];
+    const sw = bounds[1];
+    return toJSONString(makeLatLngBounds(ne, sw));
+  }
+
+  _makeMetadata(metadata) {
+    return JSON.stringify({
+      ...metadata,
+      name: this.name,
+    });
+  }
+}
+
+export default OfflineCreatePackOptions;

package/javascript/modules/offline/OfflinePack.js

@@ -0,0 +1,40 @@
+import {NativeModules} from 'react-native';
+
+const MapboxGLOfflineManager = NativeModules.MGLOfflineModule;
+
+class OfflinePack {
+  constructor(pack) {
+    this.pack = pack;
+    this._metadata = null;
+  }
+
+  get name() {
+    const {metadata} = this;
+    return metadata && metadata.name;
+  }
+
+  get bounds() {
+    return this.pack.bounds;
+  }
+
+  get metadata() {
+    if (!this._metadata && this.pack.metadata) {
+      this._metadata = JSON.parse(this.pack.metadata);
+    }
+    return this._metadata;
+  }
+
+  status() {
+    return MapboxGLOfflineManager.getPackStatus(this.name);
+  }
+
+  resume() {
+    return MapboxGLOfflineManager.resumePackDownload(this.name);
+  }
+
+  pause() {
+    return MapboxGLOfflineManager.pausePackDownload(this.name);
+  }
+}
+
+export default OfflinePack;