Merge pull request #7394 from element-hq/feature/account-provider-selection

Simplify choosing the account provider during sign in, with autocomplete of previously used ones

Author: bmarty

.maestro/tests/account/changeServer.yaml

@@ -3,8 +3,7 @@ appId: ${MAESTRO_APP_ID}
 - tapOn: "Sign in manually"
 - runFlow: ../assertions/assertLoginDisplayed.yaml
 - takeScreenshot: build/maestro/100-SignIn
-- runFlow: changeServer.yaml
-- runFlow: ../assertions/assertLoginDisplayed.yaml
+# The account provider field defaults to matrix.org, so continue straight to the MAS login.
 - tapOn:
     id: "login-continue"
 ## MAS page

.maestro/tests/account/login.yaml

@@ -1,5 +1,5 @@
 appId: ${MAESTRO_APP_ID}
 ---
 - extendedWaitUntil:
-    visible: "Change account provider"
+    visible: "Enter your account provider"
     timeout: 10000

.maestro/tests/assertions/assertLoginDisplayed.yaml

@@ -69,6 +69,7 @@ dependencies {
     implementation(projects.libraries.sessionStorage.api)
     implementation(projects.libraries.qrcode)
     implementation(projects.libraries.oauth.api)
+    implementation(projects.libraries.preferences.api)
     implementation(projects.libraries.uiUtils)
     implementation(projects.libraries.wellknown.api)
     implementation(libs.androidx.browser)
@@ -80,6 +81,7 @@ dependencies {
     testImplementation(projects.features.login.test)
     testImplementation(projects.features.enterprise.test)
     testImplementation(projects.features.preferences.test)
+    testImplementation(projects.libraries.preferences.test)
     testImplementation(projects.libraries.matrix.test)
     testImplementation(projects.libraries.oauth.test)
     testImplementation(projects.libraries.permissions.test)

features/login/impl/build.gradle.kts

@@ -23,7 +23,6 @@ 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.operation.replace
-import com.bumble.appyx.navmodel.backstack.operation.singleTop
 import dev.zacsweers.metro.AppScope
 import dev.zacsweers.metro.Assisted
 import dev.zacsweers.metro.AssistedInject
@@ -33,13 +32,11 @@ import io.element.android.features.login.api.LoginEntryPoint
 import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
 import io.element.android.features.login.impl.classic.ElementClassicConnection
 import io.element.android.features.login.impl.qrcode.QrCodeLoginFlowNode
-import io.element.android.features.login.impl.screens.changeaccountprovider.ChangeAccountProviderNode
 import io.element.android.features.login.impl.screens.chooseaccountprovider.ChooseAccountProviderNode
 import io.element.android.features.login.impl.screens.classic.ClassicFlowNode
 import io.element.android.features.login.impl.screens.confirmaccountprovider.ConfirmAccountProviderNode
 import io.element.android.features.login.impl.screens.loginpassword.LoginPasswordNode
 import io.element.android.features.login.impl.screens.onboarding.OnBoardingNode
-import io.element.android.features.login.impl.screens.searchaccountprovider.SearchAccountProviderNode
 import io.element.android.features.preferences.api.PreferencesEntryPoint
 import io.element.android.libraries.androidutils.browser.openUrlInChromeCustomTab
 import io.element.android.libraries.architecture.BackstackView
@@ -129,12 +126,6 @@ class LoginFlowNode(
         @Parcelize
         data object ChooseAccountProvider : NavTarget
 
-        @Parcelize
-        data object ChangeAccountProvider : NavTarget
-
-        @Parcelize
-        data object SearchAccountProvider : NavTarget
-
         @Parcelize
         data class LoginPassword(
             val initialLogin: String = "",
@@ -261,43 +252,9 @@ class LoginFlowNode(
                     override fun navigateToLoginPassword() {
                         backstack.push(NavTarget.LoginPassword())
                     }
-
-                    override fun navigateToChangeAccountProvider() {
-                        backstack.push(NavTarget.ChangeAccountProvider)
-                    }
                 }
                 createNode<ConfirmAccountProviderNode>(buildContext, plugins = listOf(inputs, callback))
             }
-            NavTarget.ChangeAccountProvider -> {
-                val callback = object : ChangeAccountProviderNode.Callback {
-                    override fun onDone() {
-                        // Go back to the Account Provider screen
-                        val confirmAccountProvider = backstack.elements.value.firstOrNull {
-                            it.key.navTarget is NavTarget.ConfirmAccountProvider
-                        }?.key?.navTarget ?: NavTarget.ConfirmAccountProvider(isAccountCreation = false)
-                        backstack.singleTop(confirmAccountProvider)
-                    }
-
-                    override fun navigateToSearchAccountProvider() {
-                        backstack.push(NavTarget.SearchAccountProvider)
-                    }
-                }
-
-                createNode<ChangeAccountProviderNode>(buildContext, plugins = listOf(callback))
-            }
-            NavTarget.SearchAccountProvider -> {
-                val callback = object : SearchAccountProviderNode.Callback {
-                    override fun onDone() {
-                        // Go back to the Account Provider screen
-                        val confirmAccountProvider = backstack.elements.value.firstOrNull {
-                            it.key.navTarget is NavTarget.ConfirmAccountProvider
-                        }?.key?.navTarget ?: NavTarget.ConfirmAccountProvider(isAccountCreation = false)
-                        backstack.singleTop(confirmAccountProvider)
-                    }
-                }
-
-                createNode<SearchAccountProviderNode>(buildContext, plugins = listOf(callback))
-            }
             is NavTarget.LoginPassword -> {
                 val inputs = LoginPasswordNode.Inputs(
                     initialLogin = navTarget.initialLogin,

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

@@ -13,34 +13,72 @@ import dev.zacsweers.metro.Inject
 import dev.zacsweers.metro.SingleIn
 import io.element.android.appconfig.AuthenticationConfig
 import io.element.android.features.enterprise.api.EnterpriseService
+import io.element.android.features.enterprise.api.canConnectToAnyHomeserver
+import io.element.android.libraries.di.annotations.AppCoroutineScope
+import io.element.android.libraries.preferences.api.store.AppPreferencesStore
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
 
 @SingleIn(AppScope::class)
 @Inject
 class AccountProviderDataSource(
-    enterpriseService: EnterpriseService,
+    private val enterpriseService: EnterpriseService,
+    private val appPreferencesStore: AppPreferencesStore,
+    @AppCoroutineScope private val coroutineScope: CoroutineScope,
 ) {
-    private val defaultAccountProvider = createAccountProvider(
+    // The provider used when the user has not selected one: an enterprise/MDM-configured provider,
+    // else matrix.org. The most recently used provider (from history) can override it, see init.
+    private val configuredAccountProvider = createAccountProvider(
         url = enterpriseService.homeserverAllowList()
             .firstOrNull { it != EnterpriseService.ANY_ACCOUNT_PROVIDER }
             ?: AuthenticationConfig.MATRIX_ORG_URL
     )
 
-    private val accountProvider: MutableStateFlow<AccountProvider> = MutableStateFlow(defaultAccountProvider)
+    private val accountProvider: MutableStateFlow<AccountProvider> = MutableStateFlow(configuredAccountProvider)
 
     val flow: StateFlow<AccountProvider> = accountProvider.asStateFlow()
 
+    // The account provider the user last explicitly selected (via [setAccountProvider] / [setUrl]).
+    // Unlike [flow], this is not recomputed by [reset], so it survives to be persisted to history on a
+    // successful sign-in even when the login flow is torn down in between (e.g. across an OAuth round-trip).
+    var lastSelectedAccountProviderUrl: String? = null
+        private set
+
+    init {
+        // Seed the default from the last used provider, unless the user has already selected one.
+        coroutineScope.launch {
+            val default = defaultAccountProvider()
+            accountProvider.update { current -> if (current == configuredAccountProvider) default else current }
+        }
+    }
+
     suspend fun reset() {
-        accountProvider.emit(defaultAccountProvider)
+        accountProvider.emit(defaultAccountProvider())
+    }
+
+    /**
+     * The provider to default to: the most recently used one from history when the user is free to
+     * connect to any provider, otherwise the enterprise/MDM-configured provider.
+     */
+    private suspend fun defaultAccountProvider(): AccountProvider {
+        if (!enterpriseService.canConnectToAnyHomeserver()) {
+            return configuredAccountProvider
+        }
+        val lastUsedProvider = appPreferencesStore.getHomeserverHistoryFlow().first().firstOrNull()
+        return lastUsedProvider?.let { createAccountProvider(it) } ?: configuredAccountProvider
     }
 
     suspend fun setUrl(url: String) {
         setAccountProvider(createAccountProvider(url))
     }
 
     suspend fun setAccountProvider(data: AccountProvider) {
+        lastSelectedAccountProviderUrl = data.url
         accountProvider.emit(data)
     }
 

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.login.impl.accountprovider
+
+import dev.zacsweers.metro.Inject
+import io.element.android.libraries.preferences.api.store.AppPreferencesStore
+
+/**
+ * Persist the account provider the user just authenticated against, so that it can be offered as
+ * the default (see [AccountProviderDataSource]) and as an autocomplete suggestion on the next
+ * sign-in. To be called from the manual sign-in / account creation flows only, on success.
+ *
+ * See [AppPreferencesStore.addHomeserverToHistory].
+ */
+@Inject
+class SaveAccountProviderToHistory(
+    private val accountProviderDataSource: AccountProviderDataSource,
+    private val appPreferencesStore: AppPreferencesStore,
+) {
+    suspend operator fun invoke() {
+        // Persist the provider the user actually selected, not the currently-exposed default: the latter can be
+        // reset back to the history default while the login flow is torn down across an OAuth round-trip.
+        val url = accountProviderDataSource.lastSelectedAccountProviderUrl
+            ?: accountProviderDataSource.flow.value.url
+        appPreferencesStore.addHomeserverToHistory(url)
+    }
+}

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

@@ -22,6 +22,7 @@ import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.architecture.runCatchingUpdatingState
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
+import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
 
 @Inject
 class ChangeServerPresenter(
@@ -32,7 +33,7 @@ class ChangeServerPresenter(
 ) : Presenter<ChangeServerState> {
     @Composable
     override fun present(): ChangeServerState {
-        val changeServerAction: MutableState<AsyncData<Unit>> = remember {
+        val changeServerAction: MutableState<AsyncData<MatrixHomeServerDetails>> = remember {
             mutableStateOf(AsyncData.Uninitialized)
         }
 
@@ -59,7 +60,7 @@ class ChangeServerPresenter(
 
     private suspend fun changeServer(
         data: AccountProvider,
-        changeServerAction: MutableState<AsyncData<Unit>>,
+        changeServerAction: MutableState<AsyncData<MatrixHomeServerDetails>>,
     ) {
         suspend {
             defaultAccountProviderAccessControl.assertIsAllowedToConnectToAccountProvider(
@@ -72,6 +73,8 @@ class ChangeServerPresenter(
             }
             // Homeserver is valid, remember user choice
             accountProviderDataSource.setAccountProvider(data)
+            // Return the resolved details so the caller can sign in without configuring the homeserver again.
+            details
         }.runCatchingUpdatingState(changeServerAction, errorTransform = ChangeServerError::from)
     }
 }

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

@@ -9,10 +9,13 @@
 package io.element.android.features.login.impl.changeserver
 
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
 import io.element.android.libraries.permissions.api.localnetwork.LocalNetworkPermissionDialog
 
 data class ChangeServerState(
-    val changeServerAction: AsyncData<Unit>,
+    // On success, carries the resolved homeserver details so the caller can proceed with login without
+    // configuring (and re-networking) the homeserver a second time.
+    val changeServerAction: AsyncData<MatrixHomeServerDetails>,
     val localNetworkPermissionDialog: LocalNetworkPermissionDialog,
     val eventSink: (ChangeServerEvents) -> Unit
 )