@rnmapbox/maps 10.1.0-beta.8 → 10.1.0-rc.0

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

@@ -2,18 +2,42 @@ package com.rnmapbox.rnmbx.components.location
 
 import android.annotation.SuppressLint
 import android.content.Context
-import androidx.appcompat.content.res.AppCompatResources
-import com.rnmapbox.rnmbx.components.mapview.OnMapReadyCallback
-import com.mapbox.maps.MapboxMap
+import android.content.res.Resources
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 import com.mapbox.android.core.permissions.PermissionsManager
+import com.mapbox.bindgen.Value
+import com.mapbox.maps.Image
+import com.mapbox.maps.MapView
+import com.mapbox.maps.MapboxMap
 import com.mapbox.maps.Style
+import com.mapbox.maps.plugin.LocationPuck2D
+import com.mapbox.maps.plugin.locationcomponent.LocationComponentConstants
+import com.mapbox.maps.plugin.locationcomponent.location
+import com.mapbox.maps.plugin.locationcomponent.R as LR
 import com.rnmapbox.rnmbx.R
 import com.rnmapbox.rnmbx.components.AbstractMapFeature
 import com.rnmapbox.rnmbx.components.RemovalReason
+import com.rnmapbox.rnmbx.components.images.ImageManager
+import com.rnmapbox.rnmbx.components.images.Resolver
+import com.rnmapbox.rnmbx.components.images.Subscription
+import com.rnmapbox.rnmbx.components.mapview.OnMapReadyCallback
 import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
-
-import com.rnmapbox.rnmbx.v11compat.location.PuckBearingSource
+import com.rnmapbox.rnmbx.utils.BitmapUtils
+import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.utils.extensions.getAndLogIfNotBoolean
+import com.rnmapbox.rnmbx.utils.extensions.getAndLogIfNotString
 import com.rnmapbox.rnmbx.v11compat.image.AppCompatResourcesV11
