Merge branch 'develop' into feature/fga/clean_up

2023-04-14 17:15:40 +02:00 · 2023-04-14 17:15:40 +02:00 · 7e25371bf2
commit 7e25371bf2
parent a166636060 219ac6578f
252 changed files with 5060 additions and 1618 deletions
--- a/features/createroom/impl/build.gradle.kts
+++ b/features/createroom/impl/build.gradle.kts
@ -49,12 +49,14 @@ dependencies {
    implementation(projects.libraries.uiStrings)
    implementation(projects.features.userlist.api)
    api(projects.features.createroom.api)
+    implementation(libs.coil.compose) // FIXME temp

    testImplementation(libs.test.junit)
    testImplementation(libs.coroutines.test)
    testImplementation(libs.molecule.runtime)
    testImplementation(libs.test.truth)
    testImplementation(libs.test.turbine)
+    testImplementation(libs.test.robolectric)
    testImplementation(projects.libraries.matrix.test)
    testImplementation(projects.features.userlist.impl)
    testImplementation(projects.features.userlist.test)
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/AllMatrixUsersDataSource.kt
+++ b/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()
    }
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/ConfigureRoomFlowNode.kt
+++ b/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()
+        )
+    }
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/CreateRoomConfig.kt
+++ b/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,
+)
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/CreateRoomDataStore.kt
+++ b/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))
+    }
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/CreateRoomFlowNode.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/CreateRoomFlowNode.kt
@ -30,7 +30,6 @@ 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.root.CreateRoomRootNode
 import io.element.android.libraries.architecture.BackstackNode
 import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
@ -72,9 +71,11 @@ class CreateRoomFlowNode @AssistedInject constructor(
                        plugins<CreateRoomEntryPoint.Callback>().forEach { it.onOpenRoom(roomId) }
                    }
                }
-                createNode<CreateRoomRootNode>(buildContext, plugins = listOf(callback))
+                createNode<CreateRoomRootNode>(context = buildContext, plugins = listOf(callback))
+            }
+            NavTarget.NewRoom -> {
+                createNode<ConfigureRoomFlowNode>(context = buildContext, plugins = emptyList())
            }
-            NavTarget.NewRoom -> createNode<AddPeopleNode>(buildContext)
        }
    }

--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleNode.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleNode.kt
@ -21,26 +21,35 @@ import androidx.compose.ui.Modifier
 import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.plugin.Plugin
+import 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

