Refactor search related functionality (#436)

Refactor search related functionality

This is a prelude to adding the feature of inviting users to
a room, getting everything in the right place and reusable.

What this does:

## User search refactor

Moves the (global) user search logic (dealing with MXIDs,
minimum lengths, debounces) into a `UserRepository`.

This now sits in a `usersearch` library, which will be
used by the create room flow and the new invite flow.

## SearchBar logic pull-up

Every place we use SearchBar, we're doing the same things
to style placeholders, show back/cancel buttons, etc.

We also have a results type that is duplicated for
basically every feature that uses the search bar.

I've pushed all this common functionality into the
SearchBar itself. This makes the component a bit less
general purpose, but saves a lot of repetition.

## Remove the userlist feature

Almost all the functionality of the userlist feature
is now exclusively used by the create room feature.
Room details uses its own version because the
requirements are different.

Components useful elsewhere (SelectedUsers and
SelectedUser) have gone to matrixui, everything else
has gone to createroom.

## Other bits and pieces

I've fixed everywhere that uses Scaffold to correctly
consume the WindowInsets if the contentPadding is
applied to the contents (which it universally is).
This was a change in the last version of Material3
(I guess previously Scaffold handled the consumption
for us). This fixes weird gaps above search bars.

Added overloads for the MatrixUserRow and
CheckedMatrixUserRow that take the name/subtitle/avatar
separately, so the invites list can pass arbitrary
text like "User has already been invited".

The `blockuser` package was for some reason not
under `impl` but alongside it, I've bumped it into
the right place.

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

@@ -1,40 +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.createroom.impl
-
-import io.element.android.features.userlist.api.UserListDataSource
-import io.element.android.libraries.matrix.api.MatrixClient
-import io.element.android.libraries.matrix.api.core.UserId
-import io.element.android.libraries.matrix.api.user.MatrixUser
-import javax.inject.Inject
-
-class AllMatrixUsersDataSource @Inject constructor(
-    private val client: MatrixClient
-) : UserListDataSource {
-    override suspend fun search(query: String): List<MatrixUser> {
-        val res = client.searchUsers(query, MAX_SEARCH_RESULTS)
-        return res.getOrNull()?.results.orEmpty()
-    }
-
-    override suspend fun getProfile(userId: UserId): MatrixUser? {
-        return client.getProfile(userId).getOrNull()
-    }
-
-    companion object {
-        private const val MAX_SEARCH_RESULTS = 5L
-    }
-}

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

@@ -19,7 +19,7 @@ package io.element.android.features.createroom.impl
 import android.net.Uri
 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.features.createroom.impl.userlist.UserListDataStore
 import io.element.android.libraries.di.SingleIn
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.flow.Flow

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

@@ -18,18 +18,17 @@ 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.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.features.createroom.impl.userlist.SelectionMode
+import io.element.android.features.createroom.impl.userlist.UserListPresenter
+import io.element.android.features.createroom.impl.userlist.UserListPresenterArgs
+import io.element.android.features.createroom.impl.userlist.UserListState
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.usersearch.api.UserRepository
 import javax.inject.Inject
-import javax.inject.Named
 
 class AddPeoplePresenter @Inject constructor(
     private val userListPresenterFactory: UserListPresenter.Factory,
-    @Named("AllUsers") private val userListDataSource: UserListDataSource,
+    private val userRepository: UserRepository,
     private val dataStore: CreateRoomDataStore,
 ) : Presenter<UserListState> {
 
@@ -37,10 +36,8 @@ class AddPeoplePresenter @Inject constructor(
         userListPresenterFactory.create(
             UserListPresenterArgs(
                 selectionMode = SelectionMode.Multiple,
-                minimumSearchLength = 3,
-                searchDebouncePeriodMillis = UserListPresenterArgs.DEFAULT_DEBOUNCE
             ),
-            userListDataSource,
+            userRepository,
             dataStore.selectedUserListDataStore,
         )
     }

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

@@ -17,11 +17,11 @@
 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.UserSearchResultState
-import io.element.android.features.userlist.api.aListOfSelectedUsers
-import io.element.android.features.userlist.api.aUserListState
+import io.element.android.features.createroom.impl.userlist.SelectionMode
+import io.element.android.features.createroom.impl.userlist.UserListState
+import io.element.android.features.createroom.impl.userlist.aListOfSelectedUsers
+import io.element.android.features.createroom.impl.userlist.aUserListState
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
 import io.element.android.libraries.matrix.ui.components.aMatrixUserList
 import kotlinx.collections.immutable.toImmutableList
 
@@ -30,13 +30,13 @@ open class AddPeopleUserListStateProvider : PreviewParameterProvider<UserListSta
         get() = sequenceOf(
             aUserListState(),
             aUserListState().copy(
-                searchResults = UserSearchResultState.Results(aMatrixUserList().toImmutableList()),
+                searchResults = SearchBarResultState.Results(aMatrixUserList().toImmutableList()),
                 selectedUsers = aListOfSelectedUsers(),
                 isSearchActive = false,
                 selectionMode = SelectionMode.Multiple,
             ),
             aUserListState().copy(
-                searchResults = UserSearchResultState.Results(aMatrixUserList().toImmutableList()),
+                searchResults = SearchBarResultState.Results(aMatrixUserList().toImmutableList()),
                 selectedUsers = aListOfSelectedUsers(),
                 isSearchActive = true,
                 selectionMode = SelectionMode.Multiple,

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

@@ -17,6 +17,8 @@
 package io.element.android.features.createroom.impl.addpeople
 
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.consumeWindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
@@ -30,8 +32,8 @@ import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import io.element.android.features.createroom.impl.R
-import io.element.android.features.userlist.api.UserListState
-import io.element.android.features.userlist.api.components.UserListView
+import io.element.android.features.createroom.impl.components.UserListView
+import io.element.android.features.createroom.impl.userlist.UserListState
 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
@@ -41,6 +43,7 @@ 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
 
+@OptIn(ExperimentalLayoutApi::class)
 @Composable
 fun AddPeopleView(
     state: UserListState,
@@ -49,6 +52,7 @@ fun AddPeopleView(
     onNextPressed: () -> Unit = {},
 ) {
     Scaffold(
+        modifier = modifier,
         topBar = {
             if (!state.isSearchActive) {
                 AddPeopleViewTopBar(
@@ -60,12 +64,14 @@ fun AddPeopleView(
         }
     ) { padding ->
         Column(
-            modifier = modifier
+            modifier = Modifier
                 .fillMaxSize()
-                .padding(padding),
+                .padding(padding)
+                .consumeWindowInsets(padding),
         ) {
             UserListView(
-                modifier = Modifier.fillMaxWidth(),
+                modifier = Modifier
+                    .fillMaxWidth(),
                 state = state,
             )
         }

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/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.createroom.impl.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.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.CheckableMatrixUserRow
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+
+@Composable
+fun SearchMultipleUsersResultItem(
+    matrixUser: MatrixUser,
+    isUserSelected: Boolean,
+    modifier: Modifier = Modifier,
+    onCheckedChange: (Boolean) -> Unit = {},
+) {
+    CheckableMatrixUserRow(
+        checked = isUserSelected,
+        modifier = modifier,
+        matrixUser = matrixUser,
+        avatarSize = AvatarSize.Custom(36.dp),
+        onCheckedChange = onCheckedChange,
+    )
+}
+
+@Preview
+@Composable
+internal fun SearchMultipleUsersResultItemLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+internal fun SearchMultipleUsersResultItemDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    Column {
+        SearchMultipleUsersResultItem(matrixUser = aMatrixUser(), isUserSelected = true)
+        SearchMultipleUsersResultItem(matrixUser = aMatrixUser(), isUserSelected = false)
+    }
+}

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/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.createroom.impl.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.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.MatrixUserRow
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+
+@Composable
+fun SearchSingleUserResultItem(
+    matrixUser: MatrixUser,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit = {},
+) {
+    MatrixUserRow(
+        modifier = modifier.clickable(onClick = onClick),
+        matrixUser = matrixUser,
+        avatarSize = AvatarSize.Custom(36.dp),
+    )
+}
+
+@Preview
+@Composable
+internal fun SearchSingleUserResultItemLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+internal fun SearchSingleUserResultItemDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    SearchSingleUserResultItem(matrixUser = aMatrixUser())
+}

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/components/SearchUserBar.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.components
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.theme.components.SearchBar
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.SelectedUsersList
+import io.element.android.libraries.ui.strings.R
+import kotlinx.collections.immutable.ImmutableList
+
+@Composable
+fun SearchUserBar(
+    query: String,
+    state: SearchBarResultState<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 = {},
+) {
+    SearchBar(
+        query = query,
+        onQueryChange = onTextChanged,
+        active = active,
+        onActiveChange = onActiveChanged,
+        modifier = modifier,
+        placeHolderTitle = placeHolderTitle,
+        contentPrefix = {
+            if (isMultiSelectionEnabled && active && selectedUsers.isNotEmpty()) {
+                SelectedUsersList(
+                    contentPadding = PaddingValues(16.dp),
+                    selectedUsers = selectedUsers,
+                    autoScroll = true,
+                    onUserRemoved = onUserDeselected,
+                )
+            }
+        },
+        resultState = state,
+        resultHandler = { users ->
+            LazyColumn {
+                if (isMultiSelectionEnabled) {
+                    items(users) { matrixUser ->
+                        SearchMultipleUsersResultItem(
+                            modifier = Modifier.fillMaxWidth(),
+                            matrixUser = matrixUser,
+                            isUserSelected = selectedUsers.find { it.userId == matrixUser.userId } != null,
+                            onCheckedChange = { checked ->
+                                if (checked) {
+                                    onUserSelected(matrixUser)
+                                } else {
+                                    onUserDeselected(matrixUser)
+                                }
+                            }
+                        )
+                    }
+                } else {
+                    items(users) { matrixUser ->
+                        SearchSingleUserResultItem(
+                            modifier = Modifier.fillMaxWidth(),
+                            matrixUser = matrixUser,
+                            onClick = { onUserSelected(matrixUser) }
+                        )
+                    }
+                }
+            }
+        },
+    )
+}

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

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

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

@@ -18,7 +18,7 @@ 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
+import io.element.android.features.createroom.impl.userlist.aListOfSelectedUsers
 import io.element.android.libraries.architecture.Async
 import kotlinx.collections.immutable.persistentListOf
 

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

@@ -20,8 +20,10 @@ import android.net.Uri
 import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.consumeWindowInsets
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.selection.selectableGroup
@@ -48,7 +50,6 @@ 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.createroom.impl.configureroom.avatar.AvatarActionListView
-import io.element.android.features.userlist.api.components.SelectedUsersList
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.designsystem.components.ProgressDialog
 import io.element.android.libraries.designsystem.components.button.BackButton
@@ -60,10 +61,11 @@ import io.element.android.libraries.designsystem.theme.components.Scaffold
 import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.theme.components.TextButton
 import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.ui.components.SelectedUsersList
 import kotlinx.coroutines.launch
 import io.element.android.libraries.ui.strings.R as StringR
 
-@OptIn(ExperimentalMaterialApi::class)
+@OptIn(ExperimentalLayoutApi::class, ExperimentalMaterialApi::class)
 @Composable
 fun ConfigureRoomView(
     state: ConfigureRoomState,
@@ -104,7 +106,9 @@ fun ConfigureRoomView(
         }
     ) { padding ->
         LazyColumn(
-            modifier = Modifier.padding(padding),
+            modifier = Modifier
+                .padding(padding)
+                .consumeWindowInsets(padding),
             verticalArrangement = Arrangement.spacedBy(24.dp),
         ) {
             item {

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

@@ -21,25 +21,24 @@ 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.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.features.createroom.impl.userlist.SelectionMode
+import io.element.android.features.createroom.impl.userlist.UserListDataStore
+import io.element.android.features.createroom.impl.userlist.UserListPresenter
+import io.element.android.features.createroom.impl.userlist.UserListPresenterArgs
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.architecture.execute
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.usersearch.api.UserRepository
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import javax.inject.Inject
-import javax.inject.Named
 
 class CreateRoomRootPresenter @Inject constructor(
     private val presenterFactory: UserListPresenter.Factory,
-    @Named("AllUsers") private val userListDataSource: UserListDataSource,
+    private val userRepository: UserRepository,
     private val userListDataStore: UserListDataStore,
     private val matrixClient: MatrixClient,
 ) : Presenter<CreateRoomRootState> {
@@ -48,10 +47,8 @@ class CreateRoomRootPresenter @Inject constructor(
         presenterFactory.create(
             UserListPresenterArgs(
                 selectionMode = SelectionMode.Single,
-                minimumSearchLength = 3,
-                searchDebouncePeriodMillis = UserListPresenterArgs.DEFAULT_DEBOUNCE,
             ),
-            userListDataSource,
+            userRepository,
             userListDataStore,
         )
     }

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

@@ -16,7 +16,7 @@
 
 package io.element.android.features.createroom.impl.root
 
-import io.element.android.features.userlist.api.UserListState
+import io.element.android.features.createroom.impl.userlist.UserListState
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.api.core.RoomId
 

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

@@ -17,9 +17,10 @@
 package io.element.android.features.createroom.impl.root
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.features.userlist.api.UserSearchResultState
-import io.element.android.features.userlist.api.aUserListState
+import io.element.android.features.createroom.impl.userlist.aUserListState
+
 import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
 import io.element.android.libraries.matrix.ui.components.aMatrixUser
 import kotlinx.collections.immutable.persistentListOf
 
@@ -32,7 +33,7 @@ open class CreateRoomRootStateProvider : PreviewParameterProvider<CreateRoomRoot
                 userListState = aMatrixUser().let {
                     aUserListState().copy(
                         searchQuery = it.userId.value,
-                        searchResults = UserSearchResultState.Results(persistentListOf(it)),
+                        searchResults = SearchBarResultState.Results(persistentListOf(it)),
                         selectedUsers = persistentListOf(it),
                         isSearchActive = true,
                     )
@@ -43,7 +44,7 @@ open class CreateRoomRootStateProvider : PreviewParameterProvider<CreateRoomRoot
                 userListState = aMatrixUser().let {
                     aUserListState().copy(
                         searchQuery = it.userId.value,
-                        searchResults = UserSearchResultState.Results(persistentListOf(it)),
+                        searchResults = SearchBarResultState.Results(persistentListOf(it)),
                         selectedUsers = persistentListOf(it),
                         isSearchActive = true,
                     )

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

@@ -20,7 +20,9 @@ import androidx.annotation.DrawableRes
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.consumeWindowInsets
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
@@ -32,7 +34,6 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
-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
@@ -40,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.components.UserListView
+import io.element.android.features.createroom.impl.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
@@ -55,6 +56,7 @@ import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.designsystem.R as DrawableR
 import io.element.android.libraries.ui.strings.R as StringR
 
+@OptIn(ExperimentalLayoutApi::class)
 @Composable
 fun CreateRoomRootView(
     state: CreateRoomRootState,
@@ -78,10 +80,11 @@ fun CreateRoomRootView(
         }
     ) { paddingValues ->
         Column(
-            modifier = Modifier.padding(paddingValues),
+            modifier = Modifier
+                .padding(paddingValues)
+                .consumeWindowInsets(paddingValues),
             verticalArrangement = Arrangement.spacedBy(8.dp),
         ) {
-            val context = LocalContext.current
             UserListView(
                 modifier = Modifier.fillMaxWidth(),
                 state = state.userListState,

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/userlist/DefaultUserListPresenter.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.createroom.impl.userlist
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+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.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.usersearch.api.UserRepository
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
+
+class DefaultUserListPresenter @AssistedInject constructor(
+    @Assisted val args: UserListPresenterArgs,
+    @Assisted val userRepository: UserRepository,
+    @Assisted val userListDataStore: UserListDataStore,
+) : UserListPresenter {
+
+    @AssistedFactory
+    @ContributesBinding(SessionScope::class)
+    interface DefaultUserListFactory : UserListPresenter.Factory {
+        override fun create(
+            args: UserListPresenterArgs,
+            userRepository: UserRepository,
+            userListDataStore: UserListDataStore,
+        ): DefaultUserListPresenter
+    }
+
+    @Composable
+    override fun present(): UserListState {
+        var isSearchActive by rememberSaveable { mutableStateOf(false) }
+        val selectedUsers by userListDataStore.selectedUsers().collectAsState(emptyList())
+        var searchQuery by rememberSaveable { mutableStateOf("") }
+        var searchResults: SearchBarResultState<ImmutableList<MatrixUser>> by remember {
+            mutableStateOf(SearchBarResultState.NotSearching())
+        }
+
+        LaunchedEffect(searchQuery) {
+            searchResults = SearchBarResultState.NotSearching()
+
+            userRepository.search(searchQuery).collect {
+                searchResults = when {
+                    it.isEmpty() -> SearchBarResultState.NoResults()
+                    else -> SearchBarResultState.Results(it.toImmutableList())
+                }
+            }
+        }
+
+        return UserListState(
+            searchQuery = searchQuery,
+            searchResults = searchResults,
+            selectedUsers = selectedUsers.toImmutableList(),
+            isSearchActive = isSearchActive,
+            selectionMode = args.selectionMode,
+            eventSink = { event ->
+                when (event) {
+                    is UserListEvents.OnSearchActiveChanged -> isSearchActive = event.active
+                    is UserListEvents.UpdateSearchQuery -> searchQuery = event.query
+                    is UserListEvents.AddToSelection -> userListDataStore.selectUser(event.matrixUser)
+                    is UserListEvents.RemoveFromSelection -> userListDataStore.removeUserFromSelection(event.matrixUser)
+                }
+            },
+        )
+    }
+}

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

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.createroom.impl.userlist
+
+import io.element.android.libraries.matrix.api.user.MatrixUser
+
+sealed interface UserListEvents {
+    data class UpdateSearchQuery(val query: String) : UserListEvents
+    data class AddToSelection(val matrixUser: MatrixUser) : UserListEvents
+    data class RemoveFromSelection(val matrixUser: MatrixUser) : UserListEvents
+    data class OnSearchActiveChanged(val active: Boolean) : UserListEvents
+}

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.createroom.impl.userlist
+
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.usersearch.api.UserRepository
+
+interface UserListPresenter : Presenter<UserListState> {
+
+    interface Factory {
+        fun create(
+            args: UserListPresenterArgs,
+            userRepository: UserRepository,
+            userListDataStore: UserListDataStore,
+        ): UserListPresenter
+    }
+}

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.createroom.impl.userlist
+
+data class UserListPresenterArgs(
+    val selectionMode: SelectionMode,
+)
+
+enum class SelectionMode {
+    Single,
+    Multiple,
+}

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.createroom.impl.userlist
+
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import kotlinx.collections.immutable.ImmutableList
+
+data class UserListState(
+    val searchQuery: String,
+    val searchResults: SearchBarResultState<ImmutableList<MatrixUser>>,
+    val selectedUsers: ImmutableList<MatrixUser>,
+    val isSearchActive: Boolean,
+    val selectionMode: SelectionMode,
+    val eventSink: (UserListEvents) -> Unit,
+) {
+    val isMultiSelectionEnabled = selectionMode == SelectionMode.Multiple
+}

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

@@ -0,0 +1,67 @@
+/*
+ * 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.userlist
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+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>
+        get() = sequenceOf(
+            aUserListState(),
+            aUserListState().copy(
+                isSearchActive = false,
+                selectedUsers = aListOfSelectedUsers(),
+                selectionMode = SelectionMode.Multiple,
+            ),
+            aUserListState().copy(isSearchActive = true),
+            aUserListState().copy(isSearchActive = true, searchQuery = "someone"),
+            aUserListState().copy(isSearchActive = true, searchQuery = "someone", selectionMode = SelectionMode.Multiple),
+            aUserListState().copy(
+                isSearchActive = true,
+                searchQuery = "@someone:matrix.org",
+                selectedUsers = aListOfSelectedUsers(),
+                searchResults = SearchBarResultState.Results(aMatrixUserList().toImmutableList()),
+            ),
+            aUserListState().copy(
+                isSearchActive = true,
+                searchQuery = "@someone:matrix.org",
+                selectionMode = SelectionMode.Multiple,
+                selectedUsers = aListOfSelectedUsers(),
+                searchResults = SearchBarResultState.Results(aMatrixUserList().toImmutableList()),
+            ),
+            aUserListState().copy(
+                isSearchActive = true,
+                searchQuery = "something-with-no-results",
+                searchResults = SearchBarResultState.NoResults()
+            ),
+        )
+}
+
+fun aUserListState() = UserListState(
+    isSearchActive = false,
+    searchQuery = "",
+    searchResults = SearchBarResultState.NotSearching(),
+    selectedUsers = persistentListOf(),
+    selectionMode = SelectionMode.Single,
+    eventSink = {}
+)
+
+fun aListOfSelectedUsers() = aMatrixUserList().take(6).toImmutableList()

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

@@ -1,95 +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.createroom.impl
-
-import com.google.common.truth.Truth
-import io.element.android.libraries.matrix.api.core.UserId
-import io.element.android.libraries.matrix.api.user.MatrixSearchUserResults
-import io.element.android.libraries.matrix.api.user.MatrixUser
-import io.element.android.libraries.matrix.test.AN_AVATAR_URL
-import io.element.android.libraries.matrix.test.A_USER_ID
-import io.element.android.libraries.matrix.test.A_USER_ID_2
-import io.element.android.libraries.matrix.test.A_USER_NAME
-import io.element.android.libraries.matrix.test.FakeMatrixClient
-import kotlinx.coroutines.test.runTest
-import org.junit.Test
-
-internal class AllMatrixUsersDataSourceTest {
-
-    @Test
-    fun `search - returns users on success`() = runTest {
-        val matrixClient = FakeMatrixClient()
-        matrixClient.givenSearchUsersResult(
-            searchTerm = "test",
-            result = Result.success(
-                MatrixSearchUserResults(
-                    results = listOf(aMatrixUserProfile(), aMatrixUserProfile(userId = A_USER_ID_2)),
-                    limited = false
-                )
-            )
-        )
-        val dataSource = AllMatrixUsersDataSource(matrixClient)
-
-        val results = dataSource.search("test")
-        Truth.assertThat(results).containsExactly(aMatrixUserProfile(), aMatrixUserProfile(userId = A_USER_ID_2))
-    }
-
-    @Test
-    fun `search - returns empty list on error`() = runTest {
-        val matrixClient = FakeMatrixClient()
-        matrixClient.givenSearchUsersResult(
-            searchTerm = "test",
-            result = Result.failure(Throwable("Ruhroh"))
-        )
-        val dataSource = AllMatrixUsersDataSource(matrixClient)
-
-        val results = dataSource.search("test")
-        Truth.assertThat(results).isEmpty()
-    }
-
-    @Test
-    fun `get profile - returns user on success`() = runTest {
-        val matrixClient = FakeMatrixClient()
-        matrixClient.givenGetProfileResult(
-            userId = A_USER_ID,
-            result = Result.success(aMatrixUserProfile())
-        )
-        val dataSource = AllMatrixUsersDataSource(matrixClient)
-
-        val result = dataSource.getProfile(A_USER_ID)
-        Truth.assertThat(result).isEqualTo(aMatrixUserProfile())
-    }
-
-    @Test
-    fun `get profile - returns null on error`() = runTest {
-        val matrixClient = FakeMatrixClient()
-        matrixClient.givenGetProfileResult(
-            userId = A_USER_ID,
-            result = Result.failure(Throwable("Ruhroh"))
-        )
-        val dataSource = AllMatrixUsersDataSource(matrixClient)
-
-        val result = dataSource.getProfile(A_USER_ID)
-        Truth.assertThat(result).isNull()
-    }
-
-    private fun aMatrixUserProfile(
-        userId: UserId = A_USER_ID,
-        displayName: String = A_USER_NAME,
-        avatarUrl: String = AN_AVATAR_URL
-    ) = MatrixUser(userId, displayName, avatarUrl)
-}

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

@@ -21,9 +21,9 @@ import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
 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 io.element.android.features.createroom.impl.userlist.FakeUserListPresenterFactory
+import io.element.android.features.createroom.impl.userlist.UserListDataStore
+import io.element.android.libraries.usersearch.test.FakeUserRepository
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
@@ -34,7 +34,11 @@ class AddPeoplePresenterTests {
 
     @Before
     fun setup() {
-        presenter = AddPeoplePresenter(FakeUserListPresenterFactory(), FakeUserListDataSource(), CreateRoomDataStore(UserListDataStore()))
+        presenter = AddPeoplePresenter(
+            FakeUserListPresenterFactory(),
+            FakeUserRepository(),
+            CreateRoomDataStore(UserListDataStore())
+        )
     }
 
     @Test
@@ -42,6 +46,7 @@ class AddPeoplePresenterTests {
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()
         }.test {
+            // TODO This doesn't actually test anything...
             val initialState = awaitItem()
             assertThat(initialState)
         }

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

@@ -24,7 +24,7 @@ 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.createroom.impl.configureroom.avatar.AvatarAction
-import io.element.android.features.userlist.api.UserListDataStore
+import io.element.android.features.createroom.impl.userlist.UserListDataStore
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.test.AN_AVATAR_URL

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

@@ -20,11 +20,10 @@ 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.FakeUserListDataSource
-import io.element.android.features.userlist.test.FakeUserListPresenter
-import io.element.android.features.userlist.test.FakeUserListPresenterFactory
+import io.element.android.features.createroom.impl.userlist.FakeUserListPresenter
+import io.element.android.features.createroom.impl.userlist.FakeUserListPresenterFactory
+import io.element.android.features.createroom.impl.userlist.UserListDataStore
+import io.element.android.features.createroom.impl.userlist.aUserListState
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.UserId
@@ -32,6 +31,7 @@ import io.element.android.libraries.matrix.api.user.MatrixUser
 import io.element.android.libraries.matrix.test.A_THROWABLE
 import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
+import io.element.android.libraries.usersearch.test.FakeUserRepository
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.coroutines.test.runTest
 import org.junit.Before
@@ -39,7 +39,7 @@ import org.junit.Test
 
 class CreateRoomRootPresenterTests {
 
-    private lateinit var userListDataSource: FakeUserListDataSource
+    private lateinit var userRepository: FakeUserRepository
     private lateinit var presenter: CreateRoomRootPresenter
     private lateinit var fakeUserListPresenter: FakeUserListPresenter
     private lateinit var fakeMatrixClient: FakeMatrixClient
@@ -48,8 +48,8 @@ class CreateRoomRootPresenterTests {
     fun setup() {
         fakeUserListPresenter = FakeUserListPresenter()
         fakeMatrixClient = FakeMatrixClient()
-        userListDataSource = FakeUserListDataSource()
-        presenter = CreateRoomRootPresenter(FakeUserListPresenterFactory(fakeUserListPresenter), userListDataSource, UserListDataStore(), fakeMatrixClient)
+        userRepository = FakeUserRepository()
+        presenter = CreateRoomRootPresenter(FakeUserListPresenterFactory(fakeUserListPresenter), userRepository, UserListDataStore(), fakeMatrixClient)
     }
 
     @Test

features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/userlist/DefaultUserListPresenterTests.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.
+ */
+
+package io.element.android.features.createroom.impl.userlist
+
+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.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import io.element.android.libraries.usersearch.test.FakeUserRepository
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class DefaultUserListPresenterTests {
+
+    private val userRepository = FakeUserRepository()
+
+    @Test
+    fun `present - initial state for single selection`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(selectionMode = SelectionMode.Single),
+                userRepository,
+                UserListDataStore(),
+            )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState.searchQuery).isEmpty()
+            assertThat(initialState.isMultiSelectionEnabled).isFalse()
+            assertThat(initialState.isSearchActive).isFalse()
+            assertThat(initialState.selectedUsers).isEmpty()
+            assertThat(initialState.searchResults).isInstanceOf(SearchBarResultState.NotSearching::class.java)
+        }
+    }
+
+    @Test
+    fun `present - initial state for multiple selection`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(selectionMode = SelectionMode.Multiple),
+                userRepository,
+                UserListDataStore(),
+            )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState.searchQuery).isEmpty()
+            assertThat(initialState.isMultiSelectionEnabled).isTrue()
+            assertThat(initialState.isSearchActive).isFalse()
+            assertThat(initialState.selectedUsers).isEmpty()
+            assertThat(initialState.searchResults).isInstanceOf(SearchBarResultState.NotSearching::class.java)
+        }
+    }
+
+    @Test
+    fun `present - update search query`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(selectionMode = SelectionMode.Single),
+                userRepository,
+                UserListDataStore(),
+            )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+
+            initialState.eventSink(UserListEvents.OnSearchActiveChanged(true))
+            assertThat(awaitItem().isSearchActive).isTrue()
+
+            val matrixIdQuery = "@name:matrix.org"
+            initialState.eventSink(UserListEvents.UpdateSearchQuery(matrixIdQuery))
+            assertThat(awaitItem().searchQuery).isEqualTo(matrixIdQuery)
+            assertThat(userRepository.providedQuery).isEqualTo(matrixIdQuery)
+            skipItems(1)
+
+            val notMatrixIdQuery = "name"
+            initialState.eventSink(UserListEvents.UpdateSearchQuery(notMatrixIdQuery))
+            assertThat(awaitItem().searchQuery).isEqualTo(notMatrixIdQuery)
+            assertThat(userRepository.providedQuery).isEqualTo(notMatrixIdQuery)
+            skipItems(1)
+
+            initialState.eventSink(UserListEvents.OnSearchActiveChanged(false))
+            assertThat(awaitItem().isSearchActive).isFalse()
+        }
+    }
+
+    @Test
+    fun `present - presents search results`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(
+                    selectionMode = SelectionMode.Single,
+                ),
+                userRepository,
+                UserListDataStore(),
+            )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+
+            initialState.eventSink(UserListEvents.UpdateSearchQuery("alice"))
+            assertThat(initialState.searchResults).isInstanceOf(SearchBarResultState.NotSearching::class.java)
+            assertThat(userRepository.providedQuery).isEqualTo("alice")
+            skipItems(2)
+
+            // When the user repository emits a result, it's copied to the state
+            userRepository.emitResult(listOf(aMatrixUser()))
+            assertThat(awaitItem().searchResults).isEqualTo(
+                SearchBarResultState.Results(
+                    persistentListOf(aMatrixUser())
+                )
+            )
+
+            // When the user repository emits another result, it replaces the previous value
+            userRepository.emitResult(aMatrixUserList())
+            assertThat(awaitItem().searchResults).isEqualTo(
+                SearchBarResultState.Results(
+                    aMatrixUserList()
+                )
+            )
+        }
+    }
+
+    @Test
+    fun `present - presents search results when not found`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(
+                    selectionMode = SelectionMode.Single,
+                ),
+                userRepository,
+                UserListDataStore(),
+            )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+
+            initialState.eventSink(UserListEvents.UpdateSearchQuery("alice"))
+            assertThat(initialState.searchResults).isInstanceOf(SearchBarResultState.NotSearching::class.java)
+            assertThat(userRepository.providedQuery).isEqualTo("alice")
+            skipItems(2)
+
+            // When the results list is empty, the state is set to NoResults
+            userRepository.emitResult(emptyList())
+            assertThat(awaitItem().searchResults).isInstanceOf(SearchBarResultState.NoResults::class.java)
+        }
+    }
+
+    @Test
+    fun `present - select a user`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(selectionMode = SelectionMode.Single),
+                userRepository,
+                UserListDataStore(),
+            )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+
+            val userA = aMatrixUser("@userA:domain", "A")
+            val userB = aMatrixUser("@userB:domain", "B")
+            val userABis = aMatrixUser("@userA:domain", "A")
+            val userC = aMatrixUser("@userC:domain", "C")
+
+            initialState.eventSink(UserListEvents.AddToSelection(userA))
+            assertThat(awaitItem().selectedUsers).containsExactly(userA)
+
+            initialState.eventSink(UserListEvents.AddToSelection(userB))
+            assertThat(awaitItem().selectedUsers).containsExactly(userA, userB)
+
+            initialState.eventSink(UserListEvents.AddToSelection(userABis))
+            initialState.eventSink(UserListEvents.AddToSelection(userC))
+            // duplicated users should be ignored
+            assertThat(awaitItem().selectedUsers).containsExactly(userA, userB, userC)
+
+            initialState.eventSink(UserListEvents.RemoveFromSelection(userB))
+            assertThat(awaitItem().selectedUsers).containsExactly(userA, userC)
+            initialState.eventSink(UserListEvents.RemoveFromSelection(userA))
+            assertThat(awaitItem().selectedUsers).containsExactly(userC)
+            initialState.eventSink(UserListEvents.RemoveFromSelection(userC))
+            assertThat(awaitItem().selectedUsers).isEmpty()
+        }
+    }
+}

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

