Force last owner of a room to pass ownership when leaving (#5094)

* Move `ChangeRoles*` classes to their own module so they can be shared

* Hook the change roles screen to the leave room action, add confirmation dialogs

* Use enum instead of sealed interface for `ChangeRoomMemberRolesListType`

* Try to improve communications between nodes

* refactor (leave room) : makes sure to expose only necessary code from api module

* Add `:libraries:previewutils` module to share some test fixtures used for UI previews

* Update screenshots

---------

Co-authored-by: ElementBot <android@element.io>
Co-authored-by: ganfra <francoisg@matrix.org>

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsEvent.kt

@@ -8,7 +8,7 @@
 package io.element.android.features.roomdetails.impl
 
 sealed interface RoomDetailsEvent {
-    data object LeaveRoom : RoomDetailsEvent
+    data class LeaveRoom(val needsConfirmation: Boolean) : RoomDetailsEvent
     data object MuteNotification : RoomDetailsEvent
     data object UnmuteNotification : RoomDetailsEvent
     data class CopyToClipboard(val text: String) : RoomDetailsEvent

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsFlowNode.kt

@@ -11,6 +11,8 @@ import android.os.Parcelable
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.ui.Modifier
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.coroutineScope
 import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.plugin.Plugin
@@ -25,6 +27,8 @@ import io.element.android.anvilannotations.ContributesNode
 import io.element.android.appconfig.LearnMoreConfig
 import io.element.android.features.call.api.CallType
 import io.element.android.features.call.api.ElementCallEntryPoint
+import io.element.android.features.changeroommemberroes.api.ChangeRoomMemberRolesEntryPoint
+import io.element.android.features.changeroommemberroes.api.ChangeRoomMemberRolesListType
 import io.element.android.features.knockrequests.api.list.KnockRequestsListEntryPoint
 import io.element.android.features.messages.api.MessagesEntryPoint
 import io.element.android.features.poll.api.history.PollHistoryEntryPoint
@@ -51,12 +55,15 @@ import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.core.toRoomIdOrAlias
 import io.element.android.libraries.matrix.api.permalink.PermalinkData
-import io.element.android.libraries.matrix.api.room.BaseRoom
+import io.element.android.libraries.matrix.api.room.JoinedRoom
 import io.element.android.libraries.matrix.api.verification.VerificationRequest
 import io.element.android.libraries.mediaviewer.api.MediaGalleryEntryPoint
 import io.element.android.libraries.mediaviewer.api.MediaViewerEntryPoint
 import io.element.android.services.analytics.api.AnalyticsService
 import io.element.android.services.analyticsproviders.api.trackers.captureInteraction
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import kotlinx.parcelize.Parcelize
 
 @ContributesNode(RoomScope::class)
@@ -65,7 +72,7 @@ class RoomDetailsFlowNode @AssistedInject constructor(
     @Assisted plugins: List<Plugin>,
     private val pollHistoryEntryPoint: PollHistoryEntryPoint,
     private val elementCallEntryPoint: ElementCallEntryPoint,
-    private val room: BaseRoom,
+    private val room: JoinedRoom,
     private val analyticsService: AnalyticsService,
     private val messagesEntryPoint: MessagesEntryPoint,
     private val knockRequestsListEntryPoint: KnockRequestsListEntryPoint,
@@ -73,6 +80,7 @@ class RoomDetailsFlowNode @AssistedInject constructor(
     private val mediaGalleryEntryPoint: MediaGalleryEntryPoint,
     private val outgoingVerificationEntryPoint: OutgoingVerificationEntryPoint,
     private val reportRoomEntryPoint: ReportRoomEntryPoint,
+    private val changeRoomMemberRolesEntryPoint: ChangeRoomMemberRolesEntryPoint,
 ) : BaseFlowNode<RoomDetailsFlowNode.NavTarget>(
     backstack = BackStack(
         initialElement = plugins.filterIsInstance<RoomDetailsEntryPoint.Params>().first().initialElement.toNavTarget(),
@@ -132,6 +140,24 @@ class RoomDetailsFlowNode @AssistedInject constructor(
 
         @Parcelize
         data object ReportRoom : NavTarget
+
+        @Parcelize
+        data object SelectNewOwnersWhenLeaving : NavTarget
+    }
+
+    override fun onBuilt() {
+        super.onBuilt()
+        whenChildrenAttached { commonLifecycle: Lifecycle,
+                               roomDetailsNode: RoomDetailsNode,
+                               changeRoomMemberRolesNode: ChangeRoomMemberRolesEntryPoint.NodeProxy ->
+            commonLifecycle.coroutineScope.launch {
+                changeRoomMemberRolesNode.waitForRoleChanged()
+                withContext(NonCancellable) {
+                    backstack.pop()
+                    roomDetailsNode.onNewOwnersSelected()
+                }
+            }
+        }
     }
 
     override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
@@ -198,6 +224,10 @@ class RoomDetailsFlowNode @AssistedInject constructor(
                     override fun openReportRoom() {
                         backstack.push(NavTarget.ReportRoom)
                     }
+
+                    override fun onSelectNewOwnersWhenLeaving() {
+                        backstack.push(NavTarget.SelectNewOwnersWhenLeaving)
+                    }
                 }
                 createNode<RoomDetailsNode>(buildContext, listOf(roomDetailsCallback))
             }
@@ -330,7 +360,7 @@ class RoomDetailsFlowNode @AssistedInject constructor(
             is NavTarget.VerifyUser -> {
                 val params = OutgoingVerificationEntryPoint.Params(
                     showDeviceVerifiedScreen = true,
-                    verificationRequest = VerificationRequest.Outgoing.User(userId = navTarget.userId,)
+                    verificationRequest = VerificationRequest.Outgoing.User(userId = navTarget.userId)
                 )
                 outgoingVerificationEntryPoint.nodeBuilder(this, buildContext)
                     .params(params)
@@ -352,6 +382,13 @@ class RoomDetailsFlowNode @AssistedInject constructor(
             is NavTarget.ReportRoom -> {
                 reportRoomEntryPoint.createNode(this, buildContext, room.roomId)
             }
+
+            is NavTarget.SelectNewOwnersWhenLeaving -> {
+                changeRoomMemberRolesEntryPoint.builder(this, buildContext)
+                    .room(room)
+                    .listType(ChangeRoomMemberRolesListType.SelectNewOwnersWhenLeaving)
+                    .build()
+            }
         }
     }
 

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsNode.kt

@@ -9,6 +9,8 @@ package io.element.android.features.roomdetails.impl
 
 import android.content.Context
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.lifecycle.lifecycleScope
@@ -21,7 +23,9 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import im.vector.app.features.analytics.plan.MobileScreen
 import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.leaveroom.api.LeaveRoomRenderer
 import io.element.android.libraries.androidutils.system.startSharePlainTextIntent
+import io.element.android.libraries.architecture.appyx.launchMolecule
 import io.element.android.libraries.di.RoomScope
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.room.BaseRoom
@@ -38,6 +42,7 @@ class RoomDetailsNode @AssistedInject constructor(
     private val presenter: RoomDetailsPresenter,
     private val room: BaseRoom,
     private val analyticsService: AnalyticsService,
+    private val leaveRoomRenderer: LeaveRoomRenderer,
 ) : Node(buildContext, plugins = plugins) {
     interface Callback : Plugin {
         fun openRoomMemberList()
@@ -54,9 +59,10 @@ class RoomDetailsNode @AssistedInject constructor(
         fun openDmUserProfile(userId: UserId)
         fun onJoinCall()
         fun openReportRoom()
+        fun onSelectNewOwnersWhenLeaving()
     }
 
-    private val callbacks = plugins<Callback>()
+    private val callback = plugins<Callback>().first()
 
     init {
         lifecycle.subscribe(
@@ -67,27 +73,27 @@ class RoomDetailsNode @AssistedInject constructor(
     }
 
     private fun openRoomMemberList() {
-        callbacks.forEach { it.openRoomMemberList() }
+        callback.openRoomMemberList()
     }
 
     private fun openRoomNotificationSettings() {
-        callbacks.forEach { it.openRoomNotificationSettings() }
+        callback.openRoomNotificationSettings()
     }
 
     private fun invitePeople() {
-        callbacks.forEach { it.openInviteMembers() }
+        callback.openInviteMembers()
     }
 
     private fun openPollHistory() {
-        callbacks.forEach { it.openPollHistory() }
+        callback.openPollHistory()
     }
 
     private fun openMediaGallery() {
-        callbacks.forEach { it.openMediaGallery() }
+        callback.openMediaGallery()
     }
 
     private fun onJoinCall() {
-        callbacks.forEach { it.onJoinCall() }
+        callback.onJoinCall()
     }
 
     private fun CoroutineScope.onShareRoom(context: Context) = launch {
@@ -106,41 +112,51 @@ class RoomDetailsNode @AssistedInject constructor(
     }
 
     private fun onEditRoomDetails() {
-        callbacks.forEach { it.editRoomDetails() }
+        callback.editRoomDetails()
     }
 
     private fun openAvatarPreview(name: String, url: String) {
-        callbacks.forEach { it.openAvatarPreview(name, url) }
+        callback.openAvatarPreview(name, url)
     }
 
     private fun openAdminSettings() {
-        callbacks.forEach { it.openAdminSettings() }
+        callback.openAdminSettings()
     }
 
     private fun openPinnedMessages() {
-        callbacks.forEach { it.openPinnedMessagesList() }
+        callback.openPinnedMessagesList()
     }
 
     private fun openKnockRequestsLists() {
-        callbacks.forEach { it.openKnockRequestsList() }
+        callback.openKnockRequestsList()
     }
 
     private fun openSecurityAndPrivacy() {
-        callbacks.forEach { it.openSecurityAndPrivacy() }
+        callback.openSecurityAndPrivacy()
     }
 
     private fun onProfileClick(userId: UserId) {
-        callbacks.forEach { it.openDmUserProfile(userId) }
+        callback.openDmUserProfile(userId)
     }
 
     private fun onReportRoomClick() {
-        callbacks.forEach { it.openReportRoom() }
+        callback.openReportRoom()
+    }
+
+    private fun onSelectNewOwnersWhenLeaving() {
+        return callback.onSelectNewOwnersWhenLeaving()
+    }
+
+    private val stateFlow = launchMolecule { presenter.present() }
+
+    fun onNewOwnersSelected() {
+        stateFlow.value.eventSink(RoomDetailsEvent.LeaveRoom(needsConfirmation = false))
     }
 
     @Composable
     override fun View(modifier: Modifier) {
         val context = LocalContext.current
-        val state = presenter.present()
+        val state by stateFlow.collectAsState()
 
         fun onShareRoom() {
             lifecycleScope.onShareRoom(context)
@@ -172,6 +188,13 @@ class RoomDetailsNode @AssistedInject constructor(
             onSecurityAndPrivacyClick = ::openSecurityAndPrivacy,
             onProfileClick = ::onProfileClick,
             onReportRoomClick = ::onReportRoomClick,
+            leaveRoomView = {
+                leaveRoomRenderer.Render(
+                    state = state.leaveRoomState,
+                    onSelectNewOwners = { onSelectNewOwnersWhenLeaving() },
+                    modifier = Modifier
+                )
+            }
         )
     }
 }

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsPresenter.kt

@@ -149,8 +149,9 @@ class RoomDetailsPresenter @Inject constructor(
 
         fun handleEvents(event: RoomDetailsEvent) {
             when (event) {
-                RoomDetailsEvent.LeaveRoom ->
-                    leaveRoomState.eventSink(LeaveRoomEvent.ShowConfirmation(room.roomId))
+                is RoomDetailsEvent.LeaveRoom -> {
+                    leaveRoomState.eventSink(LeaveRoomEvent.LeaveRoom(room.roomId, needsConfirmation = event.needsConfirmation))
+                }
                 RoomDetailsEvent.MuteNotification -> {
                     scope.launch(dispatchers.io) {
                         client.notificationSettingsService().muteRoom(room.roomId)

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsStateProvider.kt

@@ -8,8 +8,8 @@
 package io.element.android.features.roomdetails.impl
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.leaveroom.api.LeaveRoomEvent
 import io.element.android.features.leaveroom.api.LeaveRoomState
-import io.element.android.features.leaveroom.api.aLeaveRoomState
 import io.element.android.features.roomcall.api.RoomCallState
 import io.element.android.features.roomcall.api.aStandByCallState
 import io.element.android.features.roomdetails.impl.members.aRoomMember
@@ -156,6 +156,12 @@ fun aRoomDetailsState(
     eventSink = eventSink,
 )
 
+internal fun aLeaveRoomState(
+    eventSink: (LeaveRoomEvent) -> Unit = {}
+) = object : LeaveRoomState {
+    override val eventSink: (LeaveRoomEvent) -> Unit = eventSink
+}
+
 fun aRoomNotificationSettings(
     mode: RoomNotificationMode = RoomNotificationMode.MUTE,
     isDefault: Boolean = false,

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsView.kt

@@ -38,7 +38,6 @@ import androidx.compose.ui.unit.dp
 import im.vector.app.features.analytics.plan.Interaction
 import io.element.android.compound.theme.ElementTheme
 import io.element.android.compound.tokens.generated.CompoundIcons
-import io.element.android.features.leaveroom.api.LeaveRoomView
 import io.element.android.features.roomcall.api.hasPermissionToJoin
 import io.element.android.features.userprofile.api.UserProfileVerificationState
 import io.element.android.features.userprofile.shared.blockuser.BlockUserDialogs
@@ -112,6 +111,7 @@ fun RoomDetailsView(
     onProfileClick: (UserId) -> Unit,
     onReportRoomClick: () -> Unit,
     modifier: Modifier = Modifier,
+    leaveRoomView: @Composable () -> Unit,
 ) {
     val snackbarHostState = rememberSnackbarHostState(snackbarMessage = state.snackbarMessage)
     Scaffold(
@@ -131,7 +131,7 @@ fun RoomDetailsView(
                 .verticalScroll(rememberScrollState())
                 .consumeWindowInsets(padding)
         ) {
-            LeaveRoomView(state = state.leaveRoomState)
+            leaveRoomView()
 
             when (state.roomType) {
                 RoomDetailsType.Room -> {
@@ -262,7 +262,7 @@ fun RoomDetailsView(
             OtherActionsSection(
                 canReportRoom = state.canReportRoom,
                 onReportRoomClick = onReportRoomClick,
-                onLeaveRoomClick = { state.eventSink(RoomDetailsEvent.LeaveRoom) }
+                onLeaveRoomClick = { state.eventSink(RoomDetailsEvent.LeaveRoom(needsConfirmation = true)) }
             )
 
             if (state.showDebugInfo) {
@@ -776,5 +776,6 @@ private fun ContentToPreview(state: RoomDetailsState) {
         onSecurityAndPrivacyClick = {},
         onProfileClick = {},
         onReportRoomClick = {},
+        leaveRoomView = {},
     )
 }

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/RolesAndPermissionsFlowNode.kt

@@ -10,27 +10,34 @@ package io.element.android.features.roomdetails.impl.rolesandpermissions
 import android.os.Parcelable
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.lifecycle.coroutineScope
 import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.plugin.Plugin
 import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.operation.pop
 import com.bumble.appyx.navmodel.backstack.operation.push
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
-import io.element.android.features.roomdetails.impl.rolesandpermissions.changeroles.ChangeRolesNode
+import io.element.android.features.changeroommemberroes.api.ChangeRoomMemberRolesEntryPoint
+import io.element.android.features.changeroommemberroes.api.ChangeRoomMemberRolesListType
 import io.element.android.features.roomdetails.impl.rolesandpermissions.permissions.ChangeRoomPermissionsNode
 import io.element.android.features.roomdetails.impl.rolesandpermissions.permissions.ChangeRoomPermissionsSection
 import io.element.android.libraries.architecture.BackstackView
 import io.element.android.libraries.architecture.BaseFlowNode
 import io.element.android.libraries.architecture.createNode
 import io.element.android.libraries.di.RoomScope
+import io.element.android.libraries.matrix.api.room.JoinedRoom
+import kotlinx.coroutines.launch
 import kotlinx.parcelize.Parcelize
 
 @ContributesNode(RoomScope::class)
 class RolesAndPermissionsFlowNode @AssistedInject constructor(
     @Assisted buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
+    private val changeRoomMemberRolesEntryPoint: ChangeRoomMemberRolesEntryPoint,
+    private val joinedRoom: JoinedRoom,
 ) : BaseFlowNode<RolesAndPermissionsFlowNode.NavTarget>(
     backstack = BackStack(
         initialElement = NavTarget.AdminSettings,
@@ -53,6 +60,16 @@ class RolesAndPermissionsFlowNode @AssistedInject constructor(
         data class ChangeRoomPermissions(val section: ChangeRoomPermissionsSection) : NavTarget
     }
 
+    override fun onBuilt() {
+        super.onBuilt()
+        whenChildAttached { lifecycle, node: ChangeRoomMemberRolesEntryPoint.NodeProxy ->
+            lifecycle.coroutineScope.launch {
+                node.waitForRoleChanged()
+                backstack.pop()
+            }
+        }
+    }
+
     override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
         return when (navTarget) {
             is NavTarget.AdminSettings -> {
@@ -83,18 +100,16 @@ class RolesAndPermissionsFlowNode @AssistedInject constructor(
                 )
             }
             is NavTarget.AdminList -> {
-                val inputs = ChangeRolesNode.Inputs(ChangeRolesNode.ListType.Admins)
-                createNode<ChangeRolesNode>(
-                    buildContext = buildContext,
-                    plugins = listOf(inputs),
-                )
+                changeRoomMemberRolesEntryPoint.builder(this, buildContext)
+                    .room(joinedRoom)
+                    .listType(ChangeRoomMemberRolesListType.Admins)
+                    .build()
             }
             is NavTarget.ModeratorList -> {
-                val inputs = ChangeRolesNode.Inputs(ChangeRolesNode.ListType.Moderators)
-                createNode<ChangeRolesNode>(
-                    buildContext = buildContext,
-                    plugins = listOf(inputs),
-                )
+                changeRoomMemberRolesEntryPoint.builder(this, buildContext)
+                    .room(joinedRoom)
+                    .listType(ChangeRoomMemberRolesListType.Moderators)
+                    .build()
             }
             is NavTarget.ChangeRoomPermissions -> {
                 val inputs = ChangeRoomPermissionsNode.Inputs(navTarget.section)

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/changeroles/ChangeRolesEvent.kt

@@ -1,21 +0,0 @@
-/*
- * Copyright 2024 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.features.roomdetails.impl.rolesandpermissions.changeroles
-
-import io.element.android.libraries.matrix.api.user.MatrixUser
-
-sealed interface ChangeRolesEvent {
-    data object ToggleSearchActive : ChangeRolesEvent
-    data class QueryChanged(val query: String?) : ChangeRolesEvent
-    data class UserSelectionToggled(val matrixUser: MatrixUser) : ChangeRolesEvent
-    data object Save : ChangeRolesEvent
-    data object Exit : ChangeRolesEvent
-    data object CancelExit : ChangeRolesEvent
-    data object ClearError : ChangeRolesEvent
-    data object CancelSave : ChangeRolesEvent
-}

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/changeroles/ChangeRolesNode.kt

@@ -1,62 +0,0 @@
-/*
- * Copyright 2024 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.features.roomdetails.impl.rolesandpermissions.changeroles
-
-import android.os.Parcelable
-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.architecture.NodeInputs
-import io.element.android.libraries.architecture.inputs
-import io.element.android.libraries.di.RoomScope
-import io.element.android.libraries.matrix.api.room.RoomMember
-import kotlinx.parcelize.Parcelize
-
-@ContributesNode(RoomScope::class)
-class ChangeRolesNode @AssistedInject constructor(
-    @Assisted buildContext: BuildContext,
-    @Assisted plugins: List<Plugin>,
-    presenterFactory: ChangeRolesPresenter.Factory,
-) : Node(buildContext, plugins = plugins) {
-    sealed interface ListType : Parcelable {
-        @Parcelize
-        data object Admins : ListType
-        @Parcelize
-        data object Moderators : ListType
-    }
-
-    @Parcelize
-    data class Inputs(
-        val listType: ListType,
-    ) : NodeInputs, Parcelable
-
-    private val inputs: Inputs = inputs()
-
-    private val presenter = presenterFactory.run {
-        val role = when (inputs.listType) {
-            is ListType.Admins -> RoomMember.Role.Admin
-            is ListType.Moderators -> RoomMember.Role.Moderator
-        }
-        create(role)
-    }
-
-    @Composable
-    override fun View(modifier: Modifier) {
-        val state = presenter.present()
-        ChangeRolesView(
-            modifier = modifier,
-            state = state,
-            navigateUp = this::navigateUp,
-        )
-    }
-}

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/changeroles/ChangeRolesPresenter.kt

@@ -1,231 +0,0 @@
-/*
- * Copyright 2024 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.features.roomdetails.impl.rolesandpermissions.changeroles
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.produceState
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-import im.vector.app.features.analytics.plan.RoomModeration
-import io.element.android.features.roomdetails.impl.analytics.toAnalyticsMemberRole
-import io.element.android.features.roomdetails.impl.members.PowerLevelRoomMemberComparator
-import io.element.android.features.roomdetails.impl.members.RoomMemberListDataSource
-import io.element.android.libraries.architecture.AsyncAction
-import io.element.android.libraries.architecture.Presenter
-import io.element.android.libraries.core.coroutine.CoroutineDispatchers
-import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
-import io.element.android.libraries.matrix.api.core.UserId
-import io.element.android.libraries.matrix.api.room.JoinedRoom
-import io.element.android.libraries.matrix.api.room.RoomMember
-import io.element.android.libraries.matrix.api.room.powerlevels.UserRoleChange
-import io.element.android.libraries.matrix.api.room.powerlevels.usersWithRole
-import io.element.android.libraries.matrix.api.room.toMatrixUser
-import io.element.android.libraries.matrix.api.user.MatrixUser
-import io.element.android.libraries.matrix.ui.model.roleOf
-import io.element.android.services.analytics.api.AnalyticsService
-import kotlinx.collections.immutable.ImmutableList
-import kotlinx.collections.immutable.PersistentList
-import kotlinx.collections.immutable.persistentListOf
-import kotlinx.collections.immutable.toImmutableList
-import kotlinx.collections.immutable.toPersistentList
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.launch
-
-class ChangeRolesPresenter @AssistedInject constructor(
-    @Assisted private val role: RoomMember.Role,
-    private val room: JoinedRoom,
-    private val dispatchers: CoroutineDispatchers,
-    private val analyticsService: AnalyticsService,
-) : Presenter<ChangeRolesState> {
-    @AssistedFactory
-    interface Factory {
-        fun create(role: RoomMember.Role): ChangeRolesPresenter
-    }
-
-    @Composable
-    override fun present(): ChangeRolesState {
-        val coroutineScope = rememberCoroutineScope()
-        val dataSource = remember { RoomMemberListDataSource(room, dispatchers) }
-        var query by rememberSaveable { mutableStateOf<String?>(null) }
-        var searchActive by rememberSaveable { mutableStateOf(false) }
-        var searchResults by remember {
-            mutableStateOf<SearchBarResultState<MembersByRole>>(SearchBarResultState.Initial())
-        }
-        val selectedUsers = remember {
-            mutableStateOf<ImmutableList<MatrixUser>>(persistentListOf())
-        }
-        val exitState: MutableState<AsyncAction<Unit>> = remember { mutableStateOf(AsyncAction.Uninitialized) }
-        val saveState: MutableState<AsyncAction<Unit>> = remember { mutableStateOf(AsyncAction.Uninitialized) }
-        val usersWithRole = produceState(initialValue = persistentListOf()) {
-            room.usersWithRole(role).map { members -> members.map { it.toMatrixUser() } }
-                    .onEach { users ->
-                        val previous: PersistentList<MatrixUser> = value
-                        value = users.toPersistentList()
-                        // Users who were selected but didn't have the role, so their role change was pending
-                        val toAdd = selectedUsers.value.filter { user -> users.none { it.userId == user.userId } && previous.none { it.userId == user.userId } }
-                        // Users who no longer have the role
-                        val toRemove = previous.filter { user -> users.none { it.userId == user.userId } }.toSet()
-                        selectedUsers.value = (users + toAdd - toRemove).toImmutableList()
-                    }
-                    .launchIn(this)
-        }
-
-        val roomMemberState by room.membersStateFlow.collectAsState()
-
-        // Update search results for every query change
-        LaunchedEffect(query, roomMemberState) {
-            val results = dataSource
-                .search(query.orEmpty())
-                .groupedByRole()
-
-            searchResults = if (results.isEmpty()) {
-                SearchBarResultState.NoResultsFound()
-            } else {
-                SearchBarResultState.Results(results)
-            }
-        }
-
-        val hasPendingChanges = usersWithRole.value != selectedUsers.value
-
-        val roomInfo by room.roomInfoFlow.collectAsState()
-        fun canChangeMemberRole(userId: UserId): Boolean {
-            // This is used to group the
-            val currentUserRole = roomInfo.roleOf(room.sessionId)
-            val otherUserRole = roomInfo.roleOf(userId)
-            return currentUserRole.powerLevel > otherUserRole.powerLevel
-        }
-
-        fun handleEvent(event: ChangeRolesEvent) {
-            when (event) {
-                is ChangeRolesEvent.ToggleSearchActive -> {
-                    searchActive = !searchActive
-                }
-                is ChangeRolesEvent.QueryChanged -> {
-                    query = event.query
-                }
-                is ChangeRolesEvent.UserSelectionToggled -> {
-                    val newList = selectedUsers.value.toMutableList()
-                    val index = newList.indexOfFirst { it.userId == event.matrixUser.userId }
-                    if (index >= 0) {
-                        newList.removeAt(index)
-                    } else {
-                        newList.add(event.matrixUser)
-                    }
-                    selectedUsers.value = newList.toImmutableList()
-                }
-                is ChangeRolesEvent.Save -> {
-                    val currentUserIsAdmin = roomInfo.roleOf(room.sessionId) == RoomMember.Role.Admin
-                    val isModifyingAdmins = role == RoomMember.Role.Admin
-                    val hasChanges = selectedUsers != usersWithRole
-                    val isConfirming = saveState.value.isConfirming()
-
-                    val needsConfirmation = currentUserIsAdmin && isModifyingAdmins && hasChanges && !isConfirming
-
-                    when {
-                        needsConfirmation -> {
-                            // Confirm modifying users
-                            saveState.value = AsyncAction.ConfirmingNoParams
-                        }
-                        !saveState.value.isLoading() -> {
-                            coroutineScope.save(usersWithRole.value, selectedUsers, saveState)
-                        }
-                    }
-                }
-                is ChangeRolesEvent.ClearError -> {
-                    saveState.value = AsyncAction.Uninitialized
-                }
-                is ChangeRolesEvent.Exit -> {
-                    exitState.value = if (exitState.value.isUninitialized() && hasPendingChanges) {
-                        // Has pending changes, confirm exit
-                        AsyncAction.ConfirmingNoParams
-                    } else {
-                        // No pending changes, exit immediately
-                        AsyncAction.Success(Unit)
-                    }
-                }
-                is ChangeRolesEvent.CancelExit -> {
-                    exitState.value = AsyncAction.Uninitialized
-                }
-                is ChangeRolesEvent.CancelSave -> {
-                    saveState.value = AsyncAction.Uninitialized
-                }
-            }
-        }
-        return ChangeRolesState(
-            role = role,
-            query = query,
-            isSearchActive = searchActive,
-            searchResults = searchResults,
-            selectedUsers = selectedUsers.value,
-            hasPendingChanges = hasPendingChanges,
-            exitState = exitState.value,
-            savingState = saveState.value,
-            canChangeMemberRole = ::canChangeMemberRole,
-            eventSink = ::handleEvent,
-        )
-    }
-
-    private fun List<RoomMember>.groupedByRole(): MembersByRole {
-        val groupedMembers = MembersByRole(this)
-        return MembersByRole(
-            owners = groupedMembers.owners.sorted(),
-            admins = groupedMembers.admins.sorted(),
-            moderators = groupedMembers.moderators.sorted(),
-            members = groupedMembers.members.sorted(),
-        )
-    }
-
-    private fun Iterable<RoomMember>.sorted(): ImmutableList<RoomMember> {
-        return sortedWith(PowerLevelRoomMemberComparator()).toImmutableList()
-    }
-
-    private fun CoroutineScope.save(
-        usersWithRole: ImmutableList<MatrixUser>,
-        selectedUsers: MutableState<ImmutableList<MatrixUser>>,
-        saveState: MutableState<AsyncAction<Unit>>,
-    ) = launch {
-        saveState.value = AsyncAction.Loading
-
-        val toAdd = selectedUsers.value - usersWithRole
-        val toRemove = usersWithRole - selectedUsers.value
-
-        val changes: List<UserRoleChange> = buildList {
-            for (selectedUser in toAdd) {
-                analyticsService.capture(RoomModeration(RoomModeration.Action.ChangeMemberRole, role.toAnalyticsMemberRole()))
-                add(UserRoleChange(selectedUser.userId, role))
-            }
-            for (selectedUser in toRemove) {
-                analyticsService.capture(RoomModeration(RoomModeration.Action.ChangeMemberRole, RoomModeration.Role.User))
-                add(UserRoleChange(selectedUser.userId, RoomMember.Role.User))
-            }
-        }
-
-        room.updateUsersRoles(changes)
-            .onFailure {
-                saveState.value = AsyncAction.Failure(it)
-            }
-            .onSuccess {
-                saveState.value = AsyncAction.Success(Unit)
-                // Asynchronously reload the room members
-                launch { room.updateMembers() }
-            }
-    }
-}

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/changeroles/ChangeRolesState.kt

@@ -1,50 +0,0 @@
-/*
- * Copyright 2024 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.features.roomdetails.impl.rolesandpermissions.changeroles
-
-import io.element.android.features.roomdetails.impl.members.PowerLevelRoomMemberComparator
-import io.element.android.libraries.architecture.AsyncAction
-import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
-import io.element.android.libraries.matrix.api.core.UserId
-import io.element.android.libraries.matrix.api.room.RoomMember
-import io.element.android.libraries.matrix.api.user.MatrixUser
-import kotlinx.collections.immutable.ImmutableList
-import kotlinx.collections.immutable.toImmutableList
-
-data class ChangeRolesState(
-    val role: RoomMember.Role,
-    val query: String?,
-    val isSearchActive: Boolean,
-    val searchResults: SearchBarResultState<MembersByRole>,
-    val selectedUsers: ImmutableList<MatrixUser>,
-    val hasPendingChanges: Boolean,
-    val exitState: AsyncAction<Unit>,
-    val savingState: AsyncAction<Unit>,
-    val canChangeMemberRole: (UserId) -> Boolean,
-    val eventSink: (ChangeRolesEvent) -> Unit,
-)
-
-data class MembersByRole(
-    val owners: ImmutableList<RoomMember>,
-    val admins: ImmutableList<RoomMember>,
-    val moderators: ImmutableList<RoomMember>,
-    val members: ImmutableList<RoomMember>,
-) {
-    constructor(members: List<RoomMember>) : this(
-            owners = members.filter { it.role is RoomMember.Role.Owner }.sorted(),
-            admins = members.filter { it.role == RoomMember.Role.Admin }.sorted(),
-            moderators = members.filter { it.role == RoomMember.Role.Moderator }.sorted(),
-            members = members.filter { it.role == RoomMember.Role.User }.sorted(),
-    )
-
-    fun isEmpty() = owners.isEmpty() && admins.isEmpty() && moderators.isEmpty() && members.isEmpty()
-}
-
-private fun Iterable<RoomMember>.sorted(): ImmutableList<RoomMember> {
-    return sortedWith(PowerLevelRoomMemberComparator()).toImmutableList()
-}

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/changeroles/ChangeRolesStateProvider.kt

@@ -1,133 +0,0 @@
-/*
- * Copyright 2024 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.features.roomdetails.impl.rolesandpermissions.changeroles
-
-import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.features.roomdetails.impl.members.aRoomMember
-import io.element.android.features.roomdetails.impl.members.aRoomMemberList
-import io.element.android.libraries.architecture.AsyncAction
-import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
-import io.element.android.libraries.matrix.api.core.UserId
-import io.element.android.libraries.matrix.api.room.RoomMember
-import io.element.android.libraries.matrix.api.room.RoomMembershipState
-import io.element.android.libraries.matrix.api.user.MatrixUser
-import io.element.android.libraries.matrix.ui.components.aMatrixUser
-import io.element.android.libraries.matrix.ui.components.aMatrixUserList
-import kotlinx.collections.immutable.ImmutableList
-import kotlinx.collections.immutable.persistentListOf
-import kotlinx.collections.immutable.toImmutableList
-
-class ChangeRolesStateProvider : PreviewParameterProvider<ChangeRolesState> {
-    override val values: Sequence<ChangeRolesState>
-        get() = sequenceOf(
-            aChangeRolesState(),
-            aChangeRolesStateWithSelectedUsers().copy(role = RoomMember.Role.Moderator),
-            aChangeRolesStateWithSelectedUsers().copy(hasPendingChanges = false),
-            aChangeRolesStateWithSelectedUsers(),
-            aChangeRolesStateWithSelectedUsers().copy(
-                selectedUsers = aMatrixUserList().take(2).toImmutableList(),
-            ),
-            aChangeRolesStateWithSelectedUsers().copy(
-                query = "Alice",
-                isSearchActive = true,
-                searchResults = SearchBarResultState.Results(MembersByRole(aRoomMemberList().take(1).toImmutableList())),
-                selectedUsers = aMatrixUserList().take(1).toImmutableList(),
-            ),
-            aChangeRolesStateWithSelectedUsers().copy(exitState = AsyncAction.ConfirmingNoParams),
-            aChangeRolesStateWithSelectedUsers().copy(savingState = AsyncAction.ConfirmingNoParams),
-            aChangeRolesStateWithSelectedUsers().copy(savingState = AsyncAction.Loading),
-            aChangeRolesStateWithSelectedUsers().copy(savingState = AsyncAction.Success(Unit)),
-            aChangeRolesStateWithSelectedUsers().copy(savingState = AsyncAction.Failure(Exception("boom"))),
-            aChangeRolesStateWithOwners(),
-        )
-}
-
-internal fun aChangeRolesState(
-    role: RoomMember.Role = RoomMember.Role.Admin,
-    query: String? = null,
-    isSearchActive: Boolean = false,
-    searchResults: SearchBarResultState<MembersByRole> = SearchBarResultState.NoResultsFound(),
-    selectedUsers: ImmutableList<MatrixUser> = persistentListOf(),
-    hasPendingChanges: Boolean = false,
-    exitState: AsyncAction<Unit> = AsyncAction.Uninitialized,
-    savingState: AsyncAction<Unit> = AsyncAction.Uninitialized,
-    canRemoveMember: (UserId) -> Boolean = { true },
-    eventSink: (ChangeRolesEvent) -> Unit = {},
-) = ChangeRolesState(
-    role = role,
-    query = query,
-    isSearchActive = isSearchActive,
-    searchResults = searchResults,
-    selectedUsers = selectedUsers,
-    hasPendingChanges = hasPendingChanges,
-    exitState = exitState,
-    savingState = savingState,
-    canChangeMemberRole = canRemoveMember,
-    eventSink = eventSink,
-)
-
-internal fun aChangeRolesStateWithSelectedUsers() = aChangeRolesState(
-    selectedUsers = aMatrixUserList().toImmutableList(),
-    searchResults = SearchBarResultState.Results(
-        MembersByRole(
-            members = aRoomMemberList().mapIndexed { index, roomMember ->
-                if (index % 2 == 0) {
-                    roomMember.copy(membership = RoomMembershipState.INVITE)
-                } else {
-                    roomMember
-                }
-            }
-        )
-    ),
-    hasPendingChanges = true,
-    canRemoveMember = { it != UserId("@alice:server.org") },
-)
-
-internal fun aChangeRolesStateWithOwners() = aChangeRolesState(
-    role = RoomMember.Role.Admin,
-    searchResults = SearchBarResultState.Results(
-        MembersByRole(
-            members = persistentListOf(
-                aRoomMember(
-                    userId = UserId("@alice:server.org"),
-                    displayName = "Alice",
-                    role = RoomMember.Role.Owner(isCreator = true),
-                ),
-                aRoomMember(
-                    userId = UserId("@bob:server.org"),
-                    displayName = "Bob",
-                    role = RoomMember.Role.Owner(isCreator = false),
-                ),
-                aRoomMember(
-                    userId = UserId("@carol:server.org"),
-                    displayName = "Carol",
-                    role = RoomMember.Role.Admin,
-                ),
-                aRoomMember(
-                    userId = UserId("@david:server.org"),
-                    displayName = "David",
-                    role = RoomMember.Role.User,
-                ),
-            )
-        ),
-    ),
-    canRemoveMember = { userId ->
-        when (userId) {
-            UserId("@alice:server.org") -> false // Owner - creator
-            UserId("@bob:server.org") -> false // Owner - super admin
-            UserId("@carol:server.org") -> true // Admin
-            UserId("@david:server.org") -> true // User
-            else -> false
-        }
-    },
-    selectedUsers = persistentListOf(
-        aMatrixUser(id = "@alice:server.org", displayName = "Alice"),
-        aMatrixUser(id = "@bob:server.org", displayName = "Bob"),
-        aMatrixUser(id = "@carol:server.org", displayName = "Carol"),
-    )
-)

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/changeroles/ChangeRolesView.kt

@@ -1,438 +0,0 @@
-/*
- * Copyright 2024 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.features.roomdetails.impl.rolesandpermissions.changeroles
-
-import androidx.activity.compose.BackHandler
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.statusBarsPadding
-import androidx.compose.foundation.layout.systemBarsPadding
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.LazyListState
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.PreviewParameter
-import androidx.compose.ui.unit.dp
-import io.element.android.compound.theme.ElementTheme
-import io.element.android.features.roomdetails.impl.R
-import io.element.android.libraries.architecture.AsyncAction
-import io.element.android.libraries.designsystem.components.ProgressDialog
-import io.element.android.libraries.designsystem.components.async.AsyncActionView
-import io.element.android.libraries.designsystem.components.async.AsyncIndicator
-import io.element.android.libraries.designsystem.components.async.AsyncIndicatorHost
-import io.element.android.libraries.designsystem.components.async.rememberAsyncIndicatorState
-import io.element.android.libraries.designsystem.components.avatar.Avatar
-import io.element.android.libraries.designsystem.components.avatar.AvatarData
-import io.element.android.libraries.designsystem.components.avatar.AvatarSize
-import io.element.android.libraries.designsystem.components.avatar.AvatarType
-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.ElementPreview
-import io.element.android.libraries.designsystem.preview.PreviewsDayNight
-import io.element.android.libraries.designsystem.theme.components.Checkbox
-import io.element.android.libraries.designsystem.theme.components.HorizontalDivider
-import io.element.android.libraries.designsystem.theme.components.Scaffold
-import io.element.android.libraries.designsystem.theme.components.SearchBar
-import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
-import io.element.android.libraries.designsystem.theme.components.Text
-import io.element.android.libraries.designsystem.theme.components.TextButton
-import io.element.android.libraries.designsystem.theme.components.TopAppBar
-import io.element.android.libraries.designsystem.utils.CommonDrawables
-import io.element.android.libraries.matrix.api.core.UserId
-import io.element.android.libraries.matrix.api.room.RoomMember
-import io.element.android.libraries.matrix.api.room.RoomMembershipState
-import io.element.android.libraries.matrix.api.room.getBestName
-import io.element.android.libraries.matrix.api.room.toMatrixUser
-import io.element.android.libraries.matrix.api.user.MatrixUser
-import io.element.android.libraries.matrix.ui.components.SelectedUsersRowList
-import io.element.android.libraries.matrix.ui.model.getAvatarData
-import io.element.android.libraries.ui.strings.CommonStrings
-import kotlinx.collections.immutable.ImmutableList
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun ChangeRolesView(
-    state: ChangeRolesState,
-    navigateUp: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    val latestNavigateUp by rememberUpdatedState(newValue = navigateUp)
-    BackHandler(enabled = !state.isSearchActive) {
-        state.eventSink(ChangeRolesEvent.Exit)
-    }
-
-    Box(modifier = modifier) {
-        Scaffold(
-            modifier = Modifier
-                .fillMaxSize()
-                .systemBarsPadding(),
-            topBar = {
-                AnimatedVisibility(visible = !state.isSearchActive) {
-                    TopAppBar(
-                        titleStr = when (state.role) {
-                            RoomMember.Role.Admin -> stringResource(R.string.screen_room_change_role_administrators_title)
-                            RoomMember.Role.Moderator -> stringResource(R.string.screen_room_change_role_moderators_title)
-                            is RoomMember.Role.Owner, RoomMember.Role.User -> error("This should never be reached")
-                        },
-                        navigationIcon = {
-                            BackButton(onClick = { state.eventSink(ChangeRolesEvent.Exit) })
-                        },
-                        actions = {
-                            TextButton(
-                                text = stringResource(CommonStrings.action_save),
-                                enabled = state.hasPendingChanges,
-                                onClick = { state.eventSink(ChangeRolesEvent.Save) }
-                            )
-                        }
-                    )
-                }
-            }
-        ) { paddingValues ->
-            Column(
-                modifier = Modifier.padding(paddingValues),
-            ) {
-                val lazyListState = rememberLazyListState()
-                SearchBar(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(bottom = 16.dp),
-                    placeHolderTitle = stringResource(CommonStrings.common_search_for_someone),
-                    query = state.query.orEmpty(),
-                    onQueryChange = { state.eventSink(ChangeRolesEvent.QueryChanged(it)) },
-                    active = state.isSearchActive,
-                    onActiveChange = { state.eventSink(ChangeRolesEvent.ToggleSearchActive) },
-                    resultState = state.searchResults,
-                ) { members ->
-                    SearchResultsList(
-                        currentRole = state.role,
-                        lazyListState = lazyListState,
-                        searchResults = members,
-                        selectedUsers = state.selectedUsers,
-                        canRemoveMember = state.canChangeMemberRole,
-                        onToggleSelection = { state.eventSink(ChangeRolesEvent.UserSelectionToggled(it.toMatrixUser())) },
-                        selectedUsersList = {},
-                    )
-                }
-                AnimatedVisibility(
-                    visible = !state.isSearchActive,
-                    enter = fadeIn(),
-                    exit = fadeOut()
-                ) {
-                    Column {
-                        SearchResultsList(
-                            currentRole = state.role,
-                            lazyListState = lazyListState,
-                            searchResults = (state.searchResults as? SearchBarResultState.Results)?.results ?: MembersByRole(emptyList()),
-                            selectedUsers = state.selectedUsers,
-                            canRemoveMember = state.canChangeMemberRole,
-                            onToggleSelection = { state.eventSink(ChangeRolesEvent.UserSelectionToggled(it.toMatrixUser())) },
-                            selectedUsersList = { users ->
-                                SelectedUsersRowList(
-                                    contentPadding = PaddingValues(start = 16.dp, end = 16.dp, bottom = 16.dp),
-                                    selectedUsers = users,
-                                    onUserRemove = {
-                                        state.eventSink(ChangeRolesEvent.UserSelectionToggled(it))
-                                    },
-                                    canDeselect = { state.canChangeMemberRole(it.userId) },
-                                )
-                            }
-                        )
-                    }
-                }
-            }
-        }
-
-        val asyncIndicatorState = rememberAsyncIndicatorState()
-        AsyncIndicatorHost(modifier = Modifier.statusBarsPadding(), asyncIndicatorState)
-
-        AsyncActionView(
-            async = state.exitState,
-            onSuccess = { latestNavigateUp() },
-            confirmationDialog = {
-                ConfirmationDialog(
-                    title = stringResource(CommonStrings.dialog_unsaved_changes_title),
-                    content = stringResource(CommonStrings.dialog_unsaved_changes_description_android),
-                    onSubmitClick = { state.eventSink(ChangeRolesEvent.Exit) },
-                    onDismiss = { state.eventSink(ChangeRolesEvent.CancelExit) }
-                )
-            },
-            onErrorDismiss = { /* Cannot happen */ },
-        )
-
-        when (state.savingState) {
-            is AsyncAction.Confirming -> {
-                if (state.role == RoomMember.Role.Admin) {
-                    // Confirm adding new admins dialogs
-                    ConfirmationDialog(
-                        title = stringResource(R.string.screen_room_change_role_confirm_add_admin_title),
-                        content = stringResource(R.string.screen_room_change_role_confirm_add_admin_description),
-                        onSubmitClick = { state.eventSink(ChangeRolesEvent.Save) },
-                        onDismiss = { state.eventSink(ChangeRolesEvent.ClearError) }
-                    )
-                }
-            }
-            is AsyncAction.Loading -> {
-                ProgressDialog()
-            }
-            is AsyncAction.Failure -> {
-                ErrorDialog(
-                    content = stringResource(CommonStrings.error_unknown),
-                    onSubmit = { state.eventSink(ChangeRolesEvent.ClearError) }
-                )
-            }
-            is AsyncAction.Success -> {
-                LaunchedEffect(state.savingState) {
-                    asyncIndicatorState.enqueue(durationMs = AsyncIndicator.DURATION_SHORT) {
-                        AsyncIndicator.Custom(text = stringResource(CommonStrings.common_saved_changes))
-                    }
-                }
-            }
-            else -> Unit
-        }
-    }
-}
-
-@Composable
-private fun SearchResultsList(
-    currentRole: RoomMember.Role,
-    searchResults: MembersByRole,
-    selectedUsers: ImmutableList<MatrixUser>,
-    canRemoveMember: (UserId) -> Boolean,
-    onToggleSelection: (RoomMember) -> Unit,
-    lazyListState: LazyListState,
-    selectedUsersList: @Composable (ImmutableList<MatrixUser>) -> Unit,
-) {
-    LazyColumn(
-        state = lazyListState,
-    ) {
-        item {
-            selectedUsersList(selectedUsers)
-        }
-        if (searchResults.owners.isNotEmpty()) {
-            stickyHeader { ListSectionHeader(text = stringResource(R.string.screen_room_roles_and_permissions_owners)) }
-            item {
-                Text(
-                    modifier = Modifier
-                        .padding(start = 16.dp, end = 16.dp, bottom = 8.dp),
-                    text = stringResource(R.string.screen_room_change_role_moderators_owner_section_footer),
-                    color = ElementTheme.colors.textSecondary,
-                    style = ElementTheme.typography.fontBodySmRegular,
-                )
-            }
-            items(searchResults.owners, key = { it.userId }) { roomMember ->
-                ListMemberItem(
-                    roomMember = roomMember,
-                    canRemoveMember = canRemoveMember,
-                    onToggleSelection = onToggleSelection,
-                    selectedUsers = selectedUsers
-                )
-            }
-        }
-        if (searchResults.admins.isNotEmpty()) {
-            stickyHeader { ListSectionHeader(text = stringResource(R.string.screen_room_roles_and_permissions_admins)) }
-            // Add a footer for the admin section in change role to moderator screen
-            if (currentRole == RoomMember.Role.Moderator) {
-                item {
-                    Text(
-                        modifier = Modifier
-                            .padding(start = 16.dp, end = 16.dp, bottom = 8.dp),
-                        text = stringResource(R.string.screen_room_change_role_moderators_admin_section_footer),
-                        color = ElementTheme.colors.textSecondary,
-                        style = ElementTheme.typography.fontBodySmRegular,
-                    )
-                }
-            }
-            items(searchResults.admins, key = { it.userId }) { roomMember ->
-                ListMemberItem(
-                    roomMember = roomMember,
-                    canRemoveMember = canRemoveMember,
-                    onToggleSelection = onToggleSelection,
-                    selectedUsers = selectedUsers
-                )
-            }
-        }
-        if (searchResults.moderators.isNotEmpty()) {
-            stickyHeader { ListSectionHeader(text = stringResource(R.string.screen_room_roles_and_permissions_moderators)) }
-            items(searchResults.moderators, key = { it.userId }) { roomMember ->
-                ListMemberItem(
-                    roomMember = roomMember,
-                    canRemoveMember = canRemoveMember,
-                    onToggleSelection = onToggleSelection,
-                    selectedUsers = selectedUsers
-                )
-            }
-        }
-        if (searchResults.members.isNotEmpty()) {
-            stickyHeader { ListSectionHeader(text = stringResource(R.string.screen_room_member_list_mode_members)) }
-            items(searchResults.members, key = { it.userId }) { roomMember ->
-                ListMemberItem(
-                    roomMember = roomMember,
-                    canRemoveMember = canRemoveMember,
-                    onToggleSelection = onToggleSelection,
-                    selectedUsers = selectedUsers
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun ListSectionHeader(text: String) {
-    Text(
-        modifier = Modifier
-            .background(ElementTheme.colors.bgCanvasDefault)
-            .padding(horizontal = 16.dp, vertical = 8.dp)
-            .fillMaxWidth(),
-        text = text,
-        style = ElementTheme.typography.fontBodyLgMedium,
-    )
-}
-
-@Composable
-private fun ListMemberItem(
-    roomMember: RoomMember,
-    canRemoveMember: (UserId) -> Boolean,
-    onToggleSelection: (RoomMember) -> Unit,
-    selectedUsers: ImmutableList<MatrixUser>,
-) {
-    val canToggle = canRemoveMember(roomMember.userId)
-    val trailingContent: @Composable (() -> Unit) = {
-        if (canToggle) {
-            Checkbox(
-                checked = selectedUsers.any { it.userId == roomMember.userId },
-                onCheckedChange = { onToggleSelection(roomMember) },
-            )
-        }
-    }
-    Column {
-        MemberRow(
-            modifier = Modifier.clickable(enabled = canToggle, onClick = { onToggleSelection(roomMember) }),
-            avatarData = roomMember.getAvatarData(size = AvatarSize.UserListItem),
-            name = roomMember.getBestName(),
-            userId = roomMember.userId.value.takeIf { roomMember.displayName?.isNotBlank() == true },
-            isPending = roomMember.membership == RoomMembershipState.INVITE,
-            trailingContent = trailingContent,
-        )
-        HorizontalDivider()
-    }
-}
-
-@Composable
-private fun MemberRow(
-    avatarData: AvatarData,
-    name: String,
-    userId: String?,
-    isPending: Boolean,
-    modifier: Modifier = Modifier,
-    trailingContent: @Composable (() -> Unit)? = null,
-) {
-    Row(
-        modifier = modifier
-            .fillMaxWidth()
-            .heightIn(min = 56.dp)
-            .padding(start = 16.dp, top = 4.dp, end = 16.dp, bottom = 4.dp),
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        Avatar(
-            avatarData = avatarData,
-            avatarType = AvatarType.User,
-        )
-        Column(
-            modifier = Modifier
-                .padding(start = 12.dp)
-                .weight(1f),
-        ) {
-            Row(verticalAlignment = Alignment.CenterVertically) {
-                // Name
-                Text(
-                    modifier = Modifier.weight(1f, fill = false),
-                    text = name,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
-                    color = ElementTheme.colors.textPrimary,
-                    style = ElementTheme.typography.fontBodyLgRegular,
-                )
-                // Invitation pending marker
-                if (isPending) {
-                    Text(
-                        modifier = Modifier.padding(start = 8.dp),
-                        text = stringResource(id = R.string.screen_room_member_list_pending_header_title),
-                        style = ElementTheme.typography.fontBodySmRegular.copy(fontStyle = FontStyle.Italic),
-                        color = ElementTheme.colors.textSecondary
-                    )
-                }
-            }
-            // Id
-            userId?.let {
-                Text(
-                    text = userId,
-                    color = ElementTheme.colors.textSecondary,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
-                    style = ElementTheme.typography.fontBodySmRegular,
-                )
-            }
-        }
-        trailingContent?.invoke()
-    }
-}
-
-@PreviewsDayNight
-@Composable
-internal fun ChangeRolesViewPreview(@PreviewParameter(ChangeRolesStateProvider::class) state: ChangeRolesState) {
-    ElementPreview {
-        ChangeRolesView(
-            state = state,
-            navigateUp = {},
-        )
-    }
-}
-
-@PreviewsDayNight
-@Composable
-internal fun PendingMemberRowWithLongNamePreview() {
-    ElementPreview(
-        drawableFallbackForImages = CommonDrawables.sample_avatar,
-    ) {
-        MemberRow(
-            avatarData = AvatarData("userId", "A very long name that should be truncated", "https://example.com/avatar.png", AvatarSize.UserListItem),
-            name = "A very long name that should be truncated",
-            userId = "@alice:matrix.org",
-            isPending = true,
-            trailingContent = {
-                Checkbox(
-                    checked = true,
-                    onCheckedChange = {},
-                    enabled = true,
-                )
-            }
-        )
-    }
-}