Replace String by AccountProvider to be able to get baseUrl and serverName.

appconfig/src/main/kotlin/io/element/android/appconfig/AuthenticationConfig.kt

@@ -9,15 +9,8 @@
 package io.element.android.appconfig
 
 object AuthenticationConfig {
-    const val MATRIX_ORG_URL = "https://matrix.org"
-
     /**
      * URL with some docs that explain what's sliding sync and how to add it to your home server.
      */
     const val SLIDING_SYNC_READ_MORE_URL = "https://github.com/matrix-org/sliding-sync/blob/main/docs/Landing.md"
-
-    /**
-     * Force a sliding sync proxy url, if not null, the proxy url in the .well-known file will be ignored.
-     */
-    val SLIDING_SYNC_PROXY_URL: String? = null
 }

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

@@ -52,11 +52,11 @@ 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.di.annotations.AppCoroutineScope
 import io.element.android.libraries.featureflag.api.FeatureFlagService
 import io.element.android.libraries.featureflag.api.FeatureFlags
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.ThreadId
@@ -410,7 +410,8 @@ class RootFlowNode(
     }
 
     private suspend fun onLoginLink(params: LoginParams) {
-        if (accountProviderAccessControl.isAllowedToConnectToAccountProvider(params.accountProvider.ensureProtocol())) {
+        val accountProvider = AccountProvider.Generic(params.accountProvider)
+        if (accountProviderAccessControl.isAllowedToConnectToAccountProvider(accountProvider)) {
             // Is there a session already?
             val sessions = sessionStore.getAllSessions()
             if (sessions.isNotEmpty()) {

features/enterprise/api/src/main/kotlin/io/element/android/features/enterprise/api/EnterpriseService.kt

@@ -11,6 +11,7 @@ package io.element.android.features.enterprise.api
 import androidx.compose.ui.graphics.Color
 import io.element.android.compound.colors.SemanticColorsLightDark
 import io.element.android.libraries.matrix.api.ClientUrlContentFetcher
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.api.core.SessionId
 import kotlinx.coroutines.flow.Flow
 
@@ -36,18 +37,21 @@ interface EnterpriseService {
     suspend fun tweakMasUrl(url: String, urlContentFetcher: ClientUrlContentFetcher): String
 
     /**
-     * Returns the list of homeservers the user is allowed to sign in to.
+     * Returns the list of account provider the user is allowed to sign in to.
-     *
-     * If the list is empty or contains the special value [ANY_ACCOUNT_PROVIDER], the user is allowed to sign in to any homeserver.
      */
-    fun homeserverAllowList(): List<String>
+    fun accountProviderAllowList(): List<AccountProvider>
 
     /**
-     * Whether the user is allowed to sign in to a given homeserver, according to [homeserverAllowList].
+     * Whether the user is allowed to sign in to any account provider.
-     *
-     * @param homeserverUrl the server the user is trying to use.
      */
-    suspend fun isAllowedToConnectToHomeserver(homeserverUrl: String): Boolean
+    fun canConnectToAnyAccountProvider(): Boolean
+
+    /**
+     * Whether the user is allowed to sign in to a given homeserver, according to [accountProviderAllowList].
+     *
+     * @param accountProvider the account provider the user is trying to use.
+     */
+    suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider): Boolean
 
     /**
      * Whether the given homeserver enforces the use of Element Pro or a derived app.
@@ -97,14 +101,4 @@ interface EnterpriseService {
      * @param sessionId the session whose channel is requested.
      */
     fun getNoisyNotificationChannelId(sessionId: SessionId): String?
-
-    companion object {
-        const val ANY_ACCOUNT_PROVIDER = "*"
-    }
-}
-
-fun EnterpriseService.canConnectToAnyHomeserver(): Boolean {
-    return homeserverAllowList().let {
-        it.isEmpty() || it.contains(EnterpriseService.ANY_ACCOUNT_PROVIDER)
-    }
 }

features/enterprise/impl-foss/src/main/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseService.kt

@@ -19,6 +19,7 @@ import io.element.android.libraries.core.extensions.mapCatchingExceptions
 import io.element.android.libraries.core.uri.ensureProtocol
 import io.element.android.libraries.matrix.api.ClientUrlContentFetcher
 import io.element.android.libraries.matrix.api.TemporaryMatrixClientFactory
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.api.core.SessionId
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flowOf
@@ -33,8 +34,9 @@ class DefaultEnterpriseService(
 ) : EnterpriseService {
     override suspend fun isEnterpriseUser(sessionId: SessionId) = false
     override suspend fun tweakMasUrl(url: String, urlContentFetcher: ClientUrlContentFetcher) = url
-    override fun homeserverAllowList(): List<String> = emptyList()
+    override fun accountProviderAllowList(): List<AccountProvider> = emptyList()
-    override suspend fun isAllowedToConnectToHomeserver(homeserverUrl: String) = true
+    override fun canConnectToAnyAccountProvider(): Boolean = true
+    override suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider) = true
     override suspend fun isElementProEnforced(serverName: String): Boolean {
         val temporaryMatrixClient = temporaryMatrixClientFactory.create(serverName).getOrElse { return false }
         return temporaryMatrixClient.use { client ->

features/enterprise/impl-foss/src/test/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseServiceTest.kt

@@ -18,6 +18,7 @@ import io.element.android.libraries.matrix.test.A_HOMESERVER_URL
 import io.element.android.libraries.matrix.test.A_SESSION_ID
 import io.element.android.libraries.matrix.test.FakeTemporaryMatrixClient
 import io.element.android.libraries.matrix.test.FakeTemporaryMatrixClientFactory
+import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderGeneric
 import io.element.android.tests.testutils.lambda.lambdaRecorder
 import io.element.android.tests.testutils.lambda.value
 import kotlinx.coroutines.test.runTest
@@ -26,15 +27,21 @@ import org.junit.Test
 
 class DefaultEnterpriseServiceTest {
     @Test
-    fun homeserverWhitelist() {
+    fun accountProviderAllowList() {
         val defaultEnterpriseService = createDefaultEnterpriseService()
-        assertThat(defaultEnterpriseService.homeserverAllowList()).isEmpty()
+        assertThat(defaultEnterpriseService.accountProviderAllowList()).isEmpty()
     }
 
     @Test
-    fun `isAllowedToConnectToHomeserver is true for all homeserver urls`() = runTest {
+    fun `canConnectToAnyAccountProvider is always true`() {
         val defaultEnterpriseService = createDefaultEnterpriseService()
-        assertThat(defaultEnterpriseService.isAllowedToConnectToHomeserver(A_HOMESERVER_URL)).isTrue()
+        assertThat(defaultEnterpriseService.canConnectToAnyAccountProvider()).isTrue()
+    }
+
+    @Test
+    fun `isAllowedToConnectToAccountProvider is true for all account providers`() = runTest {
+        val defaultEnterpriseService = createDefaultEnterpriseService()
+        assertThat(defaultEnterpriseService.isAllowedToConnectToAccountProvider(anAccountProviderGeneric())).isTrue()
     }
 
     @Test

features/enterprise/test/src/main/kotlin/io/element/android/features/enterprise/test/FakeEnterpriseService.kt

@@ -13,6 +13,7 @@ import io.element.android.compound.colors.SemanticColorsLightDark
 import io.element.android.features.enterprise.api.BugReportUrl
 import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.libraries.matrix.api.ClientUrlContentFetcher
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.tests.testutils.lambda.lambdaError
 import io.element.android.tests.testutils.simulateLongTask
@@ -22,8 +23,9 @@ import kotlinx.coroutines.flow.asStateFlow
 
 class FakeEnterpriseService(
     private val isEnterpriseUserResult: (SessionId) -> Boolean = { lambdaError() },
-    private val defaultHomeserverListResult: () -> List<String> = { emptyList() },
+    private val accountProviderAllowListResult: () -> List<AccountProvider> = { emptyList() },
-    private val isAllowedToConnectToHomeserverResult: (String) -> Boolean = { lambdaError() },
+    private val canConnectToAnyAccountProviderResult: () -> Boolean = { true },
+    private val isAllowedToConnectToAccountProviderResult: (AccountProvider) -> Boolean = { lambdaError() },
     initialSemanticColors: SemanticColorsLightDark = SemanticColorsLightDark.default,
     initialBrandColor: Color? = null,
     private val overrideBrandColorResult: (SessionId?, String?) -> Unit = { _, _ -> lambdaError() },
@@ -44,12 +46,16 @@ class FakeEnterpriseService(
         tweakMasUrlResult(url, urlContentFetcher)
     }
 
-    override fun homeserverAllowList(): List<String> {
+    override fun accountProviderAllowList(): List<AccountProvider> {
-        return defaultHomeserverListResult()
+        return accountProviderAllowListResult()
     }
 
-    override suspend fun isAllowedToConnectToHomeserver(homeserverUrl: String): Boolean = simulateLongTask {
+    override fun canConnectToAnyAccountProvider(): Boolean {
-        isAllowedToConnectToHomeserverResult(homeserverUrl)
+        return canConnectToAnyAccountProviderResult()
+    }
+
+    override suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider): Boolean = simulateLongTask {
+        isAllowedToConnectToAccountProviderResult(accountProvider)
     }
 
     override suspend fun isElementProEnforced(serverName: String): Boolean = simulateLongTask {

features/login/api/build.gradle.kts

@@ -16,4 +16,5 @@ android {
 
 dependencies {
     implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
 }

features/login/api/src/main/kotlin/io/element/android/features/login/api/accesscontrol/AccountProviderAccessControl.kt

@@ -8,6 +8,8 @@
 
 package io.element.android.features.login.api.accesscontrol
 
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
+
 /**
  * Enforces the restriction an enterprise deployment can put on which account providers the user may sign in to.
  */
@@ -15,7 +17,7 @@ interface AccountProviderAccessControl {
     /**
      * Whether sign-in to this provider is permitted; `true` on a build with no such restriction.
      *
-     * @param accountProviderUrl the server the user is trying to use.
+     * @param accountProvider the account provider the user is trying to use.
      */
-    suspend fun isAllowedToConnectToAccountProvider(accountProviderUrl: String): Boolean
+    suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider): Boolean
 }

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

@@ -14,16 +14,16 @@ import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.features.enterprise.api.IsEnterpriseBuild
 import io.element.android.features.login.api.accesscontrol.AccountProviderAccessControl
 import io.element.android.features.login.impl.changeserver.AccountProviderAccessException
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 
 @ContributesBinding(AppScope::class)
 class DefaultAccountProviderAccessControl(
     private val isEnterpriseBuild: IsEnterpriseBuild,
     private val enterpriseService: EnterpriseService,
 ) : AccountProviderAccessControl {
-    override suspend fun isAllowedToConnectToAccountProvider(accountProviderUrl: String) = try {
+    override suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider) = try {
         assertIsAllowedToConnectToAccountProvider(
-            title = accountProviderUrl,
+            accountProvider = accountProvider,
-            accountProviderUrl = accountProviderUrl,
         )
         true
     } catch (_: AccountProviderAccessException) {
@@ -32,22 +32,22 @@ class DefaultAccountProviderAccessControl(
 
     @Throws(AccountProviderAccessException::class)
     suspend fun assertIsAllowedToConnectToAccountProvider(
-        title: String,
+        accountProvider: AccountProvider,
-        accountProviderUrl: String,
     ) {
         if (isEnterpriseBuild().not()) {
             // Ensure that Element Pro is not required for this account provider
-            if (enterpriseService.isElementProEnforced(accountProviderUrl)) {
+            if (enterpriseService.isElementProEnforced(accountProvider.serverNameOrBaseUrl())) {
                 throw AccountProviderAccessException.NeedElementProException(
-                    unauthorisedAccountProviderTitle = title,
+                    unauthorisedAccountProviderTitle = accountProvider.friendlyServerName(),
                     applicationId = ELEMENT_PRO_APPLICATION_ID,
                 )
             }
         }
-        if (enterpriseService.isAllowedToConnectToHomeserver(accountProviderUrl).not()) {
+        if (enterpriseService.isAllowedToConnectToAccountProvider(accountProvider).not()) {
             throw AccountProviderAccessException.UnauthorizedAccountProviderException(
-                unauthorisedAccountProviderTitle = title,
+                unauthorisedAccountProviderTitle = accountProvider.friendlyServerName(),
-                authorisedAccountProviderTitles = enterpriseService.homeserverAllowList(),
+                authorisedAccountProviderTitles = enterpriseService.accountProviderAllowList()
+                    .map { it.friendlyServerName() },
             )
         }
     }

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

@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2025 Element Creations Ltd.
- * Copyright 2023-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.accountprovider
-
-data class AccountProvider(
-    val url: String,
-    val title: String = url.removePrefix("https://").removePrefix("http://"),
-    val subtitle: String? = null,
-    val isPublic: Boolean = false,
-    val isMatrixOrg: Boolean = false,
-)

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

@@ -11,10 +11,10 @@ package io.element.android.features.login.impl.accountprovider
 import dev.zacsweers.metro.AppScope
 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.matrix.api.accountprovider.AccountProvider
+import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider
 import io.element.android.libraries.preferences.api.store.AppPreferencesStore
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -33,11 +33,9 @@ class AccountProviderDataSource(
 ) {
     // 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(
+    private val configuredAccountProvider = enterpriseService.accountProviderAllowList()
-        url = enterpriseService.homeserverAllowList()
+        .firstOrNull()
-            .firstOrNull { it != EnterpriseService.ANY_ACCOUNT_PROVIDER }
+        ?: matrixOrgAccountProvider
-            ?: AuthenticationConfig.MATRIX_ORG_URL
-    )
 
     private val accountProvider: MutableStateFlow<AccountProvider> = MutableStateFlow(configuredAccountProvider)
 
@@ -46,7 +44,7 @@ class AccountProviderDataSource(
     // 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
+    var lastSelectedAccountProvider: AccountProvider? = null
         private set
 
     init {
@@ -66,28 +64,19 @@ class AccountProviderDataSource(
      * connect to any provider, otherwise the enterprise/MDM-configured provider.
      */
     private suspend fun defaultAccountProvider(): AccountProvider {
-        if (!enterpriseService.canConnectToAnyHomeserver()) {
+        if (!enterpriseService.canConnectToAnyAccountProvider()) {
             return configuredAccountProvider
         }
         val lastUsedProvider = appPreferencesStore.getHomeserverHistoryFlow().first().firstOrNull()
-        return lastUsedProvider?.let { createAccountProvider(it) } ?: configuredAccountProvider
+        return lastUsedProvider?.let { AccountProvider.Generic(it) } ?: configuredAccountProvider
     }
 
     suspend fun setUrl(url: String) {
-        setAccountProvider(createAccountProvider(url))
+        setAccountProvider(AccountProvider.Generic(url))
     }
 
     suspend fun setAccountProvider(data: AccountProvider) {
-        lastSelectedAccountProviderUrl = data.url
+        lastSelectedAccountProvider = data
         accountProvider.emit(data)
     }
-
-    private fun createAccountProvider(url: String): AccountProvider {
-        return AccountProvider(
-            url = url,
-            subtitle = null,
-            isPublic = url == AuthenticationConfig.MATRIX_ORG_URL,
-            isMatrixOrg = url == AuthenticationConfig.MATRIX_ORG_URL,
-        )
-    }
 }

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

@@ -9,27 +9,27 @@
 package io.element.android.features.login.impl.accountprovider
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.appconfig.AuthenticationConfig
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 
 open class AccountProviderPreviewParam : PreviewParameterProvider<AccountProvider> {
     override val values: Sequence<AccountProvider>
         get() = sequenceOf(
-            anAccountProvider(),
+            anAccountProviderManaged(),
-            anAccountProvider().copy(subtitle = null),
-            anAccountProvider().copy(subtitle = null, title = "invalid"),
-            anAccountProvider().copy(subtitle = null, title = "Other", isPublic = false, isMatrixOrg = false),
-            // Add other state here
         )
 }
 
-fun anAccountProvider(
+fun anAccountProviderManaged(
-    url: String = AuthenticationConfig.MATRIX_ORG_URL,
+    serverName: String = "matrix.org",
-    subtitle: String? = "Matrix.org is an open network for secure, decentralized communication.",
+    baseUrl: String = "https://matrix-client.matrix.org",
-    isPublic: Boolean = true,
+    canUseServerName: Boolean = true,
-    isMatrixOrg: Boolean = true,
+) = AccountProvider.Managed(
-) = AccountProvider(
+    serverName = serverName,
-    url = url,
+    baseUrl = baseUrl,
-    subtitle = subtitle,
+    canUseServerName = canUseServerName,
-    isPublic = isPublic,
+)
-    isMatrixOrg = isMatrixOrg,
+
+fun anAccountProviderGeneric(
+    serverName: String = "matrix.org",
+) = AccountProvider.Generic(
+    serverName = serverName,
 )

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

@@ -14,17 +14,14 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
 import io.element.android.compound.theme.ElementTheme
 import io.element.android.compound.tokens.generated.CompoundIcons
-import io.element.android.features.login.impl.R
 import io.element.android.libraries.designsystem.atomic.atoms.RoundedIconAtom
 import io.element.android.libraries.designsystem.atomic.atoms.RoundedIconAtomSize
 import io.element.android.libraries.designsystem.preview.ElementPreview
@@ -32,6 +29,7 @@ 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.Icon
 import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 
 /**
  * https://www.figma.com/file/o9p34zmiuEpZRyvZXJZAYL/FTUE?type=design&node-id=604-60817
@@ -60,37 +58,19 @@ fun AccountProviderView(
                     .heightIn(min = 44.dp),
                 verticalAlignment = Alignment.CenterVertically
             ) {
-                if (item.isMatrixOrg) {
+                RoundedIconAtom(
-                    RoundedIconAtom(
+                    size = RoundedIconAtomSize.Medium,
-                        size = RoundedIconAtomSize.Medium,
+                    imageVector = CompoundIcons.Host(),
-                        resourceId = R.drawable.ic_matrix,
+                    tint = ElementTheme.colors.iconPrimary,
-                        tint = Color.Unspecified,
+                )
-                    )
-                } else {
-                    RoundedIconAtom(
-                        size = RoundedIconAtomSize.Medium,
-                        imageVector = CompoundIcons.Host(),
-                        tint = ElementTheme.colors.iconPrimary,
-                    )
-                }
                 Text(
                     modifier = Modifier
                         .padding(start = 16.dp)
                         .weight(1f),
-                    text = item.title,
+                    text = item.friendlyServerName(),
                     style = ElementTheme.typography.fontBodyLgMedium,
                     color = ElementTheme.colors.textPrimary,
                 )
-                if (item.isPublic) {
-                    Icon(
-                        modifier = Modifier
-                            .padding(start = 10.dp)
-                            .size(16.dp),
-                        imageVector = CompoundIcons.Public(),
-                        contentDescription = null,
-                        tint = ElementTheme.colors.iconSecondary,
-                    )
-                }
                 if (selected) {
                     Icon(
                         modifier = Modifier
@@ -101,15 +81,6 @@ fun AccountProviderView(
                     )
                 }
             }
-            if (item.subtitle != null) {
-                Text(
-                    modifier = Modifier
-                        .padding(start = 46.dp, bottom = 12.dp, end = 26.dp),
-                    text = item.subtitle,
-                    style = ElementTheme.typography.fontBodyMdRegular,
-                    color = ElementTheme.colors.textSecondary,
-                )
-            }
         }
     }
 }

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

@@ -25,8 +25,11 @@ class SaveAccountProviderToHistory(
     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
+        val accountProvider = accountProviderDataSource.lastSelectedAccountProvider
-            ?: accountProviderDataSource.flow.value.url
+            ?: accountProviderDataSource.flow.value
-        appPreferencesStore.addHomeserverToHistory(url)
+        // Persist the sanitized name the user knows the provider by rather than its base url, which can be an
+        // internal client API url (e.g. matrix.org resolves to matrix-client.matrix.org) the user would not
+        // recognise, and so that the same provider is not stored twice with and without its scheme.
+        appPreferencesStore.addHomeserverToHistory(accountProvider.serverNameOrBaseUrl())
     }
 }

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

@@ -8,7 +8,7 @@
 
 package io.element.android.features.login.impl.changeserver
 
-import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 
 sealed interface ChangeServerEvent {
     data class ChangeServer(val accountProvider: AccountProvider) : ChangeServerEvent

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

@@ -14,13 +14,13 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import dev.zacsweers.metro.Inject
 import io.element.android.features.login.impl.accesscontrol.DefaultAccountProviderAccessControl
-import io.element.android.features.login.impl.accountprovider.AccountProvider
 import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
 import io.element.android.features.login.impl.error.ChangeServerError
 import io.element.android.features.login.impl.localnetwork.LocalNetworkPermissionGate
 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.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
 
@@ -38,7 +38,7 @@ class ChangeServerPresenter(
         }
 
         val gateState = localNetworkPermissionGate.present<AccountProvider>(
-            urlOf = { provider -> provider.url },
+            urlOf = { provider -> provider.serverNameOrBaseUrl() },
             onProceed = { provider -> changeServer(provider, changeServerAction) },
         )
 
@@ -63,11 +63,8 @@ class ChangeServerPresenter(
         changeServerAction: MutableState<AsyncData<MatrixHomeServerDetails>>,
     ) {
         suspend {
-            defaultAccountProviderAccessControl.assertIsAllowedToConnectToAccountProvider(
+            defaultAccountProviderAccessControl.assertIsAllowedToConnectToAccountProvider(data)
-                title = data.title,
+            val details = authenticationService.setHomeserver(data.serverNameOrBaseUrl()).getOrThrow()
-                accountProviderUrl = data.url,
-            )
-            val details = authenticationService.setHomeserver(data.url).getOrThrow()
             if (!details.isSupported) {
                 throw ChangeServerError.UnsupportedServer
             }

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderEvent.kt

@@ -8,7 +8,7 @@
 
 package io.element.android.features.login.impl.screens.chooseaccountprovider
 
-import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 
 sealed interface ChooseAccountProviderEvent {
     data class SelectAccountProvider(val accountProvider: AccountProvider) : ChooseAccountProviderEvent

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenter.kt

@@ -14,14 +14,12 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import dev.zacsweers.metro.Inject
-import io.element.android.appconfig.AuthenticationConfig
 import io.element.android.features.enterprise.api.EnterpriseService
-import io.element.android.features.login.impl.accountprovider.AccountProvider
 import io.element.android.features.login.impl.login.LoginModeEvent
 import io.element.android.features.login.impl.login.LoginModeState
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
-import io.element.android.libraries.core.uri.ensureProtocol
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import kotlinx.collections.immutable.toImmutableList
 
 @Inject
@@ -41,7 +39,7 @@ class ChooseAccountProviderPresenter(
                         loginModeState.eventSink(
                             LoginModeEvent.Submit(
                                 isAccountCreation = false,
-                                homeserverUrl = provider.url,
+                                homeserverUrl = provider.serverNameOrBaseUrl(),
                                 resolvedHomeserverUrl = null,
                                 loginHint = null,
                             )
@@ -59,18 +57,8 @@ class ChooseAccountProviderPresenter(
         }
 
         val staticAccountProviderList = remember {
-            // The list cannot contains ANY_ACCOUNT_PROVIDER ("*") and cannot be empty at this point
+            // The list cannot be empty at this point
-            enterpriseService.homeserverAllowList()
+            enterpriseService.accountProviderAllowList().toImmutableList()
-                .map { it.ensureProtocol() }
-                .map { url ->
-                    AccountProvider(
-                        url = url,
-                        subtitle = null,
-                        isPublic = url == AuthenticationConfig.MATRIX_ORG_URL,
-                        isMatrixOrg = url == AuthenticationConfig.MATRIX_ORG_URL,
-                    )
-                }
-                .toImmutableList()
         }
 
         return ChooseAccountProviderState(

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderState.kt

@@ -8,9 +8,9 @@
 
 package io.element.android.features.login.impl.screens.chooseaccountprovider
 
-import io.element.android.features.login.impl.accountprovider.AccountProvider
 import io.element.android.features.login.impl.login.LoginModeState
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import kotlinx.collections.immutable.ImmutableList
 
 data class ChooseAccountProviderState(

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStatePreviewParam.kt

@@ -9,31 +9,22 @@
 package io.element.android.features.login.impl.screens.chooseaccountprovider
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.features.login.impl.accountprovider.anAccountProviderManaged
-import io.element.android.features.login.impl.accountprovider.anAccountProvider
 import io.element.android.features.login.impl.login.LoginModeState
 import io.element.android.features.login.impl.login.aLoginModeState
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import kotlinx.collections.immutable.toImmutableList
 
 open class ChooseAccountProviderStatePreviewParam : PreviewParameterProvider<ChooseAccountProviderState> {
-    private val server1 = anAccountProvider(
+    private val server1 = anAccountProviderManaged(
-        url = "https://server1.io",
+        baseUrl = "https://server1.io",
-        subtitle = null,
-        isPublic = false,
-        isMatrixOrg = false,
     )
-    private val server2 = anAccountProvider(
+    private val server2 = anAccountProviderManaged(
-        url = "https://server2.io",
+        baseUrl = "https://server2.io",
-        subtitle = null,
-        isPublic = false,
-        isMatrixOrg = false,
     )
-    private val server3 = anAccountProvider(
+    private val server3 = anAccountProviderManaged(
-        url = "https://server3.io",
+        baseUrl = "https://server3.io",
-        subtitle = null,
-        isPublic = false,
-        isMatrixOrg = false,
     )
     override val values: Sequence<ChooseAccountProviderState>
         get() = sequenceOf(
@@ -61,13 +52,12 @@ open class ChooseAccountProviderStatePreviewParam : PreviewParameterProvider<Cho
                 selectedAccountProvider = server2,
                 loginModeState = aLoginModeState(loginMode = AsyncData.Loading()),
             ),
-            // Add other state here
         )
 }
 
 fun aChooseAccountProviderState(
     accountProviders: List<AccountProvider> = listOf(
-        anAccountProvider()
+        anAccountProviderManaged()
     ),
     selectedAccountProvider: AccountProvider? = null,
     loginModeState: LoginModeState = aLoginModeState(),

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderView.kt

@@ -96,16 +96,8 @@ fun ChooseAccountProviderView(
                 )
 
                 state.accountProviders.forEach { item ->
-                    val alteredItem = if (item.isMatrixOrg) {
-                        // Set the subtitle from the resource
-                        item.copy(
-                            subtitle = stringResource(id = R.string.screen_change_account_provider_matrix_org_subtitle),
-                        )
-                    } else {
-                        item
-                    }
                     AccountProviderView(
-                        item = alteredItem,
+                        item = item,
                         selected = item == state.selectedAccountProvider,
                         onClick = {
                             state.eventSink(ChooseAccountProviderEvent.SelectAccountProvider(item))

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenter.kt

@@ -20,9 +20,7 @@ import androidx.compose.runtime.setValue
 import dev.zacsweers.metro.Assisted
 import dev.zacsweers.metro.AssistedFactory
 import dev.zacsweers.metro.AssistedInject
-import io.element.android.appconfig.AuthenticationConfig
 import io.element.android.features.enterprise.api.EnterpriseService
-import io.element.android.features.login.impl.accountprovider.AccountProvider
 import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
 import io.element.android.features.login.impl.changeserver.ChangeServerEvent
 import io.element.android.features.login.impl.changeserver.ChangeServerState
@@ -30,8 +28,11 @@ import io.element.android.features.login.impl.login.LoginModeEvent
 import io.element.android.features.login.impl.login.LoginModeState
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.core.uri.ensureProtocol
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
+import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider
 import io.element.android.libraries.matrix.api.core.MatrixPatterns
 import io.element.android.libraries.preferences.api.store.AppPreferencesStore
+import kotlinx.coroutines.flow.map
 
 @AssistedInject
 class ConfirmAccountProviderPresenter(
@@ -56,23 +57,25 @@ class ConfirmAccountProviderPresenter(
         val accountProvider by accountProviderDataSource.flow.collectAsState()
         val loginModeState = loginModePresenter.present()
         val changeServerState = changeServerPresenter.present()
-        val homeserverHistory by appPreferencesStore.getHomeserverHistoryFlow().collectAsState(emptyList())
+        val homeserverHistory by remember {
+            appPreferencesStore.getHomeserverHistoryFlow().map { history ->
+                history.map { AccountProvider.Generic(it) }
+            }
+        }.collectAsState(emptyList())
 
         // The account providers offered for autocomplete: previously-used ones first, then the
         // enterprise/MDM-configured allow-list, then matrix.org (always available, even before any sign-in).
-        // The "*" wildcard is a routing marker, not a real provider, so it is filtered out. Everything is
+        // Everything is rendered without the https:// scheme (added back at connection time).
-        // rendered without the https:// scheme (added back at connection time).
         val autocompleteCandidates = remember(homeserverHistory) {
-            (homeserverHistory + enterpriseService.homeserverAllowList() + AuthenticationConfig.MATRIX_ORG_URL)
+            (homeserverHistory + enterpriseService.accountProviderAllowList() + matrixOrgAccountProvider)
-                .filter { it != EnterpriseService.ANY_ACCOUNT_PROVIDER }
+                .map { it.friendlyServerName() }
-                .map { it.withoutScheme() }
                 .distinct()
         }
 
         // Editable input, seeded from the current (history-defaulted) account provider until the user edits it.
         // Displayed without the scheme, so the field shows e.g. "matrix.org" rather than "https://matrix.org".
         var userInput by rememberSaveable { mutableStateOf<String?>(null) }
-        val accountProviderInput = userInput ?: accountProvider.url.withoutScheme()
+        val accountProviderInput = userInput ?: accountProvider.friendlyServerName()
 
         // Offer the first candidate that the current input is a (case-insensitive) prefix of.
         val accountProviderSuggestion = remember(accountProviderInput, autocompleteCandidates) {
@@ -134,7 +137,7 @@ class ConfirmAccountProviderPresenter(
                     val accountProviderUrl = host.ensureProtocol()
                     submittedAccountProvider = accountProviderUrl
                     changeServerState.eventSink(
-                        ChangeServerEvent.ChangeServer(AccountProvider(url = accountProviderUrl))
+                        ChangeServerEvent.ChangeServer(AccountProvider.Generic(host))
                     )
                 }
                 ConfirmAccountProviderEvent.ClearError -> {
@@ -154,9 +157,3 @@ class ConfirmAccountProviderPresenter(
         )
     }
 }
-
-/**
- * The host part of an account provider URL, i.e. the value with any `https://` / `http://` scheme removed.
- * Returns the input unchanged when it has no scheme (e.g. `matrix.org`).
- */
-private fun String.withoutScheme(): String = substringAfter("://")

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordState.kt

@@ -9,8 +9,8 @@
 package io.element.android.features.login.impl.screens.loginpassword
 
 import android.os.Parcelable
-import io.element.android.features.login.impl.accountprovider.AccountProvider
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.api.core.SessionId
 import kotlinx.parcelize.Parcelize
 

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordStatePreviewParam.kt

@@ -9,9 +9,9 @@
 package io.element.android.features.login.impl.screens.loginpassword
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.features.login.impl.accountprovider.anAccountProviderManaged
-import io.element.android.features.login.impl.accountprovider.anAccountProvider
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.api.core.SessionId
 
 open class LoginPasswordStatePreviewParam : PreviewParameterProvider<LoginPasswordState> {
@@ -26,7 +26,7 @@ open class LoginPasswordStatePreviewParam : PreviewParameterProvider<LoginPasswo
 }
 
 fun aLoginPasswordState(
-    accountProvider: AccountProvider = anAccountProvider(),
+    accountProvider: AccountProvider = anAccountProviderManaged(),
     formState: LoginFormState = LoginFormState.Default,
     loginAction: AsyncData<SessionId> = AsyncData.Uninitialized,
     eventSink: (LoginPasswordEvent) -> Unit = {},

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordView.kt

@@ -131,7 +131,7 @@ fun LoginPasswordView(
                 iconStyle = BigIcon.Style.Default(CompoundIcons.UserProfileSolid()),
                 title = stringResource(
                     id = R.string.screen_account_provider_signin_title,
-                    state.accountProvider.title
+                    state.accountProvider.friendlyServerName()
                 ),
                 subTitle = stringResource(id = R.string.screen_login_subtitle)
             )

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

@@ -8,9 +8,11 @@
 
 package io.element.android.features.login.impl.screens.onboarding
 
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
+
 sealed interface OnBoardingEvent {
     data class OnSignIn(
-        val defaultAccountProvider: String
+        val defaultAccountProvider: AccountProvider
     ) : OnBoardingEvent
 
     data object OnVersionClick : OnBoardingEvent

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

@@ -22,7 +22,6 @@ import dev.zacsweers.metro.AssistedFactory
 import dev.zacsweers.metro.AssistedInject
 import io.element.android.appconfig.OnBoardingConfig
 import io.element.android.features.enterprise.api.EnterpriseService
-import io.element.android.features.enterprise.api.canConnectToAnyHomeserver
 import io.element.android.features.login.impl.accesscontrol.DefaultAccountProviderAccessControl
 import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
 import io.element.android.features.login.impl.login.LoginModeEvent
@@ -31,6 +30,7 @@ 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.core.meta.BuildType
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.sessionstorage.api.SessionStore
 import io.element.android.libraries.ui.utils.MultipleTapToUnlock
 import kotlinx.coroutines.launch
@@ -59,27 +59,34 @@ class OnBoardingPresenter(
     @Composable
     override fun present(): OnBoardingState {
         val localCoroutineScope = rememberCoroutineScope()
-        val forcedAccountProvider = remember {
+        val canConnectToAnyAccountProvider = remember {
-            // If homeserverAllowList() returns a singleton list, this is the default account provider.
+            enterpriseService.canConnectToAnyAccountProvider()
-            // In this case, the user can sign in using this homeserver, or use QrCode login
-            enterpriseService.homeserverAllowList().singleOrNull()
         }
-        val canConnectToAnyHomeserver = remember {
+        val forcedAccountProvider = remember {
-            enterpriseService.canConnectToAnyHomeserver()
+            // If accountProviderAllowList() returns a singleton list, and the user is not free to use another
+            // account provider, this is the default account provider.
+            // In this case, the user can sign in using this homeserver, or use QrCode login
+            if (canConnectToAnyAccountProvider) {
+                null
+            } else {
+                enterpriseService.accountProviderAllowList().singleOrNull()
+            }
         }
         val mustChooseAccountProvider = remember {
-            !canConnectToAnyHomeserver && enterpriseService.homeserverAllowList().size > 1
+            !canConnectToAnyAccountProvider && enterpriseService.accountProviderAllowList().size > 1
         }
-        val linkAccountProvider by produceState<String?>(initialValue = null) {
+        val linkAccountProvider by produceState<AccountProvider?>(initialValue = null) {
             // Account provider from the link, if allowed by the enterprise service
-            value = params.accountProvider?.takeIf {
+            value = params.accountProvider
-                try {
+                ?.let { AccountProvider.Generic(it) }
-                    defaultAccountProviderAccessControl.assertIsAllowedToConnectToAccountProvider(it, it)
+                ?.takeIf {
-                    true
+                    try {
-                } catch (_: Exception) {
+                        defaultAccountProviderAccessControl.assertIsAllowedToConnectToAccountProvider(it)
-                    false
+                        true
+                    } catch (_: Exception) {
+                        false
+                    }
                 }
-            }
         }
         val defaultAccountProvider = remember(linkAccountProvider) {
             // If there is a forced account provider, this is the default account provider
@@ -105,11 +112,11 @@ class OnBoardingPresenter(
             when (event) {
                 is OnBoardingEvent.OnSignIn -> localCoroutineScope.launch {
                     // Ensure that the current account provider is set
-                    accountProviderDataSource.setUrl(event.defaultAccountProvider)
+                    accountProviderDataSource.setAccountProvider(event.defaultAccountProvider)
                     loginModeState.eventSink(
                         LoginModeEvent.Submit(
                             isAccountCreation = false,
-                            homeserverUrl = event.defaultAccountProvider,
+                            homeserverUrl = event.defaultAccountProvider.serverNameOrBaseUrl(),
                             resolvedHomeserverUrl = null,
                             loginHint = params.loginHint?.takeIf { forcedAccountProvider == null },
                         )
@@ -134,7 +141,7 @@ class OnBoardingPresenter(
             defaultAccountProvider = defaultAccountProvider,
             mustChooseAccountProvider = mustChooseAccountProvider,
             canLoginWithQrCode = canLoginWithQrCode,
-            canCreateAccount = defaultAccountProvider == null && canConnectToAnyHomeserver && OnBoardingConfig.CAN_CREATE_ACCOUNT,
+            canCreateAccount = defaultAccountProvider == null && canConnectToAnyAccountProvider && OnBoardingConfig.CAN_CREATE_ACCOUNT,
             canReportBug = canReportBug && showReportBug,
             loginModeState = loginModeState,
             version = buildMeta.versionName,

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

@@ -11,13 +11,14 @@ package io.element.android.features.login.impl.screens.onboarding
 import androidx.annotation.DrawableRes
 import io.element.android.features.login.impl.login.LoginModeState
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 
 data class OnBoardingState(
     val isAddingAccount: Boolean,
     val showBackButton: Boolean,
     val showDeveloperSettings: Boolean,
     val productionApplicationName: String,
-    val defaultAccountProvider: String?,
+    val defaultAccountProvider: AccountProvider?,
     val mustChooseAccountProvider: Boolean,
     val canLoginWithQrCode: Boolean,
     val canCreateAccount: Boolean,

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

@@ -13,6 +13,7 @@ import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import io.element.android.features.login.impl.login.LoginModeState
 import io.element.android.features.login.impl.login.aLoginModeState
 import io.element.android.libraries.designsystem.R
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 
 open class OnBoardingStatePreviewParam : PreviewParameterProvider<OnBoardingState> {
     override val values: Sequence<OnBoardingState>
@@ -22,7 +23,11 @@ open class OnBoardingStatePreviewParam : PreviewParameterProvider<OnBoardingStat
             anOnBoardingState(canCreateAccount = true),
             anOnBoardingState(canLoginWithQrCode = true, canCreateAccount = true),
             anOnBoardingState(canLoginWithQrCode = true, canCreateAccount = true, canReportBug = true),
-            anOnBoardingState(defaultAccountProvider = "element.io", canCreateAccount = false, canReportBug = true),
+            anOnBoardingState(
+                defaultAccountProvider = AccountProvider.Generic("element.io"),
+                canCreateAccount = false,
+                canReportBug = true
+            ),
             anOnBoardingState(customLogoResId = R.drawable.sample_background),
             anOnBoardingState(
                 isAddingAccount = true,
@@ -41,7 +46,7 @@ fun anOnBoardingState(
     showBackButton: Boolean = false,
     showDeveloperSettings: Boolean = false,
     productionApplicationName: String = "Element",
-    defaultAccountProvider: String? = null,
+    defaultAccountProvider: AccountProvider? = null,
     mustChooseAccountProvider: Boolean = false,
     canLoginWithQrCode: Boolean = false,
     canCreateAccount: Boolean = false,

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

@@ -303,7 +303,7 @@ private fun OnBoardingButtons(
             )
         } else {
             Button(
-                text = stringResource(id = R.string.screen_onboarding_sign_in_to, defaultAccountProvider),
+                text = stringResource(id = R.string.screen_onboarding_sign_in_to, defaultAccountProvider.friendlyServerName()),
                 showProgress = isLoading,
                 onClick = {
                     state.eventSink(OnBoardingEvent.OnSignIn(defaultAccountProvider))

features/login/impl/src/main/res/drawable/ic_matrix.xml

@@ -1,12 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="16dp"
-    android:height="16dp"
-    android:viewportWidth="16"
-    android:viewportHeight="16">
-  <path
-      android:pathData="M8,0L8,0A8,8 0,0 1,16 8L16,8A8,8 0,0 1,8 16L8,16A8,8 0,0 1,0 8L0,8A8,8 0,0 1,8 0z"
-      android:fillColor="#101317"/>
-  <path
-      android:pathData="M5.355,5.141V5.85H5.375C5.564,5.579 5.793,5.37 6.059,5.223C6.324,5.073 6.632,5 6.976,5C7.307,5 7.609,5.065 7.883,5.192C8.157,5.319 8.363,5.548 8.507,5.87C8.662,5.641 8.874,5.438 9.139,5.263C9.405,5.088 9.721,5 10.085,5C10.362,5 10.619,5.034 10.856,5.102C11.094,5.169 11.294,5.277 11.464,5.426C11.633,5.576 11.763,5.768 11.859,6.008C11.952,6.248 12,6.536 12,6.875V10.38H10.563V7.412C10.563,7.236 10.557,7.07 10.543,6.915C10.529,6.759 10.492,6.624 10.433,6.511C10.371,6.395 10.283,6.305 10.165,6.237C10.046,6.169 9.885,6.135 9.684,6.135C9.481,6.135 9.317,6.175 9.193,6.251C9.069,6.33 8.97,6.429 8.899,6.556C8.829,6.68 8.781,6.821 8.758,6.982C8.736,7.14 8.722,7.301 8.722,7.462V10.38H7.284V7.443C7.284,7.287 7.281,7.135 7.273,6.982C7.267,6.83 7.236,6.691 7.185,6.562C7.134,6.435 7.05,6.33 6.931,6.254C6.813,6.178 6.64,6.138 6.409,6.138C6.341,6.138 6.251,6.152 6.14,6.183C6.03,6.214 5.92,6.271 5.816,6.355C5.711,6.44 5.621,6.562 5.547,6.72C5.474,6.878 5.437,7.087 5.437,7.344V10.382H4V5.141H5.355Z"
-      android:fillColor="#EBEEF2"/>
-</vector>

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accesscontrol/DefaultAccountProviderAccessControlTest.kt

@@ -11,19 +11,30 @@ package io.element.android.features.login.impl.accesscontrol
 import com.google.common.truth.Truth.assertThat
 import io.element.android.features.enterprise.test.FakeEnterpriseService
 import io.element.android.features.login.impl.changeserver.AccountProviderAccessException
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER
 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_2
 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_URL
+import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged
 import kotlinx.coroutines.test.runTest
 import org.junit.Assert.assertThrows
 import org.junit.Test
 
 class DefaultAccountProviderAccessControlTest {
+    /**
+     * The account provider the assertions are run against: its server name is the title reported by the exceptions,
+     * its base url is what the enterprise service is queried with.
+     */
+    private fun anAccountProviderUnderTest() = anAccountProviderManaged(
+        serverName = AN_ACCOUNT_PROVIDER,
+        baseUrl = AN_ACCOUNT_PROVIDER_URL,
+    )
+
     @Test
     fun `foss build should not allow using account provider that enforce enterprise build`() {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = false,
-            isAllowedToConnectToHomeserver = true,
+            isAllowedToConnectToAccountProvider = true,
             enterpriseService = FakeEnterpriseService(isElementProEnforcedResult = { true }),
         )
         accessControl.expectNeedElementProException()
@@ -34,7 +45,7 @@ class DefaultAccountProviderAccessControlTest {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = false,
             // false here.
-            isAllowedToConnectToHomeserver = false,
+            isAllowedToConnectToAccountProvider = false,
             enterpriseService = FakeEnterpriseService(isElementProEnforcedResult = { true }),
         )
         accessControl.expectNeedElementProException()
@@ -44,9 +55,9 @@ class DefaultAccountProviderAccessControlTest {
     fun `foss build should allow using account provider that does not enforce enterprise build`() = runTest {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = false,
-            isAllowedToConnectToHomeserver = true,
+            isAllowedToConnectToAccountProvider = true,
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { true },
+                isAllowedToConnectToAccountProviderResult = { true },
                 isElementProEnforcedResult = { false }
             ),
         )
@@ -57,7 +68,7 @@ class DefaultAccountProviderAccessControlTest {
     fun `foss build should allow using account provider twith missing key in wellknown`() = runTest {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = false,
-            isAllowedToConnectToHomeserver = true,
+            isAllowedToConnectToAccountProvider = true,
         )
         accessControl.expectAllowed()
     }
@@ -66,7 +77,7 @@ class DefaultAccountProviderAccessControlTest {
     fun `foss build should allow using account provider with missing wellknown`() = runTest {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = false,
-            isAllowedToConnectToHomeserver = true,
+            isAllowedToConnectToAccountProvider = true,
         )
         accessControl.expectAllowed()
     }
@@ -75,12 +86,12 @@ class DefaultAccountProviderAccessControlTest {
     fun `foss build should not allow using account provider that do not enforce enterprise build but is not allowed`() {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = false,
-            isAllowedToConnectToHomeserver = false,
+            isAllowedToConnectToAccountProvider = false,
-            allowedAccountProviders = listOf(AN_ACCOUNT_PROVIDER_2),
+            allowedAccountProviders = listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)),
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { false },
+                isAllowedToConnectToAccountProviderResult = { false },
                 isElementProEnforcedResult = { false },
-                defaultHomeserverListResult = { listOf(AN_ACCOUNT_PROVIDER_2) },
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)) },
             ),
         )
         accessControl.expectUnauthorizedAccountProviderException()
@@ -90,9 +101,9 @@ class DefaultAccountProviderAccessControlTest {
     fun `enterprise build should allow using account provider that enforce enterprise build`() = runTest {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = true,
-            isAllowedToConnectToHomeserver = true,
+            isAllowedToConnectToAccountProvider = true,
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { true },
+                isAllowedToConnectToAccountProviderResult = { true },
                 isElementProEnforcedResult = { true },
             ),
         )
@@ -103,9 +114,9 @@ class DefaultAccountProviderAccessControlTest {
     fun `enterprise build should allow using account provider that do not enforce enterprise build`() = runTest {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = true,
-            isAllowedToConnectToHomeserver = true,
+            isAllowedToConnectToAccountProvider = true,
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { true },
+                isAllowedToConnectToAccountProviderResult = { true },
                 isElementProEnforcedResult = { false },
             ),
         )
@@ -116,12 +127,12 @@ class DefaultAccountProviderAccessControlTest {
     fun `enterprise build should not allow using account provider that enforce enterprise build but is not allowed`() = runTest {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = true,
-            isAllowedToConnectToHomeserver = false,
+            isAllowedToConnectToAccountProvider = false,
-            allowedAccountProviders = listOf(AN_ACCOUNT_PROVIDER_2),
+            allowedAccountProviders = listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)),
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { false },
+                isAllowedToConnectToAccountProviderResult = { false },
                 isElementProEnforcedResult = { true },
-                defaultHomeserverListResult = { listOf(AN_ACCOUNT_PROVIDER_2) },
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)) },
             ),
         )
         accessControl.expectUnauthorizedAccountProviderException()
@@ -131,12 +142,12 @@ class DefaultAccountProviderAccessControlTest {
     fun `enterprise build should not allow using account provider that do not enforce enterprise build but is not allowed`() = runTest {
         val accessControl = createDefaultAccountProviderAccessControl(
             isEnterpriseBuild = true,
-            isAllowedToConnectToHomeserver = false,
+            isAllowedToConnectToAccountProvider = false,
-            allowedAccountProviders = listOf(AN_ACCOUNT_PROVIDER_2),
+            allowedAccountProviders = listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)),
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { false },
+                isAllowedToConnectToAccountProviderResult = { false },
                 isElementProEnforcedResult = { false },
-                defaultHomeserverListResult = { listOf(AN_ACCOUNT_PROVIDER_2) },
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)) },
             ),
         )
         accessControl.expectUnauthorizedAccountProviderException()
@@ -144,11 +155,11 @@ class DefaultAccountProviderAccessControlTest {
 
     private fun createDefaultAccountProviderAccessControl(
         isEnterpriseBuild: Boolean = false,
-        isAllowedToConnectToHomeserver: Boolean = false,
+        isAllowedToConnectToAccountProvider: Boolean = false,
-        allowedAccountProviders: List<String> = emptyList(),
+        allowedAccountProviders: List<AccountProvider> = emptyList(),
         enterpriseService: FakeEnterpriseService = FakeEnterpriseService(
-            isAllowedToConnectToHomeserverResult = { isAllowedToConnectToHomeserver },
+            isAllowedToConnectToAccountProviderResult = { isAllowedToConnectToAccountProvider },
-            defaultHomeserverListResult = { allowedAccountProviders },
+            accountProviderAllowListResult = { allowedAccountProviders },
             isElementProEnforcedResult = { false },
         )
     ) = DefaultAccountProviderAccessControl(
@@ -159,19 +170,14 @@ class DefaultAccountProviderAccessControlTest {
     private fun DefaultAccountProviderAccessControl.expectNeedElementProException() {
         val exception = assertThrows(AccountProviderAccessException.NeedElementProException::class.java) {
             runTest {
-                assertIsAllowedToConnectToAccountProvider(
+                assertIsAllowedToConnectToAccountProvider(anAccountProviderUnderTest())
-                    title = AN_ACCOUNT_PROVIDER,
-                    accountProviderUrl = AN_ACCOUNT_PROVIDER_URL,
-                )
             }
         }
         assertThat(exception.unauthorisedAccountProviderTitle).isEqualTo(AN_ACCOUNT_PROVIDER)
         assertThat(exception.applicationId).isEqualTo("io.element.enterprise")
         runTest {
             assertThat(
-                isAllowedToConnectToAccountProvider(
+                isAllowedToConnectToAccountProvider(anAccountProviderUnderTest())
-                    accountProviderUrl = AN_ACCOUNT_PROVIDER_URL,
-                )
             ).isFalse()
         }
     }
@@ -179,34 +185,24 @@ class DefaultAccountProviderAccessControlTest {
     private fun DefaultAccountProviderAccessControl.expectUnauthorizedAccountProviderException() {
         val exception = assertThrows(AccountProviderAccessException.UnauthorizedAccountProviderException::class.java) {
             runTest {
-                assertIsAllowedToConnectToAccountProvider(
+                assertIsAllowedToConnectToAccountProvider(anAccountProviderUnderTest())
-                    title = AN_ACCOUNT_PROVIDER,
-                    accountProviderUrl = AN_ACCOUNT_PROVIDER_URL,
-                )
             }
         }
         assertThat(exception.unauthorisedAccountProviderTitle).isEqualTo(AN_ACCOUNT_PROVIDER)
         assertThat(exception.authorisedAccountProviderTitles).containsExactly(AN_ACCOUNT_PROVIDER_2)
         runTest {
             assertThat(
-                isAllowedToConnectToAccountProvider(
+                isAllowedToConnectToAccountProvider(anAccountProviderUnderTest())
-                    accountProviderUrl = AN_ACCOUNT_PROVIDER_URL,
-                )
             ).isFalse()
         }
     }
 
     private suspend fun DefaultAccountProviderAccessControl.expectAllowed() {
         // If no exception is thrown, the test passes
-        assertIsAllowedToConnectToAccountProvider(
+        assertIsAllowedToConnectToAccountProvider(anAccountProviderUnderTest())
-            title = AN_ACCOUNT_PROVIDER,
-            accountProviderUrl = AN_ACCOUNT_PROVIDER_URL,
-        )
         runTest {
             assertThat(
-                isAllowedToConnectToAccountProvider(
+                isAllowedToConnectToAccountProvider(anAccountProviderUnderTest())
-                    accountProviderUrl = AN_ACCOUNT_PROVIDER_URL,
-                )
             ).isTrue()
         }
     }

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSourceTest.kt

@@ -10,9 +10,10 @@ package io.element.android.features.login.impl.accountprovider
 
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
-import io.element.android.appconfig.AuthenticationConfig
-import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.features.enterprise.test.FakeEnterpriseService
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
+import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider
+import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged
 import io.element.android.libraries.preferences.test.InMemoryAppPreferencesStore
 import io.element.android.tests.testutils.WarmUpRule
 import kotlinx.coroutines.test.runTest
@@ -24,61 +25,24 @@ class AccountProviderDataSourceTest {
     val warmUpRule = WarmUpRule()
 
     @Test
-    fun `present - initial state`() = runTest {
+    fun `present - initial state - matrix org is the default when nothing is configured`() = runTest {
         val sut = anAccountProviderDataSource()
         sut.flow.test {
-            val initialState = awaitItem()
+            assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider)
-            assertThat(initialState).isEqualTo(
-                AccountProvider(
-                    url = AuthenticationConfig.MATRIX_ORG_URL,
-                    title = "matrix.org",
-                    subtitle = null,
-                    isPublic = true,
-                    isMatrixOrg = true,
-                )
-            )
         }
     }
 
     @Test
-    fun `present - initial state - matrix org`() = runTest {
+    fun `present - initial state - the first configured account provider is the default`() = runTest {
         val sut = anAccountProviderDataSource(
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(AuthenticationConfig.MATRIX_ORG_URL) }
+                accountProviderAllowListResult = {
+                    listOf(anAccountProviderManaged(serverName = "first.org"), anAccountProviderManaged(serverName = "second.org"))
+                }
             ),
         )
         sut.flow.test {
-            val initialState = awaitItem()
+            assertThat(awaitItem()).isEqualTo(anAccountProviderManaged(serverName = "first.org"))
-            assertThat(initialState).isEqualTo(
-                AccountProvider(
-                    url = AuthenticationConfig.MATRIX_ORG_URL,
-                    title = "matrix.org",
-                    subtitle = null,
-                    isPublic = true,
-                    isMatrixOrg = true,
-                )
-            )
-        }
-    }
-
-    @Test
-    fun `present - ensure that default homeserver is not star char`() = runTest {
-        val sut = anAccountProviderDataSource(
-            enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(EnterpriseService.ANY_ACCOUNT_PROVIDER, AuthenticationConfig.MATRIX_ORG_URL) }
-            ),
-        )
-        sut.flow.test {
-            val initialState = awaitItem()
-            assertThat(initialState).isEqualTo(
-                AccountProvider(
-                    url = AuthenticationConfig.MATRIX_ORG_URL,
-                    title = "matrix.org",
-                    subtitle = null,
-                    isPublic = true,
-                    isMatrixOrg = true,
-                )
-            )
         }
     }
 
@@ -86,22 +50,11 @@ class AccountProviderDataSourceTest {
     fun `present - user change and reset`() = runTest {
         val sut = anAccountProviderDataSource()
         sut.flow.test {
-            val initialState = awaitItem()
+            assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider)
-            assertThat(initialState.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL)
+            sut.setAccountProvider(AccountProvider.Generic("https://example.com"))
-            sut.setAccountProvider(AccountProvider(url = "https://example.com"))
+            assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com"))
-            val changedState = awaitItem()
-            assertThat(changedState).isEqualTo(
-                AccountProvider(
-                    url = "https://example.com",
-                    title = "example.com",
-                    subtitle = null,
-                    isPublic = false,
-                    isMatrixOrg = false,
-                )
-            )
             sut.reset()
-            val resetState = awaitItem()
+            assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider)
-            assertThat(resetState.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL)
         }
     }
 
@@ -109,22 +62,23 @@ class AccountProviderDataSourceTest {
     fun `present - set url and reset`() = runTest {
         val sut = anAccountProviderDataSource()
         sut.flow.test {
-            val initialState = awaitItem()
+            assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider)
-            assertThat(initialState.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL)
             sut.setUrl(url = "https://example.com")
-            val changedState = awaitItem()
+            assertThat(awaitItem()).isEqualTo(
-            assertThat(changedState).isEqualTo(
+                AccountProvider.Generic("https://example.com")
-                AccountProvider(
-                    url = "https://example.com",
-                    title = "example.com",
-                    subtitle = null,
-                    isPublic = false,
-                    isMatrixOrg = false,
-                )
             )
             sut.reset()
-            val resetState = awaitItem()
+            assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider)
-            assertThat(resetState.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL)
+        }
+    }
+
+    @Test
+    fun `present - a provider set by the user is stored as they input it`() = runTest {
+        val sut = anAccountProviderDataSource()
+        sut.flow.test {
+            skipItems(1)
+            sut.setUrl(url = "example.com")
+            assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("example.com"))
         }
     }
 
@@ -136,7 +90,7 @@ class AccountProviderDataSourceTest {
             ),
         )
         sut.flow.test {
-            assertThat(awaitItem().url).isEqualTo("https://example.com")
+            assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com"))
         }
     }
 
@@ -144,14 +98,31 @@ class AccountProviderDataSourceTest {
     fun `present - history is ignored when the account provider is enforced`() = runTest {
         val sut = anAccountProviderDataSource(
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf("https://enforced.org") }
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = "enforced.org")) },
+                canConnectToAnyAccountProviderResult = { false },
             ),
             appPreferencesStore = InMemoryAppPreferencesStore(
                 homeserverHistory = listOf("https://example.com"),
             ),
         )
         sut.flow.test {
-            assertThat(awaitItem().url).isEqualTo("https://enforced.org")
+            assertThat(awaitItem()).isEqualTo(anAccountProviderManaged(serverName = "enforced.org"))
+        }
+    }
+
+    @Test
+    fun `present - history wins over the configured provider when other providers are allowed`() = runTest {
+        val sut = anAccountProviderDataSource(
+            enterpriseService = FakeEnterpriseService(
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = "preferred.org")) },
+                canConnectToAnyAccountProviderResult = { true },
+            ),
+            appPreferencesStore = InMemoryAppPreferencesStore(
+                homeserverHistory = listOf("https://example.com"),
+            ),
+        )
+        sut.flow.test {
+            assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com"))
         }
     }
 
@@ -163,11 +134,11 @@ class AccountProviderDataSourceTest {
             ),
         )
         sut.flow.test {
-            assertThat(awaitItem().url).isEqualTo("https://example.com")
+            assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com"))
             sut.setUrl("https://other.com")
-            assertThat(awaitItem().url).isEqualTo("https://other.com")
+            assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://other.com"))
             sut.reset()
-            assertThat(awaitItem().url).isEqualTo("https://example.com")
+            assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com"))
         }
     }
 }

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/SaveAccountProviderToHistoryTest.kt

@@ -20,7 +20,7 @@ class SaveAccountProviderToHistoryTest {
     val warmUpRule = WarmUpRule()
 
     @Test
-    fun `invoke saves the current account provider url to history`() = runTest {
+    fun `invoke saves the current account provider server name to history`() = runTest {
         val appPreferencesStore = InMemoryAppPreferencesStore()
         val accountProviderDataSource = anAccountProviderDataSource()
         accountProviderDataSource.setUrl("https://example.com")
@@ -29,7 +29,7 @@ class SaveAccountProviderToHistoryTest {
         sut()
 
         assertThat(appPreferencesStore.getHomeserverHistoryFlow().first())
-            .containsExactly("https://example.com")
+            .containsExactly("example.com")
     }
 
     @Test
@@ -45,6 +45,6 @@ class SaveAccountProviderToHistoryTest {
         sut()
 
         assertThat(appPreferencesStore.getHomeserverHistoryFlow().first())
-            .containsExactly("https://example.com")
+            .containsExactly("example.com")
     }
 }

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerPresenterTest.kt

@@ -12,14 +12,15 @@ import com.google.common.truth.Truth.assertThat
 import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.features.enterprise.test.FakeEnterpriseService
 import io.element.android.features.login.impl.accesscontrol.DefaultAccountProviderAccessControl
-import io.element.android.features.login.impl.accountprovider.AccountProvider
 import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
 import io.element.android.features.login.impl.accountprovider.anAccountProviderDataSource
 import io.element.android.features.login.impl.error.ChangeServerError
 import io.element.android.features.login.impl.localnetwork.LocalNetworkPermissionGate
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.test.AN_EXCEPTION
 import io.element.android.libraries.matrix.test.A_HOMESERVER_URL
+import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged
 import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService
 import io.element.android.libraries.matrix.test.auth.aMatrixHomeServerDetails
 import io.element.android.libraries.permissions.api.localnetwork.LocalNetworkPermissionDialog
@@ -57,13 +58,13 @@ class ChangeServerPresenterTest {
         createPresenter(
             authenticationService = authenticationService,
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { true },
+                isAllowedToConnectToAccountProviderResult = { true },
                 isElementProEnforcedResult = { false },
             ),
         ).test {
             val initialState = awaitItem()
             assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized)
-            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL)))
+            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL)))
             val loadingState = awaitItem()
             assertThat(loadingState.changeServerAction).isInstanceOf(AsyncData.Loading::class.java)
             val successState = awaitItem()
@@ -80,14 +81,14 @@ class ChangeServerPresenterTest {
         )
         createPresenter(
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { true },
+                isAllowedToConnectToAccountProviderResult = { true },
                 isElementProEnforcedResult = { false },
             ),
             authenticationService = authenticationService,
         ).test {
             val initialState = awaitItem()
             assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized)
-            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL)))
+            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL)))
             val loadingState = awaitItem()
             assertThat(loadingState.changeServerAction).isInstanceOf(AsyncData.Loading::class.java)
             val failureState = awaitItem()
@@ -108,14 +109,14 @@ class ChangeServerPresenterTest {
         )
         createPresenter(
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { true },
+                isAllowedToConnectToAccountProviderResult = { true },
                 isElementProEnforcedResult = { false },
             ),
             authenticationService = authenticationService,
         ).test {
             val initialState = awaitItem()
             assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized)
-            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL)))
+            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL)))
             val loadingState = awaitItem()
             assertThat(loadingState.changeServerAction).isInstanceOf(AsyncData.Loading::class.java)
             val failureState = awaitItem()
