@rnmapbox/maps 10.0.15 → 10.1.0-beta.4

package/android/src/main/java-v10/com/mapbox/rctmgl/components/location/LocationComponentManager.kt

@@ -9,11 +9,13 @@ import androidx.lifecycle.Lifecycle
 import com.mapbox.maps.plugin.locationcomponent.location
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
 import com.mapbox.maps.plugin.LocationPuck2D
-import com.mapbox.maps.plugin.PuckBearingSource
 import com.mapbox.maps.plugin.lifecycle.lifecycle
 import com.mapbox.rctmgl.R
 import com.mapbox.rctmgl.location.LocationManager
 
+import com.mapbox.rctmgl.v11compat.location.PuckBearingSource;
+import com.mapbox.rctmgl.v11compat.image.*;
+
 /**
  * The LocationComponent on android implements display of user's current location.
  * But viewport seems to be tied to it in the sense that if location is not enabled then it's viewport user tracking is not working.
@@ -35,7 +37,7 @@ class LocationComponentManager(mapView: RCTMGLMapView, context: Context) {
         val showUserLocation: Boolean,
         val followUserLocation: Boolean,
         val tintColor: Int?, // tint of location puck
-        var bearingImage: Drawable?, // bearing image (background)
+        var bearingImage: ImageHolder?, // bearing image (background)
         var puckBearingSource: PuckBearingSource? // bearing source
     ) {
         val enabled: Boolean
@@ -79,7 +81,7 @@ class LocationComponentManager(mapView: RCTMGLMapView, context: Context) {
             if (fullUpdate || (newState.hidden != oldState.hidden) || (newState.tintColor != oldState.tintColor) || (newState.bearingImage != oldState.bearingImage)) {
                 if (newState.hidden) {
                     var emptyLocationPuck = LocationPuck2D()
-                    val empty = AppCompatResources.getDrawable(mContext, R.drawable.empty)
+                    val empty = AppCompatResourcesV11.getDrawableImageHolder(mContext, R.drawable.empty)
                     emptyLocationPuck.bearingImage = empty
                     emptyLocationPuck.shadowImage = empty
                     emptyLocationPuck.topImage = empty
@@ -90,18 +92,18 @@ class LocationComponentManager(mapView: RCTMGLMapView, context: Context) {
                     val mapboxBlueColor = Color.parseColor("#4A90E2")
                     val tintColor = newState.tintColor
                     val defaultLocationPuck = LocationPuck2D()
-                    var topImage = AppCompatResources.getDrawable(mContext, R.drawable.mapbox_user_icon)
+                    var topImage = AppCompatResourcesV11.getDrawableImageHolder(mContext, R.drawable.mapbox_user_icon)
                     if (tintColor != null) {
-                        val drawable = topImage as VectorDrawable?
+                        val drawable = AppCompatResources.getDrawable(mContext, R.drawable.mapbox_user_icon) as VectorDrawable?
                         drawable!!.setTint(tintColor)
-                        topImage = drawable
+                        topImage = drawable.toBitmapImageHolder()
                     }
                     defaultLocationPuck.topImage = topImage
-                    val defaultBearingImage = AppCompatResources.getDrawable(
+                    val defaultBearingImage = AppCompatResourcesV11.getDrawableImageHolder(
                         mContext, R.drawable.mapbox_user_stroke_icon
-                    );
+                    )
                     defaultLocationPuck.bearingImage = newState.bearingImage ?: defaultBearingImage
-                    val shadowImage = AppCompatResources.getDrawable(
+                    val shadowImage = AppCompatResourcesV11.getDrawableImageHolder(
                         mContext, R.drawable.mapbox_user_icon_shadow
                     )
                     defaultLocationPuck.shadowImage = shadowImage

package/android/src/main/java-v10/com/mapbox/rctmgl/components/location/RCTMGLNativeUserLocation.kt

@@ -7,12 +7,14 @@ import com.mapbox.rctmgl.components.mapview.OnMapReadyCallback
 import com.mapbox.maps.MapboxMap
 import com.mapbox.android.core.permissions.PermissionsManager
 import com.mapbox.maps.Style
-import com.mapbox.maps.plugin.PuckBearingSource
 import com.mapbox.rctmgl.R
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.RemovalReason
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
 
+import com.mapbox.rctmgl.v11compat.location.PuckBearingSource
+import com.mapbox.rctmgl.v11compat.image.AppCompatResourcesV11
+
 enum class RenderMode {
     GPS, COMPASS, NORMAL
 }
@@ -69,10 +71,10 @@ class RCTMGLNativeUserLocation(context: Context) : AbstractMapFeature(context),
                 RenderMode.NORMAL ->
                     it.update { it.copy(bearingImage =  null, puckBearingSource = null)}
                 RenderMode.GPS -> it.update {
-                    it.copy(bearingImage =  AppCompatResources.getDrawable(
+                    it.copy(bearingImage =  AppCompatResourcesV11.getDrawableImageHolder(
                         mContext, R.drawable.mapbox_user_bearing_icon
                     ), puckBearingSource = PuckBearingSource.COURSE) }
-                RenderMode.COMPASS -> it.update{ it.copy(bearingImage=  AppCompatResources.getDrawable(
+                RenderMode.COMPASS -> it.update{ it.copy(bearingImage=  AppCompatResourcesV11.getDrawableImageHolder(
                     mContext, R.drawable.mapbox_user_puck_icon
                 ), puckBearingSource = PuckBearingSource.HEADING) }
             }

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

@@ -0,0 +1,193 @@
+package com.mapbox.rctmgl.components.mapview
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.mapbox.rctmgl.BuildConfig
+import com.mapbox.rctmgl.NativeMapViewModuleSpec
+import com.mapbox.rctmgl.utils.ConvertUtils
+import com.mapbox.rctmgl.utils.ExpressionParser
+import com.mapbox.rctmgl.utils.extensions.toCoordinate
+import com.mapbox.rctmgl.utils.extensions.toScreenCoordinate
+
+class NativeMapViewModule(context: ReactApplicationContext) : NativeMapViewModuleSpec(context) {
+    private fun withMapViewOnUIThread(viewRef: Double?, promise: Promise, fn: (RCTMGLMapView) -> 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? RCTMGLMapView
+
+            if (view != null) {
+                fn(view)
+            } else {
+                promise.reject(Exception("cannot find map view for tag ${viewRef.toInt()}"))
+            }
+        }
+    }
+
+    private fun createCommandResponse(promise: Promise): CommandResponse = object : CommandResponse {
+        override fun success(builder: (WritableMap) -> Unit) {
+            val payload: WritableMap = WritableNativeMap()
+            builder(payload)
+
+            promise.resolve(payload)
+        }
+
+        override fun error(message: String) {
+            promise.reject(Exception(message))
+        }
+    }
+
+    override fun takeSnap(viewRef: Double?, writeToDisk: Boolean, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.takeSnap(writeToDisk, createCommandResponse(promise))
+        }
+    }
+
+    override fun queryTerrainElevation(
+        viewRef: Double?,
+        coordinates: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.queryTerrainElevation(coordinates.getDouble(0), coordinates.getDouble(1), createCommandResponse(promise))
+        }
+    }
+
+    override fun setSourceVisibility(
+        viewRef: Double?,
+        visible: Boolean,
+        sourceId: String,
+        sourceLayerId: String?,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.setSourceVisibility(visible, sourceId, sourceLayerId)
+
+            promise.resolve(null)
+        }
+    }
+
+    override fun getCenter(viewRef: Double?, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getCenter(createCommandResponse(promise))
+        }
+    }
+
+    override fun getCoordinateFromView(
+        viewRef: Double?,
+        atPoint: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getCoordinateFromView(atPoint.toScreenCoordinate(), createCommandResponse(promise))
+        }
+    }
+
+    override fun getPointInView(viewRef: Double?, atCoordinate: ReadableArray, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getPointInView(atCoordinate.toCoordinate(), createCommandResponse(promise))
+        }
+    }
+
+    override fun getZoom(viewRef: Double?, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getZoom(createCommandResponse(promise))
+        }
+    }
+
+    override fun getVisibleBounds(viewRef: Double?, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getVisibleBounds(createCommandResponse(promise))
+        }
+    }
+
+    override fun queryRenderedFeaturesAtPoint(
+        viewRef: Double?,
+        atPoint: ReadableArray,
+        withFilter: ReadableArray,
+        withLayerIDs: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            val layerIds = ConvertUtils.toStringList(withLayerIDs)
+
+            it.queryRenderedFeaturesAtPoint(
+                ConvertUtils.toPointF(atPoint),
+                ExpressionParser.from(withFilter),
+                if (layerIds.size == 0) null else layerIds,
+                createCommandResponse(promise)
+            )
+        }
+    }
+
+    override fun queryRenderedFeaturesInRect(
+        viewRef: Double?,
+        withBBox: ReadableArray,
+        withFilter: ReadableArray,
+        withLayerIDs: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            val layerIds = ConvertUtils.toStringList(withLayerIDs)
+
+            it.queryRenderedFeaturesInRect(
+                ConvertUtils.toRectF(withBBox),
+                ExpressionParser.from(withFilter),
+                if (layerIds.size == 0) null else layerIds,
+                createCommandResponse(promise)
+            )
+        }
+    }
+
+    override fun setHandledMapChangedEvents(
+        viewRef: Double?,
+        events: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.setHandledMapChangedEvents(events.asArrayString())
+            promise.resolve(null)
+        }
+    }
+
+    override fun clearData(viewRef: Double?, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.clearData(createCommandResponse(promise))
+        }
+    }
+
+    override fun querySourceFeatures(
+        viewRef: Double?,
+        sourceId: String,
+        withFilter: ReadableArray,
+        withSourceLayerIDs: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            val sourceLayerIds = ConvertUtils.toStringList(withSourceLayerIDs)
+
+            it.querySourceFeatures(
+                sourceId,
+                ExpressionParser.from(withFilter),
+                if (sourceLayerIds.size == 0) null else sourceLayerIds,
+                createCommandResponse(promise)
+            )
+        }
+    }
+
+    companion object {
+        const val NAME = "MBXMapViewModule"
+    }
+}

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

@@ -2,11 +2,25 @@ package com.mapbox.rctmgl.components.mapview
 
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.MBXAndroidTextureMapViewManagerDelegate
+import com.facebook.react.viewmanagers.MBXAndroidTextureMapViewManagerInterface
+import com.facebook.react.viewmanagers.MBXMapViewManagerDelegate
 import com.mapbox.maps.MapInitOptions
 
 class RCTMGLAndroidTextureMapViewManager(context: ReactApplicationContext) : RCTMGLMapViewManager(
     context
-) {
+), MBXAndroidTextureMapViewManagerInterface<RCTMGLMapView> {
+    private val mDelegate: ViewManagerDelegate<RCTMGLMapView>
+
+    init {
+        mDelegate = MBXAndroidTextureMapViewManagerDelegate<RCTMGLMapView, RCTMGLAndroidTextureMapViewManager>(this)
+    }
+
+    override fun getDelegate(): ViewManagerDelegate<RCTMGLMapView>? {
+        return mDelegate
+    }
+
     override fun getName(): String {
         return REACT_CLASS
     }
@@ -18,6 +32,6 @@ class RCTMGLAndroidTextureMapViewManager(context: ReactApplicationContext) : RCT
     }
 
     companion object {
-        const val REACT_CLASS = "RCTMGLAndroidTextureMapView"
+        const val REACT_CLASS = "MBXAndroidTextureMapView"
     }
 }

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

@@ -24,7 +24,6 @@ import com.mapbox.maps.*
 import com.mapbox.maps.extension.localization.localizeLabels
 import com.mapbox.maps.extension.observable.eventdata.MapLoadingErrorEventData
 import com.mapbox.maps.extension.observable.eventdata.RenderFrameFinishedEventData
-import com.mapbox.maps.extension.observable.getMapLoadingErrorEventData
 import com.mapbox.maps.extension.style.expressions.generated.Expression
 import com.mapbox.maps.extension.style.layers.Layer
 import com.mapbox.maps.extension.style.layers.generated.*
@@ -72,10 +71,18 @@ import com.mapbox.rctmgl.events.MapClickEvent
 import com.mapbox.rctmgl.events.constants.EventTypes
 import com.mapbox.rctmgl.utils.*
 import com.mapbox.rctmgl.utils.extensions.toReadableArray
+import com.mapbox.rctmgl.v11compat.annotation.AnnotationID
+import com.mapbox.rctmgl.v11compat.annotation.INVALID_ANNOTATION_ID
 import org.json.JSONException
 import org.json.JSONObject
 import java.util.*
 
+import com.mapbox.maps.MapboxMap.*;
+
+import com.mapbox.rctmgl.v11compat.event.*
+import com.mapbox.rctmgl.v11compat.feature.*
+import com.mapbox.rctmgl.v11compat.mapboxmap.*
+import com.mapbox.rctmgl.v11compat.ornamentsettings.*
 
 data class OrnamentSettings(
     var enabled : Boolean? = false,
@@ -161,7 +168,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     private val mSources: MutableMap<String, RCTSource<*>>
     private val mImages: MutableList<RCTMGLImages>
     private var mPointAnnotationManager: PointAnnotationManager? = null
-    private var mActiveMarkerID: Long = -1
+    private var mActiveMarkerID: AnnotationID = INVALID_ANNOTATION_ID
     private var mProjection: ProjectionName = ProjectionName.MERCATOR
     private var mLocaleString: String? = null
     private var mLocaleLayerIds: List<String>? = null
@@ -458,7 +465,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         } else if (feature is RCTMGLPointAnnotation) {
             val annotation = feature
             if (annotation.mapboxID == mActiveMarkerID) {
-                mActiveMarkerID = -1
+                mActiveMarkerID = INVALID_ANNOTATION_ID
             }
             mPointAnnotations.remove(annotation.iD)
         } else if (feature is RCTMGLImages) {
@@ -743,7 +750,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     }
 
     fun deselectAnnotation(annotation: RCTMGLPointAnnotation) {
-        mActiveMarkerID = -1
+        mActiveMarkerID = INVALID_ANNOTATION_ID
         annotation.onDeselect()
     }
 
@@ -970,7 +977,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
                 ScreenCoordinate(rect.right.toDouble(), rect.bottom.toDouble() ),
                 ScreenCoordinate(rect.left.toDouble(), rect.top.toDouble()),
         )
-        mMap?.queryRenderedFeatures(
+        mMap.queryRenderedFeatures(
                 RenderedQueryGeometry(screenBox),
                 RenderedQueryOptions(layerIDs, filter)
         ) { features ->
@@ -1022,13 +1029,15 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
             if (snapshot == null) {
                 response.error("snapshot failed")
             } else {
-                val uri: String = if (writeToDisk) BitmapUtils.createTempFile(
+                val uri: String? = if (writeToDisk) BitmapUtils.createTempFile(
                     mContext,
                     snapshot
                 ) else BitmapUtils.createBase64(snapshot)
 
                 response.success {
-                    it.putString("uri", uri)
+                    uri?.let { uri ->
+                        it.putString("uri", uri)
+                    }
                 }
             }
         }
@@ -1305,7 +1314,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     }
 
     // region Attribution
-    var mAttributionSettings = OrnamentSettings(enabled = AttributionSettings().enabled)
+    var mAttributionSettings = OrnamentSettings(enabled = getAttributionSettings().enabled)
 
     fun setReactAttributionEnabled(attributionEnabled: Boolean?) {
         mAttributionSettings.enabled = attributionEnabled
@@ -1479,87 +1488,4 @@ fun OrnamentSettings.setPosAndMargins(posAndMargins: ReadableMap?) {
     this.margins = margins
 }
 
-interface GenericOrnamentSettings {
-    fun setHMargins(left: Float?, right: Float?)
-    fun setVMargins(top: Float?, bottom: Float?)
-    var enabled: Boolean
-    var position: Int
-}
-
-fun ScaleBarSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings {
-    private val settings = this@toGenericOrnamentSettings
-    override fun setHMargins(left: Float?, right: Float?) {
-        left?.let { settings.marginLeft = it }
-        right?.let { settings.marginRight = it }
-    }
-    override fun setVMargins(top: Float?, bottom: Float?) {
-        top?.let { settings.marginTop = it }
-        bottom?.let { settings.marginBottom = it }
-    }
-    override var enabled: Boolean
-        get() = settings.enabled
-        set(value) { settings.enabled = value }
-    override var position: Int
-        get() = settings.position
-        set(value) { settings.position = value }
-}
-
-fun CompassSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings {
-    private var settings = this@toGenericOrnamentSettings
-    override fun setHMargins(left: Float?, right: Float?) {
-        left?.let { settings.marginLeft = it }
-        right?.let { settings.marginRight = it }
-    }
-    override fun setVMargins(top: Float?, bottom: Float?) {
-        top?.let { settings.marginTop = it }
-        bottom?.let { settings.marginBottom = it }
-    }
-    override var enabled: Boolean
-        get() = settings.enabled
-        set(value) { settings.enabled = value }
-    override var position: Int
-        get() = settings.position
-        set(value) {
-            settings.position = value
-        }
-}
-
-fun LogoSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings {
-    private var settings = this@toGenericOrnamentSettings
-    override fun setHMargins(left: Float?, right: Float?) {
-        left?.let { settings.marginLeft = it }
-        right?.let { settings.marginRight = it }
-    }
-    override fun setVMargins(top: Float?, bottom: Float?) {
-        top?.let { settings.marginTop = it }
-        bottom?.let { settings.marginBottom = it }
-    }
-    override var enabled: Boolean
-        get() = settings.enabled
-        set(value) { settings.enabled = value }
-    override var position: Int
-        get() = settings.position
-        set(value) {
-            settings.position = value
-        }
-}
 
-fun AttributionSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings {
-    private var settings = this@toGenericOrnamentSettings;
-    override fun setHMargins(left: Float?, right: Float?) {
-        left?.let { settings.marginLeft = it }
-        right?.let { settings.marginRight = it }
-    }
-    override fun setVMargins(top: Float?, bottom: Float?) {
-        top?.let { settings.marginTop = it }
-        bottom?.let { settings.marginBottom = it }
-    }
-    override var enabled: Boolean
-        get() = settings.enabled
-        set(value) { settings.enabled = value }
-    override var position: Int
-        get() = settings.position
-        set(value) {
-            settings.position = value
-        }
-}