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

package/android/src/main/java/org/maplibre/reactnative/components/mapview/MLRNMapViewManager.kt

@@ -0,0 +1,187 @@
+package org.maplibre.reactnative.components.mapview
+
+import android.util.Log
+import android.view.View
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.MLRNMapViewManagerDelegate
+import com.facebook.react.viewmanagers.MLRNMapViewManagerInterface
+
+@ReactModule(name = MLRNMapViewManager.REACT_CLASS)
+open class MLRNMapViewManager(context: ReactApplicationContext) :
+    ViewGroupManager<MLRNMapView>(context), MLRNMapViewManagerInterface<MLRNMapView> {
+    private val delegate: MLRNMapViewManagerDelegate<MLRNMapView, MLRNMapViewManager> =
+        MLRNMapViewManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<MLRNMapView> = delegate
+
+    companion object {
+        const val REACT_CLASS: String = "MLRNMapView"
+        const val LOG_TAG: String = "MLRNMapViewManager"
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+
+    private val mViews: MutableMap<Int?, MLRNMapView?> = HashMap()
+
+    override fun createShadowNodeInstance(): LayoutShadowNode {
+        return MapShadowNode(this)
+    }
+
+    override fun getShadowNodeClass(): Class<out LayoutShadowNode?> {
+        return MapShadowNode::class.java
+    }
+
+    override fun onAfterUpdateTransaction(mapView: MLRNMapView) {
+        super.onAfterUpdateTransaction(mapView)
+
+        if (mapView.mapLibreMap == null) {
+            mViews.put(mapView.id, mapView)
+            mapView.init()
+        }
+    }
+
+    override fun addView(parent: MLRNMapView, child: View, index: Int) {
+        parent.addFeature(child, index)
+    }
+
+    override fun getChildCount(parent: MLRNMapView): Int {
+        return parent.featureCount
+    }
+
+    override fun getChildAt(parent: MLRNMapView, index: Int): View? {
+        return parent.getFeatureAt(index).toView();
+    }
+
+    override fun removeViewAt(parent: MLRNMapView, index: Int) {
+        parent.removeFeature(index)
+    }
+
+    override fun createViewInstance(themedReactContext: ThemedReactContext): MLRNMapView {
+        return MLRNMapView(themedReactContext, options = null)
+    }
+
+    override fun onDropViewInstance(mapView: MLRNMapView) {
+        val reactTag = mapView.id
+
+        if (mViews.containsKey(reactTag)) {
+            mViews.remove(reactTag)
+        }
+
+        super.onDropViewInstance(mapView)
+    }
+
+    fun getByReactTag(reactTag: Int): MLRNMapView? {
+        return mViews[reactTag]
+    }
+
+    //region React Props
+
+    @ReactProp(name = "mapStyle")
+    override fun setMapStyle(mapView: MLRNMapView, value: String?) {
+        mapView.setReactMapStyle(value)
+    }
+
+    @ReactProp(name = "contentInset")
+    override fun setContentInset(mapView: MLRNMapView, value: ReadableMap?) {
+        mapView.setReactContentInset(value)
+    }
+
+    @ReactProp(name = "preferredFramesPerSecond")
+    override fun setPreferredFramesPerSecond(mapView: MLRNMapView, value: Int) {
+        mapView.setReactPreferredFramesPerSecond(value)
+    }
+
+    @ReactProp(name = "dragPan")
+    override fun setDragPan(mapView: MLRNMapView, value: Boolean) {
+        mapView.setReactScrollEnabled(value)
+    }
+
+    @ReactProp(name = "touchAndDoubleTapZoom")
+    override fun setTouchAndDoubleTapZoom(mapView: MLRNMapView, value: Boolean) {
+        mapView.setReactZoomEnabled(value)
+    }
+
+    @ReactProp(name = "touchRotate")
+    override fun setTouchRotate(mapView: MLRNMapView, value: Boolean) {
+        mapView.setReactRotateEnabled(value)
+    }
+
+    @ReactProp(name = "touchPitch")
+    override fun setTouchPitch(mapView: MLRNMapView, value: Boolean) {
+        mapView.setReactPitchEnabled(value)
+    }
+
+    @ReactProp(name = "tintColor")
+    override fun setTintColor(mapView: MLRNMapView, value: Int?) {
+        mapView.setReactTintColor(value)
+    }
+
+    @ReactProp(name = "attribution")
+    override fun setAttribution(mapView: MLRNMapView, value: Boolean) {
+        mapView.setReactAttribution(value)
+    }
+
+    @ReactProp(name = "attributionPosition")
+    override fun setAttributionPosition(mapView: MLRNMapView, value: ReadableMap?) {
+        mapView.setReactAttributionPosition(value)
+    }
+
+    @ReactProp(name = "logo")
+    override fun setLogo(mapView: MLRNMapView, value: Boolean) {
+        mapView.setReactLogo(value)
+    }
+
+    @ReactProp(name = "logoPosition")
+    override fun setLogoPosition(mapView: MLRNMapView, value: ReadableMap?) {
+        mapView.setReactLogoPosition(value)
+    }
+
+    @ReactProp(name = "compass")
+    override fun setCompass(mapView: MLRNMapView, value: Boolean) {
+        mapView.setReactCompass(value)
+    }
+
+    @ReactProp(name = "compassPosition")
+    override fun setCompassPosition(mapView: MLRNMapView, value: ReadableMap?) {
+        mapView.setReactCompassPosition(value)
+    }
+
+    //endregion
+
+    private class MapShadowNode(private val mViewManager: MLRNMapViewManager) : LayoutShadowNode() {
+        override fun dispose() {
+            super.dispose()
+            disposeNativeMapView()
+        }
+
+        /**
+         * We need this mapview to dispose (calls into nativeMap.destroy) before ReactNative starts
+         * tearing down the views in onDropViewInstance.
+         */
+        fun disposeNativeMapView() {
+            val mapView = mViewManager.getByReactTag(reactTag)
+
+            if (mapView != null) {
+                UiThreadUtil.runOnUiThread {
+                    try {
+                        mapView.dispose()
+                    } catch (ex: Exception) {
+                        Log.e(
+                            LOG_TAG, " disposeNativeMapView() exception destroying map view", ex
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+

package/android/src/main/java/org/maplibre/reactnative/components/mapview/MLRNMapViewModule.kt

@@ -0,0 +1,159 @@
+package org.maplibre.reactnative.components.mapview
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import org.maplibre.android.camera.CameraUpdateFactory.newLatLngBounds
+import org.maplibre.android.geometry.LatLng
+import org.maplibre.android.geometry.LatLngBounds
+import org.maplibre.reactnative.NativeMapViewModuleSpec
+import org.maplibre.reactnative.utils.ConvertUtils
+import org.maplibre.reactnative.utils.ExpressionParser
+import org.maplibre.reactnative.utils.ReactTag
+import org.maplibre.reactnative.utils.ReactTagResolver
+
+@ReactModule(name = NativeMapViewModuleSpec.NAME)
+class MLRNMapViewModule(
+    reactContext: ReactApplicationContext, private val reactTagResolver: ReactTagResolver
+) : NativeMapViewModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNMapViewModule"
+    }
+
+    private fun withViewportOnUIThread(
+        reactTag: ReactTag, promise: Promise, fn: (MLRNMapView) -> Unit
+    ) {
+        reactTagResolver.withViewResolved(reactTag.toInt(), promise, fn)
+    }
+
+    override fun getCenter(reactTag: Double, promise: Promise) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getCenter())
+        }
+    }
+
+    override fun getZoom(reactTag: Double, promise: Promise) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getZoom())
+        }
+    }
+
+    override fun getBearing(reactTag: Double, promise: Promise) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getBearing())
+        }
+    }
+
+    override fun getPitch(reactTag: Double, promise: Promise) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getPitch())
+        }
+    }
+
+    override fun getBounds(reactTag: Double, promise: Promise) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getBounds())
+        }
+    }
+
+    override fun getViewState(reactTag: Double, promise: Promise) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getViewState())
+        }
+    }
+
+    override fun project(
+        reactTag: Double, coordinate: ReadableMap, promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) { mapView ->
+            promise.resolve(
+                mapView.project(
+                    LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude"))
+                )
+            )
+        }
+    }
+
+    override fun unproject(
+        reactTag: Double, point: ReadableMap, promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) { mapView ->
+            promise.resolve(mapView.unproject(ConvertUtils.toPointF(point)))
+        }
+    }
+
+    override fun queryRenderedFeaturesWithCoordinate(
+        reactTag: Double,
+        coordinate: ReadableMap,
+        layers: ReadableArray?,
+        filter: ReadableArray?,
+        promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) { mapView ->
+            promise.resolve(
+                mapView.queryRenderedFeaturesWithCoordinate(
+                    LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude")),
+                    layers,
+                    ExpressionParser.from(filter),
+                )
+            )
+        }
+    }
+
+    override fun queryRenderedFeaturesWithBounds(
+        reactTag: Double,
+        bounds: ReadableArray?,
+        layers: ReadableArray?,
+        filter: ReadableArray?,
+        promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) { mapView ->
+            promise.resolve(
+                mapView.queryRenderedFeaturesWithBounds(
+                    if (bounds != null && bounds.size() == 4)
+                        LatLngBounds.from(
+                            bounds.getDouble(3),
+                            bounds.getDouble(2),
+                            bounds.getDouble(1),
+                            bounds.getDouble(0)
+                        )
+                    else
+                        LatLngBounds.world(),
+                    layers, ExpressionParser.from(filter),
+                )
+            )
+        }
+    }
+
+    override fun setSourceVisibility(
+        reactTag: Double,
+        visible: Boolean,
+        sourceId: String,
+        sourceLayerId: String?,
+        promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.setSourceVisibility(visible, sourceId, sourceLayerId))
+        }
+    }
+
+    override fun takeSnap(
+        reactTag: Double, writeToDisk: Boolean, promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            it.takeSnap(writeToDisk) { payload ->
+                promise.resolve(payload)
+            }
+        }
+    }
+
+    override fun showAttribution(
+        reactTag: Double, promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.showAttribution())
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/mapview/helpers/CameraChangeTracker.kt

