@mapvina-com/mapvina-react-native 1.0.0

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

@@ -0,0 +1,159 @@
+package io.github.mapvina.reactnative.components.layer.style
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableNativeMap
+import io.github.mapvina.android.style.expressions.Expression
+import io.github.mapvina.android.style.layers.TransitionOptions
+import io.github.mapvina.reactnative.utils.ExpressionParser.fromTyped
+import io.github.mapvina.reactnative.utils.ImageEntry
+
+class MLRNStyleValue(
+    config: ReadableMap,
+) {
+    var type: String?
+        private set
+    private var isExpression = false
+    private var mExpression: Expression? = null
+    private var mPayload: ReadableMap?
+
+    var imageURI: String? = null
+        private set
+    private var isAddImage = false
+    var imageScale: Double = ImageEntry.DEFAULT_SCALE
+        private set
+
+    init {
+        this.type = config.getString("styletype")
+        mPayload = config.getMap("stylevalue")
+
+        if ("image" == this.type) {
+            imageScale = ImageEntry.DEFAULT_SCALE
+            if ("hashmap" == mPayload!!.getString("type")) {
+                val map = this.map
+                imageURI = map.getMap("uri")!!.getString("value")
+                if (map.getMap("scale") != null) {
+                    imageScale = map.getMap("scale")!!.getDouble("value")
+                }
+            } else if ("string" == mPayload!!.getString("type")) {
+                val value = mPayload!!.getString("value")
+                if (value!!.contains("://")) {
+                    imageURI = value
+                } else {
+                    imageURI = null
+                    isExpression = true
+                    mExpression = Expression.literal(value)
+                }
+            }
+
+            isAddImage = imageURI != null
+        }
+
+        if (!isAddImage) {
+            val dynamic = mPayload!!.getDynamic("value")
+            if (dynamic.type == ReadableType.Array) {
+                val array = dynamic.asArray()
+                if (array!!.size() > 0 && mPayload!!.getString("type") == "array") {
+                    val map = array.getMap(0)
+                    if (map != null && map.getString("type") == "string") {
+                        isExpression = true
+                        mExpression = fromTyped(mPayload)
+                    }
+                }
+            }
+        }
+    }
+
+    fun getInt(key: String): Int = mPayload!!.getInt(key)
+
+    fun getString(key: String): String = mPayload!!.getString(key)!!
+
+    fun getDouble(key: String): Double = mPayload!!.getDouble(key)
+
+    fun getFloat(key: String): Float = getDouble(key).toFloat()
+
+    fun getDynamic(key: String): Dynamic = mPayload!!.getDynamic(key)
+
+    fun getArray(key: String): ReadableArray? = mPayload!!.getArray(key)
+
+    fun getBoolean(key: String): Boolean = mPayload!!.getBoolean(key)
+
+    fun getFloatArray(key: String): Array<Float?> {
+        val arr = getArray(key)
+
+        val floatArr = arrayOfNulls<Float>(arr!!.size())
+        for (i in 0..<arr.size()) {
+            val item = arr.getMap(i)
+            floatArr[i] = item!!.getDouble("value").toFloat()
+        }
+
+        return floatArr
+    }
+
+    fun getStringArray(key: String): Array<String?> {
+        val arr = getArray(key)
+
+        val stringArr = arrayOfNulls<String>(arr!!.size())
+        for (i in 0..<arr.size()) {
+            val item = arr.getMap(i)
+            stringArr[i] = item!!.getString("value")
+        }
+
+        return stringArr
+    }
+
+    val map: ReadableMap
+        get() {
+            val result = WritableNativeMap()
+
+            if ("hashmap" == mPayload!!.getString("type")) {
+                val keyValues = mPayload!!.getArray("value")
+                for (i in 0..<keyValues!!.size()) {
+                    val keyValue = keyValues.getArray(i)
+                    val stringKey = keyValue!!.getMap(0)!!.getString("value")
+                    val value = WritableNativeMap()
+                    value.merge(keyValue.getMap(1)!!)
+                    result.putMap(stringKey!!, value)
+                }
+            }
+
+            return result
+        }
+
+    fun getExpression(): Expression? = mExpression
+
+    fun isExpression(): Boolean = isExpression
+
+    fun shouldAddImage(): Boolean = isAddImage
+
+    val isImageStringValue: Boolean
+        get() = "string" == mPayload!!.getString("type")
+
+    fun getImageStringValue(): String? = mPayload!!.getString("value")
+
+    val transition: TransitionOptions?
+        get() {
+            if (this.type != "transition") {
+                return null
+            }
+            val config = this.map
+
+            var enablePlacementTransitions = true
+            if (config.hasKey("enablePlacementTransitions")) {
+                enablePlacementTransitions =
+                    config.getMap("enablePlacementTransitions")!!.getBoolean("value")
+            }
+            var duration = 300
+            var delay = 0
+            if (config.hasKey("duration") && ReadableType.Map == config.getType("duration")) {
+                duration = config.getMap("duration")!!.getInt("value")
+            }
+            if (config.hasKey("delay") && ReadableType.Map == config.getType("delay")) {
+                delay = config.getMap("delay")!!.getInt("value")
+            }
+
+            return TransitionOptions(duration.toLong(), delay.toLong(), enablePlacementTransitions)
+        }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/location/LocationComponentManager.kt

@@ -0,0 +1,174 @@
+package io.github.mapvina.reactnative.components.location
+
+import android.annotation.SuppressLint
+import android.content.Context
+import io.github.mapvina.android.location.LocationComponent
+import io.github.mapvina.android.location.LocationComponentActivationOptions
+import io.github.mapvina.android.location.LocationComponentOptions
+import io.github.mapvina.android.location.OnCameraTrackingChangedListener
+import io.github.mapvina.android.location.modes.CameraMode
+import io.github.mapvina.android.location.modes.RenderMode
+import io.github.mapvina.android.maps.MapVinaMap
+import io.github.mapvina.android.maps.Style
+import io.github.mapvina.reactnative.R
+import io.github.mapvina.reactnative.components.mapview.MLRNMapView
+import io.github.mapvina.reactnative.location.LocationManager
+
+/**
+ * The LocationComponent on android implements both location tracking and display of user's current location.
+ * LocationComponentManager attempts to separate that, so that Camera can ask for location tracking independent of display of user current location.
+ * And NativeUserLocation can ask for display of user's current location - independent of Camera's user tracking.
+ */
+class LocationComponentManager(
+    mapView: MLRNMapView?,
+    private val context: Context,
+) {
+    private var mMapView: MLRNMapView? = null
+    private var mMap: MapVinaMap? = null
+
+    private var mLocationManager: LocationManager? = null
+    private var mLocationComponent: LocationComponent? = null
+
+    @RenderMode.Mode
+    private var mRenderMode: Int = RenderMode.COMPASS
+
+    private var mShowUserLocation = false
+
+    private var mFollowUserLocation = false
+
+    private var mShowingUserLocation = false
+
+    private var mOnCameraTrackingChangedListener: OnCameraTrackingChangedListener? = null
+
+    init {
+        mMapView = mapView
+        mMap = mMapView?.mapVinaMap
+
+        mLocationManager = LocationManager.getInstance(context)
+    }
+
+    fun showUserLocation(showUserLocation: Boolean) {
+        mShowUserLocation = showUserLocation
+        stateChanged()
+    }
+
+    fun setFollowUserLocation(followUserLocation: Boolean) {
+        mFollowUserLocation = followUserLocation
+        stateChanged()
+    }
+
+    fun setCameraMode(
+        @CameraMode.Mode cameraMode: Int,
+    ) {
+        mLocationComponent?.cameraMode = cameraMode
+    }
+
+    fun setRenderMode(
+        @RenderMode.Mode renderMode: Int,
+    ) {
+        mRenderMode = renderMode
+        if (mShowingUserLocation) {
+            mLocationComponent?.renderMode = renderMode
+        }
+    }
+
+    fun setPreferredFramesPerSecond(preferredFramesPerSecond: Int) {
+        if (preferredFramesPerSecond <= 0) {
+            return
+        }
+
+        mLocationComponent?.setMaxAnimationFps(preferredFramesPerSecond)
+    }
+
+    fun addOnCameraTrackingChangedListener(onCameraTrackingChangedListener: OnCameraTrackingChangedListener?) {
+        mOnCameraTrackingChangedListener?.let {
+            mLocationComponent?.removeOnCameraTrackingChangedListener(
+                it,
+            )
+        }
+
+        mOnCameraTrackingChangedListener = onCameraTrackingChangedListener
+
+        mOnCameraTrackingChangedListener?.let { mLocationComponent?.addOnCameraTrackingChangedListener(it) }
+    }
+
+    @SuppressLint("MissingPermission")
+    private fun stateChanged() {
+        mLocationComponent?.setLocationComponentEnabled((mFollowUserLocation || mShowUserLocation))
+
+        if (mShowingUserLocation != mShowUserLocation) {
+            updateShowUserLocation(mShowUserLocation)
+        }
+
+        if (mFollowUserLocation) {
+            if (!mShowUserLocation) {
+                mLocationComponent?.renderMode = RenderMode.GPS
+            } else {
+                mLocationComponent?.renderMode = mRenderMode
+            }
+            mLocationComponent?.onStart()
+        } else {
+            mLocationComponent?.cameraMode = CameraMode.NONE
+        }
+    }
+
+    fun hasLocationComponent(): Boolean = (mLocationComponent != null)
+
+    fun update(style: Style) {
+        update(mShowUserLocation, style)
+    }
+
+    fun update(
+        displayUserLocation: Boolean,
+        style: Style,
+    ) {
+        val tintColor = mMapView?.tintColor
+
+        if (mLocationComponent == null || tintColor != null) {
+            mLocationComponent = mMap?.locationComponent
+
+            val locationComponentActivationOptions: LocationComponentActivationOptions =
+                LocationComponentActivationOptions
+                    .builder(context, style)
+                    .locationComponentOptions(options(displayUserLocation))
+                    .build()
+            mLocationComponent?.activateLocationComponent(locationComponentActivationOptions)
+            mLocationComponent?.locationEngine = mLocationManager!!.engine
+            mShowingUserLocation = displayUserLocation
+        }
+
+        updateShowUserLocation(displayUserLocation)
+    }
+
+    private fun updateShowUserLocation(displayUserLocation: Boolean) {
+        if (mShowingUserLocation != displayUserLocation) {
+            mLocationComponent?.applyStyle(options(displayUserLocation))
+            mShowingUserLocation = displayUserLocation
+        }
+    }
+
+    fun options(displayUserLocation: Boolean): LocationComponentOptions {
+        var builder: LocationComponentOptions.Builder = LocationComponentOptions.builder(context)
+        val tintColor = mMapView?.tintColor
+        if (!displayUserLocation) {
+            builder =
+                builder
+                    .padding(mMap?.getPadding())
+                    .backgroundDrawable(R.drawable.empty)
+                    .backgroundDrawableStale(R.drawable.empty)
+                    .bearingDrawable(R.drawable.empty)
+                    .foregroundDrawable(R.drawable.empty)
+                    .foregroundDrawableStale(R.drawable.empty)
+                    .gpsDrawable(R.drawable.empty)
+                    .accuracyAlpha(0.0f)
+        } else if (tintColor != null) {
+            builder =
+                builder
+                    .enableStaleState(false)
+                    .bearingTintColor(tintColor)
+                    .foregroundTintColor(tintColor)
+                    .accuracyColor(tintColor)
+        }
+        return builder.build()
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/location/MLRNNativeUserLocation.kt

@@ -0,0 +1,75 @@
+package io.github.mapvina.reactnative.components.location
+
+import android.annotation.SuppressLint
+import android.content.Context
+import io.github.mapvina.android.location.modes.RenderMode
+import io.github.mapvina.android.location.permissions.PermissionsManager
+import io.github.mapvina.android.maps.MapVinaMap
+import io.github.mapvina.android.maps.OnMapReadyCallback
+import io.github.mapvina.android.maps.Style
+import io.github.mapvina.android.maps.Style.OnStyleLoaded
+import io.github.mapvina.reactnative.components.AbstractMapFeature
+import io.github.mapvina.reactnative.components.mapview.MLRNMapView
+
+class MLRNNativeUserLocation(
+    context: Context?,
+) : AbstractMapFeature(context),
+    OnMapReadyCallback,
+    OnStyleLoaded {
+    private var enabled = true
+    private var map: MapVinaMap? = null
+    private var mapView: MLRNMapView? = null
+
+    @RenderMode.Mode
+    private var mRenderMode = RenderMode.COMPASS
+    private var mPreferredFramesPerSecond = 0
+
+    override fun addToMap(mapView: MLRNMapView) {
+        enabled = true
+        this.mapView = mapView
+        mapView.getMapAsync(this)
+        setRenderMode(mRenderMode)
+        setPreferredFramesPerSecond(mPreferredFramesPerSecond)
+    }
+
+    override fun removeFromMap(mapView: MLRNMapView) {
+        enabled = false
+        if (map != null) map!!.getStyle(this)
+    }
+
+    @SuppressLint("MissingPermission")
+    override fun onMapReady(mapVinaMap: MapVinaMap) {
+        map = mapVinaMap
+        mapVinaMap.getStyle(this)
+    }
+
+    @SuppressLint("MissingPermission")
+    override fun onStyleLoaded(style: Style) {
+        val context = getContext()
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        val locationComponent = mapView!!.locationComponentManager
+        locationComponent.update(style)
+        locationComponent.showUserLocation(enabled)
+    }
+
+    fun setRenderMode(
+        @RenderMode.Mode renderMode: Int,
+    ) {
+        mRenderMode = renderMode
+        if (mapView != null) {
+            val locationComponent = mapView!!.locationComponentManager
+            locationComponent.setRenderMode(renderMode)
+        }
+    }
+
+    fun setPreferredFramesPerSecond(framesPerSecond: Int) {
+        mPreferredFramesPerSecond = framesPerSecond
+        if (mapView != null) {
+            val locationComponent = mapView!!.locationComponentManager
+            locationComponent.setPreferredFramesPerSecond(framesPerSecond)
+        }
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/location/MLRNNativeUserLocationManager.kt

@@ -0,0 +1,50 @@
+package io.github.mapvina.reactnative.components.location
+
+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.MLRNNativeUserLocationManagerDelegate
+import com.facebook.react.viewmanagers.MLRNNativeUserLocationManagerInterface
+import io.github.mapvina.android.location.modes.RenderMode
+
+@ReactModule(name = MLRNNativeUserLocationManager.REACT_CLASS)
+class MLRNNativeUserLocationManager :
+    ViewGroupManager<MLRNNativeUserLocation>(),
+    MLRNNativeUserLocationManagerInterface<MLRNNativeUserLocation> {
+    private val delegate: MLRNNativeUserLocationManagerDelegate<MLRNNativeUserLocation, MLRNNativeUserLocationManager> =
+        MLRNNativeUserLocationManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<MLRNNativeUserLocation> = delegate
+
+    companion object {
+        const val REACT_CLASS: String = "MLRNNativeUserLocation"
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): MLRNNativeUserLocation = MLRNNativeUserLocation(context)
+
+    @ReactProp(name = "mode")
+    override fun setMode(
+        userLocation: MLRNNativeUserLocation,
+        mode: String?,
+    ) {
+        if ("heading".equals(mode, ignoreCase = true)) {
+            userLocation.setRenderMode(RenderMode.COMPASS)
+        } else if ("course".equals(mode, ignoreCase = true)) {
+            userLocation.setRenderMode(RenderMode.GPS)
+        } else {
+            userLocation.setRenderMode(RenderMode.NORMAL)
+        }
+    }
+
+    @ReactProp(name = "androidPreferredFramesPerSecond")
+    override fun setAndroidPreferredFramesPerSecond(
+        userLocation: MLRNNativeUserLocation,
+        preferredFramesPerSecond: Int,
+    ) {
+        userLocation.setPreferredFramesPerSecond(preferredFramesPerSecond)
+    }
+}

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

@@ -0,0 +1,25 @@
+package io.github.mapvina.reactnative.components.mapview
+
+import android.content.Context
+import android.util.AttributeSet
+import io.github.mapvina.android.maps.MapVinaMapOptions
+
+class MLRNAndroidTextureMapView(
+    context: Context,
+    options: MapVinaMapOptions?,
+) : MLRNMapView(context, options) {
+    constructor(context: Context) : this(context, options = null)
+
+    @Suppress("UNUSED_PARAMETER")
+    constructor(context: Context, attrs: AttributeSet?) : this(context, options = null)
+
+    @Suppress("UNUSED_PARAMETER")
+    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : this(
+        context,
+        options = null,
+    )
+
+    companion object {
+        const val LOG_TAG: String = "MLRNAndroidTextureMapView"
+    }
+}

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

@@ -0,0 +1,25 @@
+package io.github.mapvina.reactnative.components.mapview
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import io.github.mapvina.android.maps.MapVinaMapOptions
+
+@ReactModule(name = MLRNAndroidTextureMapViewManager.REACT_CLASS)
+class MLRNAndroidTextureMapViewManager(
+    context: ReactApplicationContext,
+) : MLRNMapViewManager(context) {
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(themedReactContext: ThemedReactContext): MLRNAndroidTextureMapView {
+        val options = MapVinaMapOptions.createFromAttributes(themedReactContext)
+        options.textureMode(true)
+
+        return MLRNAndroidTextureMapView(themedReactContext, options)
+    }
+
+    companion object {
+        const val LOG_TAG: String = "MLRNAndroidTextureMapViewManager"
+        const val REACT_CLASS: String = "MLRNAndroidTextureMapView"
+    }
+}