First Commit

features/invitepeople/impl/build.gradle.kts

@@ -0,0 +1,46 @@
+import extension.setupDependencyInjection
+import extension.testCommonDependencies
+
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2022-2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+    id("kotlin-parcelize")
+}
+
+android {
+    namespace = "io.element.android.features.invitepeople.impl"
+
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+        }
+    }
+}
+
+setupDependencyInjection()
+
+dependencies {
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.matrixui)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.uiStrings)
+    implementation(projects.libraries.androidutils)
+    implementation(projects.libraries.usersearch.impl)
+    implementation(libs.coil.compose)
+    implementation(projects.services.apperror.api)
+    api(projects.features.invitepeople.api)
+
+    testCommonDependencies(libs, true)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.libraries.usersearch.test)
+    testImplementation(projects.services.apperror.test)
+}

features/invitepeople/impl/src/main/kotlin/io/element/android/features/invitepeople/impl/DefaultInvitePeopleEvents.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.invitepeople.impl
+
+import io.element.android.features.invitepeople.api.InvitePeopleEvents
+import io.element.android.libraries.matrix.api.user.MatrixUser
+
+sealed interface DefaultInvitePeopleEvents : InvitePeopleEvents {
+    data class ToggleUser(val user: MatrixUser) : DefaultInvitePeopleEvents
+    data class UpdateSearchQuery(val query: String) : DefaultInvitePeopleEvents
+    data class OnSearchActiveChanged(val active: Boolean) : DefaultInvitePeopleEvents
+}

features/invitepeople/impl/src/main/kotlin/io/element/android/features/invitepeople/impl/DefaultInvitePeoplePresenter.kt

@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.invitepeople.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.AssistedFactory
+import dev.zacsweers.metro.AssistedInject
+import dev.zacsweers.metro.ContributesBinding
+import io.element.android.features.invitepeople.api.InvitePeopleEvents
+import io.element.android.features.invitepeople.api.InvitePeoplePresenter
+import io.element.android.features.invitepeople.api.InvitePeopleState
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.architecture.map
+import io.element.android.libraries.architecture.runCatchingUpdatingState
+import io.element.android.libraries.architecture.runUpdatingState
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.di.annotations.SessionCoroutineScope
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.JoinedRoom
+import io.element.android.libraries.matrix.api.room.RoomMember
+import io.element.android.libraries.matrix.api.room.RoomMembershipState
+import io.element.android.libraries.matrix.api.room.filterMembers
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.ui.strings.CommonStrings
+import io.element.android.libraries.usersearch.api.UserRepository
+import io.element.android.services.apperror.api.AppErrorStateService
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+@AssistedInject
+class DefaultInvitePeoplePresenter(
+    @Assisted private val joinedRoom: JoinedRoom?,
+    @Assisted private val roomId: RoomId,
+    private val userRepository: UserRepository,
+    private val coroutineDispatchers: CoroutineDispatchers,
+    @SessionCoroutineScope private val sessionCoroutineScope: CoroutineScope,
+    private val appErrorStateService: AppErrorStateService,
+    private val matrixClient: MatrixClient,
+) : InvitePeoplePresenter {
+    @AssistedFactory
+    @ContributesBinding(SessionScope::class)
+    interface Factory : InvitePeoplePresenter.Factory {
+        override fun create(joinedRoom: JoinedRoom?, roomId: RoomId): DefaultInvitePeoplePresenter
+    }
+
+    @Composable
+    override fun present(): InvitePeopleState {
+        val roomMembers = remember { mutableStateOf<AsyncData<ImmutableList<RoomMember>>>(AsyncData.Loading()) }
+        val selectedUsers = remember { mutableStateOf<ImmutableList<MatrixUser>>(persistentListOf()) }
+        val searchResults = remember { mutableStateOf<SearchBarResultState<ImmutableList<InvitableUser>>>(SearchBarResultState.Initial()) }
+        var searchQuery by rememberSaveable { mutableStateOf("") }
+        var searchActive by rememberSaveable { mutableStateOf(false) }
+        val showSearchLoader = rememberSaveable { mutableStateOf(false) }
+        val sendInvitesAction = remember { mutableStateOf<AsyncAction<Unit>>(AsyncAction.Uninitialized) }
+
+        val room by produceState(if (joinedRoom != null) AsyncData.Success(joinedRoom) else AsyncData.Loading()) {
+            if (joinedRoom == null) {
+                val result = matrixClient.getJoinedRoom(roomId)
+                value = if (result == null) {
+                    AsyncData.Failure(Exception("Room not found"))
+                } else {
+                    AsyncData.Success(result)
+                }
+            }
+        }
+
+        LaunchedEffect(room.isSuccess()) {
+            room.dataOrNull()?.let {
+                fetchMembers(it, roomMembers)
+            }
+        }
+        LaunchedEffect(searchQuery, roomMembers) {
+            performSearch(
+                searchResults = searchResults,
+                roomMembers = roomMembers,
+                selectedUsers = selectedUsers,
+                showSearchLoader = showSearchLoader,
+                searchQuery = searchQuery
+            )
+        }
+
+        fun handleEvent(event: InvitePeopleEvents) {
+            when (event) {
+                is DefaultInvitePeopleEvents.OnSearchActiveChanged -> {
+                    searchActive = event.active
+                    searchQuery = ""
+                }
+
+                is DefaultInvitePeopleEvents.UpdateSearchQuery -> {
+                    searchQuery = event.query
+                }
+
+                is DefaultInvitePeopleEvents.ToggleUser -> {
+                    selectedUsers.toggleUser(event.user)
+                    searchResults.toggleUser(event.user)
+                }
+                is InvitePeopleEvents.SendInvites -> {
+                    room.dataOrNull()?.let {
+                        sessionCoroutineScope.sendInvites(it, selectedUsers.value, sendInvitesAction)
+                    }
+                }
+                is InvitePeopleEvents.CloseSearch -> {
+                    searchActive = false
+                    searchQuery = ""
+                }
+            }
+        }
+
+        return DefaultInvitePeopleState(
+            room = room.map { },
+            canInvite = selectedUsers.value.isNotEmpty() && !sendInvitesAction.value.isLoading(),
+            selectedUsers = selectedUsers.value,
+            searchQuery = searchQuery,
+            isSearchActive = searchActive,
+            searchResults = searchResults.value,
+            showSearchLoader = showSearchLoader.value,
+            sendInvitesAction = sendInvitesAction.value,
+            eventSink = ::handleEvent,
+        )
+    }
+
+    private fun CoroutineScope.sendInvites(
+        room: JoinedRoom,
+        selectedUsers: List<MatrixUser>,
+        sendInvitesAction: MutableState<AsyncAction<Unit>>,
+    ) = launch {
+        sendInvitesAction.runUpdatingState {
+            val anyInviteFailed = selectedUsers
+                .map { room.inviteUserById(it.userId) }
+                .any { it.isFailure }
+
+            if (anyInviteFailed) {
+                appErrorStateService.showError(
+                    titleRes = CommonStrings.common_unable_to_invite_title,
+                    bodyRes = CommonStrings.common_unable_to_invite_message,
+                )
+            }
+
+            Result.success(Unit)
+        }
+    }
+
+    @JvmName("toggleUserInSelectedUsers")
+    private fun MutableState<ImmutableList<MatrixUser>>.toggleUser(user: MatrixUser) {
+        value = if (value.contains(user)) {
+            value.filterNot { it.userId == user.userId }
+        } else {
+            value + user
+        }.toImmutableList()
+    }
+
+    @JvmName("toggleUserInSearchResults")
+    private fun MutableState<SearchBarResultState<ImmutableList<InvitableUser>>>.toggleUser(user: MatrixUser) {
+        val existingResults = value
+        if (existingResults is SearchBarResultState.Results) {
+            value = SearchBarResultState.Results(
+                existingResults.results.map { iu ->
+                    if (iu.matrixUser == user) {
+                        iu.copy(isSelected = !iu.isSelected)
+                    } else {
+                        iu
+                    }
+                }.toImmutableList()
+            )
+        }
+    }
+
+    private suspend fun performSearch(
+        searchResults: MutableState<SearchBarResultState<ImmutableList<InvitableUser>>>,
+        roomMembers: MutableState<AsyncData<ImmutableList<RoomMember>>>,
+        selectedUsers: MutableState<ImmutableList<MatrixUser>>,
+        showSearchLoader: MutableState<Boolean>,
+        searchQuery: String,
+    ) = withContext(coroutineDispatchers.io) {
+        searchResults.value = SearchBarResultState.Initial()
+        showSearchLoader.value = false
+        val joinedMembers = roomMembers.value.dataOrNull().orEmpty()
+
+        userRepository.search(searchQuery).onEach { state ->
+            showSearchLoader.value = state.isSearching
+            searchResults.value = when {
+                state.results.isEmpty() && state.isSearching -> SearchBarResultState.Initial()
+                state.results.isEmpty() && !state.isSearching -> SearchBarResultState.NoResultsFound()
+                else -> SearchBarResultState.Results(state.results.map { result ->
+                    val existingMembership = joinedMembers.firstOrNull { j -> j.userId == result.matrixUser.userId }?.membership
+                    val isJoined = existingMembership == RoomMembershipState.JOIN
+                    val isInvited = existingMembership == RoomMembershipState.INVITE
+                    InvitableUser(
+                        matrixUser = result.matrixUser,
+                        isSelected = selectedUsers.value.contains(result.matrixUser),
+                        isAlreadyJoined = isJoined,
+                        isAlreadyInvited = isInvited,
+                        isUnresolved = result.isUnresolved,
+                    )
+                }.toImmutableList())
+            }
+        }.launchIn(this)
+    }
+
+    private suspend fun fetchMembers(
+        room: JoinedRoom,
+        roomMembers: MutableState<AsyncData<ImmutableList<RoomMember>>>
+    ) {
+        suspend {
+            room.filterMembers("", coroutineDispatchers.io).toImmutableList()
+        }.runCatchingUpdatingState(roomMembers)
+    }
+}

