@rnmapbox/maps 10.0.0-beta.69 → 10.0.0-beta.71

package/android/rctmgl/build.gradle

@@ -130,7 +130,7 @@ dependencies {
             implementation 'com.mapbox.mapboxsdk:mapbox-sdk-turf:5.1.0'
         }
         else if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "mapbox") {
-            implementation 'com.mapbox.maps:android:10.11.0'
+            implementation 'com.mapbox.maps:android:10.11.1'
             implementation 'com.mapbox.mapboxsdk:mapbox-sdk-turf:6.10.0'
             implementation 'androidx.asynclayoutinflater:asynclayoutinflater:1.0.0'
         }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLMarkerView.kt

@@ -13,7 +13,6 @@ import com.mapbox.maps.ViewAnnotationOptions
 import com.mapbox.maps.viewannotation.viewAnnotationOptions
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
-import com.mapbox.rctmgl.modules.RCTMGLLogging
 import com.mapbox.rctmgl.utils.Logger
 import java.util.Vector
 

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/camera/RCTMGLCamera.kt

@@ -3,50 +3,35 @@ package com.mapbox.rctmgl.components.camera
 import android.animation.Animator
 import android.content.Context
 import android.location.Location
-import com.mapbox.rctmgl.utils.GeoJSONUtils.toPoint
+import com.facebook.react.bridge.ReadableMap
 import com.mapbox.maps.plugin.gestures.gestures
 import com.mapbox.rctmgl.location.LocationManager.Companion.getInstance
-import com.mapbox.maps.plugin.animation.camera
-import com.mapbox.rctmgl.utils.GeoJSONUtils.toLocation
-import com.mapbox.maps.plugin.animation.MapAnimationOptions.Builder
 import com.mapbox.maps.plugin.animation.flyTo
-import com.mapbox.rctmgl.components.camera.RCTMGLCameraManager
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
-import com.mapbox.rctmgl.components.camera.CameraStop
-import com.mapbox.rctmgl.components.camera.CameraUpdateQueue
 import com.mapbox.rctmgl.components.location.LocationComponentManager
 import com.mapbox.rctmgl.utils.LatLngBounds
-import com.mapbox.rctmgl.location.LocationManager.OnUserLocationChange
-import com.mapbox.rctmgl.utils.GeoJSONUtils
 import com.mapbox.maps.plugin.locationcomponent.OnIndicatorBearingChangedListener
 import com.mapbox.maps.plugin.locationcomponent.OnIndicatorPositionChangedListener
-import com.mapbox.rctmgl.components.camera.CameraUpdateItem
-import com.mapbox.rctmgl.events.IEvent
-import com.mapbox.rctmgl.events.MapChangeEvent
-import com.mapbox.rctmgl.events.constants.EventTypes
-import com.mapbox.rctmgl.components.camera.RCTMGLCamera
-import com.mapbox.android.core.permissions.PermissionsManager
-import com.mapbox.maps.plugin.animation.CameraAnimationsPlugin
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
-import com.mapbox.geojson.Point
 import com.mapbox.maps.*
 import com.mapbox.maps.plugin.PuckBearingSource
 import com.mapbox.maps.plugin.locationcomponent.location
 import com.mapbox.maps.plugin.locationcomponent.location2
+import com.mapbox.maps.plugin.viewport.ViewportStatus
+import com.mapbox.maps.plugin.viewport.ViewportStatusObserver
 import com.mapbox.maps.plugin.viewport.data.FollowPuckViewportStateBearing
 import com.mapbox.maps.plugin.viewport.data.FollowPuckViewportStateOptions
+import com.mapbox.maps.plugin.viewport.data.ViewportStatusChangeReason
 import com.mapbox.maps.plugin.viewport.viewport
 import com.mapbox.rctmgl.components.camera.constants.CameraMode
 import com.mapbox.rctmgl.components.location.*
+import com.mapbox.rctmgl.events.MapUserTrackingModeEvent
 import com.mapbox.rctmgl.location.*
