@maplibre/maplibre-react-native 11.0.0-alpha.12 → 11.0.0-alpha.14

package/android/src/main/java/org/maplibre/reactnative/MLRNPackage.kt

@@ -55,7 +55,7 @@ class MLRNPackage : BaseReactPackage() {
 
             MLRNOfflineModule.REACT_CLASS -> return MLRNOfflineModule(reactContext)
             MLRNSnapshotModule.NAME -> return MLRNSnapshotModule(reactContext)
-            MLRNLocationModule.REACT_CLASS -> return MLRNLocationModule(reactContext)
+            MLRNLocationModule.NAME -> return MLRNLocationModule(reactContext)
             MLRNLogging.REACT_CLASS -> return MLRNLogging(reactContext)
         }
 
@@ -111,13 +111,13 @@ class MLRNPackage : BaseReactPackage() {
                 isTurboModule = true
             )
 
-            moduleInfos[MLRNLocationModule.REACT_CLASS] = ReactModuleInfo(
-                MLRNLocationModule.REACT_CLASS,
-                MLRNLocationModule.REACT_CLASS,
+            moduleInfos[MLRNLocationModule.NAME] = ReactModuleInfo(
+                MLRNLocationModule.NAME,
+                MLRNLocationModule.NAME,
                 canOverrideExistingModule = false,
                 needsEagerInit = false,
                 isCxxModule = false,
-                isTurboModule = false
+                isTurboModule = true
             )
 
             moduleInfos[MLRNLogging.REACT_CLASS] = ReactModuleInfo(

package/android/src/main/java/org/maplibre/reactnative/components/camera/MLRNCamera.kt

@@ -1,14 +1,16 @@
 package org.maplibre.reactnative.components.camera
 
+import android.Manifest
 import android.content.Context
 import android.location.Location
 import android.util.AttributeSet
+import androidx.annotation.RequiresPermission
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
 import com.facebook.react.uimanager.events.EventDispatcher
 import org.maplibre.android.camera.CameraPosition
 import org.maplibre.android.camera.CameraUpdateFactory.newCameraPosition
@@ -22,8 +24,6 @@ import org.maplibre.reactnative.components.AbstractMapFeature
 import org.maplibre.reactnative.components.camera.constants.CameraEasing
 import org.maplibre.reactnative.components.location.LocationComponentManager
 import org.maplibre.reactnative.components.mapview.MLRNMapView
-import org.maplibre.reactnative.events.MapChangeEvent
-import org.maplibre.reactnative.events.TrackUserLocationChangeEvent
 import org.maplibre.reactnative.location.LocationManager
 import org.maplibre.reactnative.location.LocationManager.OnUserLocationChange
 import org.maplibre.reactnative.location.TrackUserLocationMode
@@ -63,13 +63,12 @@ class MLRNCamera(context: Context) : AbstractMapFeature(
 
 
     private val locationChangeListener: OnUserLocationChange = object : OnUserLocationChange {
-        override fun onLocationChange(nextLocation: Location) {
+        override fun onLocationChange(location: Location) {
             if (mapView!!.mapLibreMap == null || locationComponentManager == null || !locationComponentManager!!.hasLocationComponent() || trackUserLocation == TrackUserLocationMode.NONE) {
                 return
             }
 
-            userLocation.currentLocation = nextLocation
-            sendUserLocationUpdateEvent(nextLocation)
+            userLocation.setCurrentLocation(location);
         }
     }
 
@@ -103,6 +102,7 @@ class MLRNCamera(context: Context) : AbstractMapFeature(
         }
     }
 
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
     override fun addToMap(mapView: MLRNMapView) {
         this@MLRNCamera.mapView = mapView
 
@@ -192,7 +192,7 @@ class MLRNCamera(context: Context) : AbstractMapFeature(
     private fun updateUserTrackingMode(trackUserLocationMode: Int) {
         userLocation.trackingMode = trackUserLocationMode
 
-        val event = TrackUserLocationChangeEvent(surfaceId, id, trackUserLocationMode)
+        val event = OnTrackUserLocationChangeEvent(surfaceId, id, trackUserLocationMode)
         eventDispatcher?.dispatchEvent(event)
     }
 
@@ -232,17 +232,6 @@ class MLRNCamera(context: Context) : AbstractMapFeature(
             return direction
         }
 
-    private fun sendUserLocationUpdateEvent(location: Location?) {
-        if (location == null) {
-            return
-        }
-        // TODO: This has to be emitted from the proper Component
-        val event = MapChangeEvent(
-            surfaceId, id, "onUpdate", makeLocationChangePayload(location)
-        )
-        eventDispatcher?.dispatchEvent(event)
-    }
-
     private fun updateUserLocationSignificantly() {
         userTrackingState = TrackUserLocationState.BEGAN
 
@@ -282,12 +271,13 @@ class MLRNCamera(context: Context) : AbstractMapFeature(
         mapView!!.moveCamera(cameraUpdate, callback)
     }
 
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
     private fun enableLocation() {
         if (!PermissionsManager.areLocationPermissionsGranted(context)) {
             return
         }
 
-        if (!locationManager.isActive) {
+        if (!locationManager.isActive()) {
             locationManager.enable()
         }
 
@@ -385,25 +375,23 @@ class MLRNCamera(context: Context) : AbstractMapFeature(
             return mapView!!.mapLibreMap
         }
 
-    // TODO: Update structure
-    private fun makeLocationChangePayload(location: Location): WritableMap {
-        val positionProperties: WritableMap = WritableNativeMap()
-        val coordinates: WritableMap = WritableNativeMap()
-
-        coordinates.putDouble("longitude", location.longitude)
-        coordinates.putDouble("latitude", location.latitude)
-        coordinates.putDouble("altitude", location.altitude)
-        coordinates.putDouble("accuracy", location.accuracy.toDouble())
-        // TODO
-        // A better solution will be to pull the heading from the compass engine, 
-        // unfortunately the api is not public
-        coordinates.putDouble("heading", location.bearing.toDouble())
-        coordinates.putDouble("course", location.bearing.toDouble())
-        coordinates.putDouble("speed", location.speed.toDouble())
-
-        positionProperties.putMap("coords", coordinates)
-        positionProperties.putDouble("timestamp", location.time.toDouble())
-
-        return positionProperties
+
+    inner class OnTrackUserLocationChangeEvent(
+        surfaceId: Int,
+        viewId: Int,
+        private val trackUserLocationMode: Int
+    ) :
+        Event<OnTrackUserLocationChangeEvent>(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

@@ -6,8 +6,6 @@ public class EventKeys {
     // map events
     public static final String MAP_CLICK = ns("map.press");
     public static final String MAP_LONG_CLICK = ns("map.longpress");
-    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");
 
     // point annotation events
@@ -25,8 +23,6 @@ public class EventKeys {
     // images event
     public static final String IMAGES_MISSING = ns("images.missing");
 
-    // location events
-    public static final String USER_LOCATION_UPDATE = ns("user.location.update");
 
     private static String ns(String name) {
         return String.format("%s.%s", NAMESPACE, name);

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

@@ -4,7 +4,6 @@ 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 USER_LOCATION_UPDATED = "userlocationdupdated";
 
     // point annotation event types
     public static final String ANNOTATION_SELECTED = "annotationselected";

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

@@ -0,0 +1,165 @@
+package org.maplibre.reactnative.location
+
+import android.Manifest
+import android.content.Context
+import android.location.Location
+import android.os.Looper
+import android.util.Log
+import androidx.annotation.RequiresPermission
+import org.maplibre.android.location.engine.LocationEngine
+import org.maplibre.android.location.engine.LocationEngineCallback
+import org.maplibre.android.location.engine.LocationEngineRequest
+import org.maplibre.android.location.engine.LocationEngineResult
+import org.maplibre.android.location.permissions.PermissionsManager
+import org.maplibre.reactnative.location.engine.LocationEngineProvider
+import java.lang.ref.WeakReference
+
+class LocationManager private constructor(private val context: Context) :
+    LocationEngineCallback<LocationEngineResult> {
+    var engine: LocationEngine? = null
+        private set
+    private val listeners: MutableList<OnUserLocationChange> = ArrayList<OnUserLocationChange>()
+
+    private var mMinDisplacement = 0f
+    private var isActive = false
+    private var lastLocation: Location? = null
+
+    private var locationEngineRequest: LocationEngineRequest? = null
+
+    interface OnUserLocationChange {
+        fun onLocationChange(location: Location)
+    }
+
+    init {
+        this.buildEngineRequest()
+    }
+
+    private fun buildEngineRequest() {
+        this.engine = LocationEngineProvider().getLocationEngine(context)
+
+        locationEngineRequest = LocationEngineRequest.Builder(DEFAULT_INTERVAL_MILLIS)
+            .setFastestInterval(DEFAULT_FASTEST_INTERVAL_MILLIS)
+            .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
+            .setDisplacement(mMinDisplacement).build()
+    }
+
+    fun addLocationListener(listener: OnUserLocationChange?) {
+        if (!listeners.contains(listener)) {
+            listeners.add(listener!!)
+        }
+    }
+
+    fun removeLocationListener(listener: OnUserLocationChange?) {
+        if (listeners.contains(listener)) {
+            listeners.remove(listener)
+        }
+    }
+
+    fun setMinDisplacement(minDisplacement: Float) {
+        mMinDisplacement = minDisplacement
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    fun enable() {
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        // Remove existing listeners
+        engine!!.removeLocationUpdates(this)
+
+        // Refresh location engine request with new values
+        this.buildEngineRequest()
+
+        // Add new listeners
+        engine!!.requestLocationUpdates(
+            locationEngineRequest!!, this, Looper.getMainLooper()
+        )
+
+        isActive = true
+    }
+
+
+    fun disable() {
+        engine!!.removeLocationUpdates(this)
+        isActive = false
+    }
+
+    fun dispose() {
+        if (this.engine == null) {
+            return
+        }
+
+        disable()
+        engine!!.removeLocationUpdates(this)
+    }
+
+    fun isActive(): Boolean {
+        return this.engine != null && this.isActive
+    }
+
+    val lastKnownLocation: Location?
+        get() {
+            if (this.engine == null) {
+                return null
+            }
+
+            return lastLocation
+        }
+
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    fun getLastKnownLocation(callback: LocationEngineCallback<LocationEngineResult?>) {
+        if (this.engine == null) {
+            callback.onFailure(Exception("LocationEngine not initialized"))
+        }
+
+        try {
+            engine!!.getLastLocation(callback)
+        } catch (exception: Exception) {
+            Log.w(LOG_TAG, exception)
+            callback.onFailure(exception)
+        }
+    }
+
+    fun onLocationChanged(location: Location) {
+        lastLocation = location
+        for (listener in listeners) {
+            listener.onLocationChange(location)
+        }
+    }
+
+    override fun onFailure(exception: Exception) {
+        // TODO handle this.
+    }
+
+    override fun onSuccess(result: LocationEngineResult?) {
+        val location = result?.lastLocation ?: return
+
+        onLocationChanged(location)
+    }
+
+    companion object {
+        const val DEFAULT_FASTEST_INTERVAL_MILLIS: Long = 1000
+        const val DEFAULT_INTERVAL_MILLIS: Long = 1000
+
+        const val LOG_TAG: String = "LocationManager"
+
+        private var INSTANCE: WeakReference<LocationManager?>? = null
+
+        @JvmStatic
+        fun getInstance(context: Context): LocationManager {
+            val appContext = context.applicationContext
+            INSTANCE?.get()?.let { return it }
+
+            synchronized(LocationManager::class.java) {
+                INSTANCE?.get()?.let { return it }
+
+                val created = LocationManager(appContext)
+                INSTANCE = WeakReference(created)
+
+                return created
+            }
+        }
+    }
+}

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

@@ -8,7 +8,6 @@ object TrackUserLocationMode {
     const val HEADING: Int = 2
     const val COURSE: Int = 3
 
-
     @CameraMode.Mode
     fun getCameraMode(mode: Int): Int {
         return when (mode) {

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

@@ -0,0 +1,15 @@
+package org.maplibre.reactnative.location
+
+object TrackUserLocationState {
+    // The map view not yet tracked the user location
+    const val POSSIBLE: Int = 0
+
+    // The map view has begun to move to the first user location
+    const val BEGAN: Int = 1
+
+    // The map views begins a significant transition
+    const val SIGNIFICANT_TRANSITION: Int = 2
+
+    // The map view has finished moving to the user location
+    const val CHANGED: Int = 3
+}

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

@@ -0,0 +1,40 @@
+package org.maplibre.reactnative.location
+
+import android.location.Location
+import org.maplibre.android.geometry.LatLng
+
+class UserLocation @JvmOverloads constructor(private var currentLocation: Location? = null) {
+    private var previousLocation: Location? = null
+
+    var trackingMode: Int = TrackUserLocationMode.NONE
+
+    fun getCurrentLocation(): Location? {
+        return currentLocation
+    }
+
+
+    val coordinate: LatLng?
+        get() {
+            if (currentLocation == null) {
+                return null
+            }
+
+            return LatLng(
+                currentLocation!!.getLatitude(), currentLocation!!.getLongitude()
+            )
+        }
+
+    val bearing: Double
+        get() {
+            if (currentLocation == null) {
+                return 0.0
+            }
+
+            return currentLocation!!.getBearing().toDouble()
+        }
+
+    fun setCurrentLocation(currentLocation: Location?) {
+        this.previousLocation = this.currentLocation
+        this.currentLocation = currentLocation
+    }
+}

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

@@ -0,0 +1,18 @@
+package org.maplibre.reactnative.location.engine
+
+import android.content.Context
+import android.util.Log
+import org.maplibre.android.location.engine.LocationEngine
+import org.maplibre.android.location.engine.LocationEngineDefault.getDefaultLocationEngine
+
+class DefaultLocationEngineProvider : LocationEngineProvidable {
+    override fun getLocationEngine(context: Context): LocationEngine {
+        val locationEngine = getDefaultLocationEngine(context.applicationContext)
+        Log.d(LOG_TAG, "DefaultLocationEngine will be used.")
+        return locationEngine
+    }
+
+    companion object {
+        private const val LOG_TAG = "DefaultLocationEngineProvider"
+    }
+}

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

@@ -0,0 +1,8 @@
+package org.maplibre.reactnative.location.engine
+
+import android.content.Context
+import org.maplibre.android.location.engine.LocationEngine
+
+interface LocationEngineProvidable {
+    fun getLocationEngine(context: Context): LocationEngine
+}

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNLocationModule.kt

@@ -0,0 +1,153 @@
+package org.maplibre.reactnative.modules
+
+import android.Manifest
+import android.location.Location
+import android.os.Build
+import androidx.annotation.RequiresPermission
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import org.maplibre.android.location.engine.LocationEngineCallback
+import org.maplibre.android.location.engine.LocationEngineResult
+import org.maplibre.reactnative.NativeLocationModuleSpec
+import org.maplibre.reactnative.location.LocationManager
+import org.maplibre.reactnative.location.LocationManager.OnUserLocationChange
+
+class MLRNLocationModule(reactContext: ReactApplicationContext) :
+    NativeLocationModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNLocationModule"
+    }
+
+    override fun getName() = NAME
+
+    private var isEnabled = false
+    private var minDisplacement = 0f
+    private var isPaused = false
+
+    private val locationManager: LocationManager = LocationManager.getInstance(reactContext)
+
+    private val lifecycleEventListener: LifecycleEventListener = object : LifecycleEventListener {
+        @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+        override fun onHostResume() {
+            if (isEnabled) {
+                startLocationManager()
+            }
+        }
+
+        override fun onHostPause() {
+            pauseLocationManager()
+        }
+
+        override fun onHostDestroy() {
+            stopLocationManager()
+        }
+    }
+
+    private val onUserLocationChangeCallback: OnUserLocationChange = object : OnUserLocationChange {
+        override fun onLocationChange(location: Location) {
+            emitOnUpdate(locationToGeolocationPosition(location))
+        }
+    }
+
+    init {
+        reactContext.addLifecycleEventListener(lifecycleEventListener)
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun start() {
+        isEnabled = true
+        startLocationManager()
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun setMinDisplacement(minDisplacement: Double) {
+        if (this.minDisplacement == minDisplacement.toFloat()) return
+
+        this.minDisplacement = minDisplacement.toFloat()
+        if (isEnabled) {
+            locationManager.setMinDisplacement(this.minDisplacement)
+            locationManager.enable()
+        }
+    }
+
+    override fun stop() {
+        stopLocationManager()
+    }
+
+    fun pause() {
+        pauseLocationManager()
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun getCurrentPosition(promise: Promise) {
+        locationManager.getLastKnownLocation(object :
+            LocationEngineCallback<LocationEngineResult?> {
+            override fun onSuccess(result: LocationEngineResult?) {
+                val location = result?.lastLocation
+
+                if (location != null) {
+                    promise.resolve(locationToGeolocationPosition(location))
+                } else {
+                    promise.resolve(null)
+                }
+            }
+
+            override fun onFailure(exception: Exception) {
+                promise.reject(exception)
+            }
+        })
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    private fun startLocationManager() {
+        locationManager.addLocationListener(onUserLocationChangeCallback)
+        locationManager.setMinDisplacement(minDisplacement)
+        locationManager.enable()
+        isPaused = false
+    }
+
+    private fun pauseLocationManager() {
+        if (isPaused) {
+            return
+        }
+
+        locationManager.disable()
+        isPaused = true
+    }
+
+    private fun stopLocationManager() {
+        if (!isEnabled) {
+            return
+        }
+
+        locationManager.removeLocationListener(onUserLocationChangeCallback)
+        locationManager.dispose()
+        isEnabled = false
+        isPaused = false
+    }
+
+    private fun locationToGeolocationPosition(location: Location): WritableMap {
+        val coords: WritableMap = WritableNativeMap()
+
+        coords.putDouble("longitude", location.longitude)
+        coords.putDouble("latitude", location.latitude)
+        coords.putDouble("altitude", location.altitude)
+        coords.putDouble("accuracy", location.accuracy.toDouble())
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            coords.putDouble("altitudeAccuracy", location.verticalAccuracyMeters.toDouble())
+        } else {
+            coords.putNull("altitudeAccuracy")
+        }
+        coords.putDouble("heading", location.bearing.toDouble())
+        coords.putDouble("speed", location.speed.toDouble())
+
+        val geolocationPosition: WritableMap = WritableNativeMap()
+        geolocationPosition.putMap("coords", coords)
+        geolocationPosition.putDouble("timestamp", location.time.toDouble())
+
+        return geolocationPosition
+    }
+}

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

@@ -71,16 +71,11 @@ public class MLRNModule extends ReactContextBaseJavaModule {
         offlineModuleCallbackNames.put("Error", MLRNOfflineModule.OFFLINE_ERROR);
         offlineModuleCallbackNames.put("Progress", MLRNOfflineModule.OFFLINE_PROGRESS);
 
-        // location module callback names
-        Map<String, String> locationModuleCallbackNames = new HashMap<>();
-        locationModuleCallbackNames.put("Update", MLRNLocationModule.LOCATION_UPDATE);
-
         return MapBuilder.<String, Object>builder()
                 .put("StyleURL", styleURLS)
                 .put("StyleSource", styleSourceConsts)
                 .put("OfflinePackDownloadState", offlinePackDownloadStates)
                 .put("OfflineCallbackName", offlineModuleCallbackNames)
-                .put("LocationCallbackName", locationModuleCallbackNames)
                 .build();
     }
 

package/android/src/main/location-engine-default/org/maplibre/reactnative/location/engine/LocationEngineProvider.kt

@@ -0,0 +1,10 @@
+package org.maplibre.reactnative.location.engine
+
+import android.content.Context
+import org.maplibre.android.location.engine.LocationEngine
+
+class LocationEngineProvider : LocationEngineProvidable {
+    override fun getLocationEngine(context: Context): LocationEngine {
+        return DefaultLocationEngineProvider().getLocationEngine(context)
+    }
+}