features/invitepeople/impl/src/main/kotlin/io/element/android/features/invitepeople/impl/DefaultInvitePeopleRenderer.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.invitepeople.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import dev.zacsweers.metro.ContributesBinding
+import io.element.android.features.invitepeople.api.InvitePeopleRenderer
+import io.element.android.features.invitepeople.api.InvitePeopleState
+import io.element.android.libraries.di.SessionScope
+
+@ContributesBinding(SessionScope::class)
+class DefaultInvitePeopleRenderer : InvitePeopleRenderer {
+    @Composable
+    override fun Render(state: InvitePeopleState, modifier: Modifier) {
+        if (state is DefaultInvitePeopleState) {
+            InvitePeopleView(
+                state = state,
+                modifier = modifier
+            )
+        } else {
+            error("Unsupported state type: ${state::javaClass}")
+        }
+    }
+}

features/invitepeople/impl/src/main/kotlin/io/element/android/features/invitepeople/impl/DefaultInvitePeopleState.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.invitepeople.impl
+
+import io.element.android.features.invitepeople.api.InvitePeopleEvents
+import io.element.android.features.invitepeople.api.InvitePeopleState
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.architecture.AsyncData
+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 DefaultInvitePeopleState(
+    val room: AsyncData<Unit>,
+    override val canInvite: Boolean,
+    val searchQuery: String,
+    val showSearchLoader: Boolean,
+    val searchResults: SearchBarResultState<ImmutableList<InvitableUser>>,
+    val selectedUsers: ImmutableList<MatrixUser>,
+    override val isSearchActive: Boolean,
+    override val sendInvitesAction: AsyncAction<Unit>,
+    override val eventSink: (InvitePeopleEvents) -> Unit
+) : InvitePeopleState

