@maplibre/maplibre-react-native 11.0.0-alpha.26 → 11.0.0-alpha.28

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

@@ -26,7 +26,8 @@ import org.maplibre.reactnative.components.layers.MLRNRasterLayerManager
 import org.maplibre.reactnative.components.layers.MLRNSymbolLayerManager
 import org.maplibre.reactnative.components.sources.MLRNImageSourceManager
 import org.maplibre.reactnative.components.sources.MLRNRasterSourceManager
-import org.maplibre.reactnative.components.sources.MLRNShapeSourceManager
+import org.maplibre.reactnative.components.sources.shapesource.MLRNShapeSourceManager
+import org.maplibre.reactnative.components.sources.shapesource.MLRNShapeSourceModule
 import org.maplibre.reactnative.components.sources.MLRNVectorSourceManager
 import org.maplibre.reactnative.modules.MLRNLocationModule
 import org.maplibre.reactnative.modules.MLRNLogModule
@@ -52,6 +53,11 @@ class MLRNPackage : BaseReactPackage() {
                 getReactTagResolver(reactContext)
             )
 
+            MLRNShapeSourceModule.NAME -> return MLRNShapeSourceModule(
+                reactContext,
+                getReactTagResolver(reactContext)
+            )
+
 
             MLRNOfflineModule.REACT_CLASS -> return MLRNOfflineModule(reactContext)
             MLRNSnapshotModule.NAME -> return MLRNSnapshotModule(reactContext)
@@ -93,6 +99,15 @@ class MLRNPackage : BaseReactPackage() {
                 isTurboModule = true
             )
 
