Send pin-drop location (#636)

Share pindrop location This feature allows the user to share any location by just selecting it from the map. Closes: https://github.com/vector-im/element-x-android/issues/690
2023-06-30 00:07:47 +02:00
parent b292c3a29b
commit 0858cfb272
30 changed files with 534 additions and 113 deletions
--- a/features/location/impl/build.gradle.kts
+++ b/features/location/impl/build.gradle.kts
@@ -17,7 +17,6 @@
 plugins {
    id("io.element.android-compose-library")
    alias(libs.plugins.anvil)
-    alias(libs.plugins.kotlin.serialization)
    alias(libs.plugins.ksp)
 }

@@ -30,18 +29,18 @@ anvil {
 }

 dependencies {
-    implementation(libs.dagger)
    api(projects.features.location.api)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
    implementation(projects.libraries.di)
    implementation(projects.libraries.designsystem)
-    implementation(projects.libraries.network)
    implementation(projects.libraries.core)
    implementation(libs.maplibre)
-    implementation(libs.network.retrofit)
    implementation(libs.maplibre.annotation)
-    implementation(libs.coil.compose)
-    implementation(libs.serialization.json)
-    implementation(libs.accompanist.permission)
+    implementation(projects.libraries.uiStrings)
+    implementation(libs.dagger)
+    implementation(projects.anvilannotations)
+    anvil(projects.anvilcodegen)
    ksp(libs.showkase.processor)

    testImplementation(libs.test.junit)
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationEntryPointImpl.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationEntryPointImpl.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.location.api.SendLocationEntryPoint
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.AppScope
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class SendLocationEntryPointImpl @Inject constructor() : SendLocationEntryPoint {
+    override fun createNode(
+        parentNode: Node, buildContext: BuildContext
+    ): SendLocationNode = parentNode.createNode(buildContext)
+}
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationEvents.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationEvents.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl
+
+sealed interface SendLocationEvents {
+    data class ShareLocation(val lat: Double, val lng: Double) : SendLocationEvents
+    data class SwitchMode(val mode: SendLocationState.Mode) : SendLocationEvents
+}
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationNode.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationNode.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.libraries.di.RoomScope
+
+@ContributesNode(RoomScope::class)
+class SendLocationNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: SendLocationPresenter,
+) : Node(buildContext, plugins = plugins) {
+    @Composable
+    override fun View(modifier: Modifier) {
+        SendLocationView(
+            state = presenter.present(),
+            modifier = modifier,
+            onBackPressed = ::navigateUp,
+        )
+    }
+}
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationPresenter.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationPresenter.kt
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.matrix.api.room.MatrixRoom
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+class SendLocationPresenter @Inject constructor(
+    private val room: MatrixRoom,
+) : Presenter<SendLocationState> {
+    @Composable
+    override fun present(): SendLocationState {
+
+        val scope = rememberCoroutineScope()
+
+        var mode by remember {
+            mutableStateOf<SendLocationState.Mode>(SendLocationState.Mode.ALocation)
+        }
+
+        fun handleEvents(event: SendLocationEvents) {
+            when (event) {
+                is SendLocationEvents.ShareLocation -> scope.launch {
+                    shareLocation(event)
+                }
+                is SendLocationEvents.SwitchMode -> {
+                    mode = event.mode
+                }
+            }
+        }
+
+        return SendLocationState(
+            mode = mode,
+            eventSink = ::handleEvents,
+        )
+    }
+
+    private suspend fun shareLocation(
+        event: SendLocationEvents.ShareLocation
+    ) {
+        room.sendLocation(
+            body = "Location at latitude: ${event.lat}, longitude: ${event.lng}",
+            geoUri = "geo:${event.lat},${event.lng}",
+        )
+    }
+}
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationState.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationState.kt
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl
+
+data class SendLocationState(
+    val mode: Mode = Mode.ALocation,
+    val eventSink: (SendLocationEvents) -> Unit = {},
+) {
+    sealed interface Mode {
+        object MyLocation : Mode
+        object ALocation : Mode
+    }
+}
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationStateProvider.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationStateProvider.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+
+class SendLocationStateProvider : PreviewParameterProvider<SendLocationState> {
+    override val values: Sequence<SendLocationState>
+        get() = sequenceOf(
+            SendLocationState(),
+        )
+}
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationView.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/SendLocationView.kt
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.LocationOn
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.SheetValue
+import androidx.compose.material3.rememberBottomSheetScaffoldState
+import androidx.compose.material3.rememberStandardBottomSheetState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import io.element.android.features.location.api.R
+import io.element.android.features.location.impl.map.MapView
+import io.element.android.features.location.impl.map.rememberMapState
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.BottomSheetScaffold
+import io.element.android.libraries.designsystem.theme.components.CenterAlignedTopAppBar
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
+@Composable
+fun SendLocationView(
+    state: SendLocationState,
+    modifier: Modifier = Modifier,
+    onBackPressed: () -> Unit = {},
+) {
+    val mapState = rememberMapState()
+    BottomSheetScaffold(
+        sheetContent = {
+            Spacer(modifier = Modifier.height(16.dp))
+            ListItem(
+                headlineContent = {
+                    Text(stringResource(CommonStrings.screen_share_this_location_action))
+                },
+                modifier = Modifier.clickable {
+                    state.eventSink(
+                        SendLocationEvents.ShareLocation(
+                            lat = mapState.position.lat,
+                            lng = mapState.position.lon
+                        )
+                    )
+                    onBackPressed()
+                },
+                leadingContent = {
+                    Icon(Icons.Default.LocationOn, null)
+                },
+            )
+            Spacer(modifier = Modifier.height(16.dp))
+        },
+        modifier = modifier,
+        scaffoldState = rememberBottomSheetScaffoldState(
+            bottomSheetState = rememberStandardBottomSheetState(initialValue = SheetValue.Expanded),
+        ),
+        sheetDragHandle = {},
+        sheetSwipeEnabled = false,
+        topBar = {
+            CenterAlignedTopAppBar(
+                title = {
+                    Text(
+                        text = stringResource(CommonStrings.screen_share_location_title),
+                        fontSize = 16.sp,
+                        fontWeight = FontWeight.SemiBold,
+                    )
+                },
+                navigationIcon = {
+                    BackButton(onClick = onBackPressed)
+                },
+            )
+        },
+    ) {
+        Box(
+            modifier = Modifier
+                .padding(it)
+                .consumeWindowInsets(it),
+            contentAlignment = Alignment.Center
+        ) {
+            MapView(
+                modifier = Modifier.fillMaxSize(),
+                mapState = mapState,
+            )
+            Icon(
+                resourceId = R.drawable.pin,
+                contentDescription = null,
+                tint = Color.Unspecified
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun SendLocationViewLightPreview(@PreviewParameter(SendLocationStateProvider::class) state: SendLocationState) =
+    ElementPreviewLight { ContentToPreview(state) }
+
+@Preview
+@Composable
+internal fun SendLocationViewDarkPreview(@PreviewParameter(SendLocationStateProvider::class) state: SendLocationState) =
+    ElementPreviewDark { ContentToPreview(state) }
+
+@Composable
+private fun ContentToPreview(state: SendLocationState) {
+    SendLocationView(
+        state = state,
+        onBackPressed = {},
+    )
+}
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/location/Location.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/location/Location.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl.location
+
+/**
+ * Represents a location sample emitted by the device's location subsystem.
+ */
+data class Location(
+    val lat: Double,
+    val lon: Double,
+    val accuracy: Float,
+)
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/location/LocationUpdatesFlowImpl.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/location/LocationUpdatesFlowImpl.kt
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-package io.element.android.features.location.impl
+package io.element.android.features.location.impl.location

 import android.Manifest
 import android.content.Context
@@ -25,7 +25,6 @@ import androidx.core.location.LocationListenerCompat
 import androidx.core.location.LocationManagerCompat
 import androidx.core.location.LocationRequestCompat
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
-import io.element.android.features.location.api.Location
 import kotlinx.coroutines.asExecutor
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.channels.trySendBlocking
--- a/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/map/MapView.kt
+++ b/features/location/impl/src/main/kotlin/io/element/android/features/location/impl/map/MapView.kt
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl.map
+
+import android.annotation.SuppressLint
+import android.view.Gravity
+import androidx.annotation.DrawableRes
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalInspectionMode
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import com.mapbox.mapboxsdk.Mapbox
+import com.mapbox.mapboxsdk.camera.CameraPosition
+import com.mapbox.mapboxsdk.camera.CameraUpdateFactory
+import com.mapbox.mapboxsdk.geometry.LatLng
+import com.mapbox.mapboxsdk.maps.MapView
+import com.mapbox.mapboxsdk.maps.MapboxMap
+import com.mapbox.mapboxsdk.maps.Style
+import com.mapbox.mapboxsdk.plugins.annotation.SymbolManager
+import com.mapbox.mapboxsdk.plugins.annotation.SymbolOptions
+import io.element.android.features.location.api.R
+import io.element.android.features.location.api.internal.buildTileServerUrl
+import io.element.android.features.location.impl.location.Location
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.theme.ElementTheme
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
+import timber.log.Timber
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+/**
+ * Composable wrapper around MapLibre's [MapView].
+ */
+@SuppressLint("MissingPermission")
+@Composable
+fun MapView(
+    modifier: Modifier = Modifier,
+    mapState: MapState = rememberMapState(),
+    darkMode: Boolean = !ElementTheme.isLightTheme,
+) {
+    // When in preview, early return a Box with the received modifier preserving layout
+    if (LocalInspectionMode.current) {
+        @Suppress("ModifierReused") // False positive, the modifier is not reused due to the early return.
+        Box(modifier = modifier)
+        return
+    }
+
+    val context = LocalContext.current
+    val mapView = remember {
+        Mapbox.getInstance(context)
+        MapView(context)
+    }
+    var mapRefs by remember { mutableStateOf<MapRefs?>(null) }
+
+    // Build map
+    LaunchedEffect(darkMode) {
+        mapView.awaitMap().let { map ->
+            map.uiSettings.apply {
+                attributionGravity = Gravity.TOP
+                logoGravity = Gravity.TOP
+                isCompassEnabled = false
+                isRotateGesturesEnabled = false
+            }
+            map.setStyle(buildTileServerUrl(darkMode = darkMode)) { style ->
+                mapRefs = MapRefs(
+                    map = map,
+                    symbolManager = SymbolManager(mapView, map, style).apply {
+                        iconAllowOverlap = true
+                    },
+                    style = style
+                )
+            }
+        }
+    }
+
+    // Update state position when moving map
+    DisposableEffect(mapRefs) {
+        var listener: MapboxMap.OnCameraIdleListener? = null
+
+        mapRefs?.let { mapRefs ->
+            listener = MapboxMap.OnCameraIdleListener {
+                mapRefs.map.cameraPosition.target?.let { target ->
+                    val position = MapState.CameraPosition(
+                        lat = target.latitude,
+                        lon = target.longitude,
+                        zoom = mapRefs.map.cameraPosition.zoom
+                    )
+                    mapState.position = position
+                    Timber.d("Camera moved to: $position")
+                }
+            }.apply {
+                mapRefs.map.addOnCameraIdleListener(this)
+                Timber.d("Added OnCameraIdleListener $this")
+            }
+        }
+
+        onDispose {
+            mapRefs?.let { mapRefs ->
+                listener?.let {
+                    mapRefs.map.removeOnCameraIdleListener(it).apply {
+                        Timber.d("Removed OnCameraIdleListener $it")
+                    }
+                }
+            }
+        }
+    }
+
+    // Move map to given position when state has changed
+    LaunchedEffect(mapRefs, mapState.position) {
+        mapRefs?.map?.moveCamera(
+            CameraUpdateFactory.newCameraPosition(
+                CameraPosition.Builder()
+                    .target(LatLng(mapState.position.lat, mapState.position.lon))
+                    .zoom(mapState.position.zoom).build()
+            )
+        )
+        Timber.d("Camera position updated to: ${mapState.position}")
+    }
+
+    // Draw pin
+    LaunchedEffect(mapRefs, mapState.location) {
+        mapRefs?.let { mapRefs ->
+            mapState.location?.let { location ->
+                context.getDrawable(R.drawable.pin)?.let { mapRefs.style.addImage("pin", it) }
+                mapRefs.symbolManager.create(
+                    SymbolOptions()
+                        .withLatLng(LatLng(location.lat, location.lon))
+                        .withIconImage("pin")
+                        .withIconSize(1.3f)
+                )
+                Timber.d("Shown pin at location: $location")
+            }
+        }
+
+    }
+
+    // Draw markers
+    LaunchedEffect(mapRefs, mapState.markers) {
+        mapRefs?.let { mapRefs ->
+            mapState.markers.forEachIndexed { index, marker ->
+                context.getDrawable(marker.drawable)?.let { mapRefs.style.addImage("marker_$index", it) }
+                mapRefs.symbolManager.create(
+                    SymbolOptions()
+                        .withLatLng(LatLng(marker.lat, marker.lon))
+                        .withIconImage("marker_$index")
+                        .withIconSize(1.0f)
+                )
+                Timber.d("Shown marker at location: $marker")
+            }
+        }
+    }
+
+    @Suppress("ModifierReused")
+    AndroidView(
+        factory = { mapView },
+        modifier = modifier
+    )
+}
+
+@Composable
+fun rememberMapState(
+    position: MapState.CameraPosition = MapState.CameraPosition(lat = 0.0, lon = 0.0, zoom = 0.0),
+    location: Location? = null,
+    markers: ImmutableList<MapState.Marker> = emptyList<MapState.Marker>().toImmutableList(),
+): MapState = remember {
+    MapState(
+        position = position,
+        location = location,
+        markers = markers,
+    )
+} // TODO(Use remember saveable with Parcelable custom saver)
+
+@Stable
+class MapState(
+    position: CameraPosition, // The position of the camera, it's what will be shared
+    location: Location? = null, // The location retrieved by the location subsystem, if any.
+    markers: ImmutableList<Marker> = emptyList<Marker>().toImmutableList(), // The pin's location, if any.
+) {
+    var position: CameraPosition by mutableStateOf(position)
+    var location: Location? by mutableStateOf(location)
+    var markers: ImmutableList<Marker> by mutableStateOf(markers)
+
+    override fun toString(): String {
+        return "MapState(position=$position, location=$location, markers=$markers)"
+    }
+
+    @Stable
+    data class CameraPosition(
+        val lat: Double,
+        val lon: Double,
+        val zoom: Double,
+    )
+
+    @Stable
+    data class Marker(
+        @DrawableRes val drawable: Int,
+        val lat: Double,
+        val lon: Double,
+    )
+}
+
+private class MapRefs(
+    val map: MapboxMap,
+    val symbolManager: SymbolManager,
+    val style: Style
+)
+
+/**
+ * A suspending function that provides an instance of [MapboxMap] from this [MapView]. This is
+ * an alternative to [MapView.getMapAsync] by using coroutines to obtain the [MapboxMap].
+ *
+ * Inspired from [com.google.maps.android.ktx.awaitMap]
+ *
+ * @return the [MapboxMap] instance
+ */
+private suspend inline fun MapView.awaitMap(): MapboxMap =
+    suspendCoroutine { continuation ->
+        getMapAsync {
+            continuation.resume(it)
+        }
+    }
+
+@Preview
+@Composable
+fun MapViewLightPreview() =
+    ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+fun MapViewDarkPreview() =
+    ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    MapView(
+        modifier = Modifier.size(400.dp),
+        mapState = rememberMapState(
+            position = MapState.CameraPosition(
+                lat = 0.0,
+                lon = 0.0,
+                zoom = 0.0,
+            ),
+            location = Location(
+                lat = 0.0,
+                lon = 0.0,
+                accuracy = 0.0f,
+            ),
+            markers = listOf(
+                MapState.Marker(
+                    drawable = R.drawable.pin,
+                    lat = 0.0,
+                    lon = 0.0,
+                )
+            ).toImmutableList()
+        ),
+    )
+}
--- a/features/location/impl/src/test/kotlin/io/element/android/features/location/impl/SendLocationPresenterTest.kt
+++ b/features/location/impl/src/test/kotlin/io/element/android/features/location/impl/SendLocationPresenterTest.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl
+
+import app.cash.molecule.RecompositionClock
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth
+import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class SendLocationPresenterTest {
+
+    private val room = FakeMatrixRoom()
+    private val presenter = SendLocationPresenter(room)
+
+    @Test
+    fun `emits initial state`() = runTest {
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            Truth.assertThat(awaitItem().mode).isEqualTo(SendLocationState.Mode.ALocation)
+        }
+    }
+
+    @Test
+    fun `share location event shares a location`() = runTest {
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(SendLocationEvents.ShareLocation(1.0, 2.0))
+            delay(1)
+            Truth.assertThat(room.sendLocationCount).isEqualTo(1)
+        }
+    }
+
+    @Test
+    fun `switches mode`() = runTest {
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(SendLocationEvents.SwitchMode(SendLocationState.Mode.MyLocation))
+            Truth.assertThat(awaitItem().mode).isEqualTo(SendLocationState.Mode.MyLocation)
+        }
+    }
+}
--- a/features/location/impl/src/test/kotlin/io/element/android/features/location/impl/location/LocationUpdatesFlowFake.kt
+++ b/features/location/impl/src/test/kotlin/io/element/android/features/location/impl/location/LocationUpdatesFlowFake.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.location.impl.location
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+fun fakeLocationUpdatesFlow(): Flow<io.element.android.features.location.impl.location.Location> = flow {
+    while (true) {
+        delay(1_000)
+        emit(aLocation())
+    }
+}
+
+private fun aLocation() = io.element.android.features.location.impl.location.Location(
+    lat = 51.49404,
+    lon = -0.25484,
+    accuracy = 5f
+)