@rnmapbox/maps 10.0.0-beta.59 → 10.0.0-beta.61

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.9.1'
+            implementation 'com.mapbox.maps:android:10.10.0'
             implementation 'com.mapbox.mapboxsdk:mapbox-sdk-turf:6.8.0'
             implementation 'androidx.asynclayoutinflater:asynclayoutinflater:1.0.0'
         }

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

@@ -77,15 +77,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
     private var mMaxBounds: LatLngBounds? = null
     private var mFollowUserLocation = false
     private var mFollowUserMode: String? = null
-    private val mLocationChangeListener: OnUserLocationChange = object : OnUserLocationChange {
-        override fun onLocationChange(nextLocation: Location?) {
-            if (mapboxMap == null || mLocationComponentManager == null || !mLocationComponentManager!!.hasLocationComponent() || !mFollowUserLocation) {
-                return
-            }
-            mUserLocation.currentLocation = nextLocation
-            sendUserLocationUpdateEvent(toPoint(nextLocation!!))
-        }
-    }
+
     private val mLocationBearingChangedListener = OnIndicatorBearingChangedListener { v ->
         if (mFollowUserLocation) {
             mMapView!!.getMapboxMap().setCamera(CameraOptions.Builder().bearing(v).build())
@@ -95,7 +87,6 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         if (mFollowUserLocation) {
             mMapView!!.getMapboxMap().setCamera(CameraOptions.Builder().center(point).build())
             mMapView!!.gestures.focalPoint = mMapView!!.getMapboxMap().pixelForCoordinate(point)
-            sendUserLocationUpdateEvent(point)
         }
     }
     private val mCameraCallback: Animator.AnimatorListener = object : Animator.AnimatorListener {
@@ -122,10 +113,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         setInitialCamera()
         updateMaxBounds()
         mCameraStop?.let { updateCamera(it) }
-        if (mFollowUserLocation) {
-            // updateFollowLocation(mFollowUserLocation);
-            enableLocation()
-        }
+        _updateViewportState();
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
@@ -221,18 +209,6 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
             return direction
         }
 
-    private fun sendUserLocationUpdateEvent(point: Point?) {
-        if (point == null) {
-            return
-        }
-        val event: IEvent = MapChangeEvent(
-            this, EventTypes.USER_LOCATION_UPDATED, makeLocationChangePayload(
-                toLocation(point)
-            )
-        )
-        mManager.handleEvent(event)
-    }
-
     private fun hasSetCenterCoordinate(): Boolean {
         val state = mapboxMap!!.cameraState
         val center = state.center
@@ -244,78 +220,11 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         mLocationManager = getInstance(mContext)
     }
 
-    private fun enableLocation() {
-        if (!PermissionsManager.areLocationPermissionsGranted(mContext)) {
-            return
-        }
-        if (!mLocationManager!!.isActive()) {
-            mLocationManager.enable()
-        }
-        mMapView!!.getMapboxMap().getStyle {
-            enableLocationComponent(it)
-        }
-    }
-
-    private fun enableLocationComponent(style: Style) {
-        updateUserLocation(false)
-        updateLocationLayer(style)
-        val lastKnownLocation = mLocationManager!!.lastKnownLocation
-        mLocationManager.addLocationListener(mLocationChangeListener)
-        if (lastKnownLocation != null) {
-            mLocationChangeListener.onLocationChange(lastKnownLocation)
-            postDelayed({ mMapView!!.sendRegionDidChangeEvent() }, 200)
-        }
-    }
-
     private fun updateLocationLayer(style: Style) {
         if (mLocationComponentManager == null) {
             mLocationComponentManager = mMapView!!.locationComponentManager
         }
         mLocationComponentManager!!.update(style)
-        if (mFollowUserLocation) {
-            mLocationComponentManager!!.setCameraMode(
-                UserTrackingMode.getCameraMode(
-                    mUserTrackingMode
-                )
-            )
-        }
-        mLocationComponentManager!!.setFollowUserLocation(mFollowUserLocation)
-        if (mFollowUserLocation) {
-            mLocationComponentManager!!.setCameraMode(
-                UserTrackingMode.getCameraMode(
-                    mUserTrackingMode
-                )
-            )
-
-            /*
-            mLocationComponentManager.addOnCameraTrackingChangedListener(new OnCameraTrackingChangedListener() {
-                    @Override public void onCameraTrackingChanged(int currentMode) {
-                        int userTrackingMode = UserTrackingMode.NONE;
-                        switch (currentMode) {
-                            case CameraMode.NONE:
-                                userTrackingMode = UserTrackingMode.NONE;
-                                break;
-                            case CameraMode.TRACKING:
-                                userTrackingMode = UserTrackingMode.FOLLOW;
-                                break;
-                            case CameraMode.TRACKING_COMPASS:
-                                userTrackingMode = UserTrackingMode.FollowWithHeading;
-                                break;
-                            case CameraMode.TRACKING_GPS:
-                                userTrackingMode = UserTrackingMode.FollowWithCourse;
-                                break;
-                            default:
-                                userTrackingMode = UserTrackingMode.NONE;
-                        }
-                        updateUserTrackingMode(userTrackingMode);
-                    }
-                    @Override public void onCameraTrackingDismissed() {
-                    }
-            });
-             */
-        } else {
-            mLocationComponentManager!!.setCameraMode(com.mapbox.rctmgl.components.location.CameraMode.NONE)
-        }
     }
 
     fun setMinZoomLevel(zoomLevel: Double?) {
@@ -383,16 +292,16 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
             val viewport = map.viewport;
             if (mFollowUserLocation == false) {
                 viewport.idle()
-                mLocationManager?.disable()
+                mLocationComponentManager?.setFollowLocation(false)
                 return;
             }
 
+            mLocationComponentManager?.setFollowLocation(true)
             mLocationManager?.let {
-                val provider = it.provider
 
+                val provider = it.provider
                 map.location.setLocationProvider(provider);
                 map.location2.setLocationProvider(provider);
-                it.enable();
             }
 
             val location = map.location2

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

@@ -49,7 +49,7 @@ class RCTMGLCameraManager(private val mContext: ReactApplicationContext) :
         throw AssertionError("Unused code")
     }
 
-    @ReactProp(name = "followZoomLevel")
+    @ReactProp(name = "zoomLevel")
     fun setZoomLevel(camera: RCTMGLCamera, zoomLevel: Double) {
         camera.setZoomLevel(zoomLevel)
     }

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

@@ -0,0 +1,125 @@
+package com.mapbox.rctmgl.components.location
+
+import android.content.Context
+import android.graphics.Color
+import android.graphics.drawable.VectorDrawable
+import androidx.appcompat.content.res.AppCompatResources
+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.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.
+ * 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!!)
+
+    data class State(
+        val enabled: Boolean, // in case followUserLocation is active or visible
+        val hidden: Boolean, // in case it isn't native
+        val tintColor: Int?, // tint of location puck
+    )
+
+    fun showNativeUserLocation(showUserLocation: Boolean) {
+        mShowNativeUserLocation = showUserLocation
+
+        _applyChanges()
+    }
+
+    fun setFollowLocation(followLoation: Boolean) {
+        mFollowLocation = followLoation
+
+        _applyChanges()
+    }
+
+    fun update(style: Style) {
+        _applyChanges()
+    }
+
+    fun setRenderMode(renderMode: RenderMode) {
+        _applyChanges()
+    }
+
+    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
+                            }
+                        }
+                    }
+                }
+
+                if (newState.enabled != mState.enabled) {
+                    if (newState.enabled) {
+                        mLocationManager?.startCounted()
+                        val provider = mLocationManager?.provider
+                        if (provider != null) {
+                            it.location.setLocationProvider(provider)
+                        }
+                    } else {
+                        mLocationManager?.stopCounted()
+                    }
+                }
+
+                mState = newState;
+            }
+
+
+        }
+    }
+}

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

