@rnmapbox/maps 10.3.2-rc.1 → 10.3.2

package/android/src/main/java/com/rnmapbox/rnmbx/RNMBXPackage.kt

@@ -11,6 +11,7 @@ import com.rnmapbox.rnmbx.components.annotation.RNMBXCalloutManager
 import com.rnmapbox.rnmbx.components.annotation.RNMBXMarkerViewContentManager
 import com.rnmapbox.rnmbx.components.annotation.RNMBXMarkerViewManager
 import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotationManager
+import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotationManagerViewManager
 import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotationModule
 import com.rnmapbox.rnmbx.components.camera.RNMBXCameraManager
 import com.rnmapbox.rnmbx.components.camera.RNMBXCameraModule
@@ -135,6 +136,7 @@ class RNMBXPackage : TurboReactPackage() {
         managers.add(RNMBXMarkerViewManager(reactApplicationContext))
         managers.add(RNMBXMarkerViewContentManager(reactApplicationContext))
         managers.add(RNMBXPointAnnotationManager(reactApplicationContext, getViewTagResolver(reactApplicationContext, "RNMBXPointAnnotationManager")))
+        managers.add(RNMBXPointAnnotationManagerViewManager(reactApplicationContext))
         managers.add(RNMBXCalloutManager())
         managers.add(RNMBXNativeUserLocationManager())
         managers.add(RNMBXCustomLocationProviderManager())

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXMarkerView.kt

@@ -129,8 +129,6 @@ class RNMBXMarkerView(context: Context?, private val mManager: RNMBXMarkerViewMa
         }
         
         if (view.width == 0 || view.height == 0) {
-            // Fixes https://github.com/rnmapbox/maps/issues/4206
-            // Wait for the next layout via onLayoutChange
             return
         }
         

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotation.kt

@@ -27,6 +27,9 @@ import com.rnmapbox.rnmbx.v11compat.annotation.*;
 class RNMBXPointAnnotation(private val mContext: Context, private val mManager: RNMBXPointAnnotationManager) : AbstractMapFeature(mContext), View.OnLayoutChangeListener {
 
     var pointAnnotations: RNMBXPointAnnotationCoordinator? = null
+
+    var parentCoordinator: RNMBXPointAnnotationCoordinator? = null
+
     var annotation: PointAnnotation? = null
         private set
     private var mMap: MapboxMap? = null
@@ -97,7 +100,7 @@ class RNMBXPointAnnotation(private val mContext: Context, private val mManager:
     override fun addToMap(mapView: RNMBXMapView) {
         super.addToMap(mapView)
         mMap = mapView.getMapboxMap()
-        pointAnnotations = mapView.pointAnnotations
+        pointAnnotations = parentCoordinator ?: mapView.pointAnnotations
         makeMarker()
         if (mChildView != null) {
             if (!mChildView!!.isAttachedToWindow) {
@@ -117,7 +120,8 @@ class RNMBXPointAnnotation(private val mContext: Context, private val mManager:
     override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
         val map = mMapView ?: mapView
 
-        annotation?.let { map.pointAnnotations?.delete(it) }
+        val coordinator = pointAnnotations ?: map.pointAnnotations
+        annotation?.let { coordinator.delete(it) }
 
         mChildView?.let { map.offscreenAnnotationViewContainer?.removeView(it) }
         calloutView?.let { map.offscreenAnnotationViewContainer?.removeView(it)}

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotationCoordinator.kt

@@ -13,7 +13,7 @@ import com.mapbox.maps.plugin.annotation.generated.createPointAnnotationManager
 import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotation
 import com.rnmapbox.rnmbx.utils.Logger
 
-class RNMBXPointAnnotationCoordinator(val mapView: MapView) {
+class RNMBXPointAnnotationCoordinator(val mapView: MapView, layerId: String? = "RNMBX-mapview-annotations") {
     val manager: PointAnnotationManager;
     var annotationClicked = false
     var annotationDragged = false
@@ -24,7 +24,11 @@ class RNMBXPointAnnotationCoordinator(val mapView: MapView) {
     val callouts: MutableMap<String, RNMBXPointAnnotation> = hashMapOf()
 
     init {
-        manager = mapView.annotations.createPointAnnotationManager(AnnotationConfig(layerId = "RNMBX-mapview-annotations"))
+        manager = if (layerId != null) {
+            mapView.annotations.createPointAnnotationManager(AnnotationConfig(layerId = layerId))
+        } else {
+            mapView.annotations.createPointAnnotationManager()
+        }
         manager.addClickListener(OnPointAnnotationClickListener { pointAnnotation ->
             onAnnotationClick(pointAnnotation)
             false
@@ -161,6 +165,10 @@ class RNMBXPointAnnotationCoordinator(val mapView: MapView) {
         annotations[annotation.iD!!] = annotation
     }
 
+    fun destroy() {
+        mapView.annotations.removeAnnotationManager(manager)
+    }
+
     companion object {
         const val LOG_TAG = "RNMBXPointAnnotationCoordinator";
     }

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotationManagerView.kt

@@ -0,0 +1,143 @@
+package com.rnmapbox.rnmbx.components.annotation
+
+import android.content.Context
+import android.view.View
+import com.rnmapbox.rnmbx.components.AbstractMapFeature
+import com.rnmapbox.rnmbx.components.RemovalReason
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.utils.Logger
+
+class RNMBXPointAnnotationManagerView(context: Context) : AbstractMapFeature(context) {
+    var reactId: String? = null
+    var isDefault: Boolean = false
+
+    var slot: String? = null
+        set(value) { field = value; applyProps() }
+    var iconAllowOverlap: Boolean? = null
+        set(value) { field = value; applyProps() }
+    var iconIgnorePlacement: Boolean? = null
+        set(value) { field = value; applyProps() }
+    var iconOptional: Boolean? = null
+        set(value) { field = value; applyProps() }
+    var textAllowOverlap: Boolean? = null
+        set(value) { field = value; applyProps() }
+    var textIgnorePlacement: Boolean? = null
+        set(value) { field = value; applyProps() }
+    var textOptional: Boolean? = null
+        set(value) { field = value; applyProps() }
+
+    private val annotations = mutableListOf<RNMBXPointAnnotation>()
+    private var coordinator: RNMBXPointAnnotationCoordinator? = null
+
+    fun addAnnotation(childView: View, childPosition: Int) {
+        if (childView !is RNMBXPointAnnotation) {
+            Logger.w(LOG_TAG, "PointAnnotationManager: only PointAnnotation children are supported")
+            return
+        }
+        annotations.add(childPosition, childView)
+        val mapView = mMapView
+        if (mapView != null) {
+            ensureCoordinator(mapView)
+            attachAnnotation(childView, mapView)
+        }
+    }
+
+    fun removeAnnotationAt(childPosition: Int) {
+        val childView = annotations.removeAt(childPosition)
+        val mapView = mMapView
+        if (mapView != null) {
+            coordinator?.remove(childView)
+            childView.removeFromMap(mapView, RemovalReason.VIEW_REMOVAL)
+        }
+        childView.parentCoordinator = null
+    }
+
+    override fun getChildAt(childPosition: Int): View {
+        return annotations[childPosition]
+    }
+
+    override fun getChildCount(): Int {
+        return annotations.size
+    }
+
+    private fun attachAnnotation(annotation: RNMBXPointAnnotation, mapView: RNMBXMapView) {
+        val coordinator = coordinator ?: return
+        annotation.parentCoordinator = coordinator
+        coordinator.add(annotation)
+        annotation.addToMap(mapView)
+    }
+
+    private fun ensureCoordinator(mapView: RNMBXMapView) {
+        if (coordinator != null) return
+        coordinator = if (isDefault) {
+            val existing = mapView.defaultPointAnnotationManagerView
+            if (existing != null && existing !== this) {
+                Logger.w(LOG_TAG, "PointAnnotationManager: multiple default managers declared, ignoring extra default")
+            } else {
+                mapView.defaultPointAnnotationManagerView = this
+            }
+            mapView.pointAnnotations
+        } else {
+            val c = RNMBXPointAnnotationCoordinator(mapView.mapView, reactId)
+            mapView.registerPointAnnotationCoordinator(c)
+            c
+        }
+        applyProps()
+    }
+
+    override fun addToMap(mapView: RNMBXMapView) {
+        super.addToMap(mapView)
+        ensureCoordinator(mapView)
+        for (annotation in annotations) {
+            attachAnnotation(annotation, mapView)
+        }
+    }
+
+    override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
+        for (annotation in annotations) {
+            coordinator?.remove(annotation)
+            annotation.removeFromMap(mapView, reason)
+            annotation.parentCoordinator = null
+        }
+        coordinator?.let { c ->
+            if (isDefault) {
+                // The default coordinator is shared with bare annotations; leave it in
+                // place, just clear the configuration this view applied.
+                c.manager.slot = null
+                c.manager.iconAllowOverlap = null
+                c.manager.iconIgnorePlacement = null
+                c.manager.iconOptional = null
+                c.manager.textAllowOverlap = null
+                c.manager.textIgnorePlacement = null
+                c.manager.textOptional = null
+            } else {
+                mapView.unregisterPointAnnotationCoordinator(c)
+                c.destroy()
+            }
+        }
+        if (mapView.defaultPointAnnotationManagerView === this) {
+            mapView.defaultPointAnnotationManagerView = null
+        }
+        coordinator = null
+        return super.removeFromMap(mapView, reason)
+    }
+
+    private fun applyProps() {
+        val manager = coordinator?.manager ?: return
+        manager.slot = slot
+        // Only write when the prop is set. The annotation plugin defaults
+        // iconAllowOverlap/iconIgnorePlacement to true so annotations always show;
+        // writing null here would clobber that back to the style default (false) and
+        // cull colliding pins.
+        iconAllowOverlap?.let { manager.iconAllowOverlap = it }
+        iconIgnorePlacement?.let { manager.iconIgnorePlacement = it }
+        iconOptional?.let { manager.iconOptional = it }
+        textAllowOverlap?.let { manager.textAllowOverlap = it }
+        textIgnorePlacement?.let { manager.textIgnorePlacement = it }
+        textOptional?.let { manager.textOptional = it }
+    }
+
+    companion object {
+        const val LOG_TAG = "RNMBXPointAnnotationManagerView"
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotationManagerViewManager.kt

@@ -0,0 +1,105 @@
+package com.rnmapbox.rnmbx.components.annotation
+
+import android.view.View
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNMBXPointAnnotationManagerManagerDelegate
+import com.facebook.react.viewmanagers.RNMBXPointAnnotationManagerManagerInterface
+import com.rnmapbox.rnmbx.components.AbstractEventEmitter
+
+class RNMBXPointAnnotationManagerViewManager(context: ReactApplicationContext) :
+    AbstractEventEmitter<RNMBXPointAnnotationManagerView>(context),
+    RNMBXPointAnnotationManagerManagerInterface<RNMBXPointAnnotationManagerView> {
+    private val mDelegate: ViewManagerDelegate<RNMBXPointAnnotationManagerView> =
+        RNMBXPointAnnotationManagerManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<RNMBXPointAnnotationManagerView> {
+        return mDelegate
+    }
+
+    override fun customEvents(): Map<String, String>? {
+        return MapBuilder.builder<String, String>().build()
+    }
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun createViewInstance(context: ThemedReactContext): RNMBXPointAnnotationManagerView {
+        return RNMBXPointAnnotationManagerView(context)
+    }
+
+    override fun addView(parent: RNMBXPointAnnotationManagerView, childView: View, childPosition: Int) {
+        parent.addAnnotation(childView, childPosition)
+    }
+
+    override fun removeViewAt(parent: RNMBXPointAnnotationManagerView, childPosition: Int) {
+        parent.removeAnnotationAt(childPosition)
+    }
+
+    override fun getChildAt(parent: RNMBXPointAnnotationManagerView, childPosition: Int): View {
+        return parent.getChildAt(childPosition)
+    }
+
+    override fun getChildCount(parent: RNMBXPointAnnotationManagerView): Int {
+        return parent.getChildCount()
+    }
+
+    private fun optBoolean(value: Dynamic): Boolean? {
+        return if (value.isNull || value.type != ReadableType.Boolean) null else value.asBoolean()
+    }
+
+    companion object {
+        const val REACT_CLASS = "RNMBXPointAnnotationManager"
+    }
+
+    @ReactProp(name = "id")
+    override fun setId(view: RNMBXPointAnnotationManagerView, value: Dynamic) {
+        view.reactId = if (value.isNull) null else value.asString()
+    }
+
+    @ReactProp(name = "isDefault")
+    override fun setIsDefault(view: RNMBXPointAnnotationManagerView, value: Dynamic) {
+        view.isDefault = !value.isNull && value.asBoolean()
+    }
+
+    @ReactProp(name = "slot")
+    override fun setSlot(view: RNMBXPointAnnotationManagerView, value: Dynamic) {
+        view.slot = if (value.isNull) null else value.asString()
+    }
+
+    @ReactProp(name = "iconAllowOverlap")
+    override fun setIconAllowOverlap(view: RNMBXPointAnnotationManagerView, value: Dynamic) {
+        view.iconAllowOverlap = optBoolean(value)
+    }
+
+    @ReactProp(name = "iconIgnorePlacement")
+    override fun setIconIgnorePlacement(view: RNMBXPointAnnotationManagerView, value: Dynamic) {
+        view.iconIgnorePlacement = optBoolean(value)
+    }
+
+    @ReactProp(name = "iconOptional")
+    override fun setIconOptional(view: RNMBXPointAnnotationManagerView, value: Dynamic) {
+        view.iconOptional = optBoolean(value)
+    }
+
+    @ReactProp(name = "textAllowOverlap")
+    override fun setTextAllowOverlap(view: RNMBXPointAnnotationManagerView, value: Dynamic) {
+        view.textAllowOverlap = optBoolean(value)
+    }
+
+    @ReactProp(name = "textIgnorePlacement")
+    override fun setTextIgnorePlacement(view: RNMBXPointAnnotationManagerView, value: Dynamic) {
+        view.textIgnorePlacement = optBoolean(value)
+    }
+
+    @ReactProp(name = "textOptional")
+    override fun setTextOptional(view: RNMBXPointAnnotationManagerView, value: Dynamic) {
+        view.textOptional = optBoolean(value)
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/mapview/RNMBXMapView.kt

@@ -61,6 +61,7 @@ import com.rnmapbox.rnmbx.utils.extensions.toReadableArray
 import java.util.*
 
 import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotationCoordinator
+import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotationManagerView
 import com.rnmapbox.rnmbx.components.images.ImageManager
 import com.rnmapbox.rnmbx.utils.extensions.toStringKeyPairs
 
@@ -135,16 +136,35 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
 
     private val mSources: MutableMap<String, RNMBXSource<*>>
     private val mImages: MutableList<RNMBXImages>
-    public val pointAnnotations: RNMBXPointAnnotationCoordinator by lazy {
+    val pointAnnotationCoordinators = mutableListOf<RNMBXPointAnnotationCoordinator>()
+    private var pointAnnotationGesturesInited = false
+
+    var defaultPointAnnotationManagerView: RNMBXPointAnnotationManagerView? = null
+
+    private fun ensurePointAnnotationGestures() {
+        if (pointAnnotationGesturesInited) return
         val gesturesPlugin: GesturesPlugin = mapView.gestures
         gesturesPlugin.removeOnMapClickListener(this)
         gesturesPlugin.removeOnMapLongClickListener(this)
-
-        val result = RNMBXPointAnnotationCoordinator(mapView)
-
         gesturesPlugin.addOnMapClickListener(this)
         gesturesPlugin.addOnMapLongClickListener(this)
+        pointAnnotationGesturesInited = true
+    }
+
+    fun registerPointAnnotationCoordinator(coordinator: RNMBXPointAnnotationCoordinator) {
+        ensurePointAnnotationGestures()
+        if (!pointAnnotationCoordinators.contains(coordinator)) {
+            pointAnnotationCoordinators.add(coordinator)
+        }
+    }
+
+    fun unregisterPointAnnotationCoordinator(coordinator: RNMBXPointAnnotationCoordinator) {
+        pointAnnotationCoordinators.remove(coordinator)
+    }
 
+    public val pointAnnotations: RNMBXPointAnnotationCoordinator by lazy {
+        val result = RNMBXPointAnnotationCoordinator(mapView)
+        registerPointAnnotationCoordinator(result)
         result
     }
     private var mProjection: ProjectionName = ProjectionName.MERCATOR
@@ -690,11 +710,17 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
 
     override fun onMapClick(point: Point): Boolean {
         val _this = this
-        if (pointAnnotations.getAndClearAnnotationClicked()) {
+        if (pointAnnotationCoordinators.any { it.getAndClearAnnotationClicked() }) {
             return true
         }
         if (deselectAnnotationOnTap) {
-            if (pointAnnotations.deselectSelectedAnnotation()) {
+            var deselected = false
+            for (coordinator in pointAnnotationCoordinators) {
+                if (coordinator.deselectSelectedAnnotation()) {
+                    deselected = true
+                }
+            }
+            if (deselected) {
                 return true
             }
         }
@@ -728,7 +754,7 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
 
     override fun onMapLongClick(point: Point): Boolean {
         val _this = this
-        if (pointAnnotations.getAndClearAnnotationDragged()) {
+        if (pointAnnotationCoordinators.any { it.getAndClearAnnotationDragged() }) {
             return true
         }
         val screenPointPx = mMap?.pixelForCoordinate(point)

package/ios/RNMBX/RNMBXMapView.swift

@@ -229,12 +229,31 @@ open class RNMBXMapView: UIView, RCTInvalidating {
 
   var cancelables = Set<AnyCancelable>()
 
+  var pointAnnotationManagers: [RNMBXPointAnnotationManager] = []
+
+  weak var defaultPointAnnotationManagerView: RNMBXPointAnnotationManagerView? = nil
+
   lazy var pointAnnotationManager : RNMBXPointAnnotationManager = {
-    let result = RNMBXPointAnnotationManager(annotations: mapView.annotations, mapView: mapView)
+    let result = RNMBXPointAnnotationManager(annotations: mapView.annotations, mapView: mapView, id: "RNMBX-mapview-point-annotations")
     self._removeMapboxLongPressGestureRecognizer()
+    self.registerPointAnnotationManager(result)
     return result
   }()
 
+  func registerPointAnnotationManager(_ manager: RNMBXPointAnnotationManager) {
+    if !pointAnnotationManagers.contains(where: { $0 === manager }) {
+      pointAnnotationManagers.append(manager)
+    }
+    // We handle taps ourselves; detach Mapbox's built-in tap target for this manager.
+    if let mapView = _mapView {
+      mapView.gestures.singleTapGestureRecognizer.removeTarget(manager.manager, action: nil)
+    }
+  }
+
+  func unregisterPointAnnotationManager(_ manager: RNMBXPointAnnotationManager) {
+    pointAnnotationManagers.removeAll { $0 === manager }
+  }
+
   lazy var calloutAnnotationManager : MapboxMaps.PointAnnotationManager = {
     let manager = mapView.annotations.makePointAnnotationManager(id: "RNMBX-mapview-callouts")
     manager.iconAllowOverlap = true
@@ -1284,7 +1303,10 @@ extension RNMBXMapView {
   func applyOnPress() {
     let singleTapGestureRecognizer = self.mapView.gestures.singleTapGestureRecognizer
 
-    singleTapGestureRecognizer.removeTarget(pointAnnotationManager.manager, action: nil)
+    // Detach Mapbox's built-in tap target for every manager; we handle taps ourselves.
+    for manager in pointAnnotationManagers {
+      singleTapGestureRecognizer.removeTarget(manager.manager, action: nil)
+    }
     singleTapGestureRecognizer.addTarget(self, action: #selector(doHandleTap(_:)))
 
     self.tapDelegate = IgnoreRNMBXMakerViewGestureDelegate(originalDelegate: singleTapGestureRecognizer.delegate)
@@ -1386,13 +1408,34 @@ extension RNMBXMapView: GestureManagerDelegate {
     return event
   }
 
+  private func handleTapAcrossPointAnnotationManagers(_ sender: UITapGestureRecognizer, index: Int, noneFound: @escaping () -> Void) {
+    if index >= pointAnnotationManagers.count {
+      noneFound()
+      return
+    }
+    pointAnnotationManagers[index].handleTap(sender) { _ in
+      self.handleTapAcrossPointAnnotationManagers(sender, index: index + 1, noneFound: noneFound)
+    }
+  }
+
+  @discardableResult
+  func deselectCurrentlySelectedPointAnnotation(deselectAnnotationOnTap: Bool) -> Bool {
+    var any = false
+    for manager in pointAnnotationManagers {
+      if manager.deselectCurrentlySelected(deselectAnnotationOnTap: deselectAnnotationOnTap) {
+        any = true
+      }
+    }
+    return any
+  }
+
   @objc
   func doHandleTap(_ sender: UITapGestureRecognizer) {
     let tapPoint = sender.location(in: self)
-    pointAnnotationManager.handleTap(sender) { (_: UITapGestureRecognizer) in
+    handleTapAcrossPointAnnotationManagers(sender, index: 0) {
       DispatchQueue.main.async {
         if (self.deselectAnnotationOnTap) {
-          if (self.pointAnnotationManager.deselectCurrentlySelected(deselectAnnotationOnTap: true)) {
+          if (self.deselectCurrentlySelectedPointAnnotation(deselectAnnotationOnTap: true)) {
             return
           }
         }
@@ -1435,10 +1478,23 @@ extension RNMBXMapView: GestureManagerDelegate {
     }
   }
 
+  private func handleLongPressAcrossPointAnnotationManagers(_ sender: UILongPressGestureRecognizer, index: Int, noneFound: @escaping () -> Void) {
+    if index >= pointAnnotationManagers.count {
+      noneFound()
+      return
+    }
+    pointAnnotationManagers[index].handleLongPress(sender) { _ in
+      self.handleLongPressAcrossPointAnnotationManagers(sender, index: index + 1, noneFound: noneFound)
+    }
+  }
+
   @objc
   func doHandleLongPress(_ sender: UILongPressGestureRecognizer) {
     let position = sender.location(in: self)
-    pointAnnotationManager.handleLongPress(sender) { (_: UILongPressGestureRecognizer) in
+    handleLongPressAcrossPointAnnotationManagers(sender, index: 0) {
+      // Source-based drag handling only starts on `.began`; annotation drag
+      // continuation (.changed/.ended) is consumed by the owning manager above.
+      guard sender.state == .began else { return }
       DispatchQueue.main.async {
         let draggableSources = self.draggableSources()
         self.doHandleTapInSources(sources: draggableSources, tapPoint: position, hits: [:], touchedSources: []) { (hits, draggedSources) in
@@ -2026,8 +2082,12 @@ class RNMBXPointAnnotationManager : AnnotationInteractionDelegate {
   var manager : MapboxMaps.PointAnnotationManager
   weak var mapView : MapView? = nil
 
-  init(annotations: AnnotationOrchestrator, mapView: MapView) {
-    manager = annotations.makePointAnnotationManager(id: "RNMBX-mapview-point-annotations")
+  init(annotations: AnnotationOrchestrator, mapView: MapView, id: String? = nil) {
+    if let id = id {
+      manager = annotations.makePointAnnotationManager(id: id)
+    } else {
+      manager = annotations.makePointAnnotationManager()
+    }
     manager.delegate = self
     self.mapView = mapView
   }
@@ -2119,6 +2179,7 @@ class RNMBXPointAnnotationManager : AnnotationInteractionDelegate {
 
       case .changed:
           guard var annotation = self.draggedAnnotation else {
+              noAnnotationFound(sender)
               return
           }
 
@@ -2130,6 +2191,7 @@ class RNMBXPointAnnotationManager : AnnotationInteractionDelegate {
           }
       case .cancelled, .ended:
         guard let annotation = self.draggedAnnotation else {
+            noAnnotationFound(sender)
             return
         }
         // Optionally notify some other delegate to tell them the drag finished.

package/ios/RNMBX/RNMBXPointAnnotation.swift

@@ -12,6 +12,12 @@ final class WeakRef<T: AnyObject> {
 public class RNMBXPointAnnotation : RNMBXInteractiveElement {
   weak var manager: RNMBXPointAnnotationManager? = nil
 
+  weak var ownerManager: RNMBXPointAnnotationManager? = nil
+
+  var resolvedManager: RNMBXPointAnnotationManager? {
+    return ownerManager ?? map?.pointAnnotationManager
+  }
+
   static let key = "RNMBXPointAnnotation"
   static var gid = 0;
   
@@ -293,28 +299,28 @@ public class RNMBXPointAnnotation : RNMBXInteractiveElement {
 
 extension RNMBXPointAnnotation {
   func removeIfAdded() {
-    if added, let pointAnnotationManager = map?.pointAnnotationManager {
+    if added, let pointAnnotationManager = resolvedManager {
       pointAnnotationManager.remove(annotation)
       added = false
     }
   }
-  
+
   @discardableResult
   func addIfPossible() -> Bool {
     if !added
         && annotation.point.coordinates.isValid()
         && (logged("PointAnnotation: missing id attribute") { return id }) != nil,
-        let pointAnnotationManager = map?.pointAnnotationManager {
+        let pointAnnotationManager = resolvedManager {
       pointAnnotationManager.add(annotation, self)
       added = true
       return true
     }
     return false
   }
-  
+
   func update(callback: (_ annotation: inout PointAnnotation) -> Void) {
     callback(&annotation)
-    if let pointAnnotationManager = map?.pointAnnotationManager {
+    if let pointAnnotationManager = resolvedManager {
       if added {
         pointAnnotationManager.update(annotation)
       } else if !added {

package/ios/RNMBX/RNMBXPointAnnotationManagerComponentView.h

@@ -0,0 +1,15 @@
+#ifdef __cplusplus
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTUIManager.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNMBXPointAnnotationManagerComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END
+#endif // __cplusplus