@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/java/io/github/mapvina/reactnative/components/sources/MLRNSource.kt

@@ -0,0 +1,198 @@
+package io.github.mapvina.reactnative.components.sources
+
+import android.content.Context
+import android.view.View
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+import io.github.mapvina.android.log.Logger
+import io.github.mapvina.android.maps.MapVinaMap
+import io.github.mapvina.android.maps.Style
+import io.github.mapvina.android.style.sources.Source
+import io.github.mapvina.reactnative.components.AbstractMapFeature
+import io.github.mapvina.reactnative.components.layer.MLRNLayer
+import io.github.mapvina.reactnative.components.mapview.MLRNMapView
+
+abstract class MLRNSource<T : Source?>(
+    context: Context?,
+) : AbstractMapFeature(context) {
+    protected var mMapView: MLRNMapView? = null
+
+    protected var mMap: MapVinaMap? = null
+
+    @JvmField
+    protected var mID: String? = null
+
+    @JvmField
+    protected var source: T? = null
+
+    protected var mLayers: MutableList<MLRNLayer> = ArrayList()
+    private var mQueuedLayers: MutableList<MLRNLayer?>? = ArrayList()
+
+    val eventDispatcher: EventDispatcher?
+        get() {
+            val reactContext = context as ReactContext
+
+            return UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+        }
+
+    val surfaceId: Int
+        get() {
+            val reactContext = context as ReactContext
+
+            return UIManagerHelper.getSurfaceId(reactContext)
+        }
+
+    fun getID(): String = 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.ID)
+        }
+
+        return layerIDs.toTypedArray<String?>()
+    }
+
+    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.mapVinaMap
+        mMap!!.getStyle { style ->
+            val existingSource = style.getSourceAs<T?>(mID!!)
+            if (existingSource != null) {
+                source = existingSource
+            } else {
+                source = makeSource()
+                style.addSource(source!!)
+            }
+
+            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(mapView)
+            }
+        }
+        if (mQueuedLayers != null) {
+            mQueuedLayers!!.clear()
+        }
+        if (mMap != null && source != null && mMap!!.style != null) {
+            try {
+                mMap!!.style!!.removeSource(source!!)
+            } catch (ex: Throwable) {
+                Logger.w(
+                    LOG_TAG,
+                    String.format("MLRNSource.removeFromMap: %s - %s", source, 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,
+    ) {
+        val mapView = mMapView ?: return
+        if (layer == null) return
+
+        if (mID != null) {
+            layer.setSourceID(mID)
+        }
+        layer.addToMap(mapView)
+        if (!mLayers.contains(layer)) {
+            mLayers.add(childPosition, layer)
+        }
+    }
+
+    protected fun removeLayerFromMap(
+        layer: MLRNLayer?,
+        childPosition: Int,
+    ) {
+        val mapView = mMapView
+        if (mapView != null && layer != null) {
+            layer.removeFromMap(mapView)
+        }
+        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
+
+    companion object {
+        const val LOG_TAG: String = "MLRNSource"
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/sources/MLRNSourceManager.kt

@@ -0,0 +1,69 @@
+package io.github.mapvina.reactnative.components.sources
+
+import android.view.View
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+
+abstract class MLRNSourceManager<T : MLRNSource<*>>(
+    context: ReactApplicationContext,
+) : ViewGroupManager<T>(context) {
+    abstract override fun createViewInstance(themedReactContext: ThemedReactContext): T
+
+    override fun addView(
+        parent: T,
+        child: View,
+        index: Int,
+    ) {
+        parent.addLayer(child, index)
+    }
+
+    override fun getChildCount(parent: T): Int = parent.layerCount
+
+    override fun getChildAt(
+        parent: T,
+        index: Int,
+    ): View? = parent.getLayerAt(index)
+
+    override fun removeViewAt(
+        parent: T,
+        index: Int,
+    ) {
+        parent.removeLayer(index)
+    }
+
+    // TODO: Strings are nullable?
+    @ReactProp(name = "id")
+    fun setId(
+        source: T?,
+        id: String?,
+    ) {
+        if (id == null) {
+            return
+        }
+
+        source!!.setID(id)
+    }
+
+    @ReactProp(name = "hitbox")
+    fun setHitbox(
+        view: T,
+        value: ReadableMap?,
+    ) {
+        if (view is MLRNPressableSource<*>) {
+            view.setReactHitbox(value)
+        }
+    }
+
+    @ReactProp(name = "hasOnPress")
+    fun setHasOnPress(
+        view: T,
+        value: Boolean,
+    ) {
+        if (view is MLRNPressableSource<*>) {
+            view.hasOnPress = value
+        }
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/sources/geojsonsource/ClusterPropertyEntry.kt

@@ -0,0 +1,8 @@
+package io.github.mapvina.reactnative.components.sources.geojsonsource
+
+import io.github.mapvina.android.style.expressions.Expression
+
+class ClusterPropertyEntry(
+    var operator: Expression,
+    var mapping: Expression,
+)

package/android/src/main/java/io/github/mapvina/reactnative/components/sources/geojsonsource/MLRNGeoJSONSource.kt

@@ -0,0 +1,212 @@
+package io.github.mapvina.reactnative.components.sources.geojsonsource
+
+import android.content.Context
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.google.gson.JsonObject
+import io.github.mapvina.android.style.expressions.Expression
+import io.github.mapvina.android.style.sources.GeoJsonOptions
+import io.github.mapvina.android.style.sources.GeoJsonSource
+import io.github.mapvina.geojson.Feature
+import io.github.mapvina.geojson.FeatureCollection
+import io.github.mapvina.geojson.Point
+import io.github.mapvina.reactnative.components.mapview.MLRNMapView
+import io.github.mapvina.reactnative.components.sources.MLRNPressableSource
+import io.github.mapvina.reactnative.utils.GeoJSONUtils
+import java.net.URI
+
+class MLRNGeoJSONSource(
+    context: Context,
+) : MLRNPressableSource<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
+
+    override fun addToMap(mapView: MLRNMapView) {
+        // Wait for style before adding the source to the map
+        mapView.mapVinaMap!!.getStyle {
+            super@MLRNGeoJSONSource.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 (source != null && mMapView != null && !mMapView!!.isDestroyed) {
+            source!!.setUri(uri!!)
+        }
+    }
+
+    fun setGeoJson(geoJson: String?) {
+        this.geoJson = geoJson
+
+        if (source != null && mMapView != null && !mMapView!!.isDestroyed) {
+            source!!.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
+    }
+
+    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 (source == null) {
+            throw IllegalStateException("Source is not yet loaded")
+        }
+
+        val features: List<Feature> = source!!.querySourceFeatures(filter)
+
+        return GeoJSONUtils.fromFeatureCollection(
+            FeatureCollection.fromFeatures(features),
+        )
+    }
+
+    fun getClusterExpansionZoom(clusterId: Int): Int {
+        if (source == null) {
+            throw IllegalStateException("Source is not yet loaded")
+        }
+
+        val zoom = source!!.getClusterExpansionZoom(createClusterFeature(clusterId))
+
+        return zoom
+    }
+
+    fun getClusterLeaves(
+        clusterId: Int,
+        limit: Int,
+        offset: Int,
+    ): WritableArray {
+        if (source == null) {
+            throw IllegalStateException("Source is not yet loaded")
+        }
+
+        val features =
+            source!!.getClusterLeaves(
+                createClusterFeature(clusterId),
+                limit.toLong(),
+                offset.toLong(),
+            )
+
+        return GeoJSONUtils.fromFeatureList(features.features()?.toList()!!)
+    }
+
+    fun getClusterChildren(clusterId: Int): WritableArray {
+        if (source == null) {
+            throw IllegalStateException("Source is not yet loaded")
+        }
+
+        val leaves = source!!.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,
+        )
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/sources/geojsonsource/MLRNGeoJSONSourceManager.kt

@@ -0,0 +1,159 @@
+package io.github.mapvina.reactnative.components.sources.geojsonsource
+
+import android.util.Log
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.MLRNGeoJSONSourceManagerDelegate
+import com.facebook.react.viewmanagers.MLRNGeoJSONSourceManagerInterface
+import io.github.mapvina.android.style.expressions.Expression
+import io.github.mapvina.reactnative.components.sources.MLRNSourceManager
+import io.github.mapvina.reactnative.utils.ExpressionParser
+import java.net.URI
+import java.util.AbstractMap
+
+@ReactModule(name = MLRNGeoJSONSourceManager.REACT_CLASS)
+class MLRNGeoJSONSourceManager(
+    context: ReactApplicationContext,
+) : MLRNSourceManager<MLRNGeoJSONSource>(context),
+    MLRNGeoJSONSourceManagerInterface<MLRNGeoJSONSource> {
+    private val delegate: MLRNGeoJSONSourceManagerDelegate<MLRNGeoJSONSource, MLRNGeoJSONSourceManager> =
+        MLRNGeoJSONSourceManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<MLRNGeoJSONSource> = delegate
+
+    companion object {
+        const val REACT_CLASS: String = "MLRNGeoJSONSource"
+        const val LOG_TAG: String = "MLRNGeoJSONSourceManager"
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(themedReactContext: ThemedReactContext): MLRNGeoJSONSource = MLRNGeoJSONSource(themedReactContext)
+
+    @ReactProp(name = "data")
+    override fun setData(
+        source: MLRNGeoJSONSource,
+        value: String?,
+    ) {
+        if (value != null) {
+            val trimmed = value.trimStart()
+            if (trimmed.startsWith("{")) {
+                source.setGeoJson(value)
+            } else {
+                try {
+                    source.setURI(URI(value))
+                } catch (error: Exception) {
+                    Log.w(LOG_TAG, "Invalid GeoJSON data or URL: ${error.localizedMessage}")
+                }
+            }
+        }
+    }
+
+    @ReactProp(name = "maxzoom")
+    override fun setMaxzoom(
+        source: MLRNGeoJSONSource,
+        value: Int,
+    ) {
+        source.setMaxZoom(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "buffer")
+    override fun setBuffer(
+        source: MLRNGeoJSONSource,
+        value: Int,
+    ) {
+        source.setBuffer(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "tolerance")
+    override fun setTolerance(
+        source: MLRNGeoJSONSource,
+        value: Double,
+    ) {
+        source.setTolerance(if (value.toInt() != -1) value else null)
+    }
+
+    @ReactProp(name = "lineMetrics")
+    override fun setLineMetrics(
+        source: MLRNGeoJSONSource,
+        lineMetrics: Boolean,
+    ) {
+        source.setLineMetrics(lineMetrics)
+    }
+
+    @ReactProp(name = "cluster")
+    override fun setCluster(
+        source: MLRNGeoJSONSource,
+        value: Boolean,
+    ) {
+        source.setCluster(value)
+    }
+
+    @ReactProp(name = "clusterRadius")
+    override fun setClusterRadius(
+        source: MLRNGeoJSONSource,
+        value: Int,
+    ) {
+        source.setClusterRadius(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "clusterMinPoints")
+    override fun setClusterMinPoints(
+        source: MLRNGeoJSONSource,
+        value: Int,
+    ) {
+        source.setClusterMinPoints(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "clusterMaxZoom")
+    override fun setClusterMaxZoom(
+        source: MLRNGeoJSONSource,
+        value: Int,
+    ) {
+        source.setClusterMaxZoom(if (value != -1) value else null)
+    }
+
+    @ReactProp(name = "clusterProperties")
+    override fun setClusterProperties(
+        source: MLRNGeoJSONSource,
+        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)
+    }
+}