@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/java/io/github/mapvina/reactnative/components/mapview/MLRNMapViewManager.kt

@@ -0,0 +1,280 @@
+package io.github.mapvina.reactnative.components.mapview
+
+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.UiThreadUtil
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.LayoutShadowNode
+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.MLRNMapViewManagerDelegate
+import com.facebook.react.viewmanagers.MLRNMapViewManagerInterface
+
+@ReactModule(name = MLRNMapViewManager.REACT_CLASS)
+open class MLRNMapViewManager(
+    context: ReactApplicationContext,
+) : ViewGroupManager<MLRNMapView>(context),
+    MLRNMapViewManagerInterface<MLRNMapView> {
+    private val delegate: MLRNMapViewManagerDelegate<MLRNMapView, MLRNMapViewManager> =
+        MLRNMapViewManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<MLRNMapView> = delegate
+
+    companion object {
+        const val REACT_CLASS: String = "MLRNMapView"
+        const val LOG_TAG: String = "MLRNMapViewManager"
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    private val mViews: MutableMap<Int?, MLRNMapView?> = HashMap()
+
+    override fun createShadowNodeInstance(): LayoutShadowNode = MapShadowNode(this)
+
+    override fun getShadowNodeClass(): Class<out LayoutShadowNode?> = MapShadowNode::class.java
+
+    override fun onAfterUpdateTransaction(mapView: MLRNMapView) {
+        super.onAfterUpdateTransaction(mapView)
+
+        if (mapView.mapVinaMap == null) {
+            mViews.put(mapView.id, mapView)
+            mapView.init()
+        }
+    }
+
+    override fun addView(
+        parent: MLRNMapView,
+        child: View,
+        index: Int,
+    ) {
+        parent.addFeature(child, index)
+    }
+
+    override fun getChildCount(parent: MLRNMapView): Int = parent.featureCount
+
+    override fun getChildAt(
+        parent: MLRNMapView,
+        index: Int,
+    ): View? = parent.getFeatureAt(index).toView()
+
+    override fun removeViewAt(
+        parent: MLRNMapView,
+        index: Int,
+    ) {
+        parent.removeFeature(index)
+    }
+
+    override fun createViewInstance(themedReactContext: ThemedReactContext): MLRNMapView = MLRNMapView(themedReactContext, options = null)
+
+    override fun onDropViewInstance(mapView: MLRNMapView) {
+        val reactTag = mapView.id
+
+        if (mViews.containsKey(reactTag)) {
+            mViews.remove(reactTag)
+        }
+
+        mapView.dispose()
+
+        super.onDropViewInstance(mapView)
+    }
+
+    fun getByReactTag(reactTag: Int): MLRNMapView? = mViews[reactTag]
+
+    //region React Props
+
+    @ReactProp(name = "mapStyle")
+    override fun setMapStyle(
+        mapView: MLRNMapView,
+        value: String?,
+    ) {
+        mapView.setReactMapStyle(value)
+    }
+
+    @ReactProp(name = "light")
+    override fun setLight(
+        mapView: MLRNMapView,
+        value: Dynamic?,
+    ) {
+        mapView.setReactLight(value?.asMap())
+    }
+
+    @ReactProp(name = "contentInset")
+    override fun setContentInset(
+        mapView: MLRNMapView,
+        value: ReadableMap?,
+    ) {
+        mapView.setReactContentInset(value)
+    }
+
+    @ReactProp(name = "preferredFramesPerSecond")
+    override fun setPreferredFramesPerSecond(
+        mapView: MLRNMapView,
+        value: Int,
+    ) {
+        mapView.setReactPreferredFramesPerSecond(value)
+    }
+
+    @ReactProp(name = "dragPan")
+    override fun setDragPan(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactScrollEnabled(value)
+    }
+
+    @ReactProp(name = "touchZoom")
+    override fun setTouchZoom(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactTouchZoomEnabled(value)
+    }
+
+    @ReactProp(name = "doubleTapZoom")
+    override fun setDoubleTapZoom(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactDoubleTapZoomEnabled(value)
+    }
+
+    @ReactProp(name = "doubleTapHoldZoom")
+    override fun setDoubleTapHoldZoom(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactDoubleTapHoldZoomEnabled(value)
+    }
+
+    @ReactProp(name = "touchRotate")
+    override fun setTouchRotate(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactRotateEnabled(value)
+    }
+
+    @ReactProp(name = "touchPitch")
+    override fun setTouchPitch(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactPitchEnabled(value)
+    }
+
+    @ReactProp(name = "tintColor")
+    override fun setTintColor(
+        mapView: MLRNMapView,
+        value: Int?,
+    ) {
+        mapView.setReactTintColor(value)
+    }
+
+    @ReactProp(name = "attribution")
+    override fun setAttribution(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactAttribution(value)
+    }
+
+    @ReactProp(name = "attributionPosition")
+    override fun setAttributionPosition(
+        mapView: MLRNMapView,
+        value: ReadableMap?,
+    ) {
+        mapView.setReactAttributionPosition(value)
+    }
+
+    @ReactProp(name = "logo")
+    override fun setLogo(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactLogo(value)
+    }
+
+    @ReactProp(name = "logoPosition")
+    override fun setLogoPosition(
+        mapView: MLRNMapView,
+        value: ReadableMap?,
+    ) {
+        mapView.setReactLogoPosition(value)
+    }
+
+    @ReactProp(name = "compass")
+    override fun setCompass(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactCompass(value)
+    }
+
+    @ReactProp(name = "compassPosition")
+    override fun setCompassPosition(
+        mapView: MLRNMapView,
+        value: ReadableMap?,
+    ) {
+        mapView.setReactCompassPosition(value)
+    }
+
+    @ReactProp(name = "compassHiddenFacingNorth")
+    override fun setCompassHiddenFacingNorth(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+        mapView.setReactCompassHiddenFacingNorth(value)
+    }
+
+    @ReactProp(name = "scaleBar")
+    override fun setScaleBar(
+        mapView: MLRNMapView,
+        value: Boolean,
+    ) {
+    }
+
+    @ReactProp(name = "scaleBarPosition")
+    override fun setScaleBarPosition(
+        mapView: MLRNMapView,
+        value: ReadableMap?,
+    ) {
+    }
+
+    //endregion
+
+    private class MapShadowNode(
+        private val mViewManager: MLRNMapViewManager,
+    ) : LayoutShadowNode() {
+        override fun dispose() {
+            super.dispose()
+            disposeNativeMapView()
+        }
+
+        /**
+         * We need this mapview to dispose (calls into nativeMap.destroy) before ReactNative starts
+         * tearing down the views in onDropViewInstance.
+         */
+        fun disposeNativeMapView() {
+            val mapView = mViewManager.getByReactTag(reactTag)
+
+            if (mapView != null) {
+                UiThreadUtil.runOnUiThread {
+                    try {
+                        mapView.dispose()
+                    } catch (ex: Exception) {
+                        Log.e(
+                            LOG_TAG,
+                            " disposeNativeMapView() exception destroying map view",
+                            ex,
+                        )
+                    }
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/mapview/MLRNMapViewModule.kt

@@ -0,0 +1,202 @@
+package io.github.mapvina.reactnative.components.mapview
+
+import android.graphics.RectF
+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 io.github.mapvina.android.MapVina
+import io.github.mapvina.reactnative.NativeMapViewModuleSpec
+import io.github.mapvina.reactnative.utils.ConvertUtils
+import io.github.mapvina.reactnative.utils.ExpressionParser
+import io.github.mapvina.reactnative.utils.GeoJSONUtils
+import io.github.mapvina.reactnative.utils.ReactTag
+import io.github.mapvina.reactnative.utils.ReactTagResolver
+
+@ReactModule(name = NativeMapViewModuleSpec.NAME)
+class MLRNMapViewModule(
+    reactContext: ReactApplicationContext,
+    private val reactTagResolver: ReactTagResolver,
+) : NativeMapViewModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNMapViewModule"
+    }
+
+    override fun initialize() {
+        reactApplicationContext.runOnUiQueueThread {
+            MapVina.getInstance(reactApplicationContext.applicationContext)
+        }
+    }
+
+    private fun withViewportOnUIThread(
+        reactTag: ReactTag,
+        promise: Promise,
+        fn: (MLRNMapView) -> Unit,
+    ) {
+        reactTagResolver.withViewResolved(reactTag.toInt(), promise, fn)
+    }
+
+    override fun getCenter(
+        reactTag: Double,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getCenter())
+        }
+    }
+
+    override fun getZoom(
+        reactTag: Double,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getZoom())
+        }
+    }
+
+    override fun getBearing(
+        reactTag: Double,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getBearing())
+        }
+    }
+
+    override fun getPitch(
+        reactTag: Double,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getPitch())
+        }
+    }
+
+    override fun getBounds(
+        reactTag: Double,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getBounds())
+        }
+    }
+
+    override fun getViewState(
+        reactTag: Double,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            promise.resolve(it.getViewState())
+        }
+    }
+
+    override fun project(
+        reactTag: Double,
+        lngLat: ReadableArray,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) { mapView ->
+            promise.resolve(
+                mapView.project(
+                    GeoJSONUtils.toLatLng(lngLat)!!,
+                ),
+            )
+        }
+    }
+
+    override fun unproject(
+        reactTag: Double,
+        pixelPoint: ReadableArray,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) { mapView ->
+            promise.resolve(mapView.unproject(ConvertUtils.toPointF(pixelPoint)))
+        }
+    }
+
+    override fun queryRenderedFeaturesWithPoint(
+        reactTag: Double,
+        pixelPoint: ReadableArray,
+        layers: ReadableArray?,
+        filter: ReadableArray?,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) { mapView ->
+            promise.resolve(
+                mapView.queryRenderedFeaturesWithPoint(
+                    ConvertUtils.toPointF(pixelPoint),
+                    layers,
+                    ExpressionParser.from(filter),
+                ),
+            )
+        }
+    }
+
+    override fun queryRenderedFeaturesWithBounds(
+        reactTag: Double,
+        pixelPointBounds: ReadableArray?,
+        layers: ReadableArray?,
+        filter: ReadableArray?,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) { mapView ->
+            val rect =
+                if (pixelPointBounds == null) {
+                    null
+                } else {
+                    val topLeft = pixelPointBounds.getArray(0)
+                    val bottomRight = pixelPointBounds.getArray(1)
+
+                    RectF(
+                        topLeft!!.getDouble(0).toFloat(),
+                        topLeft.getDouble(1).toFloat(),
+                        bottomRight!!.getDouble(0).toFloat(),
+                        bottomRight.getDouble(1).toFloat(),
+                    )
+                }
+
+            promise.resolve(
+                mapView.queryRenderedFeaturesWithRect(
+                    rect,
+                    layers,
+                    ExpressionParser.from(filter),
+                ),
+            )
+        }
+    }
+
+    override fun setSourceVisibility(
+        reactTag: Double,
+        visible: Boolean,
+        sourceId: String,
+        sourceLayerId: String?,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            it.setSourceVisibility(visible, sourceId, sourceLayerId)
+            promise.resolve(null)
+        }
+    }
+
+    override fun createStaticMapImage(
+        reactTag: Double,
+        output: String,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            it.takeSnap(output == "file") { payload ->
+                promise.resolve(payload)
+            }
+        }
+    }
+
+    override fun showAttribution(
+        reactTag: Double,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            it.showAttribution()
+            promise.resolve(null)
+        }
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/mapview/helpers/CameraChangeTracker.kt

