Merge branch 'develop' into feature/fga/update-rust-sdk-0.1.31

2023-07-12 17:36:05 +02:00 · 2023-07-12 17:36:05 +02:00 · c8776f9806
commit c8776f9806
parent 600cd778e8 1e45235c64
29 changed files with 223 additions and 88 deletions
--- a/.github/workflows/nightlyReports.yml
+++ b/.github/workflows/nightlyReports.yml
@ -26,6 +26,9 @@ jobs:
          distribution: 'temurin' # See 'Supported distributions' for available options
          java-version: '17'

+      - name: ⚙️ Run unit & screenshot tests, debug and release
+        run: ./gradlew test $CI_GRADLE_ARG_PROPERTIES -Pci-build=true
+
      - name: ⚙️ Run unit & screenshot tests, generate kover report
        run: ./gradlew koverMergedReport $CI_GRADLE_ARG_PROPERTIES -Pci-build=true

--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@ -37,6 +37,9 @@ jobs:
        with:
          cache-read-only: ${{ github.ref != 'refs/heads/develop' }}

+      - name: ⚙️ Run unit & screenshot tests, debug and release
+        run: ./gradlew test $CI_GRADLE_ARG_PROPERTIES -Pci-build=true
+
      - name: ⚙️ Run unit & screenshot tests, generate kover report
        run: ./gradlew koverMergedReport $CI_GRADLE_ARG_PROPERTIES -Pci-build=true