features/invitepeople/impl/src/main/kotlin/io/element/android/features/invitepeople/impl/DefaultInvitePeopleStateProvider.kt

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.invitepeople.impl
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.architecture.AsyncData
+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.aMatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
+
+internal class DefaultInvitePeopleStateProvider : PreviewParameterProvider<DefaultInvitePeopleState> {
+    override val values: Sequence<DefaultInvitePeopleState>
+        get() = sequenceOf(
+            aDefaultInvitePeopleState(),
+            aDefaultInvitePeopleState(canInvite = true, selectedUsers = aMatrixUserList().toImmutableList()),
+            aDefaultInvitePeopleState(isSearchActive = true, searchQuery = "some query"),
+            aDefaultInvitePeopleState(isSearchActive = true, searchQuery = "some query", selectedUsers = aMatrixUserList().toImmutableList()),
+            aDefaultInvitePeopleState(isSearchActive = true, searchQuery = "some query", searchResults = SearchBarResultState.NoResultsFound()),
+            aDefaultInvitePeopleState(
+                isSearchActive = true,
+                canInvite = true,
+                searchQuery = "some query",
+                selectedUsers = persistentListOf(
+                    aMatrixUser("@carol:server.org", "Carol")
+                ),
+                searchResults = SearchBarResultState.Results(
+                    persistentListOf(
+                        anInvitableUser(aMatrixUser("@alice:server.org")),
+                        anInvitableUser(aMatrixUser("@bob:server.org", "Bob")),
+                        anInvitableUser(aMatrixUser("@carol:server.org", "Carol"), isSelected = true),
+                        anInvitableUser(aMatrixUser("@eve:server.org", "Eve"), isSelected = true, isAlreadyJoined = true),
+                        anInvitableUser(aMatrixUser("@justin:server.org", "Justin"), isSelected = true, isAlreadyInvited = true),
+                    )
+                )
+            ),
+            aDefaultInvitePeopleState(
+                isSearchActive = true,
+                canInvite = true,
+                searchQuery = "@alice:server.org",
+                selectedUsers = persistentListOf(
+                    aMatrixUser("@carol:server.org", "Carol")
+                ),
+                searchResults = SearchBarResultState.Results(
+                    persistentListOf(
+                        anInvitableUser(aMatrixUser("@alice:server.org"), isUnresolved = true),
+                        anInvitableUser(aMatrixUser("@bob:server.org", "Bob")),
+                    )
+                )
+            ),
+            aDefaultInvitePeopleState(
+                isSearchActive = true,
+                canInvite = true,
+                searchQuery = "@alice:server.org",
+                searchResults = SearchBarResultState.Results(
+                    persistentListOf(
+                        anInvitableUser(aMatrixUser("@alice:server.org"), isUnresolved = true),
+                    )
+                ),
+                showSearchLoader = true,
+            ),
+            aDefaultInvitePeopleState(room = AsyncData.Failure(Exception("Room not found"))),
+            aDefaultInvitePeopleState(
+                canInvite = false,
+                selectedUsers = aMatrixUserList().toImmutableList(),
+                sendInvitesAction = AsyncAction.Loading,
+            ),
+        )
+}
+
+private fun anInvitableUser(
+    matrixUser: MatrixUser,
+    isSelected: Boolean = false,
+    isAlreadyJoined: Boolean = false,
+    isAlreadyInvited: Boolean = false,
+    isUnresolved: Boolean = false,
+) = InvitableUser(
+    matrixUser = matrixUser,
+    isSelected = isSelected,
+    isAlreadyJoined = isAlreadyJoined,
+    isAlreadyInvited = isAlreadyInvited,
+    isUnresolved = isUnresolved,
+)
+
+private fun aDefaultInvitePeopleState(
+    room: AsyncData<Unit> = AsyncData.Success(Unit),
+    canInvite: Boolean = false,
+    searchQuery: String = "",
+    searchResults: SearchBarResultState<ImmutableList<InvitableUser>> = SearchBarResultState.Initial(),
+    selectedUsers: ImmutableList<MatrixUser> = persistentListOf(),
+    isSearchActive: Boolean = false,
+    showSearchLoader: Boolean = false,
+    sendInvitesAction: AsyncAction<Unit> = AsyncAction.Uninitialized,
+): DefaultInvitePeopleState {
+    return DefaultInvitePeopleState(
+        room = room,
+        canInvite = canInvite,
+        searchQuery = searchQuery,
+        searchResults = searchResults,
+        selectedUsers = selectedUsers,
+        isSearchActive = isSearchActive,
+        showSearchLoader = showSearchLoader,
+        sendInvitesAction = sendInvitesAction,
+        eventSink = {},
+    )
+}

features/invitepeople/impl/src/main/kotlin/io/element/android/features/invitepeople/impl/InvitableUser.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.invitepeople.impl
+
+import io.element.android.libraries.matrix.api.user.MatrixUser
+
+data class InvitableUser(
+    val matrixUser: MatrixUser,
+    val isSelected: Boolean,
+    val isAlreadyJoined: Boolean,
+    val isAlreadyInvited: Boolean,
+    val isUnresolved: Boolean,
+)

features/invitepeople/impl/src/main/kotlin/io/element/android/features/invitepeople/impl/InvitePeopleView.kt

