@rnmapbox/maps 10.0.0-beta.70 → 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/camera/RCTMGLCamera.kt

@@ -3,6 +3,7 @@ package com.mapbox.rctmgl.components.camera
 import android.animation.Animator
 import android.content.Context
 import android.location.Location
+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.flyTo
@@ -18,16 +19,19 @@ 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.utils.Logger
 
 
-
 class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCameraManager) :
     AbstractMapFeature(
         mContext
@@ -43,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) {
@@ -94,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) {
@@ -112,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) {
@@ -122,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()
@@ -163,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) {
 
     }
@@ -250,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) {
@@ -262,9 +286,22 @@ 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() {
@@ -320,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)
         }
@@ -339,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/UserTrackingMode.kt

@@ -0,0 +1,42 @@
+package com.mapbox.rctmgl.components.location
+
+object UserTrackingMode {
+    const val NONE = 0
+    const val FOLLOW = 1
+    const val FollowWithCourse = 2
+    const val FollowWithHeading = 3
+    @CameraMode.Mode
+    fun getCameraMode(mode: Int): Int {
+        when (mode) {
+            NONE -> return CameraMode.NONE
+            FOLLOW -> return CameraMode.TRACKING
+            FollowWithCourse -> return CameraMode.TRACKING_GPS
+            FollowWithHeading -> return CameraMode.TRACKING_COMPASS
+        }
+        return CameraMode.NONE
+    }
+
+    fun isUserGesture(reason: Int): Boolean {
+        return reason == 1 || reason == 2 // user gesture or animation
+    }
+
+    fun toString(value: Int): String? {
+        when (value) {
+            FOLLOW -> return "normal"
+            FollowWithCourse -> return "course"
+            FollowWithHeading -> return "compass"
+        }
+        return null
+    }
+
+    fun fromString(value: String?): Int {
+        var value = value
+        if (value == null) value = ""
+        return when (value) {
+            "course" -> FollowWithCourse
+            "normal" -> FOLLOW
+            "compass" -> FollowWithHeading
+            else -> FOLLOW
+        }
+    }
+}

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

@@ -15,6 +15,8 @@ import androidx.lifecycle.LifecycleRegistry
 import androidx.lifecycle.ViewTreeLifecycleOwner
 import com.facebook.react.bridge.*
 import com.mapbox.android.gestures.MoveGestureDetector
+import com.mapbox.android.gestures.RotateGestureDetector
+import com.mapbox.android.gestures.StandardScaleGestureDetector
 import com.mapbox.geojson.Feature
 import com.mapbox.geojson.FeatureCollection
 import com.mapbox.geojson.Point
@@ -28,7 +30,6 @@ import com.mapbox.maps.extension.style.layers.properties.generated.ProjectionNam
 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.animation.camera
 import com.mapbox.maps.plugin.annotation.Annotation
 import com.mapbox.maps.plugin.annotation.AnnotationConfig
 import com.mapbox.maps.plugin.annotation.annotations
@@ -39,13 +40,10 @@ import com.mapbox.maps.plugin.compass.compass
 import com.mapbox.maps.plugin.compass.generated.CompassSettings
 import com.mapbox.maps.plugin.delegates.listeners.*
 import com.mapbox.maps.plugin.gestures.*
-import com.mapbox.maps.plugin.locationcomponent.location
-import com.mapbox.maps.plugin.locationcomponent.location2
 import com.mapbox.maps.plugin.logo.generated.LogoSettings
 import com.mapbox.maps.plugin.logo.logo
 import com.mapbox.maps.plugin.scalebar.generated.ScaleBarSettings
 import com.mapbox.maps.plugin.scalebar.scalebar
-import com.mapbox.maps.plugin.viewport.viewport
 import com.mapbox.rctmgl.R
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerView
@@ -55,6 +53,7 @@ import com.mapbox.rctmgl.components.camera.RCTMGLCamera
 import com.mapbox.rctmgl.components.images.RCTMGLImages
 import com.mapbox.rctmgl.components.location.LocationComponentManager
 import com.mapbox.rctmgl.components.location.RCTMGLNativeUserLocation
