Merge branch 'develop' into feature/bma/leaveSpace

appnav/build.gradle.kts

@@ -26,9 +26,11 @@ dependencies {
     allFeaturesApi(project)
 
     implementation(projects.libraries.core)
+    implementation(projects.libraries.accountselect.api)
     implementation(projects.libraries.androidutils)
     implementation(projects.libraries.architecture)
     implementation(projects.libraries.deeplink.api)
+    implementation(projects.libraries.featureflag.api)
     implementation(projects.libraries.matrix.api)
     implementation(projects.libraries.oidc.api)
     implementation(projects.libraries.preferences.api)

appnav/src/main/kotlin/io/element/android/appnav/LoggedInAppScopeFlowNode.kt

@@ -57,6 +57,7 @@ class LoggedInAppScopeFlowNode(
 ), DependencyInjectionGraphOwner {
     interface Callback : Plugin {
         fun onOpenBugReport()
+        fun onAddAccount()
     }
 
     @Parcelize
@@ -83,6 +84,10 @@ class LoggedInAppScopeFlowNode(
             override fun onOpenBugReport() {
                 plugins<Callback>().forEach { it.onOpenBugReport() }
             }
+
+            override fun onAddAccount() {
+                plugins<Callback>().forEach { it.onAddAccount() }
+            }
         }
         return createNode<LoggedInFlowNode>(buildContext, listOf(callback))
     }

appnav/src/main/kotlin/io/element/android/appnav/LoggedInFlowNode.kt

@@ -76,7 +76,6 @@ import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.MAIN_SPACE
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.RoomIdOrAlias
-import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.core.toRoomIdOrAlias
 import io.element.android.libraries.matrix.api.permalink.PermalinkData
@@ -139,6 +138,7 @@ class LoggedInFlowNode(
 ) {
     interface Callback : Plugin {
         fun onOpenBugReport()
+        fun onAddAccount()
     }
 
     private val loggedInFlowProcessor = LoggedInEventProcessor(
@@ -393,6 +393,10 @@ class LoggedInFlowNode(
             }
             is NavTarget.Settings -> {
                 val callback = object : PreferencesEntryPoint.Callback {
+                    override fun onAddAccount() {
+                        plugins<Callback>().forEach { it.onAddAccount() }
+                    }
+
                     override fun onOpenBugReport() {
                         plugins<Callback>().forEach { it.onOpenBugReport() }
                     }
@@ -405,11 +409,7 @@ class LoggedInFlowNode(
                         backstack.push(NavTarget.Room(roomId.toRoomIdOrAlias(), initialElement = RoomNavigationTarget.NotificationSettings))
                     }
 
-                    override fun navigateTo(sessionId: SessionId, roomId: RoomId, eventId: EventId) {
+                    override fun navigateTo(roomId: RoomId, eventId: EventId) {
-                        // We do not check the sessionId, but it will have to be done at some point (multi account)
-                        if (sessionId != matrixClient.sessionId) {
-                            Timber.e("SessionId mismatch, expected ${matrixClient.sessionId} but got $sessionId")
-                        }
                         backstack.push(NavTarget.Room(roomId.toRoomIdOrAlias(), initialElement = RoomNavigationTarget.Messages(eventId)))
                     }
                 }

appnav/src/main/kotlin/io/element/android/appnav/RootFlowNode.kt

@@ -9,6 +9,8 @@ package io.element.android.appnav
 
 import android.content.Intent
 import android.os.Parcelable
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.spring
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
@@ -23,6 +25,8 @@ 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
+import com.bumble.appyx.navmodel.backstack.transitionhandler.rememberBackstackFader
+import com.bumble.appyx.navmodel.backstack.transitionhandler.rememberBackstackSlider
 import dev.zacsweers.metro.AppScope
 import dev.zacsweers.metro.Assisted
 import dev.zacsweers.metro.AssistedInject
@@ -39,13 +43,17 @@ import io.element.android.features.login.api.accesscontrol.AccountProviderAccess
 import io.element.android.features.rageshake.api.bugreport.BugReportEntryPoint
 import io.element.android.features.rageshake.api.reporter.BugReporter
 import io.element.android.features.signedout.api.SignedOutEntryPoint
+import io.element.android.libraries.accountselect.api.AccountSelectEntryPoint
 import io.element.android.libraries.architecture.BackstackView
 import io.element.android.libraries.architecture.BaseFlowNode
+import io.element.android.libraries.architecture.appyx.rememberDelegateTransitionHandler
 import io.element.android.libraries.architecture.createNode
 import io.element.android.libraries.architecture.waitForChildAttached
 import io.element.android.libraries.core.uri.ensureProtocol
 import io.element.android.libraries.deeplink.api.DeeplinkData
 import io.element.android.libraries.designsystem.theme.components.CircularProgressIndicator
+import io.element.android.libraries.featureflag.api.FeatureFlagService
+import io.element.android.libraries.featureflag.api.FeatureFlags
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.toRoomIdOrAlias
 import io.element.android.libraries.matrix.api.permalink.PermalinkData
@@ -56,12 +64,11 @@ import io.element.android.libraries.sessionstorage.api.SessionStore
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
 import kotlinx.parcelize.Parcelize
 import timber.log.Timber
 
-@ContributesNode(AppScope::class)
+@ContributesNode(AppScope::class) @AssistedInject class RootFlowNode(
-@AssistedInject
-class RootFlowNode(
     @Assisted val buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
     private val sessionStore: SessionStore,
@@ -71,9 +78,11 @@ class RootFlowNode(
     private val presenter: RootPresenter,
     private val bugReportEntryPoint: BugReportEntryPoint,
     private val signedOutEntryPoint: SignedOutEntryPoint,
+    private val accountSelectEntryPoint: AccountSelectEntryPoint,
     private val intentResolver: IntentResolver,
     private val oidcActionFlow: OidcActionFlow,
     private val bugReporter: BugReporter,
+    private val featureFlagService: FeatureFlagService,
 ) : BaseFlowNode<RootFlowNode.NavTarget>(
     backstack = BackStack(
         initialElement = NavTarget.SplashScreen,
@@ -95,27 +104,24 @@ class RootFlowNode(
     }
 
     private fun observeNavState() {
-        navStateFlowFactory.create(buildContext.savedStateMap)
+        navStateFlowFactory.create(buildContext.savedStateMap).distinctUntilChanged().onEach { navState ->
-            .distinctUntilChanged()
+            Timber.v("navState=$navState")
-            .onEach { navState ->
+            when (navState.loggedInState) {
-                Timber.v("navState=$navState")
+                is LoggedInState.LoggedIn -> {
-                when (navState.loggedInState) {
+                    if (navState.loggedInState.isTokenValid) {
-                    is LoggedInState.LoggedIn -> {
+                        tryToRestoreLatestSession(
-                        if (navState.loggedInState.isTokenValid) {
+                            onSuccess = { sessionId -> switchToLoggedInFlow(sessionId, navState.cacheIndex) },
-                            tryToRestoreLatestSession(
+                            onFailure = { switchToNotLoggedInFlow(null) }
-                                onSuccess = { sessionId -> switchToLoggedInFlow(sessionId, navState.cacheIndex) },
+                        )
-                                onFailure = { switchToNotLoggedInFlow(null) }
+                    } else {
-                            )
+                        switchToSignedOutFlow(SessionId(navState.loggedInState.sessionId))
-                        } else {
-                            switchToSignedOutFlow(SessionId(navState.loggedInState.sessionId))
-                        }
-                    }
-                    LoggedInState.NotLoggedIn -> {
-                        switchToNotLoggedInFlow(null)
                     }
                 }
+                LoggedInState.NotLoggedIn -> {
+                    switchToNotLoggedInFlow(null)
+                }
             }
-            .launchIn(lifecycleScope)
+        }.launchIn(lifecycleScope)
     }
 
     private fun switchToLoggedInFlow(sessionId: SessionId, navId: Int) {
@@ -137,20 +143,17 @@ class RootFlowNode(
         onFailure: () -> Unit,
         onSuccess: (SessionId) -> Unit,
     ) {
-        matrixSessionCache.getOrRestore(sessionId)
+        matrixSessionCache.getOrRestore(sessionId).onSuccess {
-            .onSuccess {
+            Timber.v("Succeed to restore session $sessionId")
-                Timber.v("Succeed to restore session $sessionId")
+            onSuccess(sessionId)
-                onSuccess(sessionId)
+        }.onFailure {
-            }
+            Timber.e(it, "Failed to restore session $sessionId")
-            .onFailure {
+            onFailure()
-                Timber.e(it, "Failed to restore session $sessionId")
+        }
-                onFailure()
-            }
     }
 
     private suspend fun tryToRestoreLatestSession(
-        onSuccess: (SessionId) -> Unit,
+        onSuccess: (SessionId) -> Unit, onFailure: () -> Unit
-        onFailure: () -> Unit
     ) {
         val latestSessionId = sessionStore.getLatestSessionId()
         if (latestSessionId == null) {
@@ -172,32 +175,45 @@ class RootFlowNode(
             modifier = modifier,
             onOpenBugReport = this::onOpenBugReport,
         ) {
-            BackstackView()
+            val backstackSlider = rememberBackstackSlider<NavTarget>(
+                transitionSpec = { spring(stiffness = Spring.StiffnessMediumLow) },
+            )
+            val backstackFader = rememberBackstackFader<NavTarget>(
+                transitionSpec = { spring(stiffness = Spring.StiffnessMediumLow) },
+            )
+            val transitionHandler = rememberDelegateTransitionHandler<NavTarget, BackStack.State> { navTarget ->
+                when (navTarget) {
+                    is NavTarget.SplashScreen,
+                    is NavTarget.LoggedInFlow -> backstackFader
+                    else -> backstackSlider
+                }
+            }
+            BackstackView(transitionHandler = transitionHandler)
         }
     }
 
     sealed interface NavTarget : Parcelable {
-        @Parcelize
+        @Parcelize data object SplashScreen : NavTarget
-        data object SplashScreen : NavTarget
 
-        @Parcelize
+        @Parcelize data class AccountSelect(
-        data class NotLoggedInFlow(
+            val currentSessionId: SessionId,
+            val intent: Intent?,
+            val permalinkData: PermalinkData?,
+        ) : NavTarget
+
+        @Parcelize data class NotLoggedInFlow(
             val params: LoginParams?
         ) : NavTarget
 
-        @Parcelize
+        @Parcelize data class LoggedInFlow(
-        data class LoggedInFlow(
+            val sessionId: SessionId, val navId: Int
-            val sessionId: SessionId,
-            val navId: Int
         ) : NavTarget
 
-        @Parcelize
+        @Parcelize data class SignedOutFlow(
-        data class SignedOutFlow(
             val sessionId: SessionId
         ) : NavTarget
 
-        @Parcelize
+        @Parcelize data object BugReport : NavTarget
-        data object BugReport : NavTarget
     }
 
     override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
@@ -211,6 +227,10 @@ class RootFlowNode(
                     override fun onOpenBugReport() {
                         backstack.push(NavTarget.BugReport)
                     }
+
+                    override fun onAddAccount() {
+                        backstack.push(NavTarget.NotLoggedInFlow(null))
+                    }
                 }
                 createNode<LoggedInAppScopeFlowNode>(buildContext, plugins = listOf(inputs, callback))
             }
@@ -226,13 +246,11 @@ class RootFlowNode(
                 createNode<NotLoggedInFlowNode>(buildContext, plugins = listOf(params, callback))
             }
             is NavTarget.SignedOutFlow -> {
-                signedOutEntryPoint.nodeBuilder(this, buildContext)
+                signedOutEntryPoint.nodeBuilder(this, buildContext).params(
-                    .params(
+                    SignedOutEntryPoint.Params(
-                        SignedOutEntryPoint.Params(
+                        sessionId = navTarget.sessionId
-                            sessionId = navTarget.sessionId
-                        )
                     )
-                    .build()
+                ).build()
             }
             NavTarget.SplashScreen -> splashNode(buildContext)
             NavTarget.BugReport -> {
@@ -241,10 +259,32 @@ class RootFlowNode(
                         backstack.pop()
                     }
                 }
-                bugReportEntryPoint
+                bugReportEntryPoint.nodeBuilder(this, buildContext).callback(callback).build()
-                    .nodeBuilder(this, buildContext)
+            }
-                    .callback(callback)
+            is NavTarget.AccountSelect -> {
-                    .build()
+                val callback: AccountSelectEntryPoint.Callback = object : AccountSelectEntryPoint.Callback {
+                    override fun onSelectAccount(sessionId: SessionId) {
+                        lifecycleScope.launch {
+                            if (sessionId == navTarget.currentSessionId) {
+                                // Ensure that the account selection Node is removed from the backstack
+                                // Do not pop when the account is changed to avoid a UI flicker.
+                                backstack.pop()
+                            }
+                            attachSession(sessionId).apply {
+                                if (navTarget.intent != null) {
+                                    attachIncomingShare(navTarget.intent)
+                                } else if (navTarget.permalinkData != null) {
+                                    attachPermalinkData(navTarget.permalinkData)
+                                }
+                            }
+                        }
+                    }
+
+                    override fun onCancel() {
+                        backstack.pop()
+                    }
+                }
+                accountSelectEntryPoint.nodeBuilder(this, buildContext).callback(callback).build()
             }
         }
     }
@@ -267,19 +307,29 @@ class RootFlowNode(
     }
 
     private suspend fun onLoginLink(params: LoginParams) {
-        // Is there a session already?
+        if (accountProviderAccessControl.isAllowedToConnectToAccountProvider(params.accountProvider.ensureProtocol())) {
-        val latestSessionId = sessionStore.getLatestSessionId()
+            // Is there a session already?
-        if (latestSessionId == null) {
+            val sessions = sessionStore.getAllSessions()
-            // No session, open login
+            if (sessions.isNotEmpty()) {
-            if (accountProviderAccessControl.isAllowedToConnectToAccountProvider(params.accountProvider.ensureProtocol())) {
+                if (featureFlagService.isFeatureEnabled(FeatureFlags.MultiAccount)) {
-                switchToNotLoggedInFlow(params)
+                    val loginHintMatrixId = params.loginHint?.removePrefix("mxid:")
+                    val existingAccount = sessions.find { it.userId == loginHintMatrixId }
+                    if (existingAccount != null) {
+                        // We have an existing account matching the login hint, ensure this is the current session
+                        sessionStore.setLatestSession(existingAccount.userId)
+                    } else {
+                        val latestSessionId = sessions.maxBy { it.lastUsageIndex }.userId
+                        attachSession(SessionId(latestSessionId))
+                        backstack.push(NavTarget.NotLoggedInFlow(params))
+                    }
+                } else {
+                    Timber.w("Login link ignored, multi account is disabled")
+                }
             } else {
-                Timber.w("Login link ignored, we are not allowed to connect to the homeserver")
+                switchToNotLoggedInFlow(params)
-                switchToNotLoggedInFlow(null)
             }
         } else {
-            // Just ignore the login link if we already have a session
+            Timber.w("Login link ignored, we are not allowed to connect to the homeserver")
-            Timber.w("Login link ignored, we already have a session")
         }
     }
 
@@ -290,56 +340,95 @@ class RootFlowNode(
             // No session, open login
             switchToNotLoggedInFlow(null)
         } else {
-            attachSession(latestSessionId)
+            // wait for the current session to be restored
-                .attachIncomingShare(intent)
+            val loggedInFlowNode = attachSession(latestSessionId)
+            if (sessionStore.getAllSessions().size > 1) {
+                // Several accounts, let the user choose which one to use
+                backstack.push(
+                    NavTarget.AccountSelect(
+                        currentSessionId = latestSessionId,
+                        intent = intent,
+                        permalinkData = null,
+                    )
+                )
+            } else {
+                // Only one account, directly attach the incoming share node.
+                loggedInFlowNode.attachIncomingShare(intent)
+            }
         }
     }
 
     private suspend fun navigateTo(permalinkData: PermalinkData) {
         Timber.d("Navigating to $permalinkData")
-        attachSession(null)
+        // Is there a session already?
-            .apply {
+        val latestSessionId = sessionStore.getLatestSessionId()
-                when (permalinkData) {
+        if (latestSessionId == null) {
-                    is PermalinkData.FallbackLink -> Unit
+            // No session, open login
-                    is PermalinkData.RoomEmailInviteLink -> Unit
+            switchToNotLoggedInFlow(null)
-                    is PermalinkData.RoomLink -> {
+        } else {
-                        attachRoom(
+            // wait for the current session to be restored
-                            roomIdOrAlias = permalinkData.roomIdOrAlias,
+            val loggedInFlowNode = attachSession(latestSessionId)
-                            trigger = JoinedRoom.Trigger.MobilePermalink,
+            when (permalinkData) {
-                            serverNames = permalinkData.viaParameters,
+                is PermalinkData.FallbackLink -> Unit
-                            eventId = permalinkData.eventId,
+                is PermalinkData.RoomEmailInviteLink -> Unit
-                            clearBackstack = true
+                else -> {
+                    if (sessionStore.getAllSessions().size > 1) {
+                        // Several accounts, let the user choose which one to use
+                        backstack.push(
+                            NavTarget.AccountSelect(
+                                currentSessionId = latestSessionId,
+                                intent = null,
+                                permalinkData = permalinkData,
+                            )
                         )
-                    }
+                    } else {
-                    is PermalinkData.UserLink -> {
+                        // Only one account, directly attach the room or the user node.
-                        attachUser(permalinkData.userId)
+                        loggedInFlowNode.attachPermalinkData(permalinkData)
                     }
                 }
             }
+        }
+    }
+
+    private suspend fun LoggedInFlowNode.attachPermalinkData(permalinkData: PermalinkData) {
+        when (permalinkData) {
+            is PermalinkData.FallbackLink -> Unit
+            is PermalinkData.RoomEmailInviteLink -> Unit
+            is PermalinkData.RoomLink -> {
+                attachRoom(
+                    roomIdOrAlias = permalinkData.roomIdOrAlias,
+                    trigger = JoinedRoom.Trigger.MobilePermalink,
+                    serverNames = permalinkData.viaParameters,
+                    eventId = permalinkData.eventId,
+                    clearBackstack = true
+                )
+            }
+            is PermalinkData.UserLink -> {
+                attachUser(permalinkData.userId)
+            }
+        }
     }
 
     private suspend fun navigateTo(deeplinkData: DeeplinkData) {
         Timber.d("Navigating to $deeplinkData")
-        attachSession(deeplinkData.sessionId)
+        attachSession(deeplinkData.sessionId).apply {
-            .apply {
+            when (deeplinkData) {
-                when (deeplinkData) {
+                is DeeplinkData.Root -> Unit // The room list will always be shown, observing FtueState
-                    is DeeplinkData.Root -> Unit // The room list will always be shown, observing FtueState
+                is DeeplinkData.Room -> attachRoom(deeplinkData.roomId.toRoomIdOrAlias(), clearBackstack = true)
-                    is DeeplinkData.Room -> attachRoom(deeplinkData.roomId.toRoomIdOrAlias(), clearBackstack = true)
-                }
             }
+        }
     }
 
     private fun onOidcAction(oidcAction: OidcAction) {
         oidcActionFlow.post(oidcAction)
     }
 
-    // [sessionId] will be null for permalink.
+    private suspend fun attachSession(sessionId: SessionId): LoggedInFlowNode {
-    private suspend fun attachSession(sessionId: SessionId?): LoggedInFlowNode {
+        // Ensure that the session is the latest one
-        // TODO handle multi-session
+        sessionStore.setLatestSession(sessionId.value)
         return waitForChildAttached<LoggedInAppScopeFlowNode, NavTarget> { navTarget ->
-            navTarget is NavTarget.LoggedInFlow && (sessionId == null || navTarget.sessionId == sessionId)
+            navTarget is NavTarget.LoggedInFlow && navTarget.sessionId == sessionId
-        }
+        }.attachSession()
-            .attachSession()
     }
 }
 

appnav/src/test/kotlin/io/element/android/appnav/intent/IntentResolverTest.kt

@@ -111,7 +111,7 @@ class IntentResolverTest {
     @Test
     fun `test resolve oidc`() {
         val sut = createIntentResolver(
-            oidcIntentResolverResult = { OidcAction.GoBack },
+            oidcIntentResolverResult = { OidcAction.GoBack() },
         )
         val intent = Intent(RuntimeEnvironment.getApplication(), Activity::class.java).apply {
             action = Intent.ACTION_VIEW
@@ -120,7 +120,7 @@ class IntentResolverTest {
         val result = sut.resolve(intent)
         assertThat(result).isEqualTo(
             ResolvedIntent.Oidc(
-                oidcAction = OidcAction.GoBack
+                oidcAction = OidcAction.GoBack()
             )
         )
     }

features/home/impl/build.gradle.kts

@@ -71,6 +71,7 @@ dependencies {
     testImplementation(projects.libraries.permissions.noop)
     testImplementation(projects.libraries.permissions.test)
     testImplementation(projects.libraries.preferences.test)
+    testImplementation(projects.libraries.sessionStorage.test)
     testImplementation(projects.libraries.push.test)
     testImplementation(projects.services.analytics.test)
     testImplementation(projects.services.toolbox.test)

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/CurrentUserWithNeighborsBuilder.kt

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.home.impl
+
+import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.sessionstorage.api.SessionData
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toPersistentList
+
+class CurrentUserWithNeighborsBuilder {
+    /**
+     * Build a list of [MatrixUser] containing the current user. If there are other sessions, the list
+     * will contain 3 users, with the current user in the middle.
+     * If there is only one other session, the list will contain twice the other user, to allow cycling.
+     */
+    fun build(
+        matrixUser: MatrixUser,
+        sessions: List<SessionData>,
+    ): ImmutableList<MatrixUser> {
+        // Sort by position to always have the same order (not depending on last account usage)
+        return sessions.sortedBy { it.position }
+            .map {
+                if (it.userId == matrixUser.userId.value) {
+                    // Always use the freshest profile for the current user
+                    matrixUser
+                } else {
+                    // Use the data from the DB
+                    MatrixUser(
+                        userId = UserId(it.userId),
+                        displayName = it.userDisplayName,
+                        avatarUrl = it.userAvatarUrl,
+                    )
+                }
+            }
+            .let { sessionList ->
+                // If the list has one item, there is no other session, return the list
+                when (sessionList.size) {
+                    // Can happen when the user signs out (?)
+                    0 -> listOf(matrixUser)
+                    1 -> sessionList
+                    else -> {
+                        // Create a list with extra item at the start and end if necessary to have the current user in the middle
+                        // If the list is [A, B, C, D] and the current user is A we want to return [D, A, B]
+                        // If the current user is B, we want to return [A, B, C]
+                        // If the current user is C, we want to return [B, C, D]
+                        // If the current user is D, we want to return [C, D, A]
+                        // Special case: if there are only two users, we want to return [B, A, B] or [A, B, A] to allows cycling
+                        // between the two users.
+                        val currentUserIndex = sessionList.indexOfFirst { it.userId == matrixUser.userId }
+                        when (currentUserIndex) {
+                            // This can happen when the user signs out.
+                            // In this case, just return a singleton list with the current user.
+                            -1 -> listOf(matrixUser)
+                            0 -> listOf(sessionList.last()) + sessionList.take(2)
+                            sessionList.lastIndex -> sessionList.takeLast(2) + sessionList.first()
+                            else -> sessionList.slice(currentUserIndex - 1..currentUserIndex + 1)
+                        }
+                    }
+                }
+            }
+            .toPersistentList()
+    }
+}

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/HomeEvents.kt

@@ -7,6 +7,9 @@
 
 package io.element.android.features.home.impl
 
+import io.element.android.libraries.matrix.api.core.SessionId
+
 sealed interface HomeEvents {
     data class SelectHomeNavigationBarItem(val item: HomeNavigationBarItem) : HomeEvents
+    data class SwitchToAccount(val sessionId: SessionId) : HomeEvents
 }

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/HomePresenter.kt

@@ -14,6 +14,7 @@ import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import dev.zacsweers.metro.Inject
@@ -29,6 +30,10 @@ import io.element.android.libraries.featureflag.api.FeatureFlags
 import io.element.android.libraries.indicator.api.IndicatorService
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.sync.SyncService
+import io.element.android.libraries.sessionstorage.api.SessionStore
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.launch
 
 @Inject
 class HomePresenter(
@@ -41,10 +46,21 @@ class HomePresenter(
     private val logoutPresenter: Presenter<DirectLogoutState>,
     private val rageshakeFeatureAvailability: RageshakeFeatureAvailability,
     private val featureFlagService: FeatureFlagService,
+    private val sessionStore: SessionStore,
 ) : Presenter<HomeState> {
+    private val currentUserWithNeighborsBuilder = CurrentUserWithNeighborsBuilder()
+
     @Composable
     override fun present(): HomeState {
-        val matrixUser = client.userProfile.collectAsState()
+        val coroutineState = rememberCoroutineScope()
+        val matrixUser by client.userProfile.collectAsState()
+        val currentUserAndNeighbors by remember {
+            combine(
+                client.userProfile,
+                sessionStore.sessionsFlow(),
+                currentUserWithNeighborsBuilder::build,
+            )
+        }.collectAsState(initial = persistentListOf(matrixUser))
         val isOnline by syncService.isOnline.collectAsState()
         val canReportBug by remember { rageshakeFeatureAvailability.isAvailable() }.collectAsState(false)
         val roomListState = roomListPresenter.present()
@@ -71,6 +87,9 @@ class HomePresenter(
                 is HomeEvents.SelectHomeNavigationBarItem -> {
                     currentHomeNavigationBarItemOrdinal = event.item.ordinal
                 }
+                is HomeEvents.SwitchToAccount -> coroutineState.launch {
+                    sessionStore.setLatestSession(event.sessionId.value)
+                }
             }
         }
 
@@ -82,7 +101,7 @@ class HomePresenter(
         }
         val snackbarMessage by snackbarDispatcher.collectSnackbarMessageAsState()
         return HomeState(
-            matrixUser = matrixUser.value,
+            currentUserAndNeighbors = currentUserAndNeighbors,
             showAvatarIndicator = showAvatarIndicator,
             hasNetworkConnection = isOnline,
             currentHomeNavigationBarItem = currentHomeNavigationBarItem,

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/HomeState.kt

@@ -13,10 +13,15 @@ import io.element.android.features.home.impl.spaces.HomeSpacesState
 import io.element.android.features.logout.api.direct.DirectLogoutState
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
 import io.element.android.libraries.matrix.api.user.MatrixUser
+import kotlinx.collections.immutable.ImmutableList
 
 @Immutable
 data class HomeState(
-    val matrixUser: MatrixUser,
+    /**
+     * The current user of this session, in case of multiple accounts, will contains 3 items, with the
+     * current user in the middle.
+     */
+    val currentUserAndNeighbors: ImmutableList<MatrixUser>,
     val showAvatarIndicator: Boolean,
     val hasNetworkConnection: Boolean,
     val currentHomeNavigationBarItem: HomeNavigationBarItem,

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/HomeStateProvider.kt

@@ -21,6 +21,7 @@ import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.user.MatrixUser
 import io.element.android.libraries.ui.strings.CommonStrings
+import kotlinx.collections.immutable.toPersistentList
 
 open class HomeStateProvider : PreviewParameterProvider<HomeState> {
     override val values: Sequence<HomeState>
@@ -50,6 +51,7 @@ open class HomeStateProvider : PreviewParameterProvider<HomeState> {
 
 internal fun aHomeState(
     matrixUser: MatrixUser = MatrixUser(userId = UserId("@id:domain"), displayName = "User#1"),
+    currentUserAndNeighbors: List<MatrixUser> = listOf(matrixUser),
     showAvatarIndicator: Boolean = false,
     hasNetworkConnection: Boolean = true,
     snackbarMessage: SnackbarMessage? = null,
@@ -61,7 +63,7 @@ internal fun aHomeState(
     directLogoutState: DirectLogoutState = aDirectLogoutState(),
     eventSink: (HomeEvents) -> Unit = {}
 ) = HomeState(
-    matrixUser = matrixUser,
+    currentUserAndNeighbors = currentUserAndNeighbors.toPersistentList(),
     showAvatarIndicator = showAvatarIndicator,
     hasNetworkConnection = hasNetworkConnection,
     snackbarMessage = snackbarMessage,

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/HomeView.kt

@@ -171,12 +171,15 @@ private fun HomeScaffold(
         topBar = {
             RoomListTopBar(
                 title = stringResource(state.currentHomeNavigationBarItem.labelRes),
-                matrixUser = state.matrixUser,
+                currentUserAndNeighbors = state.currentUserAndNeighbors,
                 showAvatarIndicator = state.showAvatarIndicator,
                 areSearchResultsDisplayed = roomListState.searchState.isSearchActive,
                 onToggleSearch = { roomListState.eventSink(RoomListEvents.ToggleSearchResults) },
                 onMenuActionClick = onMenuActionClick,
                 onOpenSettings = onOpenSettings,
+                onAccountSwitch = {
+                    state.eventSink(HomeEvents.SwitchToAccount(it))
+                },
                 scrollBehavior = scrollBehavior,
                 displayMenuItems = state.displayActions,
                 displayFilters = roomListState.displayFilters && state.currentHomeNavigationBarItem == HomeNavigationBarItem.Chats,

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/components/RoomListTopBar.kt

@@ -11,19 +11,25 @@ import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.foundation.pager.VerticalPager
+import androidx.compose.foundation.pager.rememberPagerState
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.TopAppBarScrollBehavior
 import androidx.compose.material3.rememberTopAppBarState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
@@ -41,7 +47,6 @@ import io.element.android.features.home.impl.filters.RoomListFiltersView
 import io.element.android.features.home.impl.filters.aRoomListFiltersState
 import io.element.android.libraries.designsystem.atomic.atoms.RedIndicatorAtom
 import io.element.android.libraries.designsystem.components.avatar.Avatar
-import io.element.android.libraries.designsystem.components.avatar.AvatarData
 import io.element.android.libraries.designsystem.components.avatar.AvatarSize
 import io.element.android.libraries.designsystem.components.avatar.AvatarType
 import io.element.android.libraries.designsystem.modifiers.backgroundVerticalGradient
@@ -57,23 +62,29 @@ import io.element.android.libraries.designsystem.theme.components.Icon
 import io.element.android.libraries.designsystem.theme.components.IconButton
 import io.element.android.libraries.designsystem.theme.components.MediumTopAppBar
 import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
 import io.element.android.libraries.matrix.ui.model.getAvatarData
 import io.element.android.libraries.testtags.TestTags
 import io.element.android.libraries.testtags.testTag
 import io.element.android.libraries.ui.strings.CommonStrings
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toPersistentList
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun RoomListTopBar(
     title: String,
-    matrixUser: MatrixUser,
+    currentUserAndNeighbors: ImmutableList<MatrixUser>,
     showAvatarIndicator: Boolean,
     areSearchResultsDisplayed: Boolean,
     onToggleSearch: () -> Unit,
     onMenuActionClick: (RoomListMenuAction) -> Unit,
     onOpenSettings: () -> Unit,
+    onAccountSwitch: (SessionId) -> Unit,
     scrollBehavior: TopAppBarScrollBehavior,
     displayMenuItems: Boolean,
     displayFilters: Boolean,
@@ -83,10 +94,11 @@ fun RoomListTopBar(
 ) {
     DefaultRoomListTopBar(
         title = title,
-        matrixUser = matrixUser,
+        currentUserAndNeighbors = currentUserAndNeighbors,
         showAvatarIndicator = showAvatarIndicator,
         areSearchResultsDisplayed = areSearchResultsDisplayed,
         onOpenSettings = onOpenSettings,
+        onAccountSwitch = onAccountSwitch,
         onSearchClick = onToggleSearch,
         onMenuActionClick = onMenuActionClick,
         scrollBehavior = scrollBehavior,
@@ -102,11 +114,12 @@ fun RoomListTopBar(
 @Composable
 private fun DefaultRoomListTopBar(
     title: String,
-    matrixUser: MatrixUser,
+    currentUserAndNeighbors: ImmutableList<MatrixUser>,
     showAvatarIndicator: Boolean,
     areSearchResultsDisplayed: Boolean,
     scrollBehavior: TopAppBarScrollBehavior,
     onOpenSettings: () -> Unit,
+    onAccountSwitch: (SessionId) -> Unit,
     onSearchClick: () -> Unit,
     onMenuActionClick: (RoomListMenuAction) -> Unit,
     displayMenuItems: Boolean,
@@ -116,12 +129,6 @@ private fun DefaultRoomListTopBar(
     modifier: Modifier = Modifier,
 ) {
     val collapsedFraction = scrollBehavior.state.collapsedFraction
-    val avatarData by remember(matrixUser) {
-        derivedStateOf {
-            matrixUser.getAvatarData(size = AvatarSize.CurrentUserTopBar)
-        }
-    }
-
     Box(modifier = modifier) {
         val collapsedTitleTextStyle = ElementTheme.typography.aliasScreenTitle
         val expandedTitleTextStyle = ElementTheme.typography.fontHeadingLgBold.copy(
@@ -158,8 +165,9 @@ private fun DefaultRoomListTopBar(
                     },
                     navigationIcon = {
                         NavigationIcon(
-                            avatarData = avatarData,
+                            currentUserAndNeighbors = currentUserAndNeighbors,
                             showAvatarIndicator = showAvatarIndicator,
+                            onAccountSwitch = onAccountSwitch,
                             onClick = onOpenSettings,
                         )
                     },
@@ -247,19 +255,67 @@ private fun DefaultRoomListTopBar(
 
 @Composable
 private fun NavigationIcon(
-    avatarData: AvatarData,
+    currentUserAndNeighbors: ImmutableList<MatrixUser>,
+    showAvatarIndicator: Boolean,
+    onAccountSwitch: (SessionId) -> Unit,
+    onClick: () -> Unit,
+) {
+    if (currentUserAndNeighbors.size == 1) {
+        AccountIcon(
+            matrixUser = currentUserAndNeighbors.single(),
+            isCurrentAccount = true,
+            showAvatarIndicator = showAvatarIndicator,
+            onClick = onClick,
+        )
+    } else {
+        // Render a vertical pager
+        val pagerState = rememberPagerState(initialPage = 1) { currentUserAndNeighbors.size }
+        // Listen to page changes and switch account if needed
+        val latestOnAccountSwitch by rememberUpdatedState(onAccountSwitch)
+        LaunchedEffect(pagerState) {
+            snapshotFlow { pagerState.settledPage }.collect { page ->
+                latestOnAccountSwitch(SessionId(currentUserAndNeighbors[page].userId.value))
+            }
+        }
+        VerticalPager(
+            state = pagerState,
+            modifier = Modifier.height(48.dp),
+        ) { page ->
+            AccountIcon(
+                matrixUser = currentUserAndNeighbors[page],
+                isCurrentAccount = page == 1,
+                showAvatarIndicator = page == 1 && showAvatarIndicator,
+                onClick = if (page == 1) {
+                    onClick
+                } else {
+                    {}
+                },
+            )
+        }
+    }
+}
+
+@Composable
+private fun AccountIcon(
+    matrixUser: MatrixUser,
+    isCurrentAccount: Boolean,
     showAvatarIndicator: Boolean,
     onClick: () -> Unit,
 ) {
     IconButton(
-        modifier = Modifier.testTag(TestTags.homeScreenSettings),
+        modifier = if (isCurrentAccount) Modifier.testTag(TestTags.homeScreenSettings) else Modifier,
         onClick = onClick,
     ) {
         Box {
+            val avatarData by remember(matrixUser) {
+                derivedStateOf {
+                    matrixUser.getAvatarData(size = AvatarSize.CurrentUserTopBar)
+                }
+            }
             Avatar(
                 avatarData = avatarData,
                 avatarType = AvatarType.User,
-                contentDescription = stringResource(CommonStrings.common_settings),
+                contentDescription = if (isCurrentAccount) stringResource(CommonStrings.common_settings) else null,
             )
             if (showAvatarIndicator) {
                 RedIndicatorAtom(
@@ -276,11 +332,12 @@ private fun NavigationIcon(
 internal fun DefaultRoomListTopBarPreview() = ElementPreview {
     DefaultRoomListTopBar(
         title = stringResource(R.string.screen_roomlist_main_space_title),
-        matrixUser = MatrixUser(UserId("@id:domain"), "Alice"),
+        currentUserAndNeighbors = persistentListOf(MatrixUser(UserId("@id:domain"), "Alice")),
         showAvatarIndicator = false,
         areSearchResultsDisplayed = false,
         scrollBehavior = TopAppBarDefaults.exitUntilCollapsedScrollBehavior(rememberTopAppBarState()),
         onOpenSettings = {},
+        onAccountSwitch = {},
         onSearchClick = {},
         displayMenuItems = true,
         displayFilters = true,
@@ -296,11 +353,33 @@ internal fun DefaultRoomListTopBarPreview() = ElementPreview {
 internal fun DefaultRoomListTopBarWithIndicatorPreview() = ElementPreview {
     DefaultRoomListTopBar(
         title = stringResource(R.string.screen_roomlist_main_space_title),
-        matrixUser = MatrixUser(UserId("@id:domain"), "Alice"),
+        currentUserAndNeighbors = persistentListOf(MatrixUser(UserId("@id:domain"), "Alice")),
         showAvatarIndicator = true,
         areSearchResultsDisplayed = false,
         scrollBehavior = TopAppBarDefaults.exitUntilCollapsedScrollBehavior(rememberTopAppBarState()),
         onOpenSettings = {},
+        onAccountSwitch = {},
+        onSearchClick = {},
+        displayMenuItems = true,
+        displayFilters = true,
+        filtersState = aRoomListFiltersState(),
+        canReportBug = true,
+        onMenuActionClick = {},
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@PreviewsDayNight
+@Composable
+internal fun DefaultRoomListTopBarMultiAccountPreview() = ElementPreview {
+    DefaultRoomListTopBar(
+        title = stringResource(R.string.screen_roomlist_main_space_title),
+        currentUserAndNeighbors = aMatrixUserList().take(3).toPersistentList(),
+        showAvatarIndicator = false,
+        areSearchResultsDisplayed = false,
+        scrollBehavior = TopAppBarDefaults.exitUntilCollapsedScrollBehavior(rememberTopAppBarState()),
+        onOpenSettings = {},
+        onAccountSwitch = {},
         onSearchClick = {},
         displayMenuItems = true,
         displayFilters = true,

features/home/impl/src/test/kotlin/io/element/android/features/home/impl/CurrentUserWithNeighborsBuilderTest.kt

@@ -0,0 +1,222 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.home.impl
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.test.A_USER_ID
+import io.element.android.libraries.matrix.test.A_USER_ID_2
+import io.element.android.libraries.matrix.test.A_USER_ID_3
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.sessionstorage.api.SessionData
+import io.element.android.libraries.sessionstorage.test.aSessionData
+import org.junit.Test
+
+class CurrentUserWithNeighborsBuilderTest {
+    @Test
+    fun `build on empty list returns current user`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser()
+        val list = listOf<SessionData>()
+        val result = sut.build(matrixUser, list)
+        assertThat(result).containsExactly(matrixUser)
+    }
+
+    @Test
+    fun `ensure that account are sorted by position`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser(id = A_USER_ID.value)
+        val list = listOf(
+            aSessionData(
+                sessionId = A_USER_ID.value,
+                position = 3,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_2.value,
+                position = 2,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_3.value,
+                position = 1,
+            ),
+        )
+        val result = sut.build(matrixUser, list)
+        assertThat(result.map { it.userId }).containsExactly(
+            A_USER_ID_3,
+            A_USER_ID_2,
+            A_USER_ID,
+        )
+    }
+
+    @Test
+    fun `if current user is not found, return a singleton with current user`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser(id = A_USER_ID.value)
+        val list = listOf(
+            aSessionData(
+                sessionId = A_USER_ID_2.value,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_3.value,
+            ),
+        )
+        val result = sut.build(matrixUser, list)
+        assertThat(result.map { it.userId }).containsExactly(
+            A_USER_ID,
+        )
+    }
+
+    @Test
+    fun `one account, will return a singleton`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser(id = A_USER_ID.value)
+        val list = listOf(
+            aSessionData(
+                sessionId = A_USER_ID.value,
+            ),
+        )
+        val result = sut.build(matrixUser, list)
+        assertThat(result.map { it.userId }).containsExactly(
+            A_USER_ID,
+        )
+    }
+
+    @Test
+    fun `two accounts, first is current, will return 3 items`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser(id = A_USER_ID.value)
+        val list = listOf(
+            aSessionData(
+                sessionId = A_USER_ID.value,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_2.value,
+            ),
+        )
+        val result = sut.build(matrixUser, list)
+        assertThat(result.map { it.userId }).containsExactly(
+            A_USER_ID_2,
+            A_USER_ID,
+            A_USER_ID_2,
+        )
+    }
+
+    @Test
+    fun `two accounts, second is current, will return 3 items`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser(id = A_USER_ID_2.value)
+        val list = listOf(
+            aSessionData(
+                sessionId = A_USER_ID.value,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_2.value,
+            ),
+        )
+        val result = sut.build(matrixUser, list)
+        assertThat(result.map { it.userId }).containsExactly(
+            A_USER_ID,
+            A_USER_ID_2,
+            A_USER_ID,
+        )
+    }
+
+    @Test
+    fun `three accounts, first is current, will return last current and next`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser(id = A_USER_ID.value)
+        val list = listOf(
+            aSessionData(
+                sessionId = A_USER_ID.value,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_2.value,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_3.value,
+            ),
+        )
+        val result = sut.build(matrixUser, list)
+        assertThat(result.map { it.userId }).containsExactly(
+            A_USER_ID_3,
+            A_USER_ID,
+            A_USER_ID_2,
+        )
+    }
+
+    @Test
+    fun `three accounts, second is current, will return first current and last`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser(id = A_USER_ID_2.value)
+        val list = listOf(
+            aSessionData(
+                sessionId = A_USER_ID.value,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_2.value,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_3.value,
+            ),
+        )
+        val result = sut.build(matrixUser, list)
+        assertThat(result.map { it.userId }).containsExactly(
+            A_USER_ID,
+            A_USER_ID_2,
+            A_USER_ID_3,
+        )
+    }
+
+    @Test
+    fun `three accounts, current is last, will return middle, current and first`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser(id = A_USER_ID_3.value)
+        val list = listOf(
+            aSessionData(
+                sessionId = A_USER_ID_2.value,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID_3.value,
+            ),
+            aSessionData(
+                sessionId = A_USER_ID.value,
+            ),
+        )
+        val result = sut.build(matrixUser, list)
+        assertThat(result.map { it.userId }).containsExactly(
+            A_USER_ID,
+            A_USER_ID_2,
+            A_USER_ID_3,
+        )
+    }
+
+    @Test
+    fun `one account, will return data from matrix user and not from db`() {
+        val sut = CurrentUserWithNeighborsBuilder()
+        val matrixUser = aMatrixUser(
+            id = A_USER_ID.value,
+            displayName = "Bob",
+            avatarUrl = "avatarUrl",
+        )
+        val list = listOf(
+            aSessionData(
+                sessionId = A_USER_ID.value,
+                userDisplayName = "Outdated Bob",
+                userAvatarUrl = "outdatedAvatarUrl",
+            ),
+        )
+        val result = sut.build(matrixUser, list)
+        assertThat(result).containsExactly(
+            MatrixUser(
+                userId = A_USER_ID,
+                displayName = "Bob",
+                avatarUrl = "avatarUrl",
+            )
+        )
+    }
+}

features/home/impl/src/test/kotlin/io/element/android/features/home/impl/HomePresenterTest.kt

@@ -32,6 +32,9 @@ import io.element.android.libraries.matrix.test.A_USER_ID
 import io.element.android.libraries.matrix.test.A_USER_NAME
 import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.matrix.test.sync.FakeSyncService
+import io.element.android.libraries.sessionstorage.api.SessionStore
+import io.element.android.libraries.sessionstorage.test.InMemorySessionStore
+import io.element.android.libraries.sessionstorage.test.aSessionData
 import io.element.android.tests.testutils.MutablePresenter
 import io.element.android.tests.testutils.WarmUpRule
 import io.element.android.tests.testutils.test
@@ -54,17 +57,29 @@ class HomePresenterTest {
         val presenter = createHomePresenter(
             client = matrixClient,
             rageshakeFeatureAvailability = { flowOf(false) },
+            sessionStore = InMemorySessionStore(
+                initialList = listOf(
+                    aSessionData(
+                        sessionId = matrixClient.sessionId.value,
+                        userDisplayName = null,
+                        userAvatarUrl = null,
+                    )
+                ),
+            ),
         )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.matrixUser).isEqualTo(MatrixUser(A_USER_ID))
+            assertThat(initialState.currentUserAndNeighbors.first()).isEqualTo(
+                MatrixUser(A_USER_ID, null, null)
+            )
             assertThat(initialState.canReportBug).isFalse()
+            skipItems(1)
             val withUserState = awaitItem()
-            assertThat(withUserState.matrixUser.userId).isEqualTo(A_USER_ID)
+            assertThat(withUserState.currentUserAndNeighbors.first()).isEqualTo(
-            assertThat(withUserState.matrixUser.displayName).isEqualTo(A_USER_NAME)
+                MatrixUser(A_USER_ID, A_USER_NAME, AN_AVATAR_URL)
-            assertThat(withUserState.matrixUser.avatarUrl).isEqualTo(AN_AVATAR_URL)
+            )
             assertThat(withUserState.showAvatarIndicator).isFalse()
             assertThat(withUserState.isSpaceFeatureEnabled).isFalse()
             assertThat(withUserState.showNavigationBar).isFalse()
@@ -75,6 +90,9 @@ class HomePresenterTest {
     fun `present - can report bug`() = runTest {
         val presenter = createHomePresenter(
             rageshakeFeatureAvailability = { flowOf(true) },
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
         )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
@@ -92,6 +110,9 @@ class HomePresenterTest {
             featureFlagService = FakeFeatureFlagService(
                 initialState = mapOf(FeatureFlags.Space.key to true),
             ),
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
         )
         presenter.test {
             skipItems(1)
@@ -105,6 +126,9 @@ class HomePresenterTest {
         val indicatorService = FakeIndicatorService()
         val presenter = createHomePresenter(
             indicatorService = indicatorService,
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
         )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
@@ -124,19 +148,28 @@ class HomePresenterTest {
             userAvatarUrl = null,
         )
         matrixClient.givenGetProfileResult(matrixClient.sessionId, Result.failure(AN_EXCEPTION))
-        val presenter = createHomePresenter(client = matrixClient)
+        val presenter = createHomePresenter(
+            client = matrixClient,
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
+        )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.matrixUser).isEqualTo(MatrixUser(matrixClient.sessionId))
+            assertThat(initialState.currentUserAndNeighbors.first()).isEqualTo(MatrixUser(matrixClient.sessionId))
             // No new state is coming
         }
     }
 
     @Test
     fun `present - NavigationBar change`() = runTest {
-        val presenter = createHomePresenter()
+        val presenter = createHomePresenter(
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
+        )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -152,6 +185,9 @@ class HomePresenterTest {
     fun `present - NavigationBar is hidden when the last space is left`() = runTest {
         val homeSpacesPresenter = MutablePresenter(aHomeSpacesState())
         val presenter = createHomePresenter(
+            sessionStore = InMemorySessionStore(
+                updateUserProfileResult = { _, _, _ -> },
+            ),
             featureFlagService = FakeFeatureFlagService(
                 initialState = mapOf(FeatureFlags.Space.key to true),
             ),
@@ -185,6 +221,7 @@ internal fun createHomePresenter(
     indicatorService: IndicatorService = FakeIndicatorService(),
     featureFlagService: FeatureFlagService = FakeFeatureFlagService(),
     homeSpacesPresenter: Presenter<HomeSpacesState> = Presenter { aHomeSpacesState() },
+    sessionStore: SessionStore = InMemorySessionStore(),
 ) = HomePresenter(
     client = client,
     syncService = syncService,
@@ -195,4 +232,5 @@ internal fun createHomePresenter(
     homeSpacesPresenter = homeSpacesPresenter,
     rageshakeFeatureAvailability = rageshakeFeatureAvailability,
     featureFlagService = featureFlagService,
+    sessionStore = sessionStore,
 )

features/login/impl/build.gradle.kts

@@ -40,6 +40,7 @@ dependencies {
     implementation(projects.libraries.testtags)
     implementation(projects.libraries.uiStrings)
     implementation(projects.libraries.permissions.api)
+    implementation(projects.libraries.sessionStorage.api)
     implementation(projects.libraries.qrcode)
     implementation(projects.libraries.oidc.api)
     implementation(projects.libraries.uiUtils)
@@ -56,5 +57,6 @@ dependencies {
     testImplementation(projects.libraries.matrix.test)
     testImplementation(projects.libraries.oidc.test)
     testImplementation(projects.libraries.permissions.test)
+    testImplementation(projects.libraries.sessionStorage.test)
     testImplementation(projects.libraries.wellknown.test)
 }

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

@@ -87,7 +87,7 @@ class LoginFlowNode(
                     // by pressing back or by closing the Custom Chrome Tab.
                     lifecycleScope.launch {
                         delay(5000)
-                        oidcActionFlow.post(OidcAction.GoBack)
+                        oidcActionFlow.post(OidcAction.GoBack(toUnblock = true))
                     }
                 }
             }

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

@@ -94,9 +94,14 @@ class LoginHelper(
     }
 
     private suspend fun onOidcAction(oidcAction: OidcAction) {
+        if (oidcAction is OidcAction.GoBack && oidcAction.toUnblock && loginModeState.value !is AsyncData.Loading) {
+            // Ignore GoBack action if the current state is not Loading. This GoBack action is coming from LoginFlowNode.
+            // This can happen if there is an error, for instance attempt to login again on the same account.
+            return
+        }
         loginModeState.value = AsyncData.Loading()
         when (oidcAction) {
-            OidcAction.GoBack -> {
+            is OidcAction.GoBack -> {
                 authenticationService.cancelOidcLogin()
                     .onSuccess {
                         loginModeState.value = AsyncData.Uninitialized

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

@@ -14,7 +14,6 @@ import androidx.compose.ui.tooling.preview.PreviewParameter
 import io.element.android.features.login.impl.R
 import io.element.android.features.login.impl.dialogs.SlidingSyncNotSupportedDialog
 import io.element.android.features.login.impl.error.ChangeServerError
-import io.element.android.features.login.impl.error.ChangeServerErrorProvider
 import io.element.android.features.login.impl.screens.createaccount.AccountCreationNotSupported
 import io.element.android.libraries.androidutils.system.openGooglePlay
 import io.element.android.libraries.architecture.AsyncData
@@ -23,6 +22,7 @@ import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
 import io.element.android.libraries.designsystem.theme.LocalBuildMeta
+import io.element.android.libraries.matrix.api.auth.AuthenticationException
 import io.element.android.libraries.matrix.api.auth.OidcDetails
 import io.element.android.libraries.ui.strings.CommonStrings
 
@@ -89,6 +89,12 @@ fun LoginModeView(
                         onSubmit = onClearError,
                     )
                 }
+                is AuthenticationException.AccountAlreadyLoggedIn -> {
+                    ErrorDialog(
+                        content = stringResource(CommonStrings.error_account_already_logged_in, error.message.orEmpty()),
+                        onSubmit = onClearError,
+                    )
+                }
                 else -> {
                     ErrorDialog(
                         content = stringResource(CommonStrings.error_unknown),
@@ -113,7 +119,7 @@ fun LoginModeView(
 
 @PreviewsDayNight
 @Composable
-internal fun LoginModeViewPreview(@PreviewParameter(ChangeServerErrorProvider::class) error: ChangeServerError) {
+internal fun LoginModeViewPreview(@PreviewParameter(LoginModeViewErrorProvider::class) error: Throwable) {
     ElementPreview {
         LoginModeView(
             loginMode = AsyncData.Failure(error),

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

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.login.impl.login
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.login.impl.error.ChangeServerErrorProvider
+import io.element.android.libraries.matrix.api.auth.AuthenticationException
+
+class LoginModeViewErrorProvider : PreviewParameterProvider<Exception> {
+    override val values: Sequence<Exception>
+        get() = ChangeServerErrorProvider().values +
+            AuthenticationException.AccountAlreadyLoggedIn("@alice:matrix.org")
+}

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingNode.kt

@@ -97,6 +97,7 @@ class OnBoardingNode(
             onNeedLoginPassword = ::onLoginPasswordNeeded,
             onLearnMoreClick = { openLearnMorePage(context) },
             onCreateAccountContinue = ::onCreateAccountContinue,
+            onBackClick = ::navigateUp,
         )
     }
 }

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenter.kt

@@ -27,6 +27,7 @@ import io.element.android.features.login.impl.login.LoginHelper
 import io.element.android.features.rageshake.api.RageshakeFeatureAvailability
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.core.meta.BuildMeta
+import io.element.android.libraries.sessionstorage.api.SessionStore
 import io.element.android.libraries.ui.utils.MultipleTapToUnlock
 
 @AssistedInject
@@ -38,6 +39,7 @@ class OnBoardingPresenter(
     private val rageshakeFeatureAvailability: RageshakeFeatureAvailability,
     private val loginHelper: LoginHelper,
     private val onBoardingLogoResIdProvider: OnBoardingLogoResIdProvider,
+    private val sessionStore: SessionStore,
 ) : Presenter<OnBoardingState> {
     @AssistedFactory
     interface Factory {
@@ -86,6 +88,10 @@ class OnBoardingPresenter(
         val onBoardingLogoResId = remember {
             onBoardingLogoResIdProvider.get()
         }
+        val isAddingAccount by produceState(initialValue = false) {
+            // We are adding an account if there is at least one session already stored
+            value = sessionStore.getAllSessions().isNotEmpty()
+        }
 
         val loginMode by loginHelper.collectLoginMode()
 
@@ -109,6 +115,7 @@ class OnBoardingPresenter(
         }
 
         return OnBoardingState(
+            isAddingAccount = isAddingAccount,
             productionApplicationName = buildMeta.productionApplicationName,
             defaultAccountProvider = defaultAccountProvider,
             mustChooseAccountProvider = mustChooseAccountProvider,

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingState.kt

@@ -12,6 +12,7 @@ import io.element.android.features.login.impl.login.LoginMode
 import io.element.android.libraries.architecture.AsyncData
 
 data class OnBoardingState(
+    val isAddingAccount: Boolean,
     val productionApplicationName: String,
     val defaultAccountProvider: String?,
     val mustChooseAccountProvider: Boolean,

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingStateProvider.kt

@@ -23,10 +23,16 @@ open class OnBoardingStateProvider : PreviewParameterProvider<OnBoardingState> {
             anOnBoardingState(canLoginWithQrCode = true, canCreateAccount = true, canReportBug = true),
             anOnBoardingState(defaultAccountProvider = "element.io", canCreateAccount = false, canReportBug = true),
             anOnBoardingState(customLogoResId = R.drawable.sample_background),
+            anOnBoardingState(
+                isAddingAccount = true,
+                canLoginWithQrCode = true,
+                canCreateAccount = true,
+            ),
         )
 }
 
 fun anOnBoardingState(
+    isAddingAccount: Boolean = false,
     productionApplicationName: String = "Element",
     defaultAccountProvider: String? = null,
     mustChooseAccountProvider: Boolean = false,
@@ -39,6 +45,7 @@ fun anOnBoardingState(
     loginMode: AsyncData<LoginMode> = AsyncData.Uninitialized,
     eventSink: (OnBoardingEvents) -> Unit = {},
 ) = OnBoardingState(
+    isAddingAccount = isAddingAccount,
     productionApplicationName = productionApplicationName,
     defaultAccountProvider = defaultAccountProvider,
     mustChooseAccountProvider = mustChooseAccountProvider,

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingView.kt

@@ -38,7 +38,9 @@ import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.designsystem.atomic.atoms.ElementLogoAtom
 import io.element.android.libraries.designsystem.atomic.atoms.ElementLogoAtomSize
 import io.element.android.libraries.designsystem.atomic.molecules.ButtonColumnMolecule
+import io.element.android.libraries.designsystem.atomic.pages.FlowStepPage
 import io.element.android.libraries.designsystem.atomic.pages.OnBoardingPage
+import io.element.android.libraries.designsystem.components.BigIcon
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
 import io.element.android.libraries.designsystem.theme.components.Button
@@ -58,6 +60,7 @@ import io.element.android.libraries.ui.strings.CommonStrings
 @Composable
 fun OnBoardingView(
     state: OnBoardingState,
+    onBackClick: () -> Unit,
     onSignInWithQrCode: () -> Unit,
     onSignIn: (mustChooseAccountProvider: Boolean) -> Unit,
     onCreateAccount: () -> Unit,
@@ -67,6 +70,52 @@ fun OnBoardingView(
     onCreateAccountContinue: (url: String) -> Unit,
     onReportProblem: () -> Unit,
     modifier: Modifier = Modifier,
+) {
+    val loginView = @Composable {
+        LoginModeView(
+            loginMode = state.loginMode,
+            onClearError = {
+                state.eventSink(OnBoardingEvents.ClearError)
+            },
+            onLearnMoreClick = onLearnMoreClick,
+            onOidcDetails = onOidcDetails,
+            onNeedLoginPassword = onNeedLoginPassword,
+            onCreateAccountContinue = onCreateAccountContinue,
+        )
+    }
+    val buttons = @Composable {
+        OnBoardingButtons(
+            state = state,
+            onSignInWithQrCode = onSignInWithQrCode,
+            onSignIn = onSignIn,
+            onCreateAccount = onCreateAccount,
+            onReportProblem = onReportProblem,
+        )
+    }
+
+    if (state.isAddingAccount) {
+        AddOtherAccountScaffold(
+            modifier = modifier,
+            loginView = loginView,
+            buttons = buttons,
+            onBackClick = onBackClick,
+        )
+    } else {
+        AddFirstAccountScaffold(
+            modifier = modifier,
+            state = state,
+            loginView = loginView,
+            buttons = buttons,
+        )
+    }
+}
+
+@Composable
+private fun AddFirstAccountScaffold(
+    state: OnBoardingState,
+    loginView: @Composable () -> Unit,
+    buttons: @Composable () -> Unit,
+    modifier: Modifier = Modifier,
 ) {
     OnBoardingPage(
         modifier = modifier,
@@ -79,29 +128,31 @@ fun OnBoardingView(
             } else {
                 OnBoardingContent(state = state)
             }
-            LoginModeView(
+            loginView()
-                loginMode = state.loginMode,
-                onClearError = {
-                    state.eventSink(OnBoardingEvents.ClearError)
-                },
-                onLearnMoreClick = onLearnMoreClick,
-                onOidcDetails = onOidcDetails,
-                onNeedLoginPassword = onNeedLoginPassword,
-                onCreateAccountContinue = onCreateAccountContinue,
-            )
         },
         footer = {
-            OnBoardingButtons(
+            buttons()
-                state = state,
-                onSignInWithQrCode = onSignInWithQrCode,
-                onSignIn = onSignIn,
-                onCreateAccount = onCreateAccount,
-                onReportProblem = onReportProblem,
-            )
         }
     )
 }
 
+@Composable
+private fun AddOtherAccountScaffold(
+    loginView: @Composable () -> Unit,
+    buttons: @Composable () -> Unit,
+    onBackClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    FlowStepPage(
+        modifier = modifier,
+        title = stringResource(CommonStrings.common_add_account),
+        iconStyle = BigIcon.Style.Default(CompoundIcons.HomeSolid()),
+        buttons = { buttons() },
+        content = loginView,
+        onBackClick = onBackClick,
+    )
+}
+
 @Composable
 private fun OnBoardingContent(state: OnBoardingState) {
     Box(
@@ -226,27 +277,29 @@ private fun OnBoardingButtons(
                     .fillMaxWidth()
             )
         }
-        if (state.canReportBug) {
+        if (state.isAddingAccount.not()) {
-            // Add a report problem text button. Use a Text since we need a special theme here.
+            if (state.canReportBug) {
-            Text(
+                // Add a report problem text button. Use a Text since we need a special theme here.
-                modifier = Modifier
+                Text(
-                    .clickable(onClick = onReportProblem)
+                    modifier = Modifier
-                    .padding(16.dp),
+                        .clickable(onClick = onReportProblem)
-                text = stringResource(id = CommonStrings.common_report_a_problem),
+                        .padding(16.dp),
-                style = ElementTheme.typography.fontBodySmRegular,
+                    text = stringResource(id = CommonStrings.common_report_a_problem),
-                color = ElementTheme.colors.textSecondary,
+                    style = ElementTheme.typography.fontBodySmRegular,
-            )
+                    color = ElementTheme.colors.textSecondary,
-        } else {
+                )
-            Text(
+            } else {
-                modifier = Modifier
+                Text(
-                    .clickable {
+                    modifier = Modifier
-                        state.eventSink(OnBoardingEvents.OnVersionClick)
+                        .clickable {
-                    }
+                            state.eventSink(OnBoardingEvents.OnVersionClick)
-                    .padding(16.dp),
+                        }
-                text = stringResource(id = R.string.screen_onboarding_app_version, state.version),
+                        .padding(16.dp),
-                style = ElementTheme.typography.fontBodySmRegular,
+                    text = stringResource(id = R.string.screen_onboarding_app_version, state.version),
-                color = ElementTheme.colors.textSecondary,
+                    style = ElementTheme.typography.fontBodySmRegular,
-            )
+                    color = ElementTheme.colors.textSecondary,
+                )
+            }
         }
     }
 }
@@ -258,6 +311,7 @@ internal fun OnBoardingViewPreview(
 ) = ElementPreview {
     OnBoardingView(
         state = state,
+        onBackClick = {},
         onSignInWithQrCode = {},
         onSignIn = {},
         onCreateAccount = {},

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenterTest.kt

@@ -117,7 +117,7 @@ class ConfirmAccountProviderPresenterTest {
             assertThat(successState.loginMode).isInstanceOf(AsyncData.Success::class.java)
             assertThat(successState.loginMode.dataOrNull()).isInstanceOf(LoginMode.Oidc::class.java)
             authenticationService.givenOidcCancelError(AN_EXCEPTION)
-            defaultOidcActionFlow.post(OidcAction.GoBack)
+            defaultOidcActionFlow.post(OidcAction.GoBack())
             val cancelFailureState = awaitItem()
             assertThat(cancelFailureState.loginMode).isInstanceOf(AsyncData.Failure::class.java)
         }
@@ -144,7 +144,30 @@ class ConfirmAccountProviderPresenterTest {
             assertThat(successState.submitEnabled).isFalse()
             assertThat(successState.loginMode).isInstanceOf(AsyncData.Success::class.java)
             assertThat(successState.loginMode.dataOrNull()).isInstanceOf(LoginMode.Oidc::class.java)
-            defaultOidcActionFlow.post(OidcAction.GoBack)
+            defaultOidcActionFlow.post(OidcAction.GoBack())
+            val cancelFinalState = awaitItem()
+            assertThat(cancelFinalState.loginMode).isInstanceOf(AsyncData.Uninitialized::class.java)
+        }
+    }
+
+    @Test
+    fun `present - oidc - cancel to unblock`() = runTest {
+        val authenticationService = FakeMatrixAuthenticationService()
+        val defaultOidcActionFlow = FakeOidcActionFlow()
+        val presenter = createConfirmAccountProviderPresenter(
+            matrixAuthenticationService = authenticationService,
+            defaultOidcActionFlow = defaultOidcActionFlow,
+        )
+        authenticationService.givenHomeserver(A_HOMESERVER_OIDC)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(ConfirmAccountProviderEvents.Continue)
+            val loadingState = awaitItem()
+            assertThat(loadingState.submitEnabled).isTrue()
+            assertThat(loadingState.loginMode).isInstanceOf(AsyncData.Loading::class.java)
+            defaultOidcActionFlow.post(OidcAction.GoBack(toUnblock = true))
             val cancelFinalState = awaitItem()
             assertThat(cancelFinalState.loginMode).isInstanceOf(AsyncData.Uninitialized::class.java)
         }

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenterTest.kt

@@ -29,6 +29,9 @@ import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationSer
 import io.element.android.libraries.matrix.test.core.aBuildMeta
 import io.element.android.libraries.oidc.api.OidcActionFlow
 import io.element.android.libraries.oidc.test.customtab.FakeOidcActionFlow
+import io.element.android.libraries.sessionstorage.api.SessionStore
+import io.element.android.libraries.sessionstorage.test.InMemorySessionStore
+import io.element.android.libraries.sessionstorage.test.aSessionData
 import io.element.android.libraries.wellknown.api.WellknownRetriever
 import io.element.android.tests.testutils.WarmUpRule
 import io.element.android.tests.testutils.test
@@ -79,10 +82,27 @@ class OnBoardingPresenterTest {
             assertThat(initialState.productionApplicationName).isEqualTo("B")
             assertThat(initialState.canCreateAccount).isEqualTo(OnBoardingConfig.CAN_CREATE_ACCOUNT)
             assertThat(initialState.canReportBug).isFalse()
+            assertThat(initialState.isAddingAccount).isFalse()
             assertThat(awaitItem().canLoginWithQrCode).isTrue()
         }
     }
 
+    @Test
+    fun `present - initial state adding account`() = runTest {
+        val presenter = createPresenter(
+            sessionStore = InMemorySessionStore(
+                initialList = listOf(
+                    aSessionData()
+                )
+            )
+        )
+        presenter.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState.isAddingAccount).isTrue()
+        }
+    }
+
     @Test
     fun `present - on boarding logo`() = runTest {
         val presenter = createPresenter(
@@ -236,6 +256,7 @@ private fun createPresenter(
     rageshakeFeatureAvailability: () -> Flow<Boolean> = { flowOf(true) },
     loginHelper: LoginHelper = createLoginHelper(),
     onBoardingLogoResIdProvider: OnBoardingLogoResIdProvider = OnBoardingLogoResIdProvider { null },
+    sessionStore: SessionStore = InMemorySessionStore(),
 ) = OnBoardingPresenter(
     params = params,
     buildMeta = buildMeta,
@@ -247,6 +268,7 @@ private fun createPresenter(
     rageshakeFeatureAvailability = rageshakeFeatureAvailability,
     loginHelper = loginHelper,
     onBoardingLogoResIdProvider = onBoardingLogoResIdProvider,
+    sessionStore = sessionStore,
 )
 
 fun createLoginHelper(

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnboardingViewTest.kt

@@ -25,6 +25,7 @@ import io.element.android.tests.testutils.EventsRecorder
 import io.element.android.tests.testutils.clickOn
 import io.element.android.tests.testutils.ensureCalledOnce
 import io.element.android.tests.testutils.ensureCalledOnceWithParam
+import io.element.android.tests.testutils.pressBack
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TestRule
@@ -50,6 +51,21 @@ class OnboardingViewTest {
         }
     }
 
+    @Test
+    fun `when can go back - clicking on back calls the expected callback`() {
+        val eventSink = EventsRecorder<OnBoardingEvents>(expectEvents = false)
+        ensureCalledOnce { callback ->
+            rule.setOnboardingView(
+                state = anOnBoardingState(
+                    isAddingAccount = true,
+                    eventSink = eventSink,
+                ),
+                onBackClick = callback,
+            )
+            rule.pressBack()
+        }
+    }
+
     @Test
     fun `when can login with QR code - clicking on sign in with QR code calls the expected callback`() {
         val eventSink = EventsRecorder<OnBoardingEvents>(expectEvents = false)
@@ -235,6 +251,7 @@ class OnboardingViewTest {
 
     private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setOnboardingView(
         state: OnBoardingState,
+        onBackClick: () -> Unit = EnsureNeverCalled(),
         onSignInWithQrCode: () -> Unit = EnsureNeverCalled(),
         onSignIn: (Boolean) -> Unit = EnsureNeverCalledWithParam(),
         onCreateAccount: () -> Unit = EnsureNeverCalled(),
@@ -247,6 +264,7 @@ class OnboardingViewTest {
         setContent {
             OnBoardingView(
                 state = state,
+                onBackClick = onBackClick,
                 onSignInWithQrCode = onSignInWithQrCode,
                 onSignIn = onSignIn,
                 onCreateAccount = onCreateAccount,

features/preferences/api/src/main/kotlin/io/element/android/features/preferences/api/PreferencesEntryPoint.kt

@@ -15,7 +15,6 @@ import io.element.android.libraries.architecture.FeatureEntryPoint
 import io.element.android.libraries.architecture.NodeInputs
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.core.SessionId
 import kotlinx.parcelize.Parcelize
 
 interface PreferencesEntryPoint : FeatureEntryPoint {
@@ -41,9 +40,10 @@ interface PreferencesEntryPoint : FeatureEntryPoint {
     }
 
     interface Callback : Plugin {
+        fun onAddAccount()
         fun onOpenBugReport()
         fun onSecureBackupClick()
         fun onOpenRoomNotificationSettings(roomId: RoomId)
-        fun navigateTo(sessionId: SessionId, roomId: RoomId, eventId: EventId)
+        fun navigateTo(roomId: RoomId, eventId: EventId)
     }
 }

features/preferences/impl/build.gradle.kts

@@ -105,6 +105,7 @@ dependencies {
     testImplementation(projects.features.logout.test)
     testImplementation(projects.libraries.indicator.test)
     testImplementation(projects.libraries.pushproviders.test)
+    testImplementation(projects.libraries.sessionStorage.test)
     testImplementation(projects.services.analytics.test)
     testImplementation(projects.services.toolbox.test)
 }

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/PreferencesFlowNode.kt

@@ -41,7 +41,6 @@ import io.element.android.libraries.architecture.createNode
 import io.element.android.libraries.di.SessionScope
 import io.element.android.libraries.matrix.api.core.EventId
 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.user.MatrixUser
 import io.element.android.libraries.troubleshoot.api.NotificationTroubleShootEntryPoint
 import io.element.android.libraries.troubleshoot.api.PushHistoryEntryPoint
@@ -117,6 +116,10 @@ class PreferencesFlowNode(
         return when (navTarget) {
             NavTarget.Root -> {
                 val callback = object : PreferencesRootNode.Callback {
+                    override fun onAddAccount() {
+                        plugins<PreferencesEntryPoint.Callback>().forEach { it.onAddAccount() }
+                    }
+
                     override fun onOpenBugReport() {
                         plugins<PreferencesEntryPoint.Callback>().forEach { it.onOpenBugReport() }
                     }
@@ -226,8 +229,8 @@ class PreferencesFlowNode(
                             }
                         }
 
-                        override fun onItemClick(sessionId: SessionId, roomId: RoomId, eventId: EventId) {
+                        override fun navigateTo(roomId: RoomId, eventId: EventId) {
-                            plugins<PreferencesEntryPoint.Callback>().forEach { it.navigateTo(sessionId, roomId, eventId) }
+                            plugins<PreferencesEntryPoint.Callback>().forEach { it.navigateTo(roomId, eventId) }
                         }
                     })
                     .build()

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootEvents.kt

@@ -7,6 +7,9 @@
 
 package io.element.android.features.preferences.impl.root
 
+import io.element.android.libraries.matrix.api.core.SessionId
+
 sealed interface PreferencesRootEvents {
     data object OnVersionInfoClick : PreferencesRootEvents
+    data class SwitchToSession(val sessionId: SessionId) : PreferencesRootEvents
 }

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootNode.kt

@@ -34,6 +34,7 @@ class PreferencesRootNode(
     private val directLogoutView: DirectLogoutView,
 ) : Node(buildContext, plugins = plugins) {
     interface Callback : Plugin {
+        fun onAddAccount()
         fun onOpenBugReport()
         fun onSecureBackupClick()
         fun onOpenAnalytics()
@@ -48,6 +49,10 @@ class PreferencesRootNode(
         fun onOpenAccountDeactivation()
     }
 
+    private fun onAddAccount() {
+        plugins<Callback>().forEach { it.onAddAccount() }
+    }
+
     private fun onOpenBugReport() {
         plugins<Callback>().forEach { it.onOpenBugReport() }
     }
@@ -119,6 +124,7 @@ class PreferencesRootNode(
             state = state,
             modifier = modifier,
             onBackClick = this::navigateUp,
+            onAddAccountClick = this::onAddAccount,
             onOpenRageShake = this::onOpenBugReport,
             onOpenAnalytics = this::onOpenAnalytics,
             onOpenAbout = this::onOpenAbout,

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootPresenter.kt

@@ -24,13 +24,21 @@ import io.element.android.features.rageshake.api.RageshakeFeatureAvailability
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarDispatcher
 import io.element.android.libraries.designsystem.utils.snackbar.collectSnackbarMessageAsState
+import io.element.android.libraries.featureflag.api.FeatureFlagService
+import io.element.android.libraries.featureflag.api.FeatureFlags
 import io.element.android.libraries.indicator.api.IndicatorService
 import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.oidc.AccountManagementAction
+import io.element.android.libraries.matrix.api.user.MatrixUser
 import io.element.android.libraries.matrix.api.verification.SessionVerificationService
+import io.element.android.libraries.sessionstorage.api.SessionStore
 import io.element.android.services.analytics.api.AnalyticsService
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toPersistentList
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 
@@ -45,6 +53,8 @@ class PreferencesRootPresenter(
     private val directLogoutPresenter: Presenter<DirectLogoutState>,
     private val showDeveloperSettingsProvider: ShowDeveloperSettingsProvider,
     private val rageshakeFeatureAvailability: RageshakeFeatureAvailability,
+    private val featureFlagService: FeatureFlagService,
+    private val sessionStore: SessionStore,
 ) : Presenter<PreferencesRootState> {
     @Composable
     override fun present(): PreferencesRootState {
@@ -55,6 +65,25 @@ class PreferencesRootPresenter(
             matrixClient.getUserProfile()
         }
 
+        val isMultiAccountEnabled by remember {
+            featureFlagService.isFeatureEnabledFlow(FeatureFlags.MultiAccount)
+        }.collectAsState(initial = false)
+
+        val otherSessions by remember {
+            sessionStore.sessionsFlow().map { list ->
+                list
+                    .filter { it.userId != matrixClient.sessionId.value }
+                    .map {
+                        MatrixUser(
+                            userId = UserId(it.userId),
+                            displayName = it.userDisplayName,
+                            avatarUrl = it.userAvatarUrl,
+                        )
+                    }
+                    .toPersistentList()
+            }
+        }.collectAsState(initial = persistentListOf())
+
         val snackbarMessage by snackbarDispatcher.collectSnackbarMessageAsState()
         val hasAnalyticsProviders = remember { analyticsService.getAvailableAnalyticsProviders().isNotEmpty() }
 
@@ -96,6 +125,9 @@ class PreferencesRootPresenter(
                 is PreferencesRootEvents.OnVersionInfoClick -> {
                     showDeveloperSettingsProvider.unlockDeveloperSettings(coroutineScope)
                 }
+                is PreferencesRootEvents.SwitchToSession -> coroutineScope.launch {
+                    sessionStore.setLatestSession(event.sessionId.value)
+                }
             }
         }
 
@@ -103,6 +135,8 @@ class PreferencesRootPresenter(
             myUser = matrixUser.value,
             version = versionFormatter.get(),
             deviceId = matrixClient.deviceId,
+            isMultiAccountEnabled = isMultiAccountEnabled,
+            otherSessions = otherSessions,
             showSecureBackup = !canVerifyUserSession,
             showSecureBackupBadge = showSecureBackupIndicator,
             accountManagementUrl = accountManagementUrl.value,

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootState.kt

@@ -11,11 +11,14 @@ import io.element.android.features.logout.api.direct.DirectLogoutState
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
 import io.element.android.libraries.matrix.api.core.DeviceId
 import io.element.android.libraries.matrix.api.user.MatrixUser
+import kotlinx.collections.immutable.ImmutableList
 
 data class PreferencesRootState(
     val myUser: MatrixUser,
     val version: String,
     val deviceId: DeviceId?,
+    val isMultiAccountEnabled: Boolean,
+    val otherSessions: ImmutableList<MatrixUser>,
     val showSecureBackup: Boolean,
     val showSecureBackupBadge: Boolean,
     val accountManagementUrl: String?,

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootStateProvider.kt

@@ -11,15 +11,20 @@ import io.element.android.features.logout.api.direct.aDirectLogoutState
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
 import io.element.android.libraries.matrix.api.core.DeviceId
 import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
 import io.element.android.libraries.ui.strings.CommonStrings
+import kotlinx.collections.immutable.toPersistentList
 
 fun aPreferencesRootState(
-    myUser: MatrixUser,
+    myUser: MatrixUser = aMatrixUser(),
+    otherSessions: List<MatrixUser> = emptyList(),
     eventSink: (PreferencesRootEvents) -> Unit = { _ -> },
 ) = PreferencesRootState(
     myUser = myUser,
     version = "Version 1.1 (1)",
     deviceId = DeviceId("ILAKNDNASDLK"),
+    isMultiAccountEnabled = true,
+    otherSessions = otherSessions.toPersistentList(),
     showSecureBackup = true,
     showSecureBackupBadge = true,
     accountManagementUrl = "aUrl",

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootView.kt

@@ -8,6 +8,7 @@
 package io.element.android.features.preferences.impl.root
 
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
 import androidx.compose.foundation.layout.padding
 import androidx.compose.runtime.Composable
@@ -23,11 +24,14 @@ import io.element.android.compound.tokens.generated.CompoundIcons
 import io.element.android.features.preferences.impl.R
 import io.element.android.features.preferences.impl.user.UserPreferences
 import io.element.android.libraries.architecture.coverage.ExcludeFromCoverage
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
 import io.element.android.libraries.designsystem.components.list.ListItemContent
 import io.element.android.libraries.designsystem.components.preferences.PreferencePage
+import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
 import io.element.android.libraries.designsystem.preview.PreviewWithLargeHeight
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
 import io.element.android.libraries.designsystem.theme.components.HorizontalDivider
 import io.element.android.libraries.designsystem.theme.components.IconSource
 import io.element.android.libraries.designsystem.theme.components.ListItem
@@ -38,12 +42,15 @@ import io.element.android.libraries.designsystem.utils.snackbar.rememberSnackbar
 import io.element.android.libraries.matrix.api.core.DeviceId
 import io.element.android.libraries.matrix.api.user.MatrixUser
 import io.element.android.libraries.matrix.ui.components.MatrixUserProvider
+import io.element.android.libraries.matrix.ui.components.MatrixUserRow
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
 import io.element.android.libraries.ui.strings.CommonStrings
 
 @Composable
 fun PreferencesRootView(
     state: PreferencesRootState,
     onBackClick: () -> Unit,
+    onAddAccountClick: () -> Unit,
     onSecureBackupClick: () -> Unit,
     onManageAccountClick: (url: String) -> Unit,
     onOpenAnalytics: () -> Unit,
@@ -74,7 +81,12 @@ fun PreferencesRootView(
             },
             user = state.myUser,
         )
-
+        if (state.isMultiAccountEnabled) {
+            MultiAccountSection(
+                state = state,
+                onAddAccountClick = onAddAccountClick,
+            )
+        }
         // 'Manage my app' section
         ManageAppSection(
             state = state,
@@ -114,6 +126,38 @@ fun PreferencesRootView(
     }
 }
 
+@Composable
+private fun ColumnScope.MultiAccountSection(
+    state: PreferencesRootState,
+    onAddAccountClick: () -> Unit,
+) {
+    HorizontalDivider(
+        thickness = 8.dp,
+        color = ElementTheme.colors.bgSubtleSecondary,
+    )
+    state.otherSessions.forEach { matrixUser ->
+        MatrixUserRow(
+            modifier = Modifier.clickable {
+                state.eventSink(PreferencesRootEvents.SwitchToSession(matrixUser.userId))
+            },
+            matrixUser = matrixUser,
+            avatarSize = AvatarSize.AccountItem,
+        )
+        HorizontalDivider()
+    }
+    ListItem(
+        leadingContent = ListItemContent.Icon(IconSource.Vector(CompoundIcons.Plus())),
+        headlineContent = {
+            Text(stringResource(CommonStrings.common_add_another_account))
+        },
+        onClick = onAddAccountClick,
+    )
+    HorizontalDivider(
+        thickness = 8.dp,
+        color = ElementTheme.colors.bgSubtleSecondary,
+    )
+}
+
 @Composable
 private fun ColumnScope.ManageAppSection(
     state: PreferencesRootState,
@@ -287,6 +331,7 @@ private fun ContentToPreview(matrixUser: MatrixUser) {
     PreferencesRootView(
         state = aPreferencesRootState(myUser = matrixUser),
         onBackClick = {},
+        onAddAccountClick = {},
         onOpenAnalytics = {},
         onOpenRageShake = {},
         onOpenDeveloperSettings = {},
@@ -302,3 +347,16 @@ private fun ContentToPreview(matrixUser: MatrixUser) {
         onDeactivateClick = {},
     )
 }
+
+@PreviewsDayNight
+@Composable
+internal fun MultiAccountSectionPreview() = ElementPreview {
+    Column {
+        MultiAccountSection(
+            state = aPreferencesRootState(
+                otherSessions = aMatrixUserList(),
+            ),
+            onAddAccountClick = {},
+        )
+    }
+}

features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/DefaultPreferencesEntryPointTest.kt

@@ -20,7 +20,6 @@ import io.element.android.features.logout.api.LogoutEntryPoint
 import io.element.android.features.preferences.api.PreferencesEntryPoint
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.troubleshoot.api.NotificationTroubleShootEntryPoint
 import io.element.android.libraries.troubleshoot.api.PushHistoryEntryPoint
 import io.element.android.tests.testutils.lambda.lambdaError
@@ -64,10 +63,11 @@ class DefaultPreferencesEntryPointTest {
             )
         }
         val callback = object : PreferencesEntryPoint.Callback {
+            override fun onAddAccount() = lambdaError()
             override fun onOpenBugReport() = lambdaError()
             override fun onSecureBackupClick() = lambdaError()
             override fun onOpenRoomNotificationSettings(roomId: RoomId) = lambdaError()
-            override fun navigateTo(sessionId: SessionId, roomId: RoomId, eventId: EventId) = lambdaError()
+            override fun navigateTo(roomId: RoomId, eventId: EventId) = lambdaError()
         }
         val params = PreferencesEntryPoint.Params(
             initialElement = PreferencesEntryPoint.InitialTarget.NotificationSettings,

features/preferences/impl/src/test/kotlin/io/element/android/features/preferences/impl/root/PreferencesRootPresenterTest.kt

@@ -16,15 +16,23 @@ import io.element.android.features.preferences.impl.utils.ShowDeveloperSettingsP
 import io.element.android.features.rageshake.api.RageshakeFeatureAvailability
 import io.element.android.libraries.core.meta.BuildType
 import io.element.android.libraries.designsystem.utils.snackbar.SnackbarDispatcher
+import io.element.android.libraries.featureflag.api.FeatureFlagService
+import io.element.android.libraries.featureflag.api.FeatureFlags
+import io.element.android.libraries.featureflag.test.FakeFeatureFlagService
 import io.element.android.libraries.indicator.api.IndicatorService
 import io.element.android.libraries.indicator.test.FakeIndicatorService
 import io.element.android.libraries.matrix.api.oidc.AccountManagementAction
 import io.element.android.libraries.matrix.api.user.MatrixUser
 import io.element.android.libraries.matrix.test.AN_AVATAR_URL
+import io.element.android.libraries.matrix.test.A_SESSION_ID
+import io.element.android.libraries.matrix.test.A_SESSION_ID_2
 import io.element.android.libraries.matrix.test.A_USER_NAME
 import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.matrix.test.core.aBuildMeta
 import io.element.android.libraries.matrix.test.verification.FakeSessionVerificationService
+import io.element.android.libraries.sessionstorage.api.SessionStore
+import io.element.android.libraries.sessionstorage.test.InMemorySessionStore
+import io.element.android.libraries.sessionstorage.test.aSessionData
 import io.element.android.services.analytics.test.FakeAnalyticsService
 import io.element.android.tests.testutils.WarmUpRule
 import io.element.android.tests.testutils.lambda.lambdaRecorder
@@ -61,6 +69,8 @@ class PreferencesRootPresenterTest {
                 )
             )
             assertThat(initialState.version).isEqualTo("A Version")
+            assertThat(initialState.isMultiAccountEnabled).isFalse()
+            assertThat(initialState.otherSessions).isEmpty()
             val loadedState = awaitItem()
             assertThat(loadedState.myUser).isEqualTo(
                 MatrixUser(
@@ -174,6 +184,34 @@ class PreferencesRootPresenterTest {
         }
     }
 
+    @Test
+    fun `present - multiple accounts`() = runTest {
+        createPresenter(
+            matrixClient = FakeMatrixClient(
+                sessionId = A_SESSION_ID,
+                canDeactivateAccountResult = { true },
+            ),
+            featureFlagService = FakeFeatureFlagService(
+                initialState = mapOf(FeatureFlags.MultiAccount.key to true)
+            ),
+            sessionStore = InMemorySessionStore(
+                initialList = listOf(
+                    aSessionData(sessionId = A_SESSION_ID.value),
+                    aSessionData(
+                        sessionId = A_SESSION_ID_2.value,
+                        userDisplayName = "Bob",
+                        userAvatarUrl = "avatarUrl",
+                    ),
+                )
+            )
+        ).test {
+            val state = awaitFirstItem()
+            assertThat(state.isMultiAccountEnabled).isTrue()
+            assertThat(state.otherSessions).hasSize(1)
+            assertThat(state.otherSessions[0]).isEqualTo(MatrixUser(userId = A_SESSION_ID_2, displayName = "Bob", avatarUrl = "avatarUrl"))
+        }
+    }
+
     private suspend fun <T> ReceiveTurbine<T>.awaitFirstItem(): T {
         skipItems(1)
         return awaitItem()
@@ -185,6 +223,8 @@ class PreferencesRootPresenterTest {
         showDeveloperSettingsProvider: ShowDeveloperSettingsProvider = ShowDeveloperSettingsProvider(aBuildMeta(BuildType.DEBUG)),
         rageshakeFeatureAvailability: RageshakeFeatureAvailability = RageshakeFeatureAvailability { flowOf(true) },
         indicatorService: IndicatorService = FakeIndicatorService(),
+        featureFlagService: FeatureFlagService = FakeFeatureFlagService(),
+        sessionStore: SessionStore = InMemorySessionStore(),
     ) = PreferencesRootPresenter(
         matrixClient = matrixClient,
         sessionVerificationService = sessionVerificationService,
@@ -195,5 +235,7 @@ class PreferencesRootPresenterTest {
         directLogoutPresenter = { aDirectLogoutState() },
         showDeveloperSettingsProvider = showDeveloperSettingsProvider,
         rageshakeFeatureAvailability = rageshakeFeatureAvailability,
+        featureFlagService = featureFlagService,
+        sessionStore = sessionStore,
     )
 }

features/signedout/impl/src/main/kotlin/io/element/android/features/signedout/impl/SignedOutStateProvider.kt

@@ -43,5 +43,9 @@ private fun aSessionData(
         passphrase = null,
         sessionPath = "/a/path/to/a/session",
         cachePath = "/a/path/to/a/cache",
+        position = 0,
+        lastUsageIndex = 0,
+        userDisplayName = null,
+        userAvatarUrl = null,
     )
 }

libraries/accountselect/api/build.gradle.kts

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+plugins {
+    id("io.element.android-library")
+}
+
+android {
+    namespace = "io.element.android.libraries.accountselect.api"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+}

libraries/accountselect/api/src/main/kotlin/io/element/android/libraries/accountselect/api/AccountSelectEntryPoint.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.api
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import io.element.android.libraries.architecture.FeatureEntryPoint
+import io.element.android.libraries.matrix.api.core.SessionId
+
+interface AccountSelectEntryPoint : FeatureEntryPoint {
+    fun nodeBuilder(parentNode: Node, buildContext: BuildContext): NodeBuilder
+
+    interface NodeBuilder {
+        fun callback(callback: Callback): NodeBuilder
+        fun build(): Node
+    }
+
+    interface Callback : Plugin {
+        fun onSelectAccount(sessionId: SessionId)
+        fun onCancel()
+    }
+}

libraries/accountselect/impl/build.gradle.kts

@@ -0,0 +1,35 @@
+import extension.setupDependencyInjection
+import extension.testCommonDependencies
+
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+}
+
+android {
+    namespace = "io.element.android.libraries.accountselect.impl"
+}
+
+setupDependencyInjection()
+
+dependencies {
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.androidutils)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.matrixui)
+    implementation(projects.libraries.sessionStorage.api)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.uiStrings)
+    api(projects.libraries.accountselect.api)
+
+    testCommonDependencies(libs)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.libraries.sessionStorage.test)
+}

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectNode.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.AssistedInject
+import io.element.android.annotations.ContributesNode
+import io.element.android.libraries.accountselect.api.AccountSelectEntryPoint
+import io.element.android.libraries.matrix.api.core.SessionId
+
+@ContributesNode(AppScope::class)
+@AssistedInject
+class AccountSelectNode(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: AccountSelectPresenter,
+) : Node(buildContext, plugins = plugins) {
+    private val callbacks = plugins.filterIsInstance<AccountSelectEntryPoint.Callback>()
+
+    private fun onDismiss() {
+        callbacks.forEach { it.onCancel() }
+    }
+
+    private fun onSelectAccount(sessionId: SessionId) {
+        callbacks.forEach { it.onSelectAccount(sessionId) }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        AccountSelectView(
+            state = state,
+            onDismiss = ::onDismiss,
+            onSelectAccount = ::onSelectAccount,
+            modifier = modifier,
+        )
+    }
+}

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectPresenter.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.produceState
+import dev.zacsweers.metro.Inject
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.sessionstorage.api.SessionStore
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toPersistentList
+
+@Inject
+class AccountSelectPresenter(
+    private val sessionStore: SessionStore,
+) : Presenter<AccountSelectState> {
+    @Composable
+    override fun present(): AccountSelectState {
+        val accounts by produceState(persistentListOf()) {
+            // Do not use sessionStore.sessionsFlow() to not make it change when an account is selected.
+            value = sessionStore.getAllSessions()
+                .map {
+                    MatrixUser(
+                        userId = UserId(it.userId),
+                        displayName = it.userDisplayName,
+                        avatarUrl = it.userAvatarUrl,
+                    )
+                }
+                .toPersistentList()
+        }
+
+        return AccountSelectState(
+            accounts = accounts,
+        )
+    }
+}

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectState.kt

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import kotlinx.collections.immutable.ImmutableList
+
+data class AccountSelectState(
+    val accounts: ImmutableList<MatrixUser>,
+)

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectStateProvider.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import kotlinx.collections.immutable.toPersistentList
+
+open class AccountSelectStateProvider : PreviewParameterProvider<AccountSelectState> {
+    override val values: Sequence<AccountSelectState>
+        get() = sequenceOf(
+            anAccountSelectState(),
+            anAccountSelectState(accounts = aMatrixUserList()),
+        )
+}
+
+private fun anAccountSelectState(
+    accounts: List<MatrixUser> = listOf(),
+) = AccountSelectState(
+    accounts = accounts.toPersistentList(),
+)

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectView.kt

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.consumeWindowInsets
+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.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.components.HorizontalDivider
+import io.element.android.libraries.designsystem.theme.components.Scaffold
+import io.element.android.libraries.designsystem.theme.components.TopAppBar
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.ui.components.MatrixUserRow
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Suppress("MultipleEmitters") // False positive
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AccountSelectView(
+    state: AccountSelectState,
+    onSelectAccount: (SessionId) -> Unit,
+    onDismiss: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    BackHandler(onBack = { onDismiss() })
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(
+                titleStr = stringResource(CommonStrings.common_select_account),
+                navigationIcon = {
+                    BackButton(onClick = { onDismiss() })
+                },
+            )
+        }
+    ) { paddingValues ->
+        Column(
+            Modifier
+                .padding(paddingValues)
+                .consumeWindowInsets(paddingValues)
+        ) {
+            LazyColumn {
+                items(state.accounts, key = { it.userId }) { matrixUser ->
+                    Column {
+                        MatrixUserRow(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .clickable {
+                                    onSelectAccount(matrixUser.userId)
+                                }
+                                .padding(vertical = 8.dp),
+                            matrixUser = matrixUser,
+                        )
+                        HorizontalDivider()
+                    }
+                }
+            }
+        }
+    }
+}
+
+@PreviewsDayNight
+@Composable
+internal fun AccountSelectViewPreview(@PreviewParameter(AccountSelectStateProvider::class) state: AccountSelectState) = ElementPreview {
+    AccountSelectView(
+        state = state,
+        onSelectAccount = {},
+        onDismiss = {},
+    )
+}

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/DefaultAccountSelectEntryPoint.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import dev.zacsweers.metro.Inject
+import io.element.android.libraries.accountselect.api.AccountSelectEntryPoint
+import io.element.android.libraries.architecture.createNode
+
+@ContributesBinding(AppScope::class)
+@Inject
+class DefaultAccountSelectEntryPoint : AccountSelectEntryPoint {
+    override fun nodeBuilder(parentNode: Node, buildContext: BuildContext): AccountSelectEntryPoint.NodeBuilder {
+        val plugins = ArrayList<Plugin>()
+
+        return object : AccountSelectEntryPoint.NodeBuilder {
+            override fun callback(callback: AccountSelectEntryPoint.Callback): AccountSelectEntryPoint.NodeBuilder {
+                plugins += callback
+                return this
+            }
+
+            override fun build(): Node {
+                return parentNode.createNode<AccountSelectNode>(buildContext, plugins)
+            }
+        }
+    }
+}

libraries/accountselect/impl/src/test/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectPresenterTest.kt

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.test.A_SESSION_ID
+import io.element.android.libraries.matrix.test.A_SESSION_ID_2
+import io.element.android.libraries.sessionstorage.api.SessionStore
+import io.element.android.libraries.sessionstorage.test.InMemorySessionStore
+import io.element.android.libraries.sessionstorage.test.aSessionData
+import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.test
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class AccountSelectPresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createAccountSelectPresenter()
+        presenter.test {
+            val initialState = awaitItem()
+            assertThat(initialState.accounts).isEmpty()
+        }
+    }
+
+    @Test
+    fun `present - multiple accounts case`() = runTest {
+        val presenter = createAccountSelectPresenter(
+            sessionStore = InMemorySessionStore(
+                initialList = listOf(
+                    aSessionData(sessionId = A_SESSION_ID.value),
+                    aSessionData(
+                        sessionId = A_SESSION_ID_2.value,
+                        userDisplayName = "Bob",
+                        userAvatarUrl = "avatarUrl",
+                    ),
+                )
+            )
+        )
+        presenter.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState.accounts).hasSize(2)
+            val firstAccount = initialState.accounts[0]
+            assertThat(firstAccount).isEqualTo(
+                MatrixUser(
+                    userId = A_SESSION_ID,
+                    displayName = null,
+                    avatarUrl = null,
+                )
+            )
+            val secondAccount = initialState.accounts[1]
+            assertThat(secondAccount).isEqualTo(
+                MatrixUser(
+                    userId = A_SESSION_ID_2,
+                    displayName = "Bob",
+                    avatarUrl = "avatarUrl",
+                )
+            )
+        }
+    }
+}
+
+internal fun createAccountSelectPresenter(
+    sessionStore: SessionStore = InMemorySessionStore(),
+) = AccountSelectPresenter(
+    sessionStore = sessionStore,
+)

libraries/accountselect/impl/src/test/kotlin/io/element/android/libraries/accountselect/impl/DefaultAccountSelectEntryPointTest.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import com.bumble.appyx.core.modality.BuildContext
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.accountselect.api.AccountSelectEntryPoint
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.tests.testutils.lambda.lambdaError
+import io.element.android.tests.testutils.node.TestParentNode
+import org.junit.Rule
+import org.junit.Test
+
+class DefaultAccountSelectEntryPointTest {
+    @get:Rule
+    val instantTaskExecutorRule = InstantTaskExecutorRule()
+
+    @Test
+    fun `test node builder`() {
+        val entryPoint = DefaultAccountSelectEntryPoint()
+        val parentNode = TestParentNode.create { buildContext, plugins ->
+            AccountSelectNode(
+                buildContext = buildContext,
+                plugins = plugins,
+                presenter = createAccountSelectPresenter(),
+            )
+        }
+        val callback = object : AccountSelectEntryPoint.Callback {
+            override fun onSelectAccount(sessionId: SessionId) = lambdaError()
+            override fun onCancel() = lambdaError()
+        }
+        val result = entryPoint.nodeBuilder(parentNode, BuildContext.root(null))
+            .callback(callback)
+            .build()
+        assertThat(result).isInstanceOf(AccountSelectNode::class.java)
+        assertThat(result.plugins).contains(callback)
+    }
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/appyx/DelegateTransitionHandler.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture.appyx
+
+import android.annotation.SuppressLint
+import androidx.compose.animation.core.Transition
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.navigation.transition.ModifierTransitionHandler
+import com.bumble.appyx.core.navigation.transition.TransitionDescriptor
+
+/**
+ * A [ModifierTransitionHandler] that delegates the creation of the modifier to another handler
+ * based on the [NavTarget]. The idea is to allow different transitions for different [NavTarget]s.
+ */
+class DelegateTransitionHandler<NavTarget, State>(
+    private val handlerProvider: (NavTarget) -> ModifierTransitionHandler<NavTarget, State>,
+) : ModifierTransitionHandler<NavTarget, State>() {
+    @SuppressLint("ModifierFactoryExtensionFunction")
+    override fun createModifier(modifier: Modifier, transition: Transition<State>, descriptor: TransitionDescriptor<NavTarget, State>): Modifier {
+        return handlerProvider(descriptor.element).createModifier(modifier, transition, descriptor)
+    }
+}
+
+@Composable
+fun <NavTarget, State> rememberDelegateTransitionHandler(
+    handlerProvider: (NavTarget) -> ModifierTransitionHandler<NavTarget, State>,
+): ModifierTransitionHandler<NavTarget, State> =
+    remember(handlerProvider) { DelegateTransitionHandler(handlerProvider = handlerProvider) }

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/components/avatar/AvatarSize.kt

@@ -73,4 +73,6 @@ enum class AvatarSize(val dp: Dp) {
     RoomPreviewInviter(56.dp),
     SpaceMember(24.dp),
     LeaveSpaceRoom(32.dp),
+
+    AccountItem(32.dp),
 }

libraries/featureflag/api/src/main/kotlin/io/element/android/libraries/featureflag/api/FeatureFlags.kt

@@ -99,5 +99,13 @@ enum class FeatureFlags(
         description = "Renders thread messages as a dedicated timeline. Restarting the app is required for this setting to fully take effect.",
         defaultValue = { false },
         isFinished = false,
-    )
+    ),
+    MultiAccount(
+        key = "feature.multi_account",
+        title = "Multi accounts",
+        description = "Allow the application to connect to multiple accounts at the same time." +
+            "\n\nWARNING: this feature is EXPERIMENTAL and UNSTABLE.",
+        defaultValue = { false },
+        isFinished = false,
+    ),
 }

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/auth/AuthenticationException.kt

@@ -8,6 +8,7 @@
 package io.element.android.libraries.matrix.api.auth
 
 sealed class AuthenticationException(message: String) : Exception(message) {
+    class AccountAlreadyLoggedIn(userId: String) : AuthenticationException(userId)
     class InvalidServerName(message: String) : AuthenticationException(message)
     class SlidingSyncVersion(message: String) : AuthenticationException(message)
     class Oidc(message: String) : AuthenticationException(message)

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/permalink/PermalinkData.kt

@@ -8,6 +8,7 @@
 package io.element.android.libraries.matrix.api.permalink
 
 import android.net.Uri
+import android.os.Parcelable
 import androidx.compose.runtime.Immutable
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
@@ -15,13 +16,15 @@ import io.element.android.libraries.matrix.api.core.RoomIdOrAlias
 import io.element.android.libraries.matrix.api.core.UserId
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
+import kotlinx.parcelize.Parcelize
 
 /**
  * This sealed class represents all the permalink cases.
  * You don't have to instantiate yourself but should use [PermalinkParser] instead.
  */
 @Immutable
-sealed interface PermalinkData {
+@Parcelize
+sealed interface PermalinkData : Parcelable {
     data class RoomLink(
         val roomIdOrAlias: RoomIdOrAlias,
         val eventId: EventId? = null,

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt

@@ -235,7 +235,6 @@ class RustMatrixClient(
     private val _userProfile: MutableStateFlow<MatrixUser> = MutableStateFlow(
         MatrixUser(
             userId = sessionId,
-            // TODO cache for displayName?
             displayName = null,
             avatarUrl = null,
         )
@@ -264,6 +263,16 @@ class RustMatrixClient(
             // Start notification settings
             notificationSettingsService.start()
 
+            // Update the user profile in the session store if needed
+            sessionStore.getSession(sessionId.value)?.let { sessionData ->
+                _userProfile.emit(
+                    MatrixUser(
+                        userId = sessionId,
+                        displayName = sessionData.userDisplayName,
+                        avatarUrl = sessionData.userAvatarUrl,
+                    )
+                )
+            }
             // Force a refresh of the profile
             getUserProfile()
         }
@@ -399,7 +408,15 @@ class RustMatrixClient(
     }
 
     override suspend fun getUserProfile(): Result<MatrixUser> = getProfile(sessionId)
-        .onSuccess { _userProfile.tryEmit(it) }
+        .onSuccess { matrixUser ->
+            _userProfile.emit(matrixUser)
+            // Also update our session storage
+            sessionStore.updateUserProfile(
+                sessionId = sessionId.value,
+                displayName = matrixUser.displayName,
+                avatarUrl = matrixUser.avatarUrl,
+            )
+        }
 
     override suspend fun searchUsers(searchTerm: String, limit: Long): Result<MatrixSearchUserResults> =
         withContext(sessionDispatcher) {

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/auth/AuthenticationException.kt

@@ -14,6 +14,7 @@ import org.matrix.rustcomponents.sdk.OidcException
 fun Throwable.mapAuthenticationException(): AuthenticationException {
     val message = this.message ?: "Unknown error"
     return when (this) {
+        is AuthenticationException -> this
         is ClientBuildException -> when (this) {
             is ClientBuildException.Generic -> AuthenticationException.Generic(message)
             is ClientBuildException.InvalidServerName -> AuthenticationException.InvalidServerName(message)

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/auth/RustMatrixAuthenticationService.kt

@@ -15,6 +15,7 @@ import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.core.extensions.mapFailure
 import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.auth.AuthenticationException
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
 import io.element.android.libraries.matrix.api.auth.OidcDetails
@@ -139,6 +140,8 @@ class RustMatrixAuthenticationService(
                 val client = currentClient ?: error("You need to call `setHomeserver()` first")
                 val currentSessionPaths = sessionPaths ?: error("You need to call `setHomeserver()` first")
                 client.login(username, password, "Element X Android", null)
+                // Ensure that the user is not already logged in with the same account
+                ensureNotAlreadyLoggedIn(client)
                 val sessionData = client.session()
                     .toSessionData(
                         isTokenValid = true,
@@ -227,17 +230,19 @@ class RustMatrixAuthenticationService(
                 val client = currentClient ?: error("You need to call `setHomeserver()` first")
                 val currentSessionPaths = sessionPaths ?: error("You need to call `setHomeserver()` first")
                 client.loginWithOidcCallback(callbackUrl)
+
+                // Free the pending data since we won't use it to abort the flow anymore
+                pendingOAuthAuthorizationData?.close()
+                pendingOAuthAuthorizationData = null
+
+                // Ensure that the user is not already logged in with the same account
+                ensureNotAlreadyLoggedIn(client)
                 val sessionData = client.session().toSessionData(
                     isTokenValid = true,
                     loginType = LoginType.OIDC,
                     passphrase = pendingPassphrase,
                     sessionPaths = currentSessionPaths,
                 )
-
-                // Free the pending data since we won't use it to abort the flow anymore
-                pendingOAuthAuthorizationData?.close()
-                pendingOAuthAuthorizationData = null
-
                 val matrixClient = rustMatrixClientFactory.create(client)
                 newMatrixClientObservers.forEach { it.invoke(matrixClient) }
                 sessionStore.addSession(sessionData)
@@ -253,6 +258,21 @@ class RustMatrixAuthenticationService(
         }
     }
 
+    @Throws(AuthenticationException.AccountAlreadyLoggedIn::class)
+    private suspend fun ensureNotAlreadyLoggedIn(client: Client) {
+        val newUserId = client.userId()
+        val accountAlreadyLoggedIn = sessionStore.getAllSessions().any {
+            it.userId == newUserId
+        }
+        if (accountAlreadyLoggedIn) {
+            // Sign out the client, ignoring any error
+            runCatchingExceptions {
+                client.logout()
+            }
+            throw AuthenticationException.AccountAlreadyLoggedIn(newUserId)
+        }
+    }
+
     override suspend fun loginWithQrCode(qrCodeData: MatrixQrCodeLoginData, progress: (QrCodeLoginStep) -> Unit) =
         withContext(coroutineDispatchers.io) {
             val sdkQrCodeLoginData = (qrCodeData as SdkQrCodeLoginData).rustQrCodeData
@@ -275,7 +295,8 @@ class RustMatrixAuthenticationService(
                     oidcConfiguration = oidcConfiguration,
                     progressListener = progressListener,
                 )
-
+                // Ensure that the user is not already logged in with the same account
+                ensureNotAlreadyLoggedIn(client)
                 val sessionData = client.session()
                     .toSessionData(
                         isTokenValid = true,

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/mapper/Session.kt

@@ -34,6 +34,11 @@ internal fun Session.toSessionData(
     passphrase = passphrase,
     sessionPath = sessionPaths.fileDirectory.absolutePath,
     cachePath = sessionPaths.cacheDirectory.absolutePath,
+    // Note: position and lastUsageIndex will be set by the SessionStore when adding the session
+    position = 0,
+    lastUsageIndex = 0,
+    userDisplayName = null,
+    userAvatarUrl = null,
 )
 
 internal fun ExternalSession.toSessionData(
@@ -55,4 +60,8 @@ internal fun ExternalSession.toSessionData(
     passphrase = passphrase,
     sessionPath = sessionPaths.fileDirectory.absolutePath,
     cachePath = sessionPaths.cacheDirectory.absolutePath,
+    position = 0,
+    lastUsageIndex = 0,
+    userDisplayName = null,
+    userAvatarUrl = null,
 )

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClientFactoryTest.kt

@@ -38,7 +38,9 @@ class RustMatrixClientFactoryTest {
 fun TestScope.createRustMatrixClientFactory(
     baseDirectory: File = File("/base"),
     cacheDirectory: File = File("/cache"),
-    sessionStore: SessionStore = InMemorySessionStore(),
+    sessionStore: SessionStore = InMemorySessionStore(
+        updateUserProfileResult = { _, _, _ -> },
+    ),
     clientBuilderProvider: ClientBuilderProvider = FakeClientBuilderProvider(),
 ) = RustMatrixClientFactory(
     baseDirectory = baseDirectory,

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClientTest.kt

@@ -5,6 +5,8 @@
  * Please see LICENSE files in the repository root for full details.
  */
 
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
 package io.element.android.libraries.matrix.impl
 
 import com.google.common.truth.Truth.assertThat
@@ -12,17 +14,24 @@ import io.element.android.libraries.featureflag.test.FakeFeatureFlagService
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeFfiClient
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeFfiSyncService
 import io.element.android.libraries.matrix.impl.room.FakeTimelineEventTypeFilterFactory
+import io.element.android.libraries.matrix.test.AN_AVATAR_URL
 import io.element.android.libraries.matrix.test.A_DEVICE_ID
 import io.element.android.libraries.matrix.test.A_USER_ID
+import io.element.android.libraries.matrix.test.A_USER_NAME
 import io.element.android.libraries.sessionstorage.api.SessionStore
 import io.element.android.libraries.sessionstorage.test.InMemorySessionStore
+import io.element.android.libraries.sessionstorage.test.aSessionData
 import io.element.android.services.toolbox.test.systemclock.FakeSystemClock
 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.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import org.matrix.rustcomponents.sdk.Client
+import org.matrix.rustcomponents.sdk.UserProfile
 import java.io.File
 
 class RustMatrixClientTest {
@@ -51,9 +60,46 @@ class RustMatrixClientTest {
         client.destroy()
     }
 
+    @Test
+    fun `retrieving the UserProfile updates the database`() = runTest {
+        val updateUserProfileResult = lambdaRecorder<String, String?, String?, Unit> { _, _, _ -> }
+        val sessionStore = InMemorySessionStore(
+            initialList = listOf(
+                aSessionData(
+                    sessionId = A_USER_ID.value,
+                    userDisplayName = null,
+                    userAvatarUrl = null,
+                )
+            ),
+            updateUserProfileResult = updateUserProfileResult,
+        )
+        val client = createRustMatrixClient(
+            client = FakeFfiClient(
+                getProfileResult = { userId ->
+                    UserProfile(
+                        userId = userId,
+                        displayName = A_USER_NAME,
+                        avatarUrl = AN_AVATAR_URL,
+                    )
+                },
+            ),
+            sessionStore = sessionStore,
+        )
+        advanceUntilIdle()
+        updateUserProfileResult.assertions().isCalledOnce()
+            .with(
+                value(A_USER_ID.value),
+                value(A_USER_NAME),
+                value(AN_AVATAR_URL),
+            )
+        client.destroy()
+    }
+
     private fun TestScope.createRustMatrixClient(
         client: Client = FakeFfiClient(),
-        sessionStore: SessionStore = InMemorySessionStore(),
+        sessionStore: SessionStore = InMemorySessionStore(
+            updateUserProfileResult = { _, _, _ -> },
+        ),
     ) = RustMatrixClient(
         innerClient = client,
         baseDirectory = File(""),

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeFfiClient.kt

@@ -42,6 +42,7 @@ class FakeFfiClient(
     private val session: Session = aRustSession(),
     private val clearCachesResult: () -> Unit = { lambdaError() },
     private val withUtdHook: (UnableToDecryptDelegate) -> Unit = { lambdaError() },
+    private val getProfileResult: (String) -> UserProfile = { UserProfile(userId = userId, displayName = null, avatarUrl = null) },
     private val homeserverLoginDetailsResult: () -> HomeserverLoginDetails = { lambdaError() },
     private val closeResult: () -> Unit = {},
 ) : Client(NoPointer) {
@@ -79,7 +80,7 @@ class FakeFfiClient(
     }
 
     override suspend fun getProfile(userId: String): UserProfile {
-        return UserProfile(userId = userId, displayName = null, avatarUrl = null)
+        return getProfileResult(userId)
     }
 
     override suspend fun homeserverLoginDetails(): HomeserverLoginDetails {

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeFfiClientBuilder.kt

@@ -42,6 +42,5 @@ class FakeFfiClientBuilder(
     override fun username(username: String) = this
     override fun enableShareHistoryOnInvite(enableShareHistoryOnInvite: Boolean): ClientBuilder = this
     override fun threadsEnabled(enabled: Boolean, threadSubscriptions: Boolean): ClientBuilder = this
-
     override suspend fun build() = buildResult()
 }

libraries/oidc/api/src/main/kotlin/io/element/android/libraries/oidc/api/OidcAction.kt

@@ -8,6 +8,6 @@
 package io.element.android.libraries.oidc.api
 
 sealed interface OidcAction {
-    data object GoBack : OidcAction
+    data class GoBack(val toUnblock: Boolean = false) : OidcAction
     data class Success(val url: String) : OidcAction
 }

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/OidcUrlParser.kt

@@ -36,7 +36,7 @@ class DefaultOidcUrlParser(
      */
     override fun parse(url: String): OidcAction? {
         if (url.startsWith(oidcRedirectUrlProvider.provide()).not()) return null
-        if (url.contains("error=access_denied")) return OidcAction.GoBack
+        if (url.contains("error=access_denied")) return OidcAction.GoBack()
         if (url.contains("code=")) return OidcAction.Success(url)
 
         // Other case not supported, let's crash the app for now

libraries/oidc/impl/src/test/kotlin/io/element/android/libraries/oidc/impl/DefaultOidcActionFlowTest.kt

@@ -24,10 +24,10 @@ class DefaultOidcActionFlowTest {
                 data.add(action)
             }
         }
-        sut.post(OidcAction.GoBack)
+        sut.post(OidcAction.GoBack())
         delay(1)
         sut.reset()
         delay(1)
-        assertThat(data).containsExactly(OidcAction.GoBack, null)
+        assertThat(data).containsExactly(OidcAction.GoBack(), null)
     }
 }

libraries/oidc/impl/src/test/kotlin/io/element/android/libraries/oidc/impl/DefaultOidcIntentResolverTest.kt

@@ -29,7 +29,7 @@ class DefaultOidcIntentResolverTest {
             data = "io.element.android:/?error=access_denied&state=IFF1UETGye2ZA8pO".toUri()
         }
         val result = sut.resolve(intent)
-        assertThat(result).isEqualTo(OidcAction.GoBack)
+        assertThat(result).isEqualTo(OidcAction.GoBack())
     }
 
     @Test

libraries/oidc/impl/src/test/kotlin/io/element/android/libraries/oidc/impl/DefaultOidcUrlParserTest.kt

@@ -31,7 +31,7 @@ class DefaultOidcUrlParserTest {
     fun `test cancel url`() {
         val sut = createDefaultOidcUrlParser()
         val aCancelUrl = "$FAKE_REDIRECT_URL?error=access_denied&state=IFF1UETGye2ZA8pO"
-        assertThat(sut.parse(aCancelUrl)).isEqualTo(OidcAction.GoBack)
+        assertThat(sut.parse(aCancelUrl)).isEqualTo(OidcAction.GoBack())
     }
 
     @Test

libraries/session-storage/api/src/main/kotlin/io/element/android/libraries/sessionstorage/api/SessionData.kt

@@ -39,4 +39,12 @@ data class SessionData(
     val sessionPath: String,
     /** The path to the cache data stored for the session in the filesystem. */
     val cachePath: String,
+    /** The position, to be able to order account. */
+    val position: Long,
+    /** The index of the last date of session usage. */
+    val lastUsageIndex: Long,
+    /** The optional display name of the user. */
+    val userDisplayName: String?,
+    /** The optional avatar URL of the user. */
+    val userAvatarUrl: String?,
 )

libraries/session-storage/api/src/main/kotlin/io/element/android/libraries/sessionstorage/api/SessionStore.kt

@@ -11,8 +11,22 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
 interface SessionStore {
+    /**
+     * A flow emitting the current logged in state.
+     * If there is at least one session, the state is [LoggedInState.LoggedIn] with the latest used session.
+     * If there is no session, the state is [LoggedInState.NotLoggedIn].
+     */
     fun loggedInStateFlow(): Flow<LoggedInState>
+
+    /**
+     * Return a flow of all sessions ordered by last usage descending.
+     */
     fun sessionsFlow(): Flow<List<SessionData>>
+
+    /**
+     * Add a new session. If other sessions exist, the new one will be set as the latest used one, and
+     * the added session position will be set to a value higher than the other session positions.
+     */
     suspend fun addSession(sessionData: SessionData)
 
     /**
@@ -20,9 +34,35 @@ interface SessionStore {
      * No op if userId is not found in DB.
      */
     suspend fun updateData(sessionData: SessionData)
+
+    /**
+     * Update the user profile info of the session matching the userId.
+     */
+    suspend fun updateUserProfile(sessionId: String, displayName: String?, avatarUrl: String?)
+
+    /**
+     * Get the session data matching the userId, or null if not found.
+     */
     suspend fun getSession(sessionId: String): SessionData?
+
+    /**
+     * Get all sessions ordered by last usage descending.
+     */
     suspend fun getAllSessions(): List<SessionData>
+
+    /**
+     * Get the latest session, or null if no session exists.
+     */
     suspend fun getLatestSession(): SessionData?
+
+    /**
+     * Set the session with [sessionId] as the latest used one.
+     */
+    suspend fun setLatestSession(sessionId: String)
+
+    /**
+     * Remove the session matching the sessionId.
+     */
     suspend fun removeSession(sessionId: String)
 }
 

libraries/session-storage/impl/build.gradle.kts

@@ -36,7 +36,7 @@ dependencies {
 sqldelight {
     databases {
         create("SessionDatabase") {
-            // https://cashapp.github.io/sqldelight/2.0.0/android_sqlite/migrations/
+            // https://sqldelight.github.io/sqldelight/2.1.0/android_sqlite/migrations/
             // To generate a .db file from your latest schema, run this task
             // ./gradlew generateDebugSessionDatabaseSchema
             // Test migration by running

libraries/session-storage/impl/src/main/kotlin/io/element/android/libraries/sessionstorage/impl/DatabaseSessionStore.kt

@@ -34,7 +34,7 @@ class DatabaseSessionStore(
     private val sessionDataMutex = Mutex()
 
     override fun loggedInStateFlow(): Flow<LoggedInState> {
-        return database.sessionDataQueries.selectFirst()
+        return database.sessionDataQueries.selectLatest()
             .asFlow()
             .mapToOneOrNull(dispatchers.io)
             .map {
@@ -51,7 +51,17 @@ class DatabaseSessionStore(
 
     override suspend fun addSession(sessionData: SessionData) {
         sessionDataMutex.withLock {
-            database.sessionDataQueries.insertSessionData(sessionData.toDbModel())
+            val lastUsageIndex = getLastUsageIndex()
+            database.sessionDataQueries.insertSessionData(
+                sessionData
+                    .copy(
+                        // position value does not really matter, so just use lastUsageIndex + 1 to ensure that
+                        // the value is always greater than value of any existing account
+                        position = lastUsageIndex + 1,
+                        lastUsageIndex = lastUsageIndex + 1,
+                    )
+                    .toDbModel()
+            )
         }
     }
 
@@ -65,18 +75,71 @@ class DatabaseSessionStore(
                 Timber.e("User ${sessionData.userId} not found in session database")
                 return
             }
-            // Copy new data from SDK, but keep login timestamp
+            // Copy new data from SDK, but keep application data
             database.sessionDataQueries.updateSession(
                 sessionData.copy(
                     loginTimestamp = result.loginTimestamp,
+                    position = result.position,
+                    lastUsageIndex = result.lastUsageIndex,
+                    userDisplayName = result.userDisplayName,
+                    userAvatarUrl = result.userAvatarUrl,
                 ).toDbModel()
             )
         }
     }
 
+    override suspend fun updateUserProfile(sessionId: String, displayName: String?, avatarUrl: String?) {
+        sessionDataMutex.withLock {
+            val result = database.sessionDataQueries.selectByUserId(sessionId)
+                .executeAsOneOrNull()
+                ?.toApiModel()
+            if (result == null) {
+                Timber.e("User $sessionId not found in session database")
+                return
+            }
+            database.sessionDataQueries.updateSession(
+                result.copy(
+                    userDisplayName = displayName,
+                    userAvatarUrl = avatarUrl,
+                ).toDbModel()
+            )
+        }
+    }
+
+    override suspend fun setLatestSession(sessionId: String) {
+        val latestSession = getLatestSession()
+        if (latestSession?.userId == sessionId) {
+            // Already the latest session
+            return
+        }
+        val lastUsageIndex = latestSession?.lastUsageIndex ?: 0
+        val result = database.sessionDataQueries.selectByUserId(sessionId)
+            .executeAsOneOrNull()
+            ?.toApiModel()
+        if (result == null) {
+            Timber.e("User $sessionId not found in session database")
+            return
+        }
+        sessionDataMutex.withLock {
+            // Update lastUsageIndex of the session
+            database.sessionDataQueries.updateSession(
+                result.copy(
+                    lastUsageIndex = lastUsageIndex + 1,
+                ).toDbModel()
+            )
+        }
+    }
+
+    private fun getLastUsageIndex(): Long {
+        return database.sessionDataQueries.selectLatest()
+            .executeAsOneOrNull()
+            ?.lastUsageIndex
+            ?: -1L
+    }
+
     override suspend fun getLatestSession(): SessionData? {
         return sessionDataMutex.withLock {
-            database.sessionDataQueries.selectFirst()
+            database.sessionDataQueries.selectLatest()
                 .executeAsOneOrNull()
                 ?.toApiModel()
         }

libraries/session-storage/impl/src/main/kotlin/io/element/android/libraries/sessionstorage/impl/SessionDataMapper.kt

@@ -27,6 +27,10 @@ internal fun SessionData.toDbModel(): DbSessionData {
         passphrase = passphrase,
         sessionPath = sessionPath,
         cachePath = cachePath,
+        position = position,
+        lastUsageIndex = lastUsageIndex,
+        userDisplayName = userDisplayName,
+        userAvatarUrl = userAvatarUrl,
     )
 }
 
@@ -45,5 +49,9 @@ internal fun DbSessionData.toApiModel(): SessionData {
         passphrase = passphrase,
         sessionPath = sessionPath,
         cachePath = cachePath,
+        position = position,
+        lastUsageIndex = lastUsageIndex,
+        userDisplayName = userDisplayName,
+        userAvatarUrl = userAvatarUrl,
     )
 }

libraries/session-storage/impl/src/main/sqldelight/io/element/android/libraries/matrix/session/SessionData.sq

@@ -27,15 +27,25 @@ CREATE TABLE SessionData (
     -- added in version 6
     sessionPath TEXT NOT NULL DEFAULT "",
     -- added in version 9
-    cachePath TEXT NOT NULL DEFAULT ""
+    cachePath TEXT NOT NULL DEFAULT "",
+    -- added in version 10
+    -- position, to be able to sort account by session creation date
+    position INTEGER NOT NULL DEFAULT 0,
+    -- index of the last usage session. Each time the current session change, the index of the current
+    -- session is incremented to the max value + 1 so it becomes the current session
+    lastUsageIndex INTEGER NOT NULL DEFAULT 0,
+    -- user display name
+    userDisplayName TEXT,
+    -- user avatar url
+    userAvatarUrl TEXT
 );
 
 
-selectFirst:
+selectLatest:
-SELECT * FROM SessionData LIMIT 1;
+SELECT * FROM SessionData ORDER BY lastUsageIndex DESC LIMIT 1;
 
 selectAll:
-SELECT * FROM SessionData;
+SELECT * FROM SessionData ORDER BY lastUsageIndex DESC;
 
 selectByUserId:
 SELECT * FROM SessionData WHERE userId = ?;

libraries/session-storage/impl/src/main/sqldelight/migrations/9.sqm

@@ -0,0 +1,9 @@
+-- Migrate DB from version 9
+-- Add position to be able to sort account by session creation date
+-- Add lastUsageIndex so we can restore the last session and switch to another one
+-- Add display name and avatar url of the user so that we can display a list of accounts.
+
+ALTER TABLE SessionData ADD COLUMN position INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE SessionData ADD COLUMN lastUsageIndex INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE SessionData ADD COLUMN userDisplayName TEXT;
+ALTER TABLE SessionData ADD COLUMN userAvatarUrl TEXT;

libraries/session-storage/impl/src/test/kotlin/io/element/android/libraries/sessionstorage/impl/DatabaseSessionStoreTest.kt

@@ -13,6 +13,7 @@ import com.google.common.truth.Truth.assertThat
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.matrix.session.SessionData
 import io.element.android.libraries.sessionstorage.api.LoggedInState
+import io.element.android.libraries.sessionstorage.api.LoginType
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.runTest
@@ -45,11 +46,11 @@ class DatabaseSessionStoreTest {
 
     @Test
     fun `addSession persists the SessionData into the DB`() = runTest {
-        assertThat(database.sessionDataQueries.selectFirst().executeAsOneOrNull()).isNull()
+        assertThat(database.sessionDataQueries.selectLatest().executeAsOneOrNull()).isNull()
 
         databaseSessionStore.addSession(aSessionData.toApiModel())
 
-        assertThat(database.sessionDataQueries.selectFirst().executeAsOneOrNull()).isEqualTo(aSessionData)
+        assertThat(database.sessionDataQueries.selectLatest().executeAsOneOrNull()).isEqualTo(aSessionData)
         assertThat(database.sessionDataQueries.selectAll().executeAsList().size).isEqualTo(1)
     }
 
@@ -59,7 +60,12 @@ class DatabaseSessionStoreTest {
             assertThat(awaitItem()).isEqualTo(LoggedInState.NotLoggedIn)
             databaseSessionStore.addSession(aSessionData.toApiModel())
             assertThat(awaitItem()).isEqualTo(LoggedInState.LoggedIn(sessionId = aSessionData.userId, isTokenValid = true))
-            // TODO add more sessions in multi-account PR.
+            // Add a second session
+            databaseSessionStore.addSession(aSessionData.copy(userId = "otherUserId").toApiModel())
+            assertThat(awaitItem()).isEqualTo(LoggedInState.LoggedIn(sessionId = "otherUserId", isTokenValid = true))
+            // Remove the second session
+            databaseSessionStore.removeSession("otherUserId")
+            assertThat(awaitItem()).isEqualTo(LoggedInState.LoggedIn(sessionId = aSessionData.userId, isTokenValid = true))
             // Remove the first session
             databaseSessionStore.removeSession(aSessionData.userId)
             assertThat(awaitItem()).isEqualTo(LoggedInState.NotLoggedIn)
@@ -124,7 +130,83 @@ class DatabaseSessionStoreTest {
     }
 
     @Test
-    fun `update session update all fields except loginTimestamp`() = runTest {
+    fun `updateUserProfile does nothing if the session is not found`() = runTest {
+        databaseSessionStore.updateUserProfile(aSessionData.userId, "userDisplayName", "userAvatarUrl")
+        assertThat(database.sessionDataQueries.selectByUserId(aSessionData.userId).executeAsOneOrNull()).isNull()
+    }
+
+    @Test
+    fun `updateUserProfile update the data`() = runTest {
+        database.sessionDataQueries.insertSessionData(aSessionData)
+        databaseSessionStore.updateUserProfile(aSessionData.userId, "userDisplayName", "userAvatarUrl")
+        val updatedSession = database.sessionDataQueries.selectByUserId(aSessionData.userId).executeAsOne()
+        assertThat(updatedSession.userDisplayName).isEqualTo("userDisplayName")
+        assertThat(updatedSession.userAvatarUrl).isEqualTo("userAvatarUrl")
+    }
+
+    @Test
+    fun `setLatestSession is no op when the session is already the latest session`() = runTest {
+        database.sessionDataQueries.insertSessionData(aSessionData)
+        val session = database.sessionDataQueries.selectByUserId(aSessionData.userId).executeAsOne()
+        assertThat(session.lastUsageIndex).isEqualTo(0)
+        assertThat(session.position).isEqualTo(0)
+        databaseSessionStore.setLatestSession(aSessionData.userId)
+        assertThat(database.sessionDataQueries.selectByUserId(aSessionData.userId).executeAsOne().lastUsageIndex).isEqualTo(0)
+    }
+
+    @Test
+    fun `setLatestSession is no op when the session is not found`() = runTest {
+        databaseSessionStore.setLatestSession(aSessionData.userId)
+    }
+
+    @Test
+    fun `multi session test`() = runTest {
+        databaseSessionStore.addSession(aSessionData.toApiModel())
+        val session = databaseSessionStore.getSession(aSessionData.userId)!!
+        assertThat(session.lastUsageIndex).isEqualTo(0)
+        assertThat(session.position).isEqualTo(0)
+        val secondSessionData = aSessionData.copy(
+            userId = "otherUserId",
+            position = 1,
+            lastUsageIndex = 1,
+        )
+        databaseSessionStore.addSession(secondSessionData.toApiModel())
+        val secondSession = database.sessionDataQueries.selectByUserId(secondSessionData.userId).executeAsOne()
+        assertThat(secondSession.lastUsageIndex).isEqualTo(1)
+        assertThat(secondSession.position).isEqualTo(1)
+        // Set the first session as the latest
+        databaseSessionStore.setLatestSession(aSessionData.userId)
+        val firstSession = database.sessionDataQueries.selectByUserId(aSessionData.userId).executeAsOne()
+        assertThat(firstSession.lastUsageIndex).isEqualTo(2)
+        assertThat(firstSession.position).isEqualTo(0)
+        // Check that the second session has not been altered
+        val secondSession2 = database.sessionDataQueries.selectByUserId(secondSessionData.userId).executeAsOne()
+        assertThat(secondSession2.lastUsageIndex).isEqualTo(1)
+        assertThat(secondSession2.position).isEqualTo(1)
+    }
+
+    @Test
+    fun `test sessionsFlow()`() = runTest {
+        databaseSessionStore.sessionsFlow().test {
+            assertThat(awaitItem()).isEmpty()
+            databaseSessionStore.addSession(aSessionData.toApiModel())
+            assertThat(awaitItem().size).isEqualTo(1)
+            val secondSessionData = aSessionData.copy(
+                userId = "otherUserId",
+                position = 1,
+                lastUsageIndex = 1,
+            )
+            databaseSessionStore.addSession(secondSessionData.toApiModel())
+            assertThat(awaitItem().size).isEqualTo(2)
+            databaseSessionStore.removeSession(aSessionData.userId)
+            assertThat(awaitItem().size).isEqualTo(1)
+            databaseSessionStore.removeSession(secondSessionData.userId)
+            assertThat(awaitItem()).isEmpty()
+        }
+    }
+
+    @Test
+    fun `update session update all fields except info used by the application`() = runTest {
         val firstSessionData = SessionData(
             userId = "userId",
             deviceId = "deviceId",
@@ -139,6 +221,10 @@ class DatabaseSessionStoreTest {
             passphrase = "aPassphrase",
             sessionPath = "sessionPath",
             cachePath = "cachePath",
+            position = 0,
+            lastUsageIndex = 0,
+            userDisplayName = "userDisplayName",
+            userAvatarUrl = "userAvatarUrl",
         )
         val secondSessionData = SessionData(
             userId = "userId",
@@ -152,8 +238,12 @@ class DatabaseSessionStoreTest {
             isTokenValid = 1,
             loginType = null,
             passphrase = "aPassphraseAltered",
-            sessionPath = "sessionPath",
+            sessionPath = "sessionPathAltered",
-            cachePath = "cachePath",
+            cachePath = "cachePathAltered",
+            position = 1,
+            lastUsageIndex = 1,
+            userDisplayName = "userDisplayNameAltered",
+            userAvatarUrl = "userAvatarUrlAltered",
         )
         assertThat(firstSessionData.userId).isEqualTo(secondSessionData.userId)
         assertThat(firstSessionData.loginTimestamp).isNotEqualTo(secondSessionData.loginTimestamp)
@@ -174,6 +264,11 @@ class DatabaseSessionStoreTest {
         assertThat(alteredSession.loginTimestamp).isEqualTo(firstSessionData.loginTimestamp)
         assertThat(alteredSession.oidcData).isEqualTo(secondSessionData.oidcData)
         assertThat(alteredSession.passphrase).isEqualTo(secondSessionData.passphrase)
+        // Check that application data have not been altered
+        assertThat(alteredSession.position).isEqualTo(firstSessionData.position)
+        assertThat(alteredSession.lastUsageIndex).isEqualTo(firstSessionData.lastUsageIndex)
+        assertThat(alteredSession.userDisplayName).isEqualTo(firstSessionData.userDisplayName)
+        assertThat(alteredSession.userAvatarUrl).isEqualTo(firstSessionData.userAvatarUrl)
     }
 
     @Test
@@ -188,10 +283,14 @@ class DatabaseSessionStoreTest {
             loginTimestamp = 1,
             oidcData = "aOidcData",
             isTokenValid = 1,
-            loginType = null,
+            loginType = LoginType.PASSWORD.name,
             passphrase = "aPassphrase",
             sessionPath = "sessionPath",
             cachePath = "cachePath",
+            position = 0,
+            lastUsageIndex = 0,
+            userDisplayName = "userDisplayName",
+            userAvatarUrl = "userAvatarUrl",
         )
         val secondSessionData = SessionData(
             userId = "userIdUnknown",
@@ -203,10 +302,14 @@ class DatabaseSessionStoreTest {
             loginTimestamp = 2,
             oidcData = "aOidcDataAltered",
             isTokenValid = 1,
-            loginType = null,
+            loginType = LoginType.PASSWORD.name,
             passphrase = "aPassphraseAltered",
-            sessionPath = "sessionPath",
+            sessionPath = "sessionPathAltered",
-            cachePath = "cachePath",
+            cachePath = "cachePathAltered",
+            position = 1,
+            lastUsageIndex = 1,
+            userDisplayName = "userDisplayNameAltered",
+            userAvatarUrl = "userAvatarUrlAltered",
         )
         assertThat(firstSessionData.userId).isNotEqualTo(secondSessionData.userId)
 
@@ -216,14 +319,6 @@ class DatabaseSessionStoreTest {
         // Get the session and check that it has not been altered
         val notAlteredSession = databaseSessionStore.getSession(firstSessionData.userId)!!.toDbModel()
 
-        assertThat(notAlteredSession.userId).isEqualTo(firstSessionData.userId)
+        assertThat(notAlteredSession).isEqualTo(firstSessionData)
-        assertThat(notAlteredSession.deviceId).isEqualTo(firstSessionData.deviceId)
-        assertThat(notAlteredSession.accessToken).isEqualTo(firstSessionData.accessToken)
-        assertThat(notAlteredSession.refreshToken).isEqualTo(firstSessionData.refreshToken)
-        assertThat(notAlteredSession.homeserverUrl).isEqualTo(firstSessionData.homeserverUrl)
-        assertThat(notAlteredSession.slidingSyncProxy).isEqualTo(firstSessionData.slidingSyncProxy)
-        assertThat(notAlteredSession.loginTimestamp).isEqualTo(firstSessionData.loginTimestamp)
-        assertThat(notAlteredSession.oidcData).isEqualTo(firstSessionData.oidcData)
-        assertThat(notAlteredSession.passphrase).isEqualTo(firstSessionData.passphrase)
     }
 }

libraries/session-storage/impl/src/test/kotlin/io/element/android/libraries/sessionstorage/impl/Fixtures.kt

@@ -24,4 +24,8 @@ internal fun aSessionData() = SessionData(
     passphrase = null,
     sessionPath = "sessionPath",
     cachePath = "cachePath",
+    position = 0,
+    lastUsageIndex = 0,
+    userDisplayName = null,
+    userAvatarUrl = null,
 )

libraries/session-storage/test/src/main/kotlin/io/element/android/libraries/sessionstorage/test/InMemorySessionStore.kt

@@ -17,6 +17,8 @@ import kotlinx.coroutines.flow.map
 
 class InMemorySessionStore(
     initialList: List<SessionData> = emptyList(),
+    private val updateUserProfileResult: (String, String?, String?) -> Unit = { _, _, _ -> error("Not implemented") },
+    private val setLatestSessionResult: (String) -> Unit = { error("Not implemented") },
 ) : SessionStore {
     private val sessionDataListFlow = MutableStateFlow(initialList)
 
@@ -53,6 +55,10 @@ class InMemorySessionStore(
         }
     }
 
+    override suspend fun updateUserProfile(sessionId: String, displayName: String?, avatarUrl: String?) {
+        updateUserProfileResult(sessionId, displayName, avatarUrl)
+    }
+
     override suspend fun getSession(sessionId: String): SessionData? {
         return sessionDataListFlow.value.firstOrNull { it.userId == sessionId }
     }
@@ -65,6 +71,10 @@ class InMemorySessionStore(
         return sessionDataListFlow.value.firstOrNull()
     }
 
+    override suspend fun setLatestSession(sessionId: String) {
+        setLatestSessionResult(sessionId)
+    }
+
     override suspend fun removeSession(sessionId: String) {
         val currentList = sessionDataListFlow.value.toMutableList()
         currentList.removeAll { it.userId == sessionId }

libraries/session-storage/test/src/main/kotlin/io/element/android/libraries/sessionstorage/test/SessionData.kt

@@ -18,7 +18,11 @@ fun aSessionData(
     cachePath: String = "/a/path/to/a/cache",
     accessToken: String = "anAccessToken",
     refreshToken: String? = "aRefreshToken",
-    ): SessionData {
+    position: Long = 0,
+    lastUsageIndex: Long = 0,
+    userDisplayName: String? = null,
+    userAvatarUrl: String? = null,
+): SessionData {
     return SessionData(
         userId = sessionId,
         deviceId = deviceId,
@@ -33,5 +37,9 @@ fun aSessionData(
         passphrase = null,
         sessionPath = sessionPath,
         cachePath = cachePath,
+        position = position,
+        lastUsageIndex = lastUsageIndex,
+        userDisplayName = userDisplayName,
+        userAvatarUrl = userAvatarUrl,
     )
 }

libraries/troubleshoot/api/src/main/kotlin/io/element/android/libraries/troubleshoot/api/PushHistoryEntryPoint.kt

@@ -13,7 +13,6 @@ import com.bumble.appyx.core.plugin.Plugin
 import io.element.android.libraries.architecture.FeatureEntryPoint
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.core.SessionId
 
 interface PushHistoryEntryPoint : FeatureEntryPoint {
     fun nodeBuilder(parentNode: Node, buildContext: BuildContext): NodeBuilder
@@ -25,6 +24,6 @@ interface PushHistoryEntryPoint : FeatureEntryPoint {
 
     interface Callback : Plugin {
         fun onDone()
-        fun onItemClick(sessionId: SessionId, roomId: RoomId, eventId: EventId)
+        fun navigateTo(roomId: RoomId, eventId: EventId)
     }
 }

libraries/troubleshoot/impl/src/main/kotlin/io/element/android/libraries/troubleshoot/impl/history/PushHistoryEvents.kt

@@ -7,8 +7,13 @@
 
 package io.element.android.libraries.troubleshoot.impl.history
 
+import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.SessionId
+
 sealed interface PushHistoryEvents {
     data class SetShowOnlyErrors(val showOnlyErrors: Boolean) : PushHistoryEvents
     data class Reset(val requiresConfirmation: Boolean) : PushHistoryEvents
+    data class NavigateTo(val sessionId: SessionId, val roomId: RoomId, val eventId: EventId) : PushHistoryEvents
     data object ClearDialog : PushHistoryEvents
 }

libraries/troubleshoot/impl/src/main/kotlin/io/element/android/libraries/troubleshoot/impl/history/PushHistoryNode.kt

@@ -20,7 +20,6 @@ import io.element.android.annotations.ContributesNode
 import io.element.android.libraries.di.SessionScope
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.troubleshoot.api.PushHistoryEntryPoint
 import io.element.android.services.analytics.api.ScreenTracker
 
@@ -29,21 +28,23 @@ import io.element.android.services.analytics.api.ScreenTracker
 class PushHistoryNode(
     @Assisted buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
-    private val presenter: PushHistoryPresenter,
+    presenterFactory: PushHistoryPresenter.Factory,
     private val screenTracker: ScreenTracker,
-) : Node(buildContext, plugins = plugins) {
+) : Node(buildContext, plugins = plugins), PushHistoryNavigator {
     private fun onDone() {
         plugins<PushHistoryEntryPoint.Callback>().forEach {
             it.onDone()
         }
     }
 
-    private fun onItemClick(sessionId: SessionId, roomId: RoomId, eventId: EventId) {
+    override fun navigateTo(roomId: RoomId, eventId: EventId) {
         plugins<PushHistoryEntryPoint.Callback>().forEach {
-            it.onItemClick(sessionId, roomId, eventId)
+            it.navigateTo(roomId, eventId)
         }
     }
 
+    private val presenter = presenterFactory.create(this)
+
     @Composable
     override fun View(modifier: Modifier) {
         screenTracker.TrackScreen(MobileScreen.ScreenName.NotificationTroubleshoot)
@@ -51,7 +52,6 @@ class PushHistoryNode(
         PushHistoryView(
             state = state,
             onBackClick = ::onDone,
-            onItemClick = ::onItemClick,
             modifier = modifier,
         )
     }

libraries/troubleshoot/impl/src/main/kotlin/io/element/android/libraries/troubleshoot/impl/history/PushHistoryPresenter.kt

@@ -14,18 +14,36 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
-import dev.zacsweers.metro.Inject
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.AssistedFactory
+import dev.zacsweers.metro.AssistedInject
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.push.api.PushService
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 
-@Inject
+fun interface PushHistoryNavigator {
+    fun navigateTo(roomId: RoomId, eventId: EventId)
+}
+
+@AssistedInject
 class PushHistoryPresenter(
+    @Assisted private val pushHistoryNavigator: PushHistoryNavigator,
     private val pushService: PushService,
+    matrixClient: MatrixClient,
 ) : Presenter<PushHistoryState> {
+    @AssistedFactory
+    fun interface Factory {
+        fun create(pushHistoryNavigator: PushHistoryNavigator): PushHistoryPresenter
+    }
+
+    private val sessionId = matrixClient.sessionId
+
     @Composable
     override fun present(): PushHistoryState {
         val coroutineScope = rememberCoroutineScope()
@@ -41,6 +59,7 @@ class PushHistoryPresenter(
             }
         }.collectAsState(emptyList())
         var resetAction: AsyncAction<Unit> by remember { mutableStateOf(AsyncAction.Uninitialized) }
+        var showNotSameAccountError by remember { mutableStateOf(false) }
 
         fun handleEvents(event: PushHistoryEvents) {
             when (event) {
@@ -60,6 +79,14 @@ class PushHistoryPresenter(
                 }
                 PushHistoryEvents.ClearDialog -> {
                     resetAction = AsyncAction.Uninitialized
+                    showNotSameAccountError = false
+                }
+                is PushHistoryEvents.NavigateTo -> {
+                    if (event.sessionId != sessionId) {
+                        showNotSameAccountError = true
+                    } else {
+                        pushHistoryNavigator.navigateTo(event.roomId, event.eventId)
+                    }
                 }
             }
         }
@@ -69,6 +96,7 @@ class PushHistoryPresenter(
             pushHistoryItems = pushHistory.toImmutableList(),
             showOnlyErrors = showOnlyErrors,
             resetAction = resetAction,
+            showNotSameAccountError = showNotSameAccountError,
             eventSink = ::handleEvents
         )
     }

libraries/troubleshoot/impl/src/main/kotlin/io/element/android/libraries/troubleshoot/impl/history/PushHistoryState.kt

@@ -16,5 +16,6 @@ data class PushHistoryState(
     val pushHistoryItems: ImmutableList<PushHistoryItem>,
     val showOnlyErrors: Boolean,
     val resetAction: AsyncAction<Unit>,
+    val showNotSameAccountError: Boolean,
     val eventSink: (PushHistoryEvents) -> Unit,
 )

libraries/troubleshoot/impl/src/main/kotlin/io/element/android/libraries/troubleshoot/impl/history/PushHistoryStateProvider.kt

@@ -40,6 +40,9 @@ open class PushHistoryStateProvider : PreviewParameterProvider<PushHistoryState>
             aPushHistoryState(
                 resetAction = AsyncAction.ConfirmingNoParams,
             ),
+            aPushHistoryState(
+                showNotSameAccountError = true,
+            ),
         )
 }
 
@@ -48,12 +51,14 @@ fun aPushHistoryState(
     pushHistoryItems: List<PushHistoryItem> = emptyList(),
     showOnlyErrors: Boolean = false,
     resetAction: AsyncAction<Unit> = AsyncAction.Uninitialized,
+    showNotSameAccountError: Boolean = false,
     eventSink: (PushHistoryEvents) -> Unit = {},
 ) = PushHistoryState(
     pushCounter = pushCounter,
     pushHistoryItems = pushHistoryItems.toImmutableList(),
     showOnlyErrors = showOnlyErrors,
     resetAction = resetAction,
+    showNotSameAccountError = showNotSameAccountError,
     eventSink = eventSink,
 )
 

libraries/troubleshoot/impl/src/main/kotlin/io/element/android/libraries/troubleshoot/impl/history/PushHistoryView.kt

@@ -37,6 +37,7 @@ import io.element.android.compound.tokens.generated.CompoundIcons
 import io.element.android.libraries.designsystem.components.async.AsyncActionView
 import io.element.android.libraries.designsystem.components.button.BackButton
 import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
+import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
 import io.element.android.libraries.designsystem.components.list.ListItemContent
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
@@ -48,9 +49,6 @@ import io.element.android.libraries.designsystem.theme.components.ListItem
 import io.element.android.libraries.designsystem.theme.components.Scaffold
 import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.theme.components.TopAppBar
-import io.element.android.libraries.matrix.api.core.EventId
-import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.push.api.history.PushHistoryItem
 import io.element.android.libraries.troubleshoot.impl.R
 import io.element.android.libraries.ui.strings.CommonStrings
@@ -60,7 +58,6 @@ import io.element.android.libraries.ui.strings.CommonStrings
 fun PushHistoryView(
     state: PushHistoryState,
     onBackClick: () -> Unit,
-    onItemClick: (SessionId, RoomId, EventId) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     var showMenu by remember { mutableStateOf(false) }
@@ -123,7 +120,6 @@ fun PushHistoryView(
                 .padding(padding)
                 .consumeWindowInsets(padding),
             state = state,
-            onItemClick = onItemClick,
         )
     }
 
@@ -142,12 +138,18 @@ fun PushHistoryView(
         },
         onErrorDismiss = {},
     )
+
+    if (state.showNotSameAccountError) {
+        ErrorDialog(
+            content = "Please switch account first to navigate to the event.",
+            onSubmit = { state.eventSink(PushHistoryEvents.ClearDialog) }
+        )
+    }
 }
 
 @Composable
 private fun PushHistoryContent(
     state: PushHistoryState,
-    onItemClick: (SessionId, RoomId, EventId) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     Column(
@@ -173,7 +175,7 @@ private fun PushHistoryContent(
                         val roomId = pushHistory.roomId
                         val eventId = pushHistory.eventId
                         if (sessionId != null && roomId != null && eventId != null) {
-                            onItemClick(sessionId, roomId, eventId)
+                            state.eventSink(PushHistoryEvents.NavigateTo(sessionId, roomId, eventId))
                         }
                     }
                 )
@@ -271,6 +273,5 @@ internal fun PushHistoryViewPreview(
     PushHistoryView(
         state = state,
         onBackClick = {},
-        onItemClick = { _, _, _ -> },
     )
 }

libraries/troubleshoot/impl/src/test/kotlin/io/element/android/libraries/troubleshoot/impl/history/DefaultPushHistoryEntryPointTest.kt

@@ -12,7 +12,7 @@ import com.bumble.appyx.core.modality.BuildContext
 import com.google.common.truth.Truth.assertThat
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.push.test.FakePushService
 import io.element.android.libraries.troubleshoot.api.PushHistoryEntryPoint
 import io.element.android.services.analytics.test.FakeScreenTracker
@@ -32,15 +32,21 @@ class DefaultPushHistoryEntryPointTest {
             PushHistoryNode(
                 buildContext = buildContext,
                 plugins = plugins,
-                presenter = PushHistoryPresenter(
+                presenterFactory = {
-                    pushService = FakePushService(),
+                    PushHistoryPresenter(
-                ),
+                        pushHistoryNavigator = object : PushHistoryNavigator {
+                            override fun navigateTo(roomId: RoomId, eventId: EventId) = lambdaError()
+                        },
+                        pushService = FakePushService(),
+                        matrixClient = FakeMatrixClient(),
+                    )
+                },
                 screenTracker = FakeScreenTracker(),
             )
         }
         val callback = object : PushHistoryEntryPoint.Callback {
             override fun onDone() = lambdaError()
-            override fun onItemClick(sessionId: SessionId, roomId: RoomId, eventId: EventId) = lambdaError()
+            override fun navigateTo(roomId: RoomId, eventId: EventId) = lambdaError()
         }
         val result = entryPoint.nodeBuilder(parentNode, BuildContext.root(null))
             .callback(callback)

libraries/troubleshoot/impl/src/test/kotlin/io/element/android/libraries/troubleshoot/impl/history/PushHistoryPresenterTest.kt

@@ -11,9 +11,19 @@ package io.element.android.libraries.troubleshoot.impl.history
 
 import com.google.common.truth.Truth.assertThat
 import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.test.AN_EVENT_ID
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.A_SESSION_ID
+import io.element.android.libraries.matrix.test.A_SESSION_ID_2
+import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.push.api.PushService
 import io.element.android.libraries.push.test.FakePushService
+import io.element.android.tests.testutils.lambda.lambdaError
 import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.lambda.value
 import io.element.android.tests.testutils.test
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
@@ -29,6 +39,7 @@ class PushHistoryPresenterTest {
             assertThat(initialState.pushHistoryItems).isEmpty()
             assertThat(initialState.showOnlyErrors).isFalse()
             assertThat(initialState.resetAction).isEqualTo(AsyncAction.Uninitialized)
+            assertThat(initialState.showNotSameAccountError).isFalse()
         }
     }
 
@@ -119,11 +130,57 @@ class PushHistoryPresenterTest {
         }
     }
 
+    @Test
+    fun `present - item click current account`() = runTest {
+        val pushHistoryNavigatorResult = lambdaRecorder<RoomId, EventId, Unit> { _, _ -> }
+        val presenter = createPushHistoryPresenter(
+            pushHistoryNavigator = { roomId, eventId ->
+                pushHistoryNavigatorResult(roomId, eventId)
+            }
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            initialState.eventSink(
+                PushHistoryEvents.NavigateTo(
+                    sessionId = A_SESSION_ID,
+                    roomId = A_ROOM_ID,
+                    eventId = AN_EVENT_ID,
+                )
+            )
+            pushHistoryNavigatorResult.assertions()
+                .isCalledOnce()
+                .with(value(A_ROOM_ID), value(AN_EVENT_ID))
+        }
+    }
+
+    @Test
+    fun `present - item click not current account`() = runTest {
+        val presenter = createPushHistoryPresenter()
+        presenter.test {
+            val initialState = awaitItem()
+            initialState.eventSink(
+                PushHistoryEvents.NavigateTo(
+                    sessionId = A_SESSION_ID_2,
+                    roomId = A_ROOM_ID,
+                    eventId = AN_EVENT_ID,
+                )
+            )
+            assertThat(awaitItem().showNotSameAccountError).isTrue()
+            // Reset error
+            initialState.eventSink(PushHistoryEvents.ClearDialog)
+            assertThat(awaitItem().showNotSameAccountError).isFalse()
+        }
+    }
+
     private fun createPushHistoryPresenter(
+        pushHistoryNavigator: PushHistoryNavigator = PushHistoryNavigator { _, _ -> lambdaError() },
         pushService: PushService = FakePushService(),
+        matrixClient: MatrixClient = FakeMatrixClient(),
     ): PushHistoryPresenter {
         return PushHistoryPresenter(
+            pushHistoryNavigator = pushHistoryNavigator,
             pushService = pushService,
+            matrixClient = matrixClient,
         )
     }
 }

libraries/troubleshoot/impl/src/test/kotlin/io/element/android/libraries/troubleshoot/impl/history/PushHistoryViewTest.kt

@@ -14,20 +14,14 @@ import androidx.compose.ui.test.onNodeWithContentDescription
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import io.element.android.libraries.matrix.api.core.EventId
-import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.test.AN_EVENT_ID
 import io.element.android.libraries.matrix.test.A_FORMATTED_DATE
 import io.element.android.libraries.matrix.test.A_ROOM_ID
 import io.element.android.libraries.matrix.test.A_SESSION_ID
 import io.element.android.libraries.ui.strings.CommonStrings
 import io.element.android.tests.testutils.EnsureNeverCalled
-import io.element.android.tests.testutils.EnsureNeverCalledWithThreeParams
 import io.element.android.tests.testutils.EventsRecorder
 import io.element.android.tests.testutils.clickOn
-import io.element.android.tests.testutils.lambda.lambdaRecorder
-import io.element.android.tests.testutils.lambda.value
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TestRule
@@ -103,9 +97,8 @@ class PushHistoryViewTest {
     }
 
     @Test
-    fun `clicking on a valid event invokes the expected callback`() {
+    fun `clicking on a valid event emits the expected Event`() {
-        val eventsRecorder = EventsRecorder<PushHistoryEvents>(expectEvents = false)
+        val eventsRecorder = EventsRecorder<PushHistoryEvents>()
-        val onItemClick = lambdaRecorder<SessionId, RoomId, EventId, Unit> { _, _, _ -> }
         rule.setPushHistoryView(
             aPushHistoryState(
                 pushHistoryItems = listOf(
@@ -118,25 +111,26 @@ class PushHistoryViewTest {
                 ),
                 eventSink = eventsRecorder,
             ),
-            onItemClick = onItemClick,
         )
         rule.onNodeWithText(A_FORMATTED_DATE).performClick()
-        onItemClick.assertions()
+        eventsRecorder.assertSingle(
-            .isCalledOnce()
+            PushHistoryEvents.NavigateTo(
-            .with(value(A_SESSION_ID), value(A_ROOM_ID), value(AN_EVENT_ID))
+                sessionId = A_SESSION_ID,
+                roomId = A_ROOM_ID,
+                eventId = AN_EVENT_ID,
+            )
+        )
     }
 }
 
 private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setPushHistoryView(
     state: PushHistoryState,
     onBackClick: () -> Unit = EnsureNeverCalled(),
-    onItemClick: (SessionId, RoomId, EventId) -> Unit = EnsureNeverCalledWithThreeParams(),
 ) {
     setContent {
         PushHistoryView(
             state = state,
             onBackClick = onBackClick,
-            onItemClick = onItemClick,
         )
     }
 }

plugins/src/main/kotlin/extension/DependencyHandleScope.kt

@@ -107,6 +107,7 @@ fun DependencyHandlerScope.allLibrariesImpl() {
     implementation(project(":libraries:mediaupload:impl"))
     implementation(project(":libraries:usersearch:impl"))
     implementation(project(":libraries:textcomposer:impl"))
+    implementation(project(":libraries:accountselect:impl"))
     implementation(project(":libraries:roomselect:impl"))
     implementation(project(":libraries:cryptography:impl"))
     implementation(project(":libraries:voiceplayer:impl"))

services/analytics/impl/src/main/kotlin/io/element/android/services/analytics/impl/DefaultAnalyticsService.kt

@@ -17,6 +17,7 @@ import im.vector.app.features.analytics.itf.VectorAnalyticsScreen
 import im.vector.app.features.analytics.plan.SuperProperties
 import im.vector.app.features.analytics.plan.UserProperties
 import io.element.android.libraries.di.annotations.AppCoroutineScope
+import io.element.android.libraries.sessionstorage.api.SessionStore
 import io.element.android.libraries.sessionstorage.api.observer.SessionListener
 import io.element.android.libraries.sessionstorage.api.observer.SessionObserver
 import io.element.android.services.analytics.api.AnalyticsService
@@ -40,6 +41,7 @@ class DefaultAnalyticsService(
     @AppCoroutineScope
     private val coroutineScope: CoroutineScope,
     private val sessionObserver: SessionObserver,
+    private val sessionStore: SessionStore,
 ) : AnalyticsService, SessionListener {
     // Cache for the store values
     private val userConsent = AtomicBoolean(false)
@@ -80,8 +82,10 @@ class DefaultAnalyticsService(
     }
 
     override suspend fun onSessionDeleted(userId: String) {
-        // Delete the store
+        // Delete the store when the last session is deleted
-        analyticsStore.reset()
+        if (sessionStore.getAllSessions().isEmpty()) {
+            analyticsStore.reset()
+        }
     }
 
     private fun observeUserConsent() {

services/analytics/impl/src/test/kotlin/io/element/android/services/analytics/impl/DefaultAnalyticsServiceTest.kt

@@ -16,7 +16,9 @@ import im.vector.app.features.analytics.plan.MobileScreen
 import im.vector.app.features.analytics.plan.PollEnd
 import im.vector.app.features.analytics.plan.SuperProperties
 import im.vector.app.features.analytics.plan.UserProperties
+import io.element.android.libraries.sessionstorage.api.SessionStore
 import io.element.android.libraries.sessionstorage.api.observer.SessionObserver
+import io.element.android.libraries.sessionstorage.test.InMemorySessionStore
 import io.element.android.libraries.sessionstorage.test.observer.NoOpSessionObserver
 import io.element.android.services.analytics.impl.store.AnalyticsStore
 import io.element.android.services.analytics.impl.store.FakeAnalyticsStore
@@ -167,7 +169,7 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `when a session is deleted, the store is reset`() = runTest {
+    fun `when the last session is deleted, the store is reset`() = runTest {
         val resetLambda = lambdaRecorder<Unit> { }
         val store = FakeAnalyticsStore(
             resetLambda = resetLambda,
@@ -258,11 +260,13 @@ class DefaultAnalyticsServiceTest {
         ),
         analyticsStore: AnalyticsStore = FakeAnalyticsStore(),
         sessionObserver: SessionObserver = NoOpSessionObserver(),
+        sessionStore: SessionStore = InMemorySessionStore(),
     ) = DefaultAnalyticsService(
         analyticsProviders = analyticsProviders,
         analyticsStore = analyticsStore,
         coroutineScope = coroutineScope,
         sessionObserver = sessionObserver,
+        sessionStore = sessionStore,
     ).also {
         // Wait for the service to be ready
         delay(1)

tests/konsist/src/test/kotlin/io/element/android/tests/konsist/KonsistClassNameTest.kt

@@ -62,6 +62,7 @@ class KonsistClassNameTest {
             .withAllParentsOf(PreviewParameterProvider::class)
             .withoutName(
                 "AspectRatioProvider",
+                "LoginModeViewErrorProvider",
                 "OverlapRatioProvider",
                 "TextFileContentProvider",
             )

tests/konsist/src/test/kotlin/io/element/android/tests/konsist/KonsistPreviewTest.kt

@@ -82,6 +82,7 @@ class KonsistPreviewTest {
         "BackgroundVerticalGradientEnterprisePreview",
         "BackgroundVerticalGradientPreview",
         "ColorAliasesPreview",
+        "DefaultRoomListTopBarMultiAccountPreview",
         "DefaultRoomListTopBarWithIndicatorPreview",
         "FocusedEventEnterprisePreview",
         "FocusedEventPreview",

tests/uitests/src/test/snapshots/images/features.home.impl.components_DefaultRoomListTopBarMultiAccount_Day_0_en.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b289624c8461e08c945a254eb629ea536552e2652c7182be21a7bd9f183da022
+size 26185

tests/uitests/src/test/snapshots/images/features.home.impl.components_DefaultRoomListTopBarMultiAccount_Night_0_en.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b86aaf39367bd454a913c4ed6cd17bbaff52e54349e0e6d363d6f84ccdc43c5f
+size 23678

tests/uitests/src/test/snapshots/images/features.login.impl.login_LoginModeView_Day_5_en.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4eaf3d650155e9a779cf796cef116eaba0f1d6722b229332b224475393a88178
+size 16828

tests/uitests/src/test/snapshots/images/features.login.impl.login_LoginModeView_Night_5_en.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59f062f54833df71be9d7c4e785bb01013a10642e0d863bf7ef2abd8862b93c8
+size 15476