@@ -9,27 +9,23 @@ import com.mapbox.maps.Style
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
 
-/*
-import com.mapbox.mapboxsdk.location.modes.RenderMode;
-import com.mapbox.mapboxsdk.maps.MapboxMap;
-import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
-import com.mapbox.mapboxsdk.maps.Style;
- */   class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
+class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
     private var mEnabled = true
     private var mMap: MapboxMap? = null
 
-    @RenderMode.Mode
-    private var mRenderMode = RenderMode.COMPASS
+    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)
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
         mEnabled = false
+        mMapView?.locationComponentManager?.showNativeUserLocation(false)
         mMap?.getStyle(this)
         super.removeFromMap(mapView)
     }
@@ -48,10 +44,10 @@ import com.mapbox.mapboxsdk.maps.Style;
         }
 
         mMapView?.locationComponentManager?.update(style)
-        mMapView?.locationComponentManager?.showUserLocation(mEnabled)
+        mMapView?.locationComponentManager?.showNativeUserLocation(mEnabled)
     }
 
-    fun setRenderMode(@RenderMode.Mode renderMode: Int) {
+    fun setRenderMode(renderMode: RenderMode) {
         mRenderMode = renderMode
         mMapView?.locationComponentManager?.setRenderMode(renderMode)
     }

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

@@ -0,0 +1,21 @@
+package com.mapbox.rctmgl.components.location
+
+/**
+ * Contains the variety of ways the user location can be rendered on the map.
+ */
+enum class RenderMode {
+    /**
+     * Basic tracking is enabled, bearing ignored.
+     */
+    NORMAL,
+    /**
+     * Tracking the user location with bearing considered
+     * from a [CompassEngine].
+     */
+    COMPASS,
+    /**
+     * Tracking the user location with bearing considered from [android.location.Location].
+     */
+    GPS
+}
+

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

@@ -29,6 +29,7 @@ import com.mapbox.maps.extension.style.layers.properties.generated.Visibility
 import com.mapbox.maps.extension.style.projection.generated.Projection
 import com.mapbox.maps.extension.style.projection.generated.setProjection
 import com.mapbox.maps.plugin.annotation.Annotation
+import com.mapbox.maps.plugin.annotation.AnnotationConfig
 import com.mapbox.maps.plugin.annotation.annotations
 import com.mapbox.maps.plugin.annotation.generated.*
 import com.mapbox.maps.plugin.attribution.attribution
@@ -125,7 +126,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
                 gesturesPlugin.removeOnMapClickListener(_this)
                 gesturesPlugin.removeOnMapLongClickListener(_this)
 
-                mPointAnnotationManager = annotations.createPointAnnotationManager()
+                mPointAnnotationManager = annotations.createPointAnnotationManager(AnnotationConfig(layerId = "rctmgl-mapview-annotations"))
                 mPointAnnotationManager?.addClickListener(OnPointAnnotationClickListener { pointAnnotation ->
                         onMarkerClick(pointAnnotation)
                         false

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/events/LocationEvent.kt

@@ -0,0 +1,75 @@
+package com.mapbox.rctmgl.events
+
+import android.location.Location
+import com.facebook.react.bridge.Arguments
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.rctmgl.events.IEvent
+import com.mapbox.rctmgl.events.constants.EventKeys
+import com.mapbox.rctmgl.events.constants.EventTypes
+import com.mapbox.rctmgl.events.LocationEvent
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import java.util.*
+
+class LocationEvent(private val location: Location, private val mapView: RCTMGLMapView?) : IEvent {
+    val uUID: UUID
+
+    init {
+        uUID = UUID.randomUUID()
+    }
+
+    constructor(location: Location) : this(location, null) {}
+
+    override fun getID(): Int {
+        return mapView?.id ?: -1
+    }
+
+    override fun getKey(): String {
+        return EventKeys.USER_LOCATION_UPDATE
+    }
+
+    override fun getType(): String {
+        return EventTypes.USER_LOCATION_UPDATED
+    }
+
+    override fun getTimestamp(): Long {
+        return System.currentTimeMillis()
+    }
+
+    override fun equals(event: IEvent): Boolean {
+        val other = event as LocationEvent
+        return uUID == other.uUID
+    }
+
+    fun equals(event: LocationEvent): Boolean {
+        return uUID == event.uUID
+    }
+
+    override fun getPayload(): WritableMap {
+        val positionProperties: WritableMap = WritableNativeMap()
+        val coords: WritableMap = WritableNativeMap()
+        coords.putDouble("longitude", location.longitude)
+        coords.putDouble("latitude", location.latitude)
+        coords.putDouble("altitude", location.altitude)
+        coords.putDouble("accuracy", location.accuracy.toDouble())
+        // A better solution will be to pull the heading from the compass engine, 
+        // unfortunately the api is not publicly available in the mapbox sdk
+        coords.putDouble("heading", location.bearing.toDouble())
+        coords.putDouble("course", location.bearing.toDouble())
+        coords.putDouble("speed", location.speed.toDouble())
+        positionProperties.putMap("coords", coords)
+        positionProperties.putDouble("timestamp", location.time.toDouble())
+        return positionProperties
+    }
+
+    override fun toJSON(): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", type)
+        map.putMap("payload", payload)
+        return map
+    }
+
+    override fun canCoalesce(): Boolean {
+        return true
+    }
+}

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

@@ -10,7 +10,6 @@ import com.mapbox.android.core.location.LocationEngineCallback
 import com.mapbox.android.core.location.LocationEngineResult
 import com.mapbox.maps.plugin.locationcomponent.LocationConsumer
 import com.mapbox.android.core.location.LocationEngineRequest
-import com.mapbox.rctmgl.location.LocationProviderForEngine
 import com.mapbox.android.core.location.LocationEngineProvider
 import com.mapbox.android.core.permissions.PermissionsManager
 import android.os.Looper
@@ -68,6 +67,11 @@ class LocationManager private constructor(private val context: Context) : Locati
     private var lastLocation: Location? = null
     private var locationEngineRequest: LocationEngineRequest? = null
     private var locationProvider: LocationProviderForEngine? = null
+    private var nStarts : Int = 0;
+    private var isPaused : Boolean = false;
+
+
+
     val provider: LocationProvider
         get() {
             if (locationProvider == null) {
@@ -80,6 +84,41 @@ class LocationManager private constructor(private val context: Context) : Locati
         fun onLocationChange(location: Location?)
     }
 
+
+    /// public interface
+
+    fun startCounted() {
+        nStarts += 1;
+        if (nStarts == 1) {
+            enable(false);
+        }
+    }
+
+    fun stopCounted() {
+        nStarts -= 1;
+        if (nStarts == 0) {
+            dispose();
+        }
+    }
+
+    fun pause() {
+        isPaused = true
+    }
+
+    fun resume() {
+        isPaused = false
+        if (nStarts > 0) {
+            enable(false)
+        }
+    }
+
+    fun destroy() {
+        dispose();
+        nStarts = -1000;
+    }
+
+    ////
+
     private fun buildEngineRequest() {
         engine = LocationEngineProvider.getBestLocationEngine(context.applicationContext)
         locationEngineRequest = LocationEngineRequest.Builder(DEFAULT_INTERVAL_MILLIS)
@@ -103,10 +142,14 @@ class LocationManager private constructor(private val context: Context) : Locati
 
     fun setMinDisplacement(minDisplacement: Float) {
         mMinDisplacement = minDisplacement
+
+        if (isActive) {
+            enable(true)
+        }
     }
 
     @SuppressLint("MissingPermission")
-    fun enable() {
+    private fun enable(refresh: Boolean) {
         if (!PermissionsManager.areLocationPermissionsGranted(context)) {
             return
         }
@@ -126,17 +169,16 @@ class LocationManager private constructor(private val context: Context) : Locati
         isActive = true
     }
 
-    fun disable() {
+    private fun disable() {
         engine?.removeLocationUpdates(this)
         isActive = false
     }
 
-    fun dispose() {
+    private fun dispose() {
         if (engine == null) {
             return
         }
         disable()
-        engine?.removeLocationUpdates(this)
     }
 
     fun isActive(): Boolean {
@@ -149,7 +191,7 @@ class LocationManager private constructor(private val context: Context) : Locati
         } else lastLocation
 
     @SuppressLint("MissingPermission")
-    fun getLastKnownLocation(callback: LocationEngineCallback<LocationEngineResult?>) {
+    fun getLastKnownLocation(callback: LocationEngineCallback<LocationEngineResult>) {
         if (engine == null) {
             callback.onFailure(Exception("LocationEngine not initialized"))
         }