-@ContributesNode(SessionScope::class)
+@ContributesNode(CreateRoomScope::class)
 class AddPeopleNode @AssistedInject constructor(
    @Assisted buildContext: BuildContext,
    @Assisted plugins: List<Plugin>,
    private val presenter: AddPeoplePresenter,
 ) : Node(buildContext, plugins = plugins) {

+    interface Callback : Plugin {
+        fun onContinue()
+    }
+
+    private fun onContinue() {
+        plugins<Callback>().forEach { it.onContinue() }
+    }
+
    @Composable
    override fun View(modifier: Modifier) {
        val state = presenter.present()
        AddPeopleView(
            state = state,
            modifier = modifier,
-            onBackPressed = { navigateUp() },
-            onNextPressed = { },
+            onBackPressed = this::navigateUp,
+            onNextPressed = this::onContinue,
        )
    }
 }
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeoplePresenter.kt
+++ b/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,
-) : Presenter<AddPeopleState> {
+    @Named("AllUsers") private val userListDataSource: UserListDataSource,
+    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 {
-        val userListState = userListPresenter.present()
-
-        fun handleEvents(event: AddPeopleEvents) {
-            // do nothing for now
-        }
-
-        return AddPeopleState(
-            userListState = userListState,
-            eventSink = ::handleEvents,
-        )
+    override fun present(): UserListState {
+        return userListPresenter.present()
    }
 }

--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleUserListStateProvider.kt
+++ b/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> {
-    override val values: Sequence<AddPeopleState>
+open class AddPeopleUserListStateProvider : PreviewParameterProvider<UserListState> {
+    override val values: Sequence<UserListState>
        get() = sequenceOf(
-            aAddPeopleState(),
-            aAddPeopleState().copy(
-                userListState = aUserListState().copy(
-                    selectedUsers = aListOfSelectedUsers(),
-                    selectionMode = SelectionMode.Multiple,
-                )
+            aUserListState(),
+            aUserListState().copy(
+                searchResults = aMatrixUserList().toImmutableList(),
+                selectedUsers = aListOfSelectedUsers(),
+                isSearchActive = false,
+                selectionMode = SelectionMode.Multiple,
            ),
-            aAddPeopleState().copy(
-                userListState = aUserListState().copy(
-                    selectedUsers = aListOfSelectedUsers(),
-                    isSearchActive = true,
-                    selectionMode = SelectionMode.Multiple,
-                )
+            aUserListState().copy(
+                searchResults = aMatrixUserList().toImmutableList(),
+                selectedUsers = aListOfSelectedUsers(),
+                isSearchActive = true,
+                selectionMode = SelectionMode.Multiple,
            )
        )
 }
-
-fun aAddPeopleState() = AddPeopleState(
-    userListState = aUserListState(),
-    eventSink = {}
-)
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleView.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleView.kt
@ -29,8 +29,9 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import io.element.android.features.userlist.api.UserListView
 import io.element.android.features.createroom.impl.R
+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
@ -43,18 +44,16 @@ 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: () -> 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,
                )
@ -68,7 +67,7 @@ fun AddPeopleView(
        ) {
            UserListView(
                modifier = Modifier.fillMaxWidth(),
-                state = state.userListState,
+                state = state,
            )
        }
    }
@ -109,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)
 }
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/components/Avatar.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/components/Avatar.kt
@ -0,0 +1,97 @@
+/*
+ * 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.components
+
+import android.net.Uri
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.AddAPhoto
+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.graphics.painter.ColorPainter
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import coil.compose.AsyncImage
+import coil.request.ImageRequest
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.preview.debugPlaceholderBackground
+import io.element.android.libraries.designsystem.theme.LocalColors
+import io.element.android.libraries.designsystem.theme.components.Icon
+
+@Composable
+fun Avatar(
+    avatarUri: Uri?,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit = {},
+) {
+    val commonModifier = modifier
+        .size(70.dp)
+        .clip(CircleShape)
+        .clickable(onClick = onClick)
+
+    if (avatarUri != null) {
+        val context = LocalContext.current
+        val model = ImageRequest.Builder(context)
+            .data(avatarUri)
+            .build()
+        AsyncImage(
+            modifier = commonModifier,
+            model = model,
+            placeholder = debugPlaceholderBackground(ColorPainter(MaterialTheme.colorScheme.surfaceVariant)),
+            contentScale = ContentScale.Crop,
+            contentDescription = null,
+        )
+    } else {
+        Box(modifier = commonModifier.background(LocalColors.current.quinary)) {
+            Icon(
+                imageVector = Icons.Outlined.AddAPhoto,
+                contentDescription = "",
+                modifier = Modifier
+                    .align(Alignment.Center)
+                    .size(40.dp),
+                tint = MaterialTheme.colorScheme.secondary,
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+fun AvatarLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+fun AvatarDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    Row {
+        Avatar(null)
+        Avatar(Uri.EMPTY)
+    }
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/components/LabelledTextField.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/components/LabelledTextField.kt
@ -0,0 +1,84 @@
+/*
+ * 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.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import io.element.android.features.createroom.impl.R
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.designsystem.theme.components.TextField
+
+@Composable
+fun LabelledTextField(
+    label: String,
+    value: String,
+    modifier: Modifier = Modifier,
+    placeholder: String = "",
+    maxLines: Int = 1,
+    onValueChange: (String) -> Unit = {},
+) {
+    Column(
+        modifier = modifier,
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        Text(
+            modifier = Modifier.padding(horizontal = 16.dp),
+            text = label
+        )
+
+        TextField(
+            modifier = Modifier.fillMaxWidth(),
+            value = value,
+            placeholder = { Text(placeholder) },
+            onValueChange = onValueChange,
+            maxLines = maxLines,
+        )
+    }
+}
+
+@Preview
+@Composable
+fun LabelledTextFieldLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+fun LabelledTextFieldDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    Column {
+        LabelledTextField(
+            label = stringResource(R.string.screen_create_room_room_name_label),
+            value = "",
+            placeholder = stringResource(R.string.screen_create_room_room_name_placeholder),
+        )
+        LabelledTextField(
+            label = stringResource(R.string.screen_create_room_room_name_label),
+            value = "a room name",
+            placeholder = stringResource(R.string.screen_create_room_room_name_placeholder),
+        )
+    }
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/components/RoomPrivacyOption.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/components/RoomPrivacyOption.kt
@ -0,0 +1,116 @@
+/*
+ * 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.components
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import io.element.android.features.createroom.impl.configureroom.RoomPrivacyItem
+import io.element.android.features.createroom.impl.configureroom.roomPrivacyItems
+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.RadioButton
+import io.element.android.libraries.designsystem.theme.components.Text
+
+@Composable
+fun RoomPrivacyOption(
+    roomPrivacyItem: RoomPrivacyItem,
+    modifier: Modifier = Modifier,
+    isSelected: Boolean = false,
+    onOptionSelected: (RoomPrivacyItem) -> Unit = {},
+) {
+    Row(
+        modifier
+            .fillMaxWidth()
+            .selectable(
+                selected = isSelected,
+                onClick = { onOptionSelected(roomPrivacyItem) },
+                role = Role.RadioButton,
+            )
+            .padding(8.dp),
+    ) {
+        Icon(
+            modifier = Modifier.padding(horizontal = 8.dp),
+            imageVector = roomPrivacyItem.icon,
+            contentDescription = "",
+            tint = MaterialTheme.colorScheme.secondary,
+        )
+
+        Column(
+            Modifier
+                .weight(1f)
+                .padding(horizontal = 8.dp)
+        ) {
+            Text(
+                text = roomPrivacyItem.title,
+                fontSize = 16.sp,
+                color = MaterialTheme.colorScheme.primary,
+            )
+            Spacer(Modifier.size(3.dp))
+            Text(
+                text = roomPrivacyItem.description,
+                fontSize = 12.sp,
+                lineHeight = 17.sp,
+                color = MaterialTheme.colorScheme.tertiary,
+            )
+        }
+
+        RadioButton(
+            modifier = Modifier
+                .align(Alignment.CenterVertically)
+                .size(48.dp),
+            selected = isSelected,
+            onClick = null // null recommended for accessibility with screenreaders
+        )
+    }
+}
+
+@Preview
+@Composable
+fun RoomPrivacyOptionLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+fun RoomPrivacyOptionDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    val aRoomPrivacyItem = roomPrivacyItems().first()
+    Column {
+        RoomPrivacyOption(
+            roomPrivacyItem = aRoomPrivacyItem,
+            isSelected = true,
+        )
+        RoomPrivacyOption(
+            roomPrivacyItem = aRoomPrivacyItem,
+            isSelected = false,
+        )
+    }
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomEvents.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomEvents.kt
@ -0,0 +1,29 @@
+/*
+ * 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.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
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomNode.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomNode.kt
@ -0,0 +1,45 @@
+/*
+ * 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.configureroom
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.createroom.impl.di.CreateRoomScope
+
+@ContributesNode(CreateRoomScope::class)
+class ConfigureRoomNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: ConfigureRoomPresenter,
+) : Node(buildContext, plugins = plugins) {
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        ConfigureRoomView(
+            state = state,
+            modifier = modifier,
+            onBackPressed = { navigateUp() } // TODO we should keep in memory the current view state
+        )
+    }
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenter.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenter.kt
@ -0,0 +1,59 @@
+/*
+ * 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.configureroom
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import io.element.android.features.createroom.impl.CreateRoomConfig
+import io.element.android.features.createroom.impl.CreateRoomDataStore
+import io.element.android.libraries.architecture.Presenter
+import javax.inject.Inject
+
+class ConfigureRoomPresenter @Inject constructor(
+    private val dataStore: CreateRoomDataStore,
+) : Presenter<ConfigureRoomState> {
+
+    @Composable
+    override fun present(): ConfigureRoomState {
+        val createRoomConfig = dataStore.getCreateRoomConfig().collectAsState(CreateRoomConfig())
+        val isCreateButtonEnabled by remember(createRoomConfig.value.roomName, createRoomConfig.value.privacy) {
+            derivedStateOf {
+                createRoomConfig.value.roomName.isNullOrEmpty().not() && createRoomConfig.value.privacy != null
+            }
+        }
+
+        fun handleEvents(event: ConfigureRoomEvents) {
+            when (event) {
+                is ConfigureRoomEvents.AvatarUriChanged -> dataStore.setAvatarUrl(event.uri?.toString())
+                is ConfigureRoomEvents.RoomNameChanged -> dataStore.setRoomName(event.name)
+                is ConfigureRoomEvents.TopicChanged -> dataStore.setTopic(event.topic)
+                is ConfigureRoomEvents.RoomPrivacyChanged -> dataStore.setPrivacy(event.privacy)
+                is ConfigureRoomEvents.RemoveFromSelection -> dataStore.selectedUserListDataStore.removeUserFromSelection(event.matrixUser)
+                ConfigureRoomEvents.CreateRoom -> Unit // TODO
+            }
+        }
+
+        return ConfigureRoomState(
+            createRoomConfig.value,
+            isCreateButtonEnabled = isCreateButtonEnabled,
+            eventSink = ::handleEvents,
+        )
+    }
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenterArgs.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenterArgs.kt
@ -14,11 +14,10 @@
 * limitations under the License.
 */