@@ -128,30 +129,30 @@ class ChangeServerPresenterTest {
 
     @Test
     fun `present - change server not allowed error`() = runTest {
-        val isAllowedToConnectToHomeserverResult = lambdaRecorder<String, Boolean> { false }
+        val isAllowedToConnectToAccountProviderResult = lambdaRecorder<AccountProvider, Boolean> { false }
         createPresenter(
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = isAllowedToConnectToHomeserverResult,
+                isAllowedToConnectToAccountProviderResult = isAllowedToConnectToAccountProviderResult,
-                defaultHomeserverListResult = { listOf("element.io") },
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = "element.io")) },
                 isElementProEnforcedResult = { false },
             ),
         ).test {
             val initialState = awaitItem()
             assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized)
-            val anAccountProvider = AccountProvider(url = A_HOMESERVER_URL)
+            val anAccountProvider = AccountProvider.Generic(A_HOMESERVER_URL)
             initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(anAccountProvider))
             val loadingState = awaitItem()
             assertThat(loadingState.changeServerAction).isInstanceOf(AsyncData.Loading::class.java)
             val failureState = awaitItem()
             assertThat(
                 (failureState.changeServerAction.errorOrNull() as ChangeServerError.UnauthorizedAccountProvider).unauthorisedAccountProviderTitle
-            ).isEqualTo(anAccountProvider.title)
+            ).isEqualTo(anAccountProvider.serverNameOrBaseUrl())
             assertThat(
                 (failureState.changeServerAction.errorOrNull() as ChangeServerError.UnauthorizedAccountProvider).authorisedAccountProviderTitles
             ).containsExactly("element.io")
