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

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

@@ -0,0 +1,32 @@
+package com.mapbox.rctmgl.components.location
+
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.mapbox.rctmgl.utils.Logger
+import javax.annotation.Nonnull
+
+class RCTMGLNativeUserLocationManager : ViewGroupManager<RCTMGLNativeUserLocation>() {
+    @Nonnull
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @ReactProp(name = "androidRenderMode")
+    fun setAndroidRenderMode(userLocation: RCTMGLNativeUserLocation, mode: String) {
+        when (mode) {
+            "compass" -> userLocation.setAndroidRenderMode(RenderMode.COMPASS);
+            "gps" -> userLocation.setAndroidRenderMode(RenderMode.GPS);
+            "normal" -> userLocation.setAndroidRenderMode(RenderMode.NORMAL);
+        }
+    }
+
+    @Nonnull
+    override fun createViewInstance(@Nonnull reactContext: ThemedReactContext): RCTMGLNativeUserLocation {
+        return RCTMGLNativeUserLocation(reactContext)
+    }
+
+    companion object {
+        const val REACT_CLASS = "RCTMGLNativeUserLocation"
+    }
+}

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
@@ -51,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
@@ -77,11 +80,68 @@ data class OrnamentSettings(
     var position: Int = -1
 )
 
+enum class MapGestureType {
+    Move,Scale,Rotate
+}
 
