Accepting and declining invites

Hook up accept and decline buttons in the invites UI. Accept will attempt to accept and then navigate to the room; decline shows a confirmation dialog. Fixes #106
2023-04-20 16:13:14 +01:00 · 2023-04-20 16:13:14 +01:00 · ff5672597a
commit ff5672597a
parent 114e9725fa
26 changed files with 582 additions and 77 deletions
--- a/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListEvents.kt
+++ b/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListEvents.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.invitelist.impl
+
+import io.element.android.features.invitelist.impl.model.InviteListInviteSummary
+
+sealed interface InviteListEvents {
+
+    data class AcceptInvite(val invite: InviteListInviteSummary) : InviteListEvents
+    data class DeclineInvite(val invite: InviteListInviteSummary) : InviteListEvents
+
+    object ConfirmDeclineInvite: InviteListEvents
+    object CancelDeclineInvite: InviteListEvents
+
+    object DismissAcceptError: InviteListEvents
+    object DismissDeclineError: InviteListEvents
+
+}
--- a/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListNode.kt
+++ b/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListNode.kt
@ -27,6 +27,7 @@ import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
 import io.element.android.features.invitelist.api.InviteListEntryPoint
 import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.core.RoomId

@ContributesNode(SessionScope::class)
 class InviteListNode @AssistedInject constructor(
@ -39,12 +40,17 @@ class InviteListNode @AssistedInject constructor(
        plugins<InviteListEntryPoint.Callback>().forEach { it.onBackClicked() }
    }

+    private fun onInviteAccepted(roomId: RoomId) {
+        plugins<InviteListEntryPoint.Callback>().forEach { it.onInviteAccepted(roomId) }
+    }
+
    @Composable
    override fun View(modifier: Modifier) {
        val state = presenter.present()
        InviteListView(
            state = state,
            onBackClicked = ::onBackClicked,
+            onInviteAccepted = ::onInviteAccepted,
        )
    }
 }
--- a/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListPresenter.kt
+++ b/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListPresenter.kt
@ -17,15 +17,24 @@
 package io.element.android.features.invitelist.impl

 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import io.element.android.features.invitelist.impl.model.InviteListInviteSummary
 import io.element.android.features.invitelist.impl.model.InviteSender
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.architecture.execute
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
 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.RoomSummary
 import kotlinx.collections.immutable.toPersistentList
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 import javax.inject.Inject

 class InviteListPresenter @Inject constructor(
@ -39,11 +48,71 @@ class InviteListPresenter @Inject constructor(
            .roomSummaries()
            .collectAsState()

+        val localCoroutineScope = rememberCoroutineScope()
+        val acceptedAction: MutableState<Async<RoomId>> = remember { mutableStateOf(Async.Uninitialized) }
+        val declinedAction: MutableState<Async<Unit>> = remember { mutableStateOf(Async.Uninitialized) }
+        val decliningInvite: MutableState<InviteListInviteSummary?> = remember { mutableStateOf(null) }
+
+        fun handleEvent(event: InviteListEvents) {
+            when (event) {
+                is InviteListEvents.AcceptInvite -> {
+                    acceptedAction.value = Async.Uninitialized
+                    localCoroutineScope.acceptInvite(event.invite.roomId, acceptedAction)
+                }
+
+                is InviteListEvents.DeclineInvite -> {
+                    decliningInvite.value = event.invite
+                }
+
+                is InviteListEvents.ConfirmDeclineInvite -> {
+                    declinedAction.value = Async.Uninitialized
+                    decliningInvite.value?.let {
+                        localCoroutineScope.declineInvite(it.roomId, declinedAction)
+                    }
+                    decliningInvite.value = null
+                }
+
+                is InviteListEvents.CancelDeclineInvite -> {
+                    decliningInvite.value = null
+                }
+
+                is InviteListEvents.DismissAcceptError -> {
+                    acceptedAction.value = Async.Uninitialized
+                }
+
+                is InviteListEvents.DismissDeclineError -> {
+                    declinedAction.value = Async.Uninitialized
+                }
+            }
+        }
+
        return InviteListState(
            inviteList = invites.mapNotNull(::toInviteSummary).toPersistentList(),
+            declineConfirmationDialog = decliningInvite.value?.let {
+                InviteDeclineConfirmationDialog.Visible(
+                    isDirect = it.isDirect,
+                    name = it.roomName,
+                )
+            } ?: InviteDeclineConfirmationDialog.Hidden,
+            acceptedAction = acceptedAction.value,
+            declinedAction = declinedAction.value,
+            eventSink = ::handleEvent
        )
    }

+    private fun CoroutineScope.acceptInvite(roomId: RoomId, acceptedAction: MutableState<Async<RoomId>>) = launch {
+        suspend {
+            client.getRoom(roomId)?.acceptInvitation()?.getOrThrow()
+            roomId
+        }.execute(acceptedAction)
+    }
+
+    private fun CoroutineScope.declineInvite(roomId: RoomId, declinedAction: MutableState<Async<Unit>>) = launch {
+        suspend {
+            client.getRoom(roomId)?.rejectInvitation()?.getOrThrow() ?: Unit
+        }.execute(declinedAction)
+    }
+
    private fun toInviteSummary(roomSummary: RoomSummary): InviteListInviteSummary? {
        return when (roomSummary) {
            is RoomSummary.Filled -> roomSummary.details.run {
@ -71,6 +140,7 @@ class InviteListPresenter @Inject constructor(
                    roomName = name,
                    roomAlias = alias,
                    roomAvatarData = avatarData,
+                    isDirect = isDirect,
                    sender = if (isDirect) null else inviter?.let {
                        InviteSender(
                            userId = it.userId,
@ -81,9 +151,10 @@ class InviteListPresenter @Inject constructor(
                                url = it.avatarUrl,
                            ),
                        )
-                    }
+                    },
                )
            }
+
            else -> null
        }
    }