-package io.element.android.features.createroom.impl.addpeople
+package io.element.android.features.createroom.impl.configureroom

-import io.element.android.features.userlist.api.UserListState
+import io.element.android.libraries.matrix.ui.model.MatrixUser

-data class AddPeopleState(
-    val userListState: UserListState,
-    val eventSink: (AddPeopleEvents) -> Unit,
+data class ConfigureRoomPresenterArgs(
+    val selectedUsers: List<MatrixUser>,
 )
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomState.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomState.kt
@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.createroom.impl.configureroom
+
+import io.element.android.features.createroom.impl.CreateRoomConfig
+
+data class ConfigureRoomState(
+    val config: CreateRoomConfig,
+    val isCreateButtonEnabled: Boolean,
+    val eventSink: (ConfigureRoomEvents) -> Unit
+)
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomStateProvider.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomStateProvider.kt
@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.createroom.impl.configureroom
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.createroom.impl.CreateRoomConfig
+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(
+    config = CreateRoomConfig(),
+    isCreateButtonEnabled = false,
+    eventSink = {}
+)
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomView.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomView.kt
@ -0,0 +1,215 @@
+/*
+ * 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.
+ */
+
+@file:OptIn(ExperimentalMaterial3Api::class)
+
+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.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.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
+import io.element.android.libraries.designsystem.theme.components.CenterAlignedTopAppBar
+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.ui.strings.R as StringR
+
+@Composable
+fun ConfigureRoomView(
+    state: ConfigureRoomState,
+    modifier: Modifier = Modifier,
+    onBackPressed: () -> Unit = {},
+) {
+    val context = LocalContext.current
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            ConfigureRoomToolbar(
+                isNextActionEnabled = state.isCreateButtonEnabled,
+                onBackPressed = onBackPressed,
+                onNextPressed = {
+                    // state.eventSink(ConfigureRoomEvents.CreateRoom)
+                    Toast.makeText(context, "not implemented yet", Toast.LENGTH_SHORT).show()
+                },
+            )
+        }
+    ) { padding ->
+        Column(
+            modifier = Modifier.padding(padding),
+            verticalArrangement = Arrangement.spacedBy(24.dp),
+        ) {
+            RoomNameWithAvatar(
+                modifier = Modifier.padding(horizontal = 16.dp),
+                avatarUri = state.config.avatarUrl?.toUri(),
+                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.config.topic.orEmpty(),
+                onTopicChanged = { state.eventSink(ConfigureRoomEvents.TopicChanged(it)) },
+            )
+            SelectedUsersList(
+                contentPadding = PaddingValues(horizontal = 24.dp),
+                selectedUsers = state.config.invites,
+                onUserRemoved = { state.eventSink(ConfigureRoomEvents.RemoveFromSelection(it)) },
+            )
+            Spacer(Modifier.weight(1f))
+            RoomPrivacyOptions(
+                modifier = Modifier.padding(bottom = 40.dp),
+                selected = state.config.privacy,
+                onOptionSelected = { state.eventSink(ConfigureRoomEvents.RoomPrivacyChanged(it.privacy)) },
+            )
+        }
+    }
+}
+
+@Composable
+fun ConfigureRoomToolbar(
+    isNextActionEnabled: Boolean,
+    modifier: Modifier = Modifier,
+    onBackPressed: () -> Unit = {},
+    onNextPressed: () -> Unit = {},
+) {
+    CenterAlignedTopAppBar(
+        modifier = modifier,
+        title = {
+            Text(
+                text = stringResource(R.string.screen_create_room_title),
+                fontSize = 16.sp,
+                fontWeight = FontWeight.SemiBold,
+            )
+        },
+        navigationIcon = { BackButton(onClick = onBackPressed) },
+        actions = {
+            TextButton(
+                modifier = Modifier.padding(horizontal = 8.dp),
+                enabled = isNextActionEnabled,
+                onClick = onNextPressed,
+            ) {
+                Text(
+                    text = stringResource(StringR.string.action_create),
+                    fontSize = 16.sp,
+                )
+            }
+        }
+    )
+}
+
+@Composable
+fun RoomNameWithAvatar(
+    avatarUri: Uri?,
+    roomName: String,
+    modifier: Modifier = Modifier,
+    onAvatarClick: () -> Unit = {},
+    onRoomNameChanged: (String) -> Unit = {},
+) {
+    Row(
+        modifier = modifier,
+        horizontalArrangement = Arrangement.spacedBy(16.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Avatar(
+            avatarUri = avatarUri,
+            onClick = onAvatarClick,
+        )
+
+        LabelledTextField(
+            label = stringResource(R.string.screen_create_room_room_name_label),
+            value = roomName,
+            placeholder = stringResource(R.string.screen_create_room_room_name_placeholder),
+            onValueChange = onRoomNameChanged
+        )
+    }
+}
+
+@Composable
+fun RoomTopic(
+    topic: String,
+    modifier: Modifier = Modifier,
+    onTopicChanged: (String) -> Unit = {},
+) {
+    LabelledTextField(
+        modifier = modifier,
+        label = stringResource(R.string.screen_create_room_topic_label),
+        value = topic,
+        placeholder = stringResource(R.string.screen_create_room_topic_placeholder),
+        onValueChange = onTopicChanged,
+        maxLines = 3,
+    )
+}
+
+@Composable
+fun RoomPrivacyOptions(
+    selected: RoomPrivacy?,
+    modifier: Modifier = Modifier,
+    onOptionSelected: (RoomPrivacyItem) -> Unit = {},
+) {
+    val items = roomPrivacyItems()
+    Column(modifier = modifier.selectableGroup()) {
+        items.forEach { item ->
+            RoomPrivacyOption(
+                roomPrivacyItem = item,
+                isSelected = selected == item.privacy,
+                onOptionSelected = onOptionSelected,
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+fun ConfigureRoomViewLightPreview(@PreviewParameter(ConfigureRoomStateProvider::class) state: ConfigureRoomState) =
+    ElementPreviewLight { ContentToPreview(state) }
+
+@Preview
+@Composable
+fun ConfigureRoomViewDarkPreview(@PreviewParameter(ConfigureRoomStateProvider::class) state: ConfigureRoomState) =
+    ElementPreviewDark { ContentToPreview(state) }
+
+@Composable
+private fun ContentToPreview(state: ConfigureRoomState) {
+    ConfigureRoomView(
+        state = state,
+    )
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/RoomPrivacy.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/RoomPrivacy.kt
@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.createroom.impl.configureroom
+
+enum class RoomPrivacy {
+    Private,
+    Public,
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/RoomPrivacyItem.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/RoomPrivacyItem.kt
@ -0,0 +1,56 @@
+/*
+ * 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.configureroom
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Lock
+import androidx.compose.material.icons.outlined.Public
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
+import io.element.android.features.createroom.impl.R
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
+
+data class RoomPrivacyItem(
+    val privacy: RoomPrivacy,
+    val icon: ImageVector,
+    val title: String,
+    val description: String,
+)
+
+@Composable
+fun roomPrivacyItems(): ImmutableList<RoomPrivacyItem> {
+    return RoomPrivacy.values()
+        .map {
+            when (it) {
+                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.Public -> RoomPrivacyItem(
+                    privacy = it,
+                    icon = Icons.Outlined.Public,
+                    title = stringResource(R.string.screen_create_room_public_option_title),
+                    description = stringResource(R.string.screen_create_room_public_option_description),
+                )
+            }
+        }
+        .toImmutableList()
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/di/CreateRoomComponent.kt
+++ b/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
+    }
+}
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/di/CreateRoomModule.kt
+++ b/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

 }
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleEvents.kt
+++ b/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeopleEvents.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()
--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/root/CreateRoomRootPresenter.kt
+++ b/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,
        )
    }

--- a/features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/root/CreateRoomRootView.kt
+++ b/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
@ -110,7 +110,7 @@ fun CreateRoomRootView(
        }
        is Async.Failure -> {
            RetryDialog(
-                content = stringResource(id = StringR.string.screen_start_chat_error_starting_chat),
+                content = stringResource(id = R.string.screen_start_chat_error_starting_chat),
                onDismiss = { state.eventSink(CreateRoomRootEvents.CancelStartDM) },
                onRetry = {
                    state.userListState.selectedUsers.firstOrNull()
@ -156,7 +156,7 @@ fun CreateRoomActionButtonsList(
    Column(modifier = modifier) {
        CreateRoomActionButton(
            iconRes = DrawableR.drawable.ic_groups,
-            text = stringResource(id = R.string.screen_create_room_action_create_room),
+            text = stringResource(id = StringR.string.action_create_a_room),
            onClick = onNewRoomClicked,
        )
        CreateRoomActionButton(
--- a/features/createroom/impl/src/main/res/values-es/translations.xml
+++ b/features/createroom/impl/src/main/res/values-es/translations.xml
@ -3,4 +3,6 @@
  <string name="screen_create_room_action_create_room">"Nueva sala"</string>
  <string name="screen_create_room_action_invite_people">"Invitar gente"</string>
  <string name="screen_create_room_add_people_title">"Añadir personas"</string>
+  <string name="screen_start_chat_error_starting_chat">"Se ha producido un error al intentar iniciar un chat"</string>
+  <string name="screen_start_chat_unknown_profile">"No podemos validar el ID de Matrix de este usuario. Es posible que no reciba la invitación."</string>
 </resources>
--- a/features/createroom/impl/src/main/res/values-it/translations.xml
+++ b/features/createroom/impl/src/main/res/values-it/translations.xml
@ -3,4 +3,6 @@
  <string name="screen_create_room_action_create_room">"Nuova stanza"</string>
  <string name="screen_create_room_action_invite_people">"Invita persone"</string>
  <string name="screen_create_room_add_people_title">"Aggiungi persone"</string>
+  <string name="screen_start_chat_error_starting_chat">"Si è verificato un errore durante il tentativo di avviare una chat"</string>
+  <string name="screen_start_chat_unknown_profile">"Non possiamo convalidare l\'ID Matrix di questo utente. L\'invito potrebbe non essere ricevuto."</string>
 </resources>
--- a/features/createroom/impl/src/main/res/values-ro/translations.xml
+++ b/features/createroom/impl/src/main/res/values-ro/translations.xml
@ -3,4 +3,6 @@
  <string name="screen_create_room_action_create_room">"Cameră nouă"</string>
  <string name="screen_create_room_action_invite_people">"Invitați persoane"</string>
  <string name="screen_create_room_add_people_title">"Adaugați persoane"</string>
+  <string name="screen_start_chat_error_starting_chat">"A apărut o eroare la încercarea începerii conversației"</string>
+  <string name="screen_start_chat_unknown_profile">"Nu am putut valida ID-ul Matrix al acestui utilizator. Este posibil ca invitația să nu fi fost primită."</string>
 </resources>
--- a/features/createroom/impl/src/main/res/values/localazy.xml
+++ b/features/createroom/impl/src/main/res/values/localazy.xml
@ -12,4 +12,6 @@
  <string name="screen_create_room_title">"Create a room"</string>
  <string name="screen_create_room_topic_label">"Topic (optional)"</string>
  <string name="screen_create_room_topic_placeholder">"What is this room about?"</string>
+  <string name="screen_start_chat_error_starting_chat">"An error occurred when trying to start a chat"</string>
+  <string name="screen_start_chat_unknown_profile">"We can’t validate this user’s Matrix ID. The invite might not be received."</string>
 </resources>
--- a/features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/addpeople/AddPeoplePresenterTests.kt
+++ b/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
--- a/features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenterTests.kt
+++ b/features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenterTests.kt
@ -0,0 +1,153 @@
+/*
+ * 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.
+ */
+
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package io.element.android.features.createroom.impl.configureroom
+
+import android.net.Uri
+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
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class ConfigureRoomPresenterTests {
+
+    private lateinit var presenter: ConfigureRoomPresenter
+    private lateinit var userListDataStore: UserListDataStore
+
+    @Before
+    fun setup() {
+        userListDataStore = UserListDataStore()
+        presenter = ConfigureRoomPresenter(CreateRoomDataStore(userListDataStore))
+    }
+
+    @Test
+    fun `present - initial state`() = runTest {
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.config).isEqualTo(CreateRoomConfig())
+            assertThat(initialState.config.roomName).isNull()
+            assertThat(initialState.config.topic).isNull()
+            assertThat(initialState.config.invites).isEmpty()
+            assertThat(initialState.config.avatarUrl).isNull()
+            assertThat(initialState.config.privacy).isNull()
+        }
+    }
+
+    @Test
+    fun `present - create room button is enabled only if the required fields are completed`() = runTest {
+        moleculeFlow(RecompositionClock.Immediate) {
+            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()
+            config = config.copy(roomName = A_ROOM_NAME)
+            assertThat(newState.config).isEqualTo(config)
+            assertThat(newState.isCreateButtonEnabled).isFalse()
+
+            // Select privacy
+            newState.eventSink(ConfigureRoomEvents.RoomPrivacyChanged(RoomPrivacy.Private))
+            newState = awaitItem()
+            config = config.copy(privacy = RoomPrivacy.Private)
+            assertThat(newState.config).isEqualTo(config)
+            assertThat(newState.isCreateButtonEnabled).isTrue()
+
+            // Clear room name
+            newState.eventSink(ConfigureRoomEvents.RoomNameChanged(""))
+            newState = awaitItem()
+            config = config.copy(roomName = null)
+            assertThat(newState.config).isEqualTo(config)
+            assertThat(newState.isCreateButtonEnabled).isFalse()
+        }
+    }
+
+    @Test
+    fun `present - state is updated when fields are changed`() = runTest {
+        moleculeFlow(RecompositionClock.Immediate) {
+            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))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(roomName = A_ROOM_NAME)
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
+            // Room topic
+            newState.eventSink(ConfigureRoomEvents.TopicChanged(A_MESSAGE))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(topic = A_MESSAGE)
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
+            // Room avatar
+            val anUri = Uri.parse(AN_AVATAR_URL)
+            newState.eventSink(ConfigureRoomEvents.AvatarUriChanged(anUri))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(avatarUrl = anUri.toString())
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
+            // Room privacy
+            newState.eventSink(ConfigureRoomEvents.RoomPrivacyChanged(RoomPrivacy.Public))
+            newState = awaitItem()
+            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)
+        }
+    }
+}
+
--- a/features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/root/CreateRoomRootPresenterTests.kt
+++ b/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()
-        presenter = CreateRoomRootPresenter(FakeUserListPresenterFactory(fakeUserListPresenter), userListDataSource, fakeMatrixClient)
+        userListDataSource = FakeUserListDataSource()
+        presenter = CreateRoomRootPresenter(FakeUserListPresenterFactory(fakeUserListPresenter), userListDataSource, UserListDataStore(), fakeMatrixClient)
    }

    @Test
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsFlowNode.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsFlowNode.kt
@ -29,10 +29,12 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
 import io.element.android.features.roomdetails.impl.members.RoomMemberListNode
+import io.element.android.features.roomdetails.impl.members.details.RoomMemberDetailsNode
 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.RoomScope
+import io.element.android.libraries.matrix.api.room.RoomMember
 import kotlinx.parcelize.Parcelize

@ContributesNode(RoomScope::class)
@ -54,6 +56,9 @@ class RoomDetailsFlowNode @AssistedInject constructor(

        @Parcelize
        object RoomMemberList : NavTarget
+
+        @Parcelize
+        data class RoomMemberDetails(val roomMember: RoomMember) : NavTarget
    }

    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
@ -66,7 +71,18 @@ class RoomDetailsFlowNode @AssistedInject constructor(
                }
                createNode<RoomDetailsNode>(buildContext, listOf(callback))
            }
