@rnmapbox/maps 10.1.0 → 10.1.2

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

@@ -0,0 +1,66 @@
+package com.rnmapbox.rnmbx.components.camera
+
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.rnmapbox.rnmbx.NativeRNMBXViewportModuleSpec
+import com.rnmapbox.rnmbx.components.mapview.CommandResponse
+import com.rnmapbox.rnmbx.utils.ViewTagResolver
+
+class RNMBXViewportModule(context: ReactApplicationContext, val viewTagResolver: ViewTagResolver) : NativeRNMBXViewportModuleSpec(context) {
+    private fun withViewportOnUIThread(
+        viewRef: Double?,
+        reject: Promise,
+        fn: (RNMBXViewport) -> Unit
+    ) {
+        if (viewRef == null) {
+            reject.reject(Exception("viewRef is null"))
+        } else {
+            viewTagResolver.withViewResolved(viewRef.toInt(), reject, fn)
+        }
+    }
+
+    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 getState(viewRef: Double?, promise: Promise) {
+        withViewportOnUIThread(viewRef, promise) {
+            promise.resolve(it.getState())
+        }
+    }
+
+    override fun transitionTo(
+        viewRef: Double?,
+        state: ReadableMap,
+        transition: ReadableMap?,
+        promise: Promise
+    ) {
+        withViewportOnUIThread(viewRef, promise) {
+            it.transitionTo(state, transition, promise)
+        }
+    }
+
+    override fun idle(viewRef: Double?, promise: Promise) {
+        withViewportOnUIThread(viewRef, promise) {
+            it.idle()
+            promise.resolve(true)
+        }
+    }
+
+    companion object {
+        const val NAME = "RNMBXViewportModule"
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/images/ImageManager.kt

@@ -0,0 +1,53 @@
+package com.rnmapbox.rnmbx.components.images
+
+import android.graphics.Bitmap
+import android.graphics.drawable.BitmapDrawable
+import com.rnmapbox.rnmbx.v11compat.Cancelable
+import com.mapbox.maps.Image
+import com.rnmapbox.rnmbx.v11compat.image.toMapboxImage
+
+/**
+ImageManager helps to resolve images defined by any of RNMBXImages component.
+ */
+
+fun interface Resolver {
+    fun resolved(name: String, image: Image)
+}
+class Subscription(val name:String, val resolver: Resolver, val manager: ImageManager): Cancelable {
+
+    fun resolved(name: String, image: Image) {
+        resolver.resolved(name, image)
+    }
+    override fun cancel() {
+        manager.unsubscribe(this)
+    }
+}
+
+class ImageManager {
+    var subscriptions: MutableMap<String, MutableList<Subscription>> = hashMapOf()
+
+    fun subscribe(name: String, resolved: Resolver) : Subscription {
+        val list = subscriptions.getOrPut(name) { mutableListOf() }
+        val result = Subscription(name, resolved, this)
+        list.add(result)
+        return result
+    }
+    fun unsubscribe(subscription: Subscription) {
+        var list = subscriptions[subscription.name]
+        list?.removeAll { it === subscription }
+    }
+
+    fun resolve(name: String, image: Image) {
+        subscriptions[name]?.forEach {
+            it.resolved(name, image)
+        }
+    }
+
+    fun resolve(name: String, image: Bitmap) {
+        resolve(name, image.toMapboxImage())
+    }
+
+    fun resolve(name: String, image: BitmapDrawable) {
+        resolve(name, image.bitmap)
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/images/RNMBXImages.kt

@@ -212,6 +212,7 @@ class RNMBXImages(context: Context, private val mManager: RNMBXImagesManager) :
             val name = nativeImage.info.name
             if (!hasImage(name, map)) {
                 val bitmap = nativeImage.drawable
+                mMapView!!.imageManager.resolve(name, nativeImage.drawable)
                 style.addBitmapImage(nativeImage)
                 mCurrentImages.add(name)
             }
@@ -264,7 +265,7 @@ class RNMBXImages(context: Context, private val mManager: RNMBXImagesManager) :
             }
         }
         if (missingImages.size > 0) {
-            val task = DownloadMapImageTask(context, map, null)
+            val task = DownloadMapImageTask(context, map, mMapView!!.imageManager)
             val params = missingImages.toTypedArray()
             task.execute(*params)
         }

package/android/src/main/java/com/rnmapbox/rnmbx/components/images/RNMBXImagesManager.kt

@@ -1,6 +1,9 @@
 package com.rnmapbox.rnmbx.components.images
 
+import android.graphics.Bitmap
+import android.graphics.Canvas
 import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
 import android.view.View
 import com.facebook.react.bridge.*
 import com.facebook.react.common.MapBuilder
@@ -11,6 +14,7 @@ import com.mapbox.maps.ImageContent
 import com.mapbox.maps.ImageStretches
 import com.rnmapbox.rnmbx.components.AbstractEventEmitter
 import com.rnmapbox.rnmbx.events.constants.EventKeys
+import com.rnmapbox.rnmbx.events.constants.eventMapOf
 import com.rnmapbox.rnmbx.utils.ImageEntry
 import com.rnmapbox.rnmbx.utils.Logger
 import com.rnmapbox.rnmbx.utils.ResourceUtils
@@ -133,12 +137,33 @@ class RNMBXImagesManager(private val mContext: ReactApplicationContext) :
         images.setHasOnImageMissing(value.asBoolean())
     }
 
+    private fun convertDrawableToBitmap(sourceDrawable: Drawable?): BitmapDrawable? {
+        if (sourceDrawable == null) {
+            return null
+        }
+        return if (sourceDrawable is BitmapDrawable) {
+            sourceDrawable
+        } else {
+            // copying drawable object to not manipulate on the same reference
+            val constantState = sourceDrawable.constantState ?: return null
+            val drawable = constantState.newDrawable().mutate()
+            val bitmap: Bitmap = Bitmap.createBitmap(
+                drawable.intrinsicWidth, drawable.intrinsicHeight,
+                Bitmap.Config.ARGB_8888
+            )
+            val canvas = Canvas(bitmap)
+            drawable.setBounds(0, 0, canvas.width, canvas.height)
+            drawable.draw(canvas)
+            BitmapDrawable(mContext.resources, bitmap)
+        }
+    }
+
     fun toNativeImage(dynamic: Dynamic): NativeImage? {
         when (dynamic.type) {
             ReadableType.String -> {
                 val resourceName = dynamic.asString();
                 val drawable =
-                    ResourceUtils.getDrawableByName(mContext, resourceName) as BitmapDrawable?
+                    convertDrawableToBitmap(ResourceUtils.getDrawableByName(mContext, resourceName))
                 if (drawable != null) {
                     return NativeImage(ImageInfo(name=resourceName), drawable)
                 } else {
@@ -150,7 +175,7 @@ class RNMBXImagesManager(private val mContext: ReactApplicationContext) :
                 val map = dynamic.asMap()
                 val resourceName = map.getString("name")
                 val drawable =
-                    ResourceUtils.getDrawableByName(mContext, resourceName) as BitmapDrawable?
+                    convertDrawableToBitmap(ResourceUtils.getDrawableByName(mContext, resourceName))
                 if (drawable != null && resourceName != null) {
                     return NativeImage(imageInfo(resourceName, map), drawable)
                 } else {
@@ -178,9 +203,9 @@ class RNMBXImagesManager(private val mContext: ReactApplicationContext) :
     }
 
     override fun customEvents(): Map<String, String>? {
-        return MapBuilder.builder<String, String>()
-            .put(EventKeys.IMAGES_MISSING, "onImageMissing")
-            .build()
+        return eventMapOf(
+            EventKeys.IMAGES_MISSING to "onImageMissing"
+        )
     }
 
     // region RNMBXImage children
@@ -266,4 +291,4 @@ class RNMBXImagesManager(private val mContext: ReactApplicationContext) :
             return ImageContent(result[0].toFloat(), result[1].toFloat() ,result[2].toFloat(), result[3].toFloat())
         }
     }
-}
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/location/LocationComponentManager.kt

@@ -1,20 +1,22 @@
 package com.rnmapbox.rnmbx.components.location
 
 import android.content.Context
+import android.graphics.BitmapFactory
 import android.graphics.Color
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.VectorDrawable
-import androidx.appcompat.content.res.AppCompatResources
+import android.graphics.drawable.BitmapDrawable
 import androidx.lifecycle.Lifecycle
-import com.mapbox.maps.plugin.locationcomponent.location
-import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.mapbox.maps.extension.style.expressions.dsl.generated.interpolate
 import com.mapbox.maps.plugin.LocationPuck2D
-import com.mapbox.maps.plugin.lifecycle.lifecycle
+import com.mapbox.maps.plugin.locationcomponent.location
 import com.rnmapbox.rnmbx.R
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
 import com.rnmapbox.rnmbx.location.LocationManager
-
-import com.rnmapbox.rnmbx.v11compat.location.PuckBearingSource;
-import com.rnmapbox.rnmbx.v11compat.image.*;
+import com.rnmapbox.rnmbx.v11compat.image.AppCompatResourcesV11
+import com.rnmapbox.rnmbx.v11compat.image.ImageHolder
+import com.rnmapbox.rnmbx.v11compat.image.toBitmapImageHolder
+import com.rnmapbox.rnmbx.v11compat.image.toByteArray
+import com.rnmapbox.rnmbx.v11compat.image.toImageData
+import com.rnmapbox.rnmbx.v11compat.location.PuckBearing
 
 /**
  * The LocationComponent on android implements display of user's current location.
@@ -23,9 +25,20 @@ import com.rnmapbox.rnmbx.v11compat.image.*;
  * And NativeUserLocation can ask for display of user's current location - independent of Camera's user tracking.
  */
 class LocationComponentManager(mapView: RNMBXMapView, context: Context) {
+    private val MAPBOX_BLUE_COLOR = Color.parseColor("#4A90E2")
+
     var mMapView = mapView
     var mContext = context
-    private var mState = State(showUserLocation=false, followUserLocation=false, tintColor= null, bearingImage = null, puckBearingSource =null)
+    private var mState = State(
+        showUserLocation = false,
+        followUserLocation = false,
+        tintColor = null,
+        bearingImage = null,
+        puckBearingSource = null,
+        topImage = null,
+        shadowImage = null,
+        scale = 1.0,
+    )
 
     private var mLocationManager: LocationManager = LocationManager.getInstance(context)
 
@@ -37,8 +50,13 @@ class LocationComponentManager(mapView: RNMBXMapView, context: Context) {
         val showUserLocation: Boolean,
         val followUserLocation: Boolean,
         val tintColor: Int?, // tint of location puck
-        var bearingImage: ImageHolder?, // bearing image (background)
-        var puckBearingSource: PuckBearingSource? // bearing source
+        var bearingImage: ImageHolder?, // The image used as the middle of the location indicator.
+        var topImage: ImageHolder?, // The image to use as the top layer for the location indicator.
+        var shadowImage: ImageHolder?, // The image that acts as a background of the location indicator.
+        var puckBearingSource: PuckBearing?, // bearing source
+        var pulsing: Boolean = true,
+        var scale: Double = 1.0,
+        var nativeUserLocation: Boolean = false, // LocaitonPuck managed by RNMBXNativeUserLocation
     ) {
         val enabled: Boolean
             get() = showUserLocation || followUserLocation
@@ -78,41 +96,54 @@ class LocationComponentManager(mapView: RNMBXMapView, context: Context) {
         mapView.location.updateSettings {
             enabled = newState.enabled
 
-            if (fullUpdate || (newState.hidden != oldState.hidden) || (newState.tintColor != oldState.tintColor) || (newState.bearingImage != oldState.bearingImage)) {
-                if (newState.hidden) {
-                    var emptyLocationPuck = LocationPuck2D()
-                    val empty = AppCompatResourcesV11.getDrawableImageHolder(mContext, R.drawable.empty)
-                    emptyLocationPuck.bearingImage = empty
-                    emptyLocationPuck.shadowImage = empty
-                    emptyLocationPuck.topImage = empty
-                    //emptyLocationPuck.opacity = 0.0
-                    locationPuck = emptyLocationPuck
-                    pulsingEnabled = false
-                } else {
-                    val mapboxBlueColor = Color.parseColor("#4A90E2")
-                    val tintColor = newState.tintColor
-                    val defaultLocationPuck = LocationPuck2D()
-                    var topImage = AppCompatResourcesV11.getDrawableImageHolder(mContext, R.drawable.mapbox_user_icon)
-                    if (tintColor != null) {
-                        val drawable = AppCompatResources.getDrawable(mContext, R.drawable.mapbox_user_icon) as VectorDrawable?
-                        drawable!!.setTint(tintColor)
-                        topImage = drawable.toBitmapImageHolder()
-                    }
-                    defaultLocationPuck.topImage = topImage
-                    val defaultBearingImage = AppCompatResourcesV11.getDrawableImageHolder(
-                        mContext, R.drawable.mapbox_user_stroke_icon
-                    )
-                    defaultLocationPuck.bearingImage = newState.bearingImage ?: defaultBearingImage
-                    val shadowImage = AppCompatResourcesV11.getDrawableImageHolder(
-                        mContext, R.drawable.mapbox_user_icon_shadow
-                    )
-                    defaultLocationPuck.shadowImage = shadowImage
-                    locationPuck = defaultLocationPuck
-                    pulsingEnabled = true
-                    if (tintColor != null) {
-                        pulsingColor = tintColor
+            if (fullUpdate ||
+                newState.hidden != oldState.hidden ||
+                newState.tintColor != oldState.tintColor ||
+                newState.scale != oldState.scale ||
+                newState.nativeUserLocation != oldState.nativeUserLocation
+            ) {
+                if (!newState.nativeUserLocation) {
+                    if (newState.hidden) {
+                        var emptyLocationPuck = LocationPuck2D()
+                        val empty =
+                            AppCompatResourcesV11.getDrawableImageHolder(mContext, R.drawable.empty)
+                        emptyLocationPuck.bearingImage = empty
+                        emptyLocationPuck.shadowImage = empty
+                        emptyLocationPuck.topImage = empty
+                        //emptyLocationPuck.opacity = 0.0
+                        locationPuck = emptyLocationPuck
+                        pulsingEnabled = false
                     } else {
-                        pulsingColor = mapboxBlueColor
+                        val tintColor = newState.tintColor
+                        var topImage = newState.topImage
+                        if (tintColor != null && topImage != null) {
+                            val imageData = (topImage as ByteArray).toImageData().toByteArray()
+                            val drawable = BitmapDrawable(
+                                mContext.resources,
+                                BitmapFactory.decodeByteArray(imageData, 0, imageData.size)
+                            )
+                            drawable.setTint(tintColor)
+                            topImage = drawable.toBitmapImageHolder()
+                        }
+                        val scaleExpression = if (newState.scale != 1.0) {
+                            interpolate {
+                                linear()
+                                zoom()
+                                stop {
+                                    literal(0)
+                                    literal(newState.scale)
+                                }
+                            }.toJson()
+                        } else null
+
+                        locationPuck = LocationPuck2D(
+                            topImage = topImage,
+                            bearingImage = newState.bearingImage,
+                            shadowImage = newState.shadowImage,
+                            scaleExpression = scaleExpression,
+                        )
+                        pulsingEnabled = newState.pulsing
+                        pulsingColor = tintColor ?: MAPBOX_BLUE_COLOR
                     }
                 }
             }
@@ -152,7 +183,7 @@ class LocationComponentManager(mapView: RNMBXMapView, context: Context) {
 
     fun showNativeUserLocation(showUserLocation: Boolean) {
         update {
-            it.copy(showUserLocation = showUserLocation)
+            it.copy(showUserLocation = showUserLocation, nativeUserLocation= showUserLocation)
         }
     }
 

package/android/src/main/java/com/rnmapbox/rnmbx/components/location/RNMBXCustomLocationProvider.kt

@@ -0,0 +1,114 @@
+package com.rnmapbox.rnmbx.components.location
+
+import android.content.Context
+import com.mapbox.geojson.Point
+import com.mapbox.maps.MapView
+import com.mapbox.maps.plugin.locationcomponent.DefaultLocationProvider
+import com.mapbox.maps.plugin.locationcomponent.LocationConsumer
+import com.mapbox.maps.plugin.locationcomponent.LocationProvider
+import com.mapbox.maps.plugin.locationcomponent.location
+import com.rnmapbox.rnmbx.components.AbstractMapFeature
+import com.rnmapbox.rnmbx.components.RemovalReason
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.utils.PropertyChanges
+import com.rnmapbox.rnmbx.utils.PropertyUpdaterWithName
+
+class RNMBXCustomLocationProvider(context: Context) : AbstractMapFeature(context) {
+    val changes = PropertyChanges<RNMBXCustomLocationProvider>()
+
+    enum class Property(val _apply: (RNMBXCustomLocationProvider) -> Unit) :
+        PropertyUpdaterWithName<RNMBXCustomLocationProvider> {
+        COORDINATE(RNMBXCustomLocationProvider::applyCoordinate),
+        HEADING(RNMBXCustomLocationProvider::applyHeading);
+
+        override fun apply(locationProvider: RNMBXCustomLocationProvider) {
+            _apply(locationProvider)
+        }
+    }
+
+    var coordinate: Pair<Double, Double>? = null
+        set(value) {
+            field = value;
+            changes.add(Property.COORDINATE)
+        }
+
+    var heading: Double? = null
+        set(value) {
+            field = value
+            changes.add(Property.HEADING)
+        }
+
+    override fun addToMap(mapView: RNMBXMapView) {
+        super.addToMap(mapView)
+        installCustomLocationProviderIfNeeded(mapView.mapView)
+    }
+
+    override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
+        removeCustomLocationProvider(mapView.mapView)
+        return super.removeFromMap(mapView, reason)
+    }
+
+    fun applyCoordinate() {
+        coordinate?.let {
+            updateCorodinate(it.second, it.first)
+        }
+    }
+
+    fun applyHeading() {
+        heading?.let {
+            updateHeading(it)
+        }
+    }
+
+    fun applyAllChanges() {
+        changes.apply(this)
+    }
+
+    fun updateCorodinate(latitude: Double, longitude: Double) {
+        val point = Point.fromLngLat(longitude, latitude)
+        locationConsumers.forEach {
+            it.onLocationUpdated(point)
+        }
+    }
+
+    fun updateHeading(heading: Double) {
+        locationConsumers.forEach {
+            it.onBearingUpdated(heading)
+        }
+    }
+
+    // region Location Provider
+    private var locationConsumers = mutableListOf<LocationConsumer>()
+    private var customLocationProvider: LocationProvider? = null
+    private var defaultLocationProvider: LocationProvider? = null
+
+    fun installCustomLocationProviderIfNeeded(mapView: MapView) {
+        var customLocationProvider: LocationProvider? = null
+        if (customLocationProvider == null) {
+            customLocationProvider = object : LocationProvider {
+                override fun registerLocationConsumer(locationConsumer: LocationConsumer) {
+                    locationConsumers.add(locationConsumer)
+                }
+
+                override fun unRegisterLocationConsumer(locationConsumer: LocationConsumer) {
+                    locationConsumers.remove(locationConsumer)
+                }
+            }
+        }
+        if (customLocationProvider != null) {
+            defaultLocationProvider = mapView.location.getLocationProvider()
+            mapView.location.setLocationProvider(customLocationProvider)
+            this.customLocationProvider = customLocationProvider
+        }
+    }
+
+    fun removeCustomLocationProvider(mapView: MapView) {
+        mapView.location.setLocationProvider(
+            defaultLocationProvider ?: DefaultLocationProvider(
+                context
+            )
+        )
+        customLocationProvider = null
+    }
+    // endregion
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/location/RNMBXCustomLocationProviderManager.kt

@@ -0,0 +1,54 @@
+package com.rnmapbox.rnmbx.components.location
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNMBXCustomLocationProviderManagerInterface
+import com.rnmapbox.rnmbx.utils.Logger
+
+class RNMBXCustomLocationProviderManager : ViewGroupManager<RNMBXCustomLocationProvider>(),
+    RNMBXCustomLocationProviderManagerInterface<RNMBXCustomLocationProvider> {
+    override fun getName(): String {
+        return  REACT_CLASS
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RNMBXCustomLocationProvider {
+        return RNMBXCustomLocationProvider(reactContext);
+    }
+
+    @ReactProp(name = "coordinate")
+    override fun setCoordinate(view: RNMBXCustomLocationProvider, value: Dynamic?) {
+        if (value?.type == ReadableType.Array) {
+            val array = value.asArray()
+            if (array.size() == 2 && array.getType(0) == ReadableType.Number && array.getType(1) == ReadableType.Number) {
+                view.coordinate = Pair(array.getDouble(0), array.getDouble(1))
+            } else {
+                Logger.e(LOG_TAG, "coordinate is expected to be an array of numbers with 2 elements")
+            }
+        } else {
+            Logger.e(LOG_TAG, "coordinate is expected to be an array of numbers with 2 elements")
+        }
+    }
+
+    @ReactProp(name = "heading")
+    override fun setHeading(view: RNMBXCustomLocationProvider, value: Dynamic?) {
+        if (value?.type == ReadableType.Number) {
+            view.heading = value.asDouble()
+        } else {
+            Logger.e(LOG_TAG, "heading is expected to be a number")
+        }
+    }
+
+    override fun onAfterUpdateTransaction(view: RNMBXCustomLocationProvider) {
+        super.onAfterUpdateTransaction(view)
+
+        view.applyAllChanges()
+    }
+
+    companion object {
+        const val REACT_CLASS = "RNMBXCustomLocationProvider"
+        const val LOG_TAG = REACT_CLASS
+    }
+}