+            moduleInfos[MLRNShapeSourceModule.NAME] = ReactModuleInfo(
+                MLRNShapeSourceModule.NAME,
+                MLRNShapeSourceModule.NAME,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = true
+            )
+
             moduleInfos[MLRNOfflineModule.REACT_CLASS] = ReactModuleInfo(
                 MLRNOfflineModule.REACT_CLASS,
                 MLRNOfflineModule.REACT_CLASS,

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

@@ -64,7 +64,6 @@ import org.maplibre.reactnative.events.MapChangeEvent
 import org.maplibre.reactnative.events.MapPressEvent
 import org.maplibre.reactnative.modules.MLRNModule
 import org.maplibre.reactnative.utils.BitmapUtils
-import org.maplibre.reactnative.utils.ConvertUtils
 import org.maplibre.reactnative.utils.GeoJSONUtils
 import kotlin.math.roundToInt
 
@@ -537,24 +536,21 @@ open class MLRNMapView(
         val screenPoint = mapLibreMap!!.projection.toScreenLocation(latLng)
         val touchableSources = this.allTouchableSources
 
-        val hits: MutableMap<String?, MutableList<Feature?>?> = HashMap()
+        val hits: MutableMap<String, MutableList<Feature>?> = HashMap()
         val hitTouchableSources: MutableList<MLRNSource<*>> = ArrayList()
         for (touchableSource in touchableSources) {
-            val hitbox = touchableSource.getTouchHitbox() ?: continue
+            val hitbox = touchableSource.hitbox ?: continue
 
-            val halfWidth = hitbox["width"]!!.toFloat() / 2.0f
-            val halfHeight = hitbox["height"]!!.toFloat() / 2.0f
-
-            val hitboxF = RectF()
-            hitboxF.set(
-                screenPoint.x - halfWidth,
-                screenPoint.y - halfHeight,
-                screenPoint.x + halfWidth,
-                screenPoint.y + halfHeight
+            val pointWithHitbox = RectF(
+                screenPoint.x - hitbox.left,
+                screenPoint.y - hitbox.top,
+                screenPoint.x + hitbox.right,
+                screenPoint.y + hitbox.bottom
             )
 
+
             val features =
-                mapLibreMap!!.queryRenderedFeatures(hitboxF, *touchableSource.getLayerIDs())
+                mapLibreMap!!.queryRenderedFeatures(pointWithHitbox, *touchableSource.getLayerIDs())
             if (features.isNotEmpty()) {
                 hits[touchableSource.getID()] = features
                 hitTouchableSources.add(touchableSource)
@@ -563,12 +559,15 @@ open class MLRNMapView(
 
         if (hits.isNotEmpty()) {
             val source = getTouchableSourceWithHighestZIndex(hitTouchableSources)
-            if (source != null && source.hasPressListener()) {
-                source.onPress(
-                    OnPressEvent(
-                        hits[source.getID()]!!, latLng, screenPoint
+            if (source != null && source.hasOnPress()) {
+                hits[source.getID()]?.let {
+                    source.onPress(
+                        OnPressEvent(
+                            it, latLng, screenPoint
+                        )
                     )
-                )
+                }
+
                 return true
             }
         }
@@ -907,13 +906,7 @@ open class MLRNMapView(
             filter,
             *(layers?.let { Array(layers.size()) { layers.getString(it) } } ?: emptyArray()))
 
-
-        val result = Arguments.createArray()
-        for (feature in features) {
-            val jsonObject = com.google.gson.JsonParser.parseString(feature.toJson()).asJsonObject
-            result.pushMap(ConvertUtils.toWritableMap(jsonObject))
-        }
-        return result
+        return GeoJSONUtils.fromFeatureList(features)
     }
 
 
@@ -938,12 +931,7 @@ open class MLRNMapView(
             filter,
             *(layers?.let { Array(layers.size()) { layers.getString(it) } } ?: emptyArray()))
 
-        val result = Arguments.createArray()
-        for (feature in features) {
-            val jsonObject = com.google.gson.JsonParser.parseString(feature.toJson()).asJsonObject
-            result.pushMap(ConvertUtils.toWritableMap(jsonObject))
-        }
-        return result
+        return GeoJSONUtils.fromFeatureList(features)
     }
 
     fun project(mapCoordinate: LatLng): WritableArray {
@@ -1258,7 +1246,7 @@ open class MLRNMapView(
 
             for (key in this.sources.keys) {
                 val source = this.sources[key]
-                if (source != null && source.hasPressListener()) {
+                if (source != null && source.hasOnPress()) {
                     sources.add(source)
                 }
             }

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

@@ -29,7 +29,7 @@ public class MLRNRasterSource extends MLRNTileSource<RasterSource> {
     }
 
     @Override
-    public boolean hasPressListener() {
+    public boolean hasOnPress() {
         return false;
     }
 

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

@@ -0,0 +1,228 @@
+package org.maplibre.reactnative.components.sources
+
+import android.content.Context
+import android.graphics.PointF
+import android.graphics.RectF
+import android.view.View
+import com.facebook.react.bridge.ReadableMap
+import org.maplibre.android.geometry.LatLng
+import org.maplibre.android.log.Logger
+import org.maplibre.android.maps.MapLibreMap
+import org.maplibre.android.maps.Style
+import org.maplibre.android.style.sources.Source
+import org.maplibre.geojson.Feature
+import org.maplibre.reactnative.components.AbstractMapFeature
+import org.maplibre.reactnative.components.layers.MLRNLayer
+import org.maplibre.reactnative.components.mapview.MLRNMapView
+
+abstract class MLRNSource<T : Source?>(context: Context?) : AbstractMapFeature(context) {
+    protected var mMapView: MLRNMapView? = null
+
+    @JvmField
+    protected var mMap: MapLibreMap? = null
+
+    @JvmField
+    protected var mID: String? = null
+
+    @JvmField
+    protected var mSource: T? = null
+    protected var mHasOnPress: Boolean = false
+
+    protected var mLayers: MutableList<MLRNLayer<*>> = ArrayList()
+    private var mQueuedLayers: MutableList<MLRNLayer<*>?>? = ArrayList()
+
+    fun getID(): String {
+        return mID!!
+    }
+
+    fun setID(id: String) {
+        mID = id
+    }
+
+    fun getLayerIDs(): Array<String?> {
+        val layerIDs: MutableList<String?> = ArrayList()
+
+        for (i in mLayers.indices) {
+            val layer = mLayers[i]
+            layerIDs.add(layer.getID())
+        }
+
+        return layerIDs.toTypedArray<String?>()
+    }
+
+    open fun hasOnPress(): Boolean {
+        return mHasOnPress
+    }
+
+    fun setHasOnPress(hasPressListener: Boolean) {
+        mHasOnPress = hasPressListener
+    }
+
+    fun setSource(source: T?) {
+        mSource = source
+    }
+
+    var hitbox: RectF? = null
+        get() {
+            if (!hasOnPress()) {
+                return null
+            }
+
+            if (field == null) {
+                return DEFAULT_HITBOX
+            }
+
+            return field
+        }
+
+    fun setReactHitbox(map: ReadableMap?) {
+        hitbox = if (map != null) {
+            RectF(
+                map.getDouble("left").toFloat(),
+                map.getDouble("top").toFloat(),
+                map.getDouble("right").toFloat(),
+                map.getDouble("bottom").toFloat()
+            )
+        } else {
+            null
+        }
+    }
+
+    val layerCount: Int
+        get() {
+            var totalCount = 0
+
+            if (mQueuedLayers != null) {
+                totalCount = mQueuedLayers!!.size
+            }
+
+            totalCount += mLayers.size
+            return totalCount
+        }
+
+    override fun addToMap(mapView: MLRNMapView) {
+        mMapView = mapView
+        mMap = mapView.mapLibreMap
+        mMap!!.getStyle { style ->
+            val existingSource = style.getSourceAs<T?>(mID!!)
+            if (existingSource != null) {
+                mSource = existingSource
+            } else {
+                mSource = makeSource()
+                style.addSource(mSource!!)
+            }
+
+            if (mQueuedLayers != null && mQueuedLayers!!.isNotEmpty()) { // first load
+                for (i in mQueuedLayers!!.indices) {
+                    addLayerToMap(mQueuedLayers!![i], i)
+                }
+                mQueuedLayers = null
+            } else if (mLayers.isNotEmpty()) { // handles the case of switching style url, but keeping layers on map
+                for (i in mLayers.indices) {
+                    addLayerToMap(mLayers[i], i)
+                }
+            }
+        }
+    }
+
+    override fun removeFromMap(mapView: MLRNMapView?) {
+        if (mLayers.isNotEmpty()) {
+            for (i in mLayers.indices) {
+                val layer = mLayers[i]
+                layer.removeFromMap(mMapView)
+            }
+        }
+        if (mQueuedLayers != null) {
+            mQueuedLayers!!.clear()
+        }
+        if (mMap != null && mSource != null && mMap!!.style != null) {
+            try {
+                mMap!!.style!!.removeSource(mSource!!)
+            } catch (ex: Throwable) {
+                Logger.w(
+                    LOG_TAG,
+                    String.format("MLRNSource.removeFromMap: %s - %s", mSource, ex.message),
+                    ex
+                )
+            }
+        }
+    }
+
+    fun addLayer(childView: View?, childPosition: Int) {
+        if (childView !is MLRNLayer<*>) {
+            return
+        }
+
+        if (mMap == null) {
+            mQueuedLayers!!.add(childPosition, childView)
+        } else {
+            addLayerToMap(childView, childPosition)
+        }
+    }
+
+    fun removeLayer(childPosition: Int) {
+        val layer: MLRNLayer<*>? = if (mQueuedLayers != null && mQueuedLayers!!.isNotEmpty()) {
+            mQueuedLayers!![childPosition]
+        } else {
+            mLayers[childPosition]
+        }
+        removeLayerFromMap(layer, childPosition)
+    }
+
+    fun getLayerAt(childPosition: Int): MLRNLayer<*>? {
+        if (mQueuedLayers != null && mQueuedLayers!!.isNotEmpty()) {
+            return mQueuedLayers!![childPosition]
+        }
+        return mLayers[childPosition]
+    }
+
+    protected fun addLayerToMap(layer: MLRNLayer<*>?, childPosition: Int) {
+        if (mMapView == null || layer == null) {
+            return
+        }
+
+        layer.addToMap(mMapView)
+        if (!mLayers.contains(layer)) {
+            mLayers.add(childPosition, layer)
+        }
+    }
+
+    protected fun removeLayerFromMap(layer: MLRNLayer<*>?, childPosition: Int) {
+        if (mMapView != null && layer != null) {
+            layer.removeFromMap(mMapView)
+        }
+        if (mQueuedLayers != null && mQueuedLayers!!.isNotEmpty()) {
+            mQueuedLayers!!.removeAt(childPosition)
+        } else {
+            mLayers.removeAt(childPosition)
+        }
+    }
+
+    val style: Style?
+        get() {
+            if (mMap == null) return null
+            return mMap!!.style
+        }
+
+    abstract fun makeSource(): T?
+
+    class OnPressEvent(
+        @JvmField var features: MutableList<Feature>,
+        @JvmField var latLng: LatLng,
+        @JvmField var screenPoint: PointF
+    )
+
+    abstract fun onPress(event: OnPressEvent)
+
+    companion object {
+        const val DEFAULT_ID: String = "composite"
+        const val LOG_TAG: String = "MLRNSource"
+
+        val DEFAULT_HITBOX: RectF = RectF(22.0f, 22.0f, 22.0f, 22.0f)
+
+        @JvmStatic
+        fun isDefaultSource(sourceID: String?): Boolean {
+            return DEFAULT_ID == sourceID
+        }
+    }
+}

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

@@ -7,7 +7,6 @@ import org.maplibre.android.style.sources.TileSet;
 
 import java.util.Collection;
 
-@SuppressWarnings("unused")
 public abstract class MLRNTileSource<T extends Source> extends MLRNSource<T> {
     static final String TILE_SPEC_VERSION = "2.1.0";
 

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

@@ -37,12 +37,12 @@ public class MLRNVectorSourceManager extends MLRNTileSourceManager<MLRNVectorSou
 
     @ReactProp(name = "hasPressListener")
     public void setHasPressListener(MLRNVectorSource source, boolean hasPressListener) {
-        source.setHasPressListener(hasPressListener);
+        source.setHasOnPress(hasPressListener);
     }
 
     @ReactProp(name="hitbox")
     public void setHitbox(MLRNVectorSource source, ReadableMap map) {
-        source.setHitbox(map);
+        source.setReactHitbox(map);
     }
 
     @Override

package/android/src/main/java/org/maplibre/reactnative/components/sources/shapesource/ClusterPropertyEntry.kt

@@ -0,0 +1,5 @@
+package org.maplibre.reactnative.components.sources.shapesource
+
+import org.maplibre.android.style.expressions.Expression
+
+class ClusterPropertyEntry(var operator: Expression, var mapping: Expression)

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

@@ -0,0 +1,232 @@
+package org.maplibre.reactnative.components.sources.shapesource
+
+import android.content.Context
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.google.gson.JsonObject
+import org.maplibre.android.style.expressions.Expression
+import org.maplibre.android.style.sources.GeoJsonOptions
+import org.maplibre.android.style.sources.GeoJsonSource
+import org.maplibre.geojson.Feature
+import org.maplibre.geojson.FeatureCollection
+import org.maplibre.geojson.Point
+import org.maplibre.reactnative.components.mapview.MLRNMapView
+import org.maplibre.reactnative.components.sources.MLRNSource
+import org.maplibre.reactnative.events.MapPressEventWithFeatures
+import org.maplibre.reactnative.utils.GeoJSONUtils
+import java.net.URI
+
+class MLRNShapeSource(context: Context) : MLRNSource<GeoJsonSource?>(context) {
+    private var uri: URI? = null
+    private var geoJson: String? = null
+
+    private var maxZoom: Int? = null
+    private var buffer: Int? = null
+    private var tolerance: Double? = null
+    private var lineMetrics: Boolean? = null
+
+    private var cluster: Boolean? = null
+    private var clusterRadius: Int? = null
+    private var clusterMinPoints: Int? = null
+    private var clusterMaxZoom: Int? = null
+    private var clusterProperties: MutableList<MutableMap.MutableEntry<String, ClusterPropertyEntry>>? =
+        null
+
+
+    val eventDispatcher: EventDispatcher?
+        get() {
+            val reactContext = context as ReactContext
+
+            return UIManagerHelper.getEventDispatcherForReactTag(reactContext, getId())
+        }
+
+    val surfaceId: Int
+        get() {
+            val reactContext = context as ReactContext
+
+            return UIManagerHelper.getSurfaceId(reactContext)
+        }
+
+    override fun addToMap(mapView: MLRNMapView) {
+        // Wait for style before adding the source to the map
+        mapView.mapLibreMap!!.getStyle {
+            super@MLRNShapeSource.addToMap(mapView)
+        }
+    }
+
+    override fun makeSource(): GeoJsonSource {
+        val options = this.options
+
+        if (geoJson != null) {
+            return GeoJsonSource(mID, geoJson, options)
+        }
+
+        return GeoJsonSource(mID, uri!!, options)
+    }
+
+    fun setURI(url: URI) {
+        uri = url
+
+        if (mSource != null && mMapView != null && !mMapView!!.isDestroyed) {
+            mSource!!.setUri(uri!!)
+        }
+    }
+
+    fun setGeoJson(geoJson: String?) {
+        this.geoJson = geoJson
+
+        if (mSource != null && mMapView != null && !mMapView!!.isDestroyed) {
+            mSource!!.setGeoJson(geoJson!!)
+        }
+    }
+
+    fun setMaxZoom(value: Int?) {
+        this.maxZoom = value
+    }
+
+    fun setBuffer(value: Int?) {
+        this.buffer = value
+    }
+
+    fun setTolerance(value: Double?) {
+        this.tolerance = value
+    }
+
+    fun setLineMetrics(lineMetrics: Boolean) {
+        this.lineMetrics = lineMetrics
+    }
+
+    fun setCluster(cluster: Boolean) {
+        this.cluster = cluster
+    }
+
+    fun setClusterRadius(clusterRadius: Int?) {
+        this.clusterRadius = clusterRadius
+    }
+
+    fun setClusterMinPoints(clusterMinPoints: Int?) {
+        this.clusterMinPoints = clusterMinPoints
+    }
+
+    fun setClusterMaxZoom(clusterMaxZoom: Int?) {
+        this.clusterMaxZoom = clusterMaxZoom
+    }
+
+    fun setClusterProperties(clusterProperties: MutableList<MutableMap.MutableEntry<String, ClusterPropertyEntry>>?) {
+        this.clusterProperties = clusterProperties
+    }
+
+
+    override fun onPress(event: OnPressEvent) {
+        val event = MapPressEventWithFeatures(
+            surfaceId, id, "onPress", event.latLng, event.screenPoint, event.features
+        )
+        eventDispatcher?.dispatchEvent(event)
+    }
+
+    private val options: GeoJsonOptions
+        get() {
+            val options = GeoJsonOptions()
+
+            if (cluster != null) {
+                options.withCluster(cluster!!)
+            }
+
+            if (clusterRadius != null) {
+                options.withClusterRadius(clusterRadius!!)
+            }
+
+            if (clusterMinPoints != null) {
+                options.withClusterMinPoints(clusterMinPoints!!)
+            }
+
+            if (clusterMaxZoom != null) {
+                options.withClusterMaxZoom(clusterMaxZoom!!)
+            }
+
+            if (clusterProperties != null) {
+                for (entry in clusterProperties) {
+                    val property: ClusterPropertyEntry = entry.value
+
+                    options.withClusterProperty(entry.key, property.operator, property.mapping)
+                }
+            }
+
+            if (maxZoom != null) {
+                options.withMaxZoom(maxZoom!!)
+            }
+
+            if (buffer != null) {
+                options.withBuffer(buffer!!)
+            }
+
+            if (tolerance != null) {
+                options.withTolerance(tolerance!!.toFloat())
+            }
+
+            if (lineMetrics != null) {
+                options.withLineMetrics(lineMetrics!!)
+            }
+
+            return options
+        }
+
+    fun getData(
+        filter: Expression?
+    ): WritableMap {
+        if (mSource == null) {
+            throw IllegalStateException("Source is not yet loaded")
+        }
+
+        val features: List<Feature> = mSource!!.querySourceFeatures(filter)
+
+
+        return GeoJSONUtils.fromFeatureCollection(
+            FeatureCollection.fromFeatures(features)
+        )
+    }
+
+    fun getClusterExpansionZoom(clusterId: Int): Int {
+        if (mSource == null) {
+            throw IllegalStateException("Source is not yet loaded")
+        }
+
+        val zoom = mSource!!.getClusterExpansionZoom(createClusterFeature(clusterId))
+
+        return zoom
+    }
+
+    fun getClusterLeaves(clusterId: Int, limit: Int, offset: Int): WritableArray {
+        if (mSource == null) {
+            throw IllegalStateException("Source is not yet loaded")
+        }
+
+        val features = mSource!!.getClusterLeaves(
+            createClusterFeature(clusterId), limit.toLong(), offset.toLong()
+        )
+
+        return GeoJSONUtils.fromFeatureList(features.features()?.toList()!!)
+    }
+
+    fun getClusterChildren(clusterId: Int): WritableArray {
+        if (mSource == null) {
+            throw IllegalStateException("Source is not yet loaded")
+        }
+
+        val leaves = mSource!!.getClusterChildren(createClusterFeature(clusterId))
+
+        return GeoJSONUtils.fromFeatureList(leaves.features()!!)
+    }
+
+    private fun createClusterFeature(clusterId: Int): Feature {
+        val properties = JsonObject()
+        properties.addProperty("cluster_id", clusterId)
+
+        return Feature.fromGeometry(
+            Point.fromLngLat(0.0, 0.0), properties
+        )
+    }
+}