Merge pull request #320 from vector-im/feature/fre/create_room_flow_persist_data

Persist data in create room flow

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/AllMatrixUsersDataSource.kt

@@ -16,13 +16,13 @@
 
 package io.element.android.features.createroom.impl
 
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.ui.model.MatrixUser
 import javax.inject.Inject
 
 // TODO this is empty as we currently don't have an endpoint to perform user search
-class AllMatrixUsersDataSource @Inject constructor() : MatrixUserDataSource {
+class AllMatrixUsersDataSource @Inject constructor() : UserListDataSource {
     override suspend fun search(query: String): List<MatrixUser> {
         return emptyList()
     }

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/ConfigureRoomFlowNode.kt

@@ -0,0 +1,95 @@
+/*
+ * 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.createroom.impl
+
+import android.os.Parcelable
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.composable.Children
+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.push
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.createroom.impl.addpeople.AddPeopleNode
+import io.element.android.features.createroom.impl.configureroom.ConfigureRoomNode
+import io.element.android.features.createroom.impl.di.CreateRoomComponent
+import io.element.android.libraries.architecture.BackstackNode
+import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
+import io.element.android.libraries.architecture.bindings
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.DaggerComponentOwner
+import io.element.android.libraries.di.SessionScope
+import kotlinx.parcelize.Parcelize
+
+@ContributesNode(SessionScope::class)
+class ConfigureRoomFlowNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+) : DaggerComponentOwner,
+    BackstackNode<ConfigureRoomFlowNode.NavTarget>(
+        backstack = BackStack(
+            initialElement = NavTarget.Root,
+            savedStateMap = buildContext.savedStateMap,
+        ),
+        buildContext = buildContext,
+        plugins = plugins
+    ) {
+
+    private val component by lazy {
+        parent!!.bindings<CreateRoomComponent.ParentBindings>().createRoomComponentBuilder().build()
+    }
+
+    override val daggerComponent: Any
+        get() = component
+
+    sealed interface NavTarget : Parcelable {
+        @Parcelize
+        object Root : NavTarget
+
+        @Parcelize
+        object ConfigureRoom : NavTarget
+    }
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return when (navTarget) {
+            NavTarget.Root -> {
+                val callback = object : AddPeopleNode.Callback {
+                    override fun onContinue() {
+                        backstack.push(NavTarget.ConfigureRoom)
+                    }
+                }
+                createNode<AddPeopleNode>(context = buildContext, plugins = listOf(callback))
+            }
+            NavTarget.ConfigureRoom -> {
+                createNode<ConfigureRoomNode>(context = buildContext)
+            }
+        }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Children(
+            navModel = backstack,
+            modifier = modifier,
+            transitionHandler = rememberDefaultTransitionHandler()
+        )
+    }
+}

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/CreateRoomConfig.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.createroom.impl
+
+import io.element.android.features.createroom.impl.configureroom.RoomPrivacy
+import io.element.android.libraries.matrix.ui.model.MatrixUser
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+data class CreateRoomConfig(
+    val roomName: String? = null,
+    val topic: String? = null,
+    val avatarUrl: String? = null,
+    val invites: ImmutableList<MatrixUser> = persistentListOf(),
+    val privacy: RoomPrivacy? = null,
+)

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/CreateRoomDataStore.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.createroom.impl
+
+import io.element.android.features.createroom.impl.configureroom.RoomPrivacy
+import io.element.android.features.createroom.impl.di.CreateRoomScope
+import io.element.android.features.userlist.api.UserListDataStore
+import io.element.android.libraries.di.SingleIn
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.combine
+import javax.inject.Inject
+
+@SingleIn(CreateRoomScope::class)
+class CreateRoomDataStore @Inject constructor(
+    val selectedUserListDataStore: UserListDataStore,
+) {
+
+    private val createRoomConfigFlow: MutableStateFlow<CreateRoomConfig> = MutableStateFlow(CreateRoomConfig())
+
+    fun getCreateRoomConfig(): Flow<CreateRoomConfig> = combine(
+        selectedUserListDataStore.selectedUsers(),
+        createRoomConfigFlow,
+    ) { selectedUsers, config ->
+        config.copy(invites = selectedUsers.toImmutableList())
+    }
+
+    fun setRoomName(roomName: String?) {
+        createRoomConfigFlow.tryEmit(createRoomConfigFlow.value.copy(roomName = roomName?.takeIf { it.isNotEmpty() }))
+    }
+
+    fun setTopic(topic: String?) {
+        createRoomConfigFlow.tryEmit(createRoomConfigFlow.value.copy(topic = topic?.takeIf { it.isNotEmpty() }))
+    }
+
+    fun setAvatarUrl(avatarUrl: String?) {
+        createRoomConfigFlow.tryEmit(createRoomConfigFlow.value.copy(avatarUrl = avatarUrl))
+    }
+
+    fun setPrivacy(privacy: RoomPrivacy?) {
+        createRoomConfigFlow.tryEmit(createRoomConfigFlow.value.copy(privacy = privacy))
+    }
+}

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/CreateRoomFlowNode.kt

@@ -30,15 +30,12 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
 import io.element.android.features.createroom.api.CreateRoomEntryPoint
-import io.element.android.features.createroom.impl.addpeople.AddPeopleNode
-import io.element.android.features.createroom.impl.configureroom.ConfigureRoomNode
 import io.element.android.features.createroom.impl.root.CreateRoomRootNode
 import io.element.android.libraries.architecture.BackstackNode
 import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
 import io.element.android.libraries.architecture.createNode
 import io.element.android.libraries.di.SessionScope
 import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.ui.model.MatrixUser
 import kotlinx.parcelize.Parcelize
 
 @ContributesNode(SessionScope::class)
@@ -60,9 +57,6 @@ class CreateRoomFlowNode @AssistedInject constructor(
 
         @Parcelize
         object NewRoom : NavTarget
-
-        @Parcelize
-        data class ConfigureRoom(val users: List<MatrixUser>) : NavTarget
     }
 
     override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
@@ -80,15 +74,7 @@ class CreateRoomFlowNode @AssistedInject constructor(
                 createNode<CreateRoomRootNode>(context = buildContext, plugins = listOf(callback))
             }
             NavTarget.NewRoom -> {
-                val callback = object : AddPeopleNode.Callback {
+                createNode<ConfigureRoomFlowNode>(context = buildContext, plugins = emptyList())
-                    override fun onContinue(selectedUsers: List<MatrixUser>) {
-                        backstack.push(NavTarget.ConfigureRoom(selectedUsers))
-                    }
-                }
-                createNode<AddPeopleNode>(context = buildContext, plugins = listOf(callback))
-            }
-            is NavTarget.ConfigureRoom -> {
-                createNode<ConfigureRoomNode>(context = buildContext, plugins = listOf(ConfigureRoomNode.Inputs(navTarget.users)))
             }
         }
     }

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleNode.kt

@@ -25,10 +25,9 @@ import com.bumble.appyx.core.plugin.plugins
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
-import io.element.android.libraries.di.SessionScope
+import io.element.android.features.createroom.impl.di.CreateRoomScope
-import io.element.android.libraries.matrix.ui.model.MatrixUser
 
-@ContributesNode(SessionScope::class)
+@ContributesNode(CreateRoomScope::class)
 class AddPeopleNode @AssistedInject constructor(
     @Assisted buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
@@ -36,11 +35,11 @@ class AddPeopleNode @AssistedInject constructor(
 ) : Node(buildContext, plugins = plugins) {
 
     interface Callback : Plugin {
-        fun onContinue(selectedUsers: List<MatrixUser>)
+        fun onContinue()
     }
 
-    private fun onContinue(selectedUsers: List<MatrixUser>) {
+    private fun onContinue() {
-        plugins<Callback>().forEach { it.onContinue(selectedUsers) }
+        plugins<Callback>().forEach { it.onContinue() }
     }
 
     @Composable
@@ -49,7 +48,7 @@ class AddPeopleNode @AssistedInject constructor(
         AddPeopleView(
             state = state,
             modifier = modifier,
-            onBackPressed = { navigateUp() },
+            onBackPressed = this::navigateUp,
             onNextPressed = this::onContinue,
         )
     }

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeoplePresenter.kt

@@ -17,38 +17,33 @@
 package io.element.android.features.createroom.impl.addpeople
 
 import androidx.compose.runtime.Composable
+import io.element.android.features.createroom.impl.CreateRoomDataStore
 import io.element.android.features.userlist.api.SelectionMode
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
 import io.element.android.features.userlist.api.UserListPresenter
 import io.element.android.features.userlist.api.UserListPresenterArgs
+import io.element.android.features.userlist.api.UserListState
 import io.element.android.libraries.architecture.Presenter
 import javax.inject.Inject
 import javax.inject.Named
 
 class AddPeoplePresenter @Inject constructor(
     private val userListPresenterFactory: UserListPresenter.Factory,
-    @Named("AllUsers") private val matrixUserDataSource: MatrixUserDataSource,
+    @Named("AllUsers") private val userListDataSource: UserListDataSource,
-) : Presenter<AddPeopleState> {
+    private val dataStore: CreateRoomDataStore,
+) : Presenter<UserListState> {
 
     private val userListPresenter by lazy {
         userListPresenterFactory.create(
             UserListPresenterArgs(selectionMode = SelectionMode.Multiple),
-            matrixUserDataSource,
+            userListDataSource,
+            dataStore.selectedUserListDataStore,
         )
     }
 
     @Composable
-    override fun present(): AddPeopleState {
+    override fun present(): UserListState {
-        val userListState = userListPresenter.present()
+        return userListPresenter.present()
-
-        fun handleEvents(event: AddPeopleEvents) {
-            // do nothing for now
-        }
-
-        return AddPeopleState(
-            userListState = userListState,
-            eventSink = ::handleEvents,
-        )
     }
 }
 

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleUserListStateProvider.kt

@@ -18,30 +18,27 @@ package io.element.android.features.createroom.impl.addpeople
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import io.element.android.features.userlist.api.SelectionMode
+import io.element.android.features.userlist.api.UserListState
 import io.element.android.features.userlist.api.aListOfSelectedUsers
 import io.element.android.features.userlist.api.aUserListState
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import kotlinx.collections.immutable.toImmutableList
 
-open class AddPeopleStateProvider : PreviewParameterProvider<AddPeopleState> {
+open class AddPeopleUserListStateProvider : PreviewParameterProvider<UserListState> {
-    override val values: Sequence<AddPeopleState>
+    override val values: Sequence<UserListState>
         get() = sequenceOf(
-            aAddPeopleState(),
+            aUserListState(),
-            aAddPeopleState().copy(
+            aUserListState().copy(
-                userListState = aUserListState().copy(
+                searchResults = aMatrixUserList().toImmutableList(),
-                    selectedUsers = aListOfSelectedUsers(),
+                selectedUsers = aListOfSelectedUsers(),
-                    selectionMode = SelectionMode.Multiple,
+                isSearchActive = false,
-                )
+                selectionMode = SelectionMode.Multiple,
             ),
-            aAddPeopleState().copy(
+            aUserListState().copy(
-                userListState = aUserListState().copy(
+                searchResults = aMatrixUserList().toImmutableList(),
-                    selectedUsers = aListOfSelectedUsers(),
+                selectedUsers = aListOfSelectedUsers(),
-                    isSearchActive = true,
+                isSearchActive = true,
-                    selectionMode = SelectionMode.Multiple,
+                selectionMode = SelectionMode.Multiple,
-                )
             )
         )
 }
-
-fun aAddPeopleState() = AddPeopleState(
-    userListState = aUserListState(),
-    eventSink = {}
-)

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleView.kt

@@ -30,7 +30,8 @@ import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import io.element.android.features.createroom.impl.R
-import io.element.android.features.userlist.api.UserListView
+import io.element.android.features.userlist.api.UserListState
+import io.element.android.features.userlist.api.components.UserListView
 import io.element.android.libraries.designsystem.components.button.BackButton
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
@@ -38,26 +39,23 @@ import io.element.android.libraries.designsystem.theme.components.CenterAlignedT
 import io.element.android.libraries.designsystem.theme.components.Scaffold
 import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.theme.components.TextButton
-import io.element.android.libraries.matrix.ui.model.MatrixUser
 import io.element.android.libraries.ui.strings.R as StringR
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun AddPeopleView(
-    state: AddPeopleState,
+    state: UserListState,
     modifier: Modifier = Modifier,
     onBackPressed: () -> Unit = {},
-    onNextPressed: (List<MatrixUser>) -> Unit = {},
+    onNextPressed: () -> Unit = {},
 ) {
-    val eventSink = state.eventSink
-
     Scaffold(
         topBar = {
-            if (!state.userListState.isSearchActive) {
+            if (!state.isSearchActive) {
                 AddPeopleViewTopBar(
-                    hasSelectedUsers = state.userListState.selectedUsers.isNotEmpty(),
+                    hasSelectedUsers = state.selectedUsers.isNotEmpty(),
                     onBackPressed = onBackPressed,
-                    onNextPressed = { onNextPressed(state.userListState.selectedUsers) },
+                    onNextPressed = onNextPressed,
                 )
             }
         }
@@ -69,7 +67,7 @@ fun AddPeopleView(
         ) {
             UserListView(
                 modifier = Modifier.fillMaxWidth(),
-                state = state.userListState,
+                state = state,
             )
         }
     }
@@ -110,15 +108,15 @@ fun AddPeopleViewTopBar(
 
 @Preview
 @Composable
-internal fun AddPeopleViewLightPreview(@PreviewParameter(AddPeopleStateProvider::class) state: AddPeopleState) =
+internal fun AddPeopleViewLightPreview(@PreviewParameter(AddPeopleUserListStateProvider::class) state: UserListState) =
     ElementPreviewLight { ContentToPreview(state) }
 
 @Preview
 @Composable
-internal fun AddPeopleViewDarkPreview(@PreviewParameter(AddPeopleStateProvider::class) state: AddPeopleState) =
+internal fun AddPeopleViewDarkPreview(@PreviewParameter(AddPeopleUserListStateProvider::class) state: UserListState) =
     ElementPreviewDark { ContentToPreview(state) }
 
 @Composable
-private fun ContentToPreview(state: AddPeopleState) {
+private fun ContentToPreview(state: UserListState) {
     AddPeopleView(state = state)
 }

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomEvents.kt

@@ -17,11 +17,13 @@
 package io.element.android.features.createroom.impl.configureroom
 
 import android.net.Uri
+import io.element.android.libraries.matrix.ui.model.MatrixUser
 
 sealed interface ConfigureRoomEvents {
     data class RoomNameChanged(val name: String) : ConfigureRoomEvents
     data class TopicChanged(val topic: String) : ConfigureRoomEvents
     data class AvatarUriChanged(val uri: Uri?) : ConfigureRoomEvents
     data class RoomPrivacyChanged(val privacy: RoomPrivacy?) : ConfigureRoomEvents
+    data class RemoveFromSelection(val matrixUser: MatrixUser) : ConfigureRoomEvents
     object CreateRoom : ConfigureRoomEvents
 }

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomNode.kt

@@ -24,27 +24,15 @@ 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.features.createroom.impl.di.CreateRoomScope
-import io.element.android.libraries.architecture.inputs
-import io.element.android.libraries.di.SessionScope
-import io.element.android.libraries.matrix.ui.model.MatrixUser
 
-@ContributesNode(SessionScope::class)
+@ContributesNode(CreateRoomScope::class)
 class ConfigureRoomNode @AssistedInject constructor(
     @Assisted buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
-    private val presenterFactory: ConfigureRoomPresenter.Factory,
+    private val presenter: ConfigureRoomPresenter,
 ) : Node(buildContext, plugins = plugins) {
 
-    data class Inputs(
-        val selectedUsers: List<MatrixUser>
-    ) : NodeInputs
-
-    private val inputs: Inputs = inputs()
-    private val presenter by lazy {
-        presenterFactory.create(ConfigureRoomPresenterArgs(inputs.selectedUsers))
-    }
-
     @Composable
     override fun View(modifier: Modifier) {
         val state = presenter.present()

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenter.kt

@@ -16,57 +16,42 @@
 
 package io.element.android.features.createroom.impl.configureroom
 
-import android.net.Uri
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.saveable.rememberSaveable
+import io.element.android.features.createroom.impl.CreateRoomConfig
-import androidx.compose.runtime.setValue
+import io.element.android.features.createroom.impl.CreateRoomDataStore
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
 import io.element.android.libraries.architecture.Presenter
-import kotlinx.collections.immutable.toImmutableList
+import javax.inject.Inject
 
-class ConfigureRoomPresenter @AssistedInject constructor(
+class ConfigureRoomPresenter @Inject constructor(
-    @Assisted val args: ConfigureRoomPresenterArgs,
+    private val dataStore: CreateRoomDataStore,
 ) : Presenter<ConfigureRoomState> {
 
-    @AssistedFactory
-    interface Factory {
-        fun create(args: ConfigureRoomPresenterArgs): ConfigureRoomPresenter
-    }
-
     @Composable
     override fun present(): ConfigureRoomState {
-        var roomName by rememberSaveable { mutableStateOf("") }
+        val createRoomConfig = dataStore.getCreateRoomConfig().collectAsState(CreateRoomConfig())
-        var topic by rememberSaveable { mutableStateOf("") }
+        val isCreateButtonEnabled by remember(createRoomConfig.value.roomName, createRoomConfig.value.privacy) {
-        var avatarUri by rememberSaveable { mutableStateOf<Uri?>(null) }
-        var privacy by rememberSaveable { mutableStateOf<RoomPrivacy?>(null) }
-        val isCreateButtonEnabled by remember {
             derivedStateOf {
-                roomName.isNotEmpty() && privacy != null
+                createRoomConfig.value.roomName.isNullOrEmpty().not() && createRoomConfig.value.privacy != null
             }
         }
 
         fun handleEvents(event: ConfigureRoomEvents) {
             when (event) {
-                is ConfigureRoomEvents.AvatarUriChanged -> avatarUri = event.uri
+                is ConfigureRoomEvents.AvatarUriChanged -> dataStore.setAvatarUrl(event.uri?.toString())
-                is ConfigureRoomEvents.RoomNameChanged -> roomName = event.name
+                is ConfigureRoomEvents.RoomNameChanged -> dataStore.setRoomName(event.name)
-                is ConfigureRoomEvents.TopicChanged -> topic = event.topic
+                is ConfigureRoomEvents.TopicChanged -> dataStore.setTopic(event.topic)
-                is ConfigureRoomEvents.RoomPrivacyChanged -> privacy = event.privacy
+                is ConfigureRoomEvents.RoomPrivacyChanged -> dataStore.setPrivacy(event.privacy)
+                is ConfigureRoomEvents.RemoveFromSelection -> dataStore.selectedUserListDataStore.removeUserFromSelection(event.matrixUser)
                 ConfigureRoomEvents.CreateRoom -> Unit // TODO
             }
         }
 
         return ConfigureRoomState(
-            selectedUsers = args.selectedUsers.toImmutableList(),
+            createRoomConfig.value,
-            roomName = roomName,
-            topic = topic,
-            avatarUri = avatarUri,
-            privacy = privacy,
             isCreateButtonEnabled = isCreateButtonEnabled,
             eventSink = ::handleEvents,
         )

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomState.kt

@@ -16,16 +16,10 @@
 
 package io.element.android.features.createroom.impl.configureroom
 
-import android.net.Uri
+import io.element.android.features.createroom.impl.CreateRoomConfig
-import io.element.android.libraries.matrix.ui.model.MatrixUser
-import kotlinx.collections.immutable.ImmutableList
 
 data class ConfigureRoomState(
-    val selectedUsers: ImmutableList<MatrixUser>,
+    val config: CreateRoomConfig,
-    val roomName: String,
-    val topic: String,
-    val avatarUri: Uri?,
-    val privacy: RoomPrivacy?,
     val isCreateButtonEnabled: Boolean,
     val eventSink: (ConfigureRoomEvents) -> Unit
 )

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomStateProvider.kt

@@ -17,22 +17,27 @@
 package io.element.android.features.createroom.impl.configureroom
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import io.element.android.features.createroom.impl.CreateRoomConfig
-import kotlinx.collections.immutable.toImmutableList
+import io.element.android.features.userlist.api.aListOfSelectedUsers
 
 open class ConfigureRoomStateProvider : PreviewParameterProvider<ConfigureRoomState> {
     override val values: Sequence<ConfigureRoomState>
         get() = sequenceOf(
             aConfigureRoomState(),
+            aConfigureRoomState().copy(
+                config = CreateRoomConfig(
+                    roomName = "Room 101",
+                    topic = "Room topic for this room when the text goes onto multiple lines and is really long, there shouldn’t be more than 3 lines",
+                    invites = aListOfSelectedUsers(),
+                    privacy = RoomPrivacy.Private,
+                ),
+                isCreateButtonEnabled = true,
+            ),
         )
 }
 
 fun aConfigureRoomState() = ConfigureRoomState(
-    selectedUsers = aMatrixUserList().toImmutableList(),
+    config = CreateRoomConfig(),
-    roomName = "",
-    topic = "",
-    avatarUri = null,
-    privacy = null,
     isCreateButtonEnabled = false,
     eventSink = {}
 )

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomView.kt

@@ -19,29 +19,31 @@
 package io.element.android.features.createroom.impl.configureroom
 
 import android.net.Uri
+import android.widget.Toast
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.selection.selectableGroup
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.core.net.toUri
 import io.element.android.features.createroom.impl.R
 import io.element.android.features.createroom.impl.components.Avatar
 import io.element.android.features.createroom.impl.components.LabelledTextField
 import io.element.android.features.createroom.impl.components.RoomPrivacyOption
-import io.element.android.features.userlist.api.SelectedUsersList
+import io.element.android.features.userlist.api.components.SelectedUsersList
 import io.element.android.libraries.designsystem.components.button.BackButton
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
@@ -57,14 +59,17 @@ fun ConfigureRoomView(
     modifier: Modifier = Modifier,
     onBackPressed: () -> Unit = {},
 ) {
-    val selectedUsersListState = rememberLazyListState()
+    val context = LocalContext.current
     Scaffold(
         modifier = modifier,
         topBar = {
             ConfigureRoomToolbar(
                 isNextActionEnabled = state.isCreateButtonEnabled,
                 onBackPressed = onBackPressed,
-                onNextPressed = { state.eventSink(ConfigureRoomEvents.CreateRoom) },
+                onNextPressed = {
+                    // state.eventSink(ConfigureRoomEvents.CreateRoom)
+                    Toast.makeText(context, "not implemented yet", Toast.LENGTH_SHORT).show()
+                },
             )
         }
     ) { padding ->
@@ -74,25 +79,25 @@ fun ConfigureRoomView(
         ) {
             RoomNameWithAvatar(
                 modifier = Modifier.padding(horizontal = 16.dp),
-                avatarUri = state.avatarUri,
+                avatarUri = state.config.avatarUrl?.toUri(),
-                roomName = state.roomName,
+                roomName = state.config.roomName.orEmpty(),
+                onAvatarClick = { Toast.makeText(context, "not implemented yet", Toast.LENGTH_SHORT).show() },
                 onRoomNameChanged = { state.eventSink(ConfigureRoomEvents.RoomNameChanged(it)) },
             )
             RoomTopic(
                 modifier = Modifier.padding(horizontal = 16.dp),
-                topic = state.topic,
+                topic = state.config.topic.orEmpty(),
                 onTopicChanged = { state.eventSink(ConfigureRoomEvents.TopicChanged(it)) },
             )
             SelectedUsersList(
-                listState = selectedUsersListState,
                 contentPadding = PaddingValues(horizontal = 24.dp),
-                selectedUsers = state.selectedUsers,
+                selectedUsers = state.config.invites,
-                onUserRemoved = { }, // TODO
+                onUserRemoved = { state.eventSink(ConfigureRoomEvents.RemoveFromSelection(it)) },
             )
             Spacer(Modifier.weight(1f))
             RoomPrivacyOptions(
                 modifier = Modifier.padding(bottom = 40.dp),
-                selected = state.privacy,
+                selected = state.config.privacy,
                 onOptionSelected = { state.eventSink(ConfigureRoomEvents.RoomPrivacyChanged(it.privacy)) },
             )
         }

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/RoomPrivacy.kt

@@ -17,6 +17,6 @@
 package io.element.android.features.createroom.impl.configureroom
 
 enum class RoomPrivacy {
-    Public,
     Private,
+    Public,
 }

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/RoomPrivacyItem.kt

@@ -38,13 +38,13 @@ fun roomPrivacyItems(): ImmutableList<RoomPrivacyItem> {
     return RoomPrivacy.values()
         .map {
             when (it) {
-                RoomPrivacy.Public -> RoomPrivacyItem(
+                RoomPrivacy.Private -> RoomPrivacyItem(
                     privacy = it,
                     icon = Icons.Outlined.Lock,
                     title = stringResource(R.string.screen_create_room_private_option_title),
                     description = stringResource(R.string.screen_create_room_private_option_description),
                 )
-                RoomPrivacy.Private -> RoomPrivacyItem(
+                RoomPrivacy.Public -> RoomPrivacyItem(
                     privacy = it,
                     icon = Icons.Outlined.Public,
                     title = stringResource(R.string.screen_create_room_public_option_title),

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/di/CreateRoomComponent.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.createroom.impl.di
+
+import com.squareup.anvil.annotations.ContributesTo
+import com.squareup.anvil.annotations.MergeSubcomponent
+import dagger.Subcomponent
+import io.element.android.libraries.architecture.NodeFactoriesBindings
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.di.SingleIn
+
+@SingleIn(CreateRoomScope::class)
+@MergeSubcomponent(CreateRoomScope::class)
+interface CreateRoomComponent : NodeFactoriesBindings {
+
+    @Subcomponent.Builder
+    interface Builder {
+        fun build(): CreateRoomComponent
+    }
+
+    @ContributesTo(SessionScope::class)
+    interface ParentBindings {
+        fun createRoomComponentBuilder(): Builder
+    }
+}

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/di/CreateRoomModule.kt

@@ -20,7 +20,7 @@ import com.squareup.anvil.annotations.ContributesTo
 import dagger.Binds
 import dagger.Module
 import io.element.android.features.createroom.impl.AllMatrixUsersDataSource
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
 import io.element.android.libraries.di.AppScope
 import javax.inject.Named
 
@@ -30,6 +30,6 @@ interface CreateRoomModule {
 
     @Binds
     @Named("AllUsers")
-    fun bindAllUserListDataSource(dataSource: AllMatrixUsersDataSource): MatrixUserDataSource
+    fun bindAllUserListDataSource(dataSource: AllMatrixUsersDataSource): UserListDataSource
 
 }

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/di/CreateRoomScope.kt

@@ -14,6 +14,6 @@
  * limitations under the License.
  */
 
-package io.element.android.features.createroom.impl.addpeople
+package io.element.android.features.createroom.impl.di
 
-sealed interface AddPeopleEvents
+abstract class CreateRoomScope private constructor()

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/root/CreateRoomRootPresenter.kt

@@ -21,8 +21,9 @@ 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.userlist.api.MatrixUserDataSource
 import io.element.android.features.userlist.api.SelectionMode
+import io.element.android.features.userlist.api.UserListDataSource
+import io.element.android.features.userlist.api.UserListDataStore
 import io.element.android.features.userlist.api.UserListPresenter
 import io.element.android.features.userlist.api.UserListPresenterArgs
 import io.element.android.libraries.architecture.Async
@@ -38,14 +39,16 @@ import javax.inject.Named
 
 class CreateRoomRootPresenter @Inject constructor(
     private val presenterFactory: UserListPresenter.Factory,
-    @Named("AllUsers") private val matrixUserDataSource: MatrixUserDataSource,
+    @Named("AllUsers") private val userListDataSource: UserListDataSource,
+    private val userListDataStore: UserListDataStore,
     private val matrixClient: MatrixClient,
 ) : Presenter<CreateRoomRootState> {
 
     private val presenter by lazy {
         presenterFactory.create(
             UserListPresenterArgs(selectionMode = SelectionMode.Single),
-            matrixUserDataSource,
+            userListDataSource,
+            userListDataStore,
         )
     }
 

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/root/CreateRoomRootView.kt

@@ -41,7 +41,7 @@ import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import io.element.android.features.createroom.impl.R
-import io.element.android.features.userlist.api.UserListView
+import io.element.android.features.userlist.api.components.UserListView
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.designsystem.components.ProgressDialog
 import io.element.android.libraries.designsystem.components.dialogs.RetryDialog

features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeoplePresenterTests.kt

@@ -22,7 +22,9 @@ 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.userlist.test.FakeMatrixUserDataSource
+import io.element.android.features.createroom.impl.CreateRoomDataStore
+import io.element.android.features.userlist.api.UserListDataStore
+import io.element.android.features.userlist.test.FakeUserListDataSource
 import io.element.android.features.userlist.test.FakeUserListPresenterFactory
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
@@ -35,7 +37,7 @@ class AddPeoplePresenterTests {
 
     @Before
     fun setup() {
-        presenter = AddPeoplePresenter(FakeUserListPresenterFactory(), FakeMatrixUserDataSource())
+        presenter = AddPeoplePresenter(FakeUserListPresenterFactory(), FakeUserListDataSource(), CreateRoomDataStore(UserListDataStore()))
     }
 
     @Test

features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenterTests.kt

@@ -23,9 +23,15 @@ 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.createroom.impl.CreateRoomConfig
+import io.element.android.features.createroom.impl.CreateRoomDataStore
+import io.element.android.features.userlist.api.UserListDataStore
 import io.element.android.libraries.matrix.test.AN_AVATAR_URL
 import io.element.android.libraries.matrix.test.A_MESSAGE
 import io.element.android.libraries.matrix.test.A_ROOM_NAME
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
@@ -37,10 +43,12 @@ import org.robolectric.RobolectricTestRunner
 class ConfigureRoomPresenterTests {
 
     private lateinit var presenter: ConfigureRoomPresenter
+    private lateinit var userListDataStore: UserListDataStore
 
     @Before
     fun setup() {
-        presenter = ConfigureRoomPresenter(ConfigureRoomPresenterArgs(emptyList()))
+        userListDataStore = UserListDataStore()
+        presenter = ConfigureRoomPresenter(CreateRoomDataStore(userListDataStore))
     }
 
     @Test
@@ -49,9 +57,12 @@ class ConfigureRoomPresenterTests {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.roomName).isEmpty()
+            assertThat(initialState.config).isEqualTo(CreateRoomConfig())
-            assertThat(initialState.topic).isEmpty()
+            assertThat(initialState.config.roomName).isNull()
-            assertThat(initialState.privacy).isNull()
+            assertThat(initialState.config.topic).isNull()
+            assertThat(initialState.config.invites).isEmpty()
+            assertThat(initialState.config.avatarUrl).isNull()
+            assertThat(initialState.config.privacy).isNull()
         }
     }
 
@@ -61,24 +72,28 @@ class ConfigureRoomPresenterTests {
             presenter.present()
         }.test {
             val initialState = awaitItem()
+            var config = initialState.config
             assertThat(initialState.isCreateButtonEnabled).isFalse()
 
             // Room name not empty
             initialState.eventSink(ConfigureRoomEvents.RoomNameChanged(A_ROOM_NAME))
             var newState: ConfigureRoomState = awaitItem()
-            assertThat(newState.roomName).isEqualTo(A_ROOM_NAME)
+            config = config.copy(roomName = A_ROOM_NAME)
+            assertThat(newState.config).isEqualTo(config)
             assertThat(newState.isCreateButtonEnabled).isFalse()
 
             // Select privacy
-            initialState.eventSink(ConfigureRoomEvents.RoomPrivacyChanged(RoomPrivacy.Private))
+            newState.eventSink(ConfigureRoomEvents.RoomPrivacyChanged(RoomPrivacy.Private))
             newState = awaitItem()
-            assertThat(newState.privacy).isEqualTo(RoomPrivacy.Private)
+            config = config.copy(privacy = RoomPrivacy.Private)
+            assertThat(newState.config).isEqualTo(config)
             assertThat(newState.isCreateButtonEnabled).isTrue()
 
             // Clear room name
-            initialState.eventSink(ConfigureRoomEvents.RoomNameChanged(""))
+            newState.eventSink(ConfigureRoomEvents.RoomNameChanged(""))
             newState = awaitItem()
-            assertThat(newState.roomName).isEqualTo("")
+            config = config.copy(roomName = null)
+            assertThat(newState.config).isEqualTo(config)
             assertThat(newState.isCreateButtonEnabled).isFalse()
         }
     }
@@ -89,26 +104,49 @@ class ConfigureRoomPresenterTests {
             presenter.present()
         }.test {
             val initialState = awaitItem()
+            var expectedConfig = CreateRoomConfig()
+            assertThat(initialState.config).isEqualTo(expectedConfig)
+
+            // Select User
+            val selectedUser1 = aMatrixUser()
+            val selectedUser2 = aMatrixUser("@id_of_bob:server.org", "Bob")
+            userListDataStore.selectUser(selectedUser1)
+            skipItems(1)
+            userListDataStore.selectUser(selectedUser2)
+            var newState = awaitItem()
+            expectedConfig = expectedConfig.copy(invites = persistentListOf(selectedUser1, selectedUser2))
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
             // Room name
             initialState.eventSink(ConfigureRoomEvents.RoomNameChanged(A_ROOM_NAME))
-            val stateAfterRoomNameChanged = awaitItem()
+            newState = awaitItem()
-            assertThat(stateAfterRoomNameChanged.roomName).isEqualTo(A_ROOM_NAME)
+            expectedConfig = expectedConfig.copy(roomName = A_ROOM_NAME)
+            assertThat(newState.config).isEqualTo(expectedConfig)
 
             // Room topic
-            stateAfterRoomNameChanged.eventSink(ConfigureRoomEvents.TopicChanged(A_MESSAGE))
+            newState.eventSink(ConfigureRoomEvents.TopicChanged(A_MESSAGE))
-            val stateAfterTopicChanged = awaitItem()
+            newState = awaitItem()
-            assertThat(stateAfterTopicChanged.topic).isEqualTo(A_MESSAGE)
+            expectedConfig = expectedConfig.copy(topic = A_MESSAGE)
+            assertThat(newState.config).isEqualTo(expectedConfig)
 
             // Room avatar
             val anUri = Uri.parse(AN_AVATAR_URL)
-            stateAfterTopicChanged.eventSink(ConfigureRoomEvents.AvatarUriChanged(anUri))
+            newState.eventSink(ConfigureRoomEvents.AvatarUriChanged(anUri))
-            val stateAfterAvatarUriChanged = awaitItem()
+            newState = awaitItem()
-            assertThat(stateAfterAvatarUriChanged.avatarUri).isEqualTo(anUri)
+            expectedConfig = expectedConfig.copy(avatarUrl = anUri.toString())
+            assertThat(newState.config).isEqualTo(expectedConfig)
 
             // Room privacy
-            stateAfterAvatarUriChanged.eventSink(ConfigureRoomEvents.RoomPrivacyChanged(RoomPrivacy.Public))
+            newState.eventSink(ConfigureRoomEvents.RoomPrivacyChanged(RoomPrivacy.Public))
-            val stateAfterPrivacyChanged = awaitItem()
+            newState = awaitItem()
-            assertThat(stateAfterPrivacyChanged.privacy).isEqualTo(RoomPrivacy.Public)
+            expectedConfig = expectedConfig.copy(privacy = RoomPrivacy.Public)
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
+            // Remove user
+            newState.eventSink(ConfigureRoomEvents.RemoveFromSelection(selectedUser1))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(invites = expectedConfig.invites.minus(selectedUser1).toImmutableList())
+            assertThat(newState.config).isEqualTo(expectedConfig)
         }
     }
 }

