@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/java/io/github/mapvina/reactnative/components/camera/MLRNCamera.kt

@@ -0,0 +1,411 @@
+package io.github.mapvina.reactnative.components.camera
+
+import android.Manifest
+import android.content.Context
+import android.location.Location
+import android.util.AttributeSet
+import androidx.annotation.RequiresPermission
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableMap
+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.camera.CameraPosition
+import io.github.mapvina.android.camera.CameraUpdateFactory.newCameraPosition
+import io.github.mapvina.android.geometry.LatLngBounds
+import io.github.mapvina.android.location.OnCameraTrackingChangedListener
+import io.github.mapvina.android.location.permissions.PermissionsManager
+import io.github.mapvina.android.maps.MapVinaMap
+import io.github.mapvina.android.maps.MapVinaMap.CancelableCallback
+import io.github.mapvina.android.maps.Style
+import io.github.mapvina.reactnative.components.AbstractMapFeature
+import io.github.mapvina.reactnative.components.camera.constants.CameraEasing
+import io.github.mapvina.reactnative.components.location.LocationComponentManager
+import io.github.mapvina.reactnative.components.mapview.MLRNMapView
+import io.github.mapvina.reactnative.location.LocationManager
+import io.github.mapvina.reactnative.location.LocationManager.OnUserLocationChange
+import io.github.mapvina.reactnative.location.TrackUserLocationMode
+import io.github.mapvina.reactnative.location.TrackUserLocationState
+import io.github.mapvina.reactnative.location.UserLocation
+
+class MLRNCamera(
+    context: Context,
+) : AbstractMapFeature(
+        context,
+    ) {
+    @Suppress("UNUSED_PARAMETER")
+    constructor(context: Context, attrs: AttributeSet?) : this(context)
+
+    @Suppress("UNUSED_PARAMETER")
+    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : this(context)
+
+    private var mapView: MLRNMapView? = null
+    private var hasSentFirstRegion = false
+    private val updateQueue = CameraUpdateQueue()
+
+    private var stop: CameraStop? = null
+
+    private var initialViewState: CameraStop? = null
+
+    private var minZoom: Double? = null
+    private var maxZoom: Double? = null
+
+    private var maxBounds: LatLngBounds? = null
+
+    private var trackUserLocation = TrackUserLocationMode.NONE
+    private var userTrackingState = TrackUserLocationState.POSSIBLE
+
+    private var locationComponentManager: LocationComponentManager? = null
+
+    private val locationManager: LocationManager = LocationManager.getInstance(context)
+    private val userLocation = UserLocation()
+
+    private val locationChangeListener: OnUserLocationChange =
+        object : OnUserLocationChange {
+            override fun onLocationChange(location: Location) {
+                if (mapView!!.mapVinaMap == null ||
+                    locationComponentManager == null ||
+                    !locationComponentManager!!.hasLocationComponent() ||
+                    trackUserLocation == TrackUserLocationMode.NONE
+                ) {
+                    return
+                }
+
+                userLocation.setCurrentLocation(location)
+            }
+        }
+
+    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)
+        }
+
+    private val cameraCallback: CancelableCallback =
+        object : CancelableCallback {
+            override fun onCancel() {
+                if (!hasSentFirstRegion) {
+                    mapView!!.sendRegionChangeEvent(false)
+                    hasSentFirstRegion = true
+                }
+            }
+
+            override fun onFinish() {
+                if (!hasSentFirstRegion) {
+                    mapView!!.sendRegionChangeEvent(false)
+                    hasSentFirstRegion = true
+                }
+            }
+        }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun addToMap(mapView: MLRNMapView) {
+        this@MLRNCamera.mapView = mapView
+
+        setInitialCamera()
+        updateMaxMinZoom()
+        updateMaxBounds()
+
+        if (stop != null) {
+            updateCamera()
+        }
+
+        if (trackUserLocation != TrackUserLocationMode.NONE) {
+            enableLocation()
+        }
+    }
+
+    override fun removeFromMap(mapView: MLRNMapView) {}
+
+    fun handleImperativeStop(stop: ReadableMap?) {
+        val mapView = this.mapView ?: return
+        val stop =
+            CameraStop.fromReadableMap(context, stop ?: Arguments.createMap(), cameraCallback)
+
+        updateQueue.offer(stop)
+        updateQueue.execute(mapView)
+    }
+
+    fun setStop(stop: ReadableMap?) {
+        this.stop =
+            CameraStop.fromReadableMap(context, stop ?: Arguments.createMap(), cameraCallback)
+
+        if (mapView != null) {
+            updateCamera()
+        }
+    }
+
+    fun setInitialViewState(stop: CameraStop?) {
+        initialViewState = stop
+    }
+
+    fun hasInitialViewState(): Boolean = initialViewState != null
+
+    fun setMaxBounds(bounds: LatLngBounds?) {
+        maxBounds = bounds
+        updateMaxBounds()
+    }
+
+    private fun updateMaxMinZoom() {
+        val map = mapvinaMap
+        if (map != null) {
+            val minZoom = minZoom
+            if (minZoom != null) {
+                map.setMinZoomPreference(minZoom)
+            }
+
+            val maxZoom = maxZoom
+            if (maxZoom != null) {
+                map.setMaxZoomPreference(maxZoom)
+            }
+        }
+    }
+
+    private fun updateMaxBounds() {
+        val map = mapvinaMap
+        if (map != null && maxBounds != null) {
+            map.setLatLngBoundsForCameraTarget(maxBounds)
+        }
+    }
+
+    private fun setInitialCamera() {
+        if (initialViewState != null) {
+            initialViewState!!.duration = 0
+            initialViewState!!.easing = CameraEasing.NONE
+            val item = initialViewState!!.toCameraUpdate(mapView!!)
+
+            item.run()
+        }
+    }
+
+    private fun updateCamera() {
+        updateQueue.offer(stop)
+        updateQueue.execute(mapView!!)
+    }
+
+    private fun updateUserTrackingMode(trackUserLocationMode: Int) {
+        userLocation.trackingMode = trackUserLocationMode
+
+        val event = OnTrackUserLocationChangeEvent(surfaceId, id, trackUserLocationMode)
+        eventDispatcher?.dispatchEvent(event)
+    }
+
+    private fun updateUserLocation() {
+        if (trackUserLocation == TrackUserLocationMode.NONE || userLocation.trackingMode == TrackUserLocationMode.NONE) {
+            return
+        }
+
+        if (userTrackingState == TrackUserLocationState.POSSIBLE) {
+            updateUserLocationSignificantly()
+        } else if (userTrackingState == TrackUserLocationState.CHANGED) {
+            updateUserLocationIncrementally()
+        }
+    }
+
+    private fun getUserLocationUpdateCameraPosition(zoomLevel: Double): CameraPosition {
+        val center = userLocation.coordinate
+
+        return CameraPosition
+            .Builder()
+            .target(center)
+            .bearing(
+                directionForUserLocationUpdate,
+            ).tilt(stop?.pitch ?: 0.0)
+            .zoom(zoomLevel)
+            .build()
+    }
+
+    private val directionForUserLocationUpdate: Double
+        get() {
+            // NOTE: The direction of this is used for map rotation only, not location layer rotation
+            val currentCamera = mapView!!.cameraPosition
+            var direction = currentCamera.bearing
+
+            val userTrackingMode = userLocation.trackingMode
+            if (userTrackingMode == TrackUserLocationMode.HEADING || userTrackingMode == TrackUserLocationMode.COURSE) {
+                direction = userLocation.bearing
+            } else if (stop?.bearing != null) {
+                direction = stop?.bearing ?: direction
+            }
+
+            return direction
+        }
+
+    private fun updateUserLocationSignificantly() {
+        userTrackingState = TrackUserLocationState.BEGAN
+
+        val cameraUpdate =
+            newCameraPosition(getUserLocationUpdateCameraPosition(mapView!!.mapVinaMap!!.cameraPosition.zoom))
+        val cameraCallback: CancelableCallback =
+            object : CancelableCallback {
+                override fun onCancel() {
+                    userTrackingState = TrackUserLocationState.CHANGED
+                }
+
+                override fun onFinish() {
+                    userTrackingState = TrackUserLocationState.CHANGED
+                }
+            }
+
+        mapView!!.moveCamera(cameraUpdate, cameraCallback)
+    }
+
+    private fun updateUserLocationIncrementally() {
+        userTrackingState = TrackUserLocationState.BEGAN
+
+        val cameraPosition = mapView!!.cameraPosition
+        val cameraUpdate =
+            newCameraPosition(getUserLocationUpdateCameraPosition(cameraPosition.zoom))
+
+        val callback: CancelableCallback =
+            object : CancelableCallback {
+                override fun onCancel() {
+                    userTrackingState = TrackUserLocationState.CHANGED
+                }
+
+                override fun onFinish() {
+                    userTrackingState = TrackUserLocationState.CHANGED
+                }
+            }
+
+        mapView!!.moveCamera(cameraUpdate, callback)
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    private fun enableLocation() {
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        if (!locationManager.isActive()) {
+            locationManager.enable()
+        }
+
+        mapView!!.mapVinaMap!!.getStyle { style ->
+            enableLocationComponent(
+                style,
+            )
+        }
+    }
+
+    private fun enableLocationComponent(style: Style) {
+        updateUserLocation()
+        updateLocationLayer(style)
+
+        val lastKnownLocation = locationManager.lastKnownLocation
+        locationManager.addLocationListener(locationChangeListener)
+
+        if (lastKnownLocation != null) {
+            locationChangeListener.onLocationChange(lastKnownLocation)
+
+            postDelayed({ mapView!!.sendRegionDidChangeEvent() }, 200)
+        }
+    }
+
+    private fun updateLocationLayer(style: Style) {
+        if (locationComponentManager == null) {
+            locationComponentManager = mapView!!.locationComponentManager
+        }
+
+        locationComponentManager!!.update(style)
+        locationComponentManager!!.setFollowUserLocation(trackUserLocation != TrackUserLocationMode.NONE)
+
+        if (trackUserLocation != TrackUserLocationMode.NONE) {
+            locationComponentManager!!.setCameraMode(
+                TrackUserLocationMode.getCameraMode(
+                    trackUserLocation,
+                ),
+            )
+            locationComponentManager!!.addOnCameraTrackingChangedListener(
+                object :
+                    OnCameraTrackingChangedListener {
+                    override fun onCameraTrackingChanged(currentMode: Int) {
+                        val userTrackingMode =
+                            when (currentMode) {
+                                io.github.mapvina.android.location.modes.CameraMode.NONE -> TrackUserLocationMode.NONE
+                                io.github.mapvina.android.location.modes.CameraMode.TRACKING -> TrackUserLocationMode.DEFAULT
+                                io.github.mapvina.android.location.modes.CameraMode.TRACKING_COMPASS -> TrackUserLocationMode.HEADING
+                                io.github.mapvina.android.location.modes.CameraMode.TRACKING_GPS -> TrackUserLocationMode.COURSE
+                                else -> TrackUserLocationMode.NONE
+                            }
+
+                        updateUserTrackingMode(userTrackingMode)
+                    }
+
+                    override fun onCameraTrackingDismissed() {
+                    }
+                },
+            )
+        } else {
+            locationComponentManager!!.setCameraMode(io.github.mapvina.android.location.modes.CameraMode.NONE)
+        }
+    }
+
+    fun setMinZoomLevel(zoomLevel: Double) {
+        minZoom = zoomLevel
+        updateMaxMinZoom()
+    }
+
+    fun setMaxZoomLevel(zoomLevel: Double) {
+        maxZoom = zoomLevel
+        updateMaxMinZoom()
+    }
+
+    fun setTrackUserLocation(trackUserLocationMode: Int) {
+        val oldTrackingMode = trackUserLocation
+        trackUserLocation = trackUserLocationMode
+        updateUserTrackingMode(trackUserLocationMode)
+
+        when (trackUserLocation) {
+            TrackUserLocationMode.NONE -> {
+                userTrackingState = TrackUserLocationState.POSSIBLE
+            }
+
+            TrackUserLocationMode.DEFAULT, TrackUserLocationMode.COURSE, TrackUserLocationMode.HEADING -> {
+                if (oldTrackingMode ==
+                    TrackUserLocationMode.NONE
+                ) {
+                    userTrackingState = TrackUserLocationState.POSSIBLE
+                }
+            }
+        }
+
+        if (mapvinaMap != null) {
+            updateLocationLayer(mapvinaMap!!.style!!)
+        }
+    }
+
+    private val mapvinaMap: MapVinaMap?
+        get() {
+            if (mapView == null) {
+                return null
+            }
+            return mapView!!.mapVinaMap
+        }
+
+    inner class OnTrackUserLocationChangeEvent(
+        surfaceId: Int,
+        viewId: Int,
+        private val trackUserLocationMode: Int,
+    ) : Event<OnTrackUserLocationChangeEvent>(surfaceId, viewId) {
+        override fun getEventName() = "onTrackUserLocationChange"
+
+        override fun getEventData(): WritableMap =
+            Arguments.createMap().apply {
+                putString(
+                    "trackUserLocation",
+                    TrackUserLocationMode.toString(trackUserLocationMode),
+                )
+            }
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/camera/MLRNCameraManager.kt

@@ -0,0 +1,84 @@
+package io.github.mapvina.reactnative.components.camera
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+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.MLRNCameraManagerDelegate
+import com.facebook.react.viewmanagers.MLRNCameraManagerInterface
+import io.github.mapvina.reactnative.location.TrackUserLocationMode
+import io.github.mapvina.reactnative.utils.GeoJSONUtils
+
+@ReactModule(name = MLRNCameraManager.REACT_CLASS)
+class MLRNCameraManager(
+    private val context: ReactApplicationContext,
+) : ViewGroupManager<MLRNCamera>(),
+    MLRNCameraManagerInterface<MLRNCamera> {
+    private val delegate: MLRNCameraManagerDelegate<MLRNCamera, MLRNCameraManager> =
+        MLRNCameraManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<MLRNCamera> = delegate
+
+    companion object {
+        const val REACT_CLASS: String = "MLRNCamera"
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext): MLRNCamera = MLRNCamera(reactContext)
+
+    @ReactProp(name = "stop")
+    override fun setStop(
+        camera: MLRNCamera,
+        value: ReadableMap?,
+    ) {
+        camera.setStop(value)
+    }
+
+    @ReactProp(name = "initialViewState")
+    override fun setInitialViewState(
+        camera: MLRNCamera,
+        value: ReadableMap?,
+    ) {
+        if (value != null && !camera.hasInitialViewState()) {
+            val stop = CameraStop.fromReadableMap(context, value, null)
+            camera.setInitialViewState(stop)
+        }
+    }
+
+    @ReactProp(name = "minZoom")
+    override fun setMinZoom(
+        camera: MLRNCamera,
+        value: Double,
+    ) {
+        camera.setMinZoomLevel(value)
+    }
+
+    @ReactProp(name = "maxZoom")
+    override fun setMaxZoom(
+        camera: MLRNCamera,
+        value: Double,
+    ) {
+        camera.setMaxZoomLevel(value)
+    }
+
+    @ReactProp(name = "maxBounds")
+    override fun setMaxBounds(
+        camera: MLRNCamera,
+        value: ReadableArray?,
+    ) {
+        camera.setMaxBounds(GeoJSONUtils.toLatLngBounds(value))
+    }
+
+    @ReactProp(name = "trackUserLocation")
+    override fun setTrackUserLocation(
+        camera: MLRNCamera,
+        value: String?,
+    ) {
+        camera.setTrackUserLocation(TrackUserLocationMode.fromString(value))
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/camera/MLRNCameraModule.kt

@@ -0,0 +1,36 @@
+package io.github.mapvina.reactnative.components.camera
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import io.github.mapvina.reactnative.NativeCameraModuleSpec
+import io.github.mapvina.reactnative.utils.ReactTag
+import io.github.mapvina.reactnative.utils.ReactTagResolver
+
+class MLRNCameraModule(
+    context: ReactApplicationContext,
+    private val reactTagResolver: ReactTagResolver,
+) : NativeCameraModuleSpec(context) {
+    companion object {
+        const val NAME = "MLRNCameraModule"
+    }
+
+    private fun withViewportOnUIThread(
+        reactTag: ReactTag,
+        reject: Promise,
+        fn: (MLRNCamera) -> Unit,
+    ) {
+        reactTagResolver.withViewResolved(reactTag.toInt(), reject, fn)
+    }
+
+    override fun setStop(
+        reactTag: ReactTag,
+        stop: ReadableMap,
+        promise: Promise,
+    ) {
+        withViewportOnUIThread(reactTag, promise) {
+            it.handleImperativeStop(stop)
+            promise.resolve(null)
+        }
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/components/camera/constants/CameraEasing.kt

@@ -0,0 +1,23 @@
+package io.github.mapvina.reactnative.components.camera.constants
+
+import androidx.annotation.IntDef
+
+object CameraEasing {
+    const val NONE: Int = 0
+    const val LINEAR: Int = 1
+    const val EASE: Int = 2
+    const val FLY: Int = 3
+
+    @IntDef(NONE, LINEAR, EASE, FLY)
+    @Retention(AnnotationRetention.SOURCE)
+    annotation class Easing
+
+    fun fromString(value: String?): Int =
+        when (value) {
+            "none" -> NONE
+            "linear" -> LINEAR
+            "ease" -> EASE
+            "fly" -> FLY
+            else -> NONE
+        }
+}