@maplibre/maplibre-react-native 11.0.0-alpha.8 → 11.0.0-alpha.9

package/android/src/main/java/org/maplibre/reactnative/events/constants/EventTypes.java

@@ -4,27 +4,8 @@ public class EventTypes {
     // map event types
     public static final String MAP_CLICK = "press";
     public static final String MAP_LONG_CLICK = "longpress";
-    public static final String MAP_USER_TRACKING_MODE_CHANGE = "usertrackingmodechange";
-
-    public static final String REGION_WILL_CHANGE = "regionwillchange";
-    public static final String REGION_IS_CHANGING = "regionischanging";
-    public static final String REGION_DID_CHANGE  = "regiondidchange";
     public static final String USER_LOCATION_UPDATED = "userlocationdupdated";
 
-    public static final String WILL_START_LOADING_MAP = "willstartloadingmap";
-    public static final String DID_FINISH_LOADING_MAP = "didfinishloadingmap";
-    public static final String DID_FAIL_LOADING_MAP = "didfailloadingmap";
-
-    public static final String WILL_START_RENDERING_FRAME = "willstartrenderingframe";
-    public static final String DID_FINISH_RENDERING_FRAME = "didfinishrenderingframe";
-    public static final String DID_FINISH_RENDERING_FRAME_FULLY = "didfinishrenderingframefully";
-
-    public static final String WILL_START_RENDERING_MAP = "willstartrenderingmap";
-    public static final String DID_FINISH_RENDERING_MAP = "didfinishrenderingmap";
-    public static final String DID_FINISH_RENDERING_MAP_FULLY = "didfinishrenderingmapfully";
-
-    public static final String DID_FINISH_LOADING_STYLE = "didfinishloadingstyle";
-
     // point annotation event types
     public static final String ANNOTATION_SELECTED = "annotationselected";
     public static final String ANNOTATION_DESELECTED = "annotationdeselected";

package/android/src/main/java/org/maplibre/reactnative/location/LocationManager.java

@@ -150,7 +150,7 @@ public class LocationManager implements LocationEngineCallback<LocationEngineRes
 
     @Override
     public void onFailure(Exception exception) {
-        // FMTODO handle this.
+        // TODO handle this.
     }
 
     @Override

package/android/src/main/java/org/maplibre/reactnative/location/TrackUserLocationMode.kt

@@ -0,0 +1,43 @@
+package org.maplibre.reactnative.location
+
+import org.maplibre.android.location.modes.CameraMode
+
+object TrackUserLocationMode {
+    const val NONE: Int = 0
+    const val DEFAULT: Int = 1
+    const val HEADING: Int = 2
+    const val COURSE: Int = 3
+
+
+    @CameraMode.Mode
+    fun getCameraMode(mode: Int): Int {
+        return when (mode) {
+            DEFAULT -> CameraMode.TRACKING
+            HEADING -> CameraMode.TRACKING_COMPASS
+            COURSE -> CameraMode.TRACKING_GPS
+            else -> CameraMode.NONE
+        }
+    }
+
+    fun isUserGesture(reason: Int): Boolean {
+        return reason == 1 || reason == 2 // user gesture or animation
+    }
+
+    fun toString(value: Int): String? {
+        return when (value) {
+            DEFAULT -> "default"
+            HEADING -> "heading"
+            COURSE -> "course"
+            else -> null
+        }
+    }
+
+    fun fromString(value: String?): Int {
+        return when (value) {
+            "default" -> DEFAULT
+            "heading" -> HEADING
+            "course" -> COURSE
+            else -> NONE
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/location/{UserTrackingState.java → TrackUserLocationState.java}

@@ -1,6 +1,6 @@
 package org.maplibre.reactnative.location;
 
-public class UserTrackingState {
+public class TrackUserLocationState {
     // The map view not yet tracked the user location
     public static final int POSSIBLE = 0;
 

package/android/src/main/java/org/maplibre/reactnative/location/UserLocation.java

@@ -8,7 +8,7 @@ public class UserLocation {
     private Location currentLocation;
     private Location previousLocation;
 
-    private int userTrackingMode = UserTrackingMode.NONE;
+    private int userTrackingMode = TrackUserLocationMode.NONE;
 
     public UserLocation() {
         this(null);

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNModule.java

@@ -3,20 +3,15 @@ package org.maplibre.reactnative.modules;
 import android.os.Handler;
 import android.util.Log;
 
-import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.react.module.annotations.ReactModule;
+
 import org.maplibre.android.MapLibre;
-import org.maplibre.android.WellKnownTileServer;
-import org.maplibre.reactnative.components.camera.constants.CameraMode;
 import org.maplibre.reactnative.components.styles.sources.MLRNSource;
-import org.maplibre.reactnative.events.constants.EventTypes;
 import org.maplibre.reactnative.http.CustomHeadersInterceptor;
-import org.maplibre.reactnative.location.UserLocationVerticalAlignment;
-import org.maplibre.reactnative.location.UserTrackingMode;
 
 import okhttp3.Dispatcher;
 import okhttp3.OkHttpClient;
@@ -61,45 +56,6 @@ public class MLRNModule extends ReactContextBaseJavaModule {
         Map<String, String> styleURLS = new HashMap<>();
         styleURLS.put("Default", DEFAULT_STYLE_URL);
 
-        // events
-        Map<String, String> eventTypes = new HashMap<>();
-        eventTypes.put("MapClick", EventTypes.MAP_CLICK);
-        eventTypes.put("MapLongClick", EventTypes.MAP_LONG_CLICK);
-        eventTypes.put("RegionWillChange", EventTypes.REGION_WILL_CHANGE);
-        eventTypes.put("RegionIsChanging", EventTypes.REGION_IS_CHANGING);
-        eventTypes.put("RegionDidChange", EventTypes.REGION_DID_CHANGE);
-        eventTypes.put("UserLocationUpdated", EventTypes.USER_LOCATION_UPDATED);
-        eventTypes.put("WillStartLoadingMap", EventTypes.WILL_START_LOADING_MAP);
-        eventTypes.put("DidFinishLoadingMap", EventTypes.DID_FINISH_LOADING_MAP);
-        eventTypes.put("DidFailLoadingMap", EventTypes.DID_FAIL_LOADING_MAP);
-        eventTypes.put("WillStartRenderingFrame", EventTypes.WILL_START_RENDERING_FRAME);
-        eventTypes.put("DidFinishRenderingFrame", EventTypes.DID_FINISH_RENDERING_FRAME);
-        eventTypes.put("DidFinishRenderingFrameFully", EventTypes.DID_FINISH_RENDERING_FRAME_FULLY);
-        eventTypes.put("WillStartRenderingMap", EventTypes.WILL_START_RENDERING_MAP);
-        eventTypes.put("DidFinishRenderingMap", EventTypes.DID_FINISH_RENDERING_MAP);
-        eventTypes.put("DidFinishRenderingMapFully", EventTypes.DID_FINISH_RENDERING_MAP_FULLY);
-        eventTypes.put("DidFinishLoadingStyle", EventTypes.DID_FINISH_LOADING_STYLE);
-
-        // user tracking modes
-        Map<String, Integer> userTrackingModes = new HashMap<>();
-        userTrackingModes.put("None", UserTrackingMode.NONE);
-        userTrackingModes.put("Follow", UserTrackingMode.FOLLOW);
-        userTrackingModes.put("FollowWithCourse", UserTrackingMode.FollowWithCourse);
-        userTrackingModes.put("FollowWithHeading", UserTrackingMode.FollowWithHeading);
-
-        // user location vertical alignment
-        Map<String, Integer> userLocationVerticalAlignment = new HashMap<>();
-        userLocationVerticalAlignment.put("Center", UserLocationVerticalAlignment.CENTER);
-        userLocationVerticalAlignment.put("Top", UserLocationVerticalAlignment.TOP);
-        userLocationVerticalAlignment.put("Bottom", UserLocationVerticalAlignment.BOTTOM);
-
-        // camera modes
-        Map<String, Integer> cameraModes = new HashMap<>();
-        cameraModes.put("Flight", CameraMode.FLIGHT);
-        cameraModes.put("Ease", CameraMode.EASE);
-        cameraModes.put("Linear", CameraMode.LINEAR);
-        cameraModes.put("None", CameraMode.NONE);
-
         // style source constants
         Map<String, String> styleSourceConsts = new HashMap<>();
         styleSourceConsts.put("DefaultSourceID", MLRNSource.DEFAULT_ID);
@@ -121,10 +77,6 @@ public class MLRNModule extends ReactContextBaseJavaModule {
 
         return MapBuilder.<String, Object>builder()
                 .put("StyleURL", styleURLS)
-                .put("EventTypes", eventTypes)
-                .put("UserTrackingModes", userTrackingModes)
-                .put("UserLocationVerticalAlignment", userLocationVerticalAlignment)
-                .put("CameraModes", cameraModes)
                 .put("StyleSource", styleSourceConsts)
                 .put("OfflinePackDownloadState", offlinePackDownloadStates)
                 .put("OfflineCallbackName", offlineModuleCallbackNames)

package/android/src/main/java/org/maplibre/reactnative/utils/ConvertUtils.java

@@ -203,15 +203,8 @@ public class ConvertUtils {
         return list;
     }
 
-    public static PointF toPointF(ReadableArray array) {
-        PointF pointF = new PointF();
-
-        if (array == null) {
-            return pointF;
-        }
-
-        pointF.set((float)array.getDouble(0), (float)array.getDouble(1));
-        return pointF;
+    public static PointF toPointF(ReadableMap map) {
+        return new PointF((float) map.getDouble("locationX"), (float) map.getDouble("locationY"));
     }
 
     public static RectF toRectF(ReadableArray array) {

package/android/src/main/java/org/maplibre/reactnative/utils/GeoJSONUtils.kt

@@ -0,0 +1,322 @@
+package org.maplibre.reactnative.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import org.maplibre.android.geometry.LatLng
+import org.maplibre.android.geometry.LatLngBounds
+import org.maplibre.android.geometry.LatLngQuad
+import org.maplibre.android.log.Logger
+import org.maplibre.geojson.Feature
+import org.maplibre.geojson.FeatureCollection
+import org.maplibre.geojson.Geometry
+import org.maplibre.geojson.GeometryCollection
+import org.maplibre.geojson.LineString
+import org.maplibre.geojson.MultiLineString
+import org.maplibre.geojson.MultiPoint
+import org.maplibre.geojson.MultiPolygon
+import org.maplibre.geojson.Point
+import org.maplibre.geojson.Polygon
+import org.maplibre.turf.TurfMeasurement
+import java.util.stream.Collectors
+
+object GeoJSONUtils {
+    const val LOG_TAG: String = "GeoJSONUtils"
+
+    @JvmStatic
+    fun fromFeature(feature: Feature): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Feature")
+        map.putString("id", feature.id())
+
+        val geometry = feature.geometry()
+        if (geometry == null) {
+            map.putNull("geometry")
+        } else {
+            map.putMap("geometry", fromGeometry(geometry))
+        }
+
+        val properties = feature.properties()
+        if (properties == null) {
+            map.putNull("properties")
+        } else {
+            map.putMap("properties", ConvertUtils.toWritableMap(properties))
+        }
+
+        return map
+    }
+
+    fun fromGeometry(geometry: Geometry): WritableMap? {
+        val type = geometry.type()
+
+        return when (type) {
+            "Point" -> fromPoint(geometry as Point)
+            "LineString" -> fromLineString(geometry as LineString)
+            "Polygon" -> fromPolygon(geometry as Polygon)
+            "MultiPoint" -> fromMultiPoint(geometry as MultiPoint)
+            "MultiLineString" -> fromMultiLineString(geometry as MultiLineString)
+            "MultiPolygon" -> fromMultiPolygon(geometry as MultiPolygon)
+            "GeometryCollection" -> fromGeometryCollection(geometry as GeometryCollection)
+            else -> {
+                Logger.w(LOG_TAG, "GeoJSONUtils.fromGeometry unsupported type: \"$type\"")
+
+                null
+            }
+        }
+    }
+
+    fun fromPoint(point: Point?): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Point")
+        map.putArray("coordinates", getCoordinates(point))
+        return map
+    }
+
+    fun fromLineString(lineString: LineString): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "LineString")
+        map.putArray("coordinates", getCoordinates(lineString))
+        return map
+    }
+
+    fun fromPolygon(polygon: Polygon): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Polygon")
+        map.putArray("coordinates", getCoordinates(polygon))
+        return map
+    }
+
+    fun fromMultiPoint(multiPoint: MultiPoint): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "MultiPoint")
+        map.putArray("coordinates", getCoordinates(multiPoint))
+        return map
+    }
+
+    fun fromMultiLineString(multiLineString: MultiLineString): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "MultiLineString")
+        map.putArray("coordinates", getCoordinates(multiLineString))
+        return map
+    }
+
+    fun fromMultiPolygon(multiPolygon: MultiPolygon): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "MultiPolygon")
+        map.putArray("coordinates", getCoordinates(multiPolygon))
+        return map
+    }
+
+    fun fromGeometryCollection(geometryCollection: GeometryCollection): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "GeometryCollection")
+
+        map.putArray(
+            "geometries",
+            Arguments.fromList(
+                geometryCollection.geometries().stream()
+                    .map<WritableMap?> { obj: Geometry -> fromGeometry(obj) }
+                    .collect(Collectors.toList())))
+
+        return map
+    }
+
+    fun getCoordinates(point: Point?): WritableArray {
+        return Arguments.fromArray(pointToDoubleArray(point))
+    }
+
+    fun getCoordinates(lineString: LineString): WritableArray {
+        val array = Arguments.createArray()
+
+        val points = lineString.coordinates()
+        for (point in points) {
+            array.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+        }
+
+        return array
+    }
+
+    fun getCoordinates(polygon: Polygon): WritableArray {
+        val array = Arguments.createArray()
+
+        val points = polygon.coordinates()
+
+        for (curPoint in points) {
+            val innerArray = Arguments.createArray()
+
+            for (point in curPoint) {
+                innerArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+            }
+
+            array.pushArray(innerArray)
+        }
+
+        return array
+    }
+
+    fun getCoordinates(multiPoint: MultiPoint): WritableArray {
+        val array = Arguments.createArray()
+
+        val points = multiPoint.coordinates()
+        for (point in points) {
+            array.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+        }
+
+        return array
+    }
+
+    fun getCoordinates(multiLineString: MultiLineString): WritableArray {
+        val array = Arguments.createArray()
+
+        val lines = multiLineString.coordinates()
+        for (line in lines) {
+            val lineArray = Arguments.createArray()
+
+            for (point in line) {
+                lineArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+            }
+
+            array.pushArray(lineArray)
+        }
+
+        return array
+    }
+
+    fun getCoordinates(multiPolygon: MultiPolygon): WritableArray {
+        val array = Arguments.createArray()
+
+        val polygons = multiPolygon.coordinates()
+        for (polygon in polygons) {
+            val polygonArray = Arguments.createArray()
+
+            for (ring in polygon) {
+                val ringArray = Arguments.createArray()
+
+                for (point in ring!!) {
+                    ringArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+                }
+
+                polygonArray.pushArray(ringArray)
+            }
+
+            array.pushArray(polygonArray)
+        }
+
+        return array
+    }
+
+    @JvmStatic
+    fun toPointFeature(latLng: LatLng, properties: WritableMap?): WritableMap {
+        val map: WritableMap = WritableNativeMap()
+        map.putString("type", "Feature")
+        map.putMap("geometry", toPointGeometry(latLng))
+        map.putMap("properties", properties)
+        return map
+    }
+
+    fun toPointGeometry(latLng: LatLng): WritableMap {
+        val geometry: WritableMap = WritableNativeMap()
+        geometry.putString("type", "Point")
+        geometry.putArray("coordinates", fromLatLng(latLng))
+        return geometry
+    }
+
+    fun fromLatLng(latLng: LatLng): WritableArray {
+        val coords = doubleArrayOf(latLng.longitude, latLng.latitude)
+        val writableCoords: WritableArray = WritableNativeArray()
+        writableCoords.pushDouble(coords[0])
+        writableCoords.pushDouble(coords[1])
+        return writableCoords
+    }
+
+    @JvmStatic
+    fun toLatLng(point: Point?): LatLng? {
+        if (point == null) {
+            return null
+        }
+        return LatLng(point.latitude(), point.longitude())
+    }
+
+    fun toLatLng(coordinates: ReadableArray?): LatLng? {
+        if (coordinates == null || coordinates.size() < 2) {
+            return null
+        }
+        return LatLng(coordinates.getDouble(1), coordinates.getDouble(0))
+    }
+
+    @JvmStatic
+    fun toPointGeometry(featureJSONString: String): Point? {
+        val feature = Feature.fromJson(featureJSONString)
+        if (feature == null) {
+            return null
+        }
+        return feature.geometry() as Point?
+    }
+
+    @JvmStatic
+    fun fromLatLngBounds(latLngBounds: LatLngBounds): WritableArray {
+        val array = Arguments.createArray()
+        array.pushDouble(latLngBounds.getLonWest())
+        array.pushDouble(latLngBounds.getLatSouth())
+        array.pushDouble(latLngBounds.getLonEast())
+        array.pushDouble(latLngBounds.getLatNorth())
+
+        return array
+    }
+
+    private fun toGeometryCollection(features: MutableList<Feature>): GeometryCollection {
+        val geometries = ArrayList<Geometry?>()
+        geometries.ensureCapacity(features.size)
+        for (feature in features) {
+            geometries.add(feature.geometry())
+        }
+        return GeometryCollection.fromGeometries(geometries)
+    }
+
+    @JvmStatic
+    fun toLatLngBounds(featureCollection: FeatureCollection): LatLngBounds {
+        val features = featureCollection.features()
+
+        val bbox = TurfMeasurement.bbox(toGeometryCollection(features!!))
+
+        return LatLngBounds.from(bbox[3], bbox[2], bbox[1], bbox[0])
+    }
+
+    @JvmStatic
+    fun toLatLngBounds(array: ReadableArray?): LatLngBounds? {
+        if (array != null && array.size() == 4) {
+            return LatLngBounds.from(
+                array.getDouble(3),
+                array.getDouble(2),
+                array.getDouble(1),
+                array.getDouble(0)
+            )
+        }
+
+        return null;
+    }
+
+    @JvmStatic
+    fun toLatLngQuad(array: ReadableArray?): LatLngQuad? {
+        // [top left, top right, bottom right, bottom left]
+        if (array == null || array.size() < 4) {
+            return null
+        }
+        return LatLngQuad(
+            toLatLng(array.getArray(0))!!,
+            toLatLng(array.getArray(1))!!,
+            toLatLng(array.getArray(2))!!,
+            toLatLng(array.getArray(3))!!
+        )
+    }
+
+    fun pointToDoubleArray(point: Point?): DoubleArray {
+        if (point == null) {
+            return doubleArrayOf(0.0, 0.0)
+        }
+        return doubleArrayOf(point.longitude(), point.latitude())
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/utils/ReactTagResolver.kt

@@ -0,0 +1,85 @@
+package org.maplibre.reactnative.utils
+
+import android.view.View
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.uimanager.IllegalViewOperationException
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import org.maplibre.android.log.Logger
+
+data class Await<V>(
+    val fn: (V) -> Unit,
+    val reject: Promise?
+)
+
+const val LOG_TAG = "ReactTagResolver"
+
+typealias ReactTag = Double
+
+// https://github.com/rnmapbox/maps/pull/3074
+open class ReactTagResolver(val context: ReactApplicationContext) {
+    private val createdViews: HashSet<Int> = hashSetOf<Int>()
+    private val awaitedViews: HashMap<Int, MutableList<Await<View?>>> = hashMapOf()
+
+    // To be called from view.setId
+    fun tagAssigned(reactTag: Int) {
+        createdViews.add(reactTag)
+
+        val list = awaitedViews[reactTag]
+        if (list != null) {
+            context.runOnUiQueueThread {
+                try {
+                    val view = manager.resolveView(reactTag)
+
+                    list.forEach { it.fn(view) }
+                } catch (err: IllegalViewOperationException) {
+                    list.forEach { it.reject?.reject(err) }
+                }
+                awaitedViews.remove(reactTag)
+            }
+        }
+    }
+
+    fun viewRemoved(reactTag: Int) {
+        awaitedViews.remove(reactTag)
+        createdViews.remove(reactTag)
+    }
+
+    private val manager: UIManager
+        get() = UIManagerHelper.getUIManager(context, UIManagerType.FABRIC)!!
+
+    fun <V> withViewResolved(reactTag: Int, promise: Promise? = null, fn: (V) -> Unit) {
+        context.runOnUiQueueThread() {
+            try {
+                val resolvedView: View? = manager.resolveView(reactTag)
+                val view = resolvedView as? V
+                if (view != null) {
+                    fn(view)
+                } else {
+                    val message =
+                        "`reactTag` $reactTag resolved to `view` $resolvedView which is null or a wrong type"
+                    Logger.e(LOG_TAG, message)
+                    promise?.reject(Throwable(message))
+                }
+            } catch (err: IllegalViewOperationException) {
+                if (!createdViews.contains(reactTag)) {
+                    awaitedViews.getOrPut(reactTag) { mutableListOf() }.add(
+                        Await({ view ->
+                            if (view != null) {
+                                fn(view as V)
+                            } else {
+                                val message = "`reactTag` $reactTag resolved null"
+                                Logger.e(LOG_TAG, message)
+                                promise?.reject(Throwable(message))
+                            }
+                        }, promise)
+                    )
+                } else {
+                    promise?.reject(err)
+                }
+            }
+        }
+    }
+}

package/ios/MLRNCallout.h

@@ -1,6 +1,6 @@
 #import <React/RCTView.h>
 
-@import MapLibre;
+#import <MapLibre/MapLibre.h>
 
 @interface MLRNCallout : RCTView <MLNCalloutView>
 

package/ios/MLRNEvent.m

@@ -6,6 +6,7 @@
   if (self = [super init]) {
     _timestamp = [[NSDate date] timeIntervalSince1970];
   }
+
   return self;
 }
 