features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/root/CreateRoomRootPresenterTests.kt

@@ -22,8 +22,9 @@ 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.userlist.api.UserListDataStore
 import io.element.android.features.userlist.api.aUserListState
-import io.element.android.features.userlist.test.FakeMatrixUserDataSource
+import io.element.android.features.userlist.test.FakeUserListDataSource
 import io.element.android.features.userlist.test.FakeUserListPresenter
 import io.element.android.features.userlist.test.FakeUserListPresenterFactory
 import io.element.android.libraries.architecture.Async
@@ -41,7 +42,7 @@ import org.junit.Test
 
 class CreateRoomRootPresenterTests {
 
-    private lateinit var userListDataSource: FakeMatrixUserDataSource
+    private lateinit var userListDataSource: FakeUserListDataSource
     private lateinit var presenter: CreateRoomRootPresenter
     private lateinit var fakeUserListPresenter: FakeUserListPresenter
     private lateinit var fakeMatrixClient: FakeMatrixClient
@@ -50,8 +51,8 @@ class CreateRoomRootPresenterTests {
     fun setup() {
         fakeUserListPresenter = FakeUserListPresenter()
         fakeMatrixClient = FakeMatrixClient()
-        userListDataSource = FakeMatrixUserDataSource()
+        userListDataSource = FakeUserListDataSource()
-        presenter = CreateRoomRootPresenter(FakeUserListPresenterFactory(fakeUserListPresenter), userListDataSource, fakeMatrixClient)
+        presenter = CreateRoomRootPresenter(FakeUserListPresenterFactory(fakeUserListPresenter), userListDataSource, UserListDataStore(), fakeMatrixClient)
     }
 
     @Test

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

@@ -20,9 +20,9 @@ import com.squareup.anvil.annotations.ContributesTo
 import dagger.Binds
 import dagger.Module
 import dagger.Provides
-import io.element.android.features.roomdetails.impl.members.RoomMatrixUserDataSource
+import io.element.android.features.roomdetails.impl.members.RoomUserListDataSource
 import io.element.android.features.roomdetails.impl.members.details.RoomMemberDetailsPresenter
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
 import io.element.android.libraries.di.RoomScope
 import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.room.RoomMember
@@ -34,7 +34,7 @@ interface RoomMemberBindsModule {
 
     @Binds
     @Named("RoomMembers")
-    fun bindRoomMemberUserListDataSource(dataSource: RoomMatrixUserDataSource): MatrixUserDataSource
+    fun bindRoomMemberUserListDataSource(dataSource: RoomUserListDataSource): UserListDataSource
 }
 
 @Module

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

@@ -21,7 +21,8 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import io.element.android.features.userlist.api.SelectionMode
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
+import io.element.android.features.userlist.api.UserListDataStore
 import io.element.android.features.userlist.api.UserListPresenter
 import io.element.android.features.userlist.api.UserListPresenterArgs
 import io.element.android.libraries.architecture.Async
@@ -36,13 +37,15 @@ import javax.inject.Named
 
 class RoomMemberListPresenter @Inject constructor(
     private val userListPresenterFactory: UserListPresenter.Factory,
-    @Named("RoomMembers") private val matrixUserDataSource: MatrixUserDataSource,
+    @Named("RoomMembers") private val userListDataSource: UserListDataSource,
+    private val userListDataStore: UserListDataStore,
 ) : Presenter<RoomMemberListState> {
 
     private val userListPresenter by lazy {
         userListPresenterFactory.create(
             UserListPresenterArgs(selectionMode = SelectionMode.Single),
-            matrixUserDataSource,
+            userListDataSource,
+            userListDataStore,
         )
     }
 
@@ -52,7 +55,7 @@ class RoomMemberListPresenter @Inject constructor(
         val allUsers = remember { mutableStateOf<Async<ImmutableList<MatrixUser>>>(Async.Loading()) }
         LaunchedEffect(Unit) {
             withContext(Dispatchers.IO) {
-                allUsers.value = Async.Success(matrixUserDataSource.search("").toImmutableList())
+                allUsers.value = Async.Success(userListDataSource.search("").toImmutableList())
             }
         }
         return RoomMemberListState(

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

@@ -39,8 +39,8 @@ import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import io.element.android.features.roomdetails.impl.R
-import io.element.android.features.userlist.api.SearchSingleUserResultItem
+import io.element.android.features.userlist.api.components.SearchSingleUserResultItem
-import io.element.android.features.userlist.api.UserListView
+import io.element.android.features.userlist.api.components.UserListView
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.architecture.isLoading
 import io.element.android.libraries.designsystem.ElementTextStyles

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

@@ -16,7 +16,7 @@
 
 package io.element.android.features.roomdetails.impl.members
 
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
 import io.element.android.libraries.core.bool.orFalse
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
 import io.element.android.libraries.matrix.api.core.UserId
@@ -25,9 +25,9 @@ import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.ui.model.MatrixUser
 import javax.inject.Inject
 
-class RoomMatrixUserDataSource @Inject constructor(
+class RoomUserListDataSource @Inject constructor(
     private val room: MatrixRoom
-) : MatrixUserDataSource {
+) : UserListDataSource {
 
     override suspend fun search(query: String): List<MatrixUser> {
         return room.members().filter { member ->

features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/members/RoomMemberListPresenterTests.kt

@@ -22,11 +22,12 @@ import app.cash.turbine.test
 import com.google.common.truth.Truth
 import io.element.android.features.roomdetails.impl.members.RoomMemberListPresenter
 import io.element.android.features.userlist.api.SelectionMode
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
+import io.element.android.features.userlist.api.UserListDataStore
 import io.element.android.features.userlist.api.UserListPresenter
 import io.element.android.features.userlist.api.UserListPresenterArgs
 import io.element.android.features.userlist.impl.DefaultUserListPresenter
-import io.element.android.features.userlist.test.FakeMatrixUserDataSource
+import io.element.android.features.userlist.test.FakeUserListDataSource
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.ui.components.aMatrixUser
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -40,13 +41,18 @@ class RoomMemberListPresenterTests {
     @Test
     fun `present - search is done automatically on start, but is async`() = runTest {
         val searchResult = listOf(aMatrixUser())
-        val userListDataSource = FakeMatrixUserDataSource().apply {
+        val userListDataSource = FakeUserListDataSource().apply {
             givenSearchResult(searchResult)
         }
+        val userListDataStore = UserListDataStore()
         val userListFactory = object : UserListPresenter.Factory {
-            override fun create(args: UserListPresenterArgs, dataSource: MatrixUserDataSource) = DefaultUserListPresenter(args, dataSource)
+            override fun create(
+                args: UserListPresenterArgs,
+                userListDataSource: UserListDataSource,
+                userListDataStore: UserListDataStore,
+            ) = DefaultUserListPresenter(args, userListDataSource, userListDataStore)
         }
-        val presenter = RoomMemberListPresenter(userListFactory, userListDataSource)
+        val presenter = RoomMemberListPresenter(userListFactory, userListDataSource, userListDataStore)
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()
         }.test {
@@ -60,5 +66,4 @@ class RoomMemberListPresenterTests {
             Truth.assertThat((loadedState.allUsers as? Async.Success)?.state).isEqualTo(searchResult.toImmutableList())
         }
     }
-
 }

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListDataSource.kt

@@ -19,7 +19,7 @@ package io.element.android.features.userlist.api
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.ui.model.MatrixUser
 
-interface MatrixUserDataSource {
+interface UserListDataSource {
     suspend fun search(query: String): List<MatrixUser>
     suspend fun getProfile(userId: UserId): MatrixUser?
 }

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListDataStore.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.userlist.api
+
+import io.element.android.libraries.matrix.ui.model.MatrixUser
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import javax.inject.Inject
+
+class UserListDataStore @Inject constructor() {
+
+    private val selectedUsers: MutableStateFlow<List<MatrixUser>> = MutableStateFlow(emptyList())
+
+    fun selectUser(user: MatrixUser) {
+        if (user !in selectedUsers.value) {
+            selectedUsers.tryEmit(selectedUsers.value.plus(user))
+        }
+    }
+
+    fun removeUserFromSelection(user: MatrixUser) {
+        selectedUsers.tryEmit(selectedUsers.value.minus(user))
+    }
+
+    fun selectedUsers(): Flow<List<MatrixUser>> = selectedUsers
+}

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListPresenter.kt

@@ -21,6 +21,10 @@ import io.element.android.libraries.architecture.Presenter
 interface UserListPresenter : Presenter<UserListState> {
 
     interface Factory {
-        fun create(args: UserListPresenterArgs, matrixUserDataSource: MatrixUserDataSource): UserListPresenter
+        fun create(
+            args: UserListPresenterArgs,
+            userListDataSource: UserListDataSource,
+            userListDataStore: UserListDataStore,
+        ): UserListPresenter
     }
 }

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListState.kt

@@ -16,7 +16,6 @@
 
 package io.element.android.features.userlist.api
 
-import androidx.compose.foundation.lazy.LazyListState
 import io.element.android.libraries.matrix.ui.model.MatrixUser
 import kotlinx.collections.immutable.ImmutableList
 
@@ -24,7 +23,6 @@ data class UserListState(
     val searchQuery: String,
     val searchResults: ImmutableList<MatrixUser>,
     val selectedUsers: ImmutableList<MatrixUser>,
-    val selectedUsersListState: LazyListState,
     val isSearchActive: Boolean,
     val selectionMode: SelectionMode,
     val eventSink: (UserListEvents) -> Unit,

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListStateProvider.kt

@@ -16,11 +16,10 @@
 
 package io.element.android.features.userlist.api
 
-import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
-import io.element.android.libraries.matrix.ui.model.MatrixUser
 import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
 
 open class UserListStateProvider : PreviewParameterProvider<UserListState> {
     override val values: Sequence<UserListState>
@@ -38,14 +37,14 @@ open class UserListStateProvider : PreviewParameterProvider<UserListState> {
                 isSearchActive = true,
                 searchQuery = "@someone:matrix.org",
                 selectedUsers = aListOfSelectedUsers(),
-                searchResults = aListOfResults(),
+                searchResults = aMatrixUserList().toImmutableList(),
             ),
             aUserListState().copy(
                 isSearchActive = true,
                 searchQuery = "@someone:matrix.org",
                 selectionMode = SelectionMode.Multiple,
                 selectedUsers = aListOfSelectedUsers(),
-                searchResults = aListOfResults(),
+                searchResults = aMatrixUserList().toImmutableList(),
             )
         )
 }
@@ -55,33 +54,8 @@ fun aUserListState() = UserListState(
     searchQuery = "",
     searchResults = persistentListOf(),
     selectedUsers = persistentListOf(),
-    selectedUsersListState = LazyListState(
-        firstVisibleItemIndex = 0,
-        firstVisibleItemScrollOffset = 0,
-    ),
     selectionMode = SelectionMode.Single,
     eventSink = {}
 )
 
-fun aListOfSelectedUsers() = persistentListOf(
+fun aListOfSelectedUsers() = aMatrixUserList().take(6).toImmutableList()
-    MatrixUser(id = UserId("@someone:matrix.org")),
-    MatrixUser(id = UserId("@other:matrix.org"), username = "other"),
-)
-
-fun aListOfResults() = persistentListOf(
-    MatrixUser(id = UserId("@someone:matrix.org")),
-    MatrixUser(id = UserId("@other:matrix.org"), username = "other"),
-    MatrixUser(
-        id = UserId("@someone_with_a_very_long_matrix_identifier:a_very_long_domain.org"),
-        username = "hey, I am someone with a very long display name"
-    ),
-    MatrixUser(id = UserId("@someone_2:matrix.org"), username = "someone 2"),
-    MatrixUser(id = UserId("@someone_3:matrix.org"), username = "someone 3"),
-    MatrixUser(id = UserId("@someone_4:matrix.org"), username = "someone 4"),
-    MatrixUser(id = UserId("@someone_5:matrix.org"), username = "someone 5"),
-    MatrixUser(id = UserId("@someone_6:matrix.org"), username = "someone 6"),
-    MatrixUser(id = UserId("@someone_7:matrix.org"), username = "someone 7"),
-    MatrixUser(id = UserId("@someone_8:matrix.org"), username = "someone 8"),
-    MatrixUser(id = UserId("@someone_9:matrix.org"), username = "someone 9"),
-    MatrixUser(id = UserId("@someone_10:matrix.org"), username = "someone 10"),
-)

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListView.kt

@@ -1,314 +0,0 @@
-/*
- * 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.userlist.api
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.LazyListState
-import androidx.compose.foundation.lazy.LazyRow
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Close
-import androidx.compose.material.icons.filled.Search
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.SearchBarDefaults
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextOverflow
-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.avatar.Avatar
-import io.element.android.libraries.designsystem.components.avatar.AvatarSize
-import io.element.android.libraries.designsystem.components.button.BackButton
-import io.element.android.libraries.designsystem.preview.ElementPreviewDark
-import io.element.android.libraries.designsystem.preview.ElementPreviewLight
-import io.element.android.libraries.designsystem.theme.components.Icon
-import io.element.android.libraries.designsystem.theme.components.IconButton
-import io.element.android.libraries.designsystem.theme.components.SearchBar
-import io.element.android.libraries.designsystem.theme.components.Text
-import io.element.android.libraries.matrix.ui.components.CheckableMatrixUserRow
-import io.element.android.libraries.matrix.ui.components.MatrixUserRow
-import io.element.android.libraries.matrix.ui.model.MatrixUser
-import io.element.android.libraries.matrix.ui.model.getBestName
-import kotlinx.collections.immutable.ImmutableList
-import io.element.android.libraries.ui.strings.R as StringR
-
-@Composable
-fun UserListView(
-    state: UserListState,
-    modifier: Modifier = Modifier,
-    onUserSelected: (MatrixUser) -> Unit = {},
-    onUserDeselected: (MatrixUser) -> Unit = {},
-) {
-    Column(
-        modifier = modifier,
-    ) {
-        SearchUserBar(
-            modifier = Modifier.fillMaxWidth(),
-            query = state.searchQuery,
-            results = state.searchResults,
-            selectedUsers = state.selectedUsers,
-            selectedUsersListState = state.selectedUsersListState,
-            active = state.isSearchActive,
-            isMultiSelectionEnabled = state.isMultiSelectionEnabled,
-            onActiveChanged = { state.eventSink(UserListEvents.OnSearchActiveChanged(it)) },
-            onTextChanged = { state.eventSink(UserListEvents.UpdateSearchQuery(it)) },
-            onUserSelected = {
-                state.eventSink(UserListEvents.AddToSelection(it))
-                onUserSelected(it)
-            },
-            onUserDeselected = {
-                state.eventSink(UserListEvents.RemoveFromSelection(it))
-                onUserDeselected(it)
-            },
-        )
-
-        if (state.isMultiSelectionEnabled && !state.isSearchActive && state.selectedUsers.isNotEmpty()) {
-            SelectedUsersList(
-                listState = state.selectedUsersListState,
-                contentPadding = PaddingValues(16.dp),
-                selectedUsers = state.selectedUsers,
-                onUserRemoved = {
-                    state.eventSink(UserListEvents.RemoveFromSelection(it))
-                    onUserDeselected(it)
-                },
-            )
-        }
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun SearchUserBar(
-    query: String,
-    results: ImmutableList<MatrixUser>,
-    selectedUsers: ImmutableList<MatrixUser>,
-    selectedUsersListState: LazyListState,
-    active: Boolean,
-    isMultiSelectionEnabled: Boolean,
-    modifier: Modifier = Modifier,
-    placeHolderTitle: String = stringResource(StringR.string.common_search_for_someone),
-    onActiveChanged: (Boolean) -> Unit = {},
-    onTextChanged: (String) -> Unit = {},
-    onUserSelected: (MatrixUser) -> Unit = {},
-    onUserDeselected: (MatrixUser) -> Unit = {},
-) {
-    val focusManager = LocalFocusManager.current
-
-    if (!active) {
-        onTextChanged("")
-        focusManager.clearFocus()
-    }
-
-    SearchBar(
-        query = query,
-        onQueryChange = onTextChanged,
-        onSearch = { focusManager.clearFocus() },
-        active = active,
-        onActiveChange = onActiveChanged,
-        modifier = modifier
-            .padding(horizontal = if (!active) 16.dp else 0.dp),
-        placeholder = {
-            Text(
-                text = placeHolderTitle,
-                modifier = Modifier.alpha(0.4f), // FIXME align on Design system theme (removing alpha should be fine)
-            )
-        },
-        leadingIcon = if (active) {
-            { BackButton(onClick = { onActiveChanged(false) }) }
-        } else {
-            null
-        },
-        trailingIcon = when {
-            active && query.isNotEmpty() -> {
-                {
-                    IconButton(onClick = { onTextChanged("") }) {
-                        Icon(Icons.Default.Close, stringResource(StringR.string.action_clear))
-                    }
-                }
-            }
-            !active -> {
-                {
-                    Icon(
-                        imageVector = Icons.Default.Search,
-                        contentDescription = stringResource(StringR.string.action_search),
-                        modifier = Modifier.alpha(0.4f), // FIXME align on Design system theme (removing alpha should be fine)
-                    )
-                }
-            }
-            else -> null
-        },
-        colors = if (!active) SearchBarDefaults.colors() else SearchBarDefaults.colors(containerColor = Color.Transparent),
-        content = {
-            if (isMultiSelectionEnabled && active && selectedUsers.isNotEmpty()) {
-                SelectedUsersList(
-                    listState = selectedUsersListState,
-                    contentPadding = PaddingValues(16.dp),
-                    selectedUsers = selectedUsers,
-                    onUserRemoved = onUserDeselected,
-                )
-            }
-
-            LazyColumn {
-                if (isMultiSelectionEnabled) {
-                    items(results) { matrixUser ->
-                        SearchMultipleUsersResultItem(
-                            modifier = Modifier.fillMaxWidth(),
-                            matrixUser = matrixUser,
-                            isUserSelected = selectedUsers.find { it.id == matrixUser.id } != null,
-                            onCheckedChange = { checked ->
-                                if (checked) {
-                                    onUserSelected(matrixUser)
-                                } else {
-                                    onUserDeselected(matrixUser)
-                                }
-                            }
-                        )
-                    }
-                } else {
-                    items(results) { matrixUser ->
-                        SearchSingleUserResultItem(
-                            modifier = Modifier.fillMaxWidth(),
-                            matrixUser = matrixUser,
-                            onClick = { onUserSelected(matrixUser) }
-                        )
-                    }
-                }
-            }
-        },
-    )
-}
-
-@Composable
-fun SearchMultipleUsersResultItem(
-    matrixUser: MatrixUser,
-    isUserSelected: Boolean,
-    modifier: Modifier = Modifier,
-    onCheckedChange: (Boolean) -> Unit,
-) {
-    CheckableMatrixUserRow(
-        checked = isUserSelected,
-        modifier = modifier,
-        matrixUser = matrixUser,
-        avatarSize = AvatarSize.Custom(36.dp),
-        onCheckedChange = onCheckedChange,
-    )
-}
-
-@Composable
-fun SearchSingleUserResultItem(
-    matrixUser: MatrixUser,
-    modifier: Modifier = Modifier,
-    onClick: () -> Unit = {},
-) {
-    MatrixUserRow(
-        modifier = modifier.clickable(onClick = onClick),
-        matrixUser = matrixUser,
-        avatarSize = AvatarSize.Custom(36.dp),
-    )
-}
-
-@Composable
-fun SelectedUsersList(
-    listState: LazyListState,
-    selectedUsers: ImmutableList<MatrixUser>,
-    modifier: Modifier = Modifier,
-    contentPadding: PaddingValues = PaddingValues(0.dp),
-    onUserRemoved: (MatrixUser) -> Unit = {},
-) {
-    LazyRow(
-        state = listState,
-        modifier = modifier,
-        contentPadding = contentPadding,
-        horizontalArrangement = Arrangement.spacedBy(24.dp),
-    ) {
-        items(selectedUsers.toList()) { matrixUser ->
-            SelectedUser(
-                matrixUser = matrixUser,
-                onUserRemoved = onUserRemoved,
-            )
-        }
-    }
-}
-
-@Composable
-fun SelectedUser(
-    matrixUser: MatrixUser,
-    modifier: Modifier = Modifier,
-    onUserRemoved: (MatrixUser) -> Unit,
-) {
-    Box(modifier = modifier.width(56.dp)) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-        ) {
-            Avatar(matrixUser.avatarData.copy(size = AvatarSize.Custom(56.dp)))
-            Text(
-                text = matrixUser.getBestName(),
-                overflow = TextOverflow.Ellipsis,
-                maxLines = 1,
-                style = MaterialTheme.typography.bodyLarge,
-            )
-        }
-        IconButton(
-            modifier = Modifier
-                .clip(CircleShape)
-                .background(MaterialTheme.colorScheme.primary)
-                .size(20.dp)
-                .align(Alignment.TopEnd),
-            onClick = { onUserRemoved(matrixUser) }
-        ) {
-            Icon(
-                imageVector = Icons.Default.Close,
-                contentDescription = stringResource(id = StringR.string.action_remove),
-                tint = MaterialTheme.colorScheme.onPrimary,
-            )
-        }
-    }
-}
-
-@Preview
-@Composable
-internal fun UserListViewLightPreview(@PreviewParameter(UserListStateProvider::class) state: UserListState) =
-    ElementPreviewLight { ContentToPreview(state) }
-
-@Preview
-@Composable
-internal fun UserListViewDarkPreview(@PreviewParameter(UserListStateProvider::class) state: UserListState) =
-    ElementPreviewDark { ContentToPreview(state) }
-
-@Composable
-private fun ContentToPreview(state: UserListState) {
-    UserListView(state = state)
-}

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SearchMultipleUsersResultItem.kt

@@ -0,0 +1,61 @@
+/*
+ * 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.userlist.api.components
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.matrix.ui.components.CheckableMatrixUserRow
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.matrix.ui.model.MatrixUser
+
+@Composable
+fun SearchMultipleUsersResultItem(
+    matrixUser: MatrixUser,
+    isUserSelected: Boolean,
+    modifier: Modifier = Modifier,
+    onCheckedChange: (Boolean) -> Unit = {},
+) {
+    CheckableMatrixUserRow(
+        checked = isUserSelected,
+        modifier = modifier,
+        matrixUser = matrixUser,
+        avatarSize = AvatarSize.Custom(36.dp),
+        onCheckedChange = onCheckedChange,
+    )
+}
+
+@Preview
+@Composable
+internal fun SearchMultipleUsersResultItemLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+internal fun SearchMultipleUsersResultItemDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    Column {
+        SearchMultipleUsersResultItem(matrixUser = aMatrixUser(), isUserSelected = true)
+        SearchMultipleUsersResultItem(matrixUser = aMatrixUser(), isUserSelected = false)
+    }
+}

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SearchSingleUserResultItem.kt

@@ -0,0 +1,55 @@
+/*
+ * 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.userlist.api.components
+
+import androidx.compose.foundation.clickable
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.matrix.ui.components.MatrixUserRow
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.matrix.ui.model.MatrixUser
+
+@Composable
+fun SearchSingleUserResultItem(
+    matrixUser: MatrixUser,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit = {},
+) {
+    MatrixUserRow(
+        modifier = modifier.clickable(onClick = onClick),
+        matrixUser = matrixUser,
+        avatarSize = AvatarSize.Custom(36.dp),
+    )
+}
+
+@Preview
+@Composable
+internal fun SearchSingleUserResultItemLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+internal fun SearchSingleUserResultItemDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    SearchSingleUserResultItem(matrixUser = aMatrixUser())
+}

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SearchUserBar.kt

@@ -0,0 +1,144 @@
+/*
+ * 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.userlist.api.components
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Search
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.SearchBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.IconButton
+import io.element.android.libraries.designsystem.theme.components.SearchBar
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.matrix.ui.model.MatrixUser
+import io.element.android.libraries.ui.strings.R
+import kotlinx.collections.immutable.ImmutableList
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun SearchUserBar(
+    query: String,
+    results: ImmutableList<MatrixUser>,
+    selectedUsers: ImmutableList<MatrixUser>,
+    active: Boolean,
+    isMultiSelectionEnabled: Boolean,
+    modifier: Modifier = Modifier,
+    placeHolderTitle: String = stringResource(R.string.common_search_for_someone),
+    onActiveChanged: (Boolean) -> Unit = {},
+    onTextChanged: (String) -> Unit = {},
+    onUserSelected: (MatrixUser) -> Unit = {},
+    onUserDeselected: (MatrixUser) -> Unit = {},
+) {
+    val focusManager = LocalFocusManager.current
+
+    if (!active) {
+        onTextChanged("")
+        focusManager.clearFocus()
+    }
+
+    SearchBar(
+        query = query,
+        onQueryChange = onTextChanged,
+        onSearch = { focusManager.clearFocus() },
+        active = active,
+        onActiveChange = onActiveChanged,
+        modifier = modifier
+            .padding(horizontal = if (!active) 16.dp else 0.dp),
+        placeholder = {
+            Text(
+                text = placeHolderTitle,
+                modifier = Modifier.alpha(0.4f), // FIXME align on Design system theme (removing alpha should be fine)
+            )
+        },
+        leadingIcon = if (active) {
+            { BackButton(onClick = { onActiveChanged(false) }) }
+        } else {
+            null
+        },
+        trailingIcon = when {
+            active && query.isNotEmpty() -> {
+                {
+                    IconButton(onClick = { onTextChanged("") }) {
+                        Icon(Icons.Default.Close, stringResource(R.string.action_clear))
+                    }
+                }
+            }
+            !active -> {
+                {
+                    Icon(
+                        imageVector = Icons.Default.Search,
+                        contentDescription = stringResource(R.string.action_search),
+                        modifier = Modifier.alpha(0.4f), // FIXME align on Design system theme (removing alpha should be fine)
+                    )
+                }
+            }
+            else -> null
+        },
+        colors = if (!active) SearchBarDefaults.colors() else SearchBarDefaults.colors(containerColor = Color.Transparent),
+        content = {
+            if (isMultiSelectionEnabled && active && selectedUsers.isNotEmpty()) {
+                SelectedUsersList(
+                    contentPadding = PaddingValues(16.dp),
+                    selectedUsers = selectedUsers,
+                    autoScroll = true,
+                    onUserRemoved = onUserDeselected,
+                )
+            }
+
+            LazyColumn {
+                if (isMultiSelectionEnabled) {
+                    items(results) { matrixUser ->
+                        SearchMultipleUsersResultItem(
+                            modifier = Modifier.fillMaxWidth(),
+                            matrixUser = matrixUser,
+                            isUserSelected = selectedUsers.find { it.id == matrixUser.id } != null,
+                            onCheckedChange = { checked ->
+                                if (checked) {
+                                    onUserSelected(matrixUser)
+                                } else {
+                                    onUserDeselected(matrixUser)
+                                }
+                            }
+                        )
+                    }
+                } else {
+                    items(results) { matrixUser ->
+                        SearchSingleUserResultItem(
+                            modifier = Modifier.fillMaxWidth(),
+                            matrixUser = matrixUser,
+                            onClick = { onUserSelected(matrixUser) }
+                        )
+                    }
+                }
+            }
+        },
+    )
+}

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SelectedUser.kt

@@ -0,0 +1,94 @@
+/*
+ * 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.userlist.api.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.components.avatar.Avatar
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.IconButton
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.matrix.ui.model.MatrixUser
+import io.element.android.libraries.matrix.ui.model.getBestName
+import io.element.android.libraries.ui.strings.R
+
+@Composable
+fun SelectedUser(
+    matrixUser: MatrixUser,
+    modifier: Modifier = Modifier,
+    onUserRemoved: (MatrixUser) -> Unit = {},
+) {
+    Box(modifier = modifier.width(56.dp)) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Avatar(matrixUser.avatarData.copy(size = AvatarSize.Custom(56.dp)))
+            Text(
+                text = matrixUser.getBestName(),
+                overflow = TextOverflow.Ellipsis,
+                maxLines = 1,
+                style = MaterialTheme.typography.bodyLarge,
+            )
+        }
+        IconButton(
+            modifier = Modifier
+                .clip(CircleShape)
+                .background(MaterialTheme.colorScheme.primary)
+                .size(20.dp)
+                .align(Alignment.TopEnd),
+            onClick = { onUserRemoved(matrixUser) }
+        ) {
+            Icon(
+                imageVector = Icons.Default.Close,
+                contentDescription = stringResource(id = R.string.action_remove),
+                tint = MaterialTheme.colorScheme.onPrimary,
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun SelectedUserLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+internal fun SelectedUserDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    SelectedUser(aMatrixUser())
+}

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SelectedUsersList.kt

@@ -0,0 +1,87 @@
+/*
+ * 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.userlist.api.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import io.element.android.features.userlist.api.aListOfSelectedUsers
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.matrix.ui.model.MatrixUser
+import kotlinx.collections.immutable.ImmutableList
+
+@Composable
+fun SelectedUsersList(
+    selectedUsers: ImmutableList<MatrixUser>,
+    modifier: Modifier = Modifier,
+    autoScroll: Boolean = false,
+    contentPadding: PaddingValues = PaddingValues(0.dp),
+    onUserRemoved: (MatrixUser) -> Unit = {},
+) {
+    val lazyListState = rememberLazyListState()
+    if (autoScroll) {
+        var currentSize by rememberSaveable { mutableStateOf(selectedUsers.size) }
+        LaunchedEffect(selectedUsers.size) {
+            val isItemAdded = selectedUsers.size > currentSize
+            if (isItemAdded) {
+                lazyListState.animateScrollToItem(selectedUsers.lastIndex)
+            }
+            currentSize = selectedUsers.size
+        }
+    }
+
+    LazyRow(
+        state = lazyListState,
+        modifier = modifier,
+        contentPadding = contentPadding,
+        horizontalArrangement = Arrangement.spacedBy(24.dp),
+    ) {
+        items(selectedUsers.toList()) { matrixUser ->
+            SelectedUser(
+                matrixUser = matrixUser,
+                onUserRemoved = onUserRemoved,
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun SelectedUsersListLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+internal fun SelectedUsersListDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    SelectedUsersList(
+        selectedUsers = aListOfSelectedUsers(),
+    )
+}

features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/UserListView.kt

@@ -0,0 +1,90 @@
+/*
+ * 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.userlist.api.components
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+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.userlist.api.UserListEvents
+import io.element.android.features.userlist.api.UserListState
+import io.element.android.features.userlist.api.UserListStateProvider
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.matrix.ui.model.MatrixUser
+
+@Composable
+fun UserListView(
+    state: UserListState,
+    modifier: Modifier = Modifier,
+    onUserSelected: (MatrixUser) -> Unit = {},
+    onUserDeselected: (MatrixUser) -> Unit = {},
+) {
+    Column(
+        modifier = modifier,
+    ) {
+        SearchUserBar(
+            modifier = Modifier.fillMaxWidth(),
+            query = state.searchQuery,
+            results = state.searchResults,
+            selectedUsers = state.selectedUsers,
+            active = state.isSearchActive,
+            isMultiSelectionEnabled = state.isMultiSelectionEnabled,
+            onActiveChanged = { state.eventSink(UserListEvents.OnSearchActiveChanged(it)) },
+            onTextChanged = { state.eventSink(UserListEvents.UpdateSearchQuery(it)) },
+            onUserSelected = {
+                state.eventSink(UserListEvents.AddToSelection(it))
+                onUserSelected(it)
+            },
+            onUserDeselected = {
+                state.eventSink(UserListEvents.RemoveFromSelection(it))
+                onUserDeselected(it)
+            },
+        )
+
+        if (state.isMultiSelectionEnabled && !state.isSearchActive && state.selectedUsers.isNotEmpty()) {
+            SelectedUsersList(
+                contentPadding = PaddingValues(16.dp),
+                selectedUsers = state.selectedUsers,
+                autoScroll = true,
+                onUserRemoved = {
+                    state.eventSink(UserListEvents.RemoveFromSelection(it))
+                    onUserDeselected(it)
+                },
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun UserListViewLightPreview(@PreviewParameter(UserListStateProvider::class) state: UserListState) =
+    ElementPreviewLight { ContentToPreview(state) }
+
+@Preview
+@Composable
+internal fun UserListViewDarkPreview(@PreviewParameter(UserListStateProvider::class) state: UserListState) =
+    ElementPreviewDark { ContentToPreview(state) }
+
+@Composable
+private fun ContentToPreview(state: UserListState) {
+    UserListView(state = state)
+}

features/userlist/impl/src/main/kotlin/io/element/android/features/userlist/impl/DefaultUserListPresenter.kt

@@ -16,26 +16,25 @@
 
 package io.element.android.features.userlist.impl
 
-import androidx.compose.foundation.lazy.LazyListState
-import androidx.compose.foundation.lazy.rememberLazyListState
 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.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import com.squareup.anvil.annotations.ContributesBinding
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
+import io.element.android.features.userlist.api.UserListDataStore
 import io.element.android.features.userlist.api.UserListEvents
+import io.element.android.features.userlist.api.UserListPresenter
 import io.element.android.features.userlist.api.UserListPresenterArgs
 import io.element.android.features.userlist.api.UserListState
-import io.element.android.features.userlist.api.UserListPresenter
 import io.element.android.libraries.di.SessionScope
 import io.element.android.libraries.matrix.api.core.MatrixPatterns
 import io.element.android.libraries.matrix.api.core.UserId
@@ -43,28 +42,27 @@ import io.element.android.libraries.matrix.ui.model.MatrixUser
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toImmutableList
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
 
 class DefaultUserListPresenter @AssistedInject constructor(
     @Assisted val args: UserListPresenterArgs,
-    @Assisted val matrixUserDataSource: MatrixUserDataSource,
+    @Assisted val userListDataSource: UserListDataSource,
+    @Assisted val userListDataStore: UserListDataStore,
 ) : UserListPresenter {
 
     @AssistedFactory
     @ContributesBinding(SessionScope::class)
     interface DefaultUserListFactory : UserListPresenter.Factory {
-        override fun create(args: UserListPresenterArgs, matrixUserDataSource: MatrixUserDataSource): DefaultUserListPresenter
+        override fun create(
+            args: UserListPresenterArgs,
+            userListDataSource: UserListDataSource,
+            userListDataStore: UserListDataStore,
+        ): DefaultUserListPresenter
     }
 
     @Composable
     override fun present(): UserListState {
-        val localCoroutineScope = rememberCoroutineScope()
         var isSearchActive by rememberSaveable { mutableStateOf(false) }
-        val selectedUsers: MutableState<ImmutableList<MatrixUser>> = remember {
+        val selectedUsers = userListDataStore.selectedUsers().collectAsState(emptyList())
-            mutableStateOf(persistentListOf())
-        }
-        val selectedUsersListState = rememberLazyListState()
         var searchQuery by rememberSaveable { mutableStateOf("") }
         val searchResults: MutableState<ImmutableList<MatrixUser>> = remember {
             mutableStateOf(persistentListOf())
@@ -74,13 +72,8 @@ class DefaultUserListPresenter @AssistedInject constructor(
             when (event) {
                 is UserListEvents.OnSearchActiveChanged -> isSearchActive = event.active
                 is UserListEvents.UpdateSearchQuery -> searchQuery = event.query
-                is UserListEvents.AddToSelection -> {
+                is UserListEvents.AddToSelection -> userListDataStore.selectUser(event.matrixUser)
-                    if (event.matrixUser !in selectedUsers.value) {
+                is UserListEvents.RemoveFromSelection -> userListDataStore.removeUserFromSelection(event.matrixUser)
-                        selectedUsers.value = selectedUsers.value.plus(event.matrixUser).toImmutableList()
-                    }
-                    localCoroutineScope.scrollToFirstSelectedUser(selectedUsersListState)
-                }
-                is UserListEvents.RemoveFromSelection -> selectedUsers.value = selectedUsers.value.minus(event.matrixUser).toImmutableList()
             }
         }
 
@@ -100,8 +93,7 @@ class DefaultUserListPresenter @AssistedInject constructor(
         return UserListState(
             searchQuery = searchQuery,
             searchResults = searchResults.value,
-            selectedUsers = selectedUsers.value.reversed().toImmutableList(),
+            selectedUsers = selectedUsers.value.toImmutableList(),
-            selectedUsersListState = selectedUsersListState,
             isSearchActive = isSearchActive,
             selectionMode = args.selectionMode,
             eventSink = ::handleEvents,
@@ -110,16 +102,12 @@ class DefaultUserListPresenter @AssistedInject constructor(
 
     private suspend fun performSearch(query: String): ImmutableList<MatrixUser> {
         val isMatrixId = MatrixPatterns.isUserId(query)
-        val results = matrixUserDataSource.search(query).toMutableList()
+        val results = userListDataSource.search(query).toMutableList()
         if (isMatrixId && results.none { it.id.value == query }) {
-            val getProfileResult: MatrixUser? = matrixUserDataSource.getProfile(UserId(query))
+            val getProfileResult: MatrixUser? = userListDataSource.getProfile(UserId(query))
             val profile = getProfileResult ?: MatrixUser(UserId(query))
             results.add(0, profile)
         }
         return results.toImmutableList()
     }
-
-    private fun CoroutineScope.scrollToFirstSelectedUser(listState: LazyListState) = launch {
-        listState.scrollToItem(index = 0)
-    }
 }

features/userlist/impl/src/test/kotlin/io/element/android/features/userlist/impl/DefaultUserListPresenterTests.kt

@@ -21,10 +21,11 @@ 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.userlist.api.SelectionMode
+import io.element.android.features.userlist.api.UserListDataStore
 import io.element.android.features.userlist.api.UserListEvents
 import io.element.android.features.userlist.api.UserListPresenterArgs
-import io.element.android.features.userlist.api.SelectionMode
+import io.element.android.features.userlist.test.FakeUserListDataSource
-import io.element.android.features.userlist.test.FakeMatrixUserDataSource
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.ui.components.aMatrixUser
 import io.element.android.libraries.matrix.ui.model.MatrixUser
@@ -37,13 +38,14 @@ import org.junit.Test
 @OptIn(ExperimentalCoroutinesApi::class)
 class DefaultUserListPresenterTests {
 
-    private val userListDataSource = FakeMatrixUserDataSource()
+    private val userListDataSource = FakeUserListDataSource()
 
     @Test
     fun `present - initial state for single selection`() = runTest {
         val presenter = DefaultUserListPresenter(
             UserListPresenterArgs(selectionMode = SelectionMode.Single),
-            userListDataSource
+            userListDataSource,
+            UserListDataStore(),
         )
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()
@@ -61,7 +63,8 @@ class DefaultUserListPresenterTests {
     fun `present - initial state for multiple selection`() = runTest {
         val presenter = DefaultUserListPresenter(
             UserListPresenterArgs(selectionMode = SelectionMode.Multiple),
-            userListDataSource
+            userListDataSource,
+            UserListDataStore(),
         )
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()
@@ -79,7 +82,8 @@ class DefaultUserListPresenterTests {
     fun `present - update search query`() = runTest {
         val presenter = DefaultUserListPresenter(
             UserListPresenterArgs(selectionMode = SelectionMode.Single),
-            userListDataSource
+            userListDataSource,
+            UserListDataStore(),
         )
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()
@@ -111,7 +115,8 @@ class DefaultUserListPresenterTests {
 
         val presenter = DefaultUserListPresenter(
             UserListPresenterArgs(selectionMode = SelectionMode.Single),
-            userListDataSource
+            userListDataSource,
+            UserListDataStore(),
         )
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()

features/userlist/test/src/main/kotlin/io/element/android/features/userlist/test/FakeUserListDataSource.kt

@@ -16,11 +16,11 @@
 
 package io.element.android.features.userlist.test
 
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.ui.model.MatrixUser
 
-class FakeMatrixUserDataSource : MatrixUserDataSource {
+class FakeUserListDataSource : UserListDataSource {
 
     private var searchResult: List<MatrixUser> = emptyList()
     private var profile: MatrixUser? = null

features/userlist/test/src/main/kotlin/io/element/android/features/userlist/test/FakeUserListPresenterFactory.kt

@@ -16,7 +16,8 @@
 
 package io.element.android.features.userlist.test
 
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import io.element.android.features.userlist.api.UserListDataSource
+import io.element.android.features.userlist.api.UserListDataStore
 import io.element.android.features.userlist.api.UserListPresenter
 import io.element.android.features.userlist.api.UserListPresenterArgs
 
@@ -24,5 +25,9 @@ class FakeUserListPresenterFactory(
     private val fakeUserListPresenter: FakeUserListPresenter = FakeUserListPresenter()
 ) : UserListPresenter.Factory {
 
-    override fun create(args: UserListPresenterArgs, matrixUserDataSource: MatrixUserDataSource): UserListPresenter = fakeUserListPresenter
+    override fun create(
+        args: UserListPresenterArgs,
+        userListDataSource: UserListDataSource,
+        userListDataStore: UserListDataStore,
+    ): UserListPresenter = fakeUserListPresenter
 }

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/components/avatar/AvatarDataProvider.kt

@@ -27,8 +27,8 @@ open class AvatarDataProvider : PreviewParameterProvider<AvatarData> {
         )
 }
 
-fun anAvatarData() = AvatarData(
+fun anAvatarData(id: String = "@id_of_alice:server.org", name: String = "Alice") = AvatarData(
     // Let's the id not start with a 'a'.
-    id = "@id_of_alice:server.org",
+    id = id,
-    name = "Alice",
+    name = name,
 )

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/MatrixClient.kt

@@ -19,6 +19,7 @@ package io.element.android.libraries.matrix.api
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.api.createroom.CreateRoomParameters
 import io.element.android.libraries.matrix.api.media.MediaResolver
 import io.element.android.libraries.matrix.api.notification.NotificationService
 import io.element.android.libraries.matrix.api.pusher.PushersService
@@ -32,8 +33,9 @@ interface MatrixClient : Closeable {
     val sessionId: SessionId
     val roomSummaryDataSource: RoomSummaryDataSource
     fun getRoom(roomId: RoomId): MatrixRoom?
-    suspend fun createDM(userId: UserId): Result<RoomId>
     fun findDM(userId: UserId): MatrixRoom?
+    suspend fun createRoom(createRoomParams: CreateRoomParameters): Result<RoomId>
+    suspend fun createDM(userId: UserId): Result<RoomId>
     fun startSync()
     fun stopSync()
     fun mediaResolver(): MediaResolver

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/createroom/CreateRoomParameters.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.libraries.matrix.api.createroom
+
+import io.element.android.libraries.matrix.api.core.UserId
+
+data class CreateRoomParameters(
+    val name: String?,
+    val topic: String? = null,
+    val isEncrypted: Boolean,
+    val isDirect: Boolean = false,
+    val visibility: RoomVisibility,
+    val preset: RoomPreset,
+    val invite: List<UserId>? = null,
+    val avatar: String? = null,
+)

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/createroom/RoomPreset.kt

@@ -13,12 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+package io.element.android.libraries.matrix.api.createroom
 
-package io.element.android.features.createroom.impl.addpeople
+enum class RoomPreset {
-
+    PRIVATE_CHAT,
-import io.element.android.features.userlist.api.UserListState
+    PUBLIC_CHAT,
-
+    TRUSTED_PRIVATE_CHAT,
-data class AddPeopleState(
+}
-    val userListState: UserListState,
-    val eventSink: (AddPeopleEvents) -> Unit,
-)

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/createroom/RoomVisibility.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.libraries.matrix.api.createroom
+
+enum class RoomVisibility {
+    PUBLIC,
+    PRIVATE,
+}

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt

@@ -20,6 +20,9 @@ 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.core.UserId
+import io.element.android.libraries.matrix.api.createroom.CreateRoomParameters
+import io.element.android.libraries.matrix.api.createroom.RoomPreset
+import io.element.android.libraries.matrix.api.createroom.RoomVisibility
 import io.element.android.libraries.matrix.api.media.MediaResolver
 import io.element.android.libraries.matrix.api.notification.NotificationService
 import io.element.android.libraries.matrix.api.pusher.PushersService
@@ -42,10 +45,7 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.Client
 import org.matrix.rustcomponents.sdk.ClientDelegate
-import org.matrix.rustcomponents.sdk.CreateRoomParameters
 import org.matrix.rustcomponents.sdk.RequiredState
-import org.matrix.rustcomponents.sdk.RoomPreset
-import org.matrix.rustcomponents.sdk.RoomVisibility
 import org.matrix.rustcomponents.sdk.SlidingSyncListBuilder
 import org.matrix.rustcomponents.sdk.SlidingSyncMode
 import org.matrix.rustcomponents.sdk.SlidingSyncRequestListFilters
@@ -55,6 +55,9 @@ import org.matrix.rustcomponents.sdk.use
 import timber.log.Timber
 import java.io.File
 import java.util.concurrent.atomic.AtomicBoolean
+import org.matrix.rustcomponents.sdk.CreateRoomParameters as RustCreateRoomParameters
+import org.matrix.rustcomponents.sdk.RoomPreset as RustRoomPreset
+import org.matrix.rustcomponents.sdk.RoomVisibility as RustRoomVisibility
 
 class RustMatrixClient constructor(
     private val client: Client,
@@ -175,24 +178,46 @@ class RustMatrixClient constructor(
         return roomId?.let { getRoom(it) }
     }
 
-    override suspend fun createDM(userId: UserId): Result<RoomId> =
+    override suspend fun createRoom(createRoomParams: CreateRoomParameters): Result<RoomId> = withContext(dispatchers.io) {
-        withContext(dispatchers.io) {
+        runCatching {
-            runCatching {
+            val roomId = client.createRoom(
-                val roomId = client.createRoom(
+                RustCreateRoomParameters(
-                    CreateRoomParameters(
+                    name = createRoomParams.name,
-                        name = null,
+                    topic = createRoomParams.topic,
-                        topic = null,
+                    isEncrypted = createRoomParams.isEncrypted,
-                        isEncrypted = true,
+                    isDirect = createRoomParams.isDirect,
-                        isDirect = true,
+                    visibility = when (createRoomParams.visibility) {
-                        visibility = RoomVisibility.PRIVATE,
+                        RoomVisibility.PUBLIC -> RustRoomVisibility.PUBLIC
-                        preset = RoomPreset.TRUSTED_PRIVATE_CHAT,
+                        RoomVisibility.PRIVATE -> RustRoomVisibility.PRIVATE
-                        invite = listOf(userId.value),
+                    },
-                        avatar = null,
+                    preset = when (createRoomParams.preset) {
-                    )
+                        RoomPreset.PRIVATE_CHAT -> RustRoomPreset.PRIVATE_CHAT
+                        RoomPreset.PUBLIC_CHAT -> RustRoomPreset.PUBLIC_CHAT
+                        RoomPreset.TRUSTED_PRIVATE_CHAT -> RustRoomPreset.TRUSTED_PRIVATE_CHAT
+                    },
+                    invite = createRoomParams.invite?.map { it.value },
+                    avatar = createRoomParams.avatar,
                 )
-                RoomId(roomId)
+            )
-            }
+            RoomId(roomId)
         }
+    }
+
+    override suspend fun createDM(userId: UserId): Result<RoomId> = withContext(dispatchers.io) {
+        runCatching {
+            val roomId = client.createRoom(
+                RustCreateRoomParameters(
+                    name = null,
+                    isEncrypted = true,
+                    isDirect = true,
+                    visibility = RustRoomVisibility.PRIVATE,
+                    preset = RustRoomPreset.TRUSTED_PRIVATE_CHAT,
+                    invite = listOf(userId.value),
+                )
+            )
+            RoomId(roomId)
+        }
+    }
 
     override fun mediaResolver(): MediaResolver = mediaResolver
 

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/FakeMatrixClient.kt

@@ -20,6 +20,7 @@ import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.api.createroom.CreateRoomParameters
 import io.element.android.libraries.matrix.api.media.MediaResolver
 import io.element.android.libraries.matrix.api.notification.NotificationService
 import io.element.android.libraries.matrix.api.pusher.PushersService
@@ -54,16 +55,21 @@ class FakeMatrixClient(
         return FakeMatrixRoom(roomId)
     }
 
+    override fun findDM(userId: UserId): MatrixRoom? {
+        return findDmResult
+    }
+
+    override suspend fun createRoom(createRoomParams: CreateRoomParameters): Result<RoomId> {
+        delay(100)
+        return Result.success(A_ROOM_ID)
+    }
+
     override suspend fun createDM(userId: UserId): Result<RoomId> {
         delay(100)
         createDmFailure?.let { throw it }
         return createDmResult
     }
 
-    override fun findDM(userId: UserId): MatrixRoom? {
-        return findDmResult
-    }
-
     override fun startSync() = Unit
 
     override fun stopSync() = Unit

libraries/matrixui/src/main/kotlin/io/element/android/libraries/matrix/ui/components/MatrixUserProvider.kt

@@ -35,7 +35,7 @@ open class MatrixUserProvider : PreviewParameterProvider<MatrixUser> {
 fun aMatrixUser(id: String = "@id_of_alice:server.org", userName: String = "Alice") = MatrixUser(
     id = UserId(id),
     username = userName,
-    avatarData = anAvatarData()
+    avatarData = anAvatarData(id, userName)
 )
 
 fun aMatrixUserList() = listOf(

tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.createroom.impl.addpeople_null_DefaultGroup_AddPeopleViewDarkPreview_0_null_1,NEXUS_5,1.0,en].png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:489aa166bf6d0f283da497b2752e457f81620959d404b5b9c3d96c7e18e8b953
+oid sha256:b96cf938377ee0f02e0cf2d5896eb83935d9416a5b87849ed81caed4db5e90f2
-size 28100
+size 41264

tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.createroom.impl.addpeople_null_DefaultGroup_AddPeopleViewDarkPreview_0_null_2,NEXUS_5,1.0,en].png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0a8969c9a82f41bbdbdfb013412d039f3be4fcf450a0dd55f3217c64d51c8489
+oid sha256:56148beb26b35c8309190271b43fc225e11b90b8b849a8e60abf98b6ab663c1b
-size 23495
+size 101010

tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.createroom.impl.addpeople_null_DefaultGroup_AddPeopleViewLightPreview_0_null_1,NEXUS_5,1.0,en].png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d5f29443193cd21eeb721a4c86f9063466439dd5ad4830708e6fa587f95e5abd
+oid sha256:92fe30f0927b8be4ffc384548e6731e7d5e347dc5caa1c84251f2a932ee1873c
-size 27456
+size 38848

tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.createroom.impl.addpeople_null_DefaultGroup_AddPeopleViewLightPreview_0_null_2,NEXUS_5,1.0,en].png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fa79c54d2431dc0c8399a2bcb8e03d73749e9d54f505ac893e2376fded0e7dfe
+oid sha256:9fa60afaf7ab23f66622d7d77e168db8b9d8bc15d178e8adb63f944de3cc29df
-size 22599
+size 96242

tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.createroom.impl.configureroom_null_DefaultGroup_ConfigureRoomViewDarkPreview_0_null_0,NEXUS_5,1.0,en].png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2327de2be62afdacae32b297347fbcd23cd5e6986f513d018068aa981ecc3941
+oid sha256:756d835de7820c96019995ab47d34c2663330c4ddc9ca124eac266ea9eeef0ab
-size 89757
+size 64397

tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.createroom.impl.configureroom_null_DefaultGroup_ConfigureRoomViewDarkPreview_0_null_1,NEXUS_5,1.0,en].png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df7631ad85dc6b3fbdabfc820b11b4e12a6128202e3faa2d105ba22793fe8c22
+size 103428

tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.createroom.impl.configureroom_null_DefaultGroup_ConfigureRoomViewLightPreview_0_null_0,NEXUS_5,1.0,en].png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:50129ad0c4d75ff5e7b8ffd43b0ffdc40d77a78f5699f9b7194a9c9ef026af69
+oid sha256:a03aa11c787804adc5b2947359421b90e6abcdc7e840983a0276a6e02da59a2f
-size 82189
+size 58526

tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.createroom.impl.configureroom_null_DefaultGroup_ConfigureRoomViewLightPreview_0_null_1,NEXUS_5,1.0,en].png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c2731ea21ca5b001aadc29ecbb15a2b263b0c042b7344cb10149174ff88ec0a
+size 96835