--- a/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListState.kt
+++ b/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListState.kt
@ -18,9 +18,20 @@ package io.element.android.features.invitelist.impl

 import androidx.compose.runtime.Immutable
 import io.element.android.features.invitelist.impl.model.InviteListInviteSummary
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.matrix.api.core.RoomId
 import kotlinx.collections.immutable.ImmutableList

@Immutable
 data class InviteListState(
-    val inviteList: ImmutableList<InviteListInviteSummary>
+    val inviteList: ImmutableList<InviteListInviteSummary>,
+    val declineConfirmationDialog: InviteDeclineConfirmationDialog = InviteDeclineConfirmationDialog.Hidden,
+    val acceptedAction: Async<RoomId> = Async.Uninitialized,
+    val declinedAction: Async<Unit> = Async.Uninitialized,
+    val eventSink: (InviteListEvents) -> Unit = {}
 )
+
+sealed interface InviteDeclineConfirmationDialog {
+    object Hidden : InviteDeclineConfirmationDialog
+    data class Visible(val isDirect: Boolean, val name: String) : InviteDeclineConfirmationDialog
+}
--- a/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListStateProvider.kt
+++ b/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListStateProvider.kt
@ -19,6 +19,7 @@ package io.element.android.features.invitelist.impl
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import io.element.android.features.invitelist.impl.model.InviteListInviteSummary
 import io.element.android.features.invitelist.impl.model.InviteSender
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.UserId
 import kotlinx.collections.immutable.ImmutableList
@ -28,7 +29,11 @@ open class InviteListStateProvider : PreviewParameterProvider<InviteListState> {
    override val values: Sequence<InviteListState>
        get() = sequenceOf(
            aInviteListState(),
-            aInviteListState().copy(inviteList = persistentListOf())
+            aInviteListState().copy(inviteList = persistentListOf()),
+            aInviteListState().copy(declineConfirmationDialog = InviteDeclineConfirmationDialog.Visible(true, "Alice")),
+            aInviteListState().copy(declineConfirmationDialog = InviteDeclineConfirmationDialog.Visible(false, "Some Room")),
+            aInviteListState().copy(acceptedAction = Async.Failure(Throwable("Whoops"))),
+            aInviteListState().copy(declinedAction = Async.Failure(Throwable("Whoops"))),
        )
 }

--- a/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListView.kt
+++ b/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/InviteListView.kt
@ -26,6 +26,7 @@ import androidx.compose.foundation.lazy.items
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
@ -33,7 +34,10 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import io.element.android.features.invitelist.impl.components.InviteSummaryRow
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.designsystem.components.button.BackButton
+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.designsystem.theme.components.Scaffold
@ -47,16 +51,56 @@ fun InviteListView(
    state: InviteListState,
    modifier: Modifier = Modifier,
    onBackClicked: () -> Unit = {},
-    onAcceptClicked: (RoomId) -> Unit = {},
-    onDeclineClicked: (RoomId) -> Unit = {},
+    onInviteAccepted: (RoomId) -> Unit = {},
 ) {
+    if (state.acceptedAction is Async.Success) {
+        LaunchedEffect(state.acceptedAction) {
+            onInviteAccepted(state.acceptedAction.state)
+        }
+    }
+
    InviteListContent(
        state = state,
        modifier = modifier,
        onBackClicked = onBackClicked,
-        onAcceptClicked = onAcceptClicked,
-        onDeclineClicked = onDeclineClicked,
    )
+
+    if (state.declineConfirmationDialog is InviteDeclineConfirmationDialog.Visible) {
+        val contentResource = if (state.declineConfirmationDialog.isDirect)
+            R.string.screen_invites_decline_direct_chat_message
+        else
+            R.string.screen_invites_decline_chat_message
+
+        val titleResource = if (state.declineConfirmationDialog.isDirect)
+            R.string.screen_invites_decline_direct_chat_title
+        else
+            R.string.screen_invites_decline_chat_title
+
+        ConfirmationDialog(
+            content = stringResource(contentResource, state.declineConfirmationDialog.name),
+            title = stringResource(titleResource),
+            onSubmitClicked = { state.eventSink(InviteListEvents.ConfirmDeclineInvite) },
+            onDismiss = { state.eventSink(InviteListEvents.CancelDeclineInvite) }
+        )
+    }
+
+    if (state.acceptedAction is Async.Failure) {
+        ErrorDialog(
+            content = stringResource(StringR.string.error_unknown),
+            title = stringResource(StringR.string.common_error),
+            submitText = stringResource(StringR.string.action_ok),
+            onDismiss = { state.eventSink(InviteListEvents.DismissAcceptError) }
+        )
+    }
+
+    if (state.declinedAction is Async.Failure) {
+        ErrorDialog(
+            content = stringResource(StringR.string.error_unknown),
+            title = stringResource(StringR.string.common_error),
+            submitText = stringResource(StringR.string.action_ok),
+            onDismiss = { state.eventSink(InviteListEvents.DismissDeclineError) }
+        )
+    }
 }

