Room list contextual menu (#427)

- Adds `ModalBottomSheet` to our design components (it wraps the homonimous Material3 one). - Adds a bottom sheet to the Room list using the aforementioned design component. - Adds navigation from the room list to a room detail (context menu "Settings" action). - Consolidates the "leave room flow" into a new `leaveroom` module used by both the room list and the room details. - Adds progress indicator to the leave room flow - Uses new `leaveroom` module in `roomdetails` module too. Parent issue: - https://github.com/vector-im/element-x-android/issues/261
2023-05-25 08:42:44 +02:00 · 2023-05-25 08:42:44 +02:00 · 0dee0784ba
commit 0dee0784ba
parent 897540ed04
60 changed files with 1462 additions and 250 deletions
--- a/features/leaveroom/api/build.gradle.kts
+++ b/features/leaveroom/api/build.gradle.kts
@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+plugins {
+    id("io.element.android-compose-library")
+    alias(libs.plugins.ksp)
+}
+
+android {
+    namespace = "io.element.android.features.leaveroom.api"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.uiStrings)
+    implementation(projects.libraries.matrix.api)
+    ksp(libs.showkase.processor)
+}
--- a/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomEvent.kt
+++ b/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomEvent.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.leaveroom.api
+
+import io.element.android.libraries.matrix.api.core.RoomId
+
+sealed interface LeaveRoomEvent {
+    data class ShowConfirmation(val roomId: RoomId) : LeaveRoomEvent
+    object HideConfirmation : LeaveRoomEvent
+    data class LeaveRoom(val roomId: RoomId) : LeaveRoomEvent
+    object HideError : LeaveRoomEvent
+}
--- a/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomPresenter.kt
+++ b/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomPresenter.kt
@ -0,0 +1,25 @@
+/*
+ * 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.leaveroom.api
+
+import androidx.compose.runtime.Composable
+import io.element.android.libraries.architecture.Presenter
+
+interface LeaveRoomPresenter : Presenter<LeaveRoomState> {
+    @Composable
+    override fun present(): LeaveRoomState
+}
--- a/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomState.kt
+++ b/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomState.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.leaveroom.api
+
+import io.element.android.libraries.matrix.api.core.RoomId
+
+data class LeaveRoomState(
+    val confirmation: Confirmation = Confirmation.Hidden,
+    val progress: Progress = Progress.Hidden,
+    val error: Error = Error.Hidden,
+    val eventSink: (LeaveRoomEvent) -> Unit = {},
+) {
+    sealed interface Confirmation {
+        object Hidden : Confirmation
+        data class Generic(val roomId: RoomId) : Confirmation
+        data class PrivateRoom(val roomId: RoomId) : Confirmation
+        data class LastUserInRoom(val roomId: RoomId) : Confirmation
+    }
+
+    sealed interface Progress {
+        object Hidden : Progress
+        object Shown : Progress
+    }
+
+    sealed interface Error {
+        object Hidden : Error
+        object Shown : Error
+    }
+}
--- a/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomStateProvider.kt
+++ b/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomStateProvider.kt
@ -0,0 +1,58 @@
+/*
+ * 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.leaveroom.api
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.matrix.api.core.RoomId
+
+class LeaveRoomStateProvider : PreviewParameterProvider<LeaveRoomState> {
+    override val values: Sequence<LeaveRoomState>
+        get() = sequenceOf(
+            LeaveRoomState(
+                confirmation = LeaveRoomState.Confirmation.Hidden,
+                progress = LeaveRoomState.Progress.Hidden,
+                error = LeaveRoomState.Error.Hidden,
+            ),
+            LeaveRoomState(
+                confirmation = LeaveRoomState.Confirmation.Generic(A_ROOM_ID),
+                progress = LeaveRoomState.Progress.Hidden,
+                error = LeaveRoomState.Error.Hidden,
+            ),
+            LeaveRoomState(
+                confirmation = LeaveRoomState.Confirmation.PrivateRoom(A_ROOM_ID),
+                progress = LeaveRoomState.Progress.Hidden,
+                error = LeaveRoomState.Error.Hidden,
+            ),
+            LeaveRoomState(
+                confirmation = LeaveRoomState.Confirmation.LastUserInRoom(A_ROOM_ID),
+                progress = LeaveRoomState.Progress.Hidden,
+                error = LeaveRoomState.Error.Hidden,
+            ),
+            LeaveRoomState(
+                confirmation = LeaveRoomState.Confirmation.Hidden,
+                progress = LeaveRoomState.Progress.Shown,
+                error = LeaveRoomState.Error.Hidden,
+            ),
+            LeaveRoomState(
+                confirmation = LeaveRoomState.Confirmation.Hidden,
+                progress = LeaveRoomState.Progress.Hidden,
+                error = LeaveRoomState.Error.Shown,
+            ),
+        )
+}
+
+private val A_ROOM_ID = RoomId("!aRoomId:aDomain")
--- a/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomView.kt
+++ b/features/leaveroom/api/src/main/kotlin/io/element/android/features/leaveroom/api/LeaveRoomView.kt
@ -0,0 +1,131 @@
+/*
+ * 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.leaveroom.api
+
+import androidx.annotation.StringRes
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.components.ProgressDialog
+import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
+import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.ui.strings.R
+import io.element.android.libraries.ui.strings.R as StringR
+
+@Composable
+fun LeaveRoomView(
+    state: LeaveRoomState
+) {
+    LeaveRoomConfirmationDialog(state)
+    LeaveRoomProgressDialog(state)
+    LeaveRoomErrorDialog(state)
+}
+
+@Composable
+private fun LeaveRoomConfirmationDialog(
+    state: LeaveRoomState,
+) {
+    when (state.confirmation) {
+        is LeaveRoomState.Confirmation.Hidden -> {}
+        is LeaveRoomState.Confirmation.PrivateRoom -> LeaveRoomConfirmationDialog(
+            text = StringR.string.leave_room_alert_private_subtitle,
+            roomId = state.confirmation.roomId,
+            eventSink = state.eventSink,
+        )
+
+        is LeaveRoomState.Confirmation.LastUserInRoom -> LeaveRoomConfirmationDialog(
+            text = StringR.string.leave_room_alert_empty_subtitle,
+            roomId = state.confirmation.roomId,
+            eventSink = state.eventSink,
+        )
+
+        is LeaveRoomState.Confirmation.Generic -> LeaveRoomConfirmationDialog(
+            text = StringR.string.leave_room_alert_subtitle,
+            roomId = state.confirmation.roomId,
+            eventSink = state.eventSink,
+        )
+    }
+}
+
+@Composable
+private fun LeaveRoomConfirmationDialog(
+    @StringRes text: Int,
+    roomId: RoomId,
+    eventSink: (LeaveRoomEvent) -> Unit,
+) {
+    ConfirmationDialog(
+        content = stringResource(text),
+        submitText = stringResource(R.string.action_leave),
+        onSubmitClicked = { eventSink(LeaveRoomEvent.LeaveRoom(roomId)) },
+        onDismiss = { eventSink(LeaveRoomEvent.HideConfirmation) },
+    )
+}
+
+@Composable
+private fun LeaveRoomProgressDialog(
+    state: LeaveRoomState,
+) {
+    when (state.progress) {
+        is LeaveRoomState.Progress.Hidden -> {}
+        is LeaveRoomState.Progress.Shown -> ProgressDialog(
+            text = stringResource(StringR.string.common_leaving_room),
+        )
+    }
+}
+
+@Composable
+private fun LeaveRoomErrorDialog(
+    state: LeaveRoomState,
+) {
+    when (state.error) {
+        is LeaveRoomState.Error.Hidden -> {}
+        is LeaveRoomState.Error.Shown -> ErrorDialog(
+            content = stringResource(StringR.string.error_unknown),
+            onDismiss = { state.eventSink(LeaveRoomEvent.HideError) }
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun LeaveRoomViewLightPreview(
+    @PreviewParameter(LeaveRoomStateProvider::class) state: LeaveRoomState
+) = ElementPreviewLight { ContentToPreview(state) }
+
+@Preview
+@Composable
+internal fun LeaveRoomViewDarkPreview(
+    @PreviewParameter(LeaveRoomStateProvider::class) state: LeaveRoomState
+) = ElementPreviewDark { ContentToPreview(state) }
+
+@Composable
+private fun ContentToPreview(state: LeaveRoomState) {
+    Box(
+        modifier = Modifier.size(300.dp, 300.dp),
+        propagateMinConstraints = true,
+    ) {
+        LeaveRoomView(state = state)
+    }
+}
--- a/features/leaveroom/fake/build.gradle.kts
+++ b/features/leaveroom/fake/build.gradle.kts
@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2022 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.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+    alias(libs.plugins.anvil)
+}
+
+android {
+    namespace = "io.element.android.features.leaveroom.fake"
+}
+
+anvil {
+    generateDaggerFactories.set(true)
+}
+
+dependencies {
+    implementation(projects.anvilannotations)
+    anvil(projects.anvilcodegen)
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    api(projects.features.leaveroom.api)
+
+    testImplementation(libs.test.junit)
+    testImplementation(libs.coroutines.test)
+    testImplementation(libs.coroutines.core)
+    testImplementation(libs.molecule.runtime)
+    testImplementation(libs.test.truth)
+    testImplementation(libs.test.turbine)
+}
--- a/features/leaveroom/fake/src/main/kotlin/io/element/android/features/leaveroom/fake/LeaveRoomPresenterFake.kt
+++ b/features/leaveroom/fake/src/main/kotlin/io/element/android/features/leaveroom/fake/LeaveRoomPresenterFake.kt
@ -0,0 +1,44 @@
+/*
+ * 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.leaveroom.fake
+
+import androidx.compose.runtime.Composable
+import io.element.android.features.leaveroom.api.LeaveRoomEvent
+import io.element.android.features.leaveroom.api.LeaveRoomPresenter
+import io.element.android.features.leaveroom.api.LeaveRoomState
+import javax.inject.Inject
+
+class LeaveRoomPresenterFake @Inject constructor() : LeaveRoomPresenter {
+
+    val events = mutableListOf<LeaveRoomEvent>()
+
+    private fun handleEvent(event: LeaveRoomEvent) {
+        events += event
+    }
+
+    private var state = LeaveRoomState(eventSink = ::handleEvent)
+        set(value) {
+            field = value.copy(eventSink = ::handleEvent)
+        }
+
+    fun givenState(state: LeaveRoomState) {
+        this.state = state
+    }
+
+    @Composable
+    override fun present(): LeaveRoomState = state
+}
--- a/features/leaveroom/fake/src/main/kotlin/io/element/android/features/leaveroom/fake/LeaveRoomPresenterFakeModule.kt
+++ b/features/leaveroom/fake/src/main/kotlin/io/element/android/features/leaveroom/fake/LeaveRoomPresenterFakeModule.kt
@ -0,0 +1,30 @@
+/*
+ * 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.leaveroom.fake
+
+import com.squareup.anvil.annotations.ContributesTo
+import dagger.Binds
+import dagger.Module
+import io.element.android.features.leaveroom.api.LeaveRoomPresenter
+import io.element.android.libraries.di.SessionScope
+
+@Module
+@ContributesTo(SessionScope::class)
+interface LeaveRoomPresenterFakeModule {
+    @Binds
+    fun leaveRoomPresenter(leaveRoomPresenter: LeaveRoomPresenterFake): LeaveRoomPresenter
+}
--- a/features/leaveroom/impl/build.gradle.kts
+++ b/features/leaveroom/impl/build.gradle.kts
@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2022 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.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+    alias(libs.plugins.anvil)
+}
+
+android {
+    namespace = "io.element.android.features.leaveroom.impl"
+}
+
+anvil {
+    generateDaggerFactories.set(true)
+}
+
+dependencies {
+    implementation(projects.anvilannotations)
+    anvil(projects.anvilcodegen)
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    api(projects.features.leaveroom.api)
+
+    testImplementation(libs.test.junit)
+    testImplementation(libs.coroutines.test)
+    testImplementation(libs.coroutines.core)
+    testImplementation(libs.molecule.runtime)
+    testImplementation(libs.test.truth)
+    testImplementation(libs.test.turbine)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.tests.testutils)
+}
--- a/features/leaveroom/impl/src/main/kotlin/io/element/android/features/leaveroom/impl/LeaveRoomPresenterImpl.kt
+++ b/features/leaveroom/impl/src/main/kotlin/io/element/android/features/leaveroom/impl/LeaveRoomPresenterImpl.kt
@ -0,0 +1,127 @@
+/*
+ * 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.leaveroom.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import io.element.android.features.leaveroom.api.LeaveRoomEvent
+import io.element.android.features.leaveroom.api.LeaveRoomPresenter
+import io.element.android.features.leaveroom.api.LeaveRoomState
+import io.element.android.features.leaveroom.api.LeaveRoomState.Confirmation.Generic
+import io.element.android.features.leaveroom.api.LeaveRoomState.Confirmation.LastUserInRoom
+import io.element.android.features.leaveroom.api.LeaveRoomState.Confirmation.PrivateRoom
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.MatrixRoom
+import io.element.android.libraries.matrix.api.room.MatrixRoomMembersState
+import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
+import io.element.android.libraries.matrix.api.room.RoomMembershipState
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+
+class LeaveRoomPresenterImpl @Inject constructor(
+    private val client: MatrixClient,
+    private val roomMembershipObserver: RoomMembershipObserver,
+    private val dispatchers: CoroutineDispatchers,
+) : LeaveRoomPresenter {
+    @Composable
+    override fun present(): LeaveRoomState {
+        val scope = rememberCoroutineScope()
+        val confirmation = remember { mutableStateOf<LeaveRoomState.Confirmation>(LeaveRoomState.Confirmation.Hidden) }
+        val progress = remember { mutableStateOf<LeaveRoomState.Progress>(LeaveRoomState.Progress.Hidden) }
+        val error = remember { mutableStateOf<LeaveRoomState.Error>(LeaveRoomState.Error.Hidden) }
+
+        return LeaveRoomState(
+            confirmation = confirmation.value,
+            progress = progress.value,
+            error = error.value,
+        ) { event ->
+            when (event) {
+                is LeaveRoomEvent.ShowConfirmation -> scope.launch(dispatchers.io) {
+                    showLeaveRoomAlert(
+                        matrixClient = client,
+                        roomId = event.roomId,
+                        confirmation = confirmation,
+                    )
+                }
+
+                is LeaveRoomEvent.HideConfirmation -> confirmation.value = LeaveRoomState.Confirmation.Hidden
+                is LeaveRoomEvent.LeaveRoom -> scope.launch(dispatchers.io) {
+                    client.leaveRoom(
+                        roomId = event.roomId,
+                        roomMembershipObserver = roomMembershipObserver,
+                        confirmation = confirmation,
+                        progress = progress,
+                        error = error,
+                    )
+                }
+
+                is LeaveRoomEvent.HideError -> error.value = LeaveRoomState.Error.Hidden
+            }
+        }
+    }
+}
+
+private suspend fun showLeaveRoomAlert(
+    matrixClient: MatrixClient,
+    roomId: RoomId,
+    confirmation: MutableState<LeaveRoomState.Confirmation>,
+) {
+    matrixClient.getRoom(roomId)?.use { room ->
+        confirmation.value = when {
+            !room.isPublic -> PrivateRoom(roomId)
+            (room.memberCount() as? Async.Success<Int>)?.state == 1 -> LastUserInRoom(roomId)
+            else -> Generic(roomId)
+        }
+    }
+}
+
+private suspend fun MatrixClient.leaveRoom(
+    roomId: RoomId,
+    roomMembershipObserver: RoomMembershipObserver,
+    confirmation: MutableState<LeaveRoomState.Confirmation>,
+    progress: MutableState<LeaveRoomState.Progress>,
+    error: MutableState<LeaveRoomState.Error>,
+) {
+    confirmation.value = LeaveRoomState.Confirmation.Hidden
+    progress.value = LeaveRoomState.Progress.Shown
+    getRoom(roomId)?.use { room ->
+        room.leave().onSuccess {
+            roomMembershipObserver.notifyUserLeftRoom(room.roomId)
+        }.onFailure {
+            Timber.e(it, "Error while leaving room ${room.name} - ${room.roomId}")
+            error.value = LeaveRoomState.Error.Shown
+        }
+    }
+    progress.value = LeaveRoomState.Progress.Hidden
+}
+
+private suspend fun MatrixRoom.memberCount(): Async<Int> = membersStateFlow.first().let { membersState ->
+    when (membersState) {
+        MatrixRoomMembersState.Unknown -> Async.Uninitialized
+        is MatrixRoomMembersState.Pending -> Async.Loading(prevState = membersState.prevRoomMembers?.size)
+        is MatrixRoomMembersState.Error -> Async.Failure(membersState.failure, prevState = membersState.prevRoomMembers?.size)
+        is MatrixRoomMembersState.Ready -> Async.Success(membersState.roomMembers.count { it.membership == RoomMembershipState.JOIN })
+    }
+}
--- a/features/leaveroom/impl/src/main/kotlin/io/element/android/features/leaveroom/impl/LeaveRoomPresenterImplModule.kt
+++ b/features/leaveroom/impl/src/main/kotlin/io/element/android/features/leaveroom/impl/LeaveRoomPresenterImplModule.kt
@ -0,0 +1,30 @@
+/*
+ * 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.leaveroom.impl
+
+import com.squareup.anvil.annotations.ContributesTo
+import dagger.Binds
+import dagger.Module
+import io.element.android.features.leaveroom.api.LeaveRoomPresenter
+import io.element.android.libraries.di.SessionScope
+
+@Module
+@ContributesTo(SessionScope::class)
+interface LeaveRoomPresenterImplModule {
+    @Binds
+    fun leaveRoomPresenter(leaveRoomPresenter: LeaveRoomPresenterImpl): LeaveRoomPresenter
+}
--- a/features/leaveroom/impl/src/test/kotlin/io/element/android/features/leaveroom/impl/LeaveRoomPresenterImplTest.kt
+++ b/features/leaveroom/impl/src/test/kotlin/io/element/android/features/leaveroom/impl/LeaveRoomPresenterImplTest.kt
@ -0,0 +1,248 @@
+/*
+ * 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.leaveroom.impl
+
+import app.cash.molecule.RecompositionClock
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.leaveroom.api.LeaveRoomEvent
+import io.element.android.features.leaveroom.api.LeaveRoomPresenter
+import io.element.android.features.leaveroom.api.LeaveRoomState
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.api.room.MatrixRoomMembersState
+import io.element.android.libraries.matrix.api.room.RoomMember
+import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
+import io.element.android.libraries.matrix.api.room.RoomMembershipState
+import io.element.android.libraries.matrix.api.timeline.item.event.MembershipChange
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
+import io.element.android.tests.testutils.testCoroutineDispatchers
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.test.runTest
+import org.junit.Ignore
+import org.junit.Test
+
+class LeaveRoomPresenterImplTest {
+
+    @Test
+    fun `present - initial state hides all dialogs`() = runTest {
+        val presenter = createPresenter()
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.confirmation).isEqualTo(LeaveRoomState.Confirmation.Hidden)
+            assertThat(initialState.progress).isEqualTo(LeaveRoomState.Progress.Hidden)
+            assertThat(initialState.error).isEqualTo(LeaveRoomState.Error.Hidden)
+        }
+    }
+
+    @Test
+    fun `present - show generic confirmation`() = runTest {
+        val presenter = createPresenter(
+            client = FakeMatrixClient().apply {
+                givenGetRoomResult(
+                    roomId = A_ROOM_ID,
+                    result = FakeMatrixRoom()
+                )
+            }
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(LeaveRoomEvent.ShowConfirmation(A_ROOM_ID))
+            val confirmationState = awaitItem()
+            assertThat(confirmationState.confirmation).isEqualTo(LeaveRoomState.Confirmation.Generic(A_ROOM_ID))
+        }
+    }
+
+    @Test
+    fun `present - show private room confirmation`() = runTest {
+        val presenter = createPresenter(
+            client = FakeMatrixClient().apply {
+                givenGetRoomResult(
+                    roomId = A_ROOM_ID,
+                    result = FakeMatrixRoom(isPublic = false),
+                )
+            }
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(LeaveRoomEvent.ShowConfirmation(A_ROOM_ID))
+            val confirmationState = awaitItem()
+            assertThat(confirmationState.confirmation).isEqualTo(LeaveRoomState.Confirmation.PrivateRoom(A_ROOM_ID))
+        }
+    }
+
+    @Test
+    fun `present - show last user in room confirmation`() = runTest {
+        val presenter = createPresenter(
+            client = FakeMatrixClient().apply {
+                givenGetRoomResult(
+                    roomId = A_ROOM_ID,
+                    result = FakeMatrixRoom().apply {
+                        givenRoomMembersState(
+                            MatrixRoomMembersState.Ready(
+                                listOf(
+                                    RoomMember(
+                                        userId = UserId(value = "@aUserId:aDomain"),
+                                        displayName = null,
+                                        avatarUrl = null,
+                                        membership = RoomMembershipState.JOIN,
+                                        isNameAmbiguous = false,
+                                        powerLevel = 0,
+                                        normalizedPowerLevel = 0,
+                                        isIgnored = false
+                                    )
+                                )
+                            )
+                        )
+                    },
+                )
+            }
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(LeaveRoomEvent.ShowConfirmation(A_ROOM_ID))
+            val confirmationState = awaitItem()
+            assertThat(confirmationState.confirmation).isEqualTo(LeaveRoomState.Confirmation.LastUserInRoom(A_ROOM_ID))
+        }
+    }
+
+    @Test
+    fun `present - leaving a room leaves the room`() = runTest {
+        val roomMembershipObserver = RoomMembershipObserver()
+        val presenter = createPresenter(
+            client = FakeMatrixClient().apply {
+                givenGetRoomResult(
+                    roomId = A_ROOM_ID,
+                    result = FakeMatrixRoom(),
+                )
+            },
+            roomMembershipObserver = roomMembershipObserver
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(LeaveRoomEvent.LeaveRoom(A_ROOM_ID))
+            cancelAndIgnoreRemainingEvents()
+        }
+
+        // Membership observer should receive a 'left room' change
+        roomMembershipObserver.updates.take(1)
+            .onEach { update -> assertThat(update.change).isEqualTo(MembershipChange.LEFT) }
+            .collect()
+    }
+
+    @Test
+    fun `present - show error if leave room fails`() = runTest {
+        val presenter = createPresenter(
+            client = FakeMatrixClient().apply {
+                givenGetRoomResult(
+                    roomId = A_ROOM_ID,
+                    result = FakeMatrixRoom().apply {
+                        givenLeaveRoomError(RuntimeException("Blimey!"))
+                    },
+                )
+            }
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(LeaveRoomEvent.LeaveRoom(A_ROOM_ID))
+            val errorState = awaitItem()
+            assertThat(errorState.error).isEqualTo(LeaveRoomState.Error.Shown)
+        }
+    }
+
+    @Test
+    @Ignore("TODO(Test the hiding/showing of the progress indicator too)")
+    fun `present - show progress indicator while leaving a room`() = runTest {
+        val roomMembershipObserver = RoomMembershipObserver()
+        val presenter = createPresenter(
+            client = FakeMatrixClient().apply {
+                givenGetRoomResult(
+                    roomId = A_ROOM_ID,
+                    result = FakeMatrixRoom(),
+                )
+            }
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(LeaveRoomEvent.LeaveRoom(A_ROOM_ID))
+            val progressState = awaitItem()
+            assertThat(progressState.progress).isEqualTo(LeaveRoomState.Progress.Shown)
+            val finalState = awaitItem()
+            assertThat(finalState.progress).isEqualTo(LeaveRoomState.Progress.Hidden)
+        }
+
+        // Membership observer should receive a 'left room' change
+        roomMembershipObserver.updates.take(1)
+            .onEach { update -> assertThat(update.change).isEqualTo(MembershipChange.LEFT) }
+            .collect()
+    }
+
+    @Test
+    fun `present - hide error hides the error`() = runTest {
+        val presenter = createPresenter(
+            client = FakeMatrixClient().apply {
+                givenGetRoomResult(
+                    roomId = A_ROOM_ID,
+                    result = FakeMatrixRoom().apply {
+                        givenLeaveRoomError(RuntimeException("Blimey!"))
+                    },
+                )
+            }
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(LeaveRoomEvent.LeaveRoom(A_ROOM_ID))
+            val errorState = awaitItem()
+            assertThat(errorState.error).isEqualTo(LeaveRoomState.Error.Shown)
+            errorState.eventSink(LeaveRoomEvent.HideError)
+            val hiddenErrorState = awaitItem()
+            assertThat(hiddenErrorState.error).isEqualTo(LeaveRoomState.Error.Hidden)
+        }
+    }
+}
+
+private fun createPresenter(
+    client: MatrixClient = FakeMatrixClient(),
+    roomMembershipObserver: RoomMembershipObserver = RoomMembershipObserver(),
+    dispatchers: CoroutineDispatchers = testCoroutineDispatchers(),
+): LeaveRoomPresenter = LeaveRoomPresenterImpl(
+    client = client,
+    roomMembershipObserver = roomMembershipObserver,
+    dispatchers = dispatchers,
+)