@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.invitepeople.impl
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.material3.ExperimentalMaterial3Api
+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.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.compound.theme.ElementTheme
+import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.designsystem.components.async.AsyncFailure
+import io.element.android.libraries.designsystem.components.async.AsyncLoading
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.components.SearchBar
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.CheckableUserRow
+import io.element.android.libraries.matrix.ui.components.CheckableUserRowData
+import io.element.android.libraries.matrix.ui.components.SelectedUsersRowList
+import io.element.android.libraries.matrix.ui.model.getAvatarData
+import io.element.android.libraries.matrix.ui.model.getBestName
+import io.element.android.libraries.ui.strings.CommonStrings
+import kotlinx.collections.immutable.ImmutableList
+
+@Composable
+fun InvitePeopleView(
+    state: DefaultInvitePeopleState,
+    modifier: Modifier = Modifier,
+) {
+    when (state.room) {
+        is AsyncData.Failure -> InvitePeopleViewError(state.room.error, modifier)
+        AsyncData.Uninitialized,
+        is AsyncData.Loading,
+        is AsyncData.Success -> InvitePeopleContentView(state, modifier)
+    }
+}
+
+@Composable
+private fun InvitePeopleViewError(
+    error: Throwable,
+    modifier: Modifier = Modifier,
+) {
+    Box(
+        modifier = modifier.fillMaxSize(),
+        contentAlignment = Alignment.Center,
+    ) {
+        AsyncFailure(
+            throwable = error,
+            onRetry = null,
+            modifier = Modifier.padding(horizontal = 16.dp),
+        )
+    }
+}
+
+@Composable
+private fun InvitePeopleContentView(
+    state: DefaultInvitePeopleState,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier.fillMaxSize(),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        InvitePeopleSearchBar(
+            modifier = Modifier.fillMaxWidth(),
+            query = state.searchQuery,
+            showLoader = state.showSearchLoader,
+            selectedUsers = state.selectedUsers,
+            state = state.searchResults,
+            active = state.isSearchActive,
+            onActiveChange = {
+                state.eventSink(
+                    DefaultInvitePeopleEvents.OnSearchActiveChanged(
+                        it
+                    )
+                )
+            },
+            onTextChange = { state.eventSink(DefaultInvitePeopleEvents.UpdateSearchQuery(it)) },
+            onToggleUser = { state.eventSink(DefaultInvitePeopleEvents.ToggleUser(it)) },
+        )
+
+        if (!state.isSearchActive) {
+            SelectedUsersRowList(
+                modifier = Modifier.fillMaxWidth(),
+                selectedUsers = state.selectedUsers,
+                autoScroll = true,
+                onUserRemove = { state.eventSink(DefaultInvitePeopleEvents.ToggleUser(it)) },
+                contentPadding = PaddingValues(16.dp),
+            )
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun InvitePeopleSearchBar(
+    query: String,
+    state: SearchBarResultState<ImmutableList<InvitableUser>>,
+    showLoader: Boolean,
+    selectedUsers: ImmutableList<MatrixUser>,
+    active: Boolean,
+    onActiveChange: (Boolean) -> Unit,
+    onTextChange: (String) -> Unit,
+    onToggleUser: (MatrixUser) -> Unit,
+    modifier: Modifier = Modifier,
+    placeHolderTitle: String = stringResource(CommonStrings.common_search_for_someone),
+) {
+    SearchBar(
+        query = query,
+        onQueryChange = onTextChange,
+        active = active,
+        onActiveChange = onActiveChange,
+        modifier = modifier,
+        placeHolderTitle = placeHolderTitle,
+        contentPrefix = {
+            if (selectedUsers.isNotEmpty()) {
+                SelectedUsersRowList(
+                    modifier = Modifier.fillMaxWidth(),
+                    selectedUsers = selectedUsers,
+                    autoScroll = true,
+                    onUserRemove = onToggleUser,
+                    contentPadding = PaddingValues(16.dp),
+                )
+            }
+        },
+        showBackButton = false,
+        resultState = state,
+        contentSuffix = {
+            if (showLoader) {
+                AsyncLoading()
+            }
+        },
+        resultHandler = { results ->
+            Text(
+                text = stringResource(id = CommonStrings.common_search_results),
+                style = ElementTheme.typography.fontBodyLgMedium,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(start = 16.dp, top = 12.dp, end = 16.dp, bottom = 8.dp)
+            )
+
+            LazyColumn {
+                itemsIndexed(results) { index, invitableUser ->
+                    val invitedOrJoined = invitableUser.isAlreadyInvited || invitableUser.isAlreadyJoined
+                    val isUnresolved = invitableUser.isUnresolved && !invitedOrJoined
+                    val enabled = isUnresolved || !invitedOrJoined
+                    val data = if (isUnresolved) {
+                        CheckableUserRowData.Unresolved(
+                            avatarData = invitableUser.matrixUser.getAvatarData(AvatarSize.UserListItem),
+                            id = invitableUser.matrixUser.userId.value,
+                        )
+                    } else {
+                        CheckableUserRowData.Resolved(
+                            avatarData = invitableUser.matrixUser.getAvatarData(AvatarSize.UserListItem),
+                            name = invitableUser.matrixUser.getBestName(),
+                            subtext = when {
+                                // If they're already invited or joined we show that information
+                                invitableUser.isAlreadyJoined -> stringResource(R.string.screen_invite_users_already_a_member)
+                                invitableUser.isAlreadyInvited -> stringResource(R.string.screen_invite_users_already_invited)
+                                // Otherwise show the ID, unless that's already used for their name
+                                invitableUser.matrixUser.displayName.isNullOrEmpty()
+                                    .not() -> invitableUser.matrixUser.userId.value
+                                else -> null
+                            }
+                        )
+                    }
+                    CheckableUserRow(
+                        checked = invitableUser.isSelected || invitedOrJoined,
+                        enabled = enabled,
+                        data = data,
+                        onCheckedChange = { onToggleUser(invitableUser.matrixUser) },
+                        modifier = Modifier.fillMaxWidth()
+                    )
+                }
+            }
+        },
+    )
+}
+
+@PreviewsDayNight
+@Composable
+internal fun InvitePeopleViewPreview(@PreviewParameter(DefaultInvitePeopleStateProvider::class) state: DefaultInvitePeopleState) =
+    ElementPreview {
+        InvitePeopleView(state = state)
+    }

features/invitepeople/impl/src/main/res/values-be/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Ужо ўдзельнік"</string>
+  <string name="screen_invite_users_already_invited">"Ужо запрасілі"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-bg/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Вече е член"</string>
+  <string name="screen_invite_users_already_invited">"Вече е бил поканен"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-cs/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Již členem"</string>
+  <string name="screen_invite_users_already_invited">"Již pozván(a)"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-cy/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Eisoes yn aelod"</string>
+  <string name="screen_invite_users_already_invited">"Wedi gwahodd yn barod"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-da/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Allerede medlem"</string>
+  <string name="screen_invite_users_already_invited">"Allerede inviteret"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-de/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Bereits Mitglied"</string>
+  <string name="screen_invite_users_already_invited">"Bereits eingeladen"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-el/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Ήδη μέλος"</string>
+  <string name="screen_invite_users_already_invited">"Ήδη προσκεκλημένος"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-es/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Ya eres miembro"</string>
+  <string name="screen_invite_users_already_invited">"Ya estás invitado"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-et/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Sa juba oled jututoa liige"</string>
+  <string name="screen_invite_users_already_invited">"Sa juba oled kutse saanud"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-eu/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Kidea da dagoeneko"</string>
+  <string name="screen_invite_users_already_invited">"Lehendik ere gonbidatuta"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-fa/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"از پیش عضو است"</string>
+  <string name="screen_invite_users_already_invited">"از پیش دعوت شده"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-fi/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"On jo jäsen"</string>
+  <string name="screen_invite_users_already_invited">"On jo kutsuttu"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-fr/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Déjà membre"</string>
+  <string name="screen_invite_users_already_invited">"Déjà invité(e)"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-hu/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Már tag"</string>
+  <string name="screen_invite_users_already_invited">"Már meghívták"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-in/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Sudah menjadi anggota"</string>
+  <string name="screen_invite_users_already_invited">"Sudah diundang"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-it/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Già membro"</string>
+  <string name="screen_invite_users_already_invited">"Già invitato"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-ka/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"უკვე წევრია"</string>
+  <string name="screen_invite_users_already_invited">"უკვე მოწვეულია"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-ko/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"이미 회원"</string>
+  <string name="screen_invite_users_already_invited">"이미 초대됨"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-lt/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Jau narys"</string>
+  <string name="screen_invite_users_already_invited">"Jau pakviestas"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-nb/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Allerede medlem"</string>
+  <string name="screen_invite_users_already_invited">"Allerede invitert"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-nl/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Reeds lid"</string>
+  <string name="screen_invite_users_already_invited">"Reeds uitgenodigd"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-pl/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Jest już członkiem"</string>
+  <string name="screen_invite_users_already_invited">"Już zaproszony"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-pt-rBR/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Já é membro"</string>
+  <string name="screen_invite_users_already_invited">"Já foi convidado"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-pt/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Já é participante"</string>
+  <string name="screen_invite_users_already_invited">"Já foi convidado"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-ro/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Deja membru"</string>
+  <string name="screen_invite_users_already_invited">"Deja invitat"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-ru/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Уже зарегистрирован"</string>
+  <string name="screen_invite_users_already_invited">"Уже приглашены"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-sk/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Už ste členom"</string>
+  <string name="screen_invite_users_already_invited">"Už ste pozvaní"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-sv/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Redan medlem"</string>
+  <string name="screen_invite_users_already_invited">"Redan inbjuden"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-tr/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Zaten üye"</string>
+  <string name="screen_invite_users_already_invited">"Zaten davet edildi"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-uk/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Уже учасник"</string>
+  <string name="screen_invite_users_already_invited">"Уже запрошені"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-ur/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"پہلے سے ہی رکن"</string>
+  <string name="screen_invite_users_already_invited">"پہلے سے مدعو شدہ"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-uz/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Allaqachon a\'zo"</string>
+  <string name="screen_invite_users_already_invited">"Allaqachon taklif qilingan"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-zh-rTW/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"已是成員"</string>
+  <string name="screen_invite_users_already_invited">"已邀請"</string>
+</resources>

features/invitepeople/impl/src/main/res/values-zh/translations.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"已经是成员"</string>
+  <string name="screen_invite_users_already_invited">"已邀请"</string>
+</resources>

features/invitepeople/impl/src/main/res/values/localazy.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_invite_users_already_a_member">"Already a member"</string>
+  <string name="screen_invite_users_already_invited">"Already invited"</string>
+</resources>

features/invitepeople/impl/src/test/kotlin/io/element/android/features/invitepeople/impl/DefaultInvitePeoplePresenterTest.kt

@@ -0,0 +1,574 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.invitepeople.impl
+
+import app.cash.turbine.ReceiveTurbine
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.invitepeople.api.InvitePeopleEvents
+import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.api.room.JoinedRoom
+import io.element.android.libraries.matrix.api.room.RoomMembersState
+import io.element.android.libraries.matrix.api.room.RoomMembershipState
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+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.FakeMatrixClient
+import io.element.android.libraries.matrix.test.room.FakeJoinedRoom
+import io.element.android.libraries.matrix.test.room.aRoomMember
+import io.element.android.libraries.matrix.test.room.aRoomMemberList
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import io.element.android.libraries.ui.strings.CommonStrings
+import io.element.android.libraries.usersearch.api.UserRepository
+import io.element.android.libraries.usersearch.api.UserSearchResult
+import io.element.android.libraries.usersearch.api.UserSearchResultState
+import io.element.android.libraries.usersearch.test.FakeUserRepository
+import io.element.android.services.apperror.api.AppErrorStateService
+import io.element.android.services.apperror.test.FakeAppErrorStateService
+import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.lambda.lambdaError
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.lambda.value
+import io.element.android.tests.testutils.test
+import io.element.android.tests.testutils.testCoroutineDispatchers
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+internal class DefaultInvitePeoplePresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - initial state has no results and no search`() = runTest {
+        val presenter = createDefaultInvitePeoplePresenter()
+        presenter.test {
+            val initialState = awaitItemAsDefault()
+            assertThat(initialState.room).isEqualTo(AsyncData.Success(Unit))
+            assertThat(initialState.searchResults).isInstanceOf(SearchBarResultState.Initial::class.java)
+            assertThat(initialState.isSearchActive).isFalse()
+            assertThat(initialState.canInvite).isFalse()
+            assertThat(initialState.searchQuery).isEmpty()
+
+            skipItems(1)
+        }
+    }
+
+    @Test
+    fun `present - updates search active state`() = runTest {
+        val presenter = createDefaultInvitePeoplePresenter()
+        presenter.test {
+            val initialState = awaitItem()
+            skipItems(1)
+
+            initialState.eventSink(DefaultInvitePeopleEvents.OnSearchActiveChanged(true))
+
+            val resultState = awaitItem()
+            assertThat(resultState.isSearchActive).isTrue()
+            resultState.eventSink(DefaultInvitePeopleEvents.UpdateSearchQuery("some query"))
+            assertThat(awaitItemAsDefault().searchQuery).isEqualTo("some query")
+            resultState.eventSink(InvitePeopleEvents.CloseSearch)
+            skipItems(1)
+            awaitItemAsDefault().also {
+                assertThat(it.isSearchActive).isFalse()
+                assertThat(it.searchQuery).isEmpty()
+            }
+        }
+    }
+
+    @Test
+    fun `present - performs search and handles empty result list`() = runTest {
+        val repository = FakeUserRepository()
+        val presenter = createDefaultInvitePeoplePresenter(
+            userRepository = repository,
+            coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true)
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            initialState.eventSink(DefaultInvitePeopleEvents.UpdateSearchQuery("some query"))
+            assertThat(repository.providedQuery).isEqualTo("some query")
+            repository.emitState(UserSearchResultState(results = emptyList(), isSearching = true))
+            skipItems(3)
+            awaitItemAsDefault().also { state ->
+                assertThat(state.searchResults).isInstanceOf(SearchBarResultState.Initial::class.java)
+                assertThat(state.showSearchLoader).isTrue()
+            }
+            repository.emitState(results = emptyList(), isSearching = false)
+            awaitItemAsDefault().also { state ->
+                assertThat(state.searchResults).isInstanceOf(SearchBarResultState.NoResultsFound::class.java)
+                assertThat(state.showSearchLoader).isFalse()
+            }
+        }
+    }
+
+    @Test
+    fun `present - performs search and handles user results`() = runTest {
+        val repository = FakeUserRepository()
+        val presenter = createDefaultInvitePeoplePresenter(
+            userRepository = repository,
+            coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true)
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            skipItems(1)
+
+            initialState.eventSink(DefaultInvitePeopleEvents.UpdateSearchQuery("some query"))
+            skipItems(1)
+
+            assertThat(repository.providedQuery).isEqualTo("some query")
+            repository.emitStateWithUsers(users = aMatrixUserList())
+            skipItems(1)
+
+            val resultState = awaitItemAsDefault()
+            assertThat(resultState.searchResults).isInstanceOf(SearchBarResultState.Results::class.java)
+
+            val expectedUsers = aMatrixUserList()
+            val users = resultState.searchResults.users()
+            expectedUsers.forEachIndexed { index, matrixUser ->
+                assertThat(users[index].matrixUser).isEqualTo(matrixUser)
+                // All users are joined or invited
+                if (users[index].isAlreadyInvited) {
+                    assertThat(users[index].isAlreadyJoined).isFalse()
+                } else {
+                    assertThat(users[index].isAlreadyJoined).isTrue()
+                }
+                assertThat(users[index].isSelected).isFalse()
+            }
+        }
+    }
+
+    @Test
+    fun `present - performs search and handles membership state of existing users`() = runTest {
+        val userList = aMatrixUserList()
+        val joinedUser = userList[0]
+        val invitedUser = userList[1]
+
+        val repository = FakeUserRepository()
+        val coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true)
+        val presenter = createDefaultInvitePeoplePresenter(
+            userRepository = repository,
+            roomMembersState = RoomMembersState.Ready(
+                persistentListOf(
+                    aRoomMember(
+                        userId = joinedUser.userId,
+                        membership = RoomMembershipState.JOIN
+                    ),
+                    aRoomMember(
+                        userId = invitedUser.userId,
+                        membership = RoomMembershipState.INVITE
+                    ),
+                )
+            ),
+            coroutineDispatchers = coroutineDispatchers,
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            skipItems(1)
+
+            initialState.eventSink(DefaultInvitePeopleEvents.UpdateSearchQuery("some query"))
+            skipItems(1)
+
+            assertThat(repository.providedQuery).isEqualTo("some query")
+            repository.emitStateWithUsers(users = aMatrixUserList())
+            skipItems(1)
+
+            val resultState = awaitItemAsDefault()
+            assertThat(resultState.searchResults).isInstanceOf(SearchBarResultState.Results::class.java)
+
+            val users = resultState.searchResults.users()
+
+            // The result that matches a user with JOINED membership is marked as such
+            val userWhoShouldBeJoined = users.find { it.matrixUser == joinedUser }
+            assertThat(userWhoShouldBeJoined).isNotNull()
+            assertThat(userWhoShouldBeJoined?.isAlreadyJoined).isTrue()
+            assertThat(userWhoShouldBeJoined?.isAlreadyInvited).isFalse()
+
+            // The result that matches a user with INVITED membership is marked as such
+            val userWhoShouldBeInvited = users.find { it.matrixUser == invitedUser }
+            assertThat(userWhoShouldBeInvited).isNotNull()
+            assertThat(userWhoShouldBeInvited?.isAlreadyJoined).isFalse()
+            assertThat(userWhoShouldBeInvited?.isAlreadyInvited).isTrue()
+
+            // All other users are neither joined nor invited
+            val otherUsers = users.minus(userWhoShouldBeInvited!!).minus(userWhoShouldBeJoined!!)
+            assertThat(otherUsers.none { it.isAlreadyInvited }).isTrue()
+            assertThat(otherUsers.none { it.isAlreadyJoined }).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - performs search and handles unresolved results`() = runTest {
+        val userList = aMatrixUserList()
+        val joinedUser = userList[0]
+        val invitedUser = userList[1]
+
+        val repository = FakeUserRepository()
+        val presenter = createDefaultInvitePeoplePresenter(
+            userRepository = repository,
+            roomMembersState =
+                RoomMembersState.Ready(
+                    persistentListOf(
+                        aRoomMember(
+                            userId = joinedUser.userId,
+                            membership = RoomMembershipState.JOIN
+                        ),
+                        aRoomMember(
+                            userId = invitedUser.userId,
+                            membership = RoomMembershipState.INVITE
+                        ),
+                    )
+                ),
+            coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true)
+        )
+
+        presenter.test {
+            val initialState = awaitItem()
+            skipItems(1)
+
+            initialState.eventSink(DefaultInvitePeopleEvents.UpdateSearchQuery("some query"))
+            skipItems(1)
+
+            assertThat(repository.providedQuery).isEqualTo("some query")
+
+            val unresolvedUser =
+                UserSearchResult(aMatrixUser(id = A_USER_ID.value), isUnresolved = true)
+            repository.emitState(listOf(unresolvedUser) + aMatrixUserList().map {
+                UserSearchResult(
+                    it
+                )
+            })
+            skipItems(1)
+
+            val resultState = awaitItemAsDefault()
+            assertThat(resultState.searchResults).isInstanceOf(SearchBarResultState.Results::class.java)
+
+            val users = resultState.searchResults.users()
+
+            val userWhoShouldBeUnresolved = users.first()
+            assertThat(userWhoShouldBeUnresolved.isUnresolved).isTrue()
+
+            // All other users are neither joined nor invited
+            val otherUsers = users.minus(userWhoShouldBeUnresolved)
+            assertThat(otherUsers.none { it.isUnresolved }).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - toggle users updates selected user state`() = runTest {
+        val repository = FakeUserRepository()
+        val presenter = createDefaultInvitePeoplePresenter(
+            userRepository = repository,
+            coroutineDispatchers = testCoroutineDispatchers()
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            skipItems(1)
+
+            // When we toggle a user not in the list, they are added
+            initialState.eventSink(DefaultInvitePeopleEvents.ToggleUser(aMatrixUser()))
+            assertThat(awaitItemAsDefault().selectedUsers).containsExactly(aMatrixUser())
+
+            // Toggling a different user also adds them
+            initialState.eventSink(DefaultInvitePeopleEvents.ToggleUser(aMatrixUser(id = A_USER_ID_2.value)))
+            assertThat(awaitItemAsDefault().selectedUsers).containsExactly(
+                aMatrixUser(),
+                aMatrixUser(id = A_USER_ID_2.value)
+            )
+
+            // Toggling the first user removes them
+            initialState.eventSink(DefaultInvitePeopleEvents.ToggleUser(aMatrixUser()))
+            assertThat(awaitItemAsDefault().selectedUsers).containsExactly(aMatrixUser(id = A_USER_ID_2.value))
+        }
+    }
+
+    @Test
+    fun `present - selected users appear as such in search results`() = runTest {
+        val repository = FakeUserRepository()
+        val presenter = createDefaultInvitePeoplePresenter(
+            userRepository = repository,
+            coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true)
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            skipItems(1)
+
+            val selectedUser = aMatrixUser()
+
+            initialState.eventSink(DefaultInvitePeopleEvents.ToggleUser(selectedUser))
+
+            initialState.eventSink(DefaultInvitePeopleEvents.UpdateSearchQuery("some query"))
+            skipItems(1)
+
+            assertThat(repository.providedQuery).isEqualTo("some query")
+            repository.emitStateWithUsers(users = aMatrixUserList() + selectedUser)
+            skipItems(2)
+
+            val resultState = awaitItemAsDefault()
+            assertThat(resultState.searchResults).isInstanceOf(SearchBarResultState.Results::class.java)
+
+            val users = resultState.searchResults.users()
+
+            // The one user we have previously toggled is marked as selected
+            val shouldBeSelectedUser = users.find { it.matrixUser == selectedUser }
+            assertThat(shouldBeSelectedUser).isNotNull()
+            assertThat(shouldBeSelectedUser?.isSelected).isTrue()
+
+            // And no others are
+            val allOtherUsers = users.minus(shouldBeSelectedUser!!)
+            assertThat(allOtherUsers.none { it.isSelected }).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - toggling a user updates existing search results`() = runTest {
+        val repository = FakeUserRepository()
+        val presenter = createDefaultInvitePeoplePresenter(
+            userRepository = repository,
+            coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true)
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            skipItems(1)
+
+            val selectedUser = aMatrixUser()
+
+            // Given a query is made
+            initialState.eventSink(DefaultInvitePeopleEvents.UpdateSearchQuery("some query"))
+            skipItems(1)
+
+            assertThat(repository.providedQuery).isEqualTo("some query")
+            repository.emitStateWithUsers(users = aMatrixUserList() + selectedUser)
+            skipItems(1)
+            awaitItemAsDefault().also { state ->
+                // selectedUser is not selected
+                assertThat(state.searchResults).isInstanceOf(SearchBarResultState.Results::class.java)
+                val users = state.searchResults.users()
+                val shouldNotBeSelectedUser = users.find { it.matrixUser == selectedUser }
+                assertThat(shouldNotBeSelectedUser).isNotNull()
+                assertThat(shouldNotBeSelectedUser?.isSelected).isFalse()
+            }
+
+            // And then a user is toggled
+            initialState.eventSink(DefaultInvitePeopleEvents.ToggleUser(selectedUser))
+            skipItems(1)
+            val resultState = awaitItemAsDefault()
+
+            // The results are updated...
+            assertThat(resultState.searchResults).isInstanceOf(SearchBarResultState.Results::class.java)
+            val users = resultState.searchResults.users()
+
+            // The one user we have now toggled is marked as selected
+            val shouldBeSelectedUser = users.find { it.matrixUser == selectedUser }
+            assertThat(shouldBeSelectedUser).isNotNull()
+            assertThat(shouldBeSelectedUser?.isSelected).isTrue()
+
+            // And no others are
+            val allOtherUsers = users.minus(shouldBeSelectedUser!!)
+            assertThat(allOtherUsers.none { it.isSelected }).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - toggling a user and send invite success`() = runTest {
+        val repository = FakeUserRepository()
+        val inviteUserResult = lambdaRecorder<UserId, Result<Unit>> { userId: UserId ->
+            Result.success(Unit)
+        }
+        val presenter = createDefaultInvitePeoplePresenter(
+            userRepository = repository,
+            inviteUserResult = inviteUserResult,
+            coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true)
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            skipItems(1)
+            val selectedUser = aMatrixUser()
+            repository.emitStateWithUsers(users = aMatrixUserList() + selectedUser)
+            skipItems(1)
+            // And then a user is toggled
+            initialState.eventSink(DefaultInvitePeopleEvents.ToggleUser(selectedUser))
+            skipItems(1)
+            val resultState = awaitItemAsDefault()
+            // The results are updated...
+            assertThat(resultState.searchResults).isInstanceOf(SearchBarResultState.Results::class.java)
+            // Send invites
+            initialState.eventSink(InvitePeopleEvents.SendInvites)
+
+            // Can't invite in the loading state
+            awaitItem().run {
+                assertThat(sendInvitesAction.isLoading()).isTrue()
+                assertThat(canInvite).isFalse()
+            }
+
+            delay(1_000)
+            inviteUserResult.assertions().isCalledOnce().with(
+                value(selectedUser.userId)
+            )
+
+            // Can invite again once the action is finished
+            awaitItem().run {
+                assertThat(sendInvitesAction.isReady()).isTrue()
+                assertThat(canInvite).isTrue()
+            }
+        }
+    }
+
+    @Test
+    fun `present - toggling a user and send invite error`() = runTest {
+        val repository = FakeUserRepository()
+        val inviteUserResult = lambdaRecorder<UserId, Result<Unit>> { _: UserId ->
+            Result.failure(AN_EXCEPTION)
+        }
+        val showErrorResResult = lambdaRecorder<Int, Int, Unit> { _, _ -> }
+        val presenter = createDefaultInvitePeoplePresenter(
+            userRepository = repository,
+            inviteUserResult = inviteUserResult,
+            coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true),
+            appErrorStateService = FakeAppErrorStateService(
+                showErrorResResult = showErrorResResult,
+            )
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            skipItems(1)
+            val selectedUser = aMatrixUser()
+            repository.emitStateWithUsers(users = aMatrixUserList() + selectedUser)
+            skipItems(1)
+            // And then a user is toggled
+            initialState.eventSink(DefaultInvitePeopleEvents.ToggleUser(selectedUser))
+            skipItems(1)
+            val resultState = awaitItemAsDefault()
+            // The results are updated...
+            assertThat(resultState.searchResults).isInstanceOf(SearchBarResultState.Results::class.java)
+            // Send invites
+            initialState.eventSink(InvitePeopleEvents.SendInvites)
+
+            // Can't invite in the loading state
+            awaitItem().run {
+                assertThat(sendInvitesAction.isLoading()).isTrue()
+                assertThat(canInvite).isFalse()
+            }
+
+            delay(1_000)
+            inviteUserResult.assertions().isCalledOnce().with(
+                value(selectedUser.userId)
+            )
+            showErrorResResult.assertions()
+                .isCalledOnce()
+                .with(
+                    value(CommonStrings.common_unable_to_invite_title),
+                    value(CommonStrings.common_unable_to_invite_message)
+                )
+
+            // Can invite again once the action is finished
+            awaitItem().run {
+                assertThat(sendInvitesAction.isReady()).isTrue()
+                assertThat(canInvite).isTrue()
+            }
+        }
+    }
+
+    @Test
+    fun `present - when joinedRoom is not provided, it is retrieved on the MatrixClient`() = runTest {
+        val matrixClient = FakeMatrixClient().apply {
+            givenGetRoomResult(A_ROOM_ID, FakeJoinedRoom())
+        }
+        val presenter = createDefaultInvitePeoplePresenter(
+            joinedRoom = null,
+            roomId = A_ROOM_ID,
+            matrixClient = matrixClient,
+        )
+        presenter.test {
+            val initialState = awaitItemAsDefault()
+            assertThat(initialState.room.isLoading()).isTrue()
+            val finalState = awaitItemAsDefault()
+            assertThat(finalState.room).isEqualTo(AsyncData.Success(Unit))
+        }
+    }
+
+    @Test
+    fun `present - when joinedRoom is not provided, it is retrieved on the MatrixClient - error case`() = runTest {
+        val matrixClient = FakeMatrixClient()
+        val presenter = createDefaultInvitePeoplePresenter(
+            joinedRoom = null,
+            roomId = A_ROOM_ID,
+            matrixClient = matrixClient,
+        )
+        presenter.test {
+            val initialState = awaitItemAsDefault()
+            assertThat(initialState.room.isLoading()).isTrue()
+            val finalState = awaitItemAsDefault()
+            assertThat(finalState.room.errorOrNull()?.message).isEqualTo("Room not found")
+        }
+    }
+
+    private suspend fun FakeUserRepository.emitStateWithUsers(
+        users: List<MatrixUser>,
+        isSearching: Boolean = false
+    ) {
+        emitState(
+            results = users.map { UserSearchResult(it) },
+            isSearching = isSearching,
+        )
+    }
+
+    private suspend fun FakeUserRepository.emitState(
+        results: List<UserSearchResult>,
+        isSearching: Boolean = false
+    ) {
+        val state = UserSearchResultState(
+            results = results,
+            isSearching = isSearching
+        )
+        emitState(state)
+    }
+
+    private fun SearchBarResultState<ImmutableList<InvitableUser>>.users() =
+        (this as? SearchBarResultState.Results<ImmutableList<InvitableUser>>)?.results.orEmpty()
+}
+
+private suspend fun <T> ReceiveTurbine<T>.awaitItemAsDefault(): DefaultInvitePeopleState {
+    return awaitItem() as DefaultInvitePeopleState
+}
+
+fun TestScope.createDefaultInvitePeoplePresenter(
+    roomMembersState: RoomMembersState = RoomMembersState.Ready(aRoomMemberList()),
+    inviteUserResult: (UserId) -> Result<Unit> = { lambdaError() },
+    joinedRoom: JoinedRoom? = FakeJoinedRoom(
+        inviteUserResult = inviteUserResult,
+    ).apply {
+        givenRoomMembersState(roomMembersState)
+    },
+    roomId: RoomId = A_ROOM_ID,
+    userRepository: UserRepository = FakeUserRepository(),
+    coroutineDispatchers: CoroutineDispatchers = testCoroutineDispatchers(),
+    appErrorStateService: AppErrorStateService = FakeAppErrorStateService(),
+    matrixClient: MatrixClient = FakeMatrixClient(),
+): DefaultInvitePeoplePresenter {
+    return DefaultInvitePeoplePresenter(
+        joinedRoom = joinedRoom,
+        roomId = roomId,
+        userRepository = userRepository,
+        coroutineDispatchers = coroutineDispatchers,
+        sessionCoroutineScope = backgroundScope,
+        appErrorStateService = appErrorStateService,
+        matrixClient = matrixClient,
+    )
+}