-import com.mapbox.rctmgl.modules.RCTMGLLogging
-import com.mapbox.rctmgl.utils.LatLng
 import com.mapbox.rctmgl.utils.Logger
 
 
-
 class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCameraManager) :
     AbstractMapFeature(
         mContext
@@ -62,21 +47,24 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
     private var mLocationComponentManager: LocationComponentManager? = null
     private var mUserTrackingMode = 0
     private var mUserTrackingState = UserTrackingState.POSSIBLE
-    private val mUserLocationVerticalAlignment = UserLocationVerticalAlignment.CENTER
     private val mLocationManager: LocationManager?
     private val mUserLocation: UserLocation = UserLocation()
     private val mCenterCoordinate: ScreenCoordinate? = null
     private val mAnimated = false
     private val mHeading = 0.0
-    private var mFollowPitch : Double? = null
+
+    private var mFollowUserLocation = false
+    private var mFollowUserMode: String? = null
     private var mFollowZoomLevel : Double? = null
+    private var mFollowPitch : Double? = null
     private var mFollowHeading : Double? = null
+    private var mFollowPadding : EdgeInsets? = null
+
     private var mZoomLevel = -1.0
     private var mMinZoomLevel : Double? = null
     private var mMaxZoomLevel : Double? = null
     private var mMaxBounds: LatLngBounds? = null
-    private var mFollowUserLocation = false
-    private var mFollowUserMode: String? = null
+
 
     private val mLocationBearingChangedListener = OnIndicatorBearingChangedListener { v ->
         if (mFollowUserLocation) {
@@ -113,7 +101,8 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         setInitialCamera()
         updateMaxBounds()
         mCameraStop?.let { updateCamera(it) }
-        _updateViewportState();
+        _observeViewportState(mapView)
+        _updateViewportState()
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
@@ -131,9 +120,14 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         mDefaultStop = stop
     }
 
-    fun setFollowPitch(pitch: Double) {
-        mFollowPitch = pitch
-        _updateViewportState();
+    fun setFollowUserMode(mode: String?) {
+        mFollowUserMode = mode
+        _updateViewportState()
+    }
+
+    fun setFollowUserLocation(value: Boolean) {
+        mFollowUserLocation = value
+        _updateViewportState()
     }
 
     fun setFollowZoomLevel(zoomLevel: Double) {
@@ -141,11 +135,30 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         _updateViewportState();
     }
 
+    fun setFollowPitch(pitch: Double) {
+        mFollowPitch = pitch
+        _updateViewportState();
+    }
+
     fun setFollowHeading(heading: Double) {
         mFollowHeading = heading
         _updateViewportState();
     }
 
+    fun setFollowPadding(padding: ReadableMap) {
+        // scale padding by pixel ratio
+        val metrics = context.resources.displayMetrics
+        val edgeInsets = EdgeInsets(
+            if (padding.hasKey("paddingTop")) padding.getDouble("paddingTop") * metrics.density else 0.0,
+            if (padding.hasKey("paddingLeft")) padding.getDouble("paddingLeft") * metrics.density else 0.0,
+            if (padding.hasKey("paddingBottom")) padding.getDouble("paddingBottom") * metrics.density else 0.0,
+            if (padding.hasKey("paddingRight")) padding.getDouble("paddingRight") * metrics.density else 0.0,
+        )
+
+        mFollowPadding = edgeInsets
+        _updateViewportState();
+    }
+
     fun setMaxBounds(bounds: LatLngBounds?) {
         mMaxBounds = bounds
         updateMaxBounds()
@@ -182,14 +195,6 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         mCameraUpdateQueue.execute(mMapView)
     }
 
-    private fun updateUserTrackingMode(userTrackingMode: Int) {
-        /* v10todo
-        mUserLocation.setTrackingMode(userTrackingMode);
-        IEvent event = new MapUserTrackingModeEvent(this, userTrackingMode);
-        mManager.handleEvent(event);
-         */
-    }
-
     private fun updateUserLocation(isAnimated: Boolean) {
 
     }
@@ -224,7 +229,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         if (mLocationComponentManager == null) {
             mLocationComponentManager = mMapView!!.locationComponentManager
         }
-        mLocationComponentManager!!.update(style)
+        mLocationComponentManager!!.update()
     }
 
     fun setMinZoomLevel(zoomLevel: Double?) {
@@ -269,7 +274,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
     fun setUserTrackingMode(userTrackingMode: Int) {
         val oldTrackingMode = mUserTrackingMode
         mUserTrackingMode = userTrackingMode
-        updateUserTrackingMode(userTrackingMode)
+        mManager.handleEvent(MapUserTrackingModeEvent(this@RCTMGLCamera, userTrackingMode))
         when (mUserTrackingMode) {
             UserTrackingMode.NONE -> mUserTrackingState = UserTrackingState.POSSIBLE
             UserTrackingMode.FOLLOW, UserTrackingMode.FollowWithCourse, UserTrackingMode.FollowWithHeading -> if (oldTrackingMode == UserTrackingMode.NONE) {
@@ -281,15 +286,33 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         }
     }
 
-    fun setFollowUserLocation(value: Boolean) {
-        mFollowUserLocation = value
-        _updateViewportState()
+    fun _observeViewportState(mapView: MapView) {
+        mapView.viewport.addStatusObserver(object: ViewportStatusObserver {
+            override fun onViewportStatusChanged(
+                from: ViewportStatus,
+                to: ViewportStatus,
+                reason: ViewportStatusChangeReason
+            ) {
+                if (to == ViewportStatus.Idle) {
+                    mManager.handleEvent(MapUserTrackingModeEvent(this@RCTMGLCamera, UserTrackingMode.NONE))
+                } else if (to is ViewportStatus.Transition) {
+
+                } else if (to is ViewportStatus.State){
+                    //mManager.handleEvent(MapUserTrackingModeEvent(this@RCTMGLCamera, UserTrackingMode.FOLLOW))
+                }
+            }
+        })
     }
 
     fun _updateViewportState() {
         mMapView?.let {
             val map = it
             val viewport = map.viewport;
+
+            if (mLocationComponentManager == null) {
+                mLocationComponentManager = it.locationComponentManager
+            }
+
             if (mFollowUserLocation == false) {
                 viewport.idle()
                 mLocationComponentManager?.setFollowLocation(false)
@@ -298,10 +321,10 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
 
             mLocationComponentManager?.setFollowLocation(true)
             mLocationManager?.let {
-
-                val provider = it.provider
-                map.location.setLocationProvider(provider);
-                map.location2.setLocationProvider(provider);
+                val provider = map.location.getLocationProvider()
+                if (provider != null) {
+                    it.provider = provider
+                }
             }
 
             val location = map.location2
@@ -334,15 +357,22 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
                 }
             }
 
+            when(val it=mFollowZoomLevel) {
+                null -> followOptions.zoom(cameraState.zoom)
+                else -> followOptions.zoom(it)
+            }
+
             when(val it=mFollowPitch) {
                 null -> followOptions.pitch(cameraState.pitch)
                 else -> followOptions.pitch(it)
             }
-            when(val it=mFollowZoomLevel) {
-                null -> followOptions.zoom(cameraState.zoom)
-                else -> followOptions.zoom(mFollowZoomLevel)
+
+            when(val it=mFollowPadding) {
+                null -> followOptions.padding(cameraState.padding)
+                else -> followOptions.padding(it)
             }
 
+
             val followState = viewport.makeFollowPuckViewportState(followOptions.build())
             viewport.transitionTo(followState)
         }
@@ -353,11 +383,6 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         }
     }
 
-    fun setFollowUserMode(mode: String?) {
-        mFollowUserMode = mode
-        _updateViewportState()
-    }
-
     private fun updatedFollowUserMode() {
         if (mFollowUserLocation) {
             setUserTrackingMode(UserTrackingMode.fromString(mFollowUserMode))

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/camera/RCTMGLCameraManager.kt

@@ -1,5 +1,4 @@
 package com.mapbox.rctmgl.components.camera
-
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.ThemedReactContext
@@ -10,7 +9,6 @@ import com.mapbox.rctmgl.components.camera.CameraStop.Companion.fromReadableMap
 import com.mapbox.rctmgl.utils.GeoJSONUtils.toLatLngBounds
 
 
-//import com.mapbox.rctmgl.utils.GeoJSONUtils;
 class RCTMGLCameraManager(private val mContext: ReactApplicationContext) :
     AbstractEventEmitter<RCTMGLCamera?>(
         mContext
@@ -54,6 +52,16 @@ class RCTMGLCameraManager(private val mContext: ReactApplicationContext) :
         camera.setZoomLevel(zoomLevel)
     }
 
+    @ReactProp(name = "minZoomLevel")
+    fun setMinZoomLevel(camera: RCTMGLCamera, value: Double) {
+        camera.setMinZoomLevel(value)
+    }
+
+    @ReactProp(name = "maxZoomLevel")
+    fun setMaxZoomLevel(camera: RCTMGLCamera, value: Double) {
+        camera.setMaxZoomLevel(value)
+    }
+
     @ReactProp(name = "followUserLocation")
     fun setFollowUserLocation(camera: RCTMGLCamera, value: Boolean) {
         camera.setFollowUserLocation(value)
@@ -64,14 +72,9 @@ class RCTMGLCameraManager(private val mContext: ReactApplicationContext) :
         camera.setFollowUserMode(value)
     }
 
-    @ReactProp(name = "minZoomLevel")
-    fun setMinZoomLevel(camera: RCTMGLCamera, value: Double) {
-        camera.setMinZoomLevel(value)
-    }
-
-    @ReactProp(name = "maxZoomLevel")
-    fun setMaxZoomLevel(camera: RCTMGLCamera, value: Double) {
-        camera.setMaxZoomLevel(value)
+    @ReactProp(name = "followZoomLevel")
+    fun setFollowZoomLevel(camera: RCTMGLCamera, value: Double) {
+        camera.setFollowZoomLevel(value)
     }
 
     @ReactProp(name = "followPitch")
@@ -84,9 +87,9 @@ class RCTMGLCameraManager(private val mContext: ReactApplicationContext) :
         camera.setFollowHeading(value)
     }
 
-    @ReactProp(name = "followZoomLevel")
-    fun setFollowZoomLevel(camera: RCTMGLCamera, value: Double) {
-        camera.setFollowZoomLevel(value)
+    @ReactProp(name = "followPadding")
+    fun setFollowPadding(camera: RCTMGLCamera, value: ReadableMap) {
+        camera.setFollowPadding(value)
     }
 
     @ReactProp(name = "maxBounds")

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

@@ -2,124 +2,166 @@ package com.mapbox.rctmgl.components.location
 
 import android.content.Context
 import android.graphics.Color
+import android.graphics.drawable.Drawable
 import android.graphics.drawable.VectorDrawable
 import androidx.appcompat.content.res.AppCompatResources
+import androidx.lifecycle.Lifecycle
 import com.mapbox.maps.plugin.locationcomponent.location
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
-import com.mapbox.maps.Style
 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
 
 /**
  * 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 enbabled then it's viewport user tracking is not working.
+ * 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: RCTMGLMapView, context: Context) {
-    private var mShowNativeUserLocation = false
-    private var mFollowLocation = false
     var mMapView = mapView
     var mContext = context
-    var mState = State(enabled=true, hidden=false, tintColor= null)
-    var mLocationManager: LocationManager? = LocationManager.getInstance(context!!)
+    private var mState = State(showUserLocation=false, followUserLocation=false, hidden=false, tintColor= null, bearingImage = null, puckBearingSource =null)
+
+    private var mLocationManager: LocationManager = LocationManager.getInstance(context)
+
+    private var mNeedsFullUpdate = true
+
+    private var mLocationManagerStarted = false
 
     data class State(
-        val enabled: Boolean, // in case followUserLocation is active or visible
+        val showUserLocation: Boolean,
+        val followUserLocation: Boolean,
         val hidden: Boolean, // in case it isn't native
         val tintColor: Int?, // tint of location puck
-    )
-
-    fun showNativeUserLocation(showUserLocation: Boolean) {
-        mShowNativeUserLocation = showUserLocation
-
-        _applyChanges()
+        var bearingImage: Drawable?, // bearing image (background)
+        var puckBearingSource: PuckBearingSource? // bearing source
+    ) {
+        val enabled: Boolean
+            get() = showUserLocation || followUserLocation
     }
 
-    fun setFollowLocation(followLoation: Boolean) {
-        mFollowLocation = followLoation
-
-        _applyChanges()
+    fun update(newStateCallback: (currentState: State) -> State) {
+        val newState = newStateCallback(mState);
+        if (newState != mState) {
+            applyStateChanges(mState, newState)
+            mState = newState
+        }
     }
 
-    fun update(style: Style) {
-        _applyChanges()
-    }
+    private fun applyStateChanges(oldState: State, newState: State) {
+        mMapView.let {
+            val needsFullUpdate = mNeedsFullUpdate
 
-    fun setRenderMode(renderMode: RenderMode) {
-        _applyChanges()
+            applyStateChanges(it, oldState, newState,  needsFullUpdate)
+
+            mNeedsFullUpdate = false
+        }
     }
 
-    fun _applyChanges() {
-        mMapView?.let {
-            val newState = State(
-                enabled = mShowNativeUserLocation || mFollowLocation,
-                hidden = !mShowNativeUserLocation,
-                tintColor = mMapView!!.tintColor,
-            )
-
-            if (! mState.equals(newState)) {
-                it.location.updateSettings {
-                    val trackLocation = true
-                    enabled = newState.enabled
-
-                    if ((newState.hidden != mState.hidden) || (newState.tintColor != mState.tintColor)) {
-                        if (newState.hidden) {
-                            var emptyLocationPuck = LocationPuck2D()
-                            val empty = AppCompatResources.getDrawable(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 = AppCompatResources.getDrawable(mContext!!, R.drawable.mapbox_user_icon)
-                            if (tintColor != null) {
-                                val drawable = topImage as VectorDrawable?
-                                drawable!!.setTint(tintColor)
-                                topImage = drawable
-                            }
-                            defaultLocationPuck.topImage = topImage
-                            val bearingImage = AppCompatResources.getDrawable(
-                                mContext!!, R.drawable.mapbox_user_stroke_icon
-                            )
-                            defaultLocationPuck.bearingImage = bearingImage
-                            val shadowImage = AppCompatResources.getDrawable(
-                                mContext!!, R.drawable.mapbox_user_icon_shadow
-                            )
-                            defaultLocationPuck.shadowImage = shadowImage
-                            locationPuck = defaultLocationPuck
-                            pulsingEnabled = true
-                            if (tintColor != null) {
-                                pulsingColor = tintColor
-                            } else {
-                                pulsingColor = mapboxBlueColor
-                            }
-                        }
+    private fun applyStateChanges(map: RCTMGLMapView, oldState: State, newState: State, fullUpdate: Boolean) {
+        if (map.getLifecycleState() != Lifecycle.State.STARTED) {
+            // 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
+        }
+        map.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 = AppCompatResources.getDrawable(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 = AppCompatResources.getDrawable(mContext, R.drawable.mapbox_user_icon)
+                    if (tintColor != null) {
+                        val drawable = topImage as VectorDrawable?
+                        drawable!!.setTint(tintColor)
+                        topImage = drawable
                     }
-                }
-
-                if (newState.enabled != mState.enabled) {
-                    if (newState.enabled) {
-                        mLocationManager?.startCounted()
-                        val provider = mLocationManager?.provider
-                        if (provider != null) {
-                            it.location.setLocationProvider(provider)
-                        }
+                    defaultLocationPuck.topImage = topImage
+                    val defaultBearingImage = AppCompatResources.getDrawable(
+                        mContext, R.drawable.mapbox_user_stroke_icon
+                    );
+                    defaultLocationPuck.bearingImage = newState.bearingImage ?: defaultBearingImage
+                    val shadowImage = AppCompatResources.getDrawable(
+                        mContext, R.drawable.mapbox_user_icon_shadow
+                    )
+                    defaultLocationPuck.shadowImage = shadowImage
+                    locationPuck = defaultLocationPuck
+                    pulsingEnabled = true
+                    if (tintColor != null) {
+                        pulsingColor = tintColor
                     } else {
-                        mLocationManager?.stopCounted()
+                        pulsingColor = mapboxBlueColor
                     }
                 }
+            }
 
-                mState = newState;
+            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: RCTMGLMapView) {
+        val provider = mapView.location.getLocationProvider()
+        if (provider != null) {
+            mLocationManager.provider = provider
+        }
+    }
+
 
+    fun showNativeUserLocation(showUserLocation: Boolean) {
+        update {
+            it.copy(showUserLocation = showUserLocation)
+        }
+    }
 
+    fun setFollowLocation(followUserLocation: Boolean) {
+        update {
+            it.copy(followUserLocation = followUserLocation)
         }
     }
+
+    fun update() {
+        update { it }
+    }
+
+    fun onDestroy() {
+        stopLocationManager();
+    }
 }

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

@@ -2,25 +2,33 @@ package com.mapbox.rctmgl.components.location
 
 import android.annotation.SuppressLint
 import android.content.Context
+import androidx.appcompat.content.res.AppCompatResources
 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.mapview.RCTMGLMapView
 
-class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
+enum class RenderMode {
+    GPS, COMPASS, NORMAL
+}
+
+class RCTMGLNativeUserLocation(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 mRenderMode : RenderMode = RenderMode.COMPASS
     override fun addToMap(mapView: RCTMGLMapView) {
         super.addToMap(mapView)
         mEnabled = true
         mapView.getMapboxMap()
         mapView.getMapAsync(this)
-        setRenderMode(mRenderMode)
         mMapView?.locationComponentManager?.showNativeUserLocation(true)
+        applyChanges()
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
@@ -34,6 +42,12 @@ class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context),
     override fun onMapReady(mapboxMap: MapboxMap) {
         mMap = mapboxMap
         mapboxMap.getStyle(this)
+        applyChanges()
+    }
+
+    fun setAndroidRenderMode(renderMode: RenderMode) {
+        mRenderMode = renderMode;
+        applyChanges();
     }
 
     @SuppressLint("MissingPermission")
@@ -43,12 +57,24 @@ class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context),
             return
         }
 
-        mMapView?.locationComponentManager?.update(style)
+        mMapView?.locationComponentManager?.update()
         mMapView?.locationComponentManager?.showNativeUserLocation(mEnabled)
     }
 
-    fun setRenderMode(renderMode: RenderMode) {
-        mRenderMode = renderMode
-        mMapView?.locationComponentManager?.setRenderMode(renderMode)
+    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 =  AppCompatResources.getDrawable(
+                        mContext, R.drawable.mapbox_user_bearing_icon
+                    ), puckBearingSource = PuckBearingSource.COURSE) }
+                RenderMode.COMPASS -> it.update{ it.copy(bearingImage=  AppCompatResources.getDrawable(
+                    mContext, R.drawable.mapbox_user_puck_icon
+                ), puckBearingSource = PuckBearingSource.HEADING) }
+            }
+        }
     }
 }