@@ -14,22 +14,20 @@
  * limitations under the License.
  */
 
-package io.element.android.features.createroom.impl.di
+package io.element.android.features.createroom.impl.userlist
 
-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.UserListDataSource
-import io.element.android.libraries.di.SessionScope
-import javax.inject.Named
+import androidx.compose.runtime.Composable
 
-@Module
-@ContributesTo(SessionScope::class)
-interface CreateRoomModule {
+class FakeUserListPresenter : UserListPresenter {
 
-    @Binds
-    @Named("AllUsers")
-    fun bindAllUserListDataSource(dataSource: AllMatrixUsersDataSource): UserListDataSource
+    private var state = aUserListState()
 
+    fun givenState(state: UserListState) {
+        this.state = state
+    }
+
+    @Composable
+    override fun present(): UserListState {
+        return state
+    }
 }

features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/userlist/FakeUserListPresenterFactory.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.userlist
+
+import io.element.android.libraries.usersearch.api.UserRepository
+
+class FakeUserListPresenterFactory(
+    private val fakeUserListPresenter: FakeUserListPresenter = FakeUserListPresenter()
+) : UserListPresenter.Factory {
+
+    override fun create(
+        args: UserListPresenterArgs,
+        userRepository: UserRepository,
+        userListDataStore: UserListDataStore,
+    ): UserListPresenter = fakeUserListPresenter
+}