@@ -0,0 +1,26 @@
+package org.maplibre.reactnative.components.mapview.helpers
+
+class CameraChangeTracker {
+    private var reason: Int = EMPTY
+    var isAnimating: Boolean = false
+
+    fun setReason(reason: Int) {
+        this.reason = reason
+    }
+
+    val isUserInteraction: Boolean
+        get() = reason == USER_GESTURE || reason == DEVELOPER_ANIMATION
+
+    val isAnimated: Boolean
+        get() = reason == DEVELOPER_ANIMATION || reason == SDK_ANIMATION
+    
+    val isEmpty: Boolean
+        get() = reason == EMPTY
+
+    companion object {
+        const val EMPTY: Int = -1
+        const val USER_GESTURE: Int = 1
+        const val DEVELOPER_ANIMATION: Int = 2
+        const val SDK_ANIMATION: Int = 3
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/mapview/helpers/LayerSourceInfo.kt

@@ -0,0 +1,74 @@
+package org.maplibre.reactnative.components.mapview.helpers
+
+import org.maplibre.android.style.layers.CircleLayer
+import org.maplibre.android.style.layers.FillExtrusionLayer
+import org.maplibre.android.style.layers.FillLayer
+import org.maplibre.android.style.layers.HeatmapLayer
+import org.maplibre.android.style.layers.HillshadeLayer
+import org.maplibre.android.style.layers.Layer
+import org.maplibre.android.style.layers.LineLayer
+import org.maplibre.android.style.layers.RasterLayer
+import org.maplibre.android.style.layers.SymbolLayer
+
+internal class LayerSourceInfo(layer: Layer?) {
+    val sourceId: String
+
+    val sourceLayerId: String?
+
+    init {
+        when (layer) {
+            is CircleLayer -> {
+                val symbolLayer = layer
+                sourceId = symbolLayer.getSourceId()
+                sourceLayerId = symbolLayer.getSourceLayer()
+            }
+
+            is FillExtrusionLayer -> {
+                val fillExtrusionLayer = layer
+                sourceId = fillExtrusionLayer.getSourceId()
+                sourceLayerId = fillExtrusionLayer.getSourceLayer()
+            }
+
+            is FillLayer -> {
+                val fillLayer = layer
+                sourceId = fillLayer.getSourceId()
+                sourceLayerId = fillLayer.getSourceLayer()
+            }
+
+            is HeatmapLayer -> {
+                val heatmapLayer = layer
+                sourceId = heatmapLayer.getSourceId()
+                sourceLayerId = heatmapLayer.getSourceLayer()
+            }
+
+            is HillshadeLayer -> {
+                val hillshadeLayer = layer
+                sourceId = hillshadeLayer.getSourceId()
+                sourceLayerId = null
+            }
+
+            is LineLayer -> {
+                val lineLayer = layer
+                sourceId = lineLayer.getSourceId()
+                sourceLayerId = lineLayer.getSourceLayer()
+            }
+
+            is RasterLayer -> {
+                val rasterLayer = layer
+                sourceId = rasterLayer.getSourceId()
+                sourceLayerId = null
+            }
+
+            is SymbolLayer -> {
+                val symbolLayer = layer
+                sourceId = symbolLayer.getSourceId()
+                sourceLayerId = symbolLayer.getSourceLayer()
+            }
+
+            else -> {
+                sourceId = ""
+                sourceLayerId = null
+            }
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/styles/layers/MLRNLayer.java

@@ -16,10 +16,6 @@ import org.maplibre.reactnative.components.AbstractMapFeature;
 import org.maplibre.reactnative.components.mapview.MLRNMapView;
 import org.maplibre.reactnative.utils.ExpressionParser;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
 public abstract class MLRNLayer<T extends Layer> extends AbstractMapFeature {
     public static final String LOG_TAG = "MLRNLayer";
 
@@ -240,7 +236,7 @@ public abstract class MLRNLayer<T extends Layer> extends AbstractMapFeature {
 
     @Override
     public void addToMap(MLRNMapView mapView) {
-        mMap = mapView.getMapboxMap();
+        mMap = mapView.getMapLibreMap();
         mMapView = mapView;
 
         if (getStyle() == null) return;

package/android/src/main/java/org/maplibre/reactnative/components/styles/light/MLRNLight.java

@@ -5,17 +5,12 @@ import android.content.Context;
 import com.facebook.react.bridge.ReadableMap;
 import org.maplibre.android.maps.MapLibreMap;
 import org.maplibre.android.maps.Style;
-import org.maplibre.android.style.layers.TransitionOptions;
 import org.maplibre.android.style.light.Light;
-import org.maplibre.android.style.light.Position;
 import org.maplibre.reactnative.components.AbstractMapFeature;
 import org.maplibre.reactnative.components.mapview.MLRNMapView;
 import org.maplibre.reactnative.components.styles.MLRNStyle;
 import org.maplibre.reactnative.components.styles.MLRNStyleFactory;
 
-import java.util.HashMap;
-import java.util.Map;
-
 public class MLRNLight extends AbstractMapFeature {
     private MapLibreMap mMap;
     private ReadableMap mReactStyle;
@@ -26,7 +21,7 @@ public class MLRNLight extends AbstractMapFeature {
 
     @Override
     public void addToMap(MLRNMapView mapView) {
-        mMap = mapView.getMapboxMap();
+        mMap = mapView.getMapLibreMap();
         setLight();
     }
 

package/android/src/main/java/org/maplibre/reactnative/components/styles/sources/MLRNShapeSource.java

@@ -5,8 +5,6 @@ import android.graphics.Bitmap;
 import android.graphics.drawable.BitmapDrawable;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import androidx.annotation.Size;
-import androidx.core.content.res.ResourcesCompat;
 
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
@@ -17,18 +15,13 @@ import org.maplibre.android.maps.Style;
 import org.maplibre.android.style.expressions.Expression;
 import org.maplibre.android.style.sources.GeoJsonOptions;
 import org.maplibre.android.style.sources.GeoJsonSource;
-import org.maplibre.android.utils.BitmapUtils;
-import org.maplibre.reactnative.R;
 import org.maplibre.reactnative.components.mapview.MLRNMapView;
 import org.maplibre.reactnative.events.AndroidCallbackEvent;
 import org.maplibre.reactnative.events.FeatureClickEvent;
 import org.maplibre.reactnative.utils.ClusterPropertyEntry;
-import org.maplibre.reactnative.utils.DownloadMapImageTask;
 import org.maplibre.reactnative.utils.ImageEntry;
 
 import java.net.URL;
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -61,10 +54,10 @@ public class MLRNShapeSource extends MLRNSource<GeoJsonSource> {
     @Override
     public void addToMap(final MLRNMapView mapView) {
         // Wait for style before adding the source to the map
-        mapView.getMapboxMap().getStyle(new Style.OnStyleLoaded() {
+        mapView.getMapLibreMap().getStyle(new Style.OnStyleLoaded() {
             @Override
             public void onStyleLoaded(@NonNull Style style) {
-                MapLibreMap map = mapView.getMapboxMap();
+                MapLibreMap map = mapView.getMapLibreMap();
                 MLRNShapeSource.super.addToMap(mapView);
             }
         });

package/android/src/main/java/org/maplibre/reactnative/components/styles/sources/MLRNSource.java

@@ -114,7 +114,7 @@ public abstract class MLRNSource<T extends Source> extends AbstractMapFeature {
     @Override
     public void addToMap(MLRNMapView mapView) {
         mMapView = mapView;
-        mMap = mapView.getMapboxMap();
+        mMap = mapView.getMapLibreMap();
         mMap.getStyle(new Style.OnStyleLoaded() {
             public void onStyleLoaded(@NonNull Style style) {
                 T existingSource = style.getSourceAs(mID);

package/android/src/main/java/org/maplibre/reactnative/events/AbstractEvent.java

@@ -46,11 +46,8 @@ abstract public class AbstractEvent implements IEvent {
 
     public WritableMap toJSON() {
         WritableMap map = Arguments.createMap();
-        map.putString("type", getType());
-
-        WritableMap payloadClone = Arguments.createMap();
-        payloadClone.merge(getPayload());
-        map.putMap("payload", payloadClone);
+        map.merge(getPayload());
+        
         return map;
     }
 

package/android/src/main/java/org/maplibre/reactnative/events/MapChangeEvent.kt

@@ -0,0 +1,18 @@
+package org.maplibre.reactnative.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class MapChangeEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val internalEventName: String,
+    private val eventData: WritableMap = Arguments.createMap()
+) : Event<MapChangeEvent>(surfaceId, viewId) {
+    override fun getEventName() = internalEventName
+
+    override fun getEventData(): WritableMap {
+        return eventData
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/MapClickEvent.java

@@ -1,17 +1,21 @@
 package org.maplibre.reactnative.events;
 
 import android.graphics.PointF;
+
 import androidx.annotation.NonNull;
+
 import android.view.View;
 
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
+
 import org.maplibre.android.geometry.LatLng;
 
 import org.maplibre.reactnative.events.constants.EventKeys;
 import org.maplibre.reactnative.events.constants.EventTypes;
 import org.maplibre.reactnative.utils.GeoJSONUtils;
 
+// TODO: Remove
 public class MapClickEvent extends AbstractEvent {
     private LatLng mTouchedLatLng;
     private PointF mScreenPoint;

package/android/src/main/java/org/maplibre/reactnative/events/MapPressEvent.kt

@@ -0,0 +1,27 @@
+package org.maplibre.reactnative.events
+
+import android.graphics.PointF
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import org.maplibre.android.geometry.LatLng
+
+class MapPressEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val internalEventName: String,
+    private val latLng: LatLng,
+    private val screenPoint: PointF,
+
+    ) : Event<MapPressEvent>(surfaceId, viewId) {
+    override fun getEventName() = internalEventName
+
+    override fun getEventData(): WritableMap {
+        return Arguments.createMap().apply {
+            putDouble("longitude", latLng.longitude)
+            putDouble("latitude", latLng.latitude)
+            putDouble("locationX", screenPoint.x.toDouble())
+            putDouble("locationY", screenPoint.y.toDouble())
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/TrackUserLocationChangeEvent.kt

@@ -0,0 +1,24 @@
+package org.maplibre.reactnative.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import org.maplibre.reactnative.events.constants.EventKeys
+import org.maplibre.reactnative.events.constants.EventTypes
+import org.maplibre.reactnative.location.TrackUserLocationMode
+
+class TrackUserLocationChangeEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val trackUserLocationMode: Int
+) :
+    Event<TrackUserLocationChangeEvent>(surfaceId, viewId) {
+    override fun getEventName() = "onTrackUserLocationChange"
+
+    override fun getEventData(): WritableMap? {
+        return Arguments.createMap().apply {
+            putString("trackUserLocation", TrackUserLocationMode.toString(trackUserLocationMode))
+        }
+    }
+}

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

@@ -9,7 +9,6 @@ public class EventKeys {
     public static final String MAP_ONCHANGE = ns("map.change");
     public static final String MAP_ON_LOCATION_CHANGE = ns("map.location.change");
     public static final String MAP_ANDROID_CALLBACK = ns("map.androidcallback");
-    public static final String MAP_USER_TRACKING_MODE_CHANGE = ns("map.usertrackingmodechange");
 
     // point annotation events
     public static final String POINT_ANNOTATION_SELECTED = ns("pointannotation.selected");