--- a/app/src/main/kotlin/io/element/android/x/MainActivity.kt
+++ b/app/src/main/kotlin/io/element/android/x/MainActivity.kt
@ -52,8 +52,7 @@ class MainActivity : NodeComponentActivity() {
        Timber.tag(loggerTag.value).w("onCreate, with savedInstanceState: ${savedInstanceState != null}")
        installSplashScreen()
        super.onCreate(savedInstanceState)
-        appBindings = bindings<AppBindings>()
-        appBindings.matrixClientsHolder().restore(savedInstanceState)
+        appBindings = bindings()
        WindowCompat.setDecorFitsSystemWindows(window, false)
        setContent {
            MainContent(appBindings)
@ -125,9 +124,4 @@ class MainActivity : NodeComponentActivity() {
        super.onDestroy()
        Timber.tag(loggerTag.value).w("onDestroy")
    }
-
-    override fun onSaveInstanceState(outState: Bundle) {
-        super.onSaveInstanceState(outState)
-        bindings<AppBindings>().matrixClientsHolder().onSaveInstanceState(outState)
-    }
 }
--- a/app/src/main/kotlin/io/element/android/x/di/AppBindings.kt
+++ b/app/src/main/kotlin/io/element/android/x/di/AppBindings.kt
@ -17,13 +17,11 @@
 package io.element.android.x.di

 import com.squareup.anvil.annotations.ContributesTo
-import io.element.android.appnav.di.MatrixClientsHolder
 import io.element.android.libraries.designsystem.utils.SnackbarDispatcher
 import io.element.android.libraries.di.AppScope

@ContributesTo(AppScope::class)
 interface AppBindings {
-    fun matrixClientsHolder(): MatrixClientsHolder
    fun mainDaggerComponentOwner(): MainDaggerComponentsOwner
    fun snackbarDispatcher(): SnackbarDispatcher
 }
--- a/appnav/src/main/kotlin/io/element/android/appnav/LoggedInFlowNode.kt
+++ b/appnav/src/main/kotlin/io/element/android/appnav/LoggedInFlowNode.kt
@ -154,8 +154,6 @@ class LoggedInFlowNode @AssistedInject constructor(
                syncService.stopSync()
            },
            onDestroy = {
-                val imageLoaderFactory = bindings<MatrixUIBindings>().notLoggedInImageLoaderFactory()
-                Coil.setImageLoader(imageLoaderFactory)
                plugins<LifecycleCallback>().forEach { it.onFlowReleased(id, inputs.matrixClient) }
                appNavigationStateService.onLeavingSpace(id)
                appNavigationStateService.onLeavingSession(id)
--- a/appnav/src/main/kotlin/io/element/android/appnav/NotLoggedInFlowNode.kt
+++ b/appnav/src/main/kotlin/io/element/android/appnav/NotLoggedInFlowNode.kt
@ -19,6 +19,7 @@ package io.element.android.appnav
 import android.os.Parcelable
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import coil.Coil
 import com.bumble.appyx.core.composable.Children
 import com.bumble.appyx.core.lifecycle.subscribe
 import com.bumble.appyx.core.modality.BuildContext
@ -34,8 +35,8 @@ import io.element.android.features.onboarding.api.OnBoardingEntryPoint
 import io.element.android.libraries.architecture.BackstackNode
 import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
 import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.matrix.ui.media.NotLoggedInImageLoaderFactory
 import kotlinx.parcelize.Parcelize
-import timber.log.Timber

@ContributesNode(AppScope::class)
 class NotLoggedInFlowNode @AssistedInject constructor(
@ -43,6 +44,7 @@ class NotLoggedInFlowNode @AssistedInject constructor(
    @Assisted plugins: List<Plugin>,
    private val onBoardingEntryPoint: OnBoardingEntryPoint,
    private val loginEntryPoint: LoginEntryPoint,
+    private val notLoggedInImageLoaderFactory: NotLoggedInImageLoaderFactory,
 ) : BackstackNode<NotLoggedInFlowNode.NavTarget>(
    backstack = BackStack(
        initialElement = NavTarget.OnBoarding,
@ -51,10 +53,12 @@ class NotLoggedInFlowNode @AssistedInject constructor(
    buildContext = buildContext,
    plugins = plugins,
 ) {
-    init {
+    override fun onBuilt() {
+        super.onBuilt()
        lifecycle.subscribe(
-            onCreate = { Timber.v("OnCreate") },
-            onDestroy = { Timber.v("OnDestroy") }
+            onCreate = {
+                Coil.setImageLoader(notLoggedInImageLoaderFactory)
+            },
        )
    }

--- a/appnav/src/main/kotlin/io/element/android/appnav/RootFlowNode.kt
+++ b/appnav/src/main/kotlin/io/element/android/appnav/RootFlowNode.kt
@ -30,6 +30,7 @@ import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.node.node
 import com.bumble.appyx.core.plugin.Plugin
 import com.bumble.appyx.core.plugin.plugins
+import com.bumble.appyx.core.state.MutableSavedStateMap
 import com.bumble.appyx.navmodel.backstack.BackStack
 import com.bumble.appyx.navmodel.backstack.operation.pop
 import com.bumble.appyx.navmodel.backstack.operation.push
@ -90,10 +91,16 @@ class RootFlowNode @AssistedInject constructor(
    ) {

    override fun onBuilt() {
+        matrixClientsHolder.restore(buildContext.savedStateMap)
        super.onBuilt()
        observeLoggedInState()
    }

+    override fun onSaveInstanceState(state: MutableSavedStateMap) {
+        super.onSaveInstanceState(state)
+        matrixClientsHolder.save(state)
+    }
+
    private fun observeLoggedInState() {
        combine(
            cacheService.onClearedCacheEventFlow(),
--- a/appnav/src/main/kotlin/io/element/android/appnav/di/MatrixClientsHolder.kt
+++ b/appnav/src/main/kotlin/io/element/android/appnav/di/MatrixClientsHolder.kt
@ -16,13 +16,11 @@

 package io.element.android.appnav.di

-import android.os.Bundle
-import io.element.android.libraries.di.AppScope
-import io.element.android.libraries.di.SingleIn
+import com.bumble.appyx.core.state.MutableSavedStateMap
+import com.bumble.appyx.core.state.SavedStateMap
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.api.core.SessionId
-import io.element.android.libraries.matrix.api.core.UserId
 import kotlinx.coroutines.runBlocking
 import timber.log.Timber
 import java.util.concurrent.ConcurrentHashMap
@ -30,7 +28,6 @@ import javax.inject.Inject

 private const val SAVE_INSTANCE_KEY = "io.element.android.x.di.MatrixClientsHolder.SaveInstanceKey"

-@SingleIn(AppScope::class)
 class MatrixClientsHolder @Inject constructor(private val authenticationService: MatrixAuthenticationService) {

    private val sessionIdsToMatrixClient = ConcurrentHashMap<SessionId, MatrixClient>()
@ -55,16 +52,20 @@ class MatrixClientsHolder @Inject constructor(private val authenticationService:
        return sessionIdsToMatrixClient[sessionId]
    }

-    @Suppress("DEPRECATION")
-    fun restore(savedInstanceState: Bundle?) {
-        if (savedInstanceState == null || sessionIdsToMatrixClient.isNotEmpty()) return
-        val userIds = savedInstanceState.getSerializable(SAVE_INSTANCE_KEY) as? Array<UserId>
-        if (userIds.isNullOrEmpty()) return
+    @Suppress("UNCHECKED_CAST")
+    fun restore(state: SavedStateMap?) {
+        Timber.d("Restore state")
+        if (state == null || sessionIdsToMatrixClient.isNotEmpty()) return Unit.also {
+            Timber.w("Restore with non-empty map")
+        }
+        val sessionIds = state[SAVE_INSTANCE_KEY] as? Array<SessionId>
+        Timber.d("Restore matrix session keys = ${sessionIds?.map { it.value }}")
+        if (sessionIds.isNullOrEmpty()) return
        // Not ideal but should only happens in case of process recreation. This ensure we restore all the active sessions before restoring the node graphs.
        runBlocking {
-            userIds.forEach { userId ->
-                Timber.v("Restore matrix session: $userId")
-                authenticationService.restoreSession(userId)
+            sessionIds.forEach { sessionId ->
+                Timber.d("Restore matrix session: $sessionId")
+                authenticationService.restoreSession(sessionId)
                    .onSuccess { matrixClient ->
                        add(matrixClient)
                    }
@ -75,9 +76,9 @@ class MatrixClientsHolder @Inject constructor(private val authenticationService:
        }
    }

-    fun onSaveInstanceState(outState: Bundle) {
+    fun save(state: MutableSavedStateMap) {
        val sessionKeys = sessionIdsToMatrixClient.keys.toTypedArray()
-        Timber.v("Save matrix session keys = $sessionKeys")
-        outState.putSerializable(SAVE_INSTANCE_KEY, sessionKeys)
+        Timber.d("Save matrix session keys = ${sessionKeys.map { it.value }}")
+        state[SAVE_INSTANCE_KEY] = sessionKeys
    }
 }
--- a/features/messages/impl/src/test/kotlin/io/element/android/features/messages/forward/ForwardMessagesPresenterTests.kt
+++ b/features/messages/impl/src/test/kotlin/io/element/android/features/messages/forward/ForwardMessagesPresenterTests.kt
@ -65,7 +65,6 @@ class ForwardMessagesPresenterTests {
        }.test {
            val initialState = awaitItem()
            skipItems(1)
-            val summary = aRoomSummaryDetail()

            initialState.eventSink(ForwardMessagesEvents.ToggleSearchActive)
            assertThat(awaitItem().isSearchActive).isTrue()
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/blockuser/BlockUserSection.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/blockuser/BlockUserSection.kt
@ -25,28 +25,65 @@ import androidx.compose.ui.res.stringResource
 import io.element.android.features.roomdetails.impl.R
 import io.element.android.features.roomdetails.impl.members.details.RoomMemberDetailsEvents
 import io.element.android.features.roomdetails.impl.members.details.RoomMemberDetailsState
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.core.bool.orFalse
 import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
+import io.element.android.libraries.designsystem.components.dialogs.RetryDialog
 import io.element.android.libraries.designsystem.components.preferences.PreferenceCategory
 import io.element.android.libraries.designsystem.components.preferences.PreferenceText
+import io.element.android.libraries.ui.strings.CommonStrings

@Composable
 internal fun BlockUserSection(state: RoomMemberDetailsState, modifier: Modifier = Modifier) {
    PreferenceCategory(showDivider = false, modifier = modifier) {
-        if (state.isBlocked) {
-            PreferenceText(
-                title = stringResource(R.string.screen_dm_details_unblock_user),
-                icon = Icons.Outlined.Block,
-                onClick = { state.eventSink(RoomMemberDetailsEvents.UnblockUser(needsConfirmation = true)) },
-            )
-        } else {
-            PreferenceText(
-                title = stringResource(R.string.screen_dm_details_block_user),
-                icon = Icons.Outlined.Block,
-                tintColor = MaterialTheme.colorScheme.error,
-                onClick = { state.eventSink(RoomMemberDetailsEvents.BlockUser(needsConfirmation = true)) },
-            )
+        when (state.isBlocked) {
+            is Async.Failure -> PreferenceBlockUser(isBlocked = state.isBlocked.prevData, isLoading = false, eventSink = state.eventSink)
+            is Async.Loading -> PreferenceBlockUser(isBlocked = state.isBlocked.prevData, isLoading = true, eventSink = state.eventSink)
+            is Async.Success -> PreferenceBlockUser(isBlocked = state.isBlocked.data, isLoading = false, eventSink = state.eventSink)
+            Async.Uninitialized -> PreferenceBlockUser(isBlocked = null, isLoading = true, eventSink = state.eventSink)
        }
    }
+    if (state.isBlocked is Async.Failure) {
+        RetryDialog(
+            content = stringResource(CommonStrings.error_unknown),
+            onDismiss = { state.eventSink(RoomMemberDetailsEvents.ClearBlockUserError) },
+            onRetry = {
+                val event = when (state.isBlocked.prevData) {
+                    true -> RoomMemberDetailsEvents.UnblockUser(needsConfirmation = false)
+                    false -> RoomMemberDetailsEvents.BlockUser(needsConfirmation = false)
+                    null -> /*Should not happen */ RoomMemberDetailsEvents.ClearBlockUserError
+                }
+                state.eventSink(event)
+            },
+        )
+    }
+}
+
+@Composable
+private fun PreferenceBlockUser(
+    isBlocked: Boolean?,
+    isLoading: Boolean,
+    eventSink: (RoomMemberDetailsEvents) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    if (isBlocked.orFalse()) {
+        PreferenceText(
+            title = stringResource(R.string.screen_dm_details_unblock_user),
+            icon = Icons.Outlined.Block,
+            onClick = { if (!isLoading) eventSink(RoomMemberDetailsEvents.UnblockUser(needsConfirmation = true)) },
+            loadingCurrentValue = isLoading,
+            modifier = modifier,
+        )
+    } else {
+        PreferenceText(
+            title = stringResource(R.string.screen_dm_details_block_user),
+            icon = Icons.Outlined.Block,
+            tintColor = MaterialTheme.colorScheme.error,
+            onClick = { if (!isLoading) eventSink(RoomMemberDetailsEvents.BlockUser(needsConfirmation = true)) },
+            loadingCurrentValue = isLoading,
+            modifier = modifier,
+        )
+    }
 }

@Composable
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsEvents.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsEvents.kt
@ -19,5 +19,6 @@ package io.element.android.features.roomdetails.impl.members.details
 sealed interface RoomMemberDetailsEvents {
    data class BlockUser(val needsConfirmation: Boolean = false) : RoomMemberDetailsEvents
    data class UnblockUser(val needsConfirmation: Boolean = false) : RoomMemberDetailsEvents
+    object ClearBlockUserError : RoomMemberDetailsEvents
    object ClearConfirmationDialog : RoomMemberDetailsEvents
 }
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsPresenter.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsPresenter.kt
@ -28,6 +28,7 @@ import androidx.compose.runtime.setValue
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.features.roomdetails.impl.members.details.RoomMemberDetailsState.ConfirmationDialog
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.core.bool.orFalse
 import io.element.android.libraries.matrix.api.MatrixClient
@ -53,8 +54,13 @@ class RoomMemberDetailsPresenter @AssistedInject constructor(
        var confirmationDialog by remember { mutableStateOf<ConfirmationDialog?>(null) }
        val roomMember by room.getRoomMemberAsState(roomMemberId)
        // the room member is not really live...
-        val isBlocked = remember {
-            mutableStateOf(roomMember?.isIgnored.orFalse())
+        val isBlocked: MutableState<Async<Boolean>> = remember(roomMember) {
+            val isIgnored = roomMember?.isIgnored
+            if (isIgnored == null) {
+                mutableStateOf(Async.Uninitialized)
+            } else {
+                mutableStateOf(Async.Success(isIgnored))
+            }
        }
        LaunchedEffect(Unit) {
            room.updateMembers()
@ -79,6 +85,9 @@ class RoomMemberDetailsPresenter @AssistedInject constructor(
                    }
                }
                RoomMemberDetailsEvents.ClearConfirmationDialog -> confirmationDialog = null
+                RoomMemberDetailsEvents.ClearBlockUserError -> {
+                    isBlocked.value = Async.Success(isBlocked.value.dataOrNull().orFalse())
+                }
            }
        }

@ -105,20 +114,31 @@ class RoomMemberDetailsPresenter @AssistedInject constructor(
        )
    }

-    private fun CoroutineScope.blockUser(userId: UserId, isBlockedState: MutableState<Boolean>) = launch {
+    private fun CoroutineScope.blockUser(userId: UserId, isBlockedState: MutableState<Async<Boolean>>) = launch {
+        isBlockedState.value = Async.Loading(false)
        client.ignoreUser(userId)
-            .map {
-                isBlockedState.value = true
-                room.updateMembers()
-            }
-
+            .fold(
+                onSuccess = {
+                    isBlockedState.value = Async.Success(true)
+                    room.updateMembers()
+                },
+                onFailure = {
+                    isBlockedState.value = Async.Failure(it, false)
+                }
+            )
    }

-    private fun CoroutineScope.unblockUser(userId: UserId, isBlockedState: MutableState<Boolean>) = launch {
+    private fun CoroutineScope.unblockUser(userId: UserId, isBlockedState: MutableState<Async<Boolean>>) = launch {
+        isBlockedState.value = Async.Loading(true)
        client.unignoreUser(userId)
-            .map {
-                isBlockedState.value = false
-                room.updateMembers()
-            }
+            .fold(
+                onSuccess = {
+                    isBlockedState.value = Async.Success(false)
+                    room.updateMembers()
+                },
+                onFailure = {
+                    isBlockedState.value = Async.Failure(it, true)
+                }
+            )
    }
 }
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsState.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsState.kt
@ -16,11 +16,13 @@

 package io.element.android.features.roomdetails.impl.members.details

+import io.element.android.libraries.architecture.Async
+
 data class RoomMemberDetailsState(
    val userId: String,
    val userName: String?,
    val avatarUrl: String?,
-    val isBlocked: Boolean,
+    val isBlocked: Async<Boolean>,
    val displayConfirmationDialog: ConfirmationDialog? = null,
    val isCurrentUser: Boolean,
    val eventSink: (RoomMemberDetailsEvents) -> Unit
--- a/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsStateProvider.kt
+++ b/features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsStateProvider.kt
@ -17,15 +17,17 @@
 package io.element.android.features.roomdetails.impl.members.details

 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.architecture.Async

 open class RoomMemberDetailsStateProvider : PreviewParameterProvider<RoomMemberDetailsState> {
    override val values: Sequence<RoomMemberDetailsState>
        get() = sequenceOf(
            aRoomMemberDetailsState(),
            aRoomMemberDetailsState().copy(userName = null),
-            aRoomMemberDetailsState().copy(isBlocked = true),
+            aRoomMemberDetailsState().copy(isBlocked = Async.Success(true)),
            aRoomMemberDetailsState().copy(displayConfirmationDialog = RoomMemberDetailsState.ConfirmationDialog.Block),
            aRoomMemberDetailsState().copy(displayConfirmationDialog = RoomMemberDetailsState.ConfirmationDialog.Unblock),
+            aRoomMemberDetailsState().copy(isBlocked = Async.Loading(true)),
            // Add other states here
        )
 }
@ -34,7 +36,7 @@ fun aRoomMemberDetailsState() = RoomMemberDetailsState(
    userId = "@daniel:domain.com",
    userName = "Daniel",
    avatarUrl = null,
-    isBlocked = false,
+    isBlocked = Async.Success(false),
    isCurrentUser = false,
    eventSink = {},
 )
--- a/features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/members/details/RoomMemberDetailsPresenterTests.kt
+++ b/features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/members/details/RoomMemberDetailsPresenterTests.kt
@ -25,7 +25,9 @@ import io.element.android.features.roomdetails.impl.members.aRoomMember
 import io.element.android.features.roomdetails.impl.members.details.RoomMemberDetailsEvents
 import io.element.android.features.roomdetails.impl.members.details.RoomMemberDetailsPresenter
 import io.element.android.features.roomdetails.impl.members.details.RoomMemberDetailsState
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.api.room.MatrixRoomMembersState
+import io.element.android.libraries.matrix.test.A_THROWABLE
 import io.element.android.libraries.matrix.test.FakeMatrixClient
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
@ -50,7 +52,7 @@ class RoomMemberDetailsPresenterTests {
            Truth.assertThat(initialState.userId).isEqualTo(roomMember.userId.value)
            Truth.assertThat(initialState.userName).isEqualTo(roomMember.displayName)
            Truth.assertThat(initialState.avatarUrl).isEqualTo(roomMember.avatarUrl)
-            Truth.assertThat(initialState.isBlocked).isEqualTo(roomMember.isIgnored)
+            Truth.assertThat(initialState.isBlocked).isEqualTo(Async.Success(roomMember.isIgnored))
            skipItems(1)
            val loadedState = awaitItem()
            Truth.assertThat(loadedState.userName).isEqualTo("A custom name")
@ -129,10 +131,33 @@ class RoomMemberDetailsPresenterTests {
        }.test {
            val initialState = awaitItem()
            initialState.eventSink(RoomMemberDetailsEvents.BlockUser(needsConfirmation = false))
-            Truth.assertThat(awaitItem().isBlocked).isTrue()
+            Truth.assertThat(awaitItem().isBlocked.isLoading()).isTrue()
+            Truth.assertThat(awaitItem().isBlocked.dataOrNull()).isTrue()

            initialState.eventSink(RoomMemberDetailsEvents.UnblockUser(needsConfirmation = false))
-            Truth.assertThat(awaitItem().isBlocked).isFalse()
+            Truth.assertThat(awaitItem().isBlocked.isLoading()).isTrue()
+            Truth.assertThat(awaitItem().isBlocked.dataOrNull()).isFalse()
+        }
+    }
+
+    @Test
+    fun `present - BlockUser with error`() = runTest {
+        val room = aMatrixRoom()
+        val roomMember = aRoomMember()
+        val matrixClient = FakeMatrixClient()
+        matrixClient.givenIgnoreUserResult(Result.failure(A_THROWABLE))
+        val presenter = RoomMemberDetailsPresenter(matrixClient, room, roomMember.userId)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(RoomMemberDetailsEvents.BlockUser(needsConfirmation = false))
+            Truth.assertThat(awaitItem().isBlocked.isLoading()).isTrue()
+            val errorState = awaitItem()
+            Truth.assertThat(errorState.isBlocked.errorOrNull()).isEqualTo(A_THROWABLE)
+            // Clear error
+            initialState.eventSink(RoomMemberDetailsEvents.ClearBlockUserError)
+            Truth.assertThat(awaitItem().isBlocked).isEqualTo(Async.Success(false))
        }
    }

--- a/libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/BackstackNode.kt
+++ b/libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/BackstackNode.kt
@ -19,6 +19,7 @@ package io.element.android.libraries.architecture
 import androidx.compose.runtime.Stable
 import com.bumble.appyx.core.children.ChildEntry
 import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.node.ParentNode
 import com.bumble.appyx.core.plugin.Plugin
 import com.bumble.appyx.navmodel.backstack.BackStack
@ -39,4 +40,15 @@ abstract class BackstackNode<NavTarget : Any>(
    buildContext = buildContext,
    plugins = plugins,
    childKeepMode = childKeepMode,
-)
+) {
+    override fun onBuilt() {
+        super.onBuilt()
+        lifecycle.logLifecycle(this::class.java.simpleName)
+        whenChildAttached<Node> { _, child ->
+            // BackstackNode will be logged by their parent.
+            if (child !is BackstackNode<*>) {
+                child.lifecycle.logLifecycle(child::class.java.simpleName)
+            }
+        }
+    }
+}
--- a/libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/LifecycleExt.kt
+++ b/libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/LifecycleExt.kt
@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.architecture
+
+import androidx.lifecycle.Lifecycle
+import com.bumble.appyx.core.lifecycle.subscribe
+import timber.log.Timber
+
+fun Lifecycle.logLifecycle(name: String) {
+    subscribe(
+        onCreate = { Timber.tag("Lifecycle").d("onCreate $name") },
+        onPause = { Timber.tag("Lifecycle").d("onPause $name") },
+        onResume = { Timber.tag("Lifecycle").d("onResume $name") },
+        onDestroy = { Timber.tag("Lifecycle").d("onDestroy $name") },
+    )
+}
--- a/libraries/core/src/main/kotlin/io/element/android/libraries/core/extensions/BasicExtensions.kt
+++ b/libraries/core/src/main/kotlin/io/element/android/libraries/core/extensions/BasicExtensions.kt
@ -64,7 +64,7 @@ fun String?.insertBeforeLast(insert: String, delimiter: String = "."): String {
 * Throws if length is < 1.
 */
 fun String.ellipsize(length: Int): String {
-    require(length > 1)
+    require(length >= 1)

    if (this.length <= length) {
        return this
--- a/libraries/deeplink/src/main/kotlin/io/element/android/libraries/deeplink/DeeplinkParser.kt
+++ b/libraries/deeplink/src/main/kotlin/io/element/android/libraries/deeplink/DeeplinkParser.kt
@ -18,7 +18,6 @@ package io.element.android.libraries.deeplink

 import android.content.Intent
 import android.net.Uri
-import io.element.android.libraries.core.data.tryOrNull
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.ThreadId
@ -37,21 +36,15 @@ class DeeplinkParser @Inject constructor() {
        if (host != HOST) return null
        val pathBits = path.orEmpty().split("/").drop(1)
        val sessionId = pathBits.elementAtOrNull(0)?.let(::SessionId) ?: return null
-        val screenPathComponent = pathBits.elementAtOrNull(1)
-        val roomId = tryOrNull { screenPathComponent?.let(::RoomId) }

-        return when {
-            roomId != null -> {
+        return when (val screenPathComponent = pathBits.elementAtOrNull(1)) {
+            null -> DeeplinkData.Root(sessionId)
+            DeepLinkPaths.INVITE_LIST -> DeeplinkData.InviteList(sessionId)
+            else -> {
+                val roomId = screenPathComponent.let(::RoomId)
                val threadId = pathBits.elementAtOrNull(2)?.let(::ThreadId)
                DeeplinkData.Room(sessionId, roomId, threadId)
            }
-            screenPathComponent == DeepLinkPaths.INVITE_LIST -> {
-                DeeplinkData.InviteList(sessionId)
-            }
-            screenPathComponent == null -> {
-                DeeplinkData.Root(sessionId)
-            }
-            else -> null
        }
    }
 }
--- a/libraries/eventformatter/impl/src/main/kotlin/io/element/android/libraries/eventformatter/impl/RoomMembershipContentFormatter.kt
+++ b/libraries/eventformatter/impl/src/main/kotlin/io/element/android/libraries/eventformatter/impl/RoomMembershipContentFormatter.kt
@ -34,7 +34,7 @@ class RoomMembershipContentFormatter @Inject constructor(
    ): CharSequence? {
        val userId = membershipContent.userId
        val memberIsYou = matrixClient.isMe(userId)
-        return when (val change = membershipContent.change) {
+        return when (membershipContent.change) {
            MembershipChange.JOINED -> if (memberIsYou) {
                sp.getString(R.string.state_event_room_join_by_you)
            } else {
--- a/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/room/MatrixRoom.kt
+++ b/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/room/MatrixRoom.kt
@ -86,7 +86,7 @@ interface MatrixRoom : Closeable {

    suspend fun toggleReaction(emoji: String, eventId: EventId): Result<Unit>

-    suspend fun forwardEvent(eventId: EventId, rooms: List<RoomId>): Result<Unit>
+    suspend fun forwardEvent(eventId: EventId, roomIds: List<RoomId>): Result<Unit>

    suspend fun retrySendMessage(transactionId: String): Result<Unit>

--- a/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/room/RoomSummaryDataSource.kt
+++ b/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/room/RoomSummaryDataSource.kt
@ -38,12 +38,13 @@ interface RoomSummaryDataSource {

 suspend fun RoomSummaryDataSource.awaitAllRoomsAreLoaded(timeout: Duration = Duration.INFINITE) {
    try {
+        Timber.d("awaitAllRoomsAreLoaded: wait")
        withTimeout(timeout) {
            allRoomsLoadingState().firstOrNull {
                it is RoomSummaryDataSource.LoadingState.Loaded
            }
        }
    } catch (timeoutException: TimeoutCancellationException) {
-        Timber.v("AwaitAllRooms: no response after $timeout")
+        Timber.d("awaitAllRoomsAreLoaded: no response after $timeout")
    }
 }
--- a/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/RoomListExtensions.kt
+++ b/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/RoomListExtensions.kt
@ -62,7 +62,7 @@ fun RoomListService.roomOrNull(roomId: String): RoomListItem? {
    return try {
        room(roomId)
    } catch (exception: RoomListException) {
-        Timber.e(exception, "Failed finding room with id=$roomId")
+        Timber.d(exception, "Failed finding room with id=$roomId.")
        return null
    }
 }
--- a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/FakeMatrixClient.kt
+++ b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/FakeMatrixClient.kt
@ -38,6 +38,7 @@ import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
 import io.element.android.libraries.matrix.test.room.FakeRoomSummaryDataSource
 import io.element.android.libraries.matrix.test.sync.FakeSyncService
 import io.element.android.libraries.matrix.test.verification.FakeSessionVerificationService
+import io.element.android.tests.testutils.simulateLongTask
 import kotlinx.coroutines.delay

 class FakeMatrixClient(
@ -72,11 +73,11 @@ class FakeMatrixClient(
        return findDmResult
    }

-    override suspend fun ignoreUser(userId: UserId): Result<Unit> {
+    override suspend fun ignoreUser(userId: UserId): Result<Unit> = simulateLongTask {
        return ignoreUserResult
    }

-    override suspend fun unignoreUser(userId: UserId): Result<Unit> {
+    override suspend fun unignoreUser(userId: UserId): Result<Unit> = simulateLongTask {
        return unignoreUserResult
    }

--- a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/room/FakeMatrixRoom.kt
+++ b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/room/FakeMatrixRoom.kt
@ -239,7 +239,7 @@ class FakeMatrixRoom(

    override suspend fun sendFile(file: File, fileInfo: FileInfo, progressCallback: ProgressCallback?): Result<Unit> = fakeSendMedia(progressCallback)

-    override suspend fun forwardEvent(eventId: EventId, rooms: List<RoomId>): Result<Unit> = simulateLongTask {
+    override suspend fun forwardEvent(eventId: EventId, roomIds: List<RoomId>): Result<Unit> = simulateLongTask {
        forwardEventResult
    }

--- a/libraries/matrixui/src/main/kotlin/io/element/android/libraries/matrix/ui/di/MatrixUIBindings.kt
+++ b/libraries/matrixui/src/main/kotlin/io/element/android/libraries/matrix/ui/di/MatrixUIBindings.kt
@ -19,10 +19,8 @@ package io.element.android.libraries.matrix.ui.di
 import com.squareup.anvil.annotations.ContributesTo
 import io.element.android.libraries.di.SessionScope
 import io.element.android.libraries.matrix.ui.media.LoggedInImageLoaderFactory
-import io.element.android.libraries.matrix.ui.media.NotLoggedInImageLoaderFactory

@ContributesTo(SessionScope::class)
 interface MatrixUIBindings {
    fun loggedInImageLoaderFactory(): LoggedInImageLoaderFactory
-    fun notLoggedInImageLoaderFactory(): NotLoggedInImageLoaderFactory
 }
--- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationFactory.kt
+++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationFactory.kt
@ -123,7 +123,7 @@ class NotificationFactory @Inject constructor(
        val roomMeta = roomNotifications.filterIsInstance<RoomNotification.Message>().map { it.meta }
        val invitationMeta = invitationNotifications.filterIsInstance<OneShotNotification.Append>().map { it.meta }
        val simpleMeta = simpleNotifications.filterIsInstance<OneShotNotification.Append>().map { it.meta }
-        val fallbackMeta = simpleNotifications.filterIsInstance<OneShotNotification.Append>().map { it.meta }
+        val fallbackMeta = fallbackNotifications.filterIsInstance<OneShotNotification.Append>().map { it.meta }
        return when {
            roomMeta.isEmpty() && invitationMeta.isEmpty() && simpleMeta.isEmpty() -> SummaryNotification.Removed
            else -> SummaryNotification.Update(
--- a/tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.roomdetails.impl.members.details_null_DefaultGroup_RoomMemberDetailsViewDarkPreview--3_3_null_5,NEXUS_5,1.0,en].png
+++ b/tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.roomdetails.impl.members.details_null_DefaultGroup_RoomMemberDetailsViewDarkPreview--3_3_null_5,NEXUS_5,1.0,en].png
@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7ca068387cff8faf728a989488e7c4b5b07983c4b24162ff82a14fd90b82d05
+size 20609
--- a/tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.roomdetails.impl.members.details_null_DefaultGroup_RoomMemberDetailsViewLightPreview--2_2_null_5,NEXUS_5,1.0,en].png
+++ b/tests/uitests/src/test/snapshots/images/io.element.android.tests.uitests_ScreenshotTest_preview_tests[io.element.android.features.roomdetails.impl.members.details_null_DefaultGroup_RoomMemberDetailsViewLightPreview--2_2_null_5,NEXUS_5,1.0,en].png
@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1599be0c5a37083c015378ee47a78a90dcf670f4df5d85dd25d39f4b2edbdf6
+size 21147