-            isAllowedToConnectToHomeserverResult.assertions()
+            isAllowedToConnectToAccountProviderResult.assertions()
                 .isCalledOnce()
-                .with(value(A_HOMESERVER_URL))
+                .with(value(AccountProvider.Generic(A_HOMESERVER_URL)))
         }
     }
 
@@ -166,14 +167,14 @@ class ChangeServerPresenterTest {
         ).test {
             val initialState = awaitItem()
             assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized)
-            val anAccountProvider = AccountProvider(url = A_HOMESERVER_URL)
+            val anAccountProvider = AccountProvider.Generic(A_HOMESERVER_URL)
             initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(anAccountProvider))
             // Skip loading state
             skipItems(1)
             val failureState = awaitItem()
             assertThat(
                 (failureState.changeServerAction.errorOrNull() as ChangeServerError.NeedElementPro).unauthorisedAccountProviderTitle
-            ).isEqualTo(anAccountProvider.title)
+            ).isEqualTo(anAccountProvider.serverNameOrBaseUrl())
             assertThat(
                 (failureState.changeServerAction.errorOrNull() as ChangeServerError.NeedElementPro).applicationId
             ).isEqualTo("io.element.enterprise")
@@ -188,13 +189,13 @@ class ChangeServerPresenterTest {
         )
         createPresenter(
             authenticationService = authenticationService,
-            enterpriseService = FakeEnterpriseService(isAllowedToConnectToHomeserverResult = { true }),
+            enterpriseService = FakeEnterpriseService(isAllowedToConnectToAccountProviderResult = { true }),
             localNetworkPermissionAdvisor = FakeLocalNetworkPermissionAdvisor(shouldPrompt = true),
             permissionsPresenter = FakePermissionsPresenter(),
         ).test {
             val initialState = awaitItem()
             assertThat(initialState.localNetworkPermissionDialog).isEqualTo(LocalNetworkPermissionDialog.None)
-            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL)))
+            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL)))
             val promptState = expectMostRecentItem()
             // Dialog is shown, permission has not been requested yet, setHomeserver has not been called.
             assertThat(promptState.localNetworkPermissionDialog).isNotEqualTo(LocalNetworkPermissionDialog.None)
