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

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

@@ -0,0 +1,183 @@
+package org.maplibre.reactnative.components.sources.shapesource
+
+import android.util.Log
+import android.view.View
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.module.annotations.ReactModule
+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.MLRNShapeSourceManagerDelegate
+import com.facebook.react.viewmanagers.MLRNShapeSourceManagerInterface
+import org.json.JSONException
+import org.json.JSONObject
+import org.maplibre.android.style.expressions.Expression
+import org.maplibre.reactnative.utils.ExpressionParser
+import java.net.MalformedURLException
+import java.net.URI
+import java.util.AbstractMap
+
+@ReactModule(name = MLRNShapeSourceManager.REACT_CLASS)
+class MLRNShapeSourceManager(context: ReactApplicationContext) :
+    ViewGroupManager<MLRNShapeSource>(context), MLRNShapeSourceManagerInterface<MLRNShapeSource> {
+
+
+    private val delegate: MLRNShapeSourceManagerDelegate<MLRNShapeSource, MLRNShapeSourceManager> =
+        MLRNShapeSourceManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<MLRNShapeSource> = delegate
+
+
+    companion object {
+        const val REACT_CLASS: String = "MLRNShapeSource"
+        const val LOG_TAG: String = "MLRNShapeSourceManager"
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(themedReactContext: ThemedReactContext): MLRNShapeSource {
+        return MLRNShapeSource(themedReactContext)
+    }
+
+    override fun getChildAt(parent: MLRNShapeSource, index: Int): View? {
+        return parent.getLayerAt(index)
+    }
+
+    override fun getChildCount(parent: MLRNShapeSource): Int {
+        return parent.layerCount
+    }
+
+    override fun addView(parent: MLRNShapeSource, child: View, index: Int) {
+        parent.addLayer(child, getChildCount(parent))
+    }
+
+    override fun removeViewAt(parent: MLRNShapeSource, index: Int) {
+        parent.removeLayer(index)
+    }
+
+    // TODO: Strings are nullable?
+    @ReactProp(name = "id")
+    override fun setId(source: MLRNShapeSource, id: String?) {
+        if (id == null) {
+            return
+        }
+
+        source.setID(id)
+    }
+
+    fun isJSONValid(test: String): Boolean {
+        try {
+            JSONObject(test)
+        } catch (_: JSONException) {
+            return false
+        }
+        return true
+    }
+
+
+    @ReactProp(name = "data")
+    override fun setData(source: MLRNShapeSource, value: String?) {
+        if (value != null) {
+            if (isJSONValid(value)) {
+                source.setGeoJson(value)
+            } else {
+                try {
+                    source.setURI(URI(value))
+                } catch (error: MalformedURLException) {
+                    Log.w(LOG_TAG, error.localizedMessage)
+                }
+            }
+        }
+    }
+
+    @ReactProp(name = "maxzoom")
+    override fun setMaxzoom(source: MLRNShapeSource, value: Int) {
+        source.setMaxZoom(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "buffer")
+    override fun setBuffer(source: MLRNShapeSource, value: Int) {
+        source.setBuffer(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "tolerance")
+    override fun setTolerance(source: MLRNShapeSource, value: Double) {
+        source.setTolerance(if (value.toInt() != -1) value else null)
+    }
+
+    @ReactProp(name = "lineMetrics")
+    override fun setLineMetrics(source: MLRNShapeSource, lineMetrics: Boolean) {
+        source.setLineMetrics(lineMetrics)
+    }
+
+
+    @ReactProp(name = "cluster")
+    override fun setCluster(source: MLRNShapeSource, value: Boolean) {
+        source.setCluster(value)
+    }
+
+    @ReactProp(name = "clusterRadius")
+    override fun setClusterRadius(source: MLRNShapeSource, value: Int) {
+        source.setClusterRadius(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "clusterMinPoints")
+    override fun setClusterMinPoints(source: MLRNShapeSource, value: Int) {
+        source.setClusterMinPoints(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "clusterMaxZoom")
+    override fun setClusterMaxZoom(source: MLRNShapeSource, value: Int) {
+        source.setClusterMaxZoom(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "clusterProperties")
+    override fun setClusterProperties(source: MLRNShapeSource, value: Dynamic) {
+        val map = value.asMap();
+        val properties: MutableList<MutableMap.MutableEntry<String, ClusterPropertyEntry>> =
+            ArrayList()
+
+        if (map != null) {
+            val iterator = map.keySetIterator()
+            while (iterator.hasNextKey()) {
+                val name = iterator.nextKey()
+                val expressions = map.getArray(name)
+
+                val operator: Expression? = if (expressions!!.getType(0) == ReadableType.Array) {
+                    ExpressionParser.from(expressions.getArray(0))
+                } else {
+                    Expression.literal(expressions.getString(0)!!)
+                }
+
+                val mapping = ExpressionParser.from(expressions.getArray(1))
+
+                // TODO: Throw error instead?
+                if (operator != null && mapping != null) {
+                    properties.add(
+                        AbstractMap.SimpleEntry<String, ClusterPropertyEntry>(
+                            name, ClusterPropertyEntry(operator, mapping)
+                        )
+                    )
+                }
+            }
+        }
+
+        source.setClusterProperties(properties)
+    }
+
+    @ReactProp(name = "hitbox")
+    override fun setHitbox(
+        view: MLRNShapeSource, value: ReadableMap?
+    ) {
+        view.setReactHitbox(value)
+    }
+
+    @ReactProp(name = "hasOnPress")
+    override fun setHasOnPress(view: MLRNShapeSource, value: Boolean) {
+        view.setHasOnPress(value)
+    }
+}

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

@@ -0,0 +1,65 @@
+package org.maplibre.reactnative.components.sources.shapesource
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.module.annotations.ReactModule
+import org.maplibre.reactnative.NativeShapeSourceModuleSpec
+import org.maplibre.reactnative.utils.ExpressionParser
+import org.maplibre.reactnative.utils.ReactTag
+import org.maplibre.reactnative.utils.ReactTagResolver
+
+@ReactModule(name = NativeShapeSourceModuleSpec.NAME)
+class MLRNShapeSourceModule(
+    reactContext: ReactApplicationContext, private val reactTagResolver: ReactTagResolver
+) : NativeShapeSourceModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNShapeSourceModule"
+    }
+
+    private fun withViewportOnUIThread(
+        reactTag: ReactTag, promise: Promise, fn: (MLRNShapeSource) -> Unit
+    ) {
+        reactTagResolver.withViewResolved(reactTag.toInt(), promise, fn)
+    }
+
+    override fun getData(
+        reactTag: Double, filter: ReadableArray?, promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) { shapeSource ->
+            promise.resolve(
+                shapeSource.getData(
+                    ExpressionParser.from(filter),
+                )
+            )
+        }
+    }
+
+    override fun getClusterExpansionZoom(reactTag: Double, clusterId: Double, promise: Promise) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getClusterExpansionZoom(clusterId.toInt()))
+        }
+    }
+
+    override fun getClusterLeaves(
+        reactTag: Double,
+        clusterId: Double,
+        limit: Double,
+        offset: Double,
+        promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getClusterLeaves(clusterId.toInt(), limit.toInt(), offset.toInt()))
+        }
+    }
+
+    override fun getClusterChildren(
+        reactTag: Double,
+        clusterId: Double,
+        promise: Promise
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getClusterChildren(clusterId.toInt()))
+        }
+    }
+}

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