-interface RCTMGLMapViewLifecycleOwner : LifecycleOwner {
+/***
+ * Mapbox's MapView observers lifecycle events see MapboxLifecyclePluginImpl - (ON_START, ON_STOP, ON_DESTROY)
+ * We need to emulate those.
+ */
+interface RCTMGLLifeCycleOwner : LifecycleOwner {
     fun handleLifecycleEvent(event: Lifecycle.Event)
 }
 
+class RCTMGLLifeCycle {
+    private var lifecycleOwner : RCTMGLLifeCycleOwner? = null
+
+    fun onAttachedToWindow(view: View) {
+        if (lifecycleOwner == null) {
+            lifecycleOwner = object : RCTMGLLifeCycleOwner {
+                private lateinit var lifecycleRegistry: LifecycleRegistry
+                init {
+                    lifecycleRegistry = LifecycleRegistry(this)
+                    lifecycleRegistry.currentState = Lifecycle.State.CREATED
+                }
+
+                override fun handleLifecycleEvent(event: Lifecycle.Event) {
+                    try {
+                        lifecycleRegistry.handleLifecycleEvent(event)
+                    } catch (e: RuntimeException) {
+                        Log.e("RCTMGLMapView", "handleLifecycleEvent, handleLifecycleEvent error: $e")
+                    }
+                }
+
+                override fun getLifecycle(): Lifecycle {
+                    return lifecycleRegistry
+                }
+            }
+            ViewTreeLifecycleOwner.set(view, lifecycleOwner);
+        }
+        lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_START)
+    }
+
+    fun onDetachedFromWindow() {
+        if (lifecycleOwner?.lifecycle?.currentState == Lifecycle.State.DESTROYED) {
+            return
+        }
+        lifecycleOwner?.handleLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_STOP)
+    }
+
+    fun onDestroy() {
+        if (lifecycleOwner?.lifecycle?.currentState == Lifecycle.State.STARTED || lifecycleOwner?.lifecycle?.currentState == Lifecycle.State.RESUMED) {
+            lifecycleOwner?.handleLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_STOP)
+        }
+        if (lifecycleOwner?.lifecycle?.currentState != Lifecycle.State.DESTROYED) {
+            lifecycleOwner?.handleLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_DESTROY)
+        }
+    }
+
+    fun getState() : Lifecycle.State {
+        return lifecycleOwner?.lifecycle?.currentState ?: Lifecycle.State.INITIALIZED;
+    }
+}
+
 open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapViewManager /*, MapboxMapOptions options*/) : MapView(mContext), OnMapClickListener, OnMapLongClickListener {
     /**
      * `PointAnnotations` are rendered to a canvas, but the React Native `Image` component is
@@ -201,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()
@@ -325,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() {
@@ -608,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) {
@@ -1140,51 +1233,34 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     // endregion
 
     // region lifecycle
-    private var lifecycleOwner : RCTMGLMapViewLifecycleOwner? = null
+    private val lifecycle : RCTMGLLifeCycle by lazy { RCTMGLLifeCycle() }
+
+    fun getLifecycleState() : Lifecycle.State {
+        return this.lifecycle.getState()
+    }
 
     override fun onDetachedFromWindow() {
-        lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
+        lifecycle.onDetachedFromWindow()
         super.onDetachedFromWindow();
     }
 
     override fun onDestroy() {
         removeAllFeatures()
         viewAnnotationManager.removeAllViewAnnotations()
-        lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+        mLocationComponentManager?.onDestroy();
+
+        lifecycle.onDestroy()
         super.onDestroy()
     }
 
     fun onDropViewInstance() {
         removeAllFeatures()
         viewAnnotationManager.removeAllViewAnnotations()
-        lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+        lifecycle.onDestroy()
     }
 
     override fun onAttachedToWindow() {
-        if (lifecycleOwner == null) {
-            lifecycleOwner = object : RCTMGLMapViewLifecycleOwner {
-                private lateinit var lifecycleRegistry: LifecycleRegistry
-                init {
-                    lifecycleRegistry = LifecycleRegistry(this)
-                    lifecycleRegistry.currentState = Lifecycle.State.CREATED
-                }
-
-                override fun handleLifecycleEvent(event: Lifecycle.Event) {
-                    try {
-                        lifecycleRegistry.handleLifecycleEvent(event)
-                    } catch (e: RuntimeException) {
-                        Log.e("RCTMGLMapView", "onAttachedToWindow error: $e")
-                    }
-                }
-
-                override fun getLifecycle(): Lifecycle {
-                    return lifecycleRegistry
-                }
-            }
-            ViewTreeLifecycleOwner.set(this, lifecycleOwner);
-        } else {
-            lifecycleOwner?.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
-        }
+        lifecycle.onAttachedToWindow(this)
         super.onAttachedToWindow()
     }
 

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/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/location/LocationManager.kt

@@ -3,8 +3,6 @@ package com.mapbox.rctmgl.location
 import android.annotation.SuppressLint
 import android.content.Context
 import android.location.Location
-//import com.mapbox.maps.plugin.locationcomponent.LocationConsumer.onLocationUpdated
-//import com.mapbox.maps.plugin.locationcomponent.LocationConsumer.onBearingUpdated
 import com.mapbox.android.core.location.LocationEngine
 import com.mapbox.android.core.location.LocationEngineCallback
 import com.mapbox.android.core.location.LocationEngineResult
@@ -20,9 +18,52 @@ import java.lang.ref.WeakReference
 import java.util.ArrayList
 import kotlin.Exception
 
-internal class LocationProviderForEngine(var mEngine: LocationEngine?) : LocationProvider, LocationEngineCallback<LocationEngineResult> {
+
+open class SingletonHolder<out T, in A>(creator: (A) -> T) {
+    private var creator: ((A) -> T)? = creator
+    @Volatile private var instance: T? = null
+
+    fun getInstance(arg: A): T {
+        val i = instance
+        if (i != null) {
+            return i
+        }
+
+        return synchronized(this) {
+            val i2 = instance
+            if (i2 != null) {
+                i2
+            } else {
+                val created = creator!!(arg)
+                instance = created
+                creator = null
+                created
+            }
+        }
+    }
+}
+
+internal class LocationProviderForEngine(var mEngine: LocationEngine?, val context: Context) : LocationProvider, LocationEngineCallback<LocationEngineResult> {
     var mConsumers = ArrayList<LocationConsumer>()
-    fun beforeAddingFirstConsumer() {}
+    @SuppressLint("MissingPermission")
+    fun beforeAddingFirstConsumer() {
+        val request = LocationEngineRequest.Builder(LocationManager.DEFAULT_INTERVAL_MILLIS
+        )
+            .setFastestInterval(LocationManager.DEFAULT_FASTEST_INTERVAL_MILLIS)
+            .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
+            .build();
+
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        mEngine?.requestLocationUpdates(
+          request,
+          this,
+          Looper.getMainLooper()
+        )
+
+    }
     fun afterRemovedLastConsumer() {}
     @SuppressLint("MissingPermission")
     override fun registerLocationConsumer(locationConsumer: LocationConsumer) {
@@ -66,25 +107,29 @@ class LocationManager private constructor(private val context: Context) : Locati
     private var isActive = false
     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;
-
+    private var locationProvider: LocationProvider? = null
+    private var nStarts : Int = 0
+    private var isPaused : Boolean = false
 
-
-    val provider: LocationProvider
+    var provider: LocationProvider
         get() {
-            if (locationProvider == null) {
-                locationProvider = LocationProviderForEngine(engine)
+            var ret = locationProvider
+            if (ret == null) {
+                val engine = LocationProviderForEngine(engine, context)
+                locationProvider = engine
+                return engine
+            } else {
+                return ret
             }
-            return locationProvider!!
+        }
+        set(value) {
+            locationProvider = value
         }
 
     interface OnUserLocationChange {
         fun onLocationChange(location: Location?)
     }
 
-
     /// public interface
 
     fun startCounted() {
@@ -228,23 +273,17 @@ class LocationManager private constructor(private val context: Context) : Locati
 
     override fun onSuccess(result: LocationEngineResult?) {
         onLocationChanged(result?.lastLocation)
-        if (locationProvider != null) {
-            locationProvider!!.onSuccess(result)
+        val provider = locationProvider
+        if (provider != null && provider is LocationProviderForEngine) {
+            provider.onSuccess(result)
         }
     }
 
-    companion object {
+    companion object : SingletonHolder<LocationManager, Context>(::LocationManager) {
         const val DEFAULT_FASTEST_INTERVAL_MILLIS: Long = 1000
         const val DEFAULT_INTERVAL_MILLIS: Long = 1000
         const val LOG_TAG = "LocationManager"
-        private var INSTANCE: WeakReference<LocationManager>? = null
-        @JvmStatic
-        fun getInstance(context: Context): LocationManager? {
-            if (INSTANCE == null) {
-                INSTANCE = WeakReference(LocationManager(context))
-            }
-            return INSTANCE!!.get()
-        }
+
     }
 
     init {

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;
 

package/ios/RCTMGL-v10/MGLModule.swift

@@ -55,6 +55,7 @@ class MGLModule : NSObject {
           "WillStartLoadingMap": RCTMGLEvent.EventType.willStartLoadingMap.rawValue,
           "DidFinishLoadingStyle": RCTMGLEvent.EventType.didFinishLoadingStyle.rawValue,
           "DidFinishLoadingMap": RCTMGLEvent.EventType.didFinishLoadingMap.rawValue,
+          "MapLoadingError": RCTMGLEvent.EventType.mapLoadingError.rawValue,
           "DidFinishRenderingFrameFully":  RCTMGLEvent.EventType.didFinishRenderingFully.rawValue,
           "DidFinishRenderingFrame": RCTMGLEvent.EventType.didFinishRendering.rawValue,
         ],

package/ios/RCTMGL-v10/RCTMGLAtmosphere.swift

@@ -56,6 +56,7 @@ class RCTMGLAtmosphere : RCTMGLSingletonLayer, RCTMGLMapComponent, RCTMGLSourceC
         styler.atmosphereLayer(
           layer: &atmosphere,
           reactStyle: reactStyle,
+          oldReactStyle: oldReactStyle,
           applyUpdater: { (updater) in fatalError("Atmosphere: TODO - implement apply updater")},
           isValid: { fatalError("Atmosphere: TODO - no isValid") }
         )

package/ios/RCTMGL-v10/RCTMGLBackgroundLayer.swift

@@ -33,6 +33,7 @@ class RCTMGLBackgroundLayer: RCTMGLLayer {
         styler.backgroundLayer(
           layer: &styleLayer,
           reactStyle: reactStyle,
+          oldReactStyle: oldReatStyle,
           applyUpdater: { (updater) in logged("RCTMGLBackgroundLayer.addStyles") {
             try style.updateLayer(withId: self.id, type: LayerType.self) { (layer: inout LayerType) in updater(&layer) }
           }},