@@ -208,12 +209,12 @@ class ChangeServerPresenterTest {
             authenticationService = FakeMatrixAuthenticationService(
                 setHomeserverResult = { Result.success(aMatrixHomeServerDetails(supportsOAuthLogin = true)) },
             ),
-            enterpriseService = FakeEnterpriseService(isAllowedToConnectToHomeserverResult = { true }),
+            enterpriseService = FakeEnterpriseService(isAllowedToConnectToAccountProviderResult = { true }),
             localNetworkPermissionAdvisor = FakeLocalNetworkPermissionAdvisor(shouldPrompt = true),
             permissionsPresenter = FakePermissionsPresenter(),
         ).test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL)))
+            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL)))
             val promptState = expectMostRecentItem()
             assertThat(promptState.localNetworkPermissionDialog).isNotEqualTo(LocalNetworkPermissionDialog.None)
             promptState.eventSink.invoke(ChangeServerEvent.DismissLocalNetworkPermission)
@@ -231,12 +232,12 @@ class ChangeServerPresenterTest {
         val permissionsPresenter = FakePermissionsPresenter()
         createPresenter(
             authenticationService = authenticationService,
-            enterpriseService = FakeEnterpriseService(isAllowedToConnectToHomeserverResult = { true }, isElementProEnforcedResult = { false }),
+            enterpriseService = FakeEnterpriseService(isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false }),
             localNetworkPermissionAdvisor = FakeLocalNetworkPermissionAdvisor(shouldPrompt = true),
             permissionsPresenter = permissionsPresenter,
         ).test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL)))
