@rnmapbox/maps 10.1.0-beta.5 → 10.1.0-beta.7

package/android/install.md

@@ -35,6 +35,20 @@ allprojects {
 }
 ```
 
+### Setting Mapbox implementation
+
+Note 10.1 or later only supports mapbox 10 and 11 implementations. So you no longer need to set this variable:
+
+Set `RNMapboxMapsImpl` in `android/build.gradle > buildscript > ext` section
+
+```groovy
+buildscript {
+    ext {
+        RNMapboxMapsImpl = 'mapbox'
+    }
+}
+```
+
 ### Using non default mapbox version
 
 *Warning*: If you set a custom version, make sure you revisit, any time you update @rnmapbox/maps. Setting it to earlier version than what we exepect will likely result in a build error.

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

@@ -0,0 +1,182 @@
+package com.rnmapbox.rnmbx
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.JavaScriptModule
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+import com.rnmapbox.rnmbx.components.annotation.RNMBXCalloutManager
+import com.rnmapbox.rnmbx.components.annotation.RNMBXMarkerViewManager
+import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotationManager
+import com.rnmapbox.rnmbx.components.camera.RNMBXCameraManager
+import com.rnmapbox.rnmbx.components.images.RNMBXImageManager
+import com.rnmapbox.rnmbx.components.images.RNMBXImagesManager
+import com.rnmapbox.rnmbx.components.location.RNMBXNativeUserLocationManager
+import com.rnmapbox.rnmbx.components.mapview.NativeMapViewModule
+import com.rnmapbox.rnmbx.components.mapview.RNMBXAndroidTextureMapViewManager
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapViewManager
+import com.rnmapbox.rnmbx.components.styles.RNMBXStyleImportManager
+import com.rnmapbox.rnmbx.components.styles.atmosphere.RNMBXAtmosphereManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXBackgroundLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXCircleLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXFillExtrusionLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXFillLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXHeatmapLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXLineLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXRasterLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXSkyLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXSymbolLayerManager
+import com.rnmapbox.rnmbx.components.styles.light.RNMBXLightManager
+import com.rnmapbox.rnmbx.components.styles.sources.RNMBXImageSourceManager
+import com.rnmapbox.rnmbx.components.styles.sources.RNMBXRasterDemSourceManager
+import com.rnmapbox.rnmbx.components.styles.sources.RNMBXRasterSourceManager
+import com.rnmapbox.rnmbx.components.styles.sources.RNMBXShapeSourceManager
+import com.rnmapbox.rnmbx.components.styles.sources.RNMBXVectorSourceManager
+import com.rnmapbox.rnmbx.components.styles.terrain.RNMBXTerrainManager
+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.RNMBXSnapshotModule
+import com.rnmapbox.rnmbx.utils.ViewTagResolver
+
+class RNMBXPackage : TurboReactPackage() {
+
+    var mapViewTagResolver: ViewTagResolver<RNMBXMapView>? = null
+    fun getMapViewTagResolver(context: ReactApplicationContext) : ViewTagResolver<RNMBXMapView> {
+        val viewTagResolver = mapViewTagResolver
+        if (viewTagResolver == null) {
+            val viewTagResolver = ViewTagResolver<RNMBXMapView>(context)
+            mapViewTagResolver = viewTagResolver
+            return viewTagResolver
+        }
+        return viewTagResolver
+    }
+
+    override fun getModule(
+        s: String,
+        reactApplicationContext: ReactApplicationContext
+    ): NativeModule? {
+        when (s) {
+            RNMBXModule.REACT_CLASS -> return RNMBXModule(reactApplicationContext)
+            RNMBXLocationModule.REACT_CLASS -> return RNMBXLocationModule(reactApplicationContext)
+            RNMBXOfflineModule.REACT_CLASS -> return RNMBXOfflineModule(reactApplicationContext)
+            RNMBXSnapshotModule.REACT_CLASS -> return RNMBXSnapshotModule(reactApplicationContext)
+            RNMBXLogging.REACT_CLASS -> return RNMBXLogging(reactApplicationContext)
+            NativeMapViewModule.NAME -> return NativeMapViewModule(reactApplicationContext, getMapViewTagResolver(reactApplicationContext))
+        }
+        return null
+    }
+
+    @Deprecated("")
+    fun createJSModules(): List<Class<out JavaScriptModule?>> {
+        return emptyList()
+    }
+
+    override fun createViewManagers(reactApplicationContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        val managers: MutableList<ViewManager<*, *>> = ArrayList()
+
+        // components
+        managers.add(RNMBXCameraManager(reactApplicationContext))
+        managers.add(RNMBXAndroidTextureMapViewManager(reactApplicationContext, getMapViewTagResolver(reactApplicationContext)))
+        managers.add(RNMBXMapViewManager(reactApplicationContext, getMapViewTagResolver(reactApplicationContext)))
+        managers.add(RNMBXStyleImportManager(reactApplicationContext))
+
+        // annotations
+        managers.add(RNMBXMarkerViewManager(reactApplicationContext))
+        managers.add(RNMBXPointAnnotationManager(reactApplicationContext))
+        managers.add(RNMBXCalloutManager())
+        managers.add(RNMBXNativeUserLocationManager())
+
+        // sources
+        managers.add(RNMBXVectorSourceManager(reactApplicationContext))
+        managers.add(RNMBXShapeSourceManager(reactApplicationContext))
+        managers.add(RNMBXRasterDemSourceManager(reactApplicationContext))
+        managers.add(RNMBXRasterSourceManager(reactApplicationContext))
+        managers.add(RNMBXImageSourceManager())
+
+        // images
+        managers.add(RNMBXImagesManager(reactApplicationContext))
+        managers.add(RNMBXImageManager(reactApplicationContext))
+
+        // layers
+        managers.add(RNMBXFillLayerManager())
+        managers.add(RNMBXFillExtrusionLayerManager())
+        managers.add(RNMBXHeatmapLayerManager())
+        managers.add(RNMBXLineLayerManager())
+        managers.add(RNMBXCircleLayerManager())
+        managers.add(RNMBXSymbolLayerManager())
+        managers.add(RNMBXRasterLayerManager())
+        managers.add(RNMBXSkyLayerManager())
+        managers.add(RNMBXTerrainManager())
+        managers.add(RNMBXAtmosphereManager())
+        managers.add(RNMBXBackgroundLayerManager())
+        managers.add(RNMBXLightManager())
+        return managers
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+            val isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+            moduleInfos[RNMBXModule.REACT_CLASS] = ReactModuleInfo(
+                RNMBXModule.REACT_CLASS,
+                RNMBXModule.REACT_CLASS,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                true,  // hasConstants
+                false,  // isCxxModule
+                false // isTurboModule
+            )
+            moduleInfos[RNMBXLocationModule.REACT_CLASS] = ReactModuleInfo(
+                RNMBXLocationModule.REACT_CLASS,
+                RNMBXLocationModule.REACT_CLASS,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                true,  // hasConstants
+                false,  // isCxxModule
+                false // isTurboModule
+            )
+            moduleInfos[RNMBXOfflineModule.REACT_CLASS] = ReactModuleInfo(
+                RNMBXOfflineModule.REACT_CLASS,
+                RNMBXOfflineModule.REACT_CLASS,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                true,  // hasConstants
+                false,  // isCxxModule
+                false // isTurboModule
+            )
+            moduleInfos[RNMBXSnapshotModule.REACT_CLASS] = ReactModuleInfo(
+                RNMBXSnapshotModule.REACT_CLASS,
+                RNMBXSnapshotModule.REACT_CLASS,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                true,  // hasConstants
+                false,  // isCxxModule
+                false // isTurboModule
+            )
+            moduleInfos[RNMBXLogging.REACT_CLASS] = ReactModuleInfo(
+                RNMBXLogging.REACT_CLASS,
+                RNMBXLogging.REACT_CLASS,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                true,  // hasConstants
+                false,  // isCxxModule
+                false // isTurboModule
+            )
+            moduleInfos[NativeMapViewModule.NAME] = ReactModuleInfo(
+                NativeMapViewModule.NAME,
+                NativeMapViewModule.NAME,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                false,  // hasConstants
+                false,  // isCxxModule
+                isTurboModule // isTurboModule
+            )
+            moduleInfos
+        }
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXCamera.kt

@@ -91,9 +91,11 @@ class RNMBXCamera(private val mContext: Context, private val mManager: RNMBXCame
 
     override fun addToMap(mapView: RNMBXMapView) {
         super.addToMap(mapView)
-        setInitialCamera()
-        updateMaxBounds()
-        mCameraStop?.let { updateCamera(it) }
+        mapView.callIfAttachedToWindow {
+            setInitialCamera()
+            updateMaxBounds()
+            mCameraStop?.let { updateCamera(it) }
+        }
         _observeViewportState(mapView.mapView)
         _updateViewportState()
     }

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

@@ -1,38 +1,34 @@
 package com.rnmapbox.rnmbx.components.mapview
 
+import android.util.Log
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.UIManager
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.IllegalViewOperationException
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.common.UIManagerType
 import com.rnmapbox.rnmbx.BuildConfig
 import com.rnmapbox.rnmbx.NativeMapViewModuleSpec
 import com.rnmapbox.rnmbx.utils.ConvertUtils
 import com.rnmapbox.rnmbx.utils.ExpressionParser
+import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.utils.ViewTagResolver
 import com.rnmapbox.rnmbx.utils.extensions.toCoordinate
 import com.rnmapbox.rnmbx.utils.extensions.toScreenCoordinate
 
-class NativeMapViewModule(context: ReactApplicationContext) : NativeMapViewModuleSpec(context) {
-    private fun withMapViewOnUIThread(viewRef: Double?, promise: Promise, fn: (RNMBXMapView) -> Unit) {
+class NativeMapViewModule(context: ReactApplicationContext, val viewTagResolver: ViewTagResolver<RNMBXMapView>) : NativeMapViewModuleSpec(context) {
+    private fun withMapViewOnUIThread(
+        viewRef: Double?,
+        reject: Promise,
+        fn: (RNMBXMapView) -> Unit
+    ) {
         if (viewRef == null) {
-            return
-        }
-
-        reactApplicationContext.runOnUiQueueThread {
-            val manager = if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED)
-                UIManagerHelper.getUIManager(reactApplicationContext, UIManagerType.FABRIC)
-            else
-                UIManagerHelper.getUIManager(reactApplicationContext, UIManagerType.DEFAULT)
-
-            val view = manager?.resolveView(viewRef.toInt()) as? RNMBXMapView
-
-            if (view != null) {
-                fn(view)
-            } else {
-                promise.reject(Exception("cannot find map view for tag ${viewRef.toInt()}"))
-            }
+            reject.reject(Exception("viewRef is null"))
+        } else {
+            viewTagResolver.withViewResolved(viewRef.toInt(), reject, fn)
         }
     }
 

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

@@ -7,9 +7,11 @@ import com.facebook.react.viewmanagers.RNMBXAndroidTextureMapViewManagerDelegate
 import com.facebook.react.viewmanagers.RNMBXAndroidTextureMapViewManagerInterface
 import com.facebook.react.viewmanagers.RNMBXMapViewManagerDelegate
 import com.mapbox.maps.MapInitOptions
+import com.rnmapbox.rnmbx.utils.ViewTagResolver
 
-class RNMBXAndroidTextureMapViewManager(context: ReactApplicationContext) : RNMBXMapViewManager(
-    context
+class RNMBXAndroidTextureMapViewManager(context: ReactApplicationContext, viewTagResolver: ViewTagResolver<RNMBXMapView>) : RNMBXMapViewManager(
+    context,
+    viewTagResolver
 ), RNMBXAndroidTextureMapViewManagerInterface<RNMBXMapView> {
     private val mDelegate: ViewManagerDelegate<RNMBXMapView>
 

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

@@ -4,6 +4,8 @@ import android.content.Context
 import android.graphics.BitmapFactory
 import android.graphics.PointF
 import android.graphics.RectF
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
 import android.view.Gravity
 import android.view.View
@@ -102,6 +104,10 @@ interface RNMBXLifeCycleOwner : LifecycleOwner {
     fun handleLifecycleEvent(event: Lifecycle.Event)
 }
 
+fun interface Cancelable {
+    fun cancel()
+}
+
 class RNMBXLifeCycle {
     private var lifecycleOwner : RNMBXLifeCycleOwner? = null
 
@@ -150,6 +156,25 @@ class RNMBXLifeCycle {
     fun getState() : Lifecycle.State {
         return lifecycleOwner?.lifecycle?.currentState ?: Lifecycle.State.INITIALIZED;
     }
+
+    var attachedToWindowWaiters : MutableList<()-> Unit> = mutableListOf()
+
+    fun callIfAttachedToWindow(callback: () -> Unit) : com.rnmapbox.rnmbx.components.mapview.Cancelable {
+        if (getState() == Lifecycle.State.STARTED) {
+            callback()
+            return com.rnmapbox.rnmbx.components.mapview.Cancelable {}
+        } else {
+            attachedToWindowWaiters.add(callback)
+            return com.rnmapbox.rnmbx.components.mapview.Cancelable {
+                attachedToWindowWaiters.removeIf { it === callback }
+            }
+        }
+    }
+
+    fun afterAttachFromLooper() {
+        attachedToWindowWaiters.forEach { it() }
+        attachedToWindowWaiters.clear()
+    }
 }
 
 data class FeatureEntry(val feature: AbstractMapFeature?, val view: View?, var addedToMap: Boolean = false) {
@@ -215,6 +240,11 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
         return mapView.getMapboxMap()
     }
 
+    override fun setId(id: Int) {
+        super.setId(id)
+        mManager.tagAssigned(id)
+    }
+
     val pointAnnotationManager: PointAnnotationManager?
         get() {
             if (mPointAnnotationManager == null) {
@@ -438,6 +468,8 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
             feature = childView
         } else if (childView is RCTLayer<*>) {
             feature = childView as AbstractMapFeature?
+        } else if (childView is AbstractMapFeature) {
+            feature = childView as AbstractMapFeature
         } else if (childView is ViewGroup) {
             val children = childView
             Logger.w(LOG_TAG, "Adding non map components as a child of a map is deprecated!")
@@ -448,7 +480,6 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
 
         val addToMap = styleLoaded
 
-
         var entry = FeatureEntry(feature, childView, false)
         if (addToMap) {
             feature?.addToMap(this)
@@ -1412,6 +1443,13 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
     override fun onAttachedToWindow() {
         lifecycle.onAttachedToWindow(this)
         super.onAttachedToWindow()
+        Handler(Looper.getMainLooper()).post {
+            lifecycle.afterAttachFromLooper()
+        }
+    }
+
+    fun callIfAttachedToWindow(callback: () -> Unit) {
+       lifecycle.callIfAttachedToWindow(callback)
     }
 
     override fun onLayoutChange(

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

@@ -22,6 +22,7 @@ import com.rnmapbox.rnmbx.events.AndroidCallbackEvent
 import com.rnmapbox.rnmbx.utils.ConvertUtils
 import com.rnmapbox.rnmbx.utils.ExpressionParser
 import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.utils.ViewTagResolver
 import com.rnmapbox.rnmbx.utils.extensions.toCoordinate
 import com.rnmapbox.rnmbx.utils.extensions.toRectF
 import com.rnmapbox.rnmbx.utils.extensions.toScreenCoordinate
@@ -46,7 +47,7 @@ interface CommandResponse {
     fun error(message: String)
 }
 
-open class RNMBXMapViewManager(context: ReactApplicationContext) :
+open class RNMBXMapViewManager(context: ReactApplicationContext, val viewTagResolver: ViewTagResolver<RNMBXMapView>) :
     AbstractEventEmitter<RNMBXMapView>(context), RNMBXMapViewManagerInterface<RNMBXMapView> {
     private val mViews: MutableMap<Int, RNMBXMapView>
 
@@ -107,6 +108,9 @@ open class RNMBXMapViewManager(context: ReactApplicationContext) :
 
     override fun onDropViewInstance(mapView: RNMBXMapView) {
         val reactTag = mapView.id
+
+        viewTagResolver.viewRemoved(reactTag)
+
         if (mViews.containsKey(reactTag)) {
             mViews.remove(reactTag)
         }
@@ -118,6 +122,10 @@ open class RNMBXMapViewManager(context: ReactApplicationContext) :
         return mViews[reactTag]
     }
 
+    fun tagAssigned(reactTag: Int) {
+        return viewTagResolver.tagAssigned(reactTag)
+    }
+
     // region React Props
     @ReactProp(name = "projection")
     override fun setProjection(mapView: RNMBXMapView, projection: String?) {

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleImport.kt

@@ -0,0 +1,37 @@
+package com.rnmapbox.rnmbx.components.styles
+
+import android.content.Context
+import android.view.ViewGroup
+import com.mapbox.bindgen.Value
+import com.rnmapbox.rnmbx.components.AbstractMapFeature
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+
+import com.rnmapbox.rnmbx.v11compat.style.*
+
+class RNMBXStyleImport(context: Context) : AbstractMapFeature(context) {
+    var id: String? = null;
+
+    var config: HashMap<String, Value> = hashMapOf()
+        set(value: HashMap<String, Value>) {
+            field = value
+            if (mMapView != null) { updateConfig() }
+        }
+
+    override fun addToMap(mapView: RNMBXMapView) {
+        super.addToMap(mapView)
+        updateConfig()
+    }
+
+    fun updateConfig() {
+        withMapView {mapView ->
+            id?.let { id ->
+                val config = this.config
+                if (config.isNotEmpty()) {
+                    mapView.mapView.getMapboxMap().getStyle()
+                        ?.setStyleImportConfigProperties(id, config)
+                }
+            }
+        }
+
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleImportManager.kt

@@ -0,0 +1,57 @@
+package com.rnmapbox.rnmbx.components.styles
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNMBXStyleImportManagerInterface
+import com.rnmapbox.rnmbx.components.AbstractEventEmitter
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.mapbox.bindgen.Value
+import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.utils.extensions.toValueHashMap
+import org.json.JSONObject
+
+class RNMBXStyleImportManager(context: ReactApplicationContext) :
+    AbstractEventEmitter<RNMBXStyleImport>(context),
+    RNMBXStyleImportManagerInterface<RNMBXStyleImport> {
+    override fun customEvents(): Map<String, String>? {
+        return MapBuilder.builder<String, String>().build()
+    }
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun createViewInstance(context: ThemedReactContext): RNMBXStyleImport {
+        return RNMBXStyleImport(context)
+    }
+
+    companion object {
+        const val REACT_CLASS = "RNMBXStyleImport"
+    }
+
+    @ReactProp(name = "id")
+    override fun setId(view: RNMBXStyleImport, value: String?) {
+        if (value != null) {
+            view.id = value
+        }
+    }
+
+    @ReactProp(name = "existing")
+    override fun setExisting(view: RNMBXStyleImport, value: Boolean) {
+
+    }
+
+    @ReactProp(name = "config")
+    override fun setConfig(view: RNMBXStyleImport, value: Dynamic) {
+        if (value.type != ReadableType.Map) {
+            Logger.e(REACT_CLASS, "config expected Map but received: ${value.type}")
+        } else {
+            view.config = value.asMap().toValueHashMap()
+        }
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleValue.kt

@@ -169,12 +169,12 @@ class RNMBXStyleValue(config: ReadableMap) {
                     config.getMap("enablePlacementTransitions")!!.getBoolean("value")
             }
             var duration = 300
-            val delay = 0
+            var delay = 0
             if (config.hasKey("duration") && ReadableType.Map == config.getType("duration")) {
                 duration = config.getMap("duration")!!.getInt("value")
             }
             if (config.hasKey("delay") && ReadableType.Map == config.getType("delay")) {
-                duration = config.getMap("delay")!!.getInt("value")
+                delay = config.getMap("delay")!!.getInt("value")
             }
             return Builder().duration(duration.toLong()).delay(delay.toLong()).build()
         }

package/android/src/main/java/com/rnmapbox/rnmbx/utils/ViewTagResolver.kt

@@ -0,0 +1,68 @@
+package com.rnmapbox.rnmbx.utils
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.uimanager.IllegalViewOperationException
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.rnmapbox.rnmbx.BuildConfig
+
+data class ViewTagWaiter<V>(
+    val fn: (V) -> Unit,
+    val reject: Promise?
+)
+
+// see https://github.com/rnmapbox/maps/pull/3074
+open class ViewTagResolver<V>(val context: ReactApplicationContext) {
+    private val createdViews: HashSet<Int> = hashSetOf<Int>()
+    private val viewWaiters: HashMap<Int, MutableList<ViewTagWaiter<V>>> = hashMapOf()
+
+    // to be called from view.setId
+    fun tagAssigned(viewTag: Int) {
+        createdViews.add(viewTag)
+
+        val list = viewWaiters[viewTag]
+        if (list != null) {
+            context.runOnUiQueueThread {
+                try {
+                    val view = manager.resolveView(viewTag) as V
+
+                    list.forEach { it.fn(view) }
+                } catch (err: IllegalViewOperationException) {
+                    list.forEach { it.reject?.reject(err) }
+                }
+                viewWaiters.remove(viewTag)
+            }
+        }
+    }
+
+    fun viewRemoved(viewTag: Int) {
+        viewWaiters.remove(viewTag)
+        createdViews.remove(viewTag)
+    }
+
+    private val manager : UIManager
+        get() =
+            if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+                UIManagerHelper.getUIManager(context, UIManagerType.FABRIC)!!
+            } else {
+                UIManagerHelper.getUIManager(context, UIManagerType.DEFAULT)!!
+            }
+
+    // calls on UiQueueThread with resolved view
+    fun withViewResolved(viewTag: Int, reject: Promise? = null, fn: (V) -> Unit) {
+        context.runOnUiQueueThread() {
+            try {
+                val view = manager.resolveView(viewTag) as V
+                fn(view)
+            } catch (err: IllegalViewOperationException) {
+                if (!createdViews.contains(viewTag)) {
+                    viewWaiters.getOrPut(viewTag) { mutableListOf<ViewTagWaiter<V>>() }.add(ViewTagWaiter(fn, reject))
+                } else {
+                    reject?.reject(err)
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Dynamic.kt

@@ -0,0 +1,57 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.mapbox.bindgen.Value
+
+fun ReadableMap.toValueHashMap(): HashMap<String, Value> {
+    var result = hashMapOf<String, Value>()
+    var iterator = keySetIterator()
+    while (iterator.hasNextKey()) {
+        val i = iterator.nextKey()
+
+        result[i] = when (getType(i)) {
+            ReadableType.Null -> Value.nullValue()
+            ReadableType.Boolean -> Value.valueOf(getBoolean(i))
+            ReadableType.Number -> Value.valueOf(getDouble(i))
+            ReadableType.String -> Value.valueOf(getString(i)!!)
+            ReadableType.Array -> getArray(i)!!.toValue()
+            ReadableType.Map -> getMap(i)!!.toValue()
+        }
+    }
+    return result
+}
+
+fun ReadableMap.toValue() : Value {
+    return Value.valueOf(toValueHashMap())
+}
+
+fun ReadableArray.toValue(): Value {
+    var result = ArrayList<Value>(size())
+
+    for (i in 0 until size()) {
+        result.add(
+        when (getType(i)) {
+            ReadableType.Null -> Value.nullValue()
+            ReadableType.Boolean -> Value.valueOf(getBoolean(i))
+            ReadableType.Number -> Value.valueOf(getDouble(i))
+            ReadableType.String -> Value.valueOf(getString(i))
+            ReadableType.Array -> getArray(i).toValue()
+            ReadableType.Map -> getMap(i).toValue()
+        })
+    }
+    return Value.valueOf(result)
+}
+
+fun Dynamic.toValue(): Value {
+    return when (type) {
+        ReadableType.Null -> Value.nullValue()
+        ReadableType.Boolean -> Value.valueOf(asBoolean())
+        ReadableType.Number -> Value.valueOf(asDouble())
+        ReadableType.String -> Value.valueOf(asString())
+        ReadableType.Array -> asArray().toValue()
+        ReadableType.Map -> asMap().toValue()
+    }
+}

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

@@ -0,0 +1,9 @@
+package com.rnmapbox.rnmbx.v11compat.style;
+
+import com.mapbox.bindgen.Value
+import com.mapbox.maps.Style
+import com.rnmapbox.rnmbx.utils.Logger
+
+fun Style?.setStyleImportConfigProperties(id: String, config: HashMap<String, Value>) {
+    Logger.w("RNBMXStyleImport", "Style imports only supported on mapbox v11")
+}

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

@@ -0,0 +1,2 @@
+package com.rnmapbox.rnmbx.v11compat.style;
+

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

@@ -1,7 +1,8 @@
 /**
 * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
 *
-* This file should be updated after modifying `RNMBXAndroidTextureMapViewNativeComponent.ts`.
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
 *
 * @generated by codegen project: GeneratePropsJavaDelegate.js
 */