@@ -7,7 +7,7 @@ import com.facebook.react.uimanager.events.Event
 import org.maplibre.android.geometry.LatLng
 import org.maplibre.reactnative.utils.GeoJSONUtils
 
-class MapPressEvent(
+open class MapPressEvent(
     surfaceId: Int,
     viewId: Int,
     private val internalEventName: String,

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

@@ -0,0 +1,24 @@
+package org.maplibre.reactnative.events
+
+import android.graphics.PointF
+import com.facebook.react.bridge.WritableMap
+import org.maplibre.android.geometry.LatLng
+import org.maplibre.geojson.Feature
+import org.maplibre.reactnative.utils.GeoJSONUtils
+
+class MapPressEventWithFeatures(
+    surfaceId: Int,
+    viewId: Int,
+    internalEventName: String,
+    latLng: LatLng,
+    screenPoint: PointF,
+    private val features: List<Feature>
+) : MapPressEvent(surfaceId, viewId, internalEventName, latLng, screenPoint) {
+
+    override fun getEventData(): WritableMap {
+        return super.getEventData().apply {
+            putArray("features", GeoJSONUtils.fromFeatureList(features))
+        }
+    }
+}
+

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

@@ -0,0 +1,203 @@
+package org.maplibre.reactnative.utils
+
+import android.graphics.PointF
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.NoSuchKeyException
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.google.gson.JsonArray
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+import com.google.gson.JsonPrimitive
+
+object ConvertUtils {
+    const val LOG_TAG: String = "ConvertUtils"
+
+    fun toJsonObject(map: ReadableMap?): JsonObject? {
+        if (map == null) return null
+        val result = JsonObject()
+        val it = map.keySetIterator()
+
+        while (it.hasNextKey()) {
+            val key = it.nextKey()
+            when (map.getType(key)) {
+                ReadableType.Map -> result.add(key, toJsonObject(map.getMap(key)))
+                ReadableType.Array -> result.add(key, toJsonArray(map.getArray(key)))
+                ReadableType.Null -> result.add(key, null)
+                ReadableType.Number -> result.addProperty(key, map.getDouble(key))
+                ReadableType.String -> result.addProperty(key, map.getString(key))
+                ReadableType.Boolean -> result.addProperty(key, map.getBoolean(key))
+            }
+        }
+        return result
+    }
+
+    @JvmStatic
+    fun toJsonArray(array: ReadableArray?): JsonArray? {
+        if (array == null) return null
+        val result = JsonArray(array.size())
+        for (i in 0..<array.size()) {
+            when (array.getType(i)) {
+                ReadableType.Map -> result.add(toJsonObject(array.getMap(i)))
+                ReadableType.Array -> result.add(toJsonArray(array.getArray(i)))
+                ReadableType.Null -> result.add(null as JsonElement?)
+                ReadableType.Number -> result.add(array.getDouble(i))
+                ReadableType.String -> result.add(array.getString(i))
+                ReadableType.Boolean -> result.add(array.getBoolean(i))
+            }
+        }
+        return result
+    }
+
+    @JvmStatic
+    fun typedToJsonElement(map: ReadableMap?): JsonElement? {
+        if (map == null) return null
+
+        val type = map.getString("type")
+
+        when (type) {
+            ExpressionParser.TYPE_MAP -> {
+                val result = JsonObject()
+
+                val keyValues = map.getArray("value")
+                for (i in 0..<keyValues!!.size()) {
+                    val keyValue = keyValues.getArray(i)
+                    val key = keyValue!!.getMap(0)!!.getString("value")
+
+                    result.add(key, typedToJsonElement(keyValue.getMap(1)))
+                }
+                return result
+            }
+            ExpressionParser.TYPE_ARRAY -> {
+                val arrayValue = map.getArray("value")
+                val result = JsonArray(arrayValue!!.size())
+                for (i in 0..<arrayValue.size()) {
+                    result.add(typedToJsonElement(arrayValue.getMap(i)))
+                }
+                return result
+            }
+            ExpressionParser.TYPE_BOOL -> {
+                return JsonPrimitive(map.getBoolean("value"))
+            }
+            ExpressionParser.TYPE_NUMBER -> {
+                return JsonPrimitive(map.getDouble("value"))
+            }
+            ExpressionParser.TYPE_STRING -> {
+                return JsonPrimitive(map.getString("value"))
+            }
+            else -> {
+                throw RuntimeException(String.format("Unrecognized type {}", map.getString("type")))
+            }
+        }
+    }
+
+    fun toWritableArray(array: JsonArray): WritableArray {
+        val writableArray = Arguments.createArray()
+
+        for (i in 0..<array.size()) {
+            val element = array.get(i)
+
+            if (element.isJsonArray) {
+                writableArray.pushArray(toWritableArray(element.getAsJsonArray()))
+            } else if (element.isJsonObject) {
+                writableArray.pushMap(toWritableMap(element.getAsJsonObject()))
+            } else if (element.isJsonPrimitive) {
+                val primitive = element.getAsJsonPrimitive()
+
+                if (primitive.isBoolean) {
+                    writableArray.pushBoolean(primitive.getAsBoolean())
+                } else if (primitive.isNumber) {
+                    writableArray.pushDouble(primitive.asDouble)
+                } else {
+                    writableArray.pushString(primitive.getAsString())
+                }
+            }
+        }
+
+        return writableArray
+    }
+
+    fun toWritableMap(`object`: JsonObject): WritableMap {
+        val map = Arguments.createMap()
+
+        for (entry in `object`.entrySet()) {
+            val propName = entry.key
+            val jsonElement = entry.value
+
+            if (jsonElement.isJsonPrimitive) {
+                val primitive = jsonElement.getAsJsonPrimitive()
+
+                if (primitive.isBoolean) {
+                    map.putBoolean(propName, primitive.getAsBoolean())
+                } else if (primitive.isNumber) {
+                    map.putDouble(propName, primitive.asDouble)
+                } else {
+                    map.putString(propName, primitive.getAsString())
+                }
+            } else if (jsonElement.isJsonArray) {
+                map.putArray(propName, toWritableArray(jsonElement.getAsJsonArray()))
+            } else if (jsonElement.isJsonObject) {
+                map.putMap(propName, toWritableMap(jsonElement.getAsJsonObject()))
+            }
+        }
+
+        return map
+    }
+
+    @JvmStatic
+    fun toStringList(array: ReadableArray?): MutableList<String?> {
+        val list: MutableList<String?> = ArrayList()
+
+        if (array == null) {
+            return list
+        }
+
+        for (i in 0..<array.size()) {
+            list.add(array.getString(i))
+        }
+
+        return list
+    }
+
+    fun toPointF(map: ReadableArray): PointF {
+        return PointF(map.getDouble(0).toFloat(), map.getDouble(1).toFloat())
+    }
+
+    @JvmStatic
+    fun getDouble(key: String, map: ReadableMap, defaultValue: Double): Double {
+        var value = defaultValue
+
+        try {
+            value = map.getDouble(key)
+        } catch (_: NoSuchKeyException) {
+            // key not found use default value
+            Log.d(
+                LOG_TAG,
+                String.format("No key found for %s, using default value %f", key, defaultValue)
+            )
+        }
+
+        return value
+    }
+
+    @JvmStatic
+    fun getString(key: String, map: ReadableMap, defaultValue: String?): String? {
+        var value = defaultValue
+
+        try {
+            value = map.getString(key)
+        } catch (_: NoSuchKeyException) {
+            // key not found use default value
+            Log.d(
+                LOG_TAG,
+                String.format("No key found for %s, using default value %s", key, defaultValue)
+            )
+        }
+
+        return value
+    }
+}

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

@@ -0,0 +1,70 @@
+package org.maplibre.reactnative.utils
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.google.gson.JsonArray
+import org.maplibre.android.style.expressions.Expression
+import org.maplibre.reactnative.utils.ConvertUtils.toJsonArray
+import org.maplibre.reactnative.utils.ConvertUtils.typedToJsonElement
+import java.util.Locale
+
+object ExpressionParser {
+    const val TYPE_STRING: String = "string"
+    const val TYPE_ARRAY: String = "array"
+    const val TYPE_NUMBER: String = "number"
+    const val TYPE_MAP: String = "hashmap"
+    const val TYPE_BOOL: String = "boolean"
+
+    @JvmStatic
+    fun from(rawExpressions: ReadableArray?): Expression? {
+        if (rawExpressions == null || rawExpressions.size() == 0) {
+            return null
+        }
+
+        return Expression.Converter.convert(toJsonArray(rawExpressions)!!)
+    }
+
+    @JvmStatic
+    fun fromTyped(rawExpressions: ReadableMap?): Expression {
+        val array = typedToJsonElement(rawExpressions) as JsonArray?
+        return Expression.Converter.convert(array!!)
+    }
+
+
+    fun from(rawExpression: ReadableMap): Expression? {
+        return Expression.raw("[" + stringExpression(rawExpression) + "]")
+    }
+
+    private fun stringExpression(item: ReadableMap): String {
+        var expression = ""
+        val type = item.getString("type")
+
+        if (TYPE_STRING == type) {
+            val value = item.getString("value")
+            expression = String.format(Locale.ENGLISH, "\"%s\"", value)
+        } else if (TYPE_NUMBER == type) {
+            val value = item.getDouble("value")
+            expression = String.format(Locale.ENGLISH, "%f", value)
+        } else if (TYPE_BOOL == type) {
+            val value = item.getBoolean("value")
+            expression = String.format(Locale.ENGLISH, "%b", value)
+        } else if (TYPE_ARRAY == type) {
+            val entries = item.getArray("value")
+
+            expression += "["
+
+            for (i in 0..<entries!!.size()) {
+                val entryExpression = stringExpression(entries.getMap(i)!!)
+                expression += entryExpression
+
+                if (i < entries.size() - 1) {
+                    expression += ","
+                }
+            }
+
+            expression += "]"
+        }
+
+        return expression
+    }
+}

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

@@ -4,8 +4,6 @@ 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
@@ -49,10 +47,26 @@ object GeoJSONUtils {
         return map
     }
 
-    fun fromGeometry(geometry: Geometry): WritableMap? {
-        val type = geometry.type()
+    fun fromFeatureCollection(featureCollection: FeatureCollection): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "FeatureCollection")
+
+        map.putArray("features", fromFeatureList(featureCollection.features() ?: emptyList()))
+
+        return map
+    }
+
+    fun fromFeatureList(featureList: List<Feature>): WritableArray {
+        val featuresArray = Arguments.createArray()
+        featureList.forEach { feature ->
+            featuresArray.pushMap(fromFeature(feature))
+        }
+
+        return featuresArray
+    }
 
-        return when (type) {
+    fun fromGeometry(geometry: Geometry): WritableMap? {
+        return when (val type = geometry.type()) {
             "Point" -> fromPoint(geometry as Point)
             "LineString" -> fromLineString(geometry as LineString)
             "Polygon" -> fromPolygon(geometry as Polygon)
@@ -210,25 +224,30 @@ object GeoJSONUtils {
 
     @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)
+        val map: WritableMap = Arguments.createMap().apply {
+            putString("type", "Feature")
+            putMap("geometry", toPointGeometry(latLng))
+            putMap("properties", properties)
+        }
+
         return map
     }
 
     fun toPointGeometry(latLng: LatLng): WritableMap {
-        val geometry: WritableMap = WritableNativeMap()
-        geometry.putString("type", "Point")
-        geometry.putArray("coordinates", fromLatLng(latLng))
+        val geometry: WritableMap = Arguments.createMap().apply {
+            putString("type", "Point")
+            putArray("coordinates", fromLatLng(latLng))
+        }
+
         return geometry
     }
 
     @JvmStatic
     fun fromLatLng(latLng: LatLng): WritableArray {
-        val coordinates: WritableArray = WritableNativeArray()
-        coordinates.pushDouble(latLng.longitude)
-        coordinates.pushDouble(latLng.latitude)
+        val coordinates: WritableArray = Arguments.createArray().apply {
+            pushDouble(latLng.longitude)
+            pushDouble(latLng.latitude)
+        }
 
         return coordinates
     }
@@ -250,10 +269,8 @@ object GeoJSONUtils {
 
     @JvmStatic
     fun toPointGeometry(featureJSONString: String): Point? {
-        val feature = Feature.fromJson(featureJSONString)
-        if (feature == null) {
-            return null
-        }
+        val feature = Feature.fromJson(featureJSONString) ?: return null
+
         return feature.geometry() as Point?
     }
 
@@ -294,7 +311,7 @@ object GeoJSONUtils {
             )
         }
 
-        return null;
+        return null
     }
 
     @JvmStatic