@rnmapbox/maps 10.0.0-beta.78 → 10.0.0-beta.80

package/android/rctmgl/build.gradle

@@ -1,4 +1,5 @@
 def defaultMapboxMapsImpl = "maplibre"
+def defaultMapboxMapsVersion = "10.11.2"
 
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
@@ -8,6 +9,10 @@ def safeExtGet(prop, fallback) {
 if (rootProject.ext.has('expoRNMapboxMapsImpl')) {
     rootProject.ext.set('RNMapboxMapsImpl', rootProject.ext.get('expoRNMapboxMapsImpl'))
 }
+if (rootProject.ext.has('expoRNMapboxMapsVersion')) {
+    rootProject.ext.set('RNMapboxMapsVersion', rootProject.ext.get('expoRNMapboxMapsVersion'))
+}
+
 
 buildscript {
   repositories {
@@ -28,6 +33,7 @@ if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "mapbox") {
 
 android {
     if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "maplibre") {
+        logger.warn('@rnmapbox/maps: Maplibre implementation is DEPRECATED and will be removed, set RNMapboxMapsImpl to mapbox- see https://github.com/rnmapbox/maps/wiki/Deprecated-RNMapboxImpl-Maplibre#android')
         sourceSets {
             main {
                 java.srcDirs = ['src/main/java-mapboxgl/common','src/main/java-mapboxgl/maplibre']
@@ -35,6 +41,7 @@ android {
         }
     }
     else if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "mapbox-gl") {
+        logger.warn('@rnmapbox/maps: Maplibre implementation is DEPRECATED and will be removed, set RNMapboxMapsImpl to mapbox  - see https://github.com/rnmapbox/maps/wiki/Deprecated-RNMapboxImpl-Maplibre#android')
         sourceSets {
             main {
                 java.srcDirs = ['src/main/java-mapboxgl/common','src/main/java-mapboxgl/mapbox']
@@ -130,7 +137,7 @@ dependencies {
             implementation 'com.mapbox.mapboxsdk:mapbox-sdk-turf:5.1.0'
         }
         else if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "mapbox") {
-            implementation 'com.mapbox.maps:android:10.11.1'
+            implementation "com.mapbox.maps:android:${safeExtGet("RNMapboxMapsVersion", defaultMapboxMapsVersion)}"
             implementation 'com.mapbox.mapboxsdk:mapbox-sdk-turf:6.10.0'
             implementation 'androidx.asynclayoutinflater:asynclayoutinflater:1.0.0'
         }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/camera/RCTMGLCamera.kt

@@ -78,7 +78,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
 
         override fun onAnimationCancel(animator: Animator) {
             if (!hasSentFirstRegion) {
-                mMapView!!.sendRegionChangeEvent(false)
+                mMapView?.sendRegionChangeEvent(false)
                 hasSentFirstRegion = true
             }
         }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapView.kt

@@ -66,10 +66,7 @@ import com.mapbox.rctmgl.events.IEvent
 import com.mapbox.rctmgl.events.MapChangeEvent
 import com.mapbox.rctmgl.events.MapClickEvent
 import com.mapbox.rctmgl.events.constants.EventTypes
-import com.mapbox.rctmgl.utils.BitmapUtils
-import com.mapbox.rctmgl.utils.GeoJSONUtils
-import com.mapbox.rctmgl.utils.LatLng
-import com.mapbox.rctmgl.utils.Logger
+import com.mapbox.rctmgl.utils.*
 import com.mapbox.rctmgl.utils.extensions.toReadableArray
 import org.json.JSONException
 import org.json.JSONObject
@@ -178,7 +175,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
 
     private var styleLoaded = false
 
-    private val mHandledMapChangedEvents: HashSet<String>? = null
+    private var mHandledMapChangedEvents: HashSet<String>? = null
     private var mAnnotationClicked = false
     private var mAnnotationDragged = false
     private var mLocationComponentManager: LocationComponentManager? = null
@@ -267,10 +264,12 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
 
         map.addOnCameraChangeListener(OnCameraChangeListener { cameraChangedEventData ->
             handleMapChangedEvent(EventTypes.REGION_IS_CHANGING)
+            handleMapChangedEvent(EventTypes.CAMERA_CHANGED)
         })
 
         map.addOnMapIdleListener(OnMapIdleListener { mapIdleEventData ->
             sendRegionDidChangeEvent()
+            handleMapChangedEvent(EventTypes.MAP_IDLE);
         })
 
         val gesturesPlugin: GesturesPlugin = this.gestures
@@ -426,9 +425,9 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     // endregion
 
     fun sendRegionChangeEvent(isAnimated: Boolean) {
-        val event: IEvent = MapChangeEvent(this, EventTypes.REGION_DID_CHANGE,
+        val didChangeEvent = MapChangeEvent(this, EventTypes.REGION_DID_CHANGE,
                 makeRegionPayload(isAnimated))
-        mManager.handleEvent(event)
+        mManager.handleEvent(didChangeEvent)
         mCameraChangeTracker.setReason(CameraChangeReason.NONE)
     }
 
@@ -719,6 +718,8 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         waiters.add(callback)
     }
 
+    // region Events
+
     fun sendRegionDidChangeEvent() {
         handleMapChangedEvent(EventTypes.REGION_DID_CHANGE)
         mCameraChangeTracker.setReason(CameraChangeReason.NONE)
@@ -726,16 +727,52 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
 
     private fun handleMapChangedEvent(eventType: String) {
         if (!canHandleEvent(eventType)) return
+
         val event: IEvent
         event = when (eventType) {
             EventTypes.REGION_WILL_CHANGE, EventTypes.REGION_DID_CHANGE, EventTypes.REGION_IS_CHANGING -> MapChangeEvent(this, eventType, makeRegionPayload(null))
+            EventTypes.CAMERA_CHANGED, EventTypes.MAP_IDLE -> MapChangeEvent(this, eventType, makeCameraPayload())
             else -> MapChangeEvent(this, eventType)
         }
         mManager.handleEvent(event)
     }
 
+    fun setHandledMapChangedEvents(events: Array<String>) {
+        mHandledMapChangedEvents = HashSet<String>(events.asList())
+    }
+
     private fun canHandleEvent(event: String): Boolean {
-        return mHandledMapChangedEvents == null || mHandledMapChangedEvents.contains(event)
+        val changedEvents = mHandledMapChangedEvents
+        return changedEvents == null || changedEvents.contains(event)
+    }
+
+    private fun makeCameraPayload(): WritableMap {
+        val position = mMap?.cameraState ?: return WritableNativeMap()
+        val properties = WritableNativeMap()
+        properties.putDouble("zoom", position.zoom)
+        properties.putDouble("heading", position.bearing)
+        properties.putDouble("pitch", position.pitch)
+        properties.putArray("center", position.center.toReadableArray())
+        try {
+            val bounds = mMap.coordinateBoundsForCamera(position.toCameraOptions())
+
+            val boundsMap = WritableNativeMap()
+            boundsMap.putArray("ne", bounds.northeast.toReadableArray())
+            boundsMap.putArray("sw", bounds.southwest.toReadableArray())
+            
+            properties.putMap("bounds", boundsMap)
+        } catch (ex: Exception) {
+            Logger.e(LOG_TAG, "An error occurred while attempting to make the region", ex)
+        }
+        val gestures = WritableNativeMap()
+        gestures.putBoolean("isGestureActive", mCameraChangeTracker.isUserInteraction)
+        // gestures.putBoolean("isAnimatingFromGesture", if (null == isAnimated) mCameraChangeTracker.isAnimated else isAnimated)
+
+        val state: WritableMap = WritableNativeMap()
+        state.putMap("properties", properties)
+        state.putMap("gestures", gestures)
+
+        return state
     }
 
     private fun makeRegionPayload(isAnimated: Boolean?): WritableMap {
@@ -757,6 +794,8 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         return GeoJSONUtils.toPointFeature(latLng, properties)
     }
 
+    // endregion
+
     /**
      * Adds the marker image to the map for use as a SymbolLayer icon
      */
@@ -1271,6 +1310,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         super.onAttachedToWindow()
     }
 
+
     // endregion
 }
 

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapViewManager.kt

@@ -23,6 +23,19 @@ import com.mapbox.rctmgl.utils.extensions.toScreenCoordinate
 import java.lang.Exception
 import java.util.HashMap
 
+fun ReadableArray.forEachString(action: (String) -> Unit) {
+    for (i in 0 until size()) {
+        action(getString(i))
+    }
+}
+
+fun ReadableArray.asArrayString(): Array<String> {
+    val result = Array<String>(size()) {
+        getString(it)
+    }
+    return result
+}
+
 open class RCTMGLMapViewManager(context: ReactApplicationContext?) :
     AbstractEventEmitter<RCTMGLMapView?>(context) {
     private val mViews: MutableMap<Int, RCTMGLMapView>
@@ -295,6 +308,11 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext?) :
             METHOD_TAKE_SNAP -> {
                 mapView.takeSnap(args!!.getString(0), args!!.getBoolean(1))
             }
+            METHOD_SET_HANDLED_MAP_EVENTS -> {
+                args?.let {
+                    mapView.setHandledMapChangedEvents(args.asArrayString());
+                }
+            }
         }
         /*
         switch (commandID) {

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/events/constants/EventTypes.java

@@ -7,10 +7,14 @@ public class EventTypes {
     public static final String MAP_USER_TRACKING_MODE_CHANGE = "usertrackingmodechange";
 
     public static final String REGION_WILL_CHANGE = "regionwillchange";
-    public static final String REGION_IS_CHANGING = "regionischanging";
+    public static final String REGION_IS_CHANGING = "regionischanging"; // deprecated
+    public static final String CAMERA_CHANGED = "camerachanged";
     public static final String REGION_DID_CHANGE  = "regiondidchange";
+    public static final String MAP_IDLE = "mapidle";
     public static final String USER_LOCATION_UPDATED = "userlocationdupdated";
 
+
+
     public static final String WILL_START_LOADING_MAP = "willstartloadingmap";
     public static final String DID_FINISH_LOADING_MAP = "didfinishloadingmap";
     public static final String DID_FAIL_LOADING_MAP = "didfailloadingmap";

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/modules/RCTMGLModule.kt

@@ -52,8 +52,10 @@ class RCTMGLModule(private val mReactContext: ReactApplicationContext) : ReactCo
         eventTypes["MapClick"] = EventTypes.MAP_CLICK
         eventTypes["MapLongClick"] = EventTypes.MAP_LONG_CLICK
         eventTypes["RegionWillChange"] = EventTypes.REGION_WILL_CHANGE
-        eventTypes["RegionIsChanging"] = EventTypes.REGION_IS_CHANGING
-        eventTypes["RegionDidChange"] = EventTypes.REGION_DID_CHANGE
+        eventTypes["RegionIsChanging"] = EventTypes.REGION_IS_CHANGING // deprecated
+        eventTypes["CameraChanged"] = EventTypes.CAMERA_CHANGED
+        eventTypes["RegionDidChange"] = EventTypes.REGION_DID_CHANGE // deprecated
+        eventTypes["MapIdle"] = EventTypes.MAP_IDLE
         eventTypes["UserLocationUpdated"] = EventTypes.USER_LOCATION_UPDATED
         eventTypes["WillStartLoadingMap"] = EventTypes.WILL_START_LOADING_MAP
         eventTypes["DidFinishLoadingMap"] = EventTypes.DID_FINISH_LOADING_MAP

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/GeoJSONUtils.kt

@@ -10,8 +10,11 @@ import com.mapbox.maps.CameraBounds
 import com.mapbox.rctmgl.utils.LatLngBounds
 import com.mapbox.turf.TurfMeasurement
 import com.mapbox.rctmgl.utils.LatLngQuad
+import com.mapbox.rctmgl.utils.extensions.toReadableArray
 import java.util.ArrayList
 
+
+
 object GeoJSONUtils {
     @JvmStatic
     fun fromFeature(feature: Feature): WritableMap {
@@ -78,7 +81,7 @@ object GeoJSONUtils {
     }
 
     private fun coordinatesL(points: List<Point>): WritableArray {
-        return fromList(points.map { coordinates(it) })
+        return fromList(points.map { it.toReadableArray() })
     }
 
     private fun coordinatesLL(points: List<List<Point>>): WritableArray {

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/extensions/Point.kt

@@ -10,4 +10,8 @@ fun Point.toReadableArray() : ReadableArray {
     array.pushDouble(this.longitude())
     array.pushDouble(this.latitude())
     return array
-}
+}
+
+fun Point.toDoubleArray() : DoubleArray {
+    return doubleArrayOf(this.longitude(), this.latitude())
+}

package/ios/RCTMGL-v10/RCTMGLCamera.swift

@@ -217,7 +217,7 @@ class RCTMGLCamera : RCTMGLMapComponentBase {
     }
   }
   
-  func _disableUsetTracking(_ map: MapView) {
+  func _disableUserTracking(_ map: MapView) {
     map.viewport.idle()
   }
   
@@ -263,12 +263,12 @@ class RCTMGLCamera : RCTMGLMapComponentBase {
       let userTrackingMode = UserTrackingMode(rawValue: self.followUserMode ?? UserTrackingMode.normal.rawValue)
       guard let userTrackingMode = userTrackingMode else {
         Logger.error("RCTMGLCamera: Unexpected followUserMode \(optional: self.followUserMode)")
-        self._disableUsetTracking(map)
+        self._disableUserTracking(map)
         return
       }
 
       guard self.followUserLocation && userTrackingMode != .none else {
-        self._disableUsetTracking(map)
+        self._disableUserTracking(map)
         return
       }
 

package/ios/RCTMGL-v10/RCTMGLInteractiveElement.swift

@@ -2,7 +2,6 @@ import MapboxMaps
 
 @objc
 class RCTMGLInteractiveElement : UIView, RCTMGLMapComponent {
-
   weak var map : RCTMGLMapView? = nil
 
   static let hitboxDefault = 44.0
@@ -48,6 +47,9 @@ class RCTMGLInteractiveElement : UIView, RCTMGLMapComponent {
   
   // MARK: - RCTMGLMapComponent
   func addToMap(_ map: RCTMGLMapView, style: Style) {
+    if (self.id == nil) {
+      Logger.log(level: .error, message: "id is required on \(self) but not specified")
+    }
     self.map = map
   }
 

package/ios/RCTMGL-v10/RCTMGLLocationModule.swift

@@ -38,31 +38,50 @@ internal class EmptyLocationProviderDelegate: LocationProviderDelegate {
     func locationProviderDidChangeAuthorization(_ provider: LocationProvider) {}
 }
 
-protocol RCTMGLLocationManagerDelegate : AnyObject {
-  func locationManager(_ locationManager: RCTMGLLocationManager, didUpdateLocation: RCTMGLLocation)
+protocol LocationProviderRCTMGLDelegate : AnyObject {
+  func locationManager(_ locationManager: LocationProviderRCTMGL, didUpdateLocation: RCTMGLLocation)
 }
 
-class RCTMGLLocationManager : LocationProviderDelegate {
+/// LocationProviderRCTMGL listens to updates from a locationProvider and implements the LocationProvider interface itself
+/// So it can be source of both updates to Mapbox mapView.location, and camera location updates as well as source to updates
+/// to RCTMGLLocationModules.
+class LocationProviderRCTMGL : LocationProviderDelegate {
   enum LocationUpdateType {
     case heading
     case location
   }
-
+  
   var provider: LocationProvider
   
   var lastKnownLocation : CLLocation?
   var lastKnownHeading : CLHeading?
   var shouldRequestAlwaysAuthorization: Bool?
   
-  weak var delegate: RCTMGLLocationManagerDelegate?
+  weak var delegate: LocationProviderRCTMGLDelegate?
   weak var locationProviderDelage: LocationProviderDelegate?
   
   var headingSimulator: Timer? = nil
   var simulatedHeading: Double = 0.0
   var simulatedHeadingIncrement: Double = 1.0
+  
+  
+  struct Status {
+    var provider = (updatingLocation: false, updatingHeading: false)
+    var rctmglModule = false
+    
+    var shouldUpdateLocation: Bool {
+      return provider.updatingLocation || rctmglModule
+    }
+    var shouldUpdateHeading: Bool {
+      return provider.updatingHeading || rctmglModule
+    }
+  }
 
-  var startUpdatingLocationCalled = false
-  var startUpdatingHeadingCalled = false
+  var started = Status(provider: (updatingLocation: false, updatingHeading: false), rctmglModule: false) {
+    didSet {
+      _syncStarted(oldValue: oldValue, started: started)
+    }
+  }
 
   init() {
     provider = AppleLocationProvider()
@@ -84,23 +103,36 @@ class RCTMGLLocationManager : LocationProviderDelegate {
       provider.requestAlwaysAuthorization()
     }
     provider.requestWhenInUseAuthorization()
-    provider.setDelegate(self)
-    provider.startUpdatingHeading()
-    provider.startUpdatingLocation()
+    started.rctmglModule = true
   }
   
   func stop() {
-    if !startUpdatingHeadingCalled {
-      provider.stopUpdatingHeading()
+    started.rctmglModule = false
+  }
+
+  func _syncStarted(oldValue: Status, started: Status) {
+    var stoppedSomething = false
+    if (oldValue.shouldUpdateLocation != started.shouldUpdateLocation) {
+      if started.shouldUpdateLocation {
+        provider.setDelegate(self)
+        provider.startUpdatingLocation()
+      } else {
+        provider.stopUpdatingLocation()
+        stoppedSomething = true
+      }
     }
-    if !startUpdatingLocationCalled {
-      provider.stopUpdatingLocation()
+    
+    if (oldValue.shouldUpdateHeading != started.shouldUpdateHeading) {
+      if started.shouldUpdateHeading {
+        provider.setDelegate(self)
+        provider.startUpdatingHeading()
+      } else {
+        provider.stopUpdatingHeading()
+        stoppedSomething = true
+      }
     }
-    _clearProviderDelegateIfNotListening()
-  }
-
-  func _clearProviderDelegateIfNotListening() {
-    if !startUpdatingHeadingCalled && !startUpdatingLocationCalled {
+    
+    if stoppedSomething && !started.shouldUpdateLocation && !started.shouldUpdateHeading {
       provider.setDelegate(EmptyLocationProviderDelegate())
     }
   }
@@ -159,7 +191,7 @@ class RCTMGLLocationManager : LocationProviderDelegate {
 
 // MARK: LocationProvider
 
-extension RCTMGLLocationManager: LocationProvider {
+extension LocationProviderRCTMGL: LocationProvider {
   var locationProviderOptions: LocationOptions {
     get {
       provider.locationProviderOptions
@@ -209,15 +241,11 @@ extension RCTMGLLocationManager: LocationProvider {
   }
   
   func startUpdatingLocation() {
-    startUpdatingLocationCalled = true
-    provider.startUpdatingLocation()
+    started.provider.updatingLocation = true
   }
   
   func stopUpdatingLocation() {
-    provider.stopUpdatingLocation()
-    startUpdatingLocationCalled = false
-
-    _clearProviderDelegateIfNotListening()
+    started.provider.updatingLocation = false
   }
   
   var headingOrientation: CLDeviceOrientation {
@@ -230,15 +258,11 @@ extension RCTMGLLocationManager: LocationProvider {
   }
   
   func startUpdatingHeading() {
-    startUpdatingHeadingCalled = true
-    provider.startUpdatingHeading()
+    started.provider.updatingHeading = true
   }
   
   func stopUpdatingHeading() {
-    startUpdatingHeadingCalled = false
-    provider.stopUpdatingHeading()
-
-    _clearProviderDelegateIfNotListening()
+    started.provider.updatingHeading = false
   }
   
   func dismissHeadingCalibrationDisplay() {
@@ -273,7 +297,7 @@ final public class SimulatedHeading: CLHeading {
     }
 }
 
-extension RCTMGLLocationManager {
+extension LocationProviderRCTMGL {
   func simulateHeading(changesPerSecond: Int, increment: Double) {
     self.simulatedHeadingIncrement = increment
     DispatchQueue.main.async {
@@ -294,18 +318,18 @@ extension RCTMGLLocationManager {
   }
 }
 
-
+// LocationModule is a sigleton class
 @objc(RCTMGLLocationModule)
-class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
+class RCTMGLLocationModule: RCTEventEmitter, LocationProviderRCTMGLDelegate {
 
   static weak var shared : RCTMGLLocationModule? = nil
 
-  var locationManager : RCTMGLLocationManager
+  var locationProviderRCTMGL : LocationProviderRCTMGL
   var hasListener = false
   
   var locationProvider : LocationProvider {
     get {
-      return locationManager
+      return locationProviderRCTMGL
     }
   }
   
@@ -318,9 +342,9 @@ class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
   )
 
   override init() {
-    locationManager = RCTMGLLocationManager()
+    locationProviderRCTMGL = LocationProviderRCTMGL()
     super.init()
-    locationManager.delegate = self
+    locationProviderRCTMGL.delegate = self
     RCTMGLLocationModule.shared = self
   }
   
@@ -340,12 +364,12 @@ class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
   }
   
   @objc func start(_ minDisplacement: CLLocationDistance) {
-    if minDisplacement >= 0.0 { locationManager.setDistanceFilter(minDisplacement) }
-    locationManager.start()
+    if minDisplacement >= 0.0 { locationProviderRCTMGL.setDistanceFilter(minDisplacement) }
+    locationProviderRCTMGL.start()
   }
   
   @objc func stop() {
-    locationManager.stop()
+    locationProviderRCTMGL.stop()
   }
   
   @objc func getLastKnownLocation() -> RCTMGLLocation? {
@@ -353,15 +377,15 @@ class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
   }
   
   @objc func setMinDisplacement(_ minDisplacement: CLLocationDistance) {
-    locationManager.setDistanceFilter(minDisplacement)
+    locationProviderRCTMGL.setDistanceFilter(minDisplacement)
   }
   
   @objc func setRequestsAlwaysUse(_ requestsAlwaysUse: Bool) {
-    locationManager.setRequestsAlwaysUse(requestsAlwaysUse);
+    locationProviderRCTMGL.setRequestsAlwaysUse(requestsAlwaysUse);
   }
 
   @objc func simulateHeading(_ changesPerSecond: NSNumber, increment: NSNumber) {
-    locationManager.simulateHeading(changesPerSecond: changesPerSecond.intValue, increment: increment.doubleValue)
+    locationProviderRCTMGL.simulateHeading(changesPerSecond: changesPerSecond.intValue, increment: increment.doubleValue)
   }
 
   @objc
@@ -376,7 +400,7 @@ class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
     hasListener = false
   }
   
-  func locationManager(_ locationManager: RCTMGLLocationManager, didUpdateLocation location: RCTMGLLocation) {
+  func locationManager(_ locationManager: LocationProviderRCTMGL, didUpdateLocation location: RCTMGLLocation) {
     guard hasListener, let _ = bridge else {
       return
     }
@@ -416,7 +440,6 @@ class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
      
     return false;
   }
-
 }
 
 

package/ios/RCTMGL-v10/RCTMGLLogging.swift

@@ -74,8 +74,10 @@ class Logger {
 }
 
 func errorMessage(_ error: Error) -> String {
-  if case DecodingError.typeMismatch(let type, let context) = error {
+  if case DecodingError.typeMismatch(let _, let context) = error {
     return "\(error.localizedDescription) \(context.codingPath) \(context.debugDescription)"
+  } else if let mapError = error as? MapError {
+    return "MapError: \(mapError.errorDescription)"
   } else {
     return "\(error.localizedDescription)"
   }

package/ios/RCTMGL-v10/RCTMGLOfflineModule.m

@@ -29,4 +29,6 @@ RCT_EXTERN_METHOD(deletePack:(NSString *)name
 
 RCT_EXTERN_METHOD(migrateOfflineCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(resetDatabase:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+
 @end

package/ios/RCTMGL-v10/RCTMGLOfflineModule.swift

@@ -572,6 +572,37 @@ class RCTMGLOfflineModule: RCTEventEmitter {
       reject("migrateOfflineCache", error.localizedDescription, error)
     }
   }
+  
+  @objc
+  func resetDatabase(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    self.tileStore.allTileRegions { result in
+      switch result {
+      case .success(let regions):
+        regions.forEach { region in
+          self.tileStore.removeTileRegion(forId: region.id)
+        }
+        self.offlineManager.allStylePacks { result in
+          switch result {
+          case .success(let packs):
+            packs.forEach { pack in
+              if let url = logged("RCTMGLOfflineModule.resetDatabase invalid styleURI",fn: { return URL(string: pack.styleURI) }),
+                 let styleUri = logged("RCTMGLOfflineModule.resetDatabase invalid styleURI2", fn: { return StyleURI(url: url) }) {
+                self.offlineManager.removeStylePack(for: styleUri)
+              }
+            }
+            resolve(nil)
+          case .failure(let error):
+            Logger.log(level:.error, message: "RCTMGLOfflineModule.resetDatabase/allStylePacks \(error.localizedDescription) \(error)")
+            reject("RCTMGLOfflineModule.resetDatabase/allStylePacks", error.localizedDescription, error)
+          }
+        }
+      case .failure(let error):
+        Logger.log(level:.error, message: "RCTMGLOfflineModule.resetDatabase/allTileRegions \(error.localizedDescription) \(error)")
+        reject("RCTMGLOfflineModule.resetDatabase/allTileRegions", error.localizedDescription, error)
+      }
+      
+    }
+  }
 }
 
 // MARK: progress throttle

package/ios/RCTMGL-v10/RCTMGLPointAnnotation.swift

@@ -207,6 +207,7 @@ class RCTMGLPointAnnotation : RCTMGLInteractiveElement {
   // MARK: - RCTMGLMapComponent
   
   override func addToMap(_ map: RCTMGLMapView, style: Style) {
+    super.addToMap(map, style: style)
     self.map = map
     addIfPossible()
   }
@@ -235,7 +236,10 @@ extension RCTMGLPointAnnotation {
   
   @discardableResult
   func addIfPossible() -> Bool {
-    if !added && annotation.point.coordinates.isValid(), let pointAnnotationManager = map?.pointAnnotationManager {
+    if !added
+        && annotation.point.coordinates.isValid()
+        && (logged("PointAnnotation: missing id attribute") { return id }) != nil,
+        let pointAnnotationManager = map?.pointAnnotationManager {
       pointAnnotationManager.add(annotation)
       added = true
       return true