@OptIn(ExperimentalMaterial3Api::class)
@ -65,8 +109,6 @@ fun InviteListContent(
    state: InviteListState,
    modifier: Modifier = Modifier,
    onBackClicked: () -> Unit = {},
-    onAcceptClicked: (RoomId) -> Unit = {},
-    onDeclineClicked: (RoomId) -> Unit = {},
 ) {
    Scaffold(
        modifier = modifier,
@ -102,8 +144,8 @@ fun InviteListContent(
                        ) { invite ->
                            InviteSummaryRow(
                                invite = invite,
-                                onAcceptClicked = onAcceptClicked,
-                                onDeclineClicked = onDeclineClicked,
+                                onAcceptClicked = { state.eventSink(InviteListEvents.AcceptInvite(invite)) },
+                                onDeclineClicked = { state.eventSink(InviteListEvents.DeclineInvite(invite)) },
                            )
                        }
                    }
--- a/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/components/InviteSummaryRow.kt
+++ b/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/components/InviteSummaryRow.kt
@ -59,7 +59,6 @@ import io.element.android.libraries.designsystem.preview.ElementPreviewLight
 import io.element.android.libraries.designsystem.theme.components.Button
 import io.element.android.libraries.designsystem.theme.components.OutlinedButton
 import io.element.android.libraries.designsystem.theme.components.Text
-import io.element.android.libraries.matrix.api.core.RoomId
 import kotlinx.collections.immutable.persistentMapOf
 import io.element.android.libraries.ui.strings.R as StringR

@ -69,8 +68,8 @@ private val minHeight = 72.dp
 internal fun InviteSummaryRow(
    invite: InviteListInviteSummary,
    modifier: Modifier = Modifier,
-    onAcceptClicked: (RoomId) -> Unit = {},
-    onDeclineClicked: (RoomId) -> Unit = {},
+    onAcceptClicked: () -> Unit = {},
+    onDeclineClicked: () -> Unit = {},
 ) {
    Box(
        modifier = modifier
@ -88,8 +87,8 @@ internal fun InviteSummaryRow(
@Composable
 internal fun DefaultInviteSummaryRow(
    invite: InviteListInviteSummary,
-    onAcceptClicked: (RoomId) -> Unit = {},
-    onDeclineClicked: (RoomId) -> Unit = {},
+    onAcceptClicked: () -> Unit = {},
+    onDeclineClicked: () -> Unit = {},
 ) {
    Row(
        modifier = Modifier
@ -138,7 +137,7 @@ internal fun DefaultInviteSummaryRow(
            Row(Modifier.padding(top = 12.dp)) {
                OutlinedButton(
                    content = { Text(stringResource(StringR.string.action_decline), style = ElementTextStyles.Button) },
-                    onClick = { onDeclineClicked(invite.roomId) },
+                    onClick = onDeclineClicked,
                    modifier = Modifier.weight(1f),
                    contentPadding = PaddingValues(horizontal = 24.dp, vertical = 7.dp),
                )
@ -147,7 +146,7 @@ internal fun DefaultInviteSummaryRow(

                Button(
                    content = { Text(stringResource(StringR.string.action_accept), style = ElementTextStyles.Button) },
-                    onClick = { onAcceptClicked(invite.roomId) },
+                    onClick = onAcceptClicked,
                    modifier = Modifier.weight(1f),
                    contentPadding = PaddingValues(horizontal = 24.dp, vertical = 7.dp),
                )
--- a/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/model/InviteListInviteSummary.kt
+++ b/features/invitelist/impl/src/main/kotlin/io/element/android/features/invitelist/impl/model/InviteListInviteSummary.kt
@ -27,7 +27,8 @@ data class InviteListInviteSummary(
    val roomName: String = "",
    val roomAlias: String? = null,
    val roomAvatarData: AvatarData = AvatarData(roomId.value, roomName),
-    val sender: InviteSender? = null
+    val sender: InviteSender? = null,
+    val isDirect: Boolean = false
 )

 data class InviteSender(