+            initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL)))
             val promptState = expectMostRecentItem()
             assertThat(promptState.localNetworkPermissionDialog).isNotEqualTo(LocalNetworkPermissionDialog.None)
             permissionsPresenter.setPermissionGranted()

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenterTest.kt

@@ -11,14 +11,13 @@ package io.element.android.features.login.impl.screens.chooseaccountprovider
 import com.google.common.truth.Truth.assertThat
 import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.features.enterprise.test.FakeEnterpriseService
-import io.element.android.features.login.impl.accountprovider.AccountProvider
 import io.element.android.features.login.impl.login.LoginModePresenter
 import io.element.android.features.login.impl.screens.onboarding.createLoginModePresenter
 import io.element.android.libraries.architecture.AsyncData
-import io.element.android.libraries.core.uri.ensureProtocol
 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_2
 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_3
 import io.element.android.libraries.matrix.test.AN_EXCEPTION
+import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged
 import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService
 import io.element.android.tests.testutils.WarmUpRule
 import io.element.android.tests.testutils.test
@@ -33,18 +32,8 @@ class ChooseAccountProviderPresenterTest {
     companion object {
         private const val ACCOUNT_PROVIDER_FROM_CONFIG_1 = AN_ACCOUNT_PROVIDER_2
         private const val ACCOUNT_PROVIDER_FROM_CONFIG_2 = AN_ACCOUNT_PROVIDER_3
-        val accountProvider1 = AccountProvider(
+        val accountProvider1 = anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG_1)
-            url = ACCOUNT_PROVIDER_FROM_CONFIG_1.ensureProtocol(),
+        val accountProvider2 = anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG_2)
-            subtitle = null,
-            isPublic = false,
-            isMatrixOrg = false,
-        )
-        val accountProvider2 = AccountProvider(
-            url = ACCOUNT_PROVIDER_FROM_CONFIG_2.ensureProtocol(),
-            subtitle = null,
-            isPublic = false,
-            isMatrixOrg = false,
-        )
     }
 
     @Test
