Merge branch 'develop' into feature/fga/room_list_filters

2024-02-19 18:00:01 +01:00 · 2024-02-19 18:00:01 +01:00 · c2e969c592
commit c2e969c592
parent f2cdc25ef3 a02129ca95
94 changed files with 1437 additions and 451 deletions
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListEvents.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListEvents.kt
@ -20,7 +20,6 @@ import io.element.android.features.roomlist.impl.model.RoomListRoomSummary
 import io.element.android.libraries.matrix.api.core.RoomId

 sealed interface RoomListEvents {
-    data class UpdateFilter(val newFilter: String) : RoomListEvents
    data class UpdateVisibleRange(val range: IntRange) : RoomListEvents
    data object DismissRequestVerificationPrompt : RoomListEvents
    data object DismissRecoveryKeyPrompt : RoomListEvents
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListPresenter.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListPresenter.kt
@ -38,6 +38,8 @@ import io.element.android.features.roomlist.impl.datasource.InviteStateDataSourc
 import io.element.android.features.roomlist.impl.datasource.RoomListDataSource
 import io.element.android.features.roomlist.impl.filters.RoomListFiltersPresenter
 import io.element.android.features.roomlist.impl.migration.MigrationScreenPresenter
+import io.element.android.features.roomlist.impl.search.RoomListSearchEvents
+import io.element.android.features.roomlist.impl.search.RoomListSearchState
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarDispatcher
@ -74,13 +76,15 @@ class RoomListPresenter @Inject constructor(
    private val inviteStateDataSource: InviteStateDataSource,
    private val leaveRoomPresenter: LeaveRoomPresenter,
    private val roomListDataSource: RoomListDataSource,
-    private val encryptionService: EncryptionService,
    private val featureFlagService: FeatureFlagService,
    private val indicatorService: IndicatorService,
    private val filtersPresenter: RoomListFiltersPresenter,
+    private val searchPresenter: Presenter<RoomListSearchState>,
    private val migrationScreenPresenter: MigrationScreenPresenter,
    private val sessionPreferencesStore: SessionPreferencesStore,
 ) : Presenter<RoomListState> {
+    private val encryptionService: EncryptionService = client.encryptionService()
+
    @Composable
    override fun present(): RoomListState {
        val coroutineScope = rememberCoroutineScope()
@ -91,10 +95,10 @@ class RoomListPresenter @Inject constructor(
        val roomList by produceState(initialValue = AsyncData.Loading()) {
            roomListDataSource.allRooms.collect { value = AsyncData.Success(it) }
        }
-        val filteredRoomList by roomListDataSource.filteredRooms.collectAsState()
-        val filter by roomListDataSource.filter.collectAsState()
        val networkConnectionStatus by networkMonitor.connectivity.collectAsState()
+
        val filtersState = filtersPresenter.present()
+        val searchState = searchPresenter.present()

        LaunchedEffect(Unit) {
            roomListDataSource.launchIn(this)
@ -125,21 +129,14 @@ class RoomListPresenter @Inject constructor(
        // Avatar indicator
        val showAvatarIndicator by indicatorService.showRoomListTopBarIndicator()

-        var displaySearchResults by rememberSaveable { mutableStateOf(false) }
        val contextMenu = remember { mutableStateOf<RoomListState.ContextMenu>(RoomListState.ContextMenu.Hidden) }

        fun handleEvents(event: RoomListEvents) {
            when (event) {
-                is RoomListEvents.UpdateFilter -> roomListDataSource.updateFilter(event.newFilter)
                is RoomListEvents.UpdateVisibleRange -> updateVisibleRange(event.range)
                RoomListEvents.DismissRequestVerificationPrompt -> verificationPromptDismissed = true
                RoomListEvents.DismissRecoveryKeyPrompt -> recoveryKeyPromptDismissed = true
-                RoomListEvents.ToggleSearchResults -> {
-                    if (displaySearchResults) {
-                        roomListDataSource.updateFilter("")
-                    }
-                    displaySearchResults = !displaySearchResults
-                }
+                RoomListEvents.ToggleSearchResults -> searchState.eventSink(RoomListSearchEvents.ToggleSearchVisibility)
                is RoomListEvents.ShowContextMenu -> {
                    coroutineScope.showContextMenu(event, contextMenu)
                }
@ -147,7 +144,6 @@ class RoomListPresenter @Inject constructor(
                    contextMenu.value = RoomListState.ContextMenu.Hidden
                }
                is RoomListEvents.LeaveRoom -> leaveRoomState.eventSink(LeaveRoomEvent.ShowConfirmation(event.roomId))
-
                is RoomListEvents.SetRoomIsFavorite -> coroutineScope.launch {
                    client.getRoom(event.roomId)?.use { room ->
                        room.setIsFavorite(event.isFavorite)
@ -178,17 +174,15 @@ class RoomListPresenter @Inject constructor(
            matrixUser = matrixUser.value,
            showAvatarIndicator = showAvatarIndicator,
            roomList = roomList,
-            filter = filter,
-            filteredRoomList = filteredRoomList,
            displayVerificationPrompt = displayVerificationPrompt,
            displayRecoveryKeyPrompt = displayRecoveryKeyPrompt,
            snackbarMessage = snackbarMessage,
            hasNetworkConnection = networkConnectionStatus == NetworkStatus.Online,
            invitesState = inviteStateDataSource.inviteState(),
-            displaySearchResults = displaySearchResults,
            contextMenu = contextMenu.value,
            leaveRoomState = leaveRoomState,
            filtersState = filtersState,
+            searchState = searchState,
            displayMigrationStatus = isMigrating,
            eventSink = ::handleEvents,
        )
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListState.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListState.kt
@ -20,6 +20,7 @@ import androidx.compose.runtime.Immutable
 import io.element.android.features.leaveroom.api.LeaveRoomState
 import io.element.android.features.roomlist.impl.filters.RoomListFiltersState
 import io.element.android.features.roomlist.impl.model.RoomListRoomSummary
+import io.element.android.features.roomlist.impl.search.RoomListSearchState
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
 import io.element.android.libraries.matrix.api.core.RoomId
@ -31,17 +32,15 @@ data class RoomListState(
    val matrixUser: MatrixUser?,
    val showAvatarIndicator: Boolean,
    val roomList: AsyncData<ImmutableList<RoomListRoomSummary>>,
-    val filter: String?,
-    val filteredRoomList: ImmutableList<RoomListRoomSummary>,
    val displayVerificationPrompt: Boolean,
    val displayRecoveryKeyPrompt: Boolean,
    val hasNetworkConnection: Boolean,
    val snackbarMessage: SnackbarMessage?,
    val invitesState: InvitesState,
-    val displaySearchResults: Boolean,
    val contextMenu: ContextMenu,
    val leaveRoomState: LeaveRoomState,
    val filtersState: RoomListFiltersState,
+    val searchState: RoomListSearchState,
    val displayMigrationStatus: Boolean,
    val eventSink: (RoomListEvents) -> Unit,
 ) {
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListStateProvider.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListStateProvider.kt
@ -22,6 +22,7 @@ import io.element.android.features.roomlist.impl.datasource.RoomListRoomSummaryF
 import io.element.android.features.roomlist.impl.filters.aRoomListFiltersState
 import io.element.android.features.roomlist.impl.model.RoomListRoomSummary
 import io.element.android.features.roomlist.impl.model.aRoomListRoomSummary
+import io.element.android.features.roomlist.impl.search.aRoomListSearchState
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
 import io.element.android.libraries.designsystem.components.avatar.AvatarSize
@ -42,14 +43,13 @@ open class RoomListStateProvider : PreviewParameterProvider<RoomListState> {
            aRoomListState().copy(hasNetworkConnection = false),
            aRoomListState().copy(invitesState = InvitesState.SeenInvites),
            aRoomListState().copy(invitesState = InvitesState.NewInvites),
-            aRoomListState().copy(displaySearchResults = true, filter = "", filteredRoomList = persistentListOf()),
-            aRoomListState().copy(displaySearchResults = true),
            aRoomListState().copy(contextMenu = aContextMenuShown(roomName = "A nice room name")),
            aRoomListState().copy(contextMenu = aContextMenuShown(isFavorite = true)),
            aRoomListState().copy(displayRecoveryKeyPrompt = true),
            aRoomListState().copy(roomList = AsyncData.Success(persistentListOf())),
            aRoomListState().copy(roomList = AsyncData.Loading(prevData = RoomListRoomSummaryFactory.createFakeList())),
            aRoomListState().copy(matrixUser = null, displayMigrationStatus = true),
+            aRoomListState().copy(searchState = aRoomListSearchState(isSearchActive = true, query = "Test")),
        )
 }

@ -57,17 +57,15 @@ internal fun aRoomListState() = RoomListState(
    matrixUser = MatrixUser(userId = UserId("@id:domain"), displayName = "User#1"),
    showAvatarIndicator = false,
    roomList = AsyncData.Success(aRoomListRoomSummaryList()),
-    filter = "filter",
-    filteredRoomList = aRoomListRoomSummaryList(),
    hasNetworkConnection = true,
    snackbarMessage = null,
    displayVerificationPrompt = false,
    displayRecoveryKeyPrompt = false,
    invitesState = InvitesState.NoInvites,
-    displaySearchResults = false,
    contextMenu = RoomListState.ContextMenu.Hidden,
    leaveRoomState = aLeaveRoomState(),
    filtersState = aRoomListFiltersState(),
+    searchState = aRoomListSearchState(),
    displayMigrationStatus = false,
    eventSink = {}
 )
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListView.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListView.kt
@ -58,7 +58,7 @@ import io.element.android.features.roomlist.impl.components.RoomSummaryRow
 import io.element.android.features.roomlist.impl.filters.RoomListFiltersView
 import io.element.android.features.roomlist.impl.migration.MigrationScreenView
 import io.element.android.features.roomlist.impl.model.RoomListRoomSummary
-import io.element.android.features.roomlist.impl.search.RoomListSearchResultView
+import io.element.android.features.roomlist.impl.search.RoomListSearchView
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
@ -119,8 +119,8 @@ fun RoomListView(
                onMenuActionClicked = onMenuActionClicked,
            )
            // This overlaid view will only be visible when state.displaySearchResults is true
-            RoomListSearchResultView(
-                state = state,
+            RoomListSearchView(
+                state = state.searchState,
                onRoomClicked = onRoomClicked,
                onRoomLongClicked = { onRoomLongClicked(it) },
                modifier = Modifier
@ -209,8 +209,7 @@ private fun RoomListContent(
                RoomListTopBar(
                    matrixUser = state.matrixUser,
                    showAvatarIndicator = state.showAvatarIndicator,
-                    areSearchResultsDisplayed = state.displaySearchResults,
-                    onFilterChanged = { state.eventSink(RoomListEvents.UpdateFilter(it)) },
+                    areSearchResultsDisplayed = state.searchState.isSearchActive,
                    onToggleSearch = { state.eventSink(RoomListEvents.ToggleSearchResults) },
                    onMenuActionClicked = onMenuActionClicked,
                    onOpenSettings = onOpenSettings,
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/components/RoomListTopBar.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/components/RoomListTopBar.kt
@ -16,7 +16,6 @@

 package io.element.android.features.roomlist.impl.components

-import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxWidth
@ -87,7 +86,6 @@ fun RoomListTopBar(
    matrixUser: MatrixUser?,
    showAvatarIndicator: Boolean,
    areSearchResultsDisplayed: Boolean,
-    onFilterChanged: (String) -> Unit,
    onToggleSearch: () -> Unit,
    onMenuActionClicked: (RoomListMenuAction) -> Unit,
    onOpenSettings: () -> Unit,
@ -95,15 +93,6 @@ fun RoomListTopBar(
    displayMenuItems: Boolean,
    modifier: Modifier = Modifier,
 ) {
-    fun closeFilter() {
-        onFilterChanged("")
-    }
-
-    BackHandler(enabled = areSearchResultsDisplayed) {
-        closeFilter()
-        onToggleSearch()
-    }
-
    DefaultRoomListTopBar(
        matrixUser = matrixUser,
        showAvatarIndicator = showAvatarIndicator,
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/datasource/RoomListDataSource.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/datasource/RoomListDataSource.kt
@ -25,15 +25,11 @@ import io.element.android.libraries.matrix.api.roomlist.RoomList
 import io.element.android.libraries.matrix.api.roomlist.RoomListService
 import io.element.android.libraries.matrix.api.roomlist.RoomSummary
 import kotlinx.collections.immutable.ImmutableList
-import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
@ -54,9 +50,7 @@ class RoomListDataSource @Inject constructor(
        observeNotificationSettings()
    }

-    private val _filter = MutableStateFlow("")
    private val _allRooms = MutableSharedFlow<ImmutableList<RoomListRoomSummary>>(replay = 1)
-    private val _filteredRooms = MutableStateFlow<ImmutableList<RoomListRoomSummary>>(persistentListOf())

    private val lock = Mutex()
    private val diffCache = MutableListDiffCache<RoomListRoomSummary>()
@ -72,29 +66,9 @@ class RoomListDataSource @Inject constructor(
                replaceWith(roomSummaries)
            }
            .launchIn(coroutineScope)
-
-        combine(
-            _filter,
-            _allRooms
-        ) { filterValue, allRoomsValue ->
-            when {
-                filterValue.isEmpty() -> emptyList()
-                else -> allRoomsValue.filter { it.name.contains(filterValue, ignoreCase = true) }
-            }.toImmutableList()
-        }
-            .onEach {
-                _filteredRooms.value = it
-            }
-            .launchIn(coroutineScope)
    }

-    fun updateFilter(filterValue: String) {
-        _filter.value = filterValue
-    }
-
-    val filter: StateFlow<String> = _filter
    val allRooms: SharedFlow<ImmutableList<RoomListRoomSummary>> = _allRooms
-    val filteredRooms: StateFlow<ImmutableList<RoomListRoomSummary>> = _filteredRooms

    @OptIn(FlowPreview::class)
    private fun observeNotificationSettings() {
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/di/RoomListModule.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/di/RoomListModule.kt
@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2024 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.roomlist.impl.di
+
+import com.squareup.anvil.annotations.ContributesTo
+import dagger.Binds
+import dagger.Module
+import io.element.android.features.roomlist.impl.search.RoomListSearchPresenter
+import io.element.android.features.roomlist.impl.search.RoomListSearchState
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.di.SessionScope
+
+@ContributesTo(SessionScope::class)
+@Module
+interface RoomListModule {
+    @Binds
+    fun bindSearchPresenter(presenter: RoomListSearchPresenter): Presenter<RoomListSearchState>
+}
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchEvents.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchEvents.kt
@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2024 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.roomlist.impl.search
+
+sealed interface RoomListSearchEvents {
+    data object ToggleSearchVisibility : RoomListSearchEvents
+    data class QueryChanged(val query: String) : RoomListSearchEvents
+    data object ClearQuery : RoomListSearchEvents
+}
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchPresenter.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchPresenter.kt
@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2024 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.roomlist.impl.search
+
+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.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import io.element.android.features.roomlist.impl.datasource.RoomListRoomSummaryFactory
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.matrix.api.roomlist.RoomList
+import io.element.android.libraries.matrix.api.roomlist.RoomListFilter
+import io.element.android.libraries.matrix.api.roomlist.RoomListService
+import io.element.android.libraries.matrix.api.roomlist.RoomSummary
+import io.element.android.libraries.matrix.api.roomlist.loadAllIncrementally
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toPersistentList
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import javax.inject.Inject
+
+private const val PAGE_SIZE = 50
+
+class RoomListSearchPresenter @Inject constructor(
+    private val roomListService: RoomListService,
+    private val roomSummaryFactory: RoomListRoomSummaryFactory,
+    private val coroutineDispatchers: CoroutineDispatchers,
+) : Presenter<RoomListSearchState> {
+    @Composable
+    override fun present(): RoomListSearchState {
+        var isSearchActive by rememberSaveable {
+            mutableStateOf(false)
+        }
+        var searchQuery by rememberSaveable {
+            mutableStateOf("")
+        }
+        val coroutineScope = rememberCoroutineScope()
+
+        val roomList = remember {
+            roomListService.createRoomList(
+                coroutineScope = coroutineScope,
+                pageSize = PAGE_SIZE,
+                initialFilter = RoomListFilter.all(RoomListFilter.None),
+                source = RoomList.Source.All,
+            )
+        }
+
+        LaunchedEffect(Unit) {
+            roomList.loadAllIncrementally(this)
+        }
+        LaunchedEffect(key1 = searchQuery) {
+            val filter = if (searchQuery.isBlank()) {
+                RoomListFilter.all(RoomListFilter.None)
+            } else {
+                RoomListFilter.all(RoomListFilter.NonLeft, RoomListFilter.NormalizedMatchRoomName(searchQuery))
+            }
+            roomList.updateFilter(filter)
+        }
+
+        fun handleEvents(event: RoomListSearchEvents) {
+            when (event) {
+                RoomListSearchEvents.ClearQuery -> {
+                    searchQuery = ""
+                }
+                is RoomListSearchEvents.QueryChanged -> {
+                    searchQuery = event.query
+                }
+                RoomListSearchEvents.ToggleSearchVisibility -> {
+                    isSearchActive = !isSearchActive
+                    searchQuery = ""
+                }
+            }
+        }
+
+        val searchResults by roomList
+            .rememberMappedSummaries()
+            .collectAsState(initial = persistentListOf())
+
+        return RoomListSearchState(
+            isSearchActive = isSearchActive,
+            query = searchQuery,
+            results = searchResults,
+            eventSink = ::handleEvents
+        )
+    }
+
+    @Composable
+    private fun RoomList.rememberMappedSummaries() = remember {
+        summaries
+            .map { roomSummaries ->
+                roomSummaries
+                    .filterIsInstance<RoomSummary.Filled>()
+                    .map(roomSummaryFactory::create)
+                    .toPersistentList()
+            }
+            .flowOn(coroutineDispatchers.computation)
+    }
+}
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchState.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchState.kt
@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2024 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.roomlist.impl.search
+
+import io.element.android.features.roomlist.impl.model.RoomListRoomSummary
+import kotlinx.collections.immutable.ImmutableList
+
+data class RoomListSearchState(
+    val isSearchActive: Boolean,
+    val query: String,
+    val results: ImmutableList<RoomListRoomSummary>,
+    val eventSink: (RoomListSearchEvents) -> Unit
+)
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchStateProvider.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchStateProvider.kt
@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2024 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.roomlist.impl.search
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.roomlist.impl.aRoomListRoomSummaryList
+import io.element.android.features.roomlist.impl.model.RoomListRoomSummary
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+class RoomListSearchStateProvider : PreviewParameterProvider<RoomListSearchState> {
+    override val values: Sequence<RoomListSearchState>
+        get() = sequenceOf(
+            aRoomListSearchState(),
+            aRoomListSearchState(
+                isSearchActive = true,
+                query = "Test",
+                results = aRoomListRoomSummaryList()
+            ),
+        )
+}
+
+fun aRoomListSearchState(
+    isSearchActive: Boolean = false,
+    query: String = "",
+    results: ImmutableList<RoomListRoomSummary> = persistentListOf(),
+    eventSink: (RoomListSearchEvents) -> Unit = { },
+) = RoomListSearchState(
+    isSearchActive = isSearchActive,
+    query = query,
+    results = results,
+    eventSink = eventSink,
+)
--- a/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchResultView.kt
+++ b/features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/search/RoomListSearchResultView.kt
@ -16,6 +16,7 @@

 package io.element.android.features.roomlist.impl.search

+import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
@ -25,32 +26,23 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.TextFieldDefaults
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.drawBehind
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
-import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.Velocity
+import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import io.element.android.compound.tokens.generated.CompoundIcons
-import io.element.android.features.roomlist.impl.RoomListEvents
-import io.element.android.features.roomlist.impl.RoomListState
-import io.element.android.features.roomlist.impl.aRoomListState
 import io.element.android.features.roomlist.impl.components.RoomSummaryRow
 import io.element.android.features.roomlist.impl.contentType
 import io.element.android.features.roomlist.impl.model.RoomListRoomSummary
@ -68,26 +60,30 @@ import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.ui.strings.CommonStrings

@Composable
-internal fun RoomListSearchResultView(
-    state: RoomListState,
+internal fun RoomListSearchView(
+    state: RoomListSearchState,
    onRoomClicked: (RoomId) -> Unit,
    onRoomLongClicked: (RoomListRoomSummary) -> Unit,
    modifier: Modifier = Modifier,
 ) {
+    BackHandler(enabled = state.isSearchActive) {
+        state.eventSink(RoomListSearchEvents.ToggleSearchVisibility)
+    }
+
    AnimatedVisibility(
-        visible = state.displaySearchResults,
+        visible = state.isSearchActive,
        enter = fadeIn(),
        exit = fadeOut(),
    ) {
        Column(
            modifier = modifier
-                .applyIf(state.displaySearchResults, ifTrue = {
+                .applyIf(state.isSearchActive, ifTrue = {
                    // Disable input interaction to underlying views
                    pointerInput(Unit) {}
                })
        ) {
-            if (state.displaySearchResults) {
-                RoomListSearchResultContent(
+            if (state.isSearchActive) {
+                RoomListSearchContent(
                    state = state,
                    onRoomClicked = onRoomClicked,
                    onRoomLongClicked = onRoomLongClicked,
@ -99,15 +95,15 @@ internal fun RoomListSearchResultView(

@OptIn(ExperimentalMaterial3Api::class)
@Composable
-private fun RoomListSearchResultContent(
-    state: RoomListState,
+private fun RoomListSearchContent(
+    state: RoomListSearchState,
    onRoomClicked: (RoomId) -> Unit,
    onRoomLongClicked: (RoomListRoomSummary) -> Unit,
 ) {
    val borderColor = MaterialTheme.colorScheme.tertiary
    val strokeWidth = 1.dp
    fun onBackButtonPressed() {
-        state.eventSink(RoomListEvents.ToggleSearchResults)
+        state.eventSink(RoomListSearchEvents.ToggleSearchVisibility)
    }

    fun onRoomClicked(room: RoomListRoomSummary) {
@ -126,7 +122,7 @@ private fun RoomListSearchResultContent(
                },
                navigationIcon = { BackButton(onClick = ::onBackButtonPressed) },
                title = {
-                    val filter = state.filter.orEmpty()
+                    val filter = state.query
                    val focusRequester = FocusRequester()
                    TextField(
                        modifier = Modifier
@ -134,7 +130,7 @@ private fun RoomListSearchResultContent(
                            .focusRequester(focusRequester),
                        value = filter,
                        singleLine = true,
-                        onValueChange = { state.eventSink(RoomListEvents.UpdateFilter(it)) },
+                        onValueChange = { state.eventSink(RoomListSearchEvents.QueryChanged(it)) },
                        colors = TextFieldDefaults.colors(
                            focusedContainerColor = Color.Transparent,
                            unfocusedContainerColor = Color.Transparent,
@ -147,7 +143,7 @@ private fun RoomListSearchResultContent(
                        trailingIcon = {
                            if (filter.isNotEmpty()) {
                                IconButton(onClick = {
-                                    state.eventSink(RoomListEvents.UpdateFilter(""))
+                                    state.eventSink(RoomListSearchEvents.ClearQuery)
                                }) {
                                    Icon(
                                        imageVector = CompoundIcons.Close(),
@ -158,8 +154,8 @@ private fun RoomListSearchResultContent(
                        }
                    )

-                    LaunchedEffect(state.displaySearchResults) {
-                        if (state.displaySearchResults) {
+                    LaunchedEffect(state.isSearchActive) {
+                        if (state.isSearchActive) {
                            focusRequester.requestFocus()
                        }
                    }
@ -168,39 +164,16 @@ private fun RoomListSearchResultContent(
            )
        }
    ) { padding ->
-        val lazyListState = rememberLazyListState()
-        val visibleRange by remember {
-            derivedStateOf {
-                val layoutInfo = lazyListState.layoutInfo
-                val firstItemIndex = layoutInfo.visibleItemsInfo.firstOrNull()?.index ?: 0
-                val size = layoutInfo.visibleItemsInfo.size
-                firstItemIndex until firstItemIndex + size
-            }
-        }
-        val nestedScrollConnection = remember {
-            object : NestedScrollConnection {
-                override suspend fun onPostFling(
-                    consumed: Velocity,
-                    available: Velocity
-                ): Velocity {
-                    state.eventSink(RoomListEvents.UpdateVisibleRange(visibleRange))
-                    return super.onPostFling(consumed, available)
-                }
-            }
-        }
        Column(
            modifier = Modifier
                .padding(padding)
                .consumeWindowInsets(padding)
        ) {
            LazyColumn(
-                modifier = Modifier
-                    .weight(1f)
-                    .nestedScroll(nestedScrollConnection),
-                state = lazyListState,
+                modifier = Modifier.weight(1f),
            ) {
                items(
-                    items = state.filteredRoomList,
+                    items = state.results,
                    contentType = { room -> room.contentType() },
                ) { room ->
                    RoomSummaryRow(
@ -216,9 +189,9 @@ private fun RoomListSearchResultContent(

@PreviewsDayNight
@Composable
-internal fun RoomListSearchResultContentPreview() = ElementPreview {
-    RoomListSearchResultContent(
-        state = aRoomListState(),
+internal fun RoomListSearchResultContentPreview(@PreviewParameter(RoomListSearchStateProvider::class) state: RoomListSearchState) = ElementPreview {
+    RoomListSearchContent(
+        state = state,
        onRoomClicked = {},
        onRoomLongClicked = {}
    )