+import com.mapbox.rctmgl.components.mapview.helpers.CameraChangeReason
 import com.mapbox.rctmgl.components.mapview.helpers.CameraChangeTracker
 import com.mapbox.rctmgl.components.styles.layers.RCTLayer
 import com.mapbox.rctmgl.components.styles.light.RCTMGLLight
@@ -81,6 +80,10 @@ data class OrnamentSettings(
     var position: Int = -1
 )
 
+enum class MapGestureType {
+    Move,Scale,Rotate
+}
+
 /***
  * Mapbox's MapView observers lifecycle events see MapboxLifecyclePluginImpl - (ON_START, ON_STOP, ON_DESTROY)
  * We need to emulate those.
@@ -258,25 +261,58 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         gesturesPlugin.addOnMapLongClickListener(_this)
         gesturesPlugin.addOnMapClickListener(_this)
 
+        gesturesPlugin.addOnScaleListener(object: OnScaleListener{
+            override fun onScale(detector: StandardScaleGestureDetector) {
+                mapGesture(MapGestureType.Scale, detector)
+            }
+            override fun onScaleBegin(detector: StandardScaleGestureDetector) {
+                mapGestureBegin(MapGestureType.Scale, detector)
+            }
+            override fun onScaleEnd(detector: StandardScaleGestureDetector) {
+                mapGestureEnd(MapGestureType.Scale, detector)
+            }
+        })
+
+        gesturesPlugin.addOnRotateListener(object: OnRotateListener{
+            override fun onRotate(detector: RotateGestureDetector) {
+                mapGesture(MapGestureType.Rotate, detector)
+            }
+            override fun onRotateBegin(detector: RotateGestureDetector) {
+                mapGestureBegin(MapGestureType.Rotate, detector)
+            }
+            override fun onRotateEnd(detector: RotateGestureDetector) {
+                mapGestureEnd(MapGestureType.Rotate, detector)
+            }
+        })
+
         gesturesPlugin.addOnMoveListener(object : OnMoveListener {
             override fun onMoveBegin(moveGestureDetector: MoveGestureDetector) {
-                mCameraChangeTracker.setReason(CameraChangeTracker.USER_GESTURE)
-                handleMapChangedEvent(EventTypes.REGION_WILL_CHANGE)
+                mapGestureBegin(MapGestureType.Move, moveGestureDetector)
             }
 
             override fun onMove(moveGestureDetector: MoveGestureDetector): Boolean {
-                mCameraChangeTracker.setReason(CameraChangeTracker.USER_GESTURE)
-                handleMapChangedEvent(EventTypes.REGION_IS_CHANGING)
-                return false
+                return mapGesture(MapGestureType.Move, moveGestureDetector)
             }
 
-            override fun onMoveEnd(moveGestureDetector: MoveGestureDetector) {}
+            override fun onMoveEnd(moveGestureDetector: MoveGestureDetector) {
+                mapGestureEnd(MapGestureType.Move, moveGestureDetector)
+            }
         })
 
-
         map.subscribe({ event -> Logger.e(LOG_TAG, String.format("Map load failed: %s", event.data.toString())) }, Arrays.asList(MapEvents.MAP_LOADING_ERROR))
     }
 
+    fun<T> mapGestureBegin(type:MapGestureType, gesture: T) {
+        mCameraChangeTracker.setReason(CameraChangeReason.USER_GESTURE)
+        handleMapChangedEvent(EventTypes.REGION_WILL_CHANGE)
+    }
+    fun<T> mapGesture(type: MapGestureType, gesture: T): Boolean {
+        mCameraChangeTracker.setReason(CameraChangeReason.USER_GESTURE)
+        handleMapChangedEvent(EventTypes.REGION_IS_CHANGING)
+        return false
+    }
+    fun<T> mapGestureEnd(type: MapGestureType, gesture: T) {}
+
     fun init() {
         // Required for rendering properly in Android Oreo
         viewTreeObserver.dispatchOnGlobalLayout()
@@ -382,7 +418,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         val event: IEvent = MapChangeEvent(this, EventTypes.REGION_DID_CHANGE,
                 makeRegionPayload(isAnimated))
         mManager.handleEvent(event)
-        mCameraChangeTracker.setReason(CameraChangeTracker.EMPTY)
+        mCameraChangeTracker.setReason(CameraChangeReason.NONE)
     }
 
     private fun removeAllFeaturesFromMap() {
@@ -665,7 +701,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
 
     fun sendRegionDidChangeEvent() {
         handleMapChangedEvent(EventTypes.REGION_DID_CHANGE)
-        mCameraChangeTracker.setReason(CameraChangeTracker.EMPTY)
+        mCameraChangeTracker.setReason(CameraChangeReason.NONE)
     }
 
     private fun handleMapChangedEvent(eventType: String) {

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

@@ -0,0 +1,23 @@
+package com.mapbox.rctmgl.components.mapview.helpers
+
+enum class CameraChangeReason {
+    NONE,
+    USER_GESTURE,
+    DEVELOPER_ANIMATION,
+    SDK_ANIMATION
+}
+
+class CameraChangeTracker {
+    private var reason : CameraChangeReason = CameraChangeReason.NONE
+    var isAnimating = false
+    fun setReason(reason: CameraChangeReason) {
+        this.reason = reason
+    }
+
+    val isUserInteraction: Boolean
+        get() = reason == CameraChangeReason.USER_GESTURE || reason == CameraChangeReason.DEVELOPER_ANIMATION
+    val isAnimated: Boolean
+        get() = reason == CameraChangeReason.DEVELOPER_ANIMATION || reason == CameraChangeReason.SDK_ANIMATION
+    val isEmpty: Boolean
+        get() = reason == CameraChangeReason.NONE
+}

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

@@ -0,0 +1,21 @@
+package com.mapbox.rctmgl.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.mapbox.rctmgl.components.location.UserTrackingMode
+import com.mapbox.rctmgl.events.constants.EventKeys
+import com.mapbox.rctmgl.events.constants.EventTypes
+
+class MapUserTrackingModeEvent(view: View?, val userTrackingMode: Int) : AbstractEvent(view, EventTypes.MAP_USER_TRACKING_MODE_CHANGE) {
+    override fun getKey(): String {
+        return EventKeys.MAP_USER_TRACKING_MODE_CHANGE;
+    }
+
+    override fun getPayload(): WritableMap {
+        val payload = Arguments.createMap()
+        payload.putBoolean("followUserLocation", userTrackingMode != UserTrackingMode.NONE)
+        payload.putString("followUserMode", UserTrackingMode.toString(userTrackingMode))
+        return payload
+    }
+}

package/index.d.ts

@@ -1,6 +1,6 @@
 declare module 'react-native-mapbox-gl__maps';
 
-import { Component, ReactNode } from 'react';
+import { Component, FC, ReactNode } from 'react';
 import {
   ViewProps,
   ViewStyle,
@@ -47,6 +47,7 @@ import {
   type UserTrackingMode as _UserTrackingMode,
   type UserTrackingModeChangeCallback as _UserTrackingModeChangeCallback,
 } from './javascript/components/Camera';
+import { Images as _Images } from './javascript/components/Images';
 import { MarkerView as _MarkerView } from './javascript/components/MarkerView';
 import { PointAnnotation as _PointAnnotation } from './javascript/components/PointAnnotation';
 import { Atmosphere as _Atmosphere } from './javascript/components/Atmosphere';
@@ -74,6 +75,10 @@ import type {
   AnimatedShape as _AnimatedShape,
 } from './javascript/types/index';
 import type { requestAndroidLocationPermissions as _requestAndroidLocationPermissions } from './javascript/requestAndroidLocationPermissions';
+import type {
+  Location as _Location,
+  LocationManager,
+} from './javascript/locationManager';
 
 // prettier-ignore
 type ExpressionName =
@@ -172,6 +177,7 @@ declare namespace MapboxGL {
   type MapboxGLEvent = _MapboxGLEvent;
   type UserTrackingMode = _UserTrackingMode;
   type UserTrackingModeChangeCallback = _UserTrackingModeChangeCallback;
+  type Location = _Location;
 
   const offlineManager: OfflineManager;
   const snapshotManager: SnapshotManager;
@@ -324,56 +330,10 @@ declare namespace MapboxGL {
 
   class UserLocation extends Component<UserLocationProps> {}
 
-  interface Location {
-    coords: Coordinates;
-    timestamp?: number;
-  }
-
-  interface Coordinates {
-    /**
-     * The heading (measured in degrees) relative to true north.
-     * Heading is used to describe the direction the device is pointing to (the value of the compass).
-     * Note that on Android this is incorrectly reporting the course value as mentioned in issue https://github.com/rnmapbox/maps/issues/1213
-     * and will be corrected in a future update.
-     */
-    heading?: number;
-
-    /**
-     * The direction in which the device is traveling, measured in degrees and relative to due north.
-     * The course refers to the direction the device is actually moving (not the same as heading).
-     */
-    course?: number;
-
-    /**
-     * The instantaneous speed of the device, measured in meters per second.
-     */
-    speed?: number;
-
-    /**
-     * The latitude in degrees.
-     */
-    latitude: number;
-
-    /**
-     * The longitude in degrees.
-     */
-    longitude: number;
-
-    /**
-     * The radius of uncertainty for the location, measured in meters.
-     */
-    accuracy?: number;
-
-    /**
-     * The altitude, measured in meters.
-     */
-    altitude?: number;
-  }
-
   class Light extends Component<LightProps> {}
 
   class Callout extends Component<CalloutProps> {}