-            NavTarget.RoomMemberList -> createNode<RoomMemberListNode>(buildContext)
+            NavTarget.RoomMemberList -> {
+                val callback = object : RoomMemberListNode.Callback {
+                    override fun openRoomMemberDetails(roomMember: RoomMember) {
+                        backstack.push(NavTarget.RoomMemberDetails(roomMember))
+                    }
+                }
+                createNode<RoomMemberListNode>(buildContext, listOf(callback))
+            }
+            is NavTarget.RoomMemberDetails -> {
+                val inputs = RoomMemberDetailsNode.Inputs(navTarget.roomMember)
+                createNode<RoomMemberDetailsNode>(buildContext, listOf(inputs))
+            }
        }
    }

--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsNode.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsNode.kt
@ -31,7 +31,6 @@ import io.element.android.libraries.androidutils.system.startSharePlainTextInten
 import io.element.android.libraries.di.RoomScope
 import io.element.android.libraries.matrix.api.permalink.PermalinkBuilder
 import io.element.android.libraries.matrix.api.room.MatrixRoom
-import io.element.android.libraries.ui.strings.R as StringR

@ContributesNode(RoomScope::class)
 class RoomDetailsNode @AssistedInject constructor(
@ -61,7 +60,6 @@ class RoomDetailsNode @AssistedInject constructor(
                activityResultLauncher = null,
                chooserTitle = context.getString(R.string.screen_room_details_share_room_title),
                text = permalink,
-                noActivityFoundMessage = context.getString(StringR.string.error_no_compatible_app_found)
            )
        }
    }
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsView.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsView.kt
@ -87,7 +87,7 @@ fun RoomDetailsView(
                roomAlias = state.roomAlias
            )