+import com.rnmapbox.rnmbx.v11compat.image.ImageHolder
+import com.rnmapbox.rnmbx.v11compat.image.toDrawable
+import com.rnmapbox.rnmbx.v11compat.image.toImageHolder
+import com.rnmapbox.rnmbx.v11compat.location.*
+import java.nio.ByteBuffer
 
 enum class RenderMode {
     GPS, COMPASS, NORMAL
@@ -25,13 +49,167 @@ class RNMBXNativeUserLocation(context: Context) : AbstractMapFeature(context), O
     private var mRenderMode : RenderMode = RenderMode.NORMAL;
     private var mContext : Context = context
 
+    private var imageManager: ImageManager? = null
+
+    // region bearing
+    var androidRenderMode: RenderMode? = null
+    var puckBearing: PuckBearing? = null
+    var puckBearingEnabled: Boolean? = null
+    // endregion
+
+    enum class PuckImagePart {
+        TOP,
+        BEARING,
+        SHADOW
+    }
+
+    private var imageNames = mutableMapOf<PuckImagePart, String>()
+    private var subscriptions = mutableMapOf<PuckImagePart, Subscription>()
+    private var images = mutableMapOf<PuckImagePart, ImageHolder>()
+
+    var topImage: String?
+        get() = imageNames[PuckImagePart.TOP]
+        set(value) { imageNameUpdated(PuckImagePart.TOP, value) }
+
+    var bearingImage: String?
+        get() = imageNames[PuckImagePart.BEARING]
+        set(value) { imageNameUpdated(PuckImagePart.BEARING, value) }
+
+    var shadowImage: String?
+        get() = imageNames[PuckImagePart.SHADOW]
+        set(value) { imageNameUpdated(PuckImagePart.SHADOW, value) }
+
+    var scale: Value? = null
+        set(value) {
+            field = value
+            _apply()
+        }
+
+    var visible: Boolean = true
+        set(value) {
+            field = value
+            _apply()
+        }
+
+    var pulsing: ReadableMap? = null
+        set(value) {
+            field = value
+            _apply()
+        }
+
+    private fun imageNameUpdated(image: PuckImagePart, name: String?) {
+        if (name != null) {
+            imageNames[image] = name
+        } else {
+            imageNames.remove(image)
+        }
+        subscriptions[image]?.let {
+            it.cancel()
+        }
+        subscriptions.remove(image)
+
+        if (name == null) {
+            imageUpdated(image, null)
+            return
+        }
+
+        imageManager?.let { subscribe(it, image, name) }
+
+    }
+
+    private fun imageUpdated(image: PuckImagePart, imageHolder: ImageHolder?) {
+        if (imageHolder != null) {
+            images[image] = imageHolder
+        } else {
+            images.remove(image)
+        }
+        _apply()
+    }
+
+    private fun _apply() {
+        mMapView?.let {
+            it.mapView?.let {
+                _apply(it)
+            }
+        }
+    }
+
+    private fun _apply(mapView: MapView) {
+        val location2 = mapView.location2;
+
+        if (visible) {
+            if (images.isEmpty()) {
+                location2.locationPuck =
+                    makeDefaultLocationPuck2D(mContext, androidRenderMode ?: RenderMode.NORMAL)
+            } else {
+                location2.locationPuck = LocationPuck2D(
+                    topImage = images[PuckImagePart.TOP],
+                    bearingImage = images[PuckImagePart.BEARING],
+                    shadowImage = images[PuckImagePart.SHADOW],
+                    scaleExpression = scale?.toJson()
+                )
+            }
+        } else {
+            val empty =
+                AppCompatResourcesV11.getDrawableImageHolder(mContext, R.drawable.empty)
+            location2.locationPuck = LocationPuck2D(
+                topImage = empty,
+                bearingImage = empty,
+                shadowImage = empty
+            )
+        }
+
+        this.puckBearing?.let {
+            location2.puckBearing = it
+        }
+        this.puckBearingEnabled?.let {
+            location2.puckBearingEnabled = it
+        }
+
+        pulsing?.let { pulsing ->
+            pulsing.getAndLogIfNotString("kind")?.also { kind ->
+                if (kind == "default") {
+                    location2.pulsingEnabled = true
+                }
+            }
+            if (pulsing.hasKey("color")) {
+                when (pulsing.getType("color")) {
+                    ReadableType.Map ->
+                        location2.pulsingColor = ColorPropConverter.getColor(pulsing.getMap("color"), mContext)
+                    ReadableType.Number ->
+                        location2.pulsingColor = pulsing.getInt("color")
+                    else ->
+                        Logger.e(LOG_TAG, "pusling.color should be either a map or a number, but was ${pulsing.getDynamic("color")}")
+                }
+            }
+            pulsing.getAndLogIfNotBoolean("isEnabled")?.let { enabled ->
+               location2.pulsingEnabled = enabled
+            }
+            if (pulsing.hasKey("radius")) {
+                when (pulsing.getType("radius")) {
+                    ReadableType.Number ->
+                        location2.pulsingMaxRadius = pulsing.getDouble("radius").toFloat()
+                    ReadableType.String ->
+                        if (pulsing.getString("radius") == "accuracy") {
+                            location2.pulsingMaxRadius = LocationComponentConstants.PULSING_MAX_RADIUS_FOLLOW_ACCURACY
+                        } else {
+                            Logger.e(LOG_TAG, "Expected pulsing/radius to be a number or accuracy but was ${pulsing.getString("radius")}")
+                        }
+                    else ->
+                        Logger.e(LOG_TAG, "Expected pulsing/radius to be a number or accuracy but was ${pulsing.getString("radius")}")
+                }
+            }
+        }
+    }
+
     override fun addToMap(mapView: RNMBXMapView) {
         super.addToMap(mapView)
         mEnabled = true
         mapView.getMapboxMap()
         mapView.getMapAsync(this)
         mMapView?.locationComponentManager?.showNativeUserLocation(true)
-        applyChanges()
+        _fetchImages(mapView)
+        _apply()
     }
 
     override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
@@ -45,12 +223,7 @@ class RNMBXNativeUserLocation(context: Context) : AbstractMapFeature(context), O
     override fun onMapReady(mapboxMap: MapboxMap) {
         mMap = mapboxMap
         mapboxMap.getStyle(this)
-        applyChanges()
-    }
-
-    fun setAndroidRenderMode(renderMode: RenderMode) {
-        mRenderMode = renderMode;
-        applyChanges();
+        _apply()
     }
 
     @SuppressLint("MissingPermission")
@@ -64,20 +237,68 @@ class RNMBXNativeUserLocation(context: Context) : AbstractMapFeature(context), O
         mMapView?.locationComponentManager?.showNativeUserLocation(mEnabled)
     }
 