@@ -13,11 +14,12 @@
   if (_payload == nil) {
     return @{};
   }
+
   return _payload;
 }
 
 - (NSDictionary *)toJSON {
-  return @{@"type" : self.type, @"payload" : self.payload};
+  return self.payload;
 }
 
 + (MLRNEvent *)makeEvent:(NSString *)type {

package/ios/MLRNEventTypes.h

@@ -2,41 +2,20 @@
 
 @interface MLRNEventTypes : NSObject
 
-extern NSString *const RCT_MAPBOX_EVENT_TAP;
-extern NSString *const RCT_MAPBOX_EVENT_LONGPRESS;
+extern NSString *const RCT_MLRN_PRESS;
+extern NSString *const RCT_MLRN_LONG_PRESS;
 
-extern NSString *const RCT_MAPBOX_USER_LOCATION_UPDATE;
-extern NSString *const RCT_MAPBOX_USER_TRACKING_MODE_CHANGE;
+extern NSString *const RCT_MLRN_ANNOTATION_TAP;
 
-extern NSString *const RCT_MAPBOX_REGION_WILL_CHANGE_EVENT;
-extern NSString *const RCT_MAPBOX_REGION_IS_CHANGING;
-extern NSString *const RCT_MAPBOX_REGION_DID_CHANGE;
+extern NSString *const RCT_MLRN_OFFLINE_PROGRESS;
+extern NSString *const RCT_MLRN_OFFLINE_ERROR;
+extern NSString *const RCT_MLRN_OFFLINE_TILE_LIMIT;
 
-extern NSString *const RCT_MAPBOX_WILL_START_LOADING_MAP;
-extern NSString *const RCT_MAPBOX_DID_FINISH_LOADING_MAP;
-extern NSString *const RCT_MAPBOX_DID_FAIL_LOADING_MAP;
+extern NSString *const RCT_MLRN_SHAPE_SOURCE_LAYER_PRESS;
+extern NSString *const RCT_MLRN_VECTOR_SOURCE_LAYER_PRESS;
 
-extern NSString *const RCT_MAPBOX_WILL_START_RENDERING_FRAME;
-extern NSString *const RCT_MAPBOX_DID_FINSIH_RENDERING_FRAME;
-extern NSString *const RCT_MAPBOX_DID_FINISH_RENDERING_FRAME_FULLY;
+extern NSString *const RCT_MLRN_USER_LOCATION_UPDATE;
 
-extern NSString *const RCT_MAPBOX_WILL_START_RENDERING_MAP;
-extern NSString *const RCT_MAPBOX_DID_FINISH_RENDERING_MAP;
-extern NSString *const RCT_MAPBOX_DID_FINISH_RENDERING_MAP_FULLY;
-
-extern NSString *const RCT_MAPBOX_DID_FINISH_LOADING_STYLE;
-
-extern NSString *const RCT_MAPBOX_ANNOTATION_TAP;
-
-extern NSString *const RCT_MAPBOX_OFFLINE_PROGRESS;
-extern NSString *const RCT_MAPBOX_OFFLINE_ERROR;
-extern NSString *const RCT_MAPBOX_OFFLINE_TILE_LIMIT;
-
-extern NSString *const RCT_MAPBOX_SHAPE_SOURCE_LAYER_PRESS;
-extern NSString *const RCT_MAPBOX_VECTOR_SOURCE_LAYER_PRESS;
-
-extern NSString *const RCT_MAPBOX_USER_LOCATION_UPDATE;
-
-extern NSString *const RCT_MAPBOX_IMAGES_MISSING_IMAGE;
+extern NSString *const RCT_MLRN_MISSING_IMAGE;
 
 @end