Multi accounts - experimental first implementation

appnav/build.gradle.kts

@@ -25,9 +25,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

@@ -75,7 +75,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(
@@ -395,6 +395,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() }
                     }
@@ -407,11 +411,7 @@ class LoggedInFlowNode(
                         backstack.push(NavTarget.Room(roomId.toRoomIdOrAlias(), initialElement = RoomNavigationTarget.NotificationSettings))
                     }
 
-                    override fun navigateTo(sessionId: SessionId, 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")
-                        }
+                    override fun navigateTo(roomId: RoomId, eventId: EventId) {
                         backstack.push(NavTarget.Room(roomId.toRoomIdOrAlias(), initialElement = RoomNavigationTarget.Messages(eventId)))
                     }
                 }

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

@@ -40,23 +40,28 @@ 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.features.viewfolder.api.ViewFolderEntryPoint
+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.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.auth.MatrixAuthenticationService
 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
 import io.element.android.libraries.oidc.api.OidcAction
 import io.element.android.libraries.oidc.api.OidcActionFlow
 import io.element.android.libraries.sessionstorage.api.LoggedInState
+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
 
@@ -73,9 +78,12 @@ class RootFlowNode(
     private val bugReportEntryPoint: BugReportEntryPoint,
     private val viewFolderEntryPoint: ViewFolderEntryPoint,
     private val signedOutEntryPoint: SignedOutEntryPoint,
+    private val accountSelectEntryPoint: AccountSelectEntryPoint,
     private val intentResolver: IntentResolver,
     private val oidcActionFlow: OidcActionFlow,
     private val bugReporter: BugReporter,
+    private val sessionStore: SessionStore,
+    private val featureFlagService: FeatureFlagService,
 ) : BaseFlowNode<RootFlowNode.NavTarget>(
     backstack = BackStack(
         initialElement = NavTarget.SplashScreen,
@@ -182,6 +190,13 @@ class RootFlowNode(
         @Parcelize
         data object SplashScreen : NavTarget
 
+        @Parcelize
+        data class AccountSelect(
+            val currentSessionId: SessionId,
+            val intent: Intent?,
+            val permalinkData: PermalinkData?,
+        ) : NavTarget
+
         @Parcelize
         data class NotLoggedInFlow(
             val params: LoginParams?
@@ -218,6 +233,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))
             }
@@ -272,6 +291,34 @@ class RootFlowNode(
                     .callback(callback)
                     .build()
             }
+            is NavTarget.AccountSelect -> {
+                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()
+            }
         }
     }
 
@@ -293,19 +340,29 @@ class RootFlowNode(
     }
 
     private suspend fun onLoginLink(params: LoginParams) {
-        // Is there a session already?
-        val latestSessionId = authenticationService.getLatestSessionId()
-        if (latestSessionId == null) {
-            // No session, open login
-            if (accountProviderAccessControl.isAllowedToConnectToAccountProvider(params.accountProvider.ensureProtocol())) {
-                switchToNotLoggedInFlow(params)
+        if (accountProviderAccessControl.isAllowedToConnectToAccountProvider(params.accountProvider.ensureProtocol())) {
+            // Is there a session already?
+            val sessions = sessionStore.getAllSessions()
+            if (sessions.isNotEmpty()) {
+                if (featureFlagService.isFeatureEnabled(FeatureFlags.MultiAccount)) {
+                    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(null)
+                switchToNotLoggedInFlow(params)
             }
         } else {
-            // Just ignore the login link if we already have a session
-            Timber.w("Login link ignored, we already have a session")
+            Timber.w("Login link ignored, we are not allowed to connect to the homeserver")
         }
     }
 
@@ -316,32 +373,73 @@ class RootFlowNode(
             // No session, open login
             switchToNotLoggedInFlow(null)
         } else {
-            attachSession(latestSessionId)
-                .attachIncomingShare(intent)
+            // wait for the current session to be restored
+            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)
-            .apply {
-                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 there a session already?
+        val latestSessionId = authenticationService.getLatestSessionId()
+        if (latestSessionId == null) {
+            // No session, open login
+            switchToNotLoggedInFlow(null)
+        } else {
+            // wait for the current session to be restored
+            val loggedInFlowNode = attachSession(latestSessionId)
+            when (permalinkData) {
+                is PermalinkData.FallbackLink -> Unit
+                is PermalinkData.RoomEmailInviteLink -> Unit
+                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,
+                            )
                         )
-                    }
-                    is PermalinkData.UserLink -> {
-                        attachUser(permalinkData.userId)
+                    } else {
+                        // Only one account, directly attach the room or the user node.
+                        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) {
@@ -359,11 +457,11 @@ class RootFlowNode(
         oidcActionFlow.post(oidcAction)
     }
 
-    // [sessionId] will be null for permalink.
-    private suspend fun attachSession(sessionId: SessionId?): LoggedInFlowNode {
-        // TODO handle multi-session
+    private suspend fun attachSession(sessionId: SessionId): LoggedInFlowNode {
+        // Ensure that the session is the latest one
+        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()
     }

appnav/src/main/kotlin/io/element/android/appnav/root/RootNavStateFlowFactory.kt

@@ -12,9 +12,9 @@ import com.bumble.appyx.core.state.SavedStateMap
 import dev.zacsweers.metro.Inject
 import io.element.android.appnav.di.MatrixSessionCache
 import io.element.android.features.preferences.api.CacheService
-import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.ui.media.ImageLoaderHolder
 import io.element.android.libraries.preferences.api.store.SessionPreferencesStoreFactory
+import io.element.android.libraries.sessionstorage.api.SessionStore
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flow
@@ -28,7 +28,7 @@ private const val SAVE_INSTANCE_KEY = "io.element.android.x.RootNavStateFlowFact
  */
 @Inject
 class RootNavStateFlowFactory(
-    private val authenticationService: MatrixAuthenticationService,
+    private val sessionStore: SessionStore,
     private val cacheService: CacheService,
     private val matrixSessionCache: MatrixSessionCache,
     private val imageLoaderHolder: ImageLoaderHolder,
@@ -39,7 +39,7 @@ class RootNavStateFlowFactory(
     fun create(savedStateMap: SavedStateMap?): Flow<RootNavState> {
         return combine(
             cacheIndexFlow(savedStateMap),
-            authenticationService.loggedInStateFlow(),
+            sessionStore.loggedInStateFlow(),
         ) { cacheIndex, loggedInState ->
             RootNavState(
                 cacheIndex = cacheIndex,

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

@@ -76,6 +76,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/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
 }