@@ -0,0 +1,26 @@
+package io.github.mapvina.reactnative.components.mapview.helpers
+
+class CameraChangeTracker {
+    private var reason: Int = EMPTY
+    var isAnimating: Boolean = false
+
+    fun setReason(reason: Int) {
+        this.reason = reason
+    }
+
+    val isUserInteraction: Boolean
+        get() = reason == USER_GESTURE || reason == DEVELOPER_ANIMATION
+
+    val isAnimated: Boolean
+        get() = reason == DEVELOPER_ANIMATION || reason == SDK_ANIMATION
+
+    val isEmpty: Boolean
+        get() = reason == EMPTY
+
+    companion object {
+        const val EMPTY: Int = -1
+        const val USER_GESTURE: Int = 1
+        const val DEVELOPER_ANIMATION: Int = 2
+        const val SDK_ANIMATION: Int = 3
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/mapview/helpers/LayerSourceInfo.kt

@@ -0,0 +1,76 @@
+package io.github.mapvina.reactnative.components.mapview.helpers
+
+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.RasterLayer
+import io.github.mapvina.android.style.layers.SymbolLayer
+
+internal class LayerSourceInfo(
+    layer: Layer?,
+) {
+    val sourceId: String
+
+    val sourceLayerId: String?
+
+    init {
+        when (layer) {
+            is CircleLayer -> {
+                val symbolLayer = layer
+                sourceId = symbolLayer.getSourceId()
+                sourceLayerId = symbolLayer.getSourceLayer()
+            }
+
+            is FillExtrusionLayer -> {
+                val fillExtrusionLayer = layer
+                sourceId = fillExtrusionLayer.getSourceId()
+                sourceLayerId = fillExtrusionLayer.getSourceLayer()
+            }
+
+            is FillLayer -> {
+                val fillLayer = layer
+                sourceId = fillLayer.getSourceId()
+                sourceLayerId = fillLayer.getSourceLayer()
+            }
+
+            is HeatmapLayer -> {
+                val heatmapLayer = layer
+                sourceId = heatmapLayer.getSourceId()
+                sourceLayerId = heatmapLayer.getSourceLayer()
+            }
+
+            is HillshadeLayer -> {
+                val hillshadeLayer = layer
+                sourceId = hillshadeLayer.getSourceId()
+                sourceLayerId = null
+            }
+
+            is LineLayer -> {
+                val lineLayer = layer
+                sourceId = lineLayer.getSourceId()
+                sourceLayerId = lineLayer.getSourceLayer()
+            }
+
+            is RasterLayer -> {
+                val rasterLayer = layer
+                sourceId = rasterLayer.getSourceId()
+                sourceLayerId = null
+            }
+
+            is SymbolLayer -> {
+                val symbolLayer = layer
+                sourceId = symbolLayer.getSourceId()
+                sourceLayerId = symbolLayer.getSourceLayer()
+            }
+
+            else -> {
+                sourceId = ""
+                sourceLayerId = null
+            }
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+package io.github.mapvina.reactnative.components.sources
+
+import android.content.Context
+import android.graphics.PointF
+import android.graphics.RectF
+import com.facebook.react.bridge.ReadableMap
+import io.github.mapvina.android.geometry.LatLng
+import io.github.mapvina.android.style.sources.Source
+import io.github.mapvina.geojson.Feature
+import io.github.mapvina.reactnative.events.MapPressEventWithFeatures
+
+abstract class MLRNPressableSource<T : Source?>(
+    context: Context?,
+) : MLRNSource<T>(context) {
+    var hasOnPress: Boolean = false
+
+    var hitbox: RectF? = null
+        get() {
+            if (!hasOnPress) {
+                return null
+            }
+            return field ?: DEFAULT_HITBOX
+        }
+
+    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
+            }
+    }
+
+    fun onPress(
+        features: MutableList<Feature>,
+        latLng: LatLng,
+        screenPoint: PointF,
+    ) {
+        eventDispatcher?.dispatchEvent(
+            MapPressEventWithFeatures(
+                surfaceId,
+                id,
+                "onPress",
+                latLng,
+                screenPoint,
+                features,
+            ),
+        )
+    }
+
+    companion object {
+        const val LOG_TAG: String = "MLRNPressableSource"
+
+        val DEFAULT_HITBOX: RectF = RectF(22.0f, 22.0f, 22.0f, 22.0f)
+    }
+}