-  type Style = React.FC<StyleProps>;
+  type Style = FC<StyleProps>;
 
   /**
    * Sources
@@ -392,14 +352,12 @@ declare namespace MapboxGL {
   class LineLayer extends Component<_LineLayerProps> {}
   class RasterLayer extends Component<_RasterLayerProps> {}
   class HeatmapLayer extends Component<_HeatmapLayerProps> {}
-  class Images extends Component<ImagesProps> {}
   class ImageSource extends Component<ImageSourceProps> {}
   class SkyLayer extends Component<_SkyLayerProps> {}
 
-  class LocationManager extends Component {
-    start(displacement?: number): void;
-    stop(): void;
-  }
+  type Location = _Location;
+  type Images = _Images;
+  const Images = _Images;
 
   /**
    * Offline
@@ -533,7 +491,6 @@ export interface MapState {
 export interface MapViewProps extends ViewProps {
   animated?: boolean;
   userTrackingMode?: MapboxGL.UserTrackingModes;
-  userLocationVerticalAlignment?: number;
   contentInset?: Array<number>;
   projection?: 'mercator' | 'globe';
   style?: StyleProp<ViewStyle>;
@@ -575,7 +532,7 @@ export interface MapViewProps extends ViewProps {
   ) => void;
   onCameraChanged?: (state: MapState) => void;
   onMapIdle?: (state: MapState) => void;
-  onUserLocationUpdate?: (feature: MapboxGL.Location) => void;
+  onUserLocationUpdate?: (feature: Location) => void;
   onWillStartLoadingMap?: () => void;
   onDidFinishLoadingMap?: () => void;
   onDidFailLoadingMap?: () => void;
@@ -596,7 +553,7 @@ export interface UserLocationProps {
   minDisplacement?: number;
   requestsAlwaysUse?: boolean;
   onPress?: () => void;
-  onUpdate?: (location: MapboxGL.Location) => void;
+  onUpdate?: (location: Location) => void;
   renderMode?: 'normal' | 'native';
   showsUserHeadingIndicator?: boolean;
   visible?: boolean;
@@ -734,12 +691,6 @@ export interface HeatmapLayerProps extends LayerBaseProps {
   style?: StyleProp<HeatmapLayerStyle>;
 }
 
-export interface ImagesProps extends ViewProps {
-  images?: { assets?: string[] } & { [key: string]: ImageSourcePropType };
-  nativeAssetImages?: string[];
-  onImageMissing?: (imageKey: string) => void;
-}
-
 export interface ImageSourceProps extends ViewProps {
   id: string;
   url?: number | string;
@@ -828,6 +779,7 @@ export import AnimatedPoint = MapboxGL.AnimatedPoint;
 /** @deprecated This will be removed in a future release. Use `AnimatedPoint` instead. */
 export import AnimatedMapPoint = MapboxGL.AnimatedPoint;
 export import AnimatedShape = MapboxGL.AnimatedShape;
+export import Images = MapboxGL.Images;
 
 export const { offlineManager } = MapboxGL;