-            ShareSection(onShareRoom = onShareRoom)
+            ShareSection(onShareUser = onShareRoom)

            if (state.roomTopic != null) {
                TopicSection(roomTopic = state.roomTopic)
@ -127,12 +127,12 @@ fun RoomDetailsView(
 }

@Composable
-internal fun ShareSection(onShareRoom: () -> Unit, modifier: Modifier = Modifier) {
+internal fun ShareSection(onShareUser: () -> Unit, modifier: Modifier = Modifier) {
    PreferenceCategory(modifier = modifier) {
        PreferenceText(
            title = stringResource(R.string.screen_room_details_share_room_title),
            icon = Icons.Outlined.Share,
-            onClick = onShareRoom,
+            onClick = onShareUser,
        )
    }
 }
@ -172,7 +172,6 @@ internal fun TopicSection(roomTopic: String, modifier: Modifier = Modifier) {
            color = MaterialTheme.colorScheme.tertiary
        )
    }
-
 }

@Composable
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/di/RoomMemberBindsModule.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/di/RoomMemberBindsModule.kt
@ -19,17 +19,35 @@ package io.element.android.features.roomdetails.impl.di
 import com.squareup.anvil.annotations.ContributesTo
 import dagger.Binds
 import dagger.Module
-import io.element.android.features.roomdetails.impl.members.RoomMatrixUserDataSource
-import io.element.android.features.userlist.api.MatrixUserDataSource
+import dagger.Provides
+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.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
 import javax.inject.Named

