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

package/MapLibreReactNative.podspec

@@ -73,7 +73,7 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/maplibre/maplibre-react-native.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,cpp}"
-  s.private_header_files = "ios/**/*.h"
+  s.public_header_files = "ios/MLRNCustomHeaders.h"
 
  install_modules_dependencies(s)
 end

package/android/build.gradle

@@ -93,9 +93,6 @@ dependencies {
     implementation "org.maplibre.gl:android-sdk-${getConfigurableExtOrDefault('nativeVariant')}:${getConfigurableExtOrDefault('nativeVersion')}"
 
     // MapLibre Plugins
-    implementation("org.maplibre.gl:android-plugin-localization-v9:${getConfigurableExtOrDefault('pluginVersion')}") {
-        exclude(group: "org.maplibre.gl", module: "android-sdk")
-    }
     implementation("org.maplibre.gl:android-plugin-annotation-v9:${getConfigurableExtOrDefault('pluginVersion')}") {
         exclude(group: "org.maplibre.gl", module: "android-sdk")
     }

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

@@ -10,10 +10,12 @@ import org.maplibre.reactnative.components.annotation.MLRNCalloutManager
 import org.maplibre.reactnative.components.annotation.MLRNMarkerViewManager
 import org.maplibre.reactnative.components.annotation.MLRNPointAnnotationManager
 import org.maplibre.reactnative.components.camera.MLRNCameraManager
+import org.maplibre.reactnative.components.camera.MLRNCameraModule
 import org.maplibre.reactnative.components.images.MLRNImagesManager
 import org.maplibre.reactnative.components.location.MLRNNativeUserLocationManager
 import org.maplibre.reactnative.components.mapview.MLRNAndroidTextureMapViewManager
 import org.maplibre.reactnative.components.mapview.MLRNMapViewManager
+import org.maplibre.reactnative.components.mapview.MLRNMapViewModule
 import org.maplibre.reactnative.components.styles.layers.MLRNBackgroundLayerManager
 import org.maplibre.reactnative.components.styles.layers.MLRNCircleLayerManager
 import org.maplibre.reactnative.components.styles.layers.MLRNFillExtrusionLayerManager
@@ -32,6 +34,7 @@ import org.maplibre.reactnative.modules.MLRNLogging
 import org.maplibre.reactnative.modules.MLRNModule
 import org.maplibre.reactnative.modules.MLRNOfflineModule
 import org.maplibre.reactnative.modules.MLRNSnapshotModule
+import org.maplibre.reactnative.utils.ReactTagResolver
 
 
 class MLRNPackage : BaseReactPackage() {
@@ -41,6 +44,16 @@ class MLRNPackage : BaseReactPackage() {
     ): NativeModule? {
         when (name) {
             MLRNModule.REACT_CLASS -> return MLRNModule(reactContext)
+            MLRNMapViewModule.NAME -> return MLRNMapViewModule(
+                reactContext,
+                getReactTagResolver(reactContext)
+            )
+            MLRNCameraModule.NAME -> return MLRNCameraModule(
+                reactContext,
+                getReactTagResolver(reactContext)
+            )
+
+
             MLRNOfflineModule.REACT_CLASS -> return MLRNOfflineModule(reactContext)
             MLRNSnapshotModule.NAME -> return MLRNSnapshotModule(reactContext)
             MLRNLocationModule.REACT_CLASS -> return MLRNLocationModule(reactContext)
@@ -63,6 +76,24 @@ class MLRNPackage : BaseReactPackage() {
                 isTurboModule = false
             )
 
+            moduleInfos[MLRNMapViewModule.NAME] = ReactModuleInfo(
+                MLRNMapViewModule.NAME,
+                MLRNMapViewModule.NAME,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = true
+            )
+
+            moduleInfos[MLRNCameraModule.NAME] = ReactModuleInfo(
+                MLRNCameraModule.NAME,
+                MLRNCameraModule.NAME,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = true
+            )
+
             moduleInfos[MLRNOfflineModule.REACT_CLASS] = ReactModuleInfo(
                 MLRNOfflineModule.REACT_CLASS,
                 MLRNOfflineModule.REACT_CLASS,
@@ -137,4 +168,16 @@ class MLRNPackage : BaseReactPackage() {
 
         return managers
     }
+
+    private var reactTagResolver: ReactTagResolver? = null
+
+    private fun getReactTagResolver(context: ReactApplicationContext): ReactTagResolver {
+        val reactTagResolver = reactTagResolver
+        if (reactTagResolver == null) {
+            val result = ReactTagResolver(context)
+            this.reactTagResolver = result
+            return result
+        }
+        return reactTagResolver
+    }
 }

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

@@ -0,0 +1,24 @@
+package org.maplibre.reactnative.components
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+class AbstractEvent(
+    viewId: Int,
+    private val mEventName: String,
+    private val mCanCoalesce: Boolean,
+    private val mEvent: WritableMap?
+) : Event<AbstractEvent>(viewId) {
+    override fun getEventName(): String {
+        return mEventName
+    }
+
+    override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+        rctEventEmitter.receiveEvent(viewTag, eventName, mEvent)
+    }
+
+    override fun canCoalesce(): Boolean {
+        return mCanCoalesce
+    }
+}

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

@@ -0,0 +1,71 @@
+package org.maplibre.reactnative.components
+
+import android.view.ViewGroup
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.uimanager.events.EventDispatcher
+import org.maplibre.reactnative.events.IEvent
+
+abstract class AbstractEventEmitter<T : ViewGroup>(private val reactContext: ReactApplicationContext) :
+    ViewGroupManager<T>() {
+    private val mRateLimitedEvents: MutableMap<String?, Long?> = HashMap()
+    private var mEventDispatcher: EventDispatcher? = null
+
+    fun handleEvent(event: IEvent) {
+        val eventCacheKey = getEventCacheKey(event)
+
+        // fail safe to protect bridge from being spammed
+        if (shouldDropEvent(eventCacheKey, event)) {
+            return
+        }
+
+        mRateLimitedEvents.put(eventCacheKey, System.currentTimeMillis())
+        mEventDispatcher!!.dispatchEvent(
+            AbstractEvent(
+                event.getID(), event.getKey(), event.canCoalesce(), event.toJSON()
+            )
+        )
+    }
+
+    override fun addEventEmitters(context: ThemedReactContext, view: T) {
+        mEventDispatcher =
+            UIManagerHelper.getUIManager(context, UIManagerType.Companion.FABRIC)!!.eventDispatcher
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String?, Any?>? {
+        val events = customEvents()
+
+        if (events == null) {
+            return null
+        }
+
+        val exportedEvents: MutableMap<String?, Any?> = HashMap<String?, Any?>()
+
+        for (event in events.entries) {
+            exportedEvents.put(
+                event.key, MapBuilder.of<String?, String?>("registrationName", event.value!!)
+            )
+        }
+
+        return exportedEvents
+    }
+
+    abstract fun customEvents(): Map<String, String>?
+
+    private fun shouldDropEvent(cacheKey: String?, event: IEvent): Boolean {
+        val lastEventTimestamp = mRateLimitedEvents.get(cacheKey)
+        return lastEventTimestamp != null && (event.getTimestamp() - lastEventTimestamp) <= BRIDGE_TIMEOUT_MS
+    }
+
+    private fun getEventCacheKey(event: IEvent): String {
+        return String.format("%s-%s", event.getKey(), event.getType())
+    }
+
+    companion object {
+        private const val BRIDGE_TIMEOUT_MS = 10.0
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/annotation/MLRNPointAnnotation.java

@@ -94,7 +94,7 @@ public class MLRNPointAnnotation extends AbstractMapFeature implements View.OnLa
     @Override
     public void addToMap(MLRNMapView mapView) {
         mMapView = mapView;
-        mMap = mapView.getMapboxMap();
+        mMap = mapView.getMapLibreMap();
         makeMarker();
 
         if (mChildView != null) {

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

@@ -0,0 +1,203 @@
+package org.maplibre.reactnative.components.camera
+
+import android.content.Context
+import com.facebook.react.bridge.ReadableMap
+import org.maplibre.android.camera.CameraPosition
+import org.maplibre.android.camera.CameraUpdateFactory.newCameraPosition
+import org.maplibre.android.camera.CameraUpdateFactory.newLatLngBounds
+import org.maplibre.android.geometry.LatLng
+import org.maplibre.android.geometry.LatLngBounds
+import org.maplibre.android.maps.MapLibreMap.CancelableCallback
+import org.maplibre.reactnative.components.camera.constants.CameraEasing
+import org.maplibre.reactnative.components.mapview.MLRNMapView
+import org.maplibre.reactnative.utils.GeoJSONUtils
+
+class CameraStop {
+    var center: LatLng? = null
+
+    var bounds: LatLngBounds? = null
+
+    var paddingTop = 0
+    var paddingRight = 0
+    var paddingBottom = 0
+    var paddingLeft = 0
+
+    var zoom: Double? = null
+    var bearing: Double? = null
+    var pitch: Double? = null
+
+    var duration = 0
+    var easing = CameraEasing.NONE
+
+    var callback: CancelableCallback? = null
+
+    fun setPadding(paddingLeft: Int, paddingRight: Int, paddingTop: Int, paddingBottom: Int) {
+        this.paddingLeft = paddingLeft
+        this.paddingRight = paddingRight
+        this.paddingTop = paddingTop
+        this.paddingBottom = paddingBottom
+    }
+
+    fun toCameraUpdate(mapView: MLRNMapView): CameraUpdateItem {
+        val map = mapView.mapLibreMap
+        val currentCamera = map!!.cameraPosition
+        val builder = CameraPosition.Builder(currentCamera)
+
+        // Adding map padding to the camera padding to mimic MLN iOS behavior
+        val contentInset = mapView.contentInset
+
+        val paddingLeft: Int = contentInset[0].toInt() + paddingLeft
+        val paddingTop: Int = contentInset[1].toInt() + paddingTop
+        val paddingRight: Int = contentInset[2].toInt() + paddingRight
+        val paddingBottom: Int = contentInset[3].toInt() + paddingBottom
+
+        val cameraPadding = intArrayOf(paddingLeft, paddingTop, paddingRight, paddingBottom)
+        val cameraPaddingClipped: IntArray = clippedPadding(cameraPadding, mapView)
+
+        var hasSetZoom = false
+
+        if (center != null) {
+            builder.target(center)
+            builder.padding(
+                cameraPaddingClipped[0].toDouble(),
+                cameraPaddingClipped[1].toDouble(),
+                cameraPaddingClipped[2].toDouble(),
+                cameraPaddingClipped[3].toDouble()
+            )
+        } else if (bounds != null) {
+            val tilt = (if (pitch != null) pitch else currentCamera.tilt)!!
+            val bearing = (if (bearing != null) bearing else currentCamera.bearing)!!
+
+            val boundsCamera =
+                map.getCameraForLatLngBounds(bounds!!, cameraPaddingClipped, bearing, tilt)
+            if (boundsCamera != null) {
+                builder.target(boundsCamera.target)
+                builder.zoom(boundsCamera.zoom)
+                builder.padding(boundsCamera.padding)
+            } else {
+                val update = newLatLngBounds(
+                    bounds!!,
+                    cameraPaddingClipped[0],
+                    cameraPaddingClipped[1],
+                    cameraPaddingClipped[2],
+                    cameraPaddingClipped[3]
+                )
+                return CameraUpdateItem(map, update, duration, easing, callback)
+            }
+
+            hasSetZoom = true
+        }
+
+        if (zoom != null && !hasSetZoom) {
+            builder.zoom(zoom!!)
+        }
+
+        if (bearing != null) {
+            builder.bearing(bearing!!)
+        }
+
+        if (pitch != null) {
+            builder.tilt(pitch!!)
+        }
+
+        return CameraUpdateItem(
+            map, newCameraPosition(builder.build()), duration, easing, callback,
+        )
+    }
+
+    companion object {
+        fun fromReadableMap(
+            context: Context, readableMap: ReadableMap, callback: CancelableCallback?
+        ): CameraStop {
+            val stop = CameraStop()
+
+            if (readableMap.hasKey("longitude") && readableMap.hasKey("latitude")) {
+                stop.center =
+                    LatLng(readableMap.getDouble("latitude"), readableMap.getDouble("longitude"))
+            } else if (readableMap.hasKey("bounds")) {
+                stop.bounds = GeoJSONUtils.toLatLngBounds(readableMap.getArray("bounds"))
+            }
+
+            var paddingTop: Int = getPaddingByKey(readableMap, "top")
+            var paddingRight: Int = getPaddingByKey(readableMap, "right")
+            var paddingBottom: Int = getPaddingByKey(readableMap, "bottom")
+            var paddingLeft: Int = getPaddingByKey(readableMap, "left")
+
+            val density = context.resources.displayMetrics.density;
+            paddingTop = (paddingTop * density).toInt()
+            paddingRight = (paddingRight * density).toInt()
+            paddingBottom = (paddingBottom * density).toInt()
+            paddingLeft = (paddingLeft * density).toInt()
+
+            stop.setPadding(
+                paddingLeft, paddingRight, paddingTop, paddingBottom
+            )
+
+            if (readableMap.hasKey("zoom")) {
+                stop.zoom = readableMap.getDouble("zoom")
+            }
+
+            if (readableMap.hasKey("bearing")) {
+                stop.bearing = readableMap.getDouble("bearing")
+            }
+
+            if (readableMap.hasKey("pitch")) {
+                stop.pitch = readableMap.getDouble("pitch")
+            }
+
+            if (readableMap.hasKey("duration")) {
+                stop.duration = readableMap.getInt("duration")
+            }
+
+            if (readableMap.hasKey("easing")) {
+                stop.easing = CameraEasing.fromString(readableMap.getString("easing"))
+            }
+
+            stop.callback = callback
+
+            return stop
+        }
+
+        private fun clippedPadding(padding: IntArray, mapView: MLRNMapView): IntArray {
+            val mapHeight = mapView.height
+            val mapWidth = mapView.width
+
+            val left = padding[0]
+            val top = padding[1]
+            val right = padding[2]
+            val bottom = padding[3]
+
+            var resultLeft = left
+            var resultTop = top
+            var resultRight = right
+            var resultBottom = bottom
+
+            if (top + bottom >= mapHeight) {
+                val totalPadding = (top + bottom).toDouble()
+                val extra =
+                    totalPadding - mapHeight + 1.0 // Add 1 to compensate for floating point math
+                resultTop = (resultTop - (top * extra) / totalPadding).toInt()
+                resultBottom = (resultBottom - (bottom * extra) / totalPadding).toInt()
+            }
+
+            if (left + right >= mapWidth) {
+                val totalPadding = (left + right).toDouble()
+                val extra =
+                    totalPadding - mapWidth + 1.0 // Add 1 to compensate for floating point math
+                resultLeft = (resultLeft - (left * extra) / totalPadding).toInt()
+                resultRight = (resultRight - (right * extra) / totalPadding).toInt()
+            }
+
+            return intArrayOf(resultLeft, resultTop, resultRight, resultBottom)
+        }
+
+        private fun getPaddingByKey(map: ReadableMap?, key: String): Int {
+            val paddingMap = map?.getMap("padding")
+            return if (paddingMap != null && paddingMap.hasKey(key)) {
+                paddingMap.getInt(key)
+            } else {
+                0
+            }
+        }
+    }
+}

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

@@ -0,0 +1,109 @@
+package org.maplibre.reactnative.components.camera
+
+import org.maplibre.android.camera.CameraUpdate
+import org.maplibre.android.constants.MapLibreConstants
+import org.maplibre.android.maps.MapLibreMap
+import org.maplibre.android.maps.MapLibreMap.CancelableCallback
+import org.maplibre.reactnative.components.camera.constants.CameraEasing
+import java.lang.ref.WeakReference
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.RunnableFuture
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+
+class CameraUpdateItem(
+    map: MapLibreMap?,
+
+    private val cameraUpdate: CameraUpdate,
+
+    private val duration: Int,
+    @param:CameraEasing.Easing private val easing: Int,
+
+    private val callback: CancelableCallback?,
+) : RunnableFuture<Void?> {
+    private var isCameraActionFinished = false
+    private var isCameraActionCancelled = false
+
+    private val mMap: WeakReference<MapLibreMap?> = WeakReference<MapLibreMap?>(map)
+
+    override fun run() {
+        val callback: CancelableCallback = object : CancelableCallback {
+            override fun onCancel() {
+                handleCallbackResponse(true)
+            }
+
+            override fun onFinish() {
+                handleCallbackResponse(false)
+            }
+        }
+
+        val map = mMap.get()
+        if (map == null) {
+            isCameraActionCancelled = true
+            return
+        }
+
+        // animateCamera / easeCamera only allows positive duration
+        if (this.duration == 0 || easing == CameraEasing.NONE) {
+            map.moveCamera(cameraUpdate, callback)
+            return
+        }
+
+        // On iOS a duration of -1 means default or dynamic duration (based on flight-path length)
+        // On Android we can fallback to MapLibre's default duration as there is no such API
+        // TODO: Implement in MapLibre Native Android
+        val duration =
+            if (this.duration < 0) MapLibreConstants.ANIMATION_DURATION else this.duration
+
+        when (easing) {
+            CameraEasing.LINEAR -> {
+                map.easeCamera(cameraUpdate, duration, false, callback)
+            }
+
+            CameraEasing.EASE -> {
+                map.easeCamera(cameraUpdate, duration, true, callback)
+            }
+
+            CameraEasing.FLY -> {
+                map.animateCamera(cameraUpdate, duration, callback)
+            }
+        }
+    }
+
+    override fun cancel(mayInterruptIfRunning: Boolean): Boolean {
+        return false
+    }
+
+    override fun isCancelled(): Boolean {
+        return isCameraActionCancelled
+    }
+
+    override fun isDone(): Boolean {
+        return isCameraActionFinished
+    }
+
+    @Throws(InterruptedException::class, ExecutionException::class)
+    override fun get(): Void? {
+        return null
+    }
+
+    @Throws(InterruptedException::class, ExecutionException::class, TimeoutException::class)
+    override fun get(timeout: Long, unit: TimeUnit): Void? {
+        return null
+    }
+
+    private fun handleCallbackResponse(isCancel: Boolean) {
+        if (callback == null) {
+            return
+        }
+
+        isCameraActionCancelled = isCancel
+        isCameraActionFinished = !isCancel
+
+        if (isCancel) {
+            callback.onCancel()
+        } else {
+            callback.onFinish()
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+package org.maplibre.reactnative.components.camera
+
+import org.maplibre.reactnative.components.mapview.MLRNMapView
+import java.util.LinkedList
+import java.util.Queue
+
+class CameraUpdateQueue {
+    private var queue: Queue<CameraStop?>
+
+    private var completeListener: OnCompleteAllListener? = null
+
+    interface OnCompleteAllListener {
+        fun onCompleteAll()
+    }
+
+    init {
+        queue = LinkedList<CameraStop?>()
+    }
+
+    fun offer(item: CameraStop?) {
+        queue.offer(item)
+    }
+
+    fun size(): Int {
+        return queue.size
+    }
+
+    val isEmpty: Boolean
+        get() = queue.isEmpty()
+
+    fun flush() {
+        while (queue.size > 0) {
+            queue.remove()
+        }
+        queue = LinkedList<CameraStop?>()
+    }
+
+    fun setOnCompleteAllListener(listener: OnCompleteAllListener?) {
+        completeListener = listener
+    }
+
+    fun execute(map: MLRNMapView) {
+        if (queue.isEmpty()) {
+            if (completeListener != null) {
+                completeListener!!.onCompleteAll()
+            }
+
+            return
+        }
+
+        val stop = queue.poll()
+        if (stop == null) {
+            return
+        }
+
+        val item = stop.toCameraUpdate(map)
+        item.run()
+        execute(map)
+    }
+}