@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/java/io/github/mapvina/reactnative/components/images/MLRNImages.kt

@@ -0,0 +1,172 @@
+package io.github.mapvina.reactnative.components.images
+
+import android.content.Context
+import android.graphics.Bitmap
+import androidx.core.content.res.ResourcesCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.EventDispatcher
+import io.github.mapvina.android.maps.MapVinaMap
+import io.github.mapvina.android.utils.BitmapUtils
+import io.github.mapvina.reactnative.R
+import io.github.mapvina.reactnative.components.AbstractMapFeature
+import io.github.mapvina.reactnative.components.mapview.MLRNMapView
+import io.github.mapvina.reactnative.utils.DownloadMapImageTask
+import io.github.mapvina.reactnative.utils.ImageEntry
+
+class MLRNImages(
+    context: Context,
+) : AbstractMapFeature(context) {
+    companion object {
+        private var imagePlaceholder: Bitmap? = null
+    }
+
+    private val currentImages = mutableSetOf<String>()
+    private val images = mutableMapOf<String, ImageEntry>()
+    private var map: MapVinaMap? = null
+
+    init {
+        if (imagePlaceholder == null) {
+            imagePlaceholder =
+                BitmapUtils.getBitmapFromDrawable(
+                    ResourcesCompat.getDrawable(context.resources, R.drawable.empty_drawable, null),
+                )
+        }
+    }
+
+    /**
+     * Set unified images.
+     * ImageEntry.uri can be:
+     * - A native asset name (simple name like "pin")
+     * - A URL (starts with http/https/file/asset/data or /)
+     */
+    fun setImages(
+        imagesList: List<Map.Entry<String, ImageEntry>>,
+        context: Context,
+    ) {
+        val newImages = mutableMapOf<String, ImageEntry>()
+
+        for (entry in imagesList) {
+            val key = entry.key
+            val value = entry.value
+            val oldValue = images.put(key, value)
+            if (oldValue == null) {
+                newImages[key] = value
+            }
+        }
+
+        map?.let { mapInstance ->
+            if (mapInstance.style != null) {
+                processImages(newImages, mapInstance, context)
+            }
+        }
+    }
+
+    override fun removeFromMap(mapView: MLRNMapView) {
+        removeImages(mapView)
+        map = null
+        images.clear()
+        currentImages.clear()
+    }
+
+    private fun removeImages(mapView: MLRNMapView) {
+        mapView.getStyle { style ->
+            for (imageName in images.keys) {
+                style.removeImage(imageName)
+            }
+        }
+    }
+
+    override fun addToMap(mapView: MLRNMapView) {
+        // Wait for style before adding the source to the map.
+        // Only then we can pre-load required images/placeholders into the style.
+        mapView.getStyle { _ ->
+            val mapInstance = mapView.mapVinaMap
+            map = mapInstance
+            map?.let {
+                processImages(images, it, context)
+            }
+        }
+    }
+
+    private fun processImages(
+        imagesToProcess: Map<String, ImageEntry>,
+        mapInstance: MapVinaMap,
+        context: Context,
+    ) {
+        if (imagesToProcess.isEmpty()) return
+
+        val style = mapInstance.style ?: return
+        val remoteImages = mutableListOf<Map.Entry<String, ImageEntry>>()
+
+        for ((imageName, entry) in imagesToProcess) {
+            if (hasImage(imageName, mapInstance)) continue
+
+            style.addImage(imageName, imagePlaceholder!!)
+            remoteImages.add(java.util.AbstractMap.SimpleEntry(imageName, entry))
+            currentImages.add(imageName)
+        }
+
+        // Download remote images asynchronously
+        if (remoteImages.isNotEmpty()) {
+            val task = DownloadMapImageTask(context, mapInstance, null)
+            task.execute(*remoteImages.toTypedArray())
+        }
+    }
+
+    fun addMissingImageToStyle(
+        id: String,
+        mapInstance: MapVinaMap,
+    ): Boolean {
+        val entry = images[id] ?: return false
+        val style = mapInstance.style ?: return false
+
+        style.addImage(id, imagePlaceholder!!)
+        val task = DownloadMapImageTask(context, mapInstance, null)
+        task.execute(java.util.AbstractMap.SimpleEntry(id, entry))
+
+        currentImages.add(id)
+        return true
+    }
+
+    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)
+        }
+
+    inner class OnImageMissingEvent(
+        private val eventData: WritableMap,
+    ) : Event<OnImageMissingEvent>(this@MLRNImages.surfaceId, this@MLRNImages.id) {
+        override fun getEventName() = "onImageMissing"
+
+        override fun getEventData() = eventData
+    }
+
+    fun sendImageMissingEvent(image: String) {
+        val writableMap = Arguments.createMap()
+        writableMap.putString("image", image)
+
+        eventDispatcher?.dispatchEvent(OnImageMissingEvent(writableMap))
+    }
+
+    private fun hasImage(
+        imageId: String,
+        mapInstance: MapVinaMap,
+    ): Boolean {
+        val style = mapInstance.style
+
+        return style?.getImage(imageId) != null
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/images/MLRNImagesManager.kt

@@ -0,0 +1,73 @@
+package io.github.mapvina.reactnative.components.images
+
+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.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.MLRNImagesManagerDelegate
+import com.facebook.react.viewmanagers.MLRNImagesManagerInterface
+import io.github.mapvina.reactnative.utils.ImageEntry
+
+@ReactModule(name = MLRNImagesManager.REACT_CLASS)
+class MLRNImagesManager(
+    private val context: ReactApplicationContext,
+) : ViewGroupManager<MLRNImages>(),
+    MLRNImagesManagerInterface<MLRNImages> {
+    companion object {
+        const val REACT_CLASS = "MLRNImages"
+    }
+
+    private val delegate: MLRNImagesManagerDelegate<MLRNImages, MLRNImagesManager> =
+        MLRNImagesManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<MLRNImages> = delegate
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): MLRNImages = MLRNImages(context)
+
+    @ReactProp(name = "images")
+    override fun setImages(
+        view: MLRNImages,
+        value: Dynamic,
+    ) {
+        val readableMap = value.asMap()
+
+        if (readableMap == null) {
+            view.setImages(emptyList(), context)
+            return
+        }
+
+        val imagesList = mutableListOf<Map.Entry<String, ImageEntry>>()
+        val iterator = readableMap.keySetIterator()
+
+        while (iterator.hasNextKey()) {
+            val imageName = iterator.nextKey()
+            val imageEntry: ImageEntry =
+                when (readableMap.getType(imageName)) {
+                    ReadableType.Map -> {
+                        val imageMap = readableMap.getMap(imageName)!!
+
+                        val uri = imageMap.getString("uri")
+                        val scale =
+                            if (imageMap.hasKey("scale")) imageMap.getDouble("scale") else null
+                        val sdf = imageMap.hasKey("sdf") && imageMap.getBoolean("sdf")
+
+                        ImageEntry(uri, scale, sdf)
+                    }
+
+                    else -> {
+                        continue
+                    }
+                }
+
+            imagesList.add(java.util.AbstractMap.SimpleEntry(imageName, imageEntry))
+        }
+
+        view.setImages(imagesList, context)
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/layer/MLRNLayer.kt

@@ -0,0 +1,370 @@
+package io.github.mapvina.reactnative.components.layer
+
+import android.content.Context
+import com.facebook.common.logging.FLog
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import io.github.mapvina.android.location.LocationComponentConstants
+import io.github.mapvina.android.maps.MapVinaMap
+import io.github.mapvina.android.maps.Style
+import io.github.mapvina.android.style.expressions.Expression
+import io.github.mapvina.android.style.layers.BackgroundLayer
+import io.github.mapvina.android.style.layers.CircleLayer
+import io.github.mapvina.android.style.layers.FillExtrusionLayer
+import io.github.mapvina.android.style.layers.FillLayer
+import io.github.mapvina.android.style.layers.HeatmapLayer
+import io.github.mapvina.android.style.layers.HillshadeLayer
+import io.github.mapvina.android.style.layers.Layer
+import io.github.mapvina.android.style.layers.LineLayer
+import io.github.mapvina.android.style.layers.Property
+import io.github.mapvina.android.style.layers.PropertyFactory
+import io.github.mapvina.android.style.layers.RasterLayer
+import io.github.mapvina.android.style.layers.SymbolLayer
+import io.github.mapvina.reactnative.components.AbstractMapFeature
+import io.github.mapvina.reactnative.components.layer.style.MLRNStyle
+import io.github.mapvina.reactnative.components.layer.style.MLRNStyleFactory
+import io.github.mapvina.reactnative.components.mapview.MLRNMapView
+import io.github.mapvina.reactnative.components.mapview.MLRNMapView.FoundLayerCallback
+import io.github.mapvina.reactnative.utils.ExpressionParser.from
+
+class MLRNLayer(
+    context: Context?,
+) : AbstractMapFeature(context) {
+    private var mID: String? = null
+    private var mSourceID: String? = null
+    private var mAboveLayerID: String? = null
+    private var mBelowLayerID: String? = null
+    private var mLayerIndex: Int? = null
+    private var mVisible: Boolean = false
+    private var mMinZoomLevel: Double? = null
+    private var mMaxZoomLevel: Double? = null
+    private var mReactStyle: ReadableMap? = null
+    private var mFilter: Expression? = null
+    private var mHadFilter: Boolean = false
+
+    private var mLayerType: String? = null
+    private var mSourceLayerID: String? = null
+
+    private var mMap: MapVinaMap? = null
+    private var mLayer: Layer? = null
+    private var mMapView: MLRNMapView? = null
+
+    var ID: String
+        get() = mID!!
+        set(id) {
+            mID = id
+        }
+
+    fun setSourceID(sourceID: String?) {
+        mSourceID = sourceID
+    }
+
+    fun setLayerType(layerType: String?) {
+        mLayerType = layerType
+    }
+
+    fun setSourceLayerID(sourceLayerID: String?) {
+        mSourceLayerID = sourceLayerID
+        if (mLayer != null) {
+            applySourceLayer()
+        }
+    }
+
+    fun setAboveLayerID(aboveLayerID: String?) {
+        if (mAboveLayerID != null && mAboveLayerID == aboveLayerID) {
+            return
+        }
+        mAboveLayerID = aboveLayerID
+        if (mLayer != null) {
+            removeFromMap(mMapView!!)
+            addAbove(mAboveLayerID!!)
+        }
+    }
+
+    fun setBelowLayerID(belowLayerID: String?) {
+        if (mBelowLayerID != null && mBelowLayerID == belowLayerID) {
+            return
+        }
+        mBelowLayerID = belowLayerID
+        if (mLayer != null) {
+            removeFromMap(mMapView!!)
+            addBelow(mBelowLayerID!!)
+        }
+    }
+
+    fun setLayerIndex(layerIndex: Int) {
+        if (mLayerIndex != null && mLayerIndex == layerIndex) {
+            return
+        }
+        mLayerIndex = layerIndex
+        if (mLayer != null) {
+            removeFromMap(mMapView!!)
+            addAtIndex(mLayerIndex!!)
+        }
+    }
+
+    fun setVisible(visible: Boolean) {
+        mVisible = visible
+        if (mLayer != null) {
+            val visibility = if (mVisible) Property.VISIBLE else Property.NONE
+            mLayer!!.setProperties(PropertyFactory.visibility(visibility))
+        }
+    }
+
+    fun setMinZoomLevel(minZoomLevel: Double) {
+        mMinZoomLevel = minZoomLevel
+        if (mLayer != null) {
+            mLayer!!.setMinZoom(minZoomLevel.toFloat())
+        }
+    }
+
+    fun setMaxZoomLevel(maxZoomLevel: Double) {
+        mMaxZoomLevel = maxZoomLevel
+        if (mLayer != null) {
+            mLayer!!.setMaxZoom(maxZoomLevel.toFloat())
+        }
+    }
+
+    fun setReactStyle(reactStyle: ReadableMap?) {
+        mReactStyle = reactStyle
+        if (mLayer != null) {
+            addStyles()
+        }
+    }
+
+    fun setFilter(readableFilterArray: ReadableArray?) {
+        val filterExpression = from(readableFilterArray)
+        mFilter = filterExpression
+        if (mLayer != null) {
+            if (mFilter != null) {
+                mHadFilter = true
+                updateFilter(mFilter)
+            } else if (mHadFilter) {
+                updateFilter(Expression.literal(true))
+            }
+        }
+    }
+
+    private fun makeLayer(): Layer? =
+        when (mLayerType) {
+            "background" -> {
+                BackgroundLayer(mID)
+            }
+
+            "circle" -> {
+                val layer = CircleLayer(mID, mSourceID)
+                if (mSourceLayerID != null) layer.setSourceLayer(mSourceLayerID)
+                layer
+            }
+
+            "fill" -> {
+                val layer = FillLayer(mID, mSourceID)
+                if (mSourceLayerID != null) layer.setSourceLayer(mSourceLayerID)
+                layer
+            }
+
+            "fill-extrusion" -> {
+                val layer = FillExtrusionLayer(mID, mSourceID)
+                if (mSourceLayerID != null) layer.setSourceLayer(mSourceLayerID)
+                layer
+            }
+
+            "heatmap" -> {
+                val layer = HeatmapLayer(mID, mSourceID)
+                if (mSourceLayerID != null) layer.setSourceLayer(mSourceLayerID)
+                layer
+            }
+
+            "hillshade" -> {
+                val layer = HillshadeLayer(mID, mSourceID)
+                if (mSourceLayerID != null) layer.setSourceLayer(mSourceLayerID)
+                layer
+            }
+
+            "line" -> {
+                val layer = LineLayer(mID, mSourceID)
+                if (mSourceLayerID != null) layer.setSourceLayer(mSourceLayerID)
+                layer
+            }
+
+            "raster" -> {
+                RasterLayer(mID, mSourceID)
+            }
+
+            "symbol" -> {
+                val layer = SymbolLayer(mID, mSourceID)
+                if (mSourceLayerID != null) layer.setSourceLayer(mSourceLayerID)
+                layer
+            }
+
+            else -> {
+                FLog.e(LOG_TAG, "Unknown layer type: $mLayerType")
+                null
+            }
+        }
+
+    private fun addStyles() {
+        val reactStyle = mReactStyle ?: return
+        val map = mMap ?: return
+        val style = MLRNStyle(context, reactStyle, map)
+        when (mLayer) {
+            is BackgroundLayer -> MLRNStyleFactory.setBackgroundLayerStyle(mLayer as BackgroundLayer, style)
+            is CircleLayer -> MLRNStyleFactory.setCircleLayerStyle(mLayer as CircleLayer, style)
+            is FillLayer -> MLRNStyleFactory.setFillLayerStyle(mLayer as FillLayer, style)
+            is FillExtrusionLayer -> MLRNStyleFactory.setFillExtrusionLayerStyle(mLayer as FillExtrusionLayer, style)
+            is HeatmapLayer -> MLRNStyleFactory.setHeatmapLayerStyle(mLayer as HeatmapLayer, style)
+            is HillshadeLayer -> MLRNStyleFactory.setHillshadeLayerStyle(mLayer as HillshadeLayer, style)
+            is LineLayer -> MLRNStyleFactory.setLineLayerStyle(mLayer as LineLayer, style)
+            is RasterLayer -> MLRNStyleFactory.setRasterLayerStyle(mLayer as RasterLayer, style)
+            is SymbolLayer -> MLRNStyleFactory.setSymbolLayerStyle(mLayer as SymbolLayer, style)
+        }
+    }
+
+    private fun updateFilter(expression: Expression?) {
+        when (mLayer) {
+            is CircleLayer -> (mLayer as CircleLayer).setFilter(expression!!)
+            is FillLayer -> (mLayer as FillLayer).setFilter(expression!!)
+            is FillExtrusionLayer -> (mLayer as FillExtrusionLayer).setFilter(expression!!)
+            is HeatmapLayer -> (mLayer as HeatmapLayer).setFilter(expression!!)
+            is LineLayer -> (mLayer as LineLayer).setFilter(expression!!)
+            is SymbolLayer -> (mLayer as SymbolLayer).setFilter(expression!!)
+        }
+    }
+
+    private fun applySourceLayer() {
+        when (mLayer) {
+            is CircleLayer -> (mLayer as CircleLayer).setSourceLayer(mSourceLayerID)
+            is FillLayer -> (mLayer as FillLayer).setSourceLayer(mSourceLayerID)
+            is FillExtrusionLayer -> (mLayer as FillExtrusionLayer).setSourceLayer(mSourceLayerID)
+            is HeatmapLayer -> (mLayer as HeatmapLayer).setSourceLayer(mSourceLayerID)
+            is HillshadeLayer -> (mLayer as HillshadeLayer).setSourceLayer(mSourceLayerID)
+            is LineLayer -> (mLayer as LineLayer).setSourceLayer(mSourceLayerID)
+            is SymbolLayer -> (mLayer as SymbolLayer).setSourceLayer(mSourceLayerID)
+        }
+    }
+
+    private fun add() {
+        if (!hasInitialized()) return
+        val style = this.style ?: return
+
+        val userBackgroundID = LocationComponentConstants.BACKGROUND_LAYER
+        val userLocationBackgroundLayer = style.getLayer(userBackgroundID)
+
+        val layer = mLayer ?: return
+
+        if (userLocationBackgroundLayer != null) {
+            style.addLayerBelow(layer, userBackgroundID)
+            mMapView!!.layerAdded(layer)
+            return
+        }
+
+        style.addLayer(layer)
+        mMapView!!.layerAdded(layer)
+    }
+
+    private fun addAbove(aboveLayerID: String) {
+        mMapView!!.waitForLayer(
+            aboveLayerID,
+            object : FoundLayerCallback {
+                override fun found(layer: Layer?) {
+                    if (!hasInitialized()) return
+                    val style = this@MLRNLayer.style ?: return
+                    val l = mLayer ?: return
+                    style.addLayerAbove(l, aboveLayerID)
+                    mMapView!!.layerAdded(l)
+                }
+            },
+        )
+    }
+
+    private fun addBelow(belowLayerID: String) {
+        mMapView!!.waitForLayer(
+            belowLayerID,
+            object : FoundLayerCallback {
+                override fun found(layer: Layer?) {
+                    if (!hasInitialized()) return
+                    val style = this@MLRNLayer.style ?: return
+                    val l = mLayer ?: return
+                    style.addLayerBelow(l, belowLayerID)
+                    mMapView!!.layerAdded(l)
+                }
+            },
+        )
+    }
+
+    private fun addAtIndex(index: Int) {
+        var idx = index
+        if (!hasInitialized()) return
+        val style = this.style ?: return
+        val l = mLayer ?: return
+        val layerSize = style.getLayers().size
+        if (idx >= layerSize) {
+            FLog.e(LOG_TAG, "Layer index is greater than number of layers on map. Layer inserted at end of layer stack.")
+            idx = layerSize - 1
+        }
+        style.addLayerAt(l, idx)
+        mMapView!!.layerAdded(l)
+    }
+
+    private fun insertLayer() {
+        val style = this.style ?: return
+        val id = mID ?: return
+        if (style.getLayer(id) != null) return
+
+        if (mAboveLayerID != null) {
+            addAbove(mAboveLayerID!!)
+        } else if (mBelowLayerID != null) {
+            addBelow(mBelowLayerID!!)
+        } else if (mLayerIndex != null) {
+            addAtIndex(mLayerIndex!!)
+        } else {
+            add()
+        }
+
+        setZoomBounds()
+    }
+
+    private fun setZoomBounds() {
+        if (mMaxZoomLevel != null) {
+            mLayer!!.setMaxZoom(mMaxZoomLevel!!.toFloat())
+        }
+        if (mMinZoomLevel != null) {
+            mLayer!!.setMinZoom(mMinZoomLevel!!.toFloat())
+        }
+    }
+
+    override fun addToMap(mapView: MLRNMapView) {
+        mMap = mapView.mapVinaMap
+        mMapView = mapView
+
+        val style = this.style ?: return
+
+        val existingLayer = style.getLayer(mID!!)
+        if (existingLayer != null) {
+            mLayer = existingLayer
+        } else {
+            mLayer = makeLayer()
+            insertLayer()
+        }
+
+        addStyles()
+        if (mFilter != null) {
+            mHadFilter = true
+            updateFilter(mFilter)
+        }
+    }
+
+    override fun removeFromMap(mapView: MLRNMapView) {
+        val layer = mLayer ?: return
+        this.style?.removeLayer(layer)
+    }
+
+    private val style: Style?
+        get() = mMap?.style
+
+    private fun hasInitialized(): Boolean = mMap != null && mLayer != null
+
+    companion object {
+        const val LOG_TAG: String = "MLRNLayer"
+    }
+}