@rnmapbox/maps 10.1.0-rc.2 → 10.1.0-rc.4

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

@@ -48,6 +48,7 @@ import com.rnmapbox.rnmbx.modules.RNMBXLocationModule
 import com.rnmapbox.rnmbx.modules.RNMBXLogging
 import com.rnmapbox.rnmbx.modules.RNMBXModule
 import com.rnmapbox.rnmbx.modules.RNMBXOfflineModule
+import com.rnmapbox.rnmbx.modules.RNMBXOfflineModuleLegacy
 import com.rnmapbox.rnmbx.modules.RNMBXSnapshotModule
 import com.rnmapbox.rnmbx.shape_animators.RNMBXMovePointShapeAnimatorModule
 import com.rnmapbox.rnmbx.shape_animators.ShapeAnimatorManager
@@ -89,6 +90,7 @@ class RNMBXPackage : TurboReactPackage() {
             RNMBXModule.REACT_CLASS -> return RNMBXModule(reactApplicationContext)
             RNMBXLocationModule.REACT_CLASS -> return RNMBXLocationModule(reactApplicationContext)
             RNMBXOfflineModule.REACT_CLASS -> return RNMBXOfflineModule(reactApplicationContext)
+            RNMBXOfflineModuleLegacy.REACT_CLASS -> return RNMBXOfflineModuleLegacy(reactApplicationContext)
             RNMBXSnapshotModule.REACT_CLASS -> return RNMBXSnapshotModule(reactApplicationContext)
             RNMBXLogging.REACT_CLASS -> return RNMBXLogging(reactApplicationContext)
             NativeMapViewModule.NAME -> return NativeMapViewModule(reactApplicationContext, getViewTagResolver(reactApplicationContext, s))
@@ -187,6 +189,15 @@ class RNMBXPackage : TurboReactPackage() {
                 false,  // isCxxModule
                 false // isTurboModule
             )
+            moduleInfos[RNMBXOfflineModuleLegacy.REACT_CLASS] = ReactModuleInfo(
+                RNMBXOfflineModuleLegacy.REACT_CLASS,
+                RNMBXOfflineModuleLegacy.REACT_CLASS,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                true,  // hasConstants
+                false,  // isCxxModule
+                false // isTurboModule
+            )
             moduleInfos[RNMBXSnapshotModule.REACT_CLASS] = ReactModuleInfo(
                 RNMBXSnapshotModule.REACT_CLASS,
                 RNMBXSnapshotModule.REACT_CLASS,

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

@@ -31,6 +31,7 @@ class RNMBXMarkerView(context: Context?, private val mManager: RNMBXMarkerViewMa
     private var mCoordinate: Point? = null
     private var mAnchor: Vec2 = Vec2(0.5, 0.5)
     private var mAllowOverlap = false
+    private var mAllowOverlapWithPuck = false
     private var mIsSelected = false
 
     fun setCoordinate(point: Point?) {
@@ -48,6 +49,11 @@ class RNMBXMarkerView(context: Context?, private val mManager: RNMBXMarkerViewMa
         update()
     }
 
+    fun setAllowOverlapWithPuck(allowOverlapWithPuck: Boolean) {
+        mAllowOverlapWithPuck = allowOverlapWithPuck
+        update()
+    }
+
     fun setIsSelected(isSelected: Boolean) {
         mIsSelected = isSelected
         update()
@@ -116,13 +122,14 @@ class RNMBXMarkerView(context: Context?, private val mManager: RNMBXMarkerViewMa
 
         val options = getOptions()
 
-
+        val content = view as? RNMBXMarkerViewContent;
+        content?.inAdd = true;
+        didAddToMap = true
         val annotation = mMapView?.viewAnnotationManager?.addViewAnnotation(
             view,
             options
         )
-        didAddToMap = true
-
+        content?.inAdd = false;
     }
 
     fun update() {
@@ -176,6 +183,7 @@ class RNMBXMarkerView(context: Context?, private val mManager: RNMBXMarkerViewMa
             width(width.toDouble())
             height(height.toDouble())
             allowOverlap(mAllowOverlap)
+            allowOverlapWithPuck(mAllowOverlapWithPuck)
             offsets(offset.dx, offset.dy)
             selected(mIsSelected)
 

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

@@ -1,21 +1,29 @@
 package com.rnmapbox.rnmbx.components.annotation
 
 import android.content.Context
+import android.view.View.MeasureSpec
 import com.facebook.react.uimanager.MeasureSpecAssertions
 import com.facebook.react.views.view.ReactViewGroup
 
 class RNMBXMarkerViewContent(context: Context): ReactViewGroup(context) {
+
+    var inAdd: Boolean = false
     // see https://github.com/rnmapbox/maps/pull/3235
     override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        try {
+        if (inAdd) {
+            val w = if (widthMeasureSpec == 0) {
+                MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY)
+            } else {
+                widthMeasureSpec
+            };
+            val h = if (heightMeasureSpec == 0) {
+                MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY)
+            } else {
+                heightMeasureSpec
+            }
+            super.onMeasure(w, h)
+        } else {
             super.onMeasure(widthMeasureSpec, heightMeasureSpec)
-        } catch(e: IllegalStateException) {
-            val w = MeasureSpec.getSize(widthMeasureSpec)
-            val h = MeasureSpec.getSize(heightMeasureSpec)
-            setMeasuredDimension(
-                if (w == 0) measuredWidth else w,
-                if (h == 0) measuredHeight else h
-            )
         }
     }
 

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

@@ -49,6 +49,11 @@ class RNMBXMarkerViewManager(reactApplicationContext: ReactApplicationContext) :
         markerView.setAllowOverlap(allowOverlap.asBoolean())
     }
 
+    @ReactProp(name = "allowOverlapWithPuck")
+    override fun setAllowOverlapWithPuck(markerView: RNMBXMarkerView, allowOverlapWithPuck: Dynamic) {
+        markerView.setAllowOverlapWithPuck(allowOverlapWithPuck.asBoolean())
+    }
+
     @ReactProp(name = "isSelected")
     override fun setIsSelected(markerView: RNMBXMarkerView, isSelected: Dynamic) {
         markerView.setIsSelected(isSelected.asBoolean())

package/android/src/main/java/com/rnmapbox/rnmbx/modules/RNMBXOfflineModuleLegacy.kt

@@ -0,0 +1,444 @@
+package com.rnmapbox.rnmbx.modules
+
+import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.mapbox.bindgen.Expected
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.geojson.Point
+import com.mapbox.maps.CoordinateBounds
+import com.mapbox.maps.GlyphsRasterizationMode
+import com.mapbox.maps.OfflineRegion
+import com.mapbox.maps.OfflineRegionCallback
+import com.mapbox.maps.OfflineRegionCreateCallback
+import com.mapbox.maps.OfflineRegionDownloadState
+import com.mapbox.maps.OfflineRegionManager
+import com.mapbox.maps.OfflineRegionStatus
+import com.mapbox.maps.OfflineRegionTilePyramidDefinition
+import com.rnmapbox.rnmbx.utils.ConvertUtils
+import com.rnmapbox.rnmbx.utils.extensions.toGeometryCollection
+import com.rnmapbox.rnmbx.utils.writableArrayOf
+import com.rnmapbox.rnmbx.v11compat.offlinemanager.getOfflineRegionManager
+import org.json.JSONException
+import org.json.JSONObject
+import java.io.File
+import java.io.UnsupportedEncodingException
+import java.nio.file.Files
+import java.nio.file.Paths
+import java.nio.file.StandardCopyOption
+import kotlin.math.ceil
+
+
+@ReactModule(name = RNMBXOfflineModuleLegacy.REACT_CLASS)
+class RNMBXOfflineModuleLegacy(private val mReactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(
+        mReactContext
+    ) {
+    companion object {
+        const val REACT_CLASS = "RNMBXOfflineModuleLegacy"
+        const val LOG_TAG = "OfflineModuleLegacy"
+        const val DEFAULT_STYLE_URL = "mapbox://styles/mapbox/streets-v11"
+        const val DEFAULT_MIN_ZOOM_LEVEL = 10.0
+        const val DEFAULT_MAX_ZOOM_LEVEL = 20.0
+        const val COMPLETE_REGION_DOWNLOAD_STATE = 2
+    }
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    val offlineRegionManager: OfflineRegionManager by lazy {
+        getOfflineRegionManager {
+            RNMBXModule.getAccessToken(mReactContext)
+        }
+    }
+
+    private fun makeDefinition(
+        bounds: CoordinateBounds,
+        options: ReadableMap
+    ): OfflineRegionTilePyramidDefinition {
+        return OfflineRegionTilePyramidDefinition.Builder()
+            .styleURL(ConvertUtils.getString("styleURL", options, DEFAULT_STYLE_URL))
+            .bounds(bounds)
+            .minZoom(ConvertUtils.getDouble("minZoom", options, DEFAULT_MIN_ZOOM_LEVEL))
+            .maxZoom(ConvertUtils.getDouble("maxZoom", options, DEFAULT_MAX_ZOOM_LEVEL))
+            .pixelRatio(mReactContext.getResources().getDisplayMetrics().density)
+            .glyphsRasterizationMode(GlyphsRasterizationMode.IDEOGRAPHS_RASTERIZED_LOCALLY)
+            .build()
+    }
+
+    private fun convertPointPairToBounds(boundsFC: FeatureCollection): CoordinateBounds? {
+        val geometryCollection = boundsFC.toGeometryCollection()
+        val geometries = geometryCollection.geometries()
+        if (geometries.size != 2) {
+            return null
+        }
+        val pt0 = geometries.get(0) as Point?
+        val pt1 = geometries.get(1) as Point?
+        if (pt0 == null || pt1 == null) {
+            return null
+        }
+        return CoordinateBounds(pt0, pt1)
+    }
+
+    private fun createPackCallback(promise: Promise, metadata: ByteArray): OfflineRegionCreateCallback {
+        return OfflineRegionCreateCallback { expected ->
+            if (expected.isValue) {
+                expected.value?.let {
+                    it.setOfflineRegionDownloadState(OfflineRegionDownloadState.ACTIVE)
+                    it.setMetadata(metadata) { expectedMetadata ->
+                        if (expectedMetadata.isError) {
+                            promise.reject("createPack error:", "Failed to setMetadata")
+                        } else {
+                            Log.d(LOG_TAG,  "createPack done:")
+                            promise.resolve(fromOfflineRegion(it))
+                        }
+                    }
+                }
+            } else {
+                Log.d(LOG_TAG,  "createPack error:")
+                promise.reject("createPack error:", "Failed to create OfflineRegion")
+            }
+        }
+    }
+
+
+    private fun fromOfflineRegion(region: OfflineRegion): WritableMap? {
+        val bb = region.tilePyramidDefinition?.bounds
+        val map = Arguments.createMap()
+
+        if (bb === null) return map
+
+        val jsonBounds = writableArrayOf(
+            writableArrayOf(bb.east(), bb.north()),
+            writableArrayOf(bb.west(), bb.south())
+        )
+
+        map.putArray("bounds", jsonBounds)
+        map.putString("metadata", String(region.metadata))
+
+        return map
+    }
+
+    private fun getMetadataBytes(metadata: String?): ByteArray? {
+        var metadataBytes: ByteArray? = null
+        if (metadata == null || metadata.isEmpty()) {
+            return metadataBytes
+        }
+        try {
+            metadataBytes = metadata.toByteArray(charset("utf-8"))
+        } catch (e: UnsupportedEncodingException) {
+            Log.w(LOG_TAG, e.localizedMessage)
+        }
+        return metadataBytes
+    }
+
+    private fun getRegionByName(
+        name: String?,
+        offlineRegions: List<OfflineRegion>
+    ): OfflineRegion? {
+        if (name.isNullOrEmpty()) {
+            return null
+        }
+        for (region in offlineRegions) {
+            try {
+                val byteMetadata = region.metadata
+
+                if (byteMetadata != null) {
+                    val metadata = JSONObject(String(byteMetadata))
+                    if (name == metadata.getString("name")) {
+                        return region
+                    }
+                }
+            } catch (e: JSONException) {
+                Log.w(LOG_TAG, e.localizedMessage)
+            }
+        }
+        return null
+    }
+
+    private fun makeRegionStatus(regionName: String, status: OfflineRegionStatus): WritableMap? {
+        val map = Arguments.createMap()
+        val progressPercentage = if (status.requiredResourceCount > 0) status.completedResourceCount.toDouble() / status.requiredResourceCount.toDouble() else 0.0
+        val percentage = ceil(progressPercentage * 100.0).coerceAtMost(100.0)
+        val isCompleted = percentage == 100.0
+        val downloadState = if (isCompleted) COMPLETE_REGION_DOWNLOAD_STATE else status.downloadState.ordinal
+
+        map.putString("name", regionName)
+        map.putInt("state", downloadState)
+        map.putDouble("percentage", percentage)
+        map.putInt("completedResourceCount", status.completedResourceCount.toInt())
+        map.putInt("completedResourceSize", status.completedResourceSize.toInt())
+        map.putInt("completedTileSize", status.completedTileSize.toInt())
+        map.putInt("completedTileCount", status.completedTileCount.toInt())
+        map.putInt("requiredResourceCount", status.requiredResourceCount.toInt())
+        return map
+    }
+
+    @ReactMethod
+    @Throws(JSONException::class)
+    fun createPack(options: ReadableMap, promise: Promise) {
+        try {
+            val metadataBytes: ByteArray? =
+                getMetadataBytes(ConvertUtils.getString("metadata", options, ""))
+
+            val boundsStr = options.getString("bounds")!!
+            val boundsFC = FeatureCollection.fromJson(boundsStr)
+            val bounds = convertPointPairToBounds(boundsFC)
+
+            if (metadataBytes == null || bounds == null) {
+                promise.reject("createPack error:", "No metadata or bounds set")
+                return
+            };
+
+            val definition: OfflineRegionTilePyramidDefinition = makeDefinition(bounds, options)
+
+            UiThreadUtil.runOnUiThread {
+                offlineRegionManager.createOfflineRegion(definition, createPackCallback(promise, metadataBytes))
+            }
+
+        } catch (e: Throwable) {
+            promise.reject("createPack error:", e)
+        }
+    }
+
+    @ReactMethod
+    fun getPacks(promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions(object: OfflineRegionCallback {
+                override fun run(expected: Expected<String, MutableList<OfflineRegion>>) {
+                    if (expected.isValue) {
+                        expected.value?.let {
+                            val payload = Arguments.createArray()
+
+                            for (region in it) {
+                                payload.pushMap(fromOfflineRegion(region!!))
+                            }
+
+                            Log.d(LOG_TAG,  "getPacks done:" + it.size.toString())
+                            promise.resolve(payload)
+                        }
+                    } else {
+                        promise.reject("getPacks error:", expected.error)
+                        Log.d(LOG_TAG,  "getPacks error:${expected.error}")
+                    }
+                }
+            })
+        }
+    }
+
+    @ReactMethod
+    fun deletePack(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { regionsExpected ->
+                if (regionsExpected.isValue) {
+                    regionsExpected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "deleteRegion - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.setOfflineRegionDownloadState(OfflineRegionDownloadState.INACTIVE)
+
+                        region.purge { purgeExpected ->
+                            if (purgeExpected.isError) {
+                                promise.reject("deleteRegion error:", purgeExpected.error);
+                            } else {
+                                promise.resolve(null);
+                            }
+                        }
+                    }
+                } else {
+                    promise.reject("deleteRegion error:", regionsExpected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun invalidatePack(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "invalidateRegion - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.invalidate { expected ->
+                            if (expected.isError) {
+                                promise.reject("invalidateRegion error:", expected.error);
+                            } else {
+                                promise.resolve(null);
+                            }
+                        }
+                    }
+                } else {
+                    promise.reject("invalidateRegion error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getPackStatus(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "getPackStatus - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.getStatus {
+                           if (it.isValue) {
+                               it.value?.let { status ->
+                                   promise.resolve(makeRegionStatus(name!!, status));
+                               }
+                           } else {
+                               promise.reject("getPackStatus error:", expected.error);
+                           }
+                        }
+                    }
+                } else {
+                    promise.reject("getPackStatus error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun pausePackDownload(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "pausePackDownload - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.setOfflineRegionDownloadState(OfflineRegionDownloadState.INACTIVE)
+                        promise.resolve(null)
+                    }
+                } else {
+                    promise.reject("pausePackDownload error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun resumePackDownload(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "resumeRegionDownload - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.setOfflineRegionDownloadState(OfflineRegionDownloadState.ACTIVE)
+                        promise.resolve(null);
+                    }
+                } else {
+                    promise.reject("resumeRegionDownload error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun resetDatabase(promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            var purgedCount = 0
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        if (regions.size == 0) promise.resolve(null)
+
+                        for (region in regions) {
+                            region.setOfflineRegionDownloadState(OfflineRegionDownloadState.INACTIVE)
+
+                            region.purge { expected ->
+                                if (expected.isError) {
+                                    promise.reject("resetDatabase error:", expected.error);
+                                } else {
+                                    purgedCount++
+                                    if (purgedCount == regions.size) {
+                                        Log.d(LOG_TAG, "resetDatabase done: ${regions.size} packs were purged")
+                                        promise.resolve(null)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    promise.reject("resetDatabase error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun migrateOfflineCache(promise: Promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            // Old and new cache file paths
+            val targetDirectoryPathName = mReactContext.filesDir.absolutePath + "/.mapbox/map_data"
+            val sourcePathName = mReactContext.filesDir.absolutePath + "/mbgl-offline.db"
+            val sourcePath = Paths.get(sourcePathName)
+            val targetPath = Paths.get("$targetDirectoryPathName/map_data.db")
+
+            try {
+                val source = File(sourcePath.toString())
+
+                if (!source.exists()) {
+                    Log.d(LOG_TAG, "Nothing to migrate")
+                    promise.resolve(false)
+                    return
+                }
+
+                val directory = File(targetDirectoryPathName)
+
+                directory.mkdirs()
+                Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING)
+                Log.d(LOG_TAG, "v10 cache directory created successfully")
+                promise.resolve(true)
+            } catch (e: Exception) {
+                val mes = "${e}... file move unsuccessful"
+                Log.d(LOG_TAG, mes)
+                promise.reject(mes)
+            }
+        } else {
+            val mes = "\"migrateOfflineCache only supported on api level 26 or later\""
+            Log.w(LOG_TAG, "migrateOfflineCache only supported on api level 26 or later")
+            promise.reject(mes)
+        }
+    }
+}

package/android/src/main/mapbox-v11-compat/v10/com/rnmapbox/rnmbx/v11compat/Annotation.kt

@@ -21,6 +21,10 @@ fun ViewAnnotationOptions.Builder.height(value: Double): ViewAnnotationOptions.B
   return this.height(value.toInt())
 }
 
+fun com.mapbox.maps.ViewAnnotationOptions.Builder.allowOverlapWithPuck(value: Boolean): ViewAnnotationOptions.Builder {
+  return this;
+}
+
 abstract class OnViewAnnotationUpdatedListener : _OnViewAnnotationUpdatedListener {
   override fun onViewAnnotationPositionUpdated(
     view: View,

package/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/Annotation.kt

@@ -27,7 +27,6 @@ fun ViewAnnotationOptions.Builder.offsets(x: Double, y: Double) {
   ))
 }
 
-
 abstract class OnViewAnnotationUpdatedListener : _OnViewAnnotationUpdatedListener {
 
 }

package/android/src/main/old-arch/com/facebook/react/viewmanagers/RNMBXMarkerViewManagerDelegate.java

@@ -31,6 +31,9 @@ public class RNMBXMarkerViewManagerDelegate<T extends View, U extends BaseViewMa
       case "allowOverlap":
         mViewManager.setAllowOverlap(view, new DynamicFromObject(value));
         break;
+      case "allowOverlapWithPuck":
+        mViewManager.setAllowOverlapWithPuck(view, new DynamicFromObject(value));
+        break;
       case "isSelected":
         mViewManager.setIsSelected(view, new DynamicFromObject(value));
         break;

package/android/src/main/old-arch/com/facebook/react/viewmanagers/RNMBXMarkerViewManagerInterface.java

@@ -16,5 +16,6 @@ public interface RNMBXMarkerViewManagerInterface<T extends View> {
   void setCoordinate(T view, Dynamic value);
   void setAnchor(T view, Dynamic value);
   void setAllowOverlap(T view, Dynamic value);
+  void setAllowOverlapWithPuck(T view, Dynamic value);
   void setIsSelected(T view, Dynamic value);
 }

package/ios/RNMBX/RNMBXMarkerView.swift

@@ -60,6 +60,12 @@ public class RNMBXMarkerView: UIView, RNMBXMapComponent {
     }
   }
   
+  @objc public var allowOverlapWithPuck: Bool = false {
+    didSet {
+      update()
+    }
+  }
+  
   @objc public var isSelected: Bool = false {
     didSet {
       update()
@@ -227,7 +233,7 @@ public class RNMBXMarkerView: UIView, RNMBXMapComponent {
     let size = self.bounds.size
     let offset = calcOffset(size: size)
   
-    let options = ViewAnnotationOptions(
+    var options = ViewAnnotationOptions(
       geometry: geometry,
       width: size.width,
       height: size.height,
@@ -236,6 +242,9 @@ public class RNMBXMarkerView: UIView, RNMBXMapComponent {
       offsetY: offset.dy,
       selected: isSelected
     )
+    #if RNMBX_11
+    options.allowOverlapWithPuck = allowOverlapWithPuck
+    #endif
     return options
   }
   

package/ios/RNMBX/RNMBXMarkerViewComponentView.mm

@@ -84,6 +84,10 @@ using namespace facebook::react;
     if (allowOverlap != nil) {
         _view.allowOverlap = allowOverlap;
     }
+    id allowOverlapWithPuck = RNMBXConvertFollyDynamicToId(newProps.allowOverlapWithPuck);
+    if (allowOverlapWithPuck != nil) {
+        _view.allowOverlapWithPuck = allowOverlapWithPuck;
+    }
     id isSelected = RNMBXConvertFollyDynamicToId(newProps.isSelected);
     if (isSelected != nil) {
         _view.isSelected = isSelected;

package/ios/RNMBX/RNMBXMarkerViewManager.m

@@ -7,6 +7,7 @@
 RCT_EXPORT_VIEW_PROPERTY(coordinate, NSString)
 RCT_EXPORT_VIEW_PROPERTY(anchor, NSDictionary)
 RCT_EXPORT_VIEW_PROPERTY(allowOverlap, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(allowOverlapWithPuck, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(isSelected, BOOL)
 
 @end

package/ios/RNMBX/RNMBXOfflineModule.m

@@ -31,4 +31,4 @@ RCT_EXTERN_METHOD(migrateOfflineCache:(RCTPromiseResolveBlock)resolve reject:(RC
 
 RCT_EXTERN_METHOD(resetDatabase:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 
-@end
+@end