@Module
@ContributesTo(RoomScope::class)
-interface RoomMemberModule {
+interface RoomMemberBindsModule {

    @Binds
    @Named("RoomMembers")
-    fun bindRoomMemberUserListDataSource(dataSource: RoomMatrixUserDataSource): MatrixUserDataSource
-
+    fun bindRoomMemberUserListDataSource(dataSource: RoomUserListDataSource): UserListDataSource
+}
+
+@Module
+@ContributesTo(RoomScope::class)
+object RoomMemberProvidesModule {
+    @Provides
+    fun provideRoomMemberDetailsPresenterFactory(
+        room: MatrixRoom,
+    ): RoomMemberDetailsPresenter.Factory {
+        return object : RoomMemberDetailsPresenter.Factory {
+            override fun create(roomMember: RoomMember): RoomMemberDetailsPresenter {
+                return RoomMemberDetailsPresenter(room, roomMember)
+            }
+        }
+    }
 }
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/RoomMemberListNode.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/RoomMemberListNode.kt
@ -21,10 +21,14 @@ import androidx.compose.ui.Modifier
 import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.roomdetails.impl.RoomDetailsFlowNode
 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
 import io.element.android.libraries.matrix.ui.model.MatrixUser
 import timber.log.Timber

@ -32,11 +36,23 @@ import timber.log.Timber
 class RoomMemberListNode @AssistedInject constructor(
    @Assisted buildContext: BuildContext,
    @Assisted plugins: List<Plugin>,
+    private val room: MatrixRoom,
    private val presenter: RoomMemberListPresenter,
 ) : Node(buildContext, plugins = plugins) {

+    interface Callback : Plugin {
+        fun openRoomMemberDetails(roomMember: RoomMember)
+    }
+
+    private val callback = plugins<Callback>().first()
+
    private fun onUserSelected(matrixUser: MatrixUser) {
-        Timber.d("TODO: implement user selection. User: $matrixUser")
+        val member = room.getMember(matrixUser.id)
+        if (member != null) {
+            callback.openRoomMemberDetails(member)
+        } else {
+            Timber.e("Could find room member ${matrixUser.id} in room ${room.roomId}")
+        }
    }

    @Composable
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/RoomMemberListPresenter.kt
+++ b/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(
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/RoomMemberListView.kt
+++ b/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.UserListView
+import io.element.android.features.userlist.api.components.SearchSingleUserResultItem
+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
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/RoomMatrixUserDataSource.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/RoomMatrixUserDataSource.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 ->
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsEvents.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsEvents.kt
@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.roomdetails.impl.members.details
+
+// TODO Add your events or remove the file completely if no events
+sealed interface RoomMemberDetailsEvents {
+    object MyEvent : RoomMemberDetailsEvents
+}
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsNode.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsNode.kt
@ -0,0 +1,81 @@
+/*
+ * 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.roomdetails.impl.members.details
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.roomdetails.impl.R
+import io.element.android.libraries.androidutils.system.startSharePlainTextIntent
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.architecture.inputs
+import io.element.android.libraries.di.RoomScope
+import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.api.permalink.PermalinkBuilder
+import io.element.android.libraries.matrix.api.room.RoomMember
+import timber.log.Timber
+import io.element.android.libraries.androidutils.R as AndroidUtilsR
+
+@ContributesNode(RoomScope::class)
+class RoomMemberDetailsNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    presenterFactory: RoomMemberDetailsPresenter.Factory,
+) : Node(buildContext, plugins = plugins) {
+
+    data class Inputs(
+        val member: RoomMember,
+    ) : NodeInputs
+
+    private val inputs = inputs<Inputs>()
+    private val presenter = presenterFactory.create(inputs.member)
+
+    @Composable
+    override fun View(modifier: Modifier) {
+
+        val context = LocalContext.current
+
+        fun onShareUser() {
+            val permalinkResult = PermalinkBuilder.permalinkForUser(UserId(inputs.member.userId))
+            permalinkResult.onSuccess { permalink ->
+                startSharePlainTextIntent(
+                    context = context,
+                    activityResultLauncher = null,
+                    chooserTitle = context.getString(R.string.screen_room_details_share_room_title),
+                    text = permalink,
+                    noActivityFoundMessage = context.getString(AndroidUtilsR.string.error_no_compatible_app_found)
+                )
+            }.onFailure {
+                Timber.e(it)
+            }
+        }
+
+        val state = presenter.present()
+        RoomMemberDetailsView(
+            state = state,
+            modifier = modifier,
+            goBack = this::navigateUp,
+            onShareUser = ::onShareUser
+        )
+    }
+}
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsPresenter.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsPresenter.kt
@ -0,0 +1,51 @@
+/*
+ * 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.roomdetails.impl.members.details
+
+import androidx.compose.runtime.Composable
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.matrix.api.room.MatrixRoom
+import io.element.android.libraries.matrix.api.room.RoomMember
+
+class RoomMemberDetailsPresenter @AssistedInject constructor(
+    private val room: MatrixRoom,
+    @Assisted private val roomMember: RoomMember,
+) : Presenter<RoomMemberDetailsState> {
+
+    interface Factory {
+        fun create(roomMember: RoomMember): RoomMemberDetailsPresenter
+    }
+
+    @Composable
+    override fun present(): RoomMemberDetailsState {
+
+//        fun handleEvents(event: RoomMemberDetailsEvents) {
+//            when (event) {
+//            }
+//        }
+
+        return RoomMemberDetailsState(
+            userId = roomMember.userId,
+            userName = roomMember.displayName,
+            avatarUrl = roomMember.avatarUrl,
+            isBlocked = roomMember.isIgnored,
+//            eventSink = ::handleEvents
+        )
+    }
+}
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsState.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsState.kt
@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.roomdetails.impl.members.details
+
+data class RoomMemberDetailsState(
+    val userId: String,
+    val userName: String?,
+    val avatarUrl: String?,
+    val isBlocked: Boolean,
+//    val eventSink: (RoomMemberDetailsEvents) -> Unit
+)
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsStateProvider.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsStateProvider.kt
@ -0,0 +1,37 @@
+/*
+ * 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.roomdetails.impl.members.details
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+
+open class RoomMemberDetailsStateProvider : PreviewParameterProvider<RoomMemberDetailsState> {
+    override val values: Sequence<RoomMemberDetailsState>
+        get() = sequenceOf(
+            aRoomMemberDetailsState(),
+            aRoomMemberDetailsState().copy(userName = null),
+            aRoomMemberDetailsState().copy(isBlocked = true),
+            // Add other states here
+        )
+}
+
+fun aRoomMemberDetailsState() = RoomMemberDetailsState(
+    userId = "@daniel:domain.com",
+    userName = "Daniel",
+    avatarUrl = null,
+    isBlocked = false,
+//    eventSink = {},
+)
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsView.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsView.kt
@ -0,0 +1,177 @@
+/*
+ * 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.roomdetails.impl.members.details
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Block
+import androidx.compose.material.icons.outlined.ChatBubbleOutline
+import androidx.compose.material.icons.outlined.Share
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.features.roomdetails.impl.R
+import io.element.android.libraries.designsystem.ElementTextStyles
+import io.element.android.libraries.designsystem.components.avatar.Avatar
+import io.element.android.libraries.designsystem.components.avatar.AvatarData
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.components.preferences.PreferenceCategory
+import io.element.android.libraries.designsystem.components.preferences.PreferenceText
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.LocalColors
+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.TopAppBar
+import io.element.android.libraries.ui.strings.R as StringR
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun RoomMemberDetailsView(
+    state: RoomMemberDetailsState,
+    onShareUser: () -> Unit,
+    goBack: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(title = { }, navigationIcon = { BackButton(onClick = goBack) })
+        },
+    ) { padding ->
+        Column(
+            modifier = Modifier
+                .padding(padding)
+                .verticalScroll(rememberScrollState())
+        ) {
+            HeaderSection(
+                avatarUrl = state.avatarUrl,
+                userId = state.userId,
+                userName = state.userName,
+            )
+
+            ShareSection(onShareUser = onShareUser)
+
+            SendMessageSection(onSendMessage = {
+                // TODO implement send DM
+            })
+
+            BlockSection(isBlocked = state.isBlocked, onToggleBlock = {
+                // TODO implement block & unblock
+            })
+        }
+    }
+}
+
+@Composable
+internal fun HeaderSection(
+    avatarUrl: String?,
+    userId: String,
+    userName: String?,
+    modifier: Modifier = Modifier
+) {
+    Column(modifier.fillMaxWidth(), horizontalAlignment = Alignment.CenterHorizontally) {
+        Box(modifier = Modifier.size(70.dp)) {
+            Avatar(
+                avatarData = AvatarData(userId, userName, avatarUrl, AvatarSize.HUGE),
+                modifier = Modifier.fillMaxSize()
+            )
+        }
+        Spacer(modifier = Modifier.height(30.dp))
+        if (userName != null) {
+            Text(userName, style = ElementTextStyles.Bold.title1)
+            Spacer(modifier = Modifier.height(8.dp))
+        }
+        Text(userId, style = ElementTextStyles.Regular.body, color = MaterialTheme.colorScheme.secondary)
+        Spacer(Modifier.height(32.dp))
+    }
+}
+
+@Composable
+internal fun ShareSection(onShareUser: () -> Unit, modifier: Modifier = Modifier) {
+    PreferenceCategory(modifier = modifier) {
+        PreferenceText(
+            title = stringResource(StringR.string.action_share),
+            icon = Icons.Outlined.Share,
+            onClick = onShareUser,
+        )
+    }
+}
+
+@Composable
+internal fun SendMessageSection(onSendMessage: () -> Unit, modifier: Modifier = Modifier) {
+    PreferenceCategory(modifier = modifier) {
+        PreferenceText(
+            title = stringResource(StringR.string.action_send_message),
+            icon = Icons.Outlined.ChatBubbleOutline,
+            onClick = onSendMessage,
+        )
+    }
+}
+
+@Composable
+internal fun BlockSection(isBlocked: Boolean, onToggleBlock: () -> Unit, modifier: Modifier = Modifier) {
+    PreferenceCategory(showDivider = false, modifier = modifier) {
+        if (isBlocked) {
+            PreferenceText(
+                title = stringResource(R.string.screen_dm_details_unblock_user),
+                icon = Icons.Outlined.Block,
+            )
+        } else {
+            PreferenceText(
+                title = stringResource(R.string.screen_dm_details_block_user),
+                icon = Icons.Outlined.Block,
+                tintColor = LocalColors.current.textActionCritical,
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+fun RoomMemberDetailsViewLightPreview(@PreviewParameter(RoomMemberDetailsStateProvider::class) state: RoomMemberDetailsState) =
+    ElementPreviewLight { ContentToPreview(state) }
+
+@Preview
+@Composable
+fun RoomMemberDetailsViewDarkPreview(@PreviewParameter(RoomMemberDetailsStateProvider::class) state: RoomMemberDetailsState) =
+    ElementPreviewDark { ContentToPreview(state) }
+
+@Composable
+private fun ContentToPreview(state: RoomMemberDetailsState) {
+    RoomMemberDetailsView(
+        state = state,
+        onShareUser = {},
+        goBack = {},
+    )
+}
--- a/features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/RoomDetailsPresenterTests.kt
+++ b/features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/RoomDetailsPresenterTests.kt
@ -232,7 +232,8 @@ fun aRoomMember(
    membership: RoomMembershipState = RoomMembershipState.JOIN,
    isNameAmbiguous: Boolean = false,
    powerLevel: Long = 0L,
-    normalizedPowerLevel: Long = 0L
+    normalizedPowerLevel: Long = 0L,
+    isIgnored: Boolean = false,
 ) = RoomMember(
    userId = userId.value,
    displayName = displayName,
@ -241,4 +242,5 @@ fun aRoomMember(
    isNameAmbiguous = isNameAmbiguous,
    powerLevel = powerLevel,
    normalizedPowerLevel = normalizedPowerLevel,
+    isIgnored = isIgnored,
 )
--- a/features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/members/RoomMemberListPresenterTests.kt
+++ b/features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/members/RoomMemberListPresenterTests.kt
@ -22,29 +22,37 @@ 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
 import kotlinx.coroutines.test.runTest
 import okhttp3.internal.toImmutableList
 import org.junit.Test

+@ExperimentalCoroutinesApi
 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 {
@ -58,5 +66,4 @@ class RoomMemberListPresenterTests {
            Truth.assertThat((loadedState.allUsers as? Async.Success)?.state).isEqualTo(searchResult.toImmutableList())
        }
    }
-
 }
--- a/features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/members/details/RoomMemberDetailsPresenterTests.kt
+++ b/features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/members/details/RoomMemberDetailsPresenterTests.kt
@ -0,0 +1,48 @@
+/*
+ * 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.roomdetails.members.details
+
+import app.cash.molecule.RecompositionClock
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth
+import io.element.android.features.roomdetails.aMatrixRoom
+import io.element.android.features.roomdetails.aRoomMember
+import io.element.android.features.roomdetails.impl.members.details.RoomMemberDetailsPresenter
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+@ExperimentalCoroutinesApi
+class RoomMemberDetailsPresenterTests {
+
+    @Test
+    fun `present - returns the room member's data`() = runTest {
+        val room = aMatrixRoom()
+        val roomMember = aRoomMember(displayName = "Alice")
+        val presenter = RoomMemberDetailsPresenter(room, roomMember)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            Truth.assertThat(initialState.userId).isEqualTo(roomMember.userId)
+            Truth.assertThat(initialState.userName).isEqualTo(roomMember.displayName)
+            Truth.assertThat(initialState.avatarUrl).isEqualTo(roomMember.avatarUrl)
+            Truth.assertThat(initialState.isBlocked).isEqualTo(roomMember.isIgnored)
+        }
+    }
+}
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/MatrixUserDataSource.kt
+++ b/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/MatrixUserDataSource.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?
 }
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListDataStore.kt
+++ b/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
+}
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListPresenter.kt
+++ b/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
    }
 }
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListState.kt
+++ b/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,
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListStateProvider.kt
+++ b/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.model.MatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
 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(
-    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"),
-)
+fun aListOfSelectedUsers() = aMatrixUserList().take(6).toImmutableList()
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListView.kt
+++ b/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/UserListView.kt
@ -1,311 +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.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,
-                modifier = Modifier.padding(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,
-                    modifier = Modifier.padding(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,
-    onUserRemoved: (MatrixUser) -> Unit = {},
-) {
-    LazyRow(
-        state = listState,
-        modifier = modifier,
-        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)
-}
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SearchMultipleUsersResultItem.kt
+++ b/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)
+    }
+}
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SearchSingleUserResultItem.kt
+++ b/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())
+}
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SearchUserBar.kt
+++ b/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) }
+                        )
+                    }
+                }
+            }
+        },
+    )
+}
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SelectedUser.kt
+++ b/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())
+}
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/SelectedUsersList.kt
+++ b/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(),
+    )
+}
--- a/features/userlist/api/src/main/kotlin/io/element/android/features/userlist/api/components/UserListView.kt
+++ b/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)
+}
--- a/features/userlist/impl/src/main/kotlin/io/element/android/features/userlist/impl/DefaultUserListPresenter.kt
+++ b/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 {
-            mutableStateOf(persistentListOf())
-        }
-        val selectedUsersListState = rememberLazyListState()
+        val selectedUsers = userListDataStore.selectedUsers().collectAsState(emptyList())
        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 -> {
-                    if (event.matrixUser !in selectedUsers.value) {
-                        selectedUsers.value = selectedUsers.value.plus(event.matrixUser).toImmutableList()
-                    }
-                    localCoroutineScope.scrollToFirstSelectedUser(selectedUsersListState)
-                }
-                is UserListEvents.RemoveFromSelection -> selectedUsers.value = selectedUsers.value.minus(event.matrixUser).toImmutableList()
+                is UserListEvents.AddToSelection -> userListDataStore.selectUser(event.matrixUser)
+                is UserListEvents.RemoveFromSelection -> userListDataStore.removeUserFromSelection(event.matrixUser)
            }
        }

@ -100,8 +93,7 @@ class DefaultUserListPresenter @AssistedInject constructor(
        return UserListState(
            searchQuery = searchQuery,
            searchResults = searchResults.value,
-            selectedUsers = selectedUsers.value.reversed().toImmutableList(),
-            selectedUsersListState = selectedUsersListState,
+            selectedUsers = selectedUsers.value.toImmutableList(),
            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)
-    }
 }
--- a/features/userlist/impl/src/test/kotlin/io/element/android/features/userlist/impl/DefaultUserListPresenterTests.kt
+++ b/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.FakeMatrixUserDataSource
+import io.element.android.features.userlist.test.FakeUserListDataSource
 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()
--- a/features/userlist/test/src/main/kotlin/io/element/android/features/userlist/test/FakeMatrixUserDataSource.kt
+++ b/features/userlist/test/src/main/kotlin/io/element/android/features/userlist/test/FakeMatrixUserDataSource.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
--- a/features/userlist/test/src/main/kotlin/io/element/android/features/userlist/test/FakeUserListPresenterFactory.kt
+++ b/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
 }