-    fun applyChanges() {
-        mMapView?.locationComponentManager?.let {
-            // emulate https://docs.mapbox.com/android/legacy/maps/guides/location-component/
-            when (mRenderMode) {
-                RenderMode.NORMAL ->
-                    it.update { it.copy(bearingImage =  null, puckBearingSource = null)}
-                RenderMode.GPS -> it.update {
-                    it.copy(bearingImage =  AppCompatResourcesV11.getDrawableImageHolder(
-                        mContext, R.drawable.mapbox_user_bearing_icon
-                    ), puckBearingSource = PuckBearingSource.COURSE) }
-                RenderMode.COMPASS -> it.update{ it.copy(bearingImage=  AppCompatResourcesV11.getDrawableImageHolder(
-                    mContext, R.drawable.mapbox_user_puck_icon
-                ), puckBearingSource = PuckBearingSource.HEADING) }
+    // region fetch images and subscribe on updates
+    private fun subscribe(imageManager: ImageManager, image: PuckImagePart, name: String) {
+        subscriptions[image]?.let {
+            it.cancel()
+            subscriptions.remove(image)
+            Logger.e("RNMBXNativeUserLocation", "subscribe: there is alread a subscription for image: $image")
+        }
+
+        subscriptions[image] = imageManager.subscribe(name, Resolver { _, imageData  ->
+            imageUpdated(image, imageData.toImageHolder())
+        })
+    }
+
+    private fun removeSubscriptions() {
+        subscriptions.forEach {
+            it.value.cancel()
+        }
+        subscriptions.clear()
+    }
+
+    private fun _fetchImages(map: RNMBXMapView) {
+        map.mapView?.getMapboxMap()?.getStyle()?.let { style ->
+            imageNames.forEach { (part,name) ->
+                if (style.hasStyleImage(name)) {
+                    style.getStyleImage(name)?.let { image ->
+                        images[part] = image.toImageHolder()
+                    }
+                }
             }
         }
+
+        removeSubscriptions()
+        val imageManager = map.imageManager
+        this.imageManager = imageManager
+        imageNames.forEach { (part,name) ->
+            subscribe(imageManager, part, name)
+        }
+    }
+    // endregion
+
+    companion object {
+        const val LOG_TAG = "RNMBXNativeUserLocation"
     }
+}
+
+fun makeDefaultLocationPuck2D(context: Context, renderMode: RenderMode): LocationPuck2D {
+    return LocationPuck2D(
+        topImage = AppCompatResourcesV11.getDrawableImageHolder(
+            context,
+            LR.drawable.mapbox_user_icon
+        ),
+        bearingImage = AppCompatResourcesV11.getDrawableImageHolder(
+            context,
+            when (renderMode) {
+                RenderMode.GPS -> LR.drawable.mapbox_user_bearing_icon
+                RenderMode.COMPASS -> LR.drawable.mapbox_user_puck_icon
+                RenderMode.NORMAL -> LR.drawable.mapbox_user_stroke_icon
+            }
+        ),
+        shadowImage = AppCompatResourcesV11.getDrawableImageHolder(
+            context,
+            LR.drawable.mapbox_user_icon_shadow
+        )
+    );
 }

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

@@ -1,23 +1,92 @@
 package com.rnmapbox.rnmbx.components.location
 
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableMap
+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.RNMBXNativeUserLocationManagerInterface
+import com.google.gson.Gson
+import com.google.gson.stream.JsonWriter
+import com.mapbox.bindgen.Value
+import com.mapbox.maps.extension.style.expressions.generated.Expression
 import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.utils.extensions.toJsonArray
+import java.io.StringWriter
 import javax.annotation.Nonnull
+import com.rnmapbox.rnmbx.v11compat.location.*
 
-class RNMBXNativeUserLocationManager : ViewGroupManager<RNMBXNativeUserLocation>() {
+class RNMBXNativeUserLocationManager : ViewGroupManager<RNMBXNativeUserLocation>(),
+    RNMBXNativeUserLocationManagerInterface<RNMBXNativeUserLocation> {
     @Nonnull
     override fun getName(): String {
         return REACT_CLASS
     }
 
     @ReactProp(name = "androidRenderMode")
-    fun setAndroidRenderMode(userLocation: RNMBXNativeUserLocation, mode: String) {
-        when (mode) {
-            "compass" -> userLocation.setAndroidRenderMode(RenderMode.COMPASS);
-            "gps" -> userLocation.setAndroidRenderMode(RenderMode.GPS);
-            "normal" -> userLocation.setAndroidRenderMode(RenderMode.NORMAL);
+    override fun setAndroidRenderMode(userLocation: RNMBXNativeUserLocation, mode: Dynamic) {
+        if (!mode.isNull) {
+            Logger.e("RNMBXNativeUserLocationManager", "androidRenderMode is deprecated, use puckBearing instead")
+        }
+        when (mode.asString()) {
+            "compass" -> userLocation.androidRenderMode = RenderMode.COMPASS
+            "gps" -> userLocation.androidRenderMode = RenderMode.GPS
+            "normal" -> userLocation.androidRenderMode = RenderMode.NORMAL
+        }
+    }
+
+    @ReactProp(name = "puckBearing")
+    override fun setPuckBearing(view: RNMBXNativeUserLocation, value: Dynamic) {
+        when (value?.asString()) {
+            "heading" -> view.puckBearing = PuckBearing.HEADING
+            "course" -> view.puckBearing = PuckBearing.COURSE
+            null -> Unit
+            else ->
+                Logger.e("RNMBXNativeUserLocationManager", "unexpected value for puckBearing: $value")
+        }
+    }
+
+    @ReactProp(name = "puckBearingEnabled")
+    override fun setPuckBearingEnabled(view: RNMBXNativeUserLocation, value: Dynamic) {
+        if (!value.isNull) {
+            if (value.type == ReadableType.Boolean) {
+                view.puckBearingEnabled = value.asBoolean()
+            } else {
+                Logger.e("RNMBXNativeUserLocationManager", "unexpected value for puckBearingEnabled: $value")
+            }
+        }
+    }
+
+    @ReactProp(name = "topImage")
+    override fun setTopImage(view: RNMBXNativeUserLocation, value: Dynamic?) {
+        view.topImage = value?.asString()
+    }
+
+    @ReactProp(name = "bearingImage")
+    override fun setBearingImage(view: RNMBXNativeUserLocation, value: Dynamic?) {
+        view.bearingImage = value?.asString()
+    }
+
+    @ReactProp(name = "shadowImage")
+    override fun setShadowImage(view: RNMBXNativeUserLocation, value: Dynamic?) {
+        view.shadowImage = value?.asString()
+    }
+
+    @ReactProp(name = "scale", defaultDouble = 1.0)
+    override fun setScale(view: RNMBXNativeUserLocation, value: Dynamic?) {
+        view.scale = _convertToDoubleValueOrExpression(value, "scale")
+    }
+
+    @ReactProp(name = "visible")
+    override fun setVisible(view: RNMBXNativeUserLocation, value: Boolean) {
+        view.visible = value
+    }
+
+    @ReactProp(name = "pulsing")
+    override fun setPulsing(view: RNMBXNativeUserLocation, value: Dynamic) {
+        if (!value.isNull) {
+            view.pulsing = value.asMap()
         }
     }
 
@@ -29,4 +98,25 @@ class RNMBXNativeUserLocationManager : ViewGroupManager<RNMBXNativeUserLocation>
     companion object {
         const val REACT_CLASS = "RNMBXNativeUserLocation"
     }
-}
+}
+
+
+
+fun _convertToDoubleValueOrExpression(value: Dynamic?, name: String): Value? {
+    if (value == null) {
+        return null
+    }
+    return when (value.type) {
+        ReadableType.Array ->
+            Expression.fromRaw(Gson().toJson(value.asArray().toJsonArray()))
+        ReadableType.Number ->
+            Value.valueOf(value.asDouble())
+        else -> {
+            Logger.e(
+                "RNMBXNativeUserLocationmanager",
+                "_convertToExpressionString: cannot convert $name to a double or double exrpession. $value"
+            )
+            return null
+        }
+    }
+}

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

@@ -25,6 +25,7 @@ object UserTrackingMode {
             FOLLOW -> return "normal"
             FollowWithCourse -> return "course"
             FollowWithHeading -> return "compass"
+            NONE -> return null
         }
         return null
     }

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

@@ -1,25 +1,18 @@
 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, val viewTagResolver: ViewTagResolver<RNMBXMapView>) : NativeMapViewModuleSpec(context) {
+class NativeMapViewModule(context: ReactApplicationContext, val viewTagResolver: ViewTagResolver) : NativeMapViewModuleSpec(context) {
     private fun withMapViewOnUIThread(
         viewRef: Double?,
         reject: Promise,
@@ -132,7 +125,7 @@ class NativeMapViewModule(context: ReactApplicationContext, val viewTagResolver:
         viewRef: Double?,
         withBBox: ReadableArray,
         withFilter: ReadableArray,
-        withLayerIDs: ReadableArray,
+        withLayerIDs: ReadableArray?,
         promise: Promise
     ) {
         withMapViewOnUIThread(viewRef, promise) {