@@ -61,7 +50,7 @@ class ChooseAccountProviderPresenterTest {
     fun `present - initial state`() = runTest {
         val presenter = createPresenter(
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG_1, ACCOUNT_PROVIDER_FROM_CONFIG_2) },
+                accountProviderAllowListResult = { listOf(accountProvider1, accountProvider2) },
             ),
         )
         presenter.test {
@@ -79,7 +68,7 @@ class ChooseAccountProviderPresenterTest {
         val authenticationService = FakeMatrixAuthenticationService()
         val presenter = createPresenter(
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG_1, ACCOUNT_PROVIDER_FROM_CONFIG_2) },
+                accountProviderAllowListResult = { listOf(accountProvider1, accountProvider2) },
             ),
             loginModePresenter = createLoginModePresenter(
                 authenticationService = authenticationService,
@@ -103,7 +92,7 @@ class ChooseAccountProviderPresenterTest {
         )
         val presenter = createPresenter(
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG_1, ACCOUNT_PROVIDER_FROM_CONFIG_2) },
+                accountProviderAllowListResult = { listOf(accountProvider1, accountProvider2) },
             ),
             loginModePresenter = createLoginModePresenter(
                 authenticationService = authenticationService,
@@ -136,7 +125,7 @@ class ChooseAccountProviderPresenterTest {
         val authenticationService = FakeMatrixAuthenticationService()
         val presenter = createPresenter(
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG_1, ACCOUNT_PROVIDER_FROM_CONFIG_2) },
+                accountProviderAllowListResult = { listOf(accountProvider1, accountProvider2) },
             ),
             loginModePresenter = createLoginModePresenter(
                 authenticationService = authenticationService,

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStateTest.kt

@@ -9,7 +9,7 @@
 package io.element.android.features.login.impl.screens.chooseaccountprovider
 
 import com.google.common.truth.Truth.assertThat
-import io.element.android.features.login.impl.accountprovider.anAccountProvider
+import io.element.android.features.login.impl.accountprovider.anAccountProviderManaged
 import io.element.android.features.login.impl.login.LoginMode
 import io.element.android.features.login.impl.login.aLoginModeState
 import io.element.android.libraries.architecture.AsyncData
@@ -27,7 +27,7 @@ class ChooseAccountProviderStateTest {
     @Test
     fun `submitEnabled returns true when there is a selectedAccountProvider`() {
         val sut = aChooseAccountProviderState(
-            selectedAccountProvider = anAccountProvider(),
+            selectedAccountProvider = anAccountProviderManaged(),
         )
         assertThat(sut.submitEnabled).isTrue()
     }
@@ -35,7 +35,7 @@ class ChooseAccountProviderStateTest {
     @Test
     fun `submitEnabled returns false when there is a selectedAccountProvider but there is an error`() {
         val sut = aChooseAccountProviderState(
-            selectedAccountProvider = anAccountProvider(),
+            selectedAccountProvider = anAccountProviderManaged(),
             loginModeState = aLoginModeState(loginMode = AsyncData.Failure(Throwable("Error"))),
         )
         assertThat(sut.submitEnabled).isFalse()
@@ -44,7 +44,7 @@ class ChooseAccountProviderStateTest {
     @Test
     fun `submitEnabled returns false when there is a selectedAccountProvider but the result is successful`() {
         val sut = aChooseAccountProviderState(
-            selectedAccountProvider = anAccountProvider(),
+            selectedAccountProvider = anAccountProviderManaged(),
             loginModeState = aLoginModeState(loginMode = AsyncData.Success(LoginMode.PasswordLogin)),
         )
         assertThat(sut.submitEnabled).isFalse()

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderViewTest.kt

@@ -16,7 +16,7 @@ import androidx.compose.ui.test.ExperimentalTestApi
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
 import androidx.compose.ui.test.v2.runAndroidComposeUiTest
-import io.element.android.features.login.impl.accountprovider.anAccountProvider
+import io.element.android.features.login.impl.accountprovider.anAccountProviderManaged
 import io.element.android.features.login.impl.login.aLoginModeState
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.matrix.api.auth.OAuthDetails
@@ -57,11 +57,11 @@ class ChooseAccountProviderViewTest : RobolectricTest() {
                     ChooseAccountProviderPresenterTest.accountProvider1,
                     ChooseAccountProviderPresenterTest.accountProvider2,
                 ),
-                selectedAccountProvider = anAccountProvider(),
+                selectedAccountProvider = anAccountProviderManaged(),
                 eventSink = eventSink,
             ),
         )
-        onNodeWithText(ChooseAccountProviderPresenterTest.accountProvider1.title).performClick()
+        onNodeWithText(ChooseAccountProviderPresenterTest.accountProvider1.friendlyServerName()).performClick()
         eventSink.assertSingle(ChooseAccountProviderEvent.SelectAccountProvider(ChooseAccountProviderPresenterTest.accountProvider1))
     }
 

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

@@ -10,7 +10,6 @@ package io.element.android.features.login.impl.screens.confirmaccountprovider
 
 import app.cash.turbine.ReceiveTurbine
 import com.google.common.truth.Truth.assertThat
-import io.element.android.appconfig.AuthenticationConfig
 import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.features.enterprise.test.FakeEnterpriseService
 import io.element.android.features.login.impl.accesscontrol.DefaultAccountProviderAccessControl
@@ -24,6 +23,7 @@ import io.element.android.features.login.impl.screens.onboarding.createLoginMode
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.test.AN_EXCEPTION
+import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged
 import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService
 import io.element.android.libraries.matrix.test.auth.aMatrixHomeServerDetails
 import io.element.android.libraries.oauth.api.OAuthAction
@@ -44,6 +44,11 @@ class ConfirmAccountProviderPresenterTest {
     @get:Rule
     val warmUpRule = WarmUpRule()
 
+    companion object {
+        private const val MATRIX_ORG_SERVER_NAME = "matrix.org"
+        private const val MATRIX_ORG_URL = "https://matrix.org"
+    }
+
     @Test
     fun `present - initial test`() = runTest {
         val presenter = createConfirmAccountProviderPresenter()
@@ -68,7 +73,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             val successState = awaitLoginMode { it is AsyncData.Success }
             assertThat(successState.loginModeState.loginMode.dataOrNull()).isEqualTo(LoginMode.PasswordLogin)
             cancelAndIgnoreRemainingEvents()
@@ -87,7 +92,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             val successState = awaitLoginMode { it is AsyncData.Success }
             assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java)
             cancelAndIgnoreRemainingEvents()
@@ -108,7 +113,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             val successState = awaitLoginMode { it is AsyncData.Success }
             assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java)
             authenticationService.givenOAuthCancelError(AN_EXCEPTION)
@@ -133,7 +138,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             val successState = awaitLoginMode { it is AsyncData.Success }
             assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java)
             defaultOAuthActionFlow.post(OAuthAction.GoBack())
@@ -157,7 +162,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             awaitLoginMode { it is AsyncData.Loading }
             defaultOAuthActionFlow.post(OAuthAction.GoBack(toUnblock = true))
             val cancelFinalState = awaitLoginMode { it is AsyncData.Uninitialized }
@@ -180,7 +185,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             val successState = awaitLoginMode { it is AsyncData.Success }
             assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java)
             authenticationService.givenLoginError(AN_EXCEPTION)
@@ -205,7 +210,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             val successState = awaitLoginMode { it is AsyncData.Success }
             assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java)
             defaultOidcActionFlow.post(OAuthAction.Success("aUrl"))
@@ -227,7 +232,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             // The account provider validation fails, so the login is never attempted.
             val failureState = awaitState { it.changeServerState.changeServerAction is AsyncData.Failure }
             assertThat(failureState.loginModeState.loginMode).isEqualTo(AsyncData.Uninitialized)
@@ -249,7 +254,7 @@ class ConfirmAccountProviderPresenterTest {
             val initialState = awaitItem()
 
             // Submit will return an error while validating the account provider
-            initialState.eventSink(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
 
             // Check an error was returned
             val submittedState = awaitState { it.changeServerState.changeServerAction is AsyncData.Failure }
@@ -274,7 +279,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             // Check an error was returned
             val submittedState = awaitLoginMode { it is AsyncData.Failure }
             assertThat(submittedState.loginModeState.loginMode.errorOrNull()).isInstanceOf(AccountCreationNotSupported::class.java)
@@ -299,7 +304,7 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             val submittedState = awaitLoginMode { it is AsyncData.Success }
             assertThat(submittedState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java)
             cancelAndIgnoreRemainingEvents()
@@ -344,7 +349,7 @@ class ConfirmAccountProviderPresenterTest {
             val suggestionState = awaitState { it.accountProviderSuggestion != null }
             suggestionState.eventSink(ConfirmAccountProviderEvent.Continue("randomcommunity.org"))
             awaitLoginMode { it is AsyncData.Success }
-            assertThat(submittedUrls.first()).isEqualTo("https://randomcommunity.org")
+            assertThat(submittedUrls.first()).isEqualTo("randomcommunity.org")
             cancelAndIgnoreRemainingEvents()
         }
     }
@@ -375,8 +380,7 @@ class ConfirmAccountProviderPresenterTest {
         val presenter = createConfirmAccountProviderPresenter(
             appPreferencesStore = InMemoryAppPreferencesStore(homeserverHistory = emptyList()),
             enterpriseService = FakeEnterpriseService(
-                // Preferred servers plus the "*" (any) wildcard: the wildcard is filtered out, the rest complete.
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = "element.io")) },
-                defaultHomeserverListResult = { listOf("https://element.io", EnterpriseService.ANY_ACCOUNT_PROVIDER) },
             ),
         )
         presenter.test {
@@ -387,6 +391,19 @@ class ConfirmAccountProviderPresenterTest {
         }
     }
 
+    @Test
+    fun `present - offers the previously used servers without the scheme as autocomplete suggestions`() = runTest {
+        val presenter = createConfirmAccountProviderPresenter(
+            appPreferencesStore = InMemoryAppPreferencesStore(homeserverHistory = listOf("https://previous.org")),
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            initialState.eventSink(ConfirmAccountProviderEvent.UserInputChanged("prev"))
+            val suggestionState = awaitState { it.accountProviderInput == "prev" }
+            assertThat(suggestionState.accountProviderSuggestion).isEqualTo("previous.org")
+        }
+    }
+
     @Test
     fun `present - offers matrix_org without the scheme as an autocomplete suggestion`() = runTest {
         val presenter = createConfirmAccountProviderPresenter(
@@ -432,7 +449,7 @@ class ConfirmAccountProviderPresenterTest {
             val initialState = awaitItem()
             initialState.eventSink(ConfirmAccountProviderEvent.Continue("matrix.org"))
             awaitLoginMode { it is AsyncData.Success }
-            assertThat(submittedUrls.first()).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL)
+            assertThat(submittedUrls.first()).isEqualTo(MATRIX_ORG_SERVER_NAME)
             cancelAndIgnoreRemainingEvents()
         }
     }
@@ -453,9 +470,9 @@ class ConfirmAccountProviderPresenterTest {
         )
         presenter.test {
             val initialState = awaitItem()
-            initialState.eventSink(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL))
+            initialState.eventSink(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL))
             awaitLoginMode { it is AsyncData.Success }
-            assertThat(submittedUrls).containsExactly(AuthenticationConfig.MATRIX_ORG_URL)
+            assertThat(submittedUrls).containsExactly(MATRIX_ORG_SERVER_NAME)
             cancelAndIgnoreRemainingEvents()
         }
     }
@@ -474,7 +491,7 @@ class ConfirmAccountProviderPresenterTest {
             val initialState = awaitItem()
             initialState.eventSink(ConfirmAccountProviderEvent.Continue("@alice:example.org"))
             awaitLoginMode { it is AsyncData.Success }
-            assertThat(submittedUrls.first()).isEqualTo("https://example.org")
+            assertThat(submittedUrls.first()).isEqualTo("example.org")
             assertThat(authenticationService.getOAuthUrlLoginHint).isEqualTo("mxid:@alice:example.org")
             cancelAndIgnoreRemainingEvents()
         }
@@ -494,7 +511,7 @@ class ConfirmAccountProviderPresenterTest {
             val initialState = awaitItem()
             initialState.eventSink(ConfirmAccountProviderEvent.Continue("@alice:example.org:8448"))
             awaitLoginMode { it is AsyncData.Success }
-            assertThat(submittedUrls.first()).isEqualTo("https://example.org:8448")
+            assertThat(submittedUrls.first()).isEqualTo("example.org:8448")
             cancelAndIgnoreRemainingEvents()
         }
     }
@@ -570,7 +587,7 @@ class ConfirmAccountProviderPresenterTest {
             accountProviderDataSource = accountProviderDataSource,
             defaultAccountProviderAccessControl = DefaultAccountProviderAccessControl(
                 enterpriseService = FakeEnterpriseService(
-                    isAllowedToConnectToHomeserverResult = { true },
+                    isAllowedToConnectToAccountProviderResult = { true },
                     isElementProEnforcedResult = { false },
                 ),
                 isEnterpriseBuild = { false },

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordPresenterTest.kt

@@ -9,11 +9,11 @@
 package io.element.android.features.login.impl.screens.loginpassword
 
 import com.google.common.truth.Truth.assertThat
-import io.element.android.appconfig.AuthenticationConfig
 import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
 import io.element.android.features.login.impl.accountprovider.SaveAccountProviderToHistory
 import io.element.android.features.login.impl.accountprovider.anAccountProviderDataSource
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.test.AN_EXCEPTION
 import io.element.android.libraries.matrix.test.A_PASSWORD
@@ -39,7 +39,7 @@ class LoginPasswordPresenterTest {
     fun `present - initial state`() = runTest {
         createLoginPasswordPresenter().test {
             val initialState = awaitItem()
-            assertThat(initialState.accountProvider.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL)
+            assertThat(initialState.accountProvider).isEqualTo(matrixOrgAccountProvider)
             assertThat(initialState.formState).isEqualTo(LoginFormState.Default)
             assertThat(initialState.loginAction).isEqualTo(AsyncData.Uninitialized)
             assertThat(initialState.submitEnabled).isFalse()
@@ -127,7 +127,7 @@ class LoginPasswordPresenterTest {
             val loggedInState = awaitItem()
             assertThat(loggedInState.loginAction).isEqualTo(AsyncData.Success(A_SESSION_ID))
             assertThat(appPreferencesStore.getHomeserverHistoryFlow().first())
-                .containsExactly(AuthenticationConfig.MATRIX_ORG_URL)
+                .containsExactly(matrixOrgAccountProvider.serverName)
         }
     }
 

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

@@ -9,7 +9,6 @@
 package io.element.android.features.login.impl.screens.onboarding
 
 import com.google.common.truth.Truth.assertThat
-import io.element.android.appconfig.AuthenticationConfig
 import io.element.android.appconfig.OnBoardingConfig
 import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.features.enterprise.api.IsEnterpriseBuild
@@ -22,6 +21,8 @@ import io.element.android.features.login.impl.localnetwork.LocalNetworkPermissio
 import io.element.android.features.login.impl.login.LoginModePresenter
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.core.meta.BuildMeta
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
+import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER
 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_2
@@ -30,6 +31,7 @@ import io.element.android.libraries.matrix.test.AN_EXCEPTION
 import io.element.android.libraries.matrix.test.A_HOMESERVER_URL
 import io.element.android.libraries.matrix.test.A_HOMESERVER_URL_2
 import io.element.android.libraries.matrix.test.A_LOGIN_HINT
+import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged
 import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService
 import io.element.android.libraries.matrix.test.core.aBuildMeta
 import io.element.android.libraries.oauth.api.OAuthActionFlow
@@ -82,7 +84,8 @@ class OnBoardingPresenterTest {
         val presenter = createPresenter(
             buildMeta = buildMeta,
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG, EnterpriseService.ANY_ACCOUNT_PROVIDER) },
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG)) },
+                canConnectToAnyAccountProviderResult = { true },
             ),
         )
         presenter.test {
@@ -184,15 +187,16 @@ class OnBoardingPresenterTest {
                 showBackButton = false,
             ),
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG, EnterpriseService.ANY_ACCOUNT_PROVIDER) },
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG)) },
-                isAllowedToConnectToHomeserverResult = { true },
+                canConnectToAnyAccountProviderResult = { true },
+                isAllowedToConnectToAccountProviderResult = { true },
                 isElementProEnforcedResult = { false },
             ),
         )
         presenter.test {
             skipItems(3)
             awaitItem().also {
-                assertThat(it.defaultAccountProvider).isEqualTo(ACCOUNT_PROVIDER_FROM_LINK)
+                assertThat(it.defaultAccountProvider).isEqualTo(AccountProvider.Generic(ACCOUNT_PROVIDER_FROM_LINK))
                 assertThat(it.canLoginWithQrCode).isFalse()
                 assertThat(it.canCreateAccount).isFalse()
             }
@@ -208,8 +212,14 @@ class OnBoardingPresenterTest {
                 showBackButton = false,
             ),
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG, ACCOUNT_PROVIDER_FROM_CONFIG_2) },
+                accountProviderAllowListResult = {
-                isAllowedToConnectToHomeserverResult = { false },
+                    listOf(
+                        anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG),
+                        anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG_2)
+                    )
+                },
+                canConnectToAnyAccountProviderResult = { false },
+                isAllowedToConnectToAccountProviderResult = { false },
             ),
         )
         presenter.test {
@@ -231,19 +241,60 @@ class OnBoardingPresenterTest {
                 showBackButton = false,
             ),
             enterpriseService = FakeEnterpriseService(
-                defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG) },
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG)) },
+                canConnectToAnyAccountProviderResult = { false },
             )
         )
         presenter.test {
             skipItems(1)
             awaitItem().also {
-                assertThat(it.defaultAccountProvider).isEqualTo(ACCOUNT_PROVIDER_FROM_CONFIG)
+                assertThat(it.defaultAccountProvider).isEqualTo(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG))
                 assertThat(it.canLoginWithQrCode).isTrue()
                 assertThat(it.canCreateAccount).isFalse()
             }
         }
     }
 
+    @Test
+    fun `present - a single configured account provider is not forced when the user may use another one`() = runTest {
+        // A singleton allow list only forces the account provider when the user is not free to use another one.
+        val presenter = createPresenter(
+            enterpriseService = FakeEnterpriseService(
+                accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG)) },
+                canConnectToAnyAccountProviderResult = { true },
+            ),
+        )
+        presenter.test {
+            awaitItem().also {
+                assertThat(it.defaultAccountProvider).isNull()
+                assertThat(it.mustChooseAccountProvider).isFalse()
+            }
+            skipItems(1)
+        }
+    }
+
+    @Test
+    fun `present - the user must choose when several account providers are configured and enforced`() = runTest {
+        val presenter = createPresenter(
+            enterpriseService = FakeEnterpriseService(
+                accountProviderAllowListResult = {
+                    listOf(
+                        anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG),
+                        anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG_2)
+                    )
+                },
+                canConnectToAnyAccountProviderResult = { false },
+            ),
+        )
+        presenter.test {
+            awaitItem().also {
+                assertThat(it.defaultAccountProvider).isNull()
+                assertThat(it.mustChooseAccountProvider).isTrue()
+            }
+            skipItems(1)
+        }
+    }
+
     @Test
     fun `present - default account provider - login and clear error`() = runTest {
         val authenticationService = FakeMatrixAuthenticationService(
@@ -259,7 +310,7 @@ class OnBoardingPresenterTest {
                 showBackButton = false,
             ),
             enterpriseService = FakeEnterpriseService(
-                isAllowedToConnectToHomeserverResult = { true },
+                isAllowedToConnectToAccountProviderResult = { true },
                 isElementProEnforcedResult = { false },
             ),
             loginModePresenter = createLoginModePresenter(
@@ -270,12 +321,12 @@ class OnBoardingPresenterTest {
         presenter.test {
             skipItems(3)
             awaitItem().also {
-                assertThat(it.defaultAccountProvider).isEqualTo(A_HOMESERVER_URL)
+                assertThat(it.defaultAccountProvider).isEqualTo(AccountProvider.Generic(A_HOMESERVER_URL))
-                assertThat(accountProviderDataSource.flow.first().url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL)
+                assertThat(accountProviderDataSource.flow.first()).isEqualTo(matrixOrgAccountProvider)
-                it.eventSink(OnBoardingEvent.OnSignIn(A_HOMESERVER_URL_2))
+                it.eventSink(OnBoardingEvent.OnSignIn(AccountProvider.Generic(A_HOMESERVER_URL_2)))
                 skipItems(1) // Loading
                 // Account data source has been updated
-                assertThat(accountProviderDataSource.flow.first().url).isEqualTo(A_HOMESERVER_URL_2)
+                assertThat(accountProviderDataSource.flow.first()).isEqualTo(AccountProvider.Generic(A_HOMESERVER_URL_2))
                 // Check an error was returned
                 val submittedState = awaitItem()
                 assertThat(submittedState.loginModeState.loginMode).isInstanceOf(AsyncData.Failure::class.java)

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

@@ -23,6 +23,7 @@ import io.element.android.features.login.impl.R
 import io.element.android.features.login.impl.login.LoginMode
 import io.element.android.features.login.impl.login.aLoginModeState
 import io.element.android.libraries.architecture.AsyncData
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.libraries.matrix.api.auth.OAuthDetails
 import io.element.android.libraries.matrix.test.AN_EXCEPTION
 import io.element.android.libraries.ui.strings.CommonStrings
@@ -134,13 +135,13 @@ class OnboardingViewTest : RobolectricTestParameter() {
         val eventSink = EventsRecorder<OnBoardingEvent>()
         setOnboardingView(
             state = anOnBoardingState(
-                defaultAccountProvider = "element.io",
+                defaultAccountProvider = AccountProvider.Generic("element.io"),
                 eventSink = eventSink,
             ),
         )
         val buttonText = activity!!.getString(R.string.screen_onboarding_sign_in_to, "element.io")
         onNodeWithText(buttonText).performClick()
-        eventSink.assertSingle(OnBoardingEvent.OnSignIn("element.io"))
+        eventSink.assertSingle(OnBoardingEvent.OnSignIn(AccountProvider.Generic("element.io")))
     }
 
     @Test
@@ -148,7 +149,7 @@ class OnboardingViewTest : RobolectricTestParameter() {
         val eventSink = EventsRecorder<OnBoardingEvent>()
         setOnboardingView(
             state = anOnBoardingState(
-                defaultAccountProvider = "element.io",
+                defaultAccountProvider = AccountProvider.Generic("element.io"),
                 loginModeState = aLoginModeState(loginMode = AsyncData.Failure(AN_EXCEPTION)),
                 eventSink = eventSink,
             ),

features/login/test/build.gradle.kts

@@ -16,6 +16,7 @@ android {
 
 dependencies {
     implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
     implementation(projects.features.login.api)
     implementation(projects.tests.testutils)
 }

features/login/test/src/main/kotlin/io/element/android/features/login/test/accesscontrol/FakeAccountProviderAccessControl.kt

@@ -8,12 +8,13 @@
 package io.element.android.features.login.test.accesscontrol
 
 import io.element.android.features.login.api.accesscontrol.AccountProviderAccessControl
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
 import io.element.android.tests.testutils.lambda.lambdaError
 
 class FakeAccountProviderAccessControl(
-    private val isAllowedToConnectToAccountProviderResult: (String) -> Boolean = { lambdaError() },
+    private val isAllowedToConnectToAccountProviderResult: (AccountProvider) -> Boolean = { lambdaError() },
 ) : AccountProviderAccessControl {
-    override suspend fun isAllowedToConnectToAccountProvider(accountProviderUrl: String): Boolean {
+    override suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider): Boolean {
-        return isAllowedToConnectToAccountProviderResult(accountProviderUrl)
+        return isAllowedToConnectToAccountProviderResult(accountProvider)
     }
 }

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProvider.kt

@@ -0,0 +1,67 @@
+/*
+ * 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.libraries.matrix.api.accountprovider
+
+sealed interface AccountProvider {
+    /**
+     * An account provider that was input by the user.
+     */
+    data class Generic(
+        val serverName: String,
+    ) : AccountProvider
+
+    /**
+     * An account provider that is provided by the app.
+     */
+    data class Managed(
+        val serverName: String,
+        val baseUrl: String,
+        val canUseServerName: Boolean,
+    ) : AccountProvider
+
+    fun serverNameOrBaseUrl(): String {
+        return when (this) {
+            is Generic -> serverName
+            is Managed -> if (canUseServerName) serverName else baseUrl
+        }.sanitized()
+    }
+
+    fun friendlyServerName(): String {
+        return when (this) {
+            is Generic -> serverName
+            is Managed -> serverName
+        }.sanitized()
+    }
+
+    /**
+     * The user may reach an allowed account provider by either of its identifiers: the server name it is known by
+     * (what the user types, e.g. `element.io`) or the base url its client API lives at (e.g. `https://element.ems.host`).
+     */
+    fun matches(other: AccountProvider): Boolean {
+        return serverNameOrBaseUrl() == other.serverNameOrBaseUrl()
+    }
+
+    /**
+     * Sanitizes the string with the following rules:
+     * - Trim any whitespace.
+     * - Lowercase the string.
+     * - Removes a https scheme (treating it as implicit).
+     * - Remove any trailing slashes.
+     */
+    private fun String.sanitized(): String {
+        return trim()
+            .lowercase()
+            // Intentionally continue to show http:// as an indicator (and for history).
+            .removePrefix("https://")
+            .removeSuffix("/")
+    }
+}
+
+val matrixOrgAccountProvider = AccountProvider.Generic(
+    serverName = "matrix.org",
+)

libraries/matrix/api/src/test/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProviderTest.kt

@@ -0,0 +1,89 @@
+/*
+ * 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.libraries.matrix.api.accountprovider
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class AccountProviderTest {
+    @Test
+    fun `serverNameOrBaseUrl of a generic account provider is the server name the user input`() {
+        assertThat(AccountProvider.Generic("matrix.org").serverNameOrBaseUrl()).isEqualTo("matrix.org")
+    }
+
+    @Test
+    fun `serverNameOrBaseUrl of a managed account provider is its server name when it can be used`() {
+        val accountProvider = AccountProvider.Managed(
+            serverName = "element.io",
+            baseUrl = "https://element.ems.host",
+            canUseServerName = true,
+        )
+        assertThat(accountProvider.serverNameOrBaseUrl()).isEqualTo("element.io")
+    }
+
+    @Test
+    fun `serverNameOrBaseUrl of a managed account provider is its base url when the server name cannot be used`() {
+        val accountProvider = AccountProvider.Managed(
+            serverName = "element.io",
+            baseUrl = "https://element.ems.host",
+            canUseServerName = false,
+        )
+        assertThat(accountProvider.serverNameOrBaseUrl()).isEqualTo("element.ems.host")
+    }
+
+    @Test
+    fun `matrixOrgAccountProvider is known by its server name`() {
+        assertThat(matrixOrgAccountProvider.serverNameOrBaseUrl()).isEqualTo("matrix.org")
+    }
+
+    @Test
+    fun `serverNameOrBaseUrl trims, lowercases and drops the implicit https scheme and a trailing slash`() {
+        assertThat(AccountProvider.Generic("  MATRIX.org ").serverNameOrBaseUrl()).isEqualTo("matrix.org")
+        assertThat(AccountProvider.Generic("https://matrix.org").serverNameOrBaseUrl()).isEqualTo("matrix.org")
+        assertThat(AccountProvider.Generic("https://matrix.org/").serverNameOrBaseUrl()).isEqualTo("matrix.org")
+    }
+
+    @Test
+    fun `serverNameOrBaseUrl keeps an explicit http scheme as an indicator`() {
+        assertThat(AccountProvider.Generic("http://localhost:8080").serverNameOrBaseUrl()).isEqualTo("http://localhost:8080")
+    }
+
+    @Test
+    fun `matches ignores the scheme, the case and a trailing slash`() {
+        val typed = AccountProvider.Generic("Element.io/")
+        assertThat(typed.matches(AccountProvider.Generic("https://element.io"))).isTrue()
+        assertThat(
+            typed.matches(
+                AccountProvider.Managed(serverName = "element.io", baseUrl = "https://element.ems.host", canUseServerName = true)
+            )
+        ).isTrue()
+    }
+
+    @Test
+    fun `matches a managed provider that cannot use its server name only through its base url`() {
+        val managed = AccountProvider.Managed(
+            serverName = "element.io",
+            baseUrl = "https://element.ems.host",
+            canUseServerName = false,
+        )
+        assertThat(AccountProvider.Generic("element.ems.host").matches(managed)).isTrue()
+        assertThat(AccountProvider.Generic("element.io").matches(managed)).isFalse()
+    }
+
+    @Test
+    fun `matches is false for a different account provider`() {
+        val typed = AccountProvider.Generic("element.io")
+        assertThat(typed.matches(AccountProvider.Generic("matrix.org"))).isFalse()
+        // A managed provider that can use its server name is not reached through its base url.
+        assertThat(
+            typed.matches(
+                AccountProvider.Managed(serverName = "other.io", baseUrl = "https://element.io", canUseServerName = true)
+            )
+        ).isFalse()
+    }
+}

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/accountprovider/AccountProviderFixture.kt

@@ -0,0 +1,28 @@
+/*
+ * 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.libraries.matrix.test.accountprovider
+
+import io.element.android.libraries.matrix.api.accountprovider.AccountProvider
+import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER
+import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_URL
+
+fun anAccountProviderGeneric(
+    serverName: String = AN_ACCOUNT_PROVIDER,
+) = AccountProvider.Generic(
+    serverName = serverName,
+)
+
+fun anAccountProviderManaged(
+    baseUrl: String = AN_ACCOUNT_PROVIDER_URL,
+    serverName: String = AN_ACCOUNT_PROVIDER,
+    canUseServerName: Boolean = true,
+) = AccountProvider.Managed(
+    serverName = serverName,
+    baseUrl = baseUrl,
+    canUseServerName = canUseServerName,
+)