Merge branch 'develop' into feature/fga/user_status_last_pieces

features/linknewdevice/impl/src/main/kotlin/io/element/android/features/linknewdevice/impl/LinkNewDeviceFlowNode.kt

@@ -56,6 +56,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
 import kotlinx.parcelize.Parcelize
 import timber.log.Timber
 
@@ -102,6 +103,7 @@ class LinkNewDeviceFlowNode(
                 @Suppress("AssignedValueIsNeverRead")
                 linkDesktopHandlerJob = observeLinkNewDesktopHandler()
             },
+            onResume = ::onResume,
             onDestroy = {
                 linkMobileHandlerJob?.cancel()
                 linkDesktopHandlerJob?.cancel()
@@ -209,6 +211,18 @@ class LinkNewDeviceFlowNode(
             .launchIn(sessionCoroutineScope)
     }
 
+    private fun onResume() = sessionCoroutineScope.launch {
+        // Application is resumed, if the step is waiting for auth, send the confirmation
+        (linkNewMobileHandler.stepFlow.value as? LinkMobileStep.WaitingForAuth)?.let {
+            Timber.tag(tag.value).d("Resuming while waiting for auth on mobile, sending confirmation")
+            it.continuationMessageSender.confirm()
+        }
+        (linkNewDesktopHandler.stepFlow.value as? LinkDesktopStep.WaitingForAuth)?.let {
+            Timber.tag(tag.value).d("Resuming while waiting for auth on desktop, sending confirmation")
+            it.continuationMessageSender.confirm()
+        }
+    }
+
     private fun navigateToError(errorType: ErrorType) {
         // Map the error to an error screen
         val error = when (errorType) {

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/resolver/HomeserverResolver.kt

@@ -14,6 +14,8 @@ import io.element.android.libraries.core.coroutine.parallelMap
 import io.element.android.libraries.core.uri.ensureProtocol
 import io.element.android.libraries.core.uri.isValidUrl
 import io.element.android.libraries.matrix.api.auth.HomeServerLoginCompatibilityChecker
+import io.element.android.libraries.matrix.api.core.MatrixPatterns
+import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.permissions.api.localnetwork.LocalNetworkPermissionAdvisor
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.flow.Flow
@@ -34,8 +36,13 @@ class HomeserverResolver(
     fun resolve(userInput: String): Flow<List<HomeserverData>> = flow {
         val flowContext = currentCoroutineContext()
         val trimmedUserInput = userInput.trim()
-        if (trimmedUserInput.length < 4) return@flow
-        val candidateBase = trimmedUserInput.ensureProtocol().removeSuffix("/")
+        val searchTerm = when {
+            MatrixPatterns.isUserId(trimmedUserInput) -> UserId(trimmedUserInput).domainName.orEmpty()
+            trimmedUserInput.startsWith("@") -> return@flow
+            else -> trimmedUserInput
+        }
+        if (searchTerm.length < 4) return@flow
+        val candidateBase = searchTerm.ensureProtocol().removeSuffix("/")
         val list = getUrlCandidates(candidateBase)
         val currentList = Collections.synchronizedList(mutableListOf<HomeserverData>())
         // Run all the requests in parallel

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/resolver/HomeserverResolverTest.kt

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2026 Element Creations 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.login.impl.resolver
+
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.test.auth.FakeHomeServerLoginCompatibilityChecker
+import io.element.android.libraries.permissions.test.FakeLocalNetworkPermissionAdvisor
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.lambda.value
+import io.element.android.tests.testutils.testCoroutineDispatchers
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class HomeserverResolverTest {
+    @Test
+    fun `resolve - a server name is used as is`() = runTest {
+        val checkResult = lambdaRecorder<String, Result<Boolean>> { Result.success(it == "https://example.org") }
+        val sut = createHomeserverResolver(checkResult)
+        sut.resolve("example.org").test {
+            assertThat(awaitItem()).isEqualTo(listOf(HomeserverData(homeserverUrl = "https://example.org")))
+            awaitComplete()
+        }
+        checkResult.assertions().isCalledExactly(1)
+            .withSequence(
+                listOf(value("https://example.org")),
+            )
+    }
+
+    @Test
+    fun `resolve - an url is used as is`() = runTest {
+        val checkResult = lambdaRecorder<String, Result<Boolean>> { Result.success(it == "https://example.org") }
+        val sut = createHomeserverResolver(checkResult)
+        sut.resolve("https://example.org").test {
+            assertThat(awaitItem()).isEqualTo(listOf(HomeserverData(homeserverUrl = "https://example.org")))
+            awaitComplete()
+        }
+        checkResult.assertions().isCalledExactly(1)
+            .withSequence(
+                listOf(value("https://example.org")),
+            )
+    }
+
+    @Test
+    fun `resolve - a user id resolves the server name of the user id`() = runTest {
+        val checkResult = lambdaRecorder<String, Result<Boolean>> { Result.success(it == "https://example.org") }
+        val sut = createHomeserverResolver(checkResult)
+        sut.resolve("@alice:example.org").test {
+            assertThat(awaitItem()).isEqualTo(listOf(HomeserverData(homeserverUrl = "https://example.org")))
+            awaitComplete()
+        }
+        checkResult.assertions().isCalledExactly(1)
+            .withSequence(
+                listOf(value("https://example.org")),
+            )
+    }
+
+    @Test
+    fun `resolve - a user id with a port resolves the server name of the user id`() = runTest {
+        val checkResult = lambdaRecorder<String, Result<Boolean>> { Result.success(it == "https://example.org:8448") }
+        val sut = createHomeserverResolver(checkResult)
+        sut.resolve("@alice:example.org:8448").test {
+            assertThat(awaitItem()).isEqualTo(listOf(HomeserverData(homeserverUrl = "https://example.org:8448")))
+            awaitComplete()
+        }
+        checkResult.assertions().isCalledExactly(1)
+            .withSequence(
+                listOf(value("https://example.org:8448")),
+            )
+    }
+
+    @Test
+    fun `resolve - an incomplete user id does not resolve anything`() = runTest {
+        val checkResult = lambdaRecorder<String, Result<Boolean>> { Result.success(true) }
+        val sut = createHomeserverResolver(checkResult)
+        sut.resolve("@alice").test {
+            awaitComplete()
+        }
+        sut.resolve("@alice:").test {
+            awaitComplete()
+        }
+        checkResult.assertions().isNeverCalled()
+    }
+
+    @Test
+    fun `resolve - a user id with a too short server name does not resolve anything`() = runTest {
+        val checkResult = lambdaRecorder<String, Result<Boolean>> { Result.success(true) }
+        val sut = createHomeserverResolver(checkResult)
+        sut.resolve("@alice:a.b").test {
+            awaitComplete()
+        }
+        checkResult.assertions().isNeverCalled()
+    }
+
+    private fun TestScope.createHomeserverResolver(
+        checkResult: (String) -> Result<Boolean>,
+    ) = HomeserverResolver(
+        dispatchers = testCoroutineDispatchers(),
+        homeServerLoginCompatibilityChecker = FakeHomeServerLoginCompatibilityChecker(checkResult = checkResult),
+        localNetworkPermissionAdvisor = FakeLocalNetworkPermissionAdvisor(),
+    )
+}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/threads/ThreadedMessagesNode.kt

@@ -28,6 +28,7 @@ import dev.zacsweers.metro.Assisted
 import dev.zacsweers.metro.AssistedInject
 import io.element.android.annotations.ContributesNode
 import io.element.android.compound.theme.ElementTheme
+import io.element.android.features.messages.impl.MessagesEvent
 import io.element.android.features.messages.impl.MessagesNavigator
 import io.element.android.features.messages.impl.MessagesPresenter
 import io.element.android.features.messages.impl.MessagesState
@@ -40,6 +41,7 @@ import io.element.android.features.messages.impl.messagecomposer.MessageComposer
 import io.element.android.features.messages.impl.timeline.TimelineController
 import io.element.android.features.messages.impl.timeline.TimelineEvent
 import io.element.android.features.messages.impl.timeline.TimelinePresenter
+import io.element.android.features.messages.impl.timeline.components.customreaction.CustomReactionBottomSheet
 import io.element.android.features.messages.impl.timeline.di.LocalTimelineItemPresenterFactories
 import io.element.android.features.messages.impl.timeline.di.TimelineItemPresenterFactories
 import io.element.android.features.messages.impl.timeline.model.TimelineItem
@@ -54,6 +56,7 @@ import io.element.android.libraries.architecture.callback
 import io.element.android.libraries.architecture.inputs
 import io.element.android.libraries.designsystem.utils.OnLifecycleEvent
 import io.element.android.libraries.di.RoomScope
+import io.element.android.libraries.emoji.api.picker.EmojiPickerRenderer
 import io.element.android.libraries.matrix.api.analytics.toAnalyticsViewRoom
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
@@ -91,6 +94,7 @@ class ThreadedMessagesNode(
     private val permalinkParser: PermalinkParser,
     private val appNavigationStateService: AppNavigationStateService,
     private val roomMemberModerationRenderer: RoomMemberModerationRenderer,
+    private val emojiPickerRenderer: EmojiPickerRenderer,
 ) : Node(buildContext, plugins = plugins), MessagesNavigator {
     data class Inputs(
         val threadRootEventId: ThreadId,
@@ -322,7 +326,15 @@ class ThreadedMessagesNode(
                     onViewAllPinnedMessagesClick = {},
                     modifier = modifier,
                     knockRequestsBannerView = {},
-                    customReactionBottomSheet = {},
+                    customReactionBottomSheet = {
+                        CustomReactionBottomSheet(
+                            state = state.customReactionState,
+                            onSelectEmoji = { uniqueId, emoji ->
+                                state.eventSink(MessagesEvent.ToggleReaction(emoji.unicode, uniqueId))
+                            },
+                            emojiPickerRenderer = emojiPickerRenderer,
+                        )
+                    },
                     onThreadsListClick = {},
                 )
 

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineItemEventRow.kt

@@ -801,15 +801,15 @@ private fun MessageEventBubbleContent(
                 .padding(top = topPadding, start = 8.dp, end = 8.dp)
                 .clip(shape)
 
-            val talkbackCompatModifier = if (isTalkbackActive()) {
+            val talkbackCompatModifier = when {
                 // Use z-index to make the replied to text being read after the message
                 // Usually, you'd use traversalIndex for that, but it's not working for some reason
-                inReplyToModifier.zIndex(1f)
-            } else {
-                inReplyToModifier.clickable(onClick = inReplyToClick)
+                isTalkbackActive() -> inReplyToModifier.zIndex(1f)
+                inReplyTo is InReplyToDetails.Error -> inReplyToModifier
+                else -> inReplyToModifier.clickable(onClick = inReplyToClick)
             }
 
-            val contentHasError = currentContentValidationState.hasError()
+            val contentHasError = currentContentValidationState.hasError() || inReplyTo is InReplyToDetails.Error
             val borderColor = if (contentHasError) ElementTheme.colors.borderCriticalSubtle else ElementTheme.colors.separatorPrimary
             val backgroundColor = if (contentHasError) ElementTheme.colors.bgCriticalSubtle else ElementTheme.colors.bgCanvasDefault
             Box(

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/customreaction/CustomReactionBottomSheet.kt

@@ -8,11 +8,16 @@
 
 package io.element.android.features.messages.impl.timeline.components.customreaction
 
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.isImeVisible
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.SheetState
 import androidx.compose.material3.SheetValue
 import androidx.compose.material3.rememberBottomSheetState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
 import io.element.android.emojibasebindings.Emoji
@@ -54,6 +59,7 @@ fun CustomReactionBottomSheet(
                 modifier = modifier,
                 scrollable = false,
             ) {
+                ExpandSheetWhenImeIsVisible(sheetState)
                 emojiPickerRenderer.Render(
                     state = state.target.emojiPickerState,
                     onSelectEmoji = ::onEmojiSelectedDismiss,
@@ -67,3 +73,14 @@ fun CustomReactionBottomSheet(
         }
     }
 }
+
+@OptIn(ExperimentalLayoutApi::class, ExperimentalMaterial3Api::class)
+@Composable
+internal fun ExpandSheetWhenImeIsVisible(sheetState: SheetState) {
+    val isImeVisible = WindowInsets.isImeVisible
+    LaunchedEffect(isImeVisible) {
+        if (isImeVisible) {
+            sheetState.expand()
+        }
+    }
+}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/protection/TimelineProtectionPresenter.kt

@@ -12,7 +12,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateSetOf
 import androidx.compose.runtime.remember
 import dev.zacsweers.metro.Inject
 import dev.zacsweers.metro.SingleIn
@@ -20,7 +19,6 @@ import io.element.android.features.contentscanner.api.ContentScannerService
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.core.coroutine.mapState
 import io.element.android.libraries.di.RoomScope
-import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.media.MediaPreviewService
 import io.element.android.libraries.matrix.api.media.isPreviewEnabled
 import io.element.android.libraries.matrix.api.room.BaseRoom
@@ -32,9 +30,8 @@ class TimelineProtectionPresenter(
     private val mediaPreviewService: MediaPreviewService,
     private val room: BaseRoom,
     private val contentScannerService: ContentScannerService,
+    private val timelineProtectionStore: TimelineProtectionStore,
 ) : Presenter<TimelineProtectionState> {
-    private val allowedEvents = mutableStateSetOf<EventId>()
-
     @Composable
     override fun present(): TimelineProtectionState {
         val mediaPreviewValue = remember {
@@ -48,7 +45,7 @@ class TimelineProtectionPresenter(
                 if (isPreviewEnabled) {
                     ProtectionState.RenderAll
                 } else {
-                    ProtectionState.RenderOnly(eventIds = allowedEvents.toImmutableSet())
+                    ProtectionState.RenderOnly(eventIds = timelineProtectionStore.allowedEventIds.toImmutableSet())
                 }
             }
         }
@@ -56,7 +53,7 @@ class TimelineProtectionPresenter(
         fun handleEvent(event: TimelineProtectionEvent) {
             when (event) {
                 is TimelineProtectionEvent.ShowContent -> {
-                    allowedEvents += setOfNotNull(event.eventId)
+                    event.eventId?.let(timelineProtectionStore::allowEvent)
                 }
                 is TimelineProtectionEvent.ValidateContent -> {
                     contentScannerService.scan(event.mediaSources, event.validationState)

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/protection/TimelineProtectionStore.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026 Element Creations 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.messages.impl.timeline.protection
+
+import androidx.compose.runtime.mutableStateSetOf
+import androidx.compose.runtime.snapshots.SnapshotStateSet
+import dev.zacsweers.metro.ContributesBinding
+import dev.zacsweers.metro.SingleIn
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.core.EventId
+
+interface TimelineProtectionStore {
+    val allowedEventIds: SnapshotStateSet<EventId>
+    fun allowEvent(eventId: EventId)
+}
+
+@ContributesBinding(SessionScope::class)
+@SingleIn(SessionScope::class)
+class DefaultTimelineProtectionStore : TimelineProtectionStore {
+    private val allowedEvents = mutableStateSetOf<EventId>()
+
+    override val allowedEventIds: SnapshotStateSet<EventId> = allowedEvents
+
+    override fun allowEvent(eventId: EventId) {
+        allowedEvents += eventId
+    }
+}

features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/timeline/TimelineViewTest.kt

@@ -13,8 +13,12 @@ package io.element.android.features.messages.impl.timeline
 import androidx.activity.ComponentActivity
 import androidx.compose.ui.test.AndroidComposeUiTest
 import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onFirst
 import androidx.compose.ui.test.onNodeWithContentDescription
 import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
 import androidx.compose.ui.test.performScrollToIndex
 import androidx.compose.ui.test.v2.runAndroidComposeUiTest
@@ -29,8 +33,14 @@ import io.element.android.features.messages.impl.timeline.protection.aTimelinePr
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.UniqueId
 import io.element.android.libraries.matrix.api.timeline.Timeline
+import io.element.android.libraries.matrix.api.timeline.item.event.MessageContent
 import io.element.android.libraries.matrix.api.timeline.item.event.MessageShield
+import io.element.android.libraries.matrix.api.timeline.item.event.TextMessageType
 import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.test.AN_EVENT_ID
+import io.element.android.libraries.matrix.test.A_USER_ID
+import io.element.android.libraries.matrix.ui.messages.reply.InReplyToDetails
+import io.element.android.libraries.matrix.ui.messages.reply.aProfileDetailsReady
 import io.element.android.libraries.ui.strings.CommonStrings
 import io.element.android.tests.testutils.EnsureNeverCalledWithParam
 import io.element.android.tests.testutils.EnsureNeverCalledWithTwoParams
@@ -168,6 +178,61 @@ class TimelineViewTest : RobolectricTest() {
         eventsRecorder.assertSingle(TimelineEvent.HideShieldDialog)
     }
 
+    @Test
+    fun `clicking on a reply to a loaded event emits the expected Event`() = runAndroidComposeUiTest {
+        val eventsRecorder = EventsRecorder<TimelineEvent>()
+        setTimelineView(
+            state = aTimelineState(
+                timelineItems = persistentListOf(
+                    aTimelineItemEvent(
+                        content = aTimelineItemTextContent(),
+                        inReplyTo = InReplyToDetails.Ready(
+                            eventId = AN_EVENT_ID,
+                            senderId = A_USER_ID,
+                            senderProfile = aProfileDetailsReady(),
+                            eventContent = MessageContent(
+                                body = "Replied message",
+                                inReplyTo = null,
+                                isEdited = false,
+                                threadInfo = null,
+                                type = TextMessageType("Replied message", null),
+                            ),
+                            textContent = "Replied message",
+                        ),
+                    ),
+                ),
+                eventSink = eventsRecorder,
+            ),
+        )
+        eventsRecorder.clear()
+
+        onAllNodesWithText("Replied message").onFirst().performClick()
+        eventsRecorder.assertSingle(TimelineEvent.FocusOnEvent(AN_EVENT_ID))
+    }
+
+    @Test
+    fun `a reply to an event which could not be loaded renders a placeholder and does not emit any Event when clicked`() = runAndroidComposeUiTest {
+        val eventsRecorder = EventsRecorder<TimelineEvent>()
+        setTimelineView(
+            state = aTimelineState(
+                timelineItems = persistentListOf(
+                    aTimelineItemEvent(
+                        content = aTimelineItemTextContent(),
+                        inReplyTo = InReplyToDetails.Error(eventId = AN_EVENT_ID, message = "Failed to fetch the event"),
+                    ),
+                ),
+                eventSink = eventsRecorder,
+            ),
+            onMessageClick = {},
+        )
+        eventsRecorder.assertSingle(TimelineEvent.OnScrollFinished(firstIndex = 0))
+        eventsRecorder.clear()
+
+        onNodeWithText("Failed to fetch the event").assertDoesNotExist()
+        onNodeWithText(activity!!.getString(CommonStrings.error_message_not_found)).assertIsDisplayed().performClick()
+        eventsRecorder.assertEmpty()
+    }
+
     @Ignore(
         "performScrollToIndex in compose tests no longer sets LazyListState.isScrollInProgress to true, so the LoadMore event is not emitted." +
             "This needs to be reworked to use a different approach to check the LoadMore event was emitted."

features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/timeline/components/customreaction/ExpandSheetWhenImeIsVisibleTest.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalTestApi::class)
+
+package io.element.android.features.messages.impl.timeline.components.customreaction
+
+import android.view.View
+import androidx.activity.ComponentActivity
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.SheetState
+import androidx.compose.material3.SheetValue
+import androidx.compose.material3.rememberBottomSheetState
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.test.AndroidComposeUiTest
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.v2.runAndroidComposeUiTest
+import androidx.core.graphics.Insets
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.google.common.truth.Truth.assertThat
+import io.element.android.tests.testutils.robolectric.RobolectricTest
+import org.junit.Test
+
+class ExpandSheetWhenImeIsVisibleTest : RobolectricTest() {
+    @Test
+    fun `the sheet is left alone while the keyboard is hidden`() = runAndroidComposeUiTest<ComponentActivity> {
+        val sheetState = renderWithIme(isImeVisible = false)
+        assertThat(sheetState.currentValue).isEqualTo(SheetValue.PartiallyExpanded)
+    }
+
+    @Test
+    fun `the sheet is expanded when the keyboard is shown`() = runAndroidComposeUiTest<ComponentActivity> {
+        val sheetState = renderWithIme(isImeVisible = true)
+        assertThat(sheetState.currentValue).isEqualTo(SheetValue.Expanded)
+    }
+}
+
+private fun AndroidComposeUiTest<ComponentActivity>.renderWithIme(isImeVisible: Boolean): SheetState {
+    lateinit var sheetState: SheetState
+    lateinit var view: View
+    setContent {
+        view = LocalView.current
+        sheetState = rememberBottomSheetState(initialValue = SheetValue.PartiallyExpanded)
+        ExpandSheetWhenImeIsVisible(sheetState)
+    }
+    runOnIdle {
+        ViewCompat.dispatchApplyWindowInsets(
+            view,
+            WindowInsetsCompat.Builder()
+                .setVisible(WindowInsetsCompat.Type.ime(), isImeVisible)
+                .setInsets(WindowInsetsCompat.Type.ime(), if (isImeVisible) Insets.of(0, 0, 0, 300) else Insets.NONE)
+                .build()
+        )
+    }
+    waitForIdle()
+    return sheetState
+}

features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/timeline/protection/TimelineProtectionPresenterTest.kt

@@ -95,6 +95,24 @@ class TimelineProtectionPresenterTest {
         }
     }
 
+    @Test
+    fun `present - shown content is restored when the presenter is recreated`() = runTest {
+        val mediaPreviewConfig = MediaPreviewConfig(mediaPreviewValue = MediaPreviewValue.Off, hideInviteAvatar = false)
+        val mediaPreviewService = FakeMediaPreviewService(mediaPreviewConfigFlow = MutableStateFlow(mediaPreviewConfig))
+        val timelineProtectionStore = DefaultTimelineProtectionStore()
+        createPresenter(mediaPreviewService = mediaPreviewService, timelineProtectionStore = timelineProtectionStore).test {
+            val initialState = awaitItem()
+            assertThat(initialState.protectionState).isEqualTo(ProtectionState.RenderOnly(persistentSetOf()))
+            initialState.eventSink(TimelineProtectionEvent.ShowContent(eventId = AN_EVENT_ID))
+            val finalState = awaitItem()
+            assertThat(finalState.protectionState).isEqualTo(ProtectionState.RenderOnly(persistentSetOf(AN_EVENT_ID)))
+        }
+        createPresenter(mediaPreviewService = mediaPreviewService, timelineProtectionStore = timelineProtectionStore).test {
+            val initialState = awaitItem()
+            assertThat(initialState.protectionState).isEqualTo(ProtectionState.RenderOnly(persistentSetOf(AN_EVENT_ID)))
+        }
+    }
+
     @OptIn(ExperimentalCoroutinesApi::class)
     @Test
     fun `present - validate media scans the media source`() = runTest {
@@ -134,9 +152,11 @@ class TimelineProtectionPresenterTest {
         room: BaseRoom = FakeBaseRoom(),
         mediaPreviewService: MediaPreviewService = FakeMediaPreviewService(),
         contentScannerService: ContentScannerService = ContentScannerService { _: List<MediaSource>, _: ContentValidationState -> },
+        timelineProtectionStore: TimelineProtectionStore = DefaultTimelineProtectionStore(),
     ) = TimelineProtectionPresenter(
         mediaPreviewService = mediaPreviewService,
         room = room,
         contentScannerService = contentScannerService,
+        timelineProtectionStore = timelineProtectionStore,
     )
 }

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

@@ -37,6 +37,7 @@ import io.element.android.libraries.matrix.api.room.roomMembers
 import io.element.android.libraries.matrix.api.room.toMatrixUser
 import io.element.android.libraries.matrix.ui.room.PowerLevelRoomMemberComparator
 import io.element.android.libraries.matrix.ui.room.roomMemberIdentityStateChange
+import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.ImmutableMap
 import kotlinx.collections.immutable.persistentMapOf
 import kotlinx.collections.immutable.toImmutableList
@@ -58,6 +59,7 @@ class RoomMemberListPresenter(
     override fun present(): RoomMemberListState {
         val searchQuery = rememberTextFieldState()
         val membersState by room.membersStateFlow.collectAsState()
+        val roomInfo by room.roomInfoFlow.collectAsState()
         val canInvite by room.permissionsAsState(false) { perms -> perms.canOwnUserInvite() }
         val roomModerationState = roomMembersModerationPresenter.present()
 
@@ -72,13 +74,18 @@ class RoomMemberListPresenter(
         var selectedSection by remember { mutableStateOf(SelectedSection.MEMBERS) }
         var roomMembers: AsyncData<RoomMembers> by remember { mutableStateOf(AsyncData.Loading()) }
         var filteredRoomMembers: AsyncData<RoomMembers> by remember { mutableStateOf(AsyncData.Loading()) }
+        val activeCallParticipants = roomInfo.activeRoomCallParticipants
+
+        val comparator = remember(activeCallParticipants) {
+            roomMemberListComparator(activeCallParticipants)
+        }
 
         // Update the room members when the screen is loaded
         LaunchedEffect(Unit) {
             room.updateMembers()
         }
 
-        LaunchedEffect(membersState, roomMemberIdentityStates) {
+        LaunchedEffect(membersState, roomMemberIdentityStates, activeCallParticipants) {
             if (membersState is RoomMembersState.Unknown) {
                 return@LaunchedEffect
             }
@@ -90,23 +97,23 @@ class RoomMemberListPresenter(
             }
             withContext(coroutineDispatchers.io) {
                 val members = membersState.roomMembers().orEmpty().groupBy { it.membership }
-                val info = room.info()
-                if (members.getOrDefault(RoomMembershipState.JOIN, emptyList()).size < info.joinedMembersCount / 2) {
+                if (members.getOrDefault(RoomMembershipState.JOIN, emptyList()).size < roomInfo.joinedMembersCount / 2) {
                     // Don't display initial room member list if we have less than half of the joined members:
-                    // This result will come from the timeline loading membership events and it'll be wrong.
+                    // This result will come from the timeline loading membership events, and it'll be wrong.
                     return@withContext
                 }
                 val result = RoomMembers(
                     invited = members.getOrDefault(RoomMembershipState.INVITE, emptyList())
-                        .map { it.withIdentityState(roomMemberIdentityStates) }
+                        .map { it.withIdentityState(roomMemberIdentityStates, activeCallParticipants) }
                         .toImmutableList(),
                     joined = members.getOrDefault(RoomMembershipState.JOIN, emptyList())
-                        .sortedWith(powerLevelRoomMemberComparator)
-                        .map { it.withIdentityState(roomMemberIdentityStates) }
+                        .sortedWith(comparator)
+                        // .sortedWith(powerLevelRoomMemberComparator)
+                        .map { it.withIdentityState(roomMemberIdentityStates, activeCallParticipants) }
                         .toImmutableList(),
                     banned = members.getOrDefault(RoomMembershipState.BAN, emptyList())
                         .sortedBy { it.userId.value }
-                        .map { it.withIdentityState(roomMemberIdentityStates) }
+                        .map { it.withIdentityState(roomMemberIdentityStates, activeCallParticipants) }
                         .toImmutableList(),
                 )
                 roomMembers = if (membersState is RoomMembersState.Pending) {
@@ -150,12 +157,29 @@ class RoomMemberListPresenter(
         return state
     }
 
-    private suspend fun RoomMember.withIdentityState(identityStates: ImmutableMap<UserId, IdentityState>): RoomMemberWithIdentityState {
+    private suspend fun RoomMember.withIdentityState(
+        identityStates: ImmutableMap<UserId, IdentityState>,
+        activeCallParticipants: ImmutableList<UserId>
+    ): RoomMemberWithIdentityState {
         return if (room.info().isEncrypted != true) {
-            RoomMemberWithIdentityState(this, null)
+            RoomMemberWithIdentityState(this, null, userId in activeCallParticipants)
         } else {
             val identityState = identityStates[userId] ?: encryptionService.getUserIdentity(userId, fallbackToServer = false).getOrNull()
-            RoomMemberWithIdentityState(this, identityState)
+            RoomMemberWithIdentityState(this, identityState, userId in activeCallParticipants)
         }
     }
+
+    private fun roomMemberListComparator(
+        activeCallParticipants: List<UserId>,
+    ): Comparator<RoomMember> =
+        Comparator { a, b ->
+            val aInCall = a.userId in activeCallParticipants
+            val bInCall = b.userId in activeCallParticipants
+
+            when {
+                aInCall && !bInCall -> -1
+                !aInCall && bInCall -> 1
+                else -> powerLevelRoomMemberComparator.compare(a, b)
+            }
+        }
 }

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

@@ -66,4 +66,5 @@ data class RoomMembers(
 data class RoomMemberWithIdentityState(
     val roomMember: RoomMember,
     val identityState: IdentityState?,
+    val isInCall: Boolean
 )

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

@@ -78,7 +78,7 @@ private fun aLoadedRoomMembers() = AsyncData.Success(
         joined = persistentListOf(
             anAlice().withIdentity(identityState = IdentityState.Verified),
             aBob().withIdentity(identityState = IdentityState.PinViolation),
-            aCarol().withIdentity(),
+            aCarol().withIdentity(isInCall = true),
             aDavid().withIdentity(),
             anEve().withIdentity(identityState = IdentityState.VerificationViolation)
         ),
@@ -174,4 +174,8 @@ fun aBannedSusie(): RoomMember = aRoomMember(UserId("@susie:server.org"), USER_N
 
 fun aBannedMallory(): RoomMember = aRoomMember(UserId("@mallory:server.org"), USER_NAME_MALLORY, membership = RoomMembershipState.BAN)
 
-private fun RoomMember.withIdentity(identityState: IdentityState? = null) = RoomMemberWithIdentityState(this, identityState)
+private fun RoomMember.withIdentity(identityState: IdentityState? = null, isInCall: Boolean = false) = RoomMemberWithIdentityState(
+    this,
+    identityState,
+    isInCall
+)

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

@@ -338,6 +338,15 @@ private fun RoomMemberListItem(
                         color = ElementTheme.colors.textSecondary,
                     )
                 }
+
+                if (roomMemberWithIdentity.isInCall) {
+                    Icon(
+                        modifier = Modifier.size(20.dp),
+                        imageVector = CompoundIcons.VideoCallSolid(),
+                        contentDescription = stringResource(CommonStrings.action_video_call),
+                        tint = ElementTheme.colors.iconSuccessPrimary
+                    )
+                }
             }
         }
     )

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

@@ -191,6 +191,38 @@ class RoomMemberListPresenterTest {
             awaitItem().eventSink(RoomMemberListEvent.RoomMemberSelected(anInvitedVictor()))
         }
     }
+
+    @Test
+    fun `call participants are shown first in joined members`() = runTest {
+        val room = createFakeJoinedRoom().apply {
+            givenRoomInfo(
+                aRoomInfo(
+                    joinedMembersCount = 5,
+                    activeRoomCallParticipants = listOf(
+                        aCarol().userId
+                    ),
+                )
+            )
+            givenRoomMembersState(RoomMembersState.Ready(aRoomMemberList()))
+        }
+
+        val presenter = createPresenter(joinedRoom = room)
+
+        presenter.test {
+            skipItems(1)
+
+            val loadedState = awaitItem()
+            val joined = loadedState.filteredRoomMembers.dataOrNull()!!.joined
+
+            assertThat(joined.first().roomMember.userId)
+                .isEqualTo(aCarol().userId)
+
+            assertThat(joined.first().isInCall).isTrue()
+
+            assertThat(joined.count { it.isInCall }).isEqualTo(1)
+            assertThat(joined.drop(1).all { !it.isInCall }).isTrue()
+        }
+    }
 }
 
 private fun createFakeJoinedRoom(