@rnmapbox/maps 10.1.0-beta.2 → 10.1.0-beta.21

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

@@ -0,0 +1,203 @@
+package com.rnmapbox.rnmbx.components.location
+
+import android.content.Context
+import android.graphics.BitmapFactory
+import android.graphics.Color
+import android.graphics.drawable.BitmapDrawable
+import androidx.lifecycle.Lifecycle
+import com.mapbox.maps.extension.style.expressions.dsl.generated.interpolate
+import com.mapbox.maps.plugin.LocationPuck2D
+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.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.
+ * 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.
+ * LocationComponentManager attempts to separate that, so that Camera can ask for location tracking independent of display of user current location.
+ * 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,
+        topImage = null,
+        shadowImage = null,
+        scale = 1.0,
+    )
+
+    private var mLocationManager: LocationManager = LocationManager.getInstance(context)
+
+    private var mNeedsFullUpdate = true
+
+    private var mLocationManagerStarted = false
+
+    data class State(
+        val showUserLocation: Boolean,
+        val followUserLocation: Boolean,
+        val tintColor: Int?, // tint of location puck
+        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
+
+        val hidden: Boolean
+            get() = followUserLocation && !showUserLocation
+    }
+
+    fun update(newStateCallback: (currentState: State) -> State) {
+        val newState = newStateCallback(mState);
+        if (newState != mState) {
+            applyStateChanges(mState, newState)
+            mState = newState
+        }
+    }
+
+    private fun applyStateChanges(oldState: State, newState: State) {
+        mMapView.let {
+            val needsFullUpdate = mNeedsFullUpdate
+
+            applyStateChanges(it, oldState, newState,  needsFullUpdate)
+
+            mNeedsFullUpdate = false
+        }
+    }
+
+    private fun applyStateChanges(map: RNMBXMapView, oldState: State, newState: State, fullUpdate: Boolean) {
+        val mapView = map.mapView
+        if (map.getLifecycleState() != Lifecycle.State.STARTED && map.getLifecycleState() != Lifecycle.State.INITIALIZED) {
+            // In case lifecycle was already stopped, so we're part of shutdown, do not call updateSettings as it'll just restart
+            // the loationComponent that will not be stopped. See https://github.com/mapbox/mapbox-maps-android/issues/2017
+            if (!newState.enabled) {
+                stopLocationManager()
+            }
+            return
+        }
+        mapView.location.updateSettings {
+            enabled = newState.enabled
+
+            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 {
+                        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
+                    }
+                }
+            }
+
+            if (fullUpdate || newState.enabled != mState.enabled) {
+                if (newState.enabled) {
+                    startLocationManager()
+                    useMapLocationProvider(map)
+                } else {
+                    stopLocationManager()
+                }
+            }
+        }
+    }
+
+    private fun startLocationManager() {
+        if (!mLocationManagerStarted) {
+            mLocationManager.startCounted()
+            mLocationManagerStarted = true
+        }
+    }
+
+    private fun stopLocationManager() {
+        if (mLocationManagerStarted) {
+            mLocationManager.stopCounted()
+            mLocationManagerStarted = false
+        }
+    }
+
+    private fun useMapLocationProvider(mapView: RNMBXMapView) {
+        val provider = mapView.mapView.location.getLocationProvider()
+        if (provider != null) {
+            mLocationManager.provider = provider
+        }
+    }
+
+
+    fun showNativeUserLocation(showUserLocation: Boolean) {
+        update {
+            it.copy(showUserLocation = showUserLocation, nativeUserLocation= showUserLocation)
+        }
+    }
+
+    fun setFollowLocation(followUserLocation: Boolean) {
+        update {
+            it.copy(followUserLocation = followUserLocation)
+        }
+    }
+
+    fun update() {
+        update { it }
+    }
+
+    fun onDestroy() {
+        stopLocationManager();
+    }
+}

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
+    }
+}

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

@@ -0,0 +1,253 @@
+package com.rnmapbox.rnmbx.components.location
+
+import android.annotation.SuppressLint
+import android.content.Context
+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.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.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.utils.BitmapUtils
+import com.rnmapbox.rnmbx.utils.Logger
+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
+}
+
+class RNMBXNativeUserLocation(context: Context) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
+    private var mEnabled = true
+    private var mMap: MapboxMap? = null
+    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()
+        }
+
+    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
+        }
+    }
+
+    override fun addToMap(mapView: RNMBXMapView) {
+        super.addToMap(mapView)
+        mEnabled = true
+        mapView.getMapboxMap()
+        mapView.getMapAsync(this)
+        mMapView?.locationComponentManager?.showNativeUserLocation(true)
+        _fetchImages(mapView)
+        _apply()
+    }
+
+    override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
+        mEnabled = false
+        mMapView?.locationComponentManager?.showNativeUserLocation(false)
+        mMap?.getStyle(this)
+        return super.removeFromMap(mapView, reason)
+    }
+
+    @SuppressLint("MissingPermission")
+    override fun onMapReady(mapboxMap: MapboxMap) {
+        mMap = mapboxMap
+        mapboxMap.getStyle(this)
+        _apply()
+    }
+
+    @SuppressLint("MissingPermission")
+    override fun onStyleLoaded(style: Style) {
+        val context = context
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        mMapView?.locationComponentManager?.update()
+        mMapView?.locationComponentManager?.showNativeUserLocation(mEnabled)
+    }
+
+    // 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
+}
+
+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
+        )
+    );
+}