Merge branch 'develop' into renovate/com.google.auto.service-auto-service-annotations-1.x

.idea/dictionaries/bmarty.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="bmarty">
+    <words>
+      <w>homeserver</w>
+    </words>
+  </dictionary>
+</component>

.maestro/README.md

@@ -25,7 +25,7 @@ maestro test \
     -e APP_ID=io.element.android.x.debug \
     -e USERNAME=user \
     -e PASSWORD=123 \
-    -e ROOM_NAME="my room" \
+    -e ROOM_NAME="MyRoom" \
     .maestro/allTests.yaml
 ```
 

.maestro/tests/account/changeServer.yaml

@@ -3,4 +3,15 @@ appId: ${APP_ID}
 - tapOn:
     id: "login-change_server"
 - takeScreenshot: build/maestro/200-ChangeServer
-- tapOn: "Continue"
+- tapOn: "matrix.org"
+- tapOn:
+    id: "login-change_server"
+- tapOn: "Other"
+- tapOn:
+    id: "change_server-server"
+- inputText: "element"
+- hideKeyboard
+- tapOn: "element.io"
+- tapOn: "Cancel"
+- back
+- back

.maestro/tests/account/login.yaml

@@ -5,6 +5,8 @@ appId: ${APP_ID}
 - takeScreenshot: build/maestro/100-SignIn
 - runFlow: changeServer.yaml
 - runFlow: ../assertions/assertLoginDisplayed.yaml
+- tapOn:
+    id: "login-continue"
 - tapOn:
     id: "login-email_username"
 - inputText: ${USERNAME}

.maestro/tests/assertions/assertLoginDisplayed.yaml

@@ -1,5 +1,5 @@
 appId: ${APP_ID}
 ---
 - extendedWaitUntil:
-    visible: "Welcome back!"
+    visible: "Change account provider"
     timeout: 10_000

anvilcodegen/build.gradle.kts

@@ -26,5 +26,5 @@ dependencies {
     implementation("com.squareup:kotlinpoet:1.14.2")
     implementation(libs.dagger)
     compileOnly("com.google.auto.service:auto-service-annotations:1.1.1")
-    kapt("com.google.auto.service:auto-service:1.1.0")
+    kapt("com.google.auto.service:auto-service:1.1.1")
 }

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

@@ -23,7 +23,6 @@ import io.element.android.libraries.matrix.api.verification.SessionVerificationS
 import io.element.android.libraries.matrix.api.verification.VerificationFlowState
 import io.element.android.libraries.ui.strings.R
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.launchIn
@@ -31,7 +30,6 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 import javax.inject.Inject
-import kotlin.coroutines.coroutineContext
 
 class LoggedInEventProcessor @Inject constructor(
     private val snackbarDispatcher: SnackbarDispatcher,

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

@@ -63,7 +63,9 @@ class NotLoggedInFlowNode @AssistedInject constructor(
         object OnBoarding : NavTarget
 
         @Parcelize
-        object LoginFlow : NavTarget
+        data class LoginFlow(
+            val isAccountCreation: Boolean,
+        ) : NavTarget
     }
 
     override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
@@ -71,11 +73,11 @@ class NotLoggedInFlowNode @AssistedInject constructor(
             NavTarget.OnBoarding -> {
                 val callback = object : OnBoardingEntryPoint.Callback {
                     override fun onSignUp() {
-                        //NOOP
+                        backstack.push(NavTarget.LoginFlow(isAccountCreation = true))
                     }
 
                     override fun onSignIn() {
-                        backstack.push(NavTarget.LoginFlow)
+                        backstack.push(NavTarget.LoginFlow(isAccountCreation = false))
                     }
                 }
                 onBoardingEntryPoint
@@ -83,8 +85,10 @@ class NotLoggedInFlowNode @AssistedInject constructor(
                     .callback(callback)
                     .build()
             }
-            NavTarget.LoginFlow -> {
-                loginEntryPoint.createNode(this, buildContext)
+            is NavTarget.LoginFlow -> {
+                loginEntryPoint.nodeBuilder(this, buildContext)
+                    .params(LoginEntryPoint.Params(isAccountCreation = navTarget.isAccountCreation))
+                    .build()
             }
         }
     }

features/leaveroom/impl/src/test/kotlin/io/element/android/features/leaveroom/impl/LeaveRoomPresenterImplTest.kt

@@ -213,5 +213,5 @@ private fun TestScope.createPresenter(
 ): LeaveRoomPresenter = LeaveRoomPresenterImpl(
     client = client,
     roomMembershipObserver = roomMembershipObserver,
-    dispatchers = testCoroutineDispatchers(testScheduler, false),
+    dispatchers = testCoroutineDispatchers(false),
 )

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

@@ -16,6 +16,19 @@
 
 package io.element.android.features.login.api
 
-import io.element.android.libraries.architecture.SimpleFeatureEntryPoint
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import io.element.android.libraries.architecture.FeatureEntryPoint
 
-interface LoginEntryPoint : SimpleFeatureEntryPoint
+interface LoginEntryPoint : FeatureEntryPoint {
+    data class Params(
+        val isAccountCreation: Boolean,
+    )
+
+    fun nodeBuilder(parentNode: Node, buildContext: BuildContext): NodeBuilder
+
+    interface NodeBuilder {
+        fun params(params: Params): NodeBuilder
+        fun build(): Node
+    }
+}

features/login/impl/build.gradle.kts

@@ -19,6 +19,7 @@ plugins {
     alias(libs.plugins.anvil)
     alias(libs.plugins.ksp)
     id("kotlin-parcelize")
+    kotlin("plugin.serialization") version "1.8.21"
 }
 
 android {
@@ -41,11 +42,15 @@ dependencies {
     implementation(projects.libraries.core)
     implementation(projects.libraries.architecture)
     implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.network)
     implementation(projects.libraries.designsystem)
     implementation(projects.libraries.elementresources)
     implementation(projects.libraries.testtags)
     implementation(projects.libraries.uiStrings)
     implementation(libs.androidx.browser)
+    implementation(libs.network.retrofit)
+    implementation(libs.serialization.json)
     api(projects.features.login.api)
     ksp(libs.showkase.processor)
 
@@ -55,6 +60,7 @@ dependencies {
     testImplementation(libs.test.truth)
     testImplementation(libs.test.turbine)
     testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.tests.testutils)
 
     androidTestImplementation(libs.test.junitext)
 }

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

@@ -18,6 +18,7 @@ package io.element.android.features.login.impl
 
 import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
 import com.squareup.anvil.annotations.ContributesBinding
 import io.element.android.features.login.api.LoginEntryPoint
 import io.element.android.libraries.architecture.createNode
@@ -26,7 +27,19 @@ import javax.inject.Inject
 
 @ContributesBinding(AppScope::class)
 class DefaultLoginEntryPoint @Inject constructor() : LoginEntryPoint {
-    override fun createNode(parentNode: Node, buildContext: BuildContext): Node {
-        return parentNode.createNode<LoginFlowNode>(buildContext)
+    override fun nodeBuilder(parentNode: Node, buildContext: BuildContext): LoginEntryPoint.NodeBuilder {
+        val plugins = ArrayList<Plugin>()
+
+        return object : LoginEntryPoint.NodeBuilder {
+
+            override fun params(params: LoginEntryPoint.Params): LoginEntryPoint.NodeBuilder {
+                plugins += LoginFlowNode.Inputs(isAccountCreation = params.isAccountCreation)
+                return this
+            }
+
+            override fun build(): Node {
+                return parentNode.createNode<LoginFlowNode>(buildContext, plugins)
+            }
+        }
     }
 }

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

@@ -20,7 +20,6 @@ import android.app.Activity
 import android.os.Parcelable
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import com.bumble.appyx.core.composable.Children
@@ -29,17 +28,23 @@ import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.plugin.Plugin
 import com.bumble.appyx.navmodel.backstack.BackStack
 import com.bumble.appyx.navmodel.backstack.operation.push
+import com.bumble.appyx.navmodel.backstack.operation.singleTop
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
-import io.element.android.features.login.impl.changeserver.ChangeServerNode
+import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
 import io.element.android.features.login.impl.oidc.CustomTabAvailabilityChecker
 import io.element.android.features.login.impl.oidc.customtab.CustomTabHandler
 import io.element.android.features.login.impl.oidc.webview.OidcNode
-import io.element.android.features.login.impl.root.LoginRootNode
+import io.element.android.features.login.impl.screens.changeaccountprovider.ChangeAccountProviderNode
+import io.element.android.features.login.impl.screens.confirmaccountprovider.ConfirmAccountProviderNode
+import io.element.android.features.login.impl.screens.loginpassword.LoginPasswordNode
+import io.element.android.features.login.impl.screens.searchaccountprovider.SearchAccountProviderNode
 import io.element.android.libraries.architecture.BackstackNode
+import io.element.android.libraries.architecture.NodeInputs
 import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
 import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.architecture.inputs
 import io.element.android.libraries.designsystem.theme.ElementTheme
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.matrix.api.auth.OidcDetails
@@ -51,9 +56,10 @@ class LoginFlowNode @AssistedInject constructor(
     @Assisted plugins: List<Plugin>,
     private val customTabAvailabilityChecker: CustomTabAvailabilityChecker,
     private val customTabHandler: CustomTabHandler,
+    private val accountProviderDataSource: AccountProviderDataSource,
 ) : BackstackNode<LoginFlowNode.NavTarget>(
     backstack = BackStack(
-        initialElement = NavTarget.Root,
+        initialElement = NavTarget.ConfirmAccountProvider,
         savedStateMap = buildContext.savedStateMap,
     ),
     buildContext = buildContext,
@@ -62,12 +68,24 @@ class LoginFlowNode @AssistedInject constructor(
     private var activity: Activity? = null
     private var darkTheme: Boolean = false
 
+    data class Inputs(
+        val isAccountCreation: Boolean,
+    ) : NodeInputs
+
+    private val inputs: Inputs = inputs()
+
     sealed interface NavTarget : Parcelable {
         @Parcelize
-        object Root : NavTarget
+        object ConfirmAccountProvider : NavTarget
 
         @Parcelize
-        object ChangeServer : NavTarget
+        object ChangeAccountProvider : NavTarget
+
+        @Parcelize
+        object SearchAccountProvider : NavTarget
+
+        @Parcelize
+        object LoginPassword : NavTarget
 
         @Parcelize
         data class OidcView(val oidcDetails: OidcDetails) : NavTarget
@@ -75,12 +93,11 @@ class LoginFlowNode @AssistedInject constructor(
 
     override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
         return when (navTarget) {
-            NavTarget.Root -> {
-                val callback = object : LoginRootNode.Callback {
-                    override fun onChangeHomeServer() {
-                        backstack.push(NavTarget.ChangeServer)
-                    }
-
+            NavTarget.ConfirmAccountProvider -> {
+                val inputs = ConfirmAccountProviderNode.Inputs(
+                    isAccountCreation = inputs.isAccountCreation
+                )
+                val callback = object : ConfirmAccountProviderNode.Callback {
                     override fun onOidcDetails(oidcDetails: OidcDetails) {
                         if (customTabAvailabilityChecker.supportCustomTab()) {
                             // In this case open a Chrome Custom tab
@@ -90,11 +107,44 @@ class LoginFlowNode @AssistedInject constructor(
                             backstack.push(NavTarget.OidcView(oidcDetails))
                         }
                     }
-                }
-                createNode<LoginRootNode>(buildContext, plugins = listOf(callback))
-            }
 
-            NavTarget.ChangeServer -> createNode<ChangeServerNode>(buildContext)
+                    override fun onLoginPasswordNeeded() {
+                        backstack.push(NavTarget.LoginPassword)
+                    }
+
+                    override fun onChangeAccountProvider() {
+                        backstack.push(NavTarget.ChangeAccountProvider)
+                    }
+                }
+                createNode<ConfirmAccountProviderNode>(buildContext, plugins = listOf(inputs, callback))
+            }
+            NavTarget.ChangeAccountProvider -> {
+                val callback = object : ChangeAccountProviderNode.Callback {
+                    override fun onDone() {
+                        // Go back to the Account Provider screen
+                        backstack.singleTop(NavTarget.ConfirmAccountProvider)
+                    }
+
+                    override fun onOtherClicked() {
+                        backstack.push(NavTarget.SearchAccountProvider)
+                    }
+                }
+
+                createNode<ChangeAccountProviderNode>(buildContext, plugins = listOf(callback))
+            }
+            NavTarget.SearchAccountProvider -> {
+                val callback = object : SearchAccountProviderNode.Callback {
+                    override fun onDone() {
+                        // Go back to the Account Provider screen
+                        backstack.singleTop(NavTarget.ConfirmAccountProvider)
+                    }
+                }
+
+                createNode<SearchAccountProviderNode>(buildContext, plugins = listOf(callback))
+            }
+            NavTarget.LoginPassword -> {
+                createNode<LoginPasswordNode>(buildContext, plugins = listOf())
+            }
             is NavTarget.OidcView -> {
                 val input = OidcNode.Inputs(navTarget.oidcDetails)
                 createNode<OidcNode>(buildContext, plugins = listOf(input))
@@ -109,6 +159,7 @@ class LoginFlowNode @AssistedInject constructor(
         DisposableEffect(Unit) {
             onDispose {
                 activity = null
+                accountProviderDataSource.reset()
             }
         }
         Children(

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.accountprovider
+
+data class AccountProvider constructor(
+    val title: String,
+    val subtitle: String? = null,
+    val isPublic: Boolean = false,
+    val isMatrixOrg: Boolean = false,
+    val isValid: Boolean = false,
+    val supportSlidingSync: Boolean = false,
+)

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.accountprovider
+
+import io.element.android.features.login.impl.util.defaultAccountProvider
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.SingleIn
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import javax.inject.Inject
+
+@SingleIn(AppScope::class)
+class AccountProviderDataSource @Inject constructor(
+) {
+    private val accountProvider: MutableStateFlow<AccountProvider> = MutableStateFlow(
+        defaultAccountProvider
+    )
+
+    fun flow(): StateFlow<AccountProvider> {
+        return accountProvider.asStateFlow()
+    }
+
+    fun reset() {
+        accountProvider.tryEmit(defaultAccountProvider)
+    }
+
+    fun userSelection(data: AccountProvider) {
+        accountProvider.tryEmit(data)
+    }
+}

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

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.accountprovider
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+
+open class AccountProviderProvider : PreviewParameterProvider<AccountProvider> {
+    override val values: Sequence<AccountProvider>
+        get() = sequenceOf(
+            anAccountProvider(),
+            anAccountProvider().copy(subtitle = null),
+            anAccountProvider().copy(subtitle = null, title = "no.sliding.sync", supportSlidingSync = false),
+            anAccountProvider().copy(subtitle = null, title = "invalid", isValid = false, supportSlidingSync = false),
+            anAccountProvider().copy(subtitle = null, title = "Other", isPublic = false, isMatrixOrg = false),
+            // Add other state here
+        )
+}
+
+fun anAccountProvider() = AccountProvider(
+    title = "matrix.org",
+    subtitle = "Matrix.org is an open network for secure, decentralized communication.",
+    isPublic = true,
+    isMatrixOrg = true,
+    isValid = true,
+    supportSlidingSync = true,
+)

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

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.accountprovider
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+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.material.icons.Icons
+import androidx.compose.material.icons.filled.Search
+import androidx.compose.material3.MaterialTheme
+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.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.features.login.impl.R
+import io.element.android.libraries.designsystem.ElementTextStyles
+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.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.Divider
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.Text
+
+/**
+ * https://www.figma.com/file/o9p34zmiuEpZRyvZXJZAYL/FTUE?type=design&node-id=604-60817
+ */
+@Composable
+fun AccountProviderView(
+    item: AccountProvider,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit,
+) {
+    Column(modifier = modifier
+        .fillMaxWidth()
+        .clickable { onClick() }) {
+        Divider()
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(vertical = 4.dp, horizontal = 16.dp)
+        ) {
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .heightIn(min = 44.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                if (item.isMatrixOrg) {
+                    RoundedIconAtom(
+                        size = RoundedIconAtomSize.Medium,
+                        resourceId = R.drawable.ic_matrix,
+                        tint = Color.Unspecified,
+                    )
+                } else {
+                    RoundedIconAtom(
+                        size = RoundedIconAtomSize.Medium,
+                        imageVector = Icons.Filled.Search,
+                        tint = MaterialTheme.colorScheme.primary,
+                    )
+                }
+                Text(
+                    modifier = Modifier
+                        .padding(start = 16.dp)
+                        .weight(1f),
+                    text = item.title,
+                    style = ElementTextStyles.Regular.headline.copy(textAlign = TextAlign.Start),
+                    color = MaterialTheme.colorScheme.primary,
+                )
+                if (item.isPublic) {
+                    Icon(
+                        modifier = Modifier
+                            .padding(start = 10.dp)
+                            .size(16.dp),
+                        resourceId = R.drawable.ic_public,
+                        contentDescription = null,
+                        tint = Color.Unspecified,
+                    )
+                }
+            }
+            if (item.subtitle != null) {
+                Text(
+                    modifier = Modifier
+                        .padding(start = 46.dp, bottom = 12.dp, end = 26.dp),
+                    text = item.subtitle,
+                    style = ElementTextStyles.Regular.subheadline.copy(textAlign = TextAlign.Start),
+                    color = MaterialTheme.colorScheme.secondary,
+                )
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+fun AccountProviderViewLightPreview(@PreviewParameter(AccountProviderProvider::class) item: AccountProvider) =
+    ElementPreviewLight { ContentToPreview(item) }
+
+@Preview
+@Composable
+fun AccountProviderViewDarkPreview(@PreviewParameter(AccountProviderProvider::class) item: AccountProvider) =
+    ElementPreviewDark { ContentToPreview(item) }
+
+@Composable
+private fun ContentToPreview(item: AccountProvider) {
+    AccountProviderView(
+        item = item,
+        onClick = { }
+    )
+}

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

@@ -16,8 +16,9 @@
 
 package io.element.android.features.login.impl.changeserver
 
+import io.element.android.features.login.impl.accountprovider.AccountProvider
+
 sealed interface ChangeServerEvents {
-    data class SetServer(val server: String) : ChangeServerEvents
-    object Submit : ChangeServerEvents
+    data class ChangeServer(val accountProvider: AccountProvider) : ChangeServerEvents
     object ClearError : ChangeServerEvents
 }

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

@@ -21,8 +21,9 @@ import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.saveable.rememberSaveable
-import io.element.android.features.login.impl.util.LoginConstants
+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.libraries.architecture.Async
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.architecture.execute
@@ -33,44 +34,43 @@ import kotlinx.coroutines.launch
 import java.net.URL
 import javax.inject.Inject
 
-class ChangeServerPresenter @Inject constructor(private val authenticationService: MatrixAuthenticationService) : Presenter<ChangeServerState> {
+class ChangeServerPresenter @Inject constructor(
+    private val authenticationService: MatrixAuthenticationService,
+    private val accountProviderDataSource: AccountProviderDataSource,
+) : Presenter<ChangeServerState> {
 
     @Composable
     override fun present(): ChangeServerState {
         val localCoroutineScope = rememberCoroutineScope()
 
-        val homeserver = rememberSaveable {
-            mutableStateOf(authenticationService.getHomeserverDetails().value?.url ?: LoginConstants.DEFAULT_HOMESERVER_URL)
-        }
         val changeServerAction: MutableState<Async<Unit>> = remember {
             mutableStateOf(Async.Uninitialized)
         }
 
         fun handleEvents(event: ChangeServerEvents) {
             when (event) {
-                is ChangeServerEvents.SetServer -> {
-                    homeserver.value = event.server
-                    handleEvents(ChangeServerEvents.ClearError)
-                }
-                ChangeServerEvents.Submit -> {
-                    localCoroutineScope.submit(homeserver, changeServerAction)
-                }
+                is ChangeServerEvents.ChangeServer -> localCoroutineScope.changeServer(event.accountProvider, changeServerAction)
                 ChangeServerEvents.ClearError -> changeServerAction.value = Async.Uninitialized
             }
         }
 
         return ChangeServerState(
-            homeserver = homeserver.value,
             changeServerAction = changeServerAction.value,
             eventSink = ::handleEvents
         )
     }
 
-    private fun CoroutineScope.submit(homeserverUrl: MutableState<String>, changeServerAction: MutableState<Async<Unit>>) = launch {
+    private fun CoroutineScope.changeServer(
+        data: AccountProvider,
+        changeServerAction: MutableState<Async<Unit>>,
+    ) = launch {
         suspend {
-            val domain = tryOrNull { URL(homeserverUrl.value) }?.host ?: homeserverUrl.value
-            authenticationService.setHomeserver(domain).getOrThrow()
-            homeserverUrl.value = domain
+            val domain = tryOrNull { URL(data.title) }?.host ?: data.title
+            authenticationService.setHomeserver(domain).map {
+                authenticationService.getHomeserverDetails().value!!
+                // Valid, remember user choice
+                accountProviderDataSource.userSelection(data)
+            }.getOrThrow()
         }.execute(changeServerAction, errorMapping = ChangeServerError::from)
     }
 }

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

@@ -19,9 +19,6 @@ package io.element.android.features.login.impl.changeserver
 import io.element.android.libraries.architecture.Async
 
 data class ChangeServerState(
-    val homeserver: String,
     val changeServerAction: Async<Unit>,
-    val eventSink: (ChangeServerEvents) -> Unit,
-) {
-    val submitEnabled: Boolean get() = homeserver.isNotEmpty() && (changeServerAction is Async.Uninitialized || changeServerAction is Async.Loading)
-}
+    val eventSink: (ChangeServerEvents) -> Unit
+)

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

@@ -17,26 +17,16 @@
 package io.element.android.features.login.impl.changeserver
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.features.login.impl.R
 import io.element.android.libraries.architecture.Async
 
 open class ChangeServerStateProvider : PreviewParameterProvider<ChangeServerState> {
     override val values: Sequence<ChangeServerState>
         get() = sequenceOf(
             aChangeServerState(),
-            aChangeServerState().copy(homeserver = "matrix.org"),
-            aChangeServerState().copy(homeserver = "matrix.org", changeServerAction = Async.Loading()),
-            aChangeServerState().copy(
-                homeserver = "invalid.org",
-                changeServerAction = Async.Failure(ChangeServerError.InlineErrorMessage(R.string.screen_change_server_error_invalid_homeserver))
-            ),
-            aChangeServerState().copy(homeserver = "invalid.org", changeServerAction = Async.Failure(ChangeServerError.SlidingSyncAlert)),
-            aChangeServerState().copy(homeserver = "matrix.org", changeServerAction = Async.Success(Unit)),
         )
 }
 
 fun aChangeServerState() = ChangeServerState(
-    homeserver = "",
     changeServerAction = Async.Uninitialized,
     eventSink = {}
 )

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 New Vector Ltd
+ * Copyright (c) 2023 New Vector Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,276 +16,74 @@
 
 package io.element.android.features.login.impl.changeserver
 
-import androidx.compose.foundation.background
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.consumeWindowInsets
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.imePadding
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Close
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.ExperimentalTextApi
-import androidx.compose.ui.text.ParagraphStyle
-import androidx.compose.ui.text.SpanStyle
-import androidx.compose.ui.text.UrlAnnotation
-import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.KeyboardType
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
-import androidx.compose.ui.unit.dp
-import io.element.android.features.login.impl.R
-import io.element.android.features.login.impl.util.LoginConstants
+import io.element.android.features.login.impl.dialogs.SlidingSyncNotSupportedDialog
+import io.element.android.features.login.impl.error.ChangeServerError
 import io.element.android.libraries.architecture.Async
-import io.element.android.libraries.designsystem.ElementTextStyles
-import io.element.android.libraries.designsystem.LinkColor
-import io.element.android.libraries.designsystem.components.ClickableLinkText
-import io.element.android.libraries.designsystem.components.button.BackButton
-import io.element.android.libraries.designsystem.components.button.ButtonWithProgress
-import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
-import io.element.android.libraries.designsystem.components.form.textFieldState
+import io.element.android.libraries.designsystem.components.ProgressDialog
+import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
-import io.element.android.libraries.designsystem.theme.LocalColors
-import io.element.android.libraries.designsystem.theme.components.Icon
-import io.element.android.libraries.designsystem.theme.components.IconButton
-import io.element.android.libraries.designsystem.theme.components.Scaffold
-import io.element.android.libraries.designsystem.theme.components.Text
-import io.element.android.libraries.designsystem.theme.components.TextField
-import io.element.android.libraries.designsystem.theme.components.TopAppBar
-import io.element.android.libraries.designsystem.theme.components.onTabOrEnterKeyFocusNext
-import io.element.android.libraries.testtags.TestTags
-import io.element.android.libraries.testtags.testTag
-import io.element.android.libraries.ui.strings.R as StringR
 
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalTextApi::class, ExperimentalLayoutApi::class)
 @Composable
 fun ChangeServerView(
     state: ChangeServerState,
     onLearnMoreClicked: () -> Unit,
-    onBackPressed: () -> Unit,
+    onDone: () -> Unit,
     modifier: Modifier = Modifier,
-    onChangeServerSuccess: () -> Unit = {},
 ) {
     val eventSink = state.eventSink
-    val scrollState = rememberScrollState()
-    val isLoading by remember(state.changeServerAction) {
-        derivedStateOf {
-            state.changeServerAction is Async.Loading
-        }
-    }
-    val invalidHomeserverError = (state.changeServerAction as? Async.Failure)?.error as? ChangeServerError.InlineErrorMessage
-    val slidingSyncNotSupportedError = (state.changeServerAction as? Async.Failure)?.error as? ChangeServerError.SlidingSyncAlert
-    val focusManager = LocalFocusManager.current
-
-    fun submit() {
-        // Clear focus to prevent keyboard issues with textfields
-        focusManager.clearFocus(force = true)
-
-        eventSink(ChangeServerEvents.Submit)
-    }
-
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = {},
-                navigationIcon = { BackButton(onClick = onBackPressed) }
-            )
-        }
-    ) { padding ->
-        Box(
-            modifier = modifier
-                .fillMaxSize()
-                .imePadding()
-                .padding(padding)
-                .consumeWindowInsets(padding)
-        ) {
-            Column(
-                modifier = Modifier
-                    .verticalScroll(
-                        state = scrollState,
-                    )
-                    .padding(horizontal = 16.dp)
-            ) {
-                Spacer(Modifier.height(42.dp))
-                Box(
-                    modifier = Modifier
-                        .size(width = 70.dp, height = 70.dp)
-                        .align(Alignment.CenterHorizontally)
-                        .background(
-                            color = LocalColors.current.quinary,
-                            shape = RoundedCornerShape(14.dp)
-                        )
-                ) {
-                    Icon(
-                        modifier = Modifier
-                            .align(Alignment.Center)
-                            .size(width = 32.dp, height = 32.dp),
-                        tint = MaterialTheme.colorScheme.secondary,
-                        resourceId = R.drawable.ic_homeserver,
-                        contentDescription = "",
+    when (state.changeServerAction) {
+        is Async.Failure -> {
+            when (val error = state.changeServerAction.error) {
+                is ChangeServerError.Error -> {
+                    ErrorDialog(
+                        modifier = modifier,
+                        content = error.message(),
+                        onDismiss = {
+                            eventSink.invoke(ChangeServerEvents.ClearError)
+                        }
                     )
                 }
-                Spacer(modifier = Modifier.height(16.dp))
-                Text(
-                    text = stringResource(id = R.string.screen_change_server_title),
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .align(Alignment.CenterHorizontally),
-                    textAlign = TextAlign.Center,
-                    style = ElementTextStyles.Bold.title2,
-                    color = MaterialTheme.colorScheme.primary,
-                )
-                Spacer(Modifier.height(8.dp))
-                Text(
-                    text = stringResource(id = R.string.screen_change_server_subtitle),
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 16.dp),
-                    textAlign = TextAlign.Center,
-                    style = ElementTextStyles.Regular.subheadline,
-                    color = MaterialTheme.colorScheme.secondary,
-                )
-                Spacer(Modifier.height(24.dp))
-                Text(
-                    stringResource(R.string.screen_change_server_form_header),
-                    style = ElementTextStyles.Regular.formHeader,
-                    modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
-                )
-                var homeserverFieldState by textFieldState(stateValue = state.homeserver)
-                TextField(
-                    value = homeserverFieldState,
-                    readOnly = isLoading,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .testTag(TestTags.changeServerServer)
-                        .onTabOrEnterKeyFocusNext(focusManager),
-                    onValueChange = {
-                        homeserverFieldState = it
-                        eventSink(ChangeServerEvents.SetServer(it))
-                    },
-                    keyboardOptions = KeyboardOptions(
-                        keyboardType = KeyboardType.Password,
-                        imeAction = ImeAction.Done,
-                    ),
-                    keyboardActions = KeyboardActions(
-                        onDone = { submit() }
-                    ),
-                    singleLine = true,
-                    maxLines = 1,
-                    trailingIcon = if (homeserverFieldState.isNotEmpty()) {
-                        {
-                            IconButton(onClick = {
-                                eventSink(ChangeServerEvents.SetServer(""))
-                            }, enabled = !isLoading) {
-                                Icon(imageVector = Icons.Filled.Close, contentDescription = stringResource(StringR.string.action_clear))
-                            }
-                        }
-                    } else null,
-                    isError = invalidHomeserverError != null,
-                    supportingText = {
-                        if (invalidHomeserverError != null) {
-                            Text(invalidHomeserverError.message(), color = MaterialTheme.colorScheme.error)
-                        } else {
-                            val footerMessage = stringResource(R.string.screen_change_server_form_notice, "")
-                            val footerAction = stringResource(StringR.string.action_learn_more)
-                            val footerText = buildAnnotatedString {
-                                val defaultColor = MaterialTheme.colorScheme.tertiary
-                                withStyle(ParagraphStyle(textAlign = TextAlign.Start)) {
-                                    withStyle(SpanStyle(color = defaultColor)) {
-                                        append(footerMessage)
-                                    }
-                                    val start = length
-                                    withStyle(SpanStyle(color = LinkColor)) {
-                                        append(footerAction)
-                                    }
-                                    addUrlAnnotation(UrlAnnotation(LoginConstants.SLIDING_SYNC_READ_MORE_URL), start, length)
-                                }
-                            }
-                            ClickableLinkText(
-                                text = footerText,
-                                interactionSource = MutableInteractionSource(),
-                                style = ElementTextStyles.Regular.caption1,
-                            )
-                        }
-                    }
-
-                )
-                if (slidingSyncNotSupportedError != null) {
-                    SlidingSyncNotSupportedDialog(onLearnMoreClicked = {
-                        onLearnMoreClicked()
-                        eventSink(ChangeServerEvents.ClearError)
-                    }, onDismiss = {
-                        eventSink(ChangeServerEvents.ClearError)
+                is ChangeServerError.SlidingSyncAlert -> {
+                    SlidingSyncNotSupportedDialog(
+                        modifier = modifier,
+                        onLearnMoreClicked = {
+                            onLearnMoreClicked()
+                            eventSink.invoke(ChangeServerEvents.ClearError)
+                        }, onDismiss = {
+                        eventSink.invoke(ChangeServerEvents.ClearError)
                     })
                 }
-                Spacer(Modifier.height(32.dp))
-                ButtonWithProgress(
-                    text = stringResource(id = R.string.screen_change_server_submit),
-                    showProgress = isLoading,
-                    onClick = ::submit,
-                    enabled = state.submitEnabled,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .testTag(TestTags.changeServerContinue)
-                )
-                if (state.changeServerAction is Async.Success) {
-                    onChangeServerSuccess()
-                }
             }
         }
+        is Async.Loading -> ProgressDialog()
+        is Async.Success -> LaunchedEffect(state.changeServerAction) {
+            onDone()
+        }
+        Async.Uninitialized -> Unit
     }
 }
 
-@Composable
-internal fun SlidingSyncNotSupportedDialog(onLearnMoreClicked: () -> Unit, onDismiss: () -> Unit) {
-    ConfirmationDialog(
-        onDismiss = onDismiss,
-        submitText = stringResource(StringR.string.action_learn_more),
-        onSubmitClicked = onLearnMoreClicked,
-        onCancelClicked = onDismiss,
-        emphasizeSubmitButton = true,
-        title = stringResource(StringR.string.dialog_title_error),
-        content = stringResource(R.string.screen_change_server_error_no_sliding_sync_message),
-    )
-}
-
 @Preview
 @Composable
-internal fun ChangeServerViewLightPreview(@PreviewParameter(ChangeServerStateProvider::class) state: ChangeServerState) =
+fun ChangeServerViewLightPreview(@PreviewParameter(ChangeServerStateProvider::class) state: ChangeServerState) =
     ElementPreviewLight { ContentToPreview(state) }
 
 @Preview
 @Composable
-internal fun ChangeServerViewDarkPreview(@PreviewParameter(ChangeServerStateProvider::class) state: ChangeServerState) =
+fun ChangeServerViewDarkPreview(@PreviewParameter(ChangeServerStateProvider::class) state: ChangeServerState) =
     ElementPreviewDark { ContentToPreview(state) }
 
 @Composable
 private fun ContentToPreview(state: ChangeServerState) {
-    ChangeServerView(state = state, onBackPressed = {}, onLearnMoreClicked = {})
+    ChangeServerView(
+        state = state,
+        onLearnMoreClicked = {},
+        onDone = {},
+    )
 }

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.dialogs
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import io.element.android.features.login.impl.R
+import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
+import io.element.android.libraries.ui.strings.R as StringR
+
+@Composable
+internal fun SlidingSyncNotSupportedDialog(
+    onLearnMoreClicked: () -> Unit,
+    onDismiss: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ConfirmationDialog(
+        modifier = modifier,
+        onDismiss = onDismiss,
+        submitText = stringResource(StringR.string.action_learn_more),
+        onSubmitClicked = onLearnMoreClicked,
+        onCancelClicked = onDismiss,
+        emphasizeSubmitButton = true,
+        title = stringResource(StringR.string.dialog_title_error),
+        content = stringResource(R.string.screen_change_server_error_no_sliding_sync_message),
+    )
+}

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.element.android.features.login.impl.changeserver
+package io.element.android.features.login.impl.error
 
 import androidx.annotation.StringRes
 import androidx.compose.runtime.Composable
@@ -23,7 +23,7 @@ import io.element.android.features.login.impl.R
 import io.element.android.libraries.matrix.api.auth.AuthenticationException
 
 sealed class ChangeServerError : Throwable() {
-    data class InlineErrorMessage(@StringRes val messageId: Int) : ChangeServerError() {
+    data class Error(@StringRes val messageId: Int) : ChangeServerError() {
         @Composable
         fun message(): String = stringResource(messageId)
     }
@@ -32,7 +32,7 @@ sealed class ChangeServerError : Throwable() {
     companion object {
         fun from(error: Throwable): ChangeServerError = when (error) {
             is AuthenticationException.SlidingSyncNotAvailable -> SlidingSyncAlert
-            else -> InlineErrorMessage(R.string.screen_change_server_error_invalid_homeserver)
+            else -> Error(R.string.screen_change_server_error_invalid_homeserver)
         }
     }
 }

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

@@ -16,19 +16,21 @@
 
 package io.element.android.features.login.impl.error
 
+import androidx.annotation.StringRes
 import io.element.android.features.login.impl.R
 import io.element.android.libraries.matrix.api.auth.AuthErrorCode
 import io.element.android.libraries.matrix.api.auth.AuthenticationException
 import io.element.android.libraries.matrix.api.auth.errorCode
-import io.element.android.libraries.ui.strings.R.string as StringR
+import io.element.android.libraries.ui.strings.R as StringR
 
+@StringRes
 fun loginError(
     throwable: Throwable
 ): Int {
-    val authException = throwable as? AuthenticationException ?: return StringR.error_unknown
+    val authException = throwable as? AuthenticationException ?: return StringR.string.error_unknown
     return when (authException.errorCode) {
         AuthErrorCode.FORBIDDEN -> R.string.screen_login_error_invalid_credentials
         AuthErrorCode.USER_DEACTIVATED -> R.string.screen_login_error_deactivated_account
-        AuthErrorCode.UNKNOWN -> StringR.error_unknown
+        AuthErrorCode.UNKNOWN -> StringR.string.error_unknown
     }
 }

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.resolver
+
+data class HomeserverData constructor(
+    // The computed homeserver url, for which a wellknown file has been retrieved, or just a valid Url
+    val homeserverUrl: String,
+    // True if a wellknown file has been found and is valid. If false, it means that the [homeserverUrl] is valid
+    val isWellknownValid: Boolean,
+    // True if a wellknown file has been found and is valid and is claiming a sliding sync Url
+    val supportSlidingSync: Boolean,
+)

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.resolver
+
+import io.element.android.features.login.impl.resolver.network.WellknownRequest
+import io.element.android.libraries.core.bool.orFalse
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.core.data.tryOrNull
+import io.element.android.libraries.core.uri.ensureProtocol
+import io.element.android.libraries.core.uri.isValidUrl
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+import java.util.Collections
+import javax.inject.Inject
+
+/**
+ * Resolve homeserver base on search terms.
+ */
+class HomeserverResolver @Inject constructor(
+    private val dispatchers: CoroutineDispatchers,
+    private val wellknownRequest: WellknownRequest,
+) {
+
+    suspend fun resolve(userInput: String): Flow<List<HomeserverData>> = flow {
+        val flowContext = currentCoroutineContext()
+        val trimmedUserInput = userInput.trim()
+        if (trimmedUserInput.length < 4) return@flow
+        val candidateBase = trimmedUserInput.ensureProtocol().removeSuffix("/")
+        val list = getUrlCandidates(candidateBase)
+        val currentList = Collections.synchronizedList(mutableListOf<HomeserverData>())
+        // Run all the requests in parallel
+        withContext(dispatchers.io) {
+            list.map { url ->
+                async {
+                    val wellKnown = tryOrNull {
+                        withTimeout(5000) {
+                            wellknownRequest.execute(url)
+                        }
+                    }
+                    val isValid = wellKnown?.isValid().orFalse()
+                    if (isValid) {
+                        val supportSlidingSync = wellKnown?.supportSlidingSync().orFalse()
+                        // Emit the list as soon as possible
+                        currentList.add(
+                            HomeserverData(
+                                homeserverUrl = url,
+                                isWellknownValid = true,
+                                supportSlidingSync = supportSlidingSync
+                            )
+                        )
+                        withContext(flowContext) {
+                            emit(currentList.toList())
+                        }
+                    }
+                }
+            }.awaitAll()
+        }
+        // If list is empty, and the user has entered an URL, do not block the user.
+        if (currentList.isEmpty() && trimmedUserInput.isValidUrl()) {
+            emit(
+                listOf(
+                    HomeserverData(
+                        homeserverUrl = trimmedUserInput,
+                        isWellknownValid = false,
+                        supportSlidingSync = false,
+                    )
+                )
+            )
+        }
+    }
+
+    private fun getUrlCandidates(data: String): List<String> {
+        return buildList {
+            if (data.contains(".")) {
+                // TLD detected?
+            } else {
+                add("${data}.org")
+                add("${data}.com")
+                add("${data}.io")
+            }
+            // Always try what the user has entered
+            add(data)
+        }
+    }
+}

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/resolver/network/DefaultWellknownRequest.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.element.android.features.login.impl.resolver.network
+
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.network.RetrofitFactory
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultWellknownRequest @Inject constructor(
+    private val retrofitFactory: RetrofitFactory,
+) : WellknownRequest {
+    /**
+     * Return the WellKnown data, if found.
+     * @param baseUrl for instance https://matrix.org
+     */
+    override suspend fun execute(baseUrl: String): WellKnown {
+        val wellknownApi = retrofitFactory.create(baseUrl)
+            .create(WellknownAPI::class.java)
+        return wellknownApi.getWellKnown()
+    }
+}

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/resolver/network/WellKnown.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.resolver.network
+
+import io.element.android.libraries.core.bool.orFalse
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/**
+ * https://matrix.org/docs/spec/client_server/r0.4.0.html#server-discovery
+ * <pre>
+ * {
+ *     "m.homeserver": {
+ *         "base_url": "https://matrix.org"
+ *     },
+ *     "m.identity_server": {
+ *         "base_url": "https://vector.im"
+ *     },
+ *     "org.matrix.msc3575.proxy": {
+ *         "url": "https://slidingsync.lab.matrix.org"
+ *     }
+ * }
+ * </pre>
+ * .
+ */
+@Serializable
+data class WellKnown(
+    @SerialName("m.homeserver")
+    val homeServer: WellKnownBaseConfig? = null,
+
+    @SerialName("m.identity_server")
+    val identityServer: WellKnownBaseConfig? = null,
+
+    @SerialName("org.matrix.msc3575.proxy")
+    val slidingSyncProxy: WellKnownSlidingSyncConfig? = null,
+) {
+    fun isValid(): Boolean {
+        return homeServer?.baseURL?.isNotBlank().orFalse()
+    }
+
+    fun supportSlidingSync(): Boolean {
+        return slidingSyncProxy?.url?.isNotBlank().orFalse()
+    }
+}

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/resolver/network/WellKnownBaseConfig.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.resolver.network
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/**
+ * https://matrix.org/docs/spec/client_server/r0.4.0.html#server-discovery
+ * <pre>
+ * {
+ *     "base_url": "https://element.io"
+ * }
+ * </pre>
+ * .
+ */
+@Serializable
+data class WellKnownBaseConfig(
+        @SerialName("base_url")
+        val baseURL: String? = null
+)

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/resolver/network/WellKnownSlidingSyncConfig.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.resolver.network
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class WellKnownSlidingSyncConfig(
+        @SerialName("url")
+        val url: String? = null,
+)

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/resolver/network/WellknownAPI.kt

@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-package io.element.android.features.login.impl.root
+package io.element.android.features.login.impl.resolver.network
 
-sealed interface LoginRootEvents {
-    object RetryFetchServerInfo : LoginRootEvents
-    data class SetLogin(val login: String) : LoginRootEvents
-    data class SetPassword(val password: String) : LoginRootEvents
-    object Submit : LoginRootEvents
-    object ClearError : LoginRootEvents
+import retrofit2.http.GET
+
+internal interface WellknownAPI {
+    @GET(".well-known/matrix/client")
+    suspend fun getWellKnown(): WellKnown
 }

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/resolver/network/WellknownRequest.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.element.android.features.login.impl.resolver.network
+
+interface WellknownRequest {
+    /**
+     * Return the WellKnown data, or throw an error if not found.
+     * @param baseUrl for instance https://matrix.org
+     */
+    suspend fun execute(baseUrl: String): WellKnown
+}

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

@@ -1,171 +0,0 @@
-/*
- * Copyright (c) 2023 New Vector Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.element.android.features.login.impl.root
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.saveable.rememberSaveable
-import io.element.android.features.login.api.oidc.OidcAction
-import io.element.android.features.login.impl.oidc.customtab.DefaultOidcActionFlow
-import io.element.android.features.login.impl.util.LoginConstants
-import io.element.android.libraries.architecture.Async
-import io.element.android.libraries.architecture.Presenter
-import io.element.android.libraries.architecture.execute
-import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
-import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-class LoginRootPresenter @Inject constructor(
-    private val authenticationService: MatrixAuthenticationService,
-    private val defaultOidcActionFlow: DefaultOidcActionFlow,
-) : Presenter<LoginRootState> {
-
-    @Composable
-    override fun present(): LoginRootState {
-        val localCoroutineScope = rememberCoroutineScope()
-        val currentHomeServerDetails = authenticationService.getHomeserverDetails().collectAsState().value
-        val homeserver = currentHomeServerDetails?.url ?: LoginConstants.DEFAULT_HOMESERVER_URL
-        val getHomeServerDetailsAction: MutableState<Async<MatrixHomeServerDetails>> = remember {
-            if (currentHomeServerDetails != null) {
-                mutableStateOf(Async.Success(currentHomeServerDetails))
-            } else {
-                mutableStateOf(Async.Uninitialized)
-            }
-        }
-
-        LaunchedEffect(Unit) {
-            if (currentHomeServerDetails == null) {
-                getHomeServerDetails(homeserver, getHomeServerDetailsAction)
-            }
-        }
-
-        val loggedInState: MutableState<LoggedInState> = remember {
-            mutableStateOf(LoggedInState.NotLoggedIn)
-        }
-        val formState = rememberSaveable {
-            mutableStateOf(LoginFormState.Default)
-        }
-
-        LaunchedEffect(Unit) {
-            launch {
-                defaultOidcActionFlow.collect {
-                    onOidcAction(it, loggedInState)
-                }
-            }
-        }
-
-        fun handleEvents(event: LoginRootEvents) {
-            when (event) {
-                LoginRootEvents.RetryFetchServerInfo -> localCoroutineScope.getHomeServerDetails(homeserver, getHomeServerDetailsAction)
-                is LoginRootEvents.SetLogin -> updateFormState(formState) {
-                    copy(login = event.login)
-                }
-                is LoginRootEvents.SetPassword -> updateFormState(formState) {
-                    copy(password = event.password)
-                }
-                LoginRootEvents.Submit -> {
-                    val homeServerDetails = getHomeServerDetailsAction.value.dataOrNull() ?: return
-                    when {
-                        homeServerDetails.supportsOidcLogin -> localCoroutineScope.submitOidc(loggedInState)
-                        homeServerDetails.supportsPasswordLogin -> localCoroutineScope.submit(formState.value, loggedInState)
-                    }
-                }
-                LoginRootEvents.ClearError -> loggedInState.value = LoggedInState.NotLoggedIn
-            }
-        }
-
-        return LoginRootState(
-            homeserverUrl = homeserver,
-            homeserverDetails = getHomeServerDetailsAction.value,
-            loggedInState = loggedInState.value,
-            formState = formState.value,
-            eventSink = ::handleEvents
-        )
-    }
-
-    private fun CoroutineScope.getHomeServerDetails(
-        homeserver: String,
-        state: MutableState<Async<MatrixHomeServerDetails>>,
-    ) = launch {
-        suspend {
-            authenticationService.setHomeserver(homeserver)
-                .map {
-                    authenticationService.getHomeserverDetails().value!!
-                }
-                .getOrThrow()
-        }.execute(state)
-    }
-
-    private fun CoroutineScope.submitOidc(loggedInState: MutableState<LoggedInState>) = launch {
-        loggedInState.value = LoggedInState.LoggingIn
-        authenticationService.getOidcUrl()
-            .onSuccess {
-                loggedInState.value = LoggedInState.OidcStarted(it)
-            }
-            .onFailure { failure ->
-                loggedInState.value = LoggedInState.ErrorLoggingIn(failure)
-            }
-    }
-
-    private fun CoroutineScope.submit(formState: LoginFormState, loggedInState: MutableState<LoggedInState>) = launch {
-        loggedInState.value = LoggedInState.LoggingIn
-        authenticationService.login(formState.login.trim(), formState.password)
-            .onSuccess { sessionId ->
-                loggedInState.value = LoggedInState.LoggedIn(sessionId)
-            }
-            .onFailure { failure ->
-                loggedInState.value = LoggedInState.ErrorLoggingIn(failure)
-            }
-    }
-
-    private fun updateFormState(formState: MutableState<LoginFormState>, updateLambda: LoginFormState.() -> LoginFormState) {
-        formState.value = updateLambda(formState.value)
-    }
-
-    private suspend fun onOidcAction(oidcAction: OidcAction?, loggedInState: MutableState<LoggedInState>) {
-        oidcAction ?: return
-        loggedInState.value = LoggedInState.LoggingIn
-        when (oidcAction) {
-            OidcAction.GoBack -> {
-                authenticationService.cancelOidcLogin()
-                    .onSuccess {
-                        loggedInState.value = LoggedInState.NotLoggedIn
-                    }
-                    .onFailure { failure ->
-                        loggedInState.value = LoggedInState.ErrorLoggingIn(failure)
-                    }
-            }
-            is OidcAction.Success -> {
-                authenticationService.loginWithOidc(oidcAction.url)
-                    .onSuccess { sessionId ->
-                        loggedInState.value = LoggedInState.LoggedIn(sessionId)
-                    }
-                    .onFailure { failure ->
-                        loggedInState.value = LoggedInState.ErrorLoggingIn(failure)
-                    }
-            }
-        }
-        defaultOidcActionFlow.reset()
-    }
-}

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

@@ -1,76 +0,0 @@
-/*
- * Copyright (c) 2023 New Vector Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.element.android.features.login.impl.root
-
-import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.libraries.architecture.Async
-import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
-import io.element.android.libraries.matrix.api.core.SessionId
-
-open class LoginRootStateProvider : PreviewParameterProvider<LoginRootState> {
-    override val values: Sequence<LoginRootState>
-        get() = sequenceOf(
-            aLoginRootState(),
-            aLoginRootState().copy(
-                homeserverDetails = Async.Success(
-                    MatrixHomeServerDetails(
-                        "some-custom-server.com",
-                        supportsPasswordLogin = true,
-                        supportsOidcLogin = false
-                    )
-                )
-            ),
-            aLoginRootState().copy(formState = LoginFormState("user", "pass")),
-            aLoginRootState().copy(formState = LoginFormState("user", "pass"), loggedInState = LoggedInState.LoggingIn),
-            aLoginRootState().copy(formState = LoginFormState("user", "pass"), loggedInState = LoggedInState.ErrorLoggingIn(Throwable())),
-            aLoginRootState().copy(formState = LoginFormState("user", "pass"), loggedInState = LoggedInState.LoggedIn(SessionId("@user:domain"))),
-            // Oidc
-            aLoginRootState().copy(
-                homeserverUrl = "server-with-oidc.org",
-                homeserverDetails = Async.Success(
-                    MatrixHomeServerDetails(
-                        "server-with-oidc.org",
-                        supportsPasswordLogin = false,
-                        supportsOidcLogin = true
-                    )
-                )
-            ),
-            // No password, no oidc support
-            aLoginRootState().copy(
-                homeserverUrl = "wrong.org",
-                homeserverDetails = Async.Success(
-                    MatrixHomeServerDetails(
-                        "wrong.org",
-                        supportsPasswordLogin = false,
-                        supportsOidcLogin = false
-                    )
-                )
-            ),
-            // Loading
-            aLoginRootState().copy(homeserverDetails = Async.Loading()),
-            //Error
-            aLoginRootState().copy(homeserverDetails = Async.Failure(Exception("An error occurred"))),
-        )
-}
-
-fun aLoginRootState() = LoginRootState(
-    homeserverUrl = "matrix.org",
-    homeserverDetails = Async.Success(MatrixHomeServerDetails("matrix.org", supportsPasswordLogin = true, supportsOidcLogin = false)),
-    loggedInState = LoggedInState.NotLoggedIn,
-    formState = LoginFormState.Default,
-    eventSink = {}
-)

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/changeaccountprovider/ChangeAccountProviderNode.kt

@@ -14,49 +14,52 @@
  * limitations under the License.
  */
 
-package io.element.android.features.login.impl.changeserver
+package io.element.android.features.login.impl.screens.changeaccountprovider
 
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
-import io.element.android.features.login.impl.util.LoginConstants
-import io.element.android.libraries.core.data.tryOrNull
+import io.element.android.features.login.impl.util.openLearnMorePage
 import io.element.android.libraries.di.AppScope
 
 @ContributesNode(AppScope::class)
-class ChangeServerNode @AssistedInject constructor(
+class ChangeAccountProviderNode @AssistedInject constructor(
     @Assisted buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
-    private val presenter: ChangeServerPresenter,
+    private val presenter: ChangeAccountProviderPresenter,
 ) : Node(buildContext, plugins = plugins) {
-    private fun onSuccess() {
-        navigateUp()
+
+    interface Callback : Plugin {
+        fun onDone()
+        fun onOtherClicked()
     }
 
-    private fun openLearnMorePage(context: Context) {
-        val intent = Intent(Intent.ACTION_VIEW, Uri.parse(LoginConstants.SLIDING_SYNC_READ_MORE_URL))
-        tryOrNull { context.startActivity(intent) }
+    private fun onDone() {
+        plugins<Callback>().forEach { it.onDone() }
+    }
+
+    private fun onOtherClicked() {
+        plugins<Callback>().forEach { it.onOtherClicked() }
     }
 
     @Composable
     override fun View(modifier: Modifier) {
         val state = presenter.present()
         val context = LocalContext.current
-        ChangeServerView(
+        ChangeAccountProviderView(
             state = state,
             modifier = modifier,
-            onChangeServerSuccess = this::onSuccess,
-            onBackPressed = { navigateUp() },
+            onBackPressed = ::navigateUp,
             onLearnMoreClicked = { openLearnMorePage(context) },
+            onDone = ::onDone,
+            onOtherProviderClicked = ::onOtherClicked,
         )
     }
 }

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/changeaccountprovider/ChangeAccountProviderPresenter.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.changeaccountprovider
+
+import androidx.compose.runtime.Composable
+import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.features.login.impl.changeserver.ChangeServerPresenter
+import io.element.android.libraries.architecture.Presenter
+import javax.inject.Inject
+
+class ChangeAccountProviderPresenter @Inject constructor(
+    private val changeServerPresenter: ChangeServerPresenter,
+) : Presenter<ChangeAccountProviderState> {
+
+    @Composable
+    override fun present(): ChangeAccountProviderState {
+        val changeServerState = changeServerPresenter.present()
+        return ChangeAccountProviderState(
+            // Just matrix.org by default for now
+            accountProviders = listOf(
+                AccountProvider(
+                    title = "matrix.org",
+                    subtitle = null,
+                    isPublic = true,
+                    isMatrixOrg = true,
+                    isValid = true,
+                    supportSlidingSync = true,
+                )
+            ),
+            changeServerState = changeServerState,
+        )
+    }
+}

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/changeaccountprovider/ChangeAccountProviderState.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.changeaccountprovider
+
+import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.features.login.impl.changeserver.ChangeServerState
+
+// Do not use default value, so no member get forgotten in the presenters.
+data class ChangeAccountProviderState constructor(
+    val accountProviders: List<AccountProvider>,
+    val changeServerState: ChangeServerState,
+)

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/changeaccountprovider/ChangeAccountProviderStateProvider.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.changeaccountprovider
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.login.impl.accountprovider.anAccountProvider
+import io.element.android.features.login.impl.changeserver.aChangeServerState
+
+open class ChangeAccountProviderStateProvider : PreviewParameterProvider<ChangeAccountProviderState> {
+    override val values: Sequence<ChangeAccountProviderState>
+        get() = sequenceOf(
+            aChangeAccountProviderState(),
+            // Add other state here
+        )
+}
+
+fun aChangeAccountProviderState() = ChangeAccountProviderState(
+    accountProviders = listOf(
+        anAccountProvider()
+    ),
+    changeServerState = aChangeServerState(),
+)

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/changeaccountprovider/ChangeAccountProviderView.kt

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
+
+package io.element.android.features.login.impl.screens.changeaccountprovider
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Home
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.features.login.impl.R
+import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.features.login.impl.accountprovider.AccountProviderView
+import io.element.android.features.login.impl.changeserver.ChangeServerEvents
+import io.element.android.features.login.impl.changeserver.ChangeServerView
+import io.element.android.libraries.designsystem.atomic.molecules.IconTitleSubtitleMolecule
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.Scaffold
+import io.element.android.libraries.designsystem.theme.components.TopAppBar
+
+/**
+ * https://www.figma.com/file/o9p34zmiuEpZRyvZXJZAYL/FTUE?type=design&node-id=604-60817
+ */
+@Composable
+fun ChangeAccountProviderView(
+    state: ChangeAccountProviderState,
+    onBackPressed: () -> Unit,
+    onLearnMoreClicked: () -> Unit,
+    onDone: () -> Unit,
+    onOtherProviderClicked: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(
+                title = {},
+                navigationIcon = { BackButton(onClick = onBackPressed) }
+            )
+        }
+    ) { padding ->
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding()
+                .padding(padding)
+                .consumeWindowInsets(padding)
+        ) {
+            Column(
+                modifier = Modifier
+                    .verticalScroll(state = rememberScrollState())
+            ) {
+                IconTitleSubtitleMolecule(
+                    modifier = Modifier.padding(top = 16.dp, bottom = 32.dp, start = 16.dp, end = 16.dp),
+                    iconImageVector = Icons.Filled.Home,
+                    iconTint = MaterialTheme.colorScheme.primary,
+                    title = stringResource(id = R.string.screen_change_account_provider_title),
+                    subTitle = stringResource(id = R.string.screen_change_account_provider_subtitle),
+                )
+
+                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,
+                        onClick = {
+                            state.changeServerState.eventSink.invoke(ChangeServerEvents.ChangeServer(alteredItem))
+                        }
+                    )
+                }
+                // Other
+                AccountProviderView(
+                    item = AccountProvider(
+                        title = stringResource(id = R.string.screen_change_account_provider_other),
+                    ),
+                    onClick = onOtherProviderClicked
+                )
+                Spacer(Modifier.height(32.dp))
+            }
+            ChangeServerView(
+                state = state.changeServerState,
+                onLearnMoreClicked = onLearnMoreClicked,
+                onDone = onDone,
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+fun ChangeAccountProviderViewLightPreview(@PreviewParameter(ChangeAccountProviderStateProvider::class) state: ChangeAccountProviderState) =
+    ElementPreviewLight { ContentToPreview(state) }
+
+@Preview
+@Composable
+fun ChangeAccountProviderViewDarkPreview(@PreviewParameter(ChangeAccountProviderStateProvider::class) state: ChangeAccountProviderState) =
+    ElementPreviewDark { ContentToPreview(state) }
+
+@Composable
+private fun ContentToPreview(state: ChangeAccountProviderState) {
+    ChangeAccountProviderView(
+        state = state,
+        onBackPressed = { },
+        onLearnMoreClicked = { },
+        onDone = { },
+        onOtherProviderClicked = { },
+    )
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.confirmaccountprovider
+
+sealed interface ConfirmAccountProviderEvents {
+    object Continue : ConfirmAccountProviderEvents
+    object ClearError : ConfirmAccountProviderEvents
+}

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

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.confirmaccountprovider
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.login.impl.util.openLearnMorePage
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.architecture.inputs
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.matrix.api.auth.OidcDetails
+
+@ContributesNode(AppScope::class)
+class ConfirmAccountProviderNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    presenterFactory: ConfirmAccountProviderPresenter.Factory,
+) : Node(buildContext, plugins = plugins) {
+
+    data class Inputs(
+        val isAccountCreation: Boolean,
+    ) : NodeInputs
+
+    private val inputs: Inputs = inputs()
+    private val presenter = presenterFactory.create(
+        ConfirmAccountProviderPresenter.Params(
+            isAccountCreation = inputs.isAccountCreation,
+        )
+    )
+
+    interface Callback : Plugin {
+        fun onLoginPasswordNeeded()
+        fun onOidcDetails(oidcDetails: OidcDetails)
+        fun onChangeAccountProvider()
+    }
+
+    private fun onOidcDetails(data: OidcDetails) {
+        plugins<Callback>().forEach { it.onOidcDetails(data) }
+    }
+
+    private fun onLoginPasswordNeeded() {
+        plugins<Callback>().forEach { it.onLoginPasswordNeeded() }
+    }
+
+    private fun onChangeAccountProvider() {
+        plugins<Callback>().forEach { it.onChangeAccountProvider() }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        val context = LocalContext.current
+        ConfirmAccountProviderView(
+            state = state,
+            modifier = modifier,
+            onOidcDetails = ::onOidcDetails,
+            onLoginPasswordNeeded = ::onLoginPasswordNeeded,
+            onChange = ::onChangeAccountProvider,
+            onLearnMoreClicked = { openLearnMorePage(context) },
+        )
+    }
+}

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

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.confirmaccountprovider
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
+import io.element.android.features.login.impl.error.ChangeServerError
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.architecture.execute
+import io.element.android.libraries.core.data.tryOrNull
+import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import java.net.URL
+
+class ConfirmAccountProviderPresenter @AssistedInject constructor(
+    @Assisted private val params: Params,
+    private val accountProviderDataSource: AccountProviderDataSource,
+    private val authenticationService: MatrixAuthenticationService
+) : Presenter<ConfirmAccountProviderState> {
+
+    data class Params(
+        val isAccountCreation: Boolean,
+    )
+
+    @AssistedFactory
+    interface Factory {
+        fun create(params: Params): ConfirmAccountProviderPresenter
+    }
+
+    @Composable
+    override fun present(): ConfirmAccountProviderState {
+        val accountProvider by accountProviderDataSource.flow().collectAsState()
+        val localCoroutineScope = rememberCoroutineScope()
+
+        val loginFlowAction: MutableState<Async<LoginFlow>> = remember {
+            mutableStateOf(Async.Uninitialized)
+        }
+
+        fun handleEvents(event: ConfirmAccountProviderEvents) {
+            when (event) {
+                ConfirmAccountProviderEvents.Continue -> {
+                    localCoroutineScope.submit(accountProvider.title, loginFlowAction)
+                }
+                ConfirmAccountProviderEvents.ClearError -> loginFlowAction.value = Async.Uninitialized
+            }
+        }
+
+        return ConfirmAccountProviderState(
+            accountProvider = accountProvider,
+            isAccountCreation = params.isAccountCreation,
+            loginFlow = loginFlowAction.value,
+            eventSink = ::handleEvents
+        )
+    }
+
+    private fun CoroutineScope.submit(
+        homeserverUrl: String,
+        loginFlowAction: MutableState<Async<LoginFlow>>,
+    ) = launch {
+        suspend {
+            val domain = tryOrNull { URL(homeserverUrl) }?.host ?: homeserverUrl
+            authenticationService.setHomeserver(domain).map {
+                val matrixHomeServerDetails = authenticationService.getHomeserverDetails().value!!
+                if (matrixHomeServerDetails.supportsOidcLogin) {
+                    // Retrieve the details right now
+                    LoginFlow.OidcFlow(authenticationService.getOidcUrl().getOrThrow())
+                } else if (matrixHomeServerDetails.supportsPasswordLogin) {
+                    LoginFlow.PasswordLogin
+                } else {
+                    throw IllegalStateException("Unsupported login flow")
+                }
+            }.getOrThrow()
+        }.execute(loginFlowAction, errorMapping = ChangeServerError::from)
+    }
+}

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.confirmaccountprovider
+
+import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.matrix.api.auth.OidcDetails
+
+// Do not use default value, so no member get forgotten in the presenters.
+data class ConfirmAccountProviderState(
+    val accountProvider: AccountProvider,
+    val isAccountCreation: Boolean,
+    val loginFlow: Async<LoginFlow>,
+    val eventSink: (ConfirmAccountProviderEvents) -> Unit
+) {
+    val submitEnabled: Boolean get() = accountProvider.title.isNotEmpty() && (loginFlow is Async.Uninitialized || loginFlow is Async.Loading)
+}
+
+sealed interface LoginFlow {
+    object PasswordLogin : LoginFlow
+    data class OidcFlow(val oidcDetails: OidcDetails) : LoginFlow
+}

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.confirmaccountprovider
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.login.impl.accountprovider.anAccountProvider
+import io.element.android.libraries.architecture.Async
+
+open class ConfirmAccountProviderStateProvider : PreviewParameterProvider<ConfirmAccountProviderState> {
+    override val values: Sequence<ConfirmAccountProviderState>
+        get() = sequenceOf(
+            aConfirmAccountProviderState(),
+            // Add other state here
+        )
+}
+
+fun aConfirmAccountProviderState() = ConfirmAccountProviderState(
+    accountProvider = anAccountProvider(),
+    isAccountCreation = false,
+    loginFlow = Async.Uninitialized,
+    eventSink = {}
+)

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

@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.confirmaccountprovider
+
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.AccountCircle
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.features.login.impl.R
+import io.element.android.features.login.impl.dialogs.SlidingSyncNotSupportedDialog
+import io.element.android.features.login.impl.error.ChangeServerError
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.designsystem.atomic.molecules.ButtonColumnMolecule
+import io.element.android.libraries.designsystem.atomic.molecules.IconTitleSubtitleMolecule
+import io.element.android.libraries.designsystem.atomic.pages.HeaderFooterPage
+import io.element.android.libraries.designsystem.components.button.ButtonWithProgress
+import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.designsystem.theme.components.TextButton
+import io.element.android.libraries.matrix.api.auth.OidcDetails
+import io.element.android.libraries.testtags.TestTags
+import io.element.android.libraries.testtags.testTag
+
+@Composable
+fun ConfirmAccountProviderView(
+    state: ConfirmAccountProviderState,
+    onOidcDetails: (OidcDetails) -> Unit,
+    onLoginPasswordNeeded: () -> Unit,
+    onLearnMoreClicked: () -> Unit,
+    onChange: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val isLoading by remember(state.loginFlow) {
+        derivedStateOf {
+            state.loginFlow is Async.Loading
+        }
+    }
+    val eventSink = state.eventSink
+
+    HeaderFooterPage(
+        modifier = modifier,
+        header = {
+            IconTitleSubtitleMolecule(
+                modifier = Modifier.padding(top = 60.dp),
+                iconImageVector = Icons.Filled.AccountCircle,
+                title = stringResource(
+                    id = if (state.isAccountCreation) {
+                        R.string.screen_account_provider_signup_title
+                    } else {
+                        R.string.screen_account_provider_signin_title
+                    },
+                    state.accountProvider.title
+                ),
+                subTitle = stringResource(
+                    id = if (state.isAccountCreation) {
+                        R.string.screen_account_provider_signup_subtitle
+                    } else {
+                        // Use same value for now.
+                        R.string.screen_account_provider_signup_subtitle
+                    },
+                )
+            )
+        },
+        footer = {
+            ButtonColumnMolecule {
+                ButtonWithProgress(
+                    text = stringResource(id = R.string.screen_account_provider_continue),
+                    showProgress = isLoading,
+                    onClick = { eventSink.invoke(ConfirmAccountProviderEvents.Continue) },
+                    enabled = state.submitEnabled,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .testTag(TestTags.loginContinue)
+                )
+                TextButton(
+                    onClick = onChange,
+                    enabled = true,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .testTag(TestTags.loginChangeServer)
+                ) {
+                    Text(text = stringResource(id = R.string.screen_account_provider_change))
+                }
+            }
+        }
+    ) {
+        when (state.loginFlow) {
+            is Async.Failure -> {
+                when (val error = state.loginFlow.error) {
+                    is ChangeServerError.Error -> {
+                        ErrorDialog(
+                            content = error.message(),
+                            onDismiss = {
+                                eventSink.invoke(ConfirmAccountProviderEvents.ClearError)
+                            }
+                        )
+                    }
+                    is ChangeServerError.SlidingSyncAlert -> {
+                        SlidingSyncNotSupportedDialog(onLearnMoreClicked = {
+                            onLearnMoreClicked()
+                            eventSink(ConfirmAccountProviderEvents.ClearError)
+                        }, onDismiss = {
+                            eventSink(ConfirmAccountProviderEvents.ClearError)
+                        })
+                    }
+                }
+            }
+            is Async.Loading -> Unit // The Continue button shows the loading state
+            is Async.Success -> {
+                when (val loginFlowState = state.loginFlow.state) {
+                    is LoginFlow.OidcFlow -> onOidcDetails(loginFlowState.oidcDetails)
+                    LoginFlow.PasswordLogin -> onLoginPasswordNeeded()
+                }
+            }
+            Async.Uninitialized -> Unit
+        }
+    }
+}
+
+@Preview
+@Composable
+fun ConfirmAccountProviderViewLightPreview(@PreviewParameter(ConfirmAccountProviderStateProvider::class) state: ConfirmAccountProviderState) =
+    ElementPreviewLight { ContentToPreview(state) }
+
+@Preview
+@Composable
+fun ConfirmAccountProviderViewDarkPreview(@PreviewParameter(ConfirmAccountProviderStateProvider::class) state: ConfirmAccountProviderState) =
+    ElementPreviewDark { ContentToPreview(state) }
+
+@Composable
+private fun ContentToPreview(state: ConfirmAccountProviderState) {
+    ConfirmAccountProviderView(
+        state = state,
+        onOidcDetails = {},
+        onLoginPasswordNeeded = {},
+        onLearnMoreClicked = {},
+        onChange = {},
+    )
+}

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

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.loginpassword
+
+sealed interface LoginPasswordEvents {
+    data class SetLogin(val login: String) : LoginPasswordEvents
+    data class SetPassword(val password: String) : LoginPasswordEvents
+    object Submit : LoginPasswordEvents
+    object ClearError : LoginPasswordEvents
+}

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.loginpassword
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.libraries.di.AppScope
+
+@ContributesNode(AppScope::class)
+class LoginPasswordNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: LoginPasswordPresenter,
+) : Node(buildContext, plugins = plugins) {
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        LoginPasswordView(
+            state = state,
+            modifier = modifier,
+            onBackPressed = ::navigateUp
+        )
+    }
+}

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

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.loginpassword
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
+import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
+import io.element.android.libraries.matrix.api.core.SessionId
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+class LoginPasswordPresenter @Inject constructor(
+    private val authenticationService: MatrixAuthenticationService,
+    private val accountProviderDataSource: AccountProviderDataSource,
+) : Presenter<LoginPasswordState> {
+
+    @Composable
+    override fun present(): LoginPasswordState {
+        val localCoroutineScope = rememberCoroutineScope()
+        val loginAction: MutableState<Async<SessionId>> = remember {
+            mutableStateOf(Async.Uninitialized)
+        }
+
+        val formState = rememberSaveable {
+            mutableStateOf(LoginFormState.Default)
+        }
+        val accountProvider by accountProviderDataSource.flow().collectAsState()
+
+        fun handleEvents(event: LoginPasswordEvents) {
+            when (event) {
+                is LoginPasswordEvents.SetLogin -> updateFormState(formState) {
+                    copy(login = event.login)
+                }
+                is LoginPasswordEvents.SetPassword -> updateFormState(formState) {
+                    copy(password = event.password)
+                }
+                LoginPasswordEvents.Submit -> {
+                    localCoroutineScope.submit(formState.value, loginAction)
+                }
+                LoginPasswordEvents.ClearError -> loginAction.value = Async.Uninitialized
+            }
+        }
+
+        return LoginPasswordState(
+            accountProvider = accountProvider,
+            formState = formState.value,
+            loginAction = loginAction.value,
+            eventSink = ::handleEvents
+        )
+    }
+
+    private fun CoroutineScope.submit(formState: LoginFormState, loggedInState: MutableState<Async<SessionId>>) = launch {
+        loggedInState.value = Async.Loading()
+        authenticationService.login(formState.login.trim(), formState.password)
+            .onSuccess { sessionId ->
+                loggedInState.value = Async.Success(sessionId)
+            }
+            .onFailure { failure ->
+                loggedInState.value = Async.Failure(failure)
+            }
+    }
+
+    private fun updateFormState(formState: MutableState<LoginFormState>, updateLambda: LoginFormState.() -> LoginFormState) {
+        formState.value = updateLambda(formState.value)
+    }
+}

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

@@ -14,36 +14,23 @@
  * limitations under the License.
  */
 
-package io.element.android.features.login.impl.root
+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.Async
-import io.element.android.libraries.core.bool.orFalse
-import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
-import io.element.android.libraries.matrix.api.auth.OidcDetails
 import io.element.android.libraries.matrix.api.core.SessionId
 import kotlinx.parcelize.Parcelize
 
-data class LoginRootState(
-    val homeserverUrl: String,
-    val homeserverDetails: Async<MatrixHomeServerDetails>,
-    val loggedInState: LoggedInState,
+data class LoginPasswordState(
+    val accountProvider: AccountProvider,
     val formState: LoginFormState,
-    val eventSink: (LoginRootEvents) -> Unit
+    val loginAction: Async<SessionId>,
+    val eventSink: (LoginPasswordEvents) -> Unit
 ) {
-    val supportPasswordLogin = (homeserverDetails as? Async.Success)?.state?.supportsPasswordLogin.orFalse()
-    val supportOidcLogin = (homeserverDetails as? Async.Success)?.state?.supportsOidcLogin.orFalse()
     val submitEnabled: Boolean
-        get() = loggedInState !is LoggedInState.ErrorLoggingIn &&
-            ((formState.login.isNotEmpty() && formState.password.isNotEmpty()) || supportOidcLogin)
-}
-
-sealed interface LoggedInState {
-    object NotLoggedIn : LoggedInState
-    object LoggingIn : LoggedInState
-    data class OidcStarted(val oidcDetail: OidcDetails) : LoggedInState
-    data class ErrorLoggingIn(val failure: Throwable) : LoggedInState
-    data class LoggedIn(val sessionId: SessionId) : LoggedInState
+        get() = loginAction !is Async.Failure &&
+            ((formState.login.isNotEmpty() && formState.password.isNotEmpty()))
 }
 
 @Parcelize

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.loginpassword
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.login.impl.accountprovider.anAccountProvider
+import io.element.android.libraries.architecture.Async
+
+open class LoginPasswordStateProvider : PreviewParameterProvider<LoginPasswordState> {
+    override val values: Sequence<LoginPasswordState>
+        get() = sequenceOf(
+            aLoginPasswordState(),
+            // Loading
+            aLoginPasswordState().copy(loginAction = Async.Loading()),
+            // Error
+            aLoginPasswordState().copy(loginAction = Async.Failure(Exception("An error occurred"))),
+        )
+}
+
+fun aLoginPasswordState() = LoginPasswordState(
+    accountProvider = anAccountProvider(),
+    formState = LoginFormState.Default,
+    loginAction = Async.Uninitialized,
+    eventSink = {}
+)

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 New Vector Ltd
+ * Copyright (c) 2023 New Vector Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,15 +14,11 @@
  * limitations under the License.
  */
 
-package io.element.android.features.login.impl.root
+package io.element.android.features.login.impl.screens.loginpassword
 
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.consumeWindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
@@ -30,31 +26,25 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.ChevronRight
+import androidx.compose.material.icons.filled.AccountCircle
 import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.Visibility
 import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.autofill.AutofillType
-import androidx.compose.ui.draw.clip
 import androidx.compose.ui.focus.FocusDirection
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.res.stringResource
@@ -62,7 +52,6 @@ import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.text.input.VisualTransformation
-import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewParameter
 import androidx.compose.ui.unit.dp
@@ -70,8 +59,7 @@ import io.element.android.features.login.impl.R
 import io.element.android.features.login.impl.error.loginError
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.designsystem.ElementTextStyles
-import io.element.android.libraries.designsystem.components.async.AsyncFailure
-import io.element.android.libraries.designsystem.components.async.AsyncLoading
+import io.element.android.libraries.designsystem.atomic.molecules.IconTitleSubtitleMolecule
 import io.element.android.libraries.designsystem.components.button.BackButton
 import io.element.android.libraries.designsystem.components.button.ButtonWithProgress
 import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
@@ -86,23 +74,20 @@ import io.element.android.libraries.designsystem.theme.components.TextField
 import io.element.android.libraries.designsystem.theme.components.TopAppBar
 import io.element.android.libraries.designsystem.theme.components.autofill
 import io.element.android.libraries.designsystem.theme.components.onTabOrEnterKeyFocusNext
-import io.element.android.libraries.matrix.api.auth.OidcDetails
 import io.element.android.libraries.testtags.TestTags
 import io.element.android.libraries.testtags.testTag
 import io.element.android.libraries.ui.strings.R as StringR
 
 @OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
 @Composable
-fun LoginRootView(
-    state: LoginRootState,
+fun LoginPasswordView(
+    state: LoginPasswordState,
     modifier: Modifier = Modifier,
-    onChangeServer: () -> Unit = {},
-    onOidcDetails: (OidcDetails) -> Unit = {},
     onBackPressed: () -> Unit,
 ) {
-    val isLoading by remember(state.loggedInState) {
+    val isLoading by remember(state.loginAction) {
         derivedStateOf {
-            state.loggedInState == LoggedInState.LoggingIn
+            state.loginAction is Async.Loading
         }
     }
     val focusManager = LocalFocusManager.current
@@ -111,10 +96,11 @@ fun LoginRootView(
         // Clear focus to prevent keyboard issues with textfields
         focusManager.clearFocus(force = true)
 
-        state.eventSink(LoginRootEvents.Submit)
+        state.eventSink(LoginPasswordEvents.Submit)
     }
 
     Scaffold(
+        modifier = modifier,
         topBar = {
             TopAppBar(
                 title = {},
@@ -123,7 +109,7 @@ fun LoginRootView(
         }
     ) { padding ->
         Box(
-            modifier = modifier
+            modifier = Modifier
                 .fillMaxSize()
                 .imePadding()
                 .padding(padding)
@@ -136,142 +122,48 @@ fun LoginRootView(
                     .verticalScroll(state = scrollState)
                     .padding(horizontal = 16.dp),
             ) {
-                Spacer(Modifier.height(16.dp))
                 // Title
-                Text(
-                    text = stringResource(id = R.string.screen_login_title),
+                IconTitleSubtitleMolecule(
+                    modifier = Modifier.padding(top = 20.dp),
+                    iconImageVector = Icons.Filled.AccountCircle,
+                    title = stringResource(
+                        id = R.string.screen_account_provider_signin_title,
+                        state.accountProvider.title
+                    ),
+                    subTitle = stringResource(id = R.string.screen_login_form_header)
+                )
+                Spacer(Modifier.height(32.dp))
+                LoginForm(state = state,
+                    isLoading = isLoading,
+                    onSubmit = ::submit
+                )
+                Spacer(Modifier.height(28.dp))
+                // Submit
+                ButtonWithProgress(
+                    text = stringResource(R.string.screen_login_submit),
+                    showProgress = isLoading,
+                    onClick = ::submit,
+                    enabled = state.submitEnabled,
                     modifier = Modifier
-                        .fillMaxWidth(),
-                    style = ElementTextStyles.Bold.title1,
-                    color = MaterialTheme.colorScheme.primary,
+                        .fillMaxWidth()
+                        .testTag(TestTags.loginContinue)
                 )
-                Spacer(Modifier.height(32.dp))
-
-                ChangeServerSection(
-                    interactionEnabled = !isLoading,
-                    homeserver = state.homeserverUrl,
-                    onChangeServer = onChangeServer
-                )
-
-                Spacer(Modifier.height(32.dp))
-
-                when (state.homeserverDetails) {
-                    Async.Uninitialized,
-                    is Async.Loading -> AsyncLoading()
-                    is Async.Failure -> AsyncFailure(
-                        throwable = state.homeserverDetails.error,
-                        onRetry = {
-                            state.eventSink.invoke(LoginRootEvents.RetryFetchServerInfo)
-                        }
-                    )
-                    is Async.Success -> ServerDetailForm(state, isLoading, ::submit)
-                }
+                Spacer(modifier = Modifier.height(32.dp))
             }
-            when (val loggedInState = state.loggedInState) {
-                is LoggedInState.OidcStarted -> onOidcDetails(loggedInState.oidcDetail)
-                else -> Unit
+
+            if (state.loginAction is Async.Failure) {
+                LoginErrorDialog(error = state.loginAction.error, onDismiss = {
+                    state.eventSink(LoginPasswordEvents.ClearError)
+                })
             }
         }
     }
-
-    if (state.loggedInState is LoggedInState.ErrorLoggingIn) {
-        LoginErrorDialog(error = state.loggedInState.failure, onDismiss = {
-            state.eventSink(LoginRootEvents.ClearError)
-        })
-    }
-}
-
-@Composable
-fun ServerDetailForm(
-    state: LoginRootState,
-    isLoading: Boolean,
-    submit: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    when {
-        state.supportOidcLogin -> {
-            // Oidc, in this case, just display a Spacer and the submit button
-            Spacer(modifier.height(28.dp))
-        }
-        state.supportPasswordLogin -> {
-            LoginForm(state = state, isLoading = isLoading, onSubmit = submit, modifier = modifier)
-        }
-        else -> {
-            Text(modifier = modifier, text = "No supported login flow")
-        }
-    }
-
-    Spacer(Modifier.height(28.dp))
-
-    if (state.supportOidcLogin || state.supportPasswordLogin) {
-        // Submit
-        ButtonWithProgress(
-            text = stringResource(R.string.screen_login_submit),
-            showProgress = isLoading,
-            onClick = submit,
-            enabled = state.submitEnabled,
-            modifier = Modifier
-                .fillMaxWidth()
-                .testTag(TestTags.loginContinue)
-        )
-        Spacer(modifier = Modifier.height(32.dp))
-    }
-}
-
-@Composable
-internal fun ChangeServerSection(
-    interactionEnabled: Boolean,
-    homeserver: String,
-    onChangeServer: () -> Unit,
-    modifier: Modifier = Modifier
-) {
-    Column(modifier) {
-        Text(
-            modifier = Modifier.padding(start = 16.dp, bottom = 8.dp),
-            text = stringResource(id = R.string.screen_login_server_header),
-            style = ElementTextStyles.Regular.formHeader,
-        )
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .clip(RoundedCornerShape(14.dp))
-                .background(MaterialTheme.colorScheme.surfaceVariant)
-                .testTag(TestTags.loginChangeServer)
-                .clickable {
-                    if (interactionEnabled) {
-                        onChangeServer()
-                    }
-                },
-            horizontalArrangement = Arrangement.End,
-            verticalAlignment = Alignment.CenterVertically,
-        ) {
-            Text(
-                text = homeserver,
-                style = ElementTextStyles.Bold.body,
-                textAlign = TextAlign.Start,
-                modifier = Modifier
-                    .weight(1f)
-                    .padding(horizontal = 16.dp, vertical = 16.dp)
-            )
-            IconButton(
-                modifier = Modifier.size(24.dp),
-                onClick = {
-                    if (interactionEnabled) {
-                        onChangeServer()
-                    }
-                }
-            ) {
-                Icon(imageVector = Icons.Default.ChevronRight, contentDescription = null, tint = MaterialTheme.colorScheme.tertiary)
-            }
-            Spacer(Modifier.width(8.dp))
-        }
-    }
 }
 
 @OptIn(ExperimentalComposeUiApi::class)
 @Composable
 internal fun LoginForm(
-    state: LoginRootState,
+    state: LoginPasswordState,
     isLoading: Boolean,
     onSubmit: () -> Unit,
     modifier: Modifier = Modifier
@@ -299,14 +191,14 @@ internal fun LoginForm(
                 .testTag(TestTags.loginEmailUsername)
                 .autofill(autofillTypes = listOf(AutofillType.Username), onFill = {
                     loginFieldState = it
-                    eventSink(LoginRootEvents.SetLogin(it))
+                    eventSink(LoginPasswordEvents.SetLogin(it))
                 }),
             label = {
                 Text(text = stringResource(R.string.screen_login_username_hint))
             },
             onValueChange = {
                 loginFieldState = it
-                eventSink(LoginRootEvents.SetLogin(it))
+                eventSink(LoginPasswordEvents.SetLogin(it))
             },
             keyboardOptions = KeyboardOptions(
                 keyboardType = KeyboardType.Email,
@@ -316,7 +208,6 @@ internal fun LoginForm(
                 focusManager.moveFocus(FocusDirection.Down)
             }),
             singleLine = true,
-            maxLines = 1,
             trailingIcon = if (loginFieldState.isNotEmpty()) {
                 {
                     IconButton(onClick = {
@@ -329,7 +220,7 @@ internal fun LoginForm(
         )
 
         var passwordVisible by remember { mutableStateOf(false) }
-        if (state.loggedInState is LoggedInState.LoggingIn) {
+        if (state.loginAction is Async.Loading) {
             // Ensure password is hidden when user submits the form
             passwordVisible = false
         }
@@ -343,11 +234,11 @@ internal fun LoginForm(
                 .testTag(TestTags.loginPassword)
                 .autofill(autofillTypes = listOf(AutofillType.Password), onFill = {
                     passwordFieldState = it
-                    eventSink(LoginRootEvents.SetPassword(it))
+                    eventSink(LoginPasswordEvents.SetPassword(it))
                 }),
             onValueChange = {
                 passwordFieldState = it
-                eventSink(LoginRootEvents.SetPassword(it))
+                eventSink(LoginPasswordEvents.SetPassword(it))
             },
             label = {
                 Text(text = stringResource(R.string.screen_login_password_hint))
@@ -371,7 +262,6 @@ internal fun LoginForm(
                 onDone = { onSubmit() }
             ),
             singleLine = true,
-            maxLines = 1,
         )
     }
 }
@@ -386,17 +276,17 @@ internal fun LoginErrorDialog(error: Throwable, onDismiss: () -> Unit) {
 
 @Preview
 @Composable
-internal fun LoginRootScreenLightPreview(@PreviewParameter(LoginRootStateProvider::class) state: LoginRootState) =
+internal fun LoginPasswordViewLightPreview(@PreviewParameter(LoginPasswordStateProvider::class) state: LoginPasswordState) =
     ElementPreviewLight { ContentToPreview(state) }
 
 @Preview
 @Composable
-internal fun LoginRootScreenDarkPreview(@PreviewParameter(LoginRootStateProvider::class) state: LoginRootState) =
+internal fun LoginPasswordViewDarkPreview(@PreviewParameter(LoginPasswordStateProvider::class) state: LoginPasswordState) =
     ElementPreviewDark { ContentToPreview(state) }
 
 @Composable
-private fun ContentToPreview(state: LoginRootState) {
-    LoginRootView(
+private fun ContentToPreview(state: LoginPasswordState) {
+    LoginPasswordView(
         state = state,
         onBackPressed = {}
     )

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/searchaccountprovider/SearchAccountProviderEvents.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.searchaccountprovider
+
+sealed interface SearchAccountProviderEvents {
+    /**
+     * The user has typed something, expect to get a list of matching account provider results
+     * in the state.
+     */
+    data class UserInput(val input: String) : SearchAccountProviderEvents
+}

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/searchaccountprovider/SearchAccountProviderNode.kt

@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
-package io.element.android.features.login.impl.root
+package io.element.android.features.login.impl.screens.searchaccountprovider
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.plugin.Plugin
@@ -25,38 +26,34 @@ import com.bumble.appyx.core.plugin.plugins
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.login.impl.util.openLearnMorePage
 import io.element.android.libraries.di.AppScope
-import io.element.android.libraries.matrix.api.auth.OidcDetails
 
 @ContributesNode(AppScope::class)
-class LoginRootNode @AssistedInject constructor(
+class SearchAccountProviderNode @AssistedInject constructor(
     @Assisted buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
-    private val presenter: LoginRootPresenter,
+    private val presenter: SearchAccountProviderPresenter,
 ) : Node(buildContext, plugins = plugins) {
 
     interface Callback : Plugin {
-        fun onChangeHomeServer()
-        fun onOidcDetails(oidcDetails: OidcDetails)
+        fun onDone()
     }
 
-    private fun onChangeHomeServer() {
-        plugins<Callback>().forEach { it.onChangeHomeServer() }
-    }
-
-    private fun onOidcDetails(oidcDetails: OidcDetails) {
-        plugins<Callback>().forEach { it.onOidcDetails(oidcDetails) }
+    private fun onDone() {
+        plugins<Callback>().forEach { it.onDone() }
     }
 
     @Composable
     override fun View(modifier: Modifier) {
         val state = presenter.present()
-        LoginRootView(
+        val context = LocalContext.current
+        SearchAccountProviderView(
             state = state,
             modifier = modifier,
-            onChangeServer = ::onChangeHomeServer,
-            onOidcDetails = ::onOidcDetails,
-            onBackPressed = ::navigateUp
+            onBackPressed = ::navigateUp,
+            onLearnMoreClicked = { openLearnMorePage(context) },
+            onDone = ::onDone,
         )
     }
 }

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/searchaccountprovider/SearchAccountProviderPresenter.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.searchaccountprovider
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import io.element.android.features.login.impl.changeserver.ChangeServerPresenter
+import io.element.android.features.login.impl.resolver.HomeserverData
+import io.element.android.features.login.impl.resolver.HomeserverResolver
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.architecture.Presenter
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+class SearchAccountProviderPresenter @Inject constructor(
+    private val homeserverResolver: HomeserverResolver,
+    private val changeServerPresenter: ChangeServerPresenter,
+) : Presenter<SearchAccountProviderState> {
+
+    @Composable
+    override fun present(): SearchAccountProviderState {
+        var userInput by rememberSaveable {
+            mutableStateOf("")
+        }
+        val changeServerState = changeServerPresenter.present()
+
+        val data: MutableState<Async<List<HomeserverData>>> = remember {
+            mutableStateOf(Async.Uninitialized)
+        }
+
+        LaunchedEffect(userInput) {
+            onUserInput(userInput, data)
+        }
+
+        fun handleEvents(event: SearchAccountProviderEvents) {
+            when (event) {
+                is SearchAccountProviderEvents.UserInput -> {
+                    userInput = event.input
+                }
+            }
+        }
+
+        return SearchAccountProviderState(
+            userInput = userInput,
+            userInputResult = data.value,
+            changeServerState = changeServerState,
+            eventSink = ::handleEvents
+        )
+    }
+
+    private fun CoroutineScope.onUserInput(userInput: String, data: MutableState<Async<List<HomeserverData>>>) = launch {
+        data.value = Async.Uninitialized
+        // Debounce
+        delay(300)
+        data.value = Async.Loading()
+        homeserverResolver.resolve(userInput).collect {
+            data.value = Async.Success(it)
+        }
+        if (data.value !is Async.Success) {
+            data.value = Async.Uninitialized
+        }
+    }
+}

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/searchaccountprovider/SearchAccountProviderState.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.searchaccountprovider
+
+import io.element.android.features.login.impl.changeserver.ChangeServerState
+import io.element.android.features.login.impl.resolver.HomeserverData
+import io.element.android.libraries.architecture.Async
+
+// Do not use default value, so no member get forgotten in the presenters.
+data class SearchAccountProviderState(
+    val userInput: String,
+    val userInputResult: Async<List<HomeserverData>>,
+    val changeServerState: ChangeServerState,
+    val eventSink: (SearchAccountProviderEvents) -> Unit
+)

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/searchaccountprovider/SearchAccountProviderStateProvider.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.searchaccountprovider
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.login.impl.changeserver.aChangeServerState
+import io.element.android.features.login.impl.resolver.HomeserverData
+import io.element.android.libraries.architecture.Async
+
+open class SearchAccountProviderStateProvider : PreviewParameterProvider<SearchAccountProviderState> {
+    override val values: Sequence<SearchAccountProviderState>
+        get() = sequenceOf(
+            aSearchAccountProviderState(),
+            aSearchAccountProviderState(userInputResult = Async.Success(aHomeserverDataList())),
+            // Add other state here
+        )
+}
+
+fun aSearchAccountProviderState(
+    userInput: String = "",
+    userInputResult: Async<List<HomeserverData>> = Async.Uninitialized,
+) = SearchAccountProviderState(
+    userInput = userInput,
+    userInputResult = userInputResult,
+    changeServerState = aChangeServerState(),
+    eventSink = {}
+)
+
+fun aHomeserverDataList(): List<HomeserverData> {
+    return listOf(
+        aHomeserverData(isWellknownValid = true, supportSlidingSync = true),
+        aHomeserverData(homeserverUrl = "https://no.sliding.sync", isWellknownValid = true, supportSlidingSync = false),
+        aHomeserverData(homeserverUrl = "https://invalid", isWellknownValid = false, supportSlidingSync = false),
+    )
+}
+
+fun aHomeserverData(
+    homeserverUrl: String = "https://matrix.org",
+    isWellknownValid: Boolean = true,
+    supportSlidingSync: Boolean = true,
+): HomeserverData {
+    return HomeserverData(
+        homeserverUrl = homeserverUrl,
+        isWellknownValid = isWellknownValid,
+        supportSlidingSync = supportSlidingSync,
+    )
+}

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/searchaccountprovider/SearchAccountProviderView.kt

@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
+
+package io.element.android.features.login.impl.screens.searchaccountprovider
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Search
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusDirection
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.features.login.impl.R
+import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.features.login.impl.accountprovider.AccountProviderView
+import io.element.android.features.login.impl.changeserver.ChangeServerEvents
+import io.element.android.features.login.impl.changeserver.ChangeServerView
+import io.element.android.features.login.impl.resolver.HomeserverData
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.designsystem.atomic.molecules.IconTitleSubtitleMolecule
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.components.form.textFieldState
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.CircularProgressIndicator
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.IconButton
+import io.element.android.libraries.designsystem.theme.components.OutlinedTextField
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.designsystem.theme.components.onTabOrEnterKeyFocusNext
+import io.element.android.libraries.testtags.TestTags
+import io.element.android.libraries.testtags.testTag
+import io.element.android.libraries.ui.strings.R as StringR
+
+/**
+ * https://www.figma.com/file/o9p34zmiuEpZRyvZXJZAYL/FTUE?type=design&node-id=611-61435
+ */
+@Composable
+fun SearchAccountProviderView(
+    state: SearchAccountProviderState,
+    onBackPressed: () -> Unit,
+    onLearnMoreClicked: () -> Unit,
+    onDone: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val eventSink = state.eventSink
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(
+                title = {},
+                navigationIcon = { BackButton(onClick = onBackPressed) }
+            )
+        }
+    ) { padding ->
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding()
+                .padding(padding)
+                .consumeWindowInsets(padding)
+        ) {
+            LazyColumn(modifier = Modifier.fillMaxWidth(), state = rememberLazyListState()) {
+                item {
+                    IconTitleSubtitleMolecule(
+                        modifier = Modifier.padding(top = 16.dp, bottom = 40.dp, start = 16.dp, end = 16.dp),
+                        iconImageVector = Icons.Filled.Search,
+                        title = stringResource(id = R.string.screen_account_provider_form_title),
+                        subTitle = stringResource(id = R.string.screen_account_provider_form_subtitle),
+                    )
+                }
+                item {
+                    // TextInput
+                    var userInputState by textFieldState(stateValue = state.userInput)
+                    val focusManager = LocalFocusManager.current
+                    OutlinedTextField(
+                        value = userInputState,
+                        // readOnly = isLoading,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(start = 16.dp, end = 16.dp, bottom = 16.dp)
+                            .onTabOrEnterKeyFocusNext(focusManager)
+                            .testTag(TestTags.changeServerServer),
+                        onValueChange = {
+                            userInputState = it
+                            eventSink(SearchAccountProviderEvents.UserInput(it))
+                        },
+                        keyboardOptions = KeyboardOptions(
+                            keyboardType = KeyboardType.Uri,
+                            imeAction = ImeAction.Done,
+                        ),
+                        keyboardActions = KeyboardActions(onDone = {
+                            focusManager.moveFocus(FocusDirection.Down)
+                        }),
+                        singleLine = true,
+                        trailingIcon = if (userInputState.isNotEmpty()) {
+                            {
+                                IconButton(onClick = {
+                                    userInputState = ""
+                                    eventSink(SearchAccountProviderEvents.UserInput(""))
+                                }) {
+                                    Icon(
+                                        imageVector = Icons.Filled.Close,
+                                        contentDescription = stringResource(StringR.string.action_clear)
+                                    )
+                                }
+                            }
+                        } else null,
+                        supportingText = {
+                            Text(text = stringResource(id = R.string.screen_account_provider_form_notice), color = MaterialTheme.colorScheme.secondary)
+                        }
+                    )
+                }
+
+                when (state.userInputResult) {
+                    is Async.Failure -> {
+                        // Ignore errors (let the user type more chars)
+                    }
+                    is Async.Loading -> {
+                        item {
+                            Box(
+                                modifier = Modifier
+                                    .fillMaxSize()
+                            ) {
+                                CircularProgressIndicator(
+                                    modifier = Modifier.align(Alignment.Center)
+                                )
+                            }
+                        }
+                    }
+                    is Async.Success -> {
+                        items(state.userInputResult.state) { homeserverData ->
+                            val item = homeserverData.toAccountProvider()
+                            AccountProviderView(
+                                item = item,
+                                onClick = {
+                                    state.changeServerState.eventSink.invoke(ChangeServerEvents.ChangeServer(item))
+                                }
+                            )
+                        }
+                    }
+                    Async.Uninitialized -> Unit
+                }
+                item {
+                    Spacer(Modifier.height(32.dp))
+                }
+            }
+            ChangeServerView(
+                state = state.changeServerState,
+                onLearnMoreClicked = onLearnMoreClicked,
+                onDone = onDone,
+            )
+        }
+    }
+}
+
+@Composable
+private fun HomeserverData.toAccountProvider(): AccountProvider {
+    val isMatrixOrg = homeserverUrl == "https://matrix.org"
+    return AccountProvider(
+        title = homeserverUrl.removePrefix("http://").removePrefix("https://"),
+        subtitle = if (isMatrixOrg) stringResource(id = R.string.screen_change_account_provider_matrix_org_subtitle) else null,
+        isPublic = isMatrixOrg, // There is no need to know for other servers right now
+        isMatrixOrg = isMatrixOrg,
+        isValid = isWellknownValid,
+        supportSlidingSync = supportSlidingSync,
+    )
+}
+
+@Preview
+@Composable
+fun SearchAccountProviderViewLightPreview(@PreviewParameter(SearchAccountProviderStateProvider::class) state: SearchAccountProviderState) =
+    ElementPreviewLight { ContentToPreview(state) }
+
+@Preview
+@Composable
+fun SearchAccountProviderViewDarkPreview(@PreviewParameter(SearchAccountProviderStateProvider::class) state: SearchAccountProviderState) =
+    ElementPreviewDark { ContentToPreview(state) }
+
+@Composable
+private fun ContentToPreview(state: SearchAccountProviderState) {
+    SearchAccountProviderView(
+        state = state,
+        onBackPressed = {},
+        onLearnMoreClicked = {},
+        onDone = {},
+    )
+}

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

@@ -16,8 +16,18 @@
 
 package io.element.android.features.login.impl.util
 
+import io.element.android.features.login.impl.accountprovider.AccountProvider
+
 object LoginConstants {
+    const val MATRIX_ORG_URL = "matrix.org"
 
     const val DEFAULT_HOMESERVER_URL = "matrix.org" // TODO Oidc "synapse-oidc.lab.element.dev"
     const val SLIDING_SYNC_READ_MORE_URL = "https://github.com/matrix-org/sliding-sync/blob/main/docs/Landing.md"
 }
+
+val defaultAccountProvider = AccountProvider(
+    title = LoginConstants.DEFAULT_HOMESERVER_URL,
+    subtitle = null,
+    isPublic = LoginConstants.DEFAULT_HOMESERVER_URL == LoginConstants.MATRIX_ORG_URL,
+    isMatrixOrg = LoginConstants.DEFAULT_HOMESERVER_URL == LoginConstants.MATRIX_ORG_URL,
+)

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.util
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import io.element.android.libraries.core.data.tryOrNull
+
+fun openLearnMorePage(context: Context) {
+    val intent = Intent(Intent.ACTION_VIEW, Uri.parse(LoginConstants.SLIDING_SYNC_READ_MORE_URL))
+    tryOrNull { context.startActivity(intent) }
+}

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

@@ -0,0 +1,12 @@
+<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/main/res/drawable/ic_public.xml

@@ -0,0 +1,12 @@
+<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="M16,8C16,12.418 12.418,16 8,16C3.582,16 0,12.418 0,8C0,3.582 3.582,0 8,0C12.418,0 16,3.582 16,8Z"
+      android:fillColor="#818A95"/>
+  <path
+      android:pathData="M12.473,12.527L13.079,10.656C13.087,10.631 13.091,10.605 13.091,10.579V10.065C13.091,10 13.066,9.938 13.02,9.891L12.483,9.339C12.464,9.319 12.442,9.303 12.418,9.291L11.218,8.674C11.194,8.661 11.172,8.645 11.153,8.625L10.619,8.076C10.572,8.028 10.507,8 10.44,8H8.25C8.112,8 8,7.888 8,7.75V6.941C8,6.803 7.888,6.691 7.75,6.691H6.341C6.203,6.691 6.091,6.579 6.091,6.441V5.689C6.091,5.53 6.236,5.412 6.391,5.444L8.972,5.975C9.128,6.007 9.273,5.888 9.273,5.73V4.829C9.273,4.764 9.298,4.701 9.344,4.655L11.012,2.938C11.107,2.841 11.107,2.687 11.012,2.59L9.948,1.494C9.922,1.468 9.892,1.448 9.857,1.435L9.37,1.249C8.482,0.911 7.507,0.88 6.6,1.161L6.091,1.318C4.776,1.747 3.742,2.774 3.305,4.086L3.081,4.758C3.027,4.919 2.995,5.086 2.986,5.255L2.915,6.582C2.911,6.652 2.937,6.72 2.985,6.77L4.108,7.925C4.155,7.973 4.22,8 4.288,8H5.394C5.434,8 5.473,8.01 5.508,8.028L6.592,8.585C6.675,8.628 6.727,8.714 6.727,8.807V10.561C6.727,10.599 6.736,10.636 6.753,10.67L7.295,11.787C7.337,11.873 7.424,11.927 7.52,11.927H8.531C8.598,11.927 8.663,11.955 8.71,12.003L9.273,12.582L9.881,13.208C9.9,13.227 9.915,13.249 9.927,13.273L10.39,14.225C10.466,14.381 10.673,14.415 10.794,14.29L11.182,13.891L11.818,13.237L12.414,12.624C12.441,12.596 12.461,12.563 12.473,12.527Z"
+      android:fillColor="#ffffff"/>
+</vector>

features/login/impl/src/main/res/values/localazy.xml

@@ -1,5 +1,18 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_account_provider_change">"Change account provider"</string>
+  <string name="screen_account_provider_continue">"Continue"</string>
+  <string name="screen_account_provider_form_hint">"Homeserver address"</string>
+  <string name="screen_account_provider_form_notice">"Enter a search term or a domain address."</string>
+  <string name="screen_account_provider_form_subtitle">"Search for a company, community, or private server."</string>
+  <string name="screen_account_provider_form_title">"Find an account provider"</string>
+  <string name="screen_account_provider_signin_title">"You’re about to sign in to %s"</string>
+  <string name="screen_account_provider_signup_subtitle">"This is where you conversations will live — just like you would use an email provider to keep your emails."</string>
+  <string name="screen_account_provider_signup_title">"You’re about to create an account on %s"</string>
+  <string name="screen_change_account_provider_matrix_org_subtitle">"Matrix.org is an open network for secure, decentralized communication."</string>
+  <string name="screen_change_account_provider_other">"Other"</string>
+  <string name="screen_change_account_provider_subtitle">"Use a different account provider, such as your own private server or a work account."</string>
+  <string name="screen_change_account_provider_title">"Change account provider"</string>
   <string name="screen_change_server_error_invalid_homeserver">"We couldn\'t reach this homeserver. Please check that you have entered the homeserver URL correctly. If the URL is correct, contact your homeserver administrator for further help."</string>
   <string name="screen_change_server_error_no_sliding_sync_message">"This server currently doesn’t support sliding sync."</string>
   <string name="screen_change_server_form_header">"Homeserver URL"</string>
@@ -13,9 +26,15 @@
   <string name="screen_login_server_header">"Where your conversations live"</string>
   <string name="screen_login_title">"Welcome back!"</string>
   <string name="screen_login_title_with_homeserver">"Sign in to %1$s"</string>
+  <string name="screen_server_confirmation_change_server">"Change account provider"</string>
+  <string name="screen_server_confirmation_message_login_element_dot_io">"A private server for Element employees."</string>
+  <string name="screen_server_confirmation_message_login_matrix_dot_org">"Matrix is an open network for secure, decentralised communication."</string>
+  <string name="screen_server_confirmation_message_register">"This is where your conversations will live — just like you would use an email provider to keep your emails."</string>
+  <string name="screen_server_confirmation_title_login">"You’re about to sign in to %1$s"</string>
+  <string name="screen_server_confirmation_title_register">"You’re about to create an account on %1$s"</string>
   <string name="screen_change_server_submit">"Continue"</string>
   <string name="screen_change_server_title">"Select your server"</string>
   <string name="screen_login_password_hint">"Password"</string>
   <string name="screen_login_submit">"Continue"</string>
   <string name="screen_login_username_hint">"Username"</string>
-</resources>
+</resources>

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

@@ -20,147 +20,72 @@ import app.cash.molecule.RecompositionClock
 import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
-import io.element.android.features.login.impl.util.LoginConstants
+import io.element.android.features.login.impl.accountprovider.AccountProvider
+import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.test.A_HOMESERVER
-import io.element.android.libraries.matrix.test.A_HOMESERVER_URL_2
-import io.element.android.libraries.matrix.test.A_THROWABLE
+import io.element.android.libraries.matrix.test.A_HOMESERVER_URL
 import io.element.android.libraries.matrix.test.auth.FakeAuthenticationService
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 
 class ChangeServerPresenterTest {
     @Test
-    fun `present - should start with default homeserver`() = runTest {
+    fun `present - initial state`() = runTest {
         val presenter = ChangeServerPresenter(
             FakeAuthenticationService(),
+            AccountProviderDataSource()
         )
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            assertThat(initialState.homeserver).isEqualTo(LoginConstants.DEFAULT_HOMESERVER_URL)
-            assertThat(initialState.submitEnabled).isTrue()
+            assertThat(initialState.changeServerAction).isEqualTo(Async.Uninitialized)
         }
     }
 
     @Test
-    fun `present - authentication service can provide a homeserver`() = runTest {
-        val presenter = ChangeServerPresenter(
-            FakeAuthenticationService().apply {
-                givenHomeserver(A_HOMESERVER.copy(url = A_HOMESERVER_URL_2))
-            },
-        )
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            assertThat(initialState.homeserver).isEqualTo(A_HOMESERVER_URL_2)
-            assertThat(initialState.submitEnabled).isTrue()
-        }
-    }
-
-    @Test
-    fun `present - disable if empty or not correct`() = runTest {
-        val presenter = ChangeServerPresenter(
-            FakeAuthenticationService(),
-        )
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            initialState.eventSink.invoke(ChangeServerEvents.SetServer(""))
-            val emptyState = awaitItem()
-            assertThat(emptyState.homeserver).isEqualTo("")
-            assertThat(emptyState.submitEnabled).isFalse()
-        }
-    }
-
-    @Test
-    fun `present - submit`() = runTest {
-        val presenter = ChangeServerPresenter(
-            FakeAuthenticationService(),
-        )
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            initialState.eventSink.invoke(ChangeServerEvents.Submit)
-            val loadingState = awaitItem()
-            assertThat(loadingState.submitEnabled).isTrue()
-            assertThat(loadingState.changeServerAction).isInstanceOf(Async.Loading::class.java)
-            val successState = awaitItem()
-            assertThat(successState.submitEnabled).isFalse()
-            assertThat(successState.changeServerAction).isInstanceOf(Async.Success::class.java)
-        }
-    }
-
-    @Test
-    fun `present - submit parses URL`() = runTest {
-        val presenter = ChangeServerPresenter(
-            FakeAuthenticationService(),
-        )
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val longUrl = "https://matrix.org/.well-known/"
-            val initialState = awaitItem()
-            initialState.eventSink.invoke(ChangeServerEvents.SetServer(longUrl))
-            awaitItem()
-            initialState.eventSink.invoke(ChangeServerEvents.Submit)
-            val loadingState = awaitItem()
-            assertThat(loadingState.submitEnabled).isTrue()
-            assertThat(loadingState.changeServerAction).isInstanceOf(Async.Loading::class.java)
-            awaitItem() // Skip changing the url to the parsed domain
-            val successState = awaitItem()
-            assertThat(successState.submitEnabled).isFalse()
-            assertThat(successState.changeServerAction).isInstanceOf(Async.Success::class.java)
-            assertThat(successState.homeserver).isEqualTo("matrix.org")
-        }
-    }
-
-    @Test
-    fun `present - submit fails`() = runTest {
-        val authServer = FakeAuthenticationService()
-        val presenter = ChangeServerPresenter(authServer)
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            authServer.givenChangeServerError(Throwable())
-            initialState.eventSink.invoke(ChangeServerEvents.Submit)
-            skipItems(1) // Loading
-            val failureState = awaitItem()
-            assertThat(failureState.submitEnabled).isFalse()
-            assertThat(failureState.changeServerAction).isInstanceOf(Async.Failure::class.java)
-        }
-    }
-
-    @Test
-    fun `present - clear error`() = runTest {
+    fun `present - change server ok`() = runTest {
         val authenticationService = FakeAuthenticationService()
         val presenter = ChangeServerPresenter(
             authenticationService,
+            AccountProviderDataSource()
         )
         moleculeFlow(RecompositionClock.Immediate) {
             presenter.present()
         }.test {
             val initialState = awaitItem()
+            assertThat(initialState.changeServerAction).isEqualTo(Async.Uninitialized)
+            authenticationService.givenHomeserver(A_HOMESERVER)
+            initialState.eventSink.invoke(ChangeServerEvents.ChangeServer(AccountProvider(A_HOMESERVER_URL)))
+            val loadingState = awaitItem()
+            assertThat(loadingState.changeServerAction).isInstanceOf(Async.Loading::class.java)
+            val successState = awaitItem()
+            assertThat(successState.changeServerAction).isEqualTo(Async.Success(Unit))
+        }
+    }
 
-            // Submit will return an error
-            authenticationService.givenChangeServerError(A_THROWABLE)
-            initialState.eventSink(ChangeServerEvents.Submit)
-
-            skipItems(1) // Loading
-
-            // Check an error was returned
-            val submittedState = awaitItem()
-            assertThat(submittedState.changeServerAction).isInstanceOf(Async.Failure::class.java)
-
-            // Assert the error is then cleared
-            submittedState.eventSink(ChangeServerEvents.ClearError)
-            val clearedState = awaitItem()
-            assertThat(clearedState.changeServerAction).isEqualTo(Async.Uninitialized)
+    @Test
+    fun `present - change server error`() = runTest {
+        val authenticationService = FakeAuthenticationService()
+        val presenter = ChangeServerPresenter(
+            authenticationService,
+            AccountProviderDataSource()
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.changeServerAction).isEqualTo(Async.Uninitialized)
+            initialState.eventSink.invoke(ChangeServerEvents.ChangeServer(AccountProvider(A_HOMESERVER_URL)))
+            val loadingState = awaitItem()
+            assertThat(loadingState.changeServerAction).isInstanceOf(Async.Loading::class.java)
+            val failureState = awaitItem()
+            assertThat(failureState.changeServerAction).isInstanceOf(Async.Failure::class.java)
+            // Clear error
+            failureState.eventSink.invoke(ChangeServerEvents.ClearError)
+            val finalState = awaitItem()
+            assertThat(finalState.changeServerAction).isEqualTo(Async.Uninitialized)
         }
     }
 }

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/resolver/network/FakeWellknownRequest.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.resolver.network
+
+class FakeWellknownRequest : WellknownRequest {
+    private var resultMap: Map<String, WellKnown> = emptyMap()
+    fun givenResultMap(map: Map<String, WellKnown>) {
+        resultMap = map
+    }
+
+    override suspend fun execute(baseUrl: String): WellKnown {
+        return resultMap[baseUrl] ?: error("No result provided for $baseUrl")
+    }
+}

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/root/LoginRootPresenterTest.kt

@@ -1,308 +0,0 @@
-/*
- * Copyright (c) 2023 New Vector Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.element.android.features.login.impl.root
-
-import app.cash.molecule.RecompositionClock
-import app.cash.molecule.moleculeFlow
-import app.cash.turbine.test
-import com.google.common.truth.Truth.assertThat
-import io.element.android.features.login.api.oidc.OidcAction
-import io.element.android.features.login.impl.oidc.customtab.DefaultOidcActionFlow
-import io.element.android.features.login.impl.util.LoginConstants
-import io.element.android.libraries.architecture.Async
-import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
-import io.element.android.libraries.matrix.test.A_HOMESERVER
-import io.element.android.libraries.matrix.test.A_HOMESERVER_OIDC
-import io.element.android.libraries.matrix.test.A_PASSWORD
-import io.element.android.libraries.matrix.test.A_SESSION_ID
-import io.element.android.libraries.matrix.test.A_THROWABLE
-import io.element.android.libraries.matrix.test.A_USER_NAME
-import io.element.android.libraries.matrix.test.auth.A_OIDC_DATA
-import io.element.android.libraries.matrix.test.auth.FakeAuthenticationService
-import kotlinx.coroutines.test.runTest
-import org.junit.Test
-
-class LoginRootPresenterTest {
-    @Test
-    fun `present - initial state`() = runTest {
-        val presenter = LoginRootPresenter(
-            FakeAuthenticationService(),
-            DefaultOidcActionFlow(),
-        )
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            assertThat(initialState.homeserverUrl).isEqualTo(LoginConstants.DEFAULT_HOMESERVER_URL)
-            assertThat(initialState.homeserverDetails).isEqualTo(Async.Uninitialized)
-            assertThat(initialState.loggedInState).isEqualTo(LoggedInState.NotLoggedIn)
-            assertThat(initialState.formState).isEqualTo(LoginFormState.Default)
-            assertThat(initialState.submitEnabled).isFalse()
-            cancelAndIgnoreRemainingEvents()
-        }
-    }
-
-    @Test
-    fun `present - initial state server load`() = runTest {
-        val authenticationService = FakeAuthenticationService()
-        val oidcActionFlow = DefaultOidcActionFlow()
-        val presenter = LoginRootPresenter(
-            authenticationService,
-            oidcActionFlow,
-        )
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            assertThat(initialState.homeserverUrl).isEqualTo(LoginConstants.DEFAULT_HOMESERVER_URL)
-            assertThat(initialState.homeserverDetails).isEqualTo(Async.Uninitialized)
-            assertThat(initialState.loggedInState).isEqualTo(LoggedInState.NotLoggedIn)
-            assertThat(initialState.formState).isEqualTo(LoginFormState.Default)
-            assertThat(initialState.submitEnabled).isFalse()
-            val loadingState = awaitItem()
-            assertThat(loadingState.homeserverDetails).isEqualTo(Async.Loading<MatrixHomeServerDetails>())
-            authenticationService.givenHomeserver(A_HOMESERVER)
-            skipItems(1)
-            val loadedState = awaitItem()
-            assertThat(loadedState.homeserverDetails).isEqualTo(Async.Success(A_HOMESERVER))
-        }
-    }
-
-    @Test
-    fun `present - initial state server load error and retry`() = runTest {
-        val authenticationService = FakeAuthenticationService()
-        val oidcActionFlow = DefaultOidcActionFlow()
-        val presenter = LoginRootPresenter(
-            authenticationService,
-            oidcActionFlow,
-        )
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            assertThat(initialState.homeserverUrl).isEqualTo(LoginConstants.DEFAULT_HOMESERVER_URL)
-            assertThat(initialState.homeserverDetails).isEqualTo(Async.Uninitialized)
-            assertThat(initialState.loggedInState).isEqualTo(LoggedInState.NotLoggedIn)
-            assertThat(initialState.formState).isEqualTo(LoginFormState.Default)
-            assertThat(initialState.submitEnabled).isFalse()
-            val loadingState = awaitItem()
-            assertThat(loadingState.homeserverDetails).isEqualTo(Async.Loading<MatrixHomeServerDetails>())
-            val aThrowable = Throwable("Error")
-            authenticationService.givenChangeServerError(aThrowable)
-            val errorState = awaitItem()
-            assertThat(errorState.homeserverDetails).isEqualTo(Async.Failure<MatrixHomeServerDetails>(aThrowable))
-            // Retry
-            errorState.eventSink.invoke(LoginRootEvents.RetryFetchServerInfo)
-            val loadingState2 = awaitItem()
-            assertThat(loadingState2.homeserverDetails).isEqualTo(Async.Loading<MatrixHomeServerDetails>())
-            authenticationService.givenChangeServerError(null)
-            authenticationService.givenHomeserver(A_HOMESERVER)
-            skipItems(1)
-            val loadedState = awaitItem()
-            assertThat(loadedState.homeserverDetails).isEqualTo(Async.Success(A_HOMESERVER))
-        }
-    }
-
-    @Test
-    fun `present - enter login and password`() = runTest {
-        val authenticationService = FakeAuthenticationService()
-        val oidcActionFlow = DefaultOidcActionFlow()
-        val presenter = LoginRootPresenter(
-            authenticationService,
-            oidcActionFlow,
-        )
-        authenticationService.givenHomeserver(A_HOMESERVER)
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            initialState.eventSink.invoke(LoginRootEvents.SetLogin(A_USER_NAME))
-            val loginState = awaitItem()
-            assertThat(loginState.formState).isEqualTo(LoginFormState(login = A_USER_NAME, password = ""))
-            assertThat(loginState.submitEnabled).isFalse()
-            initialState.eventSink.invoke(LoginRootEvents.SetPassword(A_PASSWORD))
-            val loginAndPasswordState = awaitItem()
-            assertThat(loginAndPasswordState.formState).isEqualTo(LoginFormState(login = A_USER_NAME, password = A_PASSWORD))
-            assertThat(loginAndPasswordState.submitEnabled).isTrue()
-        }
-    }
-
-    @Test
-    fun `present - oidc login`() = runTest {
-        val authenticationService = FakeAuthenticationService()
-        val oidcActionFlow = DefaultOidcActionFlow()
-        val presenter = LoginRootPresenter(
-            authenticationService,
-            oidcActionFlow,
-        )
-        authenticationService.givenHomeserver(A_HOMESERVER_OIDC)
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            assertThat(initialState.submitEnabled).isTrue()
-            initialState.eventSink.invoke(LoginRootEvents.Submit)
-            val oidcState = awaitItem()
-            assertThat(oidcState.loggedInState).isEqualTo(LoggedInState.OidcStarted(A_OIDC_DATA))
-        }
-    }
-
-    @Test
-    fun `present - oidc login error`() = runTest {
-        val authenticationService = FakeAuthenticationService()
-        val oidcActionFlow = DefaultOidcActionFlow()
-        val presenter = LoginRootPresenter(
-            authenticationService,
-            oidcActionFlow,
-        )
-        authenticationService.givenHomeserver(A_HOMESERVER_OIDC)
-        authenticationService.givenOidcError(A_THROWABLE)
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            assertThat(initialState.submitEnabled).isTrue()
-            initialState.eventSink.invoke(LoginRootEvents.Submit)
-            val oidcState = awaitItem()
-            assertThat(oidcState.loggedInState).isEqualTo(LoggedInState.ErrorLoggingIn(A_THROWABLE))
-        }
-    }
-
-    @Test
-    fun `present - oidc custom tab login`() = runTest {
-        val authenticationService = FakeAuthenticationService()
-        val oidcActionFlow = DefaultOidcActionFlow()
-        val presenter = LoginRootPresenter(
-            authenticationService,
-            oidcActionFlow,
-        )
-        authenticationService.givenHomeserver(A_HOMESERVER_OIDC)
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            assertThat(initialState.submitEnabled).isTrue()
-            initialState.eventSink.invoke(LoginRootEvents.Submit)
-            val oidcState = awaitItem()
-            assertThat(oidcState.loggedInState).isEqualTo(LoggedInState.OidcStarted(A_OIDC_DATA))
-            // Oidc cancel, sdk error
-            authenticationService.givenOidcCancelError(A_THROWABLE)
-            oidcActionFlow.post(OidcAction.GoBack)
-            val stateCancelSdkError = awaitItem()
-            assertThat(stateCancelSdkError.loggedInState).isEqualTo(LoggedInState.ErrorLoggingIn(A_THROWABLE))
-            // Oidc cancel, sdk OK
-            authenticationService.givenOidcCancelError(null)
-            oidcActionFlow.post(OidcAction.GoBack)
-            val stateCancel = awaitItem()
-            assertThat(stateCancel.loggedInState).isEqualTo(LoggedInState.NotLoggedIn)
-            // Oidc success, sdk error
-            authenticationService.givenLoginError(A_THROWABLE)
-            oidcActionFlow.post(OidcAction.Success(A_OIDC_DATA.url))
-            val stateSuccessSdkErrorLoading = awaitItem()
-            assertThat(stateSuccessSdkErrorLoading.loggedInState).isEqualTo(LoggedInState.LoggingIn)
-            val stateSuccessSdkError = awaitItem()
-            assertThat(stateSuccessSdkError.loggedInState).isEqualTo(LoggedInState.ErrorLoggingIn(A_THROWABLE))
-            // Oidc success
-            authenticationService.givenLoginError(null)
-            oidcActionFlow.post(OidcAction.Success(A_OIDC_DATA.url))
-            val stateSuccess = awaitItem()
-            assertThat(stateSuccess.loggedInState).isEqualTo(LoggedInState.LoggingIn)
-            val stateSuccessLoggedIn = awaitItem()
-            assertThat(stateSuccessLoggedIn.loggedInState).isEqualTo(LoggedInState.LoggedIn(A_SESSION_ID))
-        }
-    }
-
-    @Test
-    fun `present - submit`() = runTest {
-        val authenticationService = FakeAuthenticationService()
-        val oidcActionFlow = DefaultOidcActionFlow()
-        val presenter = LoginRootPresenter(
-            authenticationService,
-            oidcActionFlow,
-        )
-        authenticationService.givenHomeserver(A_HOMESERVER)
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            initialState.eventSink.invoke(LoginRootEvents.SetLogin(A_USER_NAME))
-            initialState.eventSink.invoke(LoginRootEvents.SetPassword(A_PASSWORD))
-            skipItems(1)
-            val loginAndPasswordState = awaitItem()
-            loginAndPasswordState.eventSink.invoke(LoginRootEvents.Submit)
-            val submitState = awaitItem()
-            assertThat(submitState.loggedInState).isEqualTo(LoggedInState.LoggingIn)
-            val loggedInState = awaitItem()
-            assertThat(loggedInState.loggedInState).isEqualTo(LoggedInState.LoggedIn(A_SESSION_ID))
-        }
-    }
-
-    @Test
-    fun `present - submit with error`() = runTest {
-        val authenticationService = FakeAuthenticationService()
-        val oidcActionFlow = DefaultOidcActionFlow()
-        val presenter = LoginRootPresenter(
-            authenticationService,
-            oidcActionFlow,
-        )
-        authenticationService.givenHomeserver(A_HOMESERVER)
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            initialState.eventSink.invoke(LoginRootEvents.SetLogin(A_USER_NAME))
-            initialState.eventSink.invoke(LoginRootEvents.SetPassword(A_PASSWORD))
-            skipItems(1)
-            val loginAndPasswordState = awaitItem()
-            authenticationService.givenLoginError(A_THROWABLE)
-            loginAndPasswordState.eventSink.invoke(LoginRootEvents.Submit)
-            val submitState = awaitItem()
-            assertThat(submitState.loggedInState).isEqualTo(LoggedInState.LoggingIn)
-            val loggedInState = awaitItem()
-            assertThat(loggedInState.loggedInState).isEqualTo(LoggedInState.ErrorLoggingIn(A_THROWABLE))
-        }
-    }
-
-    @Test
-    fun `present - clear error`() = runTest {
-        val authenticationService = FakeAuthenticationService()
-        val oidcActionFlow = DefaultOidcActionFlow()
-        val presenter = LoginRootPresenter(
-            authenticationService,
-            oidcActionFlow,
-        )
-        authenticationService.givenHomeserver(A_HOMESERVER)
-        moleculeFlow(RecompositionClock.Immediate) {
-            presenter.present()
-        }.test {
-            val initialState = awaitItem()
-            // Submit will return an error
-            authenticationService.givenLoginError(A_THROWABLE)
-            initialState.eventSink(LoginRootEvents.Submit)
-            awaitItem() // Skip LoggingIn state
-
-            // Check an error was returned
-            val submittedState = awaitItem()
-            assertThat(submittedState.loggedInState).isEqualTo(LoggedInState.ErrorLoggingIn(A_THROWABLE))
-
-            // Assert the error is then cleared
-            submittedState.eventSink(LoginRootEvents.ClearError)
-            val clearedState = awaitItem()
-            assertThat(clearedState.loggedInState).isEqualTo(LoggedInState.NotLoggedIn)
-        }
-    }
-}

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/changeaccountprovider/ChangeAccountProviderPresenterTest.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.changeaccountprovider
+
+import app.cash.molecule.RecompositionClock
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+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.ChangeServerPresenter
+import io.element.android.libraries.matrix.test.auth.FakeAuthenticationService
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class ChangeAccountProviderPresenterTest {
+    @Test
+    fun `present - initial state`() = runTest {
+        val changeServerPresenter = ChangeServerPresenter(
+            FakeAuthenticationService(),
+            AccountProviderDataSource()
+        )
+        val presenter = ChangeAccountProviderPresenter(
+            changeServerPresenter
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.accountProviders).isEqualTo(
+                listOf(
+                    AccountProvider(
+                        title = "matrix.org",
+                        subtitle = null,
+                        isPublic = true,
+                        isMatrixOrg = true,
+                        isValid = true,
+                        supportSlidingSync = true,
+                    )
+                )
+            )
+        }
+    }
+}

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

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.confirmaccountprovider
+
+import app.cash.molecule.RecompositionClock
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
+import io.element.android.features.login.impl.util.defaultAccountProvider
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.matrix.test.A_HOMESERVER
+import io.element.android.libraries.matrix.test.A_HOMESERVER_OIDC
+import io.element.android.libraries.matrix.test.A_THROWABLE
+import io.element.android.libraries.matrix.test.auth.FakeAuthenticationService
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class ConfirmAccountProviderPresenterTest {
+    @Test
+    fun `present - initial test`() = runTest {
+        val presenter = ConfirmAccountProviderPresenter(
+            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
+            AccountProviderDataSource(),
+            FakeAuthenticationService(),
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.isAccountCreation).isFalse()
+            assertThat(initialState.submitEnabled).isTrue()
+            assertThat(initialState.accountProvider).isEqualTo(defaultAccountProvider)
+            assertThat(initialState.loginFlow).isEqualTo(Async.Uninitialized)
+        }
+    }
+
+    @Test
+    fun `present - continue password login`() = runTest {
+        val authServer = FakeAuthenticationService()
+        val presenter = ConfirmAccountProviderPresenter(
+            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
+            AccountProviderDataSource(),
+            authServer,
+        )
+        authServer.givenHomeserver(A_HOMESERVER)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(ConfirmAccountProviderEvents.Continue)
+            val loadingState = awaitItem()
+            assertThat(loadingState.submitEnabled).isTrue()
+            assertThat(loadingState.loginFlow).isInstanceOf(Async.Loading::class.java)
+            val successState = awaitItem()
+            assertThat(successState.submitEnabled).isFalse()
+            assertThat(successState.loginFlow).isInstanceOf(Async.Success::class.java)
+            assertThat(successState.loginFlow.dataOrNull()).isEqualTo(LoginFlow.PasswordLogin)
+        }
+    }
+
+    @Test
+    fun `present - continue oidc`() = runTest {
+        val authServer = FakeAuthenticationService()
+        val presenter = ConfirmAccountProviderPresenter(
+            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
+            AccountProviderDataSource(),
+            authServer,
+        )
+        authServer.givenHomeserver(A_HOMESERVER_OIDC)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(ConfirmAccountProviderEvents.Continue)
+            val loadingState = awaitItem()
+            assertThat(loadingState.submitEnabled).isTrue()
+            assertThat(loadingState.loginFlow).isInstanceOf(Async.Loading::class.java)
+            val successState = awaitItem()
+            assertThat(successState.submitEnabled).isFalse()
+            assertThat(successState.loginFlow).isInstanceOf(Async.Success::class.java)
+            assertThat(successState.loginFlow.dataOrNull()).isInstanceOf(LoginFlow.OidcFlow::class.java)
+        }
+    }
+
+    @Test
+    fun `present - submit fails`() = runTest {
+        val authServer = FakeAuthenticationService()
+        val presenter = ConfirmAccountProviderPresenter(
+            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
+            AccountProviderDataSource(),
+            authServer,
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            authServer.givenChangeServerError(Throwable())
+            initialState.eventSink.invoke(ConfirmAccountProviderEvents.Continue)
+            skipItems(1) // Loading
+            val failureState = awaitItem()
+            assertThat(failureState.submitEnabled).isFalse()
+            assertThat(failureState.loginFlow).isInstanceOf(Async.Failure::class.java)
+        }
+    }
+
+    @Test
+    fun `present - clear error`() = runTest {
+        val authenticationService = FakeAuthenticationService()
+        val presenter = ConfirmAccountProviderPresenter(
+            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
+            AccountProviderDataSource(),
+            authenticationService,
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+
+            // Submit will return an error
+            authenticationService.givenChangeServerError(A_THROWABLE)
+            initialState.eventSink(ConfirmAccountProviderEvents.Continue)
+
+            skipItems(1) // Loading
+
+            // Check an error was returned
+            val submittedState = awaitItem()
+            assertThat(submittedState.loginFlow).isInstanceOf(Async.Failure::class.java)
+
+            // Assert the error is then cleared
+            submittedState.eventSink(ConfirmAccountProviderEvents.ClearError)
+            val clearedState = awaitItem()
+            assertThat(clearedState.loginFlow).isEqualTo(Async.Uninitialized)
+        }
+    }
+}

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

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.loginpassword
+
+import app.cash.molecule.RecompositionClock
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
+import io.element.android.features.login.impl.util.defaultAccountProvider
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.test.A_HOMESERVER
+import io.element.android.libraries.matrix.test.A_PASSWORD
+import io.element.android.libraries.matrix.test.A_SESSION_ID
+import io.element.android.libraries.matrix.test.A_THROWABLE
+import io.element.android.libraries.matrix.test.A_USER_NAME
+import io.element.android.libraries.matrix.test.auth.FakeAuthenticationService
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class LoginPasswordPresenterTest {
+    @Test
+    fun `present - initial state`() = runTest {
+        val authenticationService = FakeAuthenticationService()
+        val accountProviderDataSource = AccountProviderDataSource()
+        val presenter = LoginPasswordPresenter(
+            authenticationService,
+            accountProviderDataSource,
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.accountProvider).isEqualTo(defaultAccountProvider)
+            assertThat(initialState.formState).isEqualTo(LoginFormState.Default)
+            assertThat(initialState.loginAction).isEqualTo(Async.Uninitialized)
+            assertThat(initialState.submitEnabled).isFalse()
+        }
+    }
+
+    @Test
+    fun `present - enter login and password`() = runTest {
+        val authenticationService = FakeAuthenticationService()
+        val accountProviderDataSource = AccountProviderDataSource()
+        val presenter = LoginPasswordPresenter(
+            authenticationService,
+            accountProviderDataSource,
+        )
+        authenticationService.givenHomeserver(A_HOMESERVER)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(LoginPasswordEvents.SetLogin(A_USER_NAME))
+            val loginState = awaitItem()
+            assertThat(loginState.formState).isEqualTo(LoginFormState(login = A_USER_NAME, password = ""))
+            assertThat(loginState.submitEnabled).isFalse()
+            initialState.eventSink.invoke(LoginPasswordEvents.SetPassword(A_PASSWORD))
+            val loginAndPasswordState = awaitItem()
+            assertThat(loginAndPasswordState.formState).isEqualTo(LoginFormState(login = A_USER_NAME, password = A_PASSWORD))
+            assertThat(loginAndPasswordState.submitEnabled).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - submit`() = runTest {
+        val authenticationService = FakeAuthenticationService()
+        val accountProviderDataSource = AccountProviderDataSource()
+        val presenter = LoginPasswordPresenter(
+            authenticationService,
+            accountProviderDataSource,
+        )
+        authenticationService.givenHomeserver(A_HOMESERVER)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(LoginPasswordEvents.SetLogin(A_USER_NAME))
+            initialState.eventSink.invoke(LoginPasswordEvents.SetPassword(A_PASSWORD))
+            skipItems(1)
+            val loginAndPasswordState = awaitItem()
+            loginAndPasswordState.eventSink.invoke(LoginPasswordEvents.Submit)
+            val submitState = awaitItem()
+            assertThat(submitState.loginAction).isInstanceOf(Async.Loading::class.java)
+            val loggedInState = awaitItem()
+            assertThat(loggedInState.loginAction).isEqualTo(Async.Success(A_SESSION_ID))
+        }
+    }
+
+    @Test
+    fun `present - submit with error`() = runTest {
+        val authenticationService = FakeAuthenticationService()
+        val accountProviderDataSource = AccountProviderDataSource()
+        val presenter = LoginPasswordPresenter(
+            authenticationService,
+            accountProviderDataSource,
+        )
+        authenticationService.givenHomeserver(A_HOMESERVER)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(LoginPasswordEvents.SetLogin(A_USER_NAME))
+            initialState.eventSink.invoke(LoginPasswordEvents.SetPassword(A_PASSWORD))
+            skipItems(1)
+            val loginAndPasswordState = awaitItem()
+            authenticationService.givenLoginError(A_THROWABLE)
+            loginAndPasswordState.eventSink.invoke(LoginPasswordEvents.Submit)
+            val submitState = awaitItem()
+            assertThat(submitState.loginAction).isInstanceOf(Async.Loading::class.java)
+            val loggedInState = awaitItem()
+            assertThat(loggedInState.loginAction).isEqualTo(Async.Failure<SessionId>(A_THROWABLE))
+        }
+    }
+
+    @Test
+    fun `present - clear error`() = runTest {
+        val authenticationService = FakeAuthenticationService()
+        val accountProviderDataSource = AccountProviderDataSource()
+        val presenter = LoginPasswordPresenter(
+            authenticationService,
+            accountProviderDataSource,
+        )
+        authenticationService.givenHomeserver(A_HOMESERVER)
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(LoginPasswordEvents.SetLogin(A_USER_NAME))
+            initialState.eventSink.invoke(LoginPasswordEvents.SetPassword(A_PASSWORD))
+            skipItems(1)
+            val loginAndPasswordState = awaitItem()
+            authenticationService.givenLoginError(A_THROWABLE)
+            loginAndPasswordState.eventSink.invoke(LoginPasswordEvents.Submit)
+            val submitState = awaitItem()
+            assertThat(submitState.loginAction).isInstanceOf(Async.Loading::class.java)
+            val loggedInState = awaitItem()
+            // Check an error was returned
+            assertThat(loggedInState.loginAction).isEqualTo(Async.Failure<SessionId>(A_THROWABLE))
+            // Assert the error is then cleared
+            loggedInState.eventSink(LoginPasswordEvents.ClearError)
+            val clearedState = awaitItem()
+            assertThat(clearedState.loginAction).isEqualTo(Async.Uninitialized)
+        }
+    }
+}

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/searchaccountprovider/SearchAccountProviderPresenterTest.kt

@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.login.impl.screens.searchaccountprovider
+
+import app.cash.molecule.RecompositionClock
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
+import io.element.android.features.login.impl.changeserver.ChangeServerPresenter
+import io.element.android.features.login.impl.resolver.HomeserverResolver
+import io.element.android.features.login.impl.resolver.network.FakeWellknownRequest
+import io.element.android.features.login.impl.resolver.network.WellKnown
+import io.element.android.features.login.impl.resolver.network.WellKnownBaseConfig
+import io.element.android.features.login.impl.resolver.network.WellKnownSlidingSyncConfig
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.matrix.test.A_HOMESERVER_URL
+import io.element.android.libraries.matrix.test.auth.FakeAuthenticationService
+import io.element.android.tests.testutils.testCoroutineDispatchers
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class SearchAccountProviderPresenterTest {
+    @Test
+    fun `present - initial state`() = runTest {
+        val fakeWellknownRequest = FakeWellknownRequest()
+        val changeServerPresenter = ChangeServerPresenter(
+            FakeAuthenticationService(),
+            AccountProviderDataSource()
+        )
+        val presenter = SearchAccountProviderPresenter(
+            HomeserverResolver(testCoroutineDispatchers(), fakeWellknownRequest),
+            changeServerPresenter
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.userInput).isEmpty()
+            assertThat(initialState.userInputResult).isEqualTo(Async.Uninitialized)
+        }
+    }
+
+    @Test
+    fun `present - enter text no result`() = runTest {
+        val fakeWellknownRequest = FakeWellknownRequest()
+        val changeServerPresenter = ChangeServerPresenter(
+            FakeAuthenticationService(),
+            AccountProviderDataSource()
+        )
+        val presenter = SearchAccountProviderPresenter(
+            HomeserverResolver(testCoroutineDispatchers(), fakeWellknownRequest),
+            changeServerPresenter
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(SearchAccountProviderEvents.UserInput("test"))
+            val withInputState = awaitItem()
+            assertThat(withInputState.userInput).isEqualTo("test")
+            assertThat(initialState.userInputResult).isEqualTo(Async.Uninitialized)
+            assertThat(awaitItem().userInputResult).isInstanceOf(Async.Loading::class.java)
+            assertThat(awaitItem().userInputResult).isEqualTo(Async.Uninitialized)
+        }
+    }
+
+    @Test
+    fun `present - enter valid url no wellknown`() = runTest {
+        val fakeWellknownRequest = FakeWellknownRequest()
+        val changeServerPresenter = ChangeServerPresenter(
+            FakeAuthenticationService(),
+            AccountProviderDataSource()
+        )
+        val presenter = SearchAccountProviderPresenter(
+            HomeserverResolver(testCoroutineDispatchers(), fakeWellknownRequest),
+            changeServerPresenter
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(SearchAccountProviderEvents.UserInput("https://test.org"))
+            val withInputState = awaitItem()
+            assertThat(withInputState.userInput).isEqualTo("https://test.org")
+            assertThat(initialState.userInputResult).isEqualTo(Async.Uninitialized)
+            assertThat(awaitItem().userInputResult).isInstanceOf(Async.Loading::class.java)
+            assertThat(awaitItem().userInputResult).isEqualTo(
+                Async.Success(
+                    listOf(
+                        aHomeserverData(homeserverUrl = "https://test.org", isWellknownValid = false, supportSlidingSync = false)
+                    )
+                )
+            )
+        }
+    }
+
+    @Test
+    fun `present - enter text one result no sliding sync`() = runTest {
+        val fakeWellknownRequest = FakeWellknownRequest()
+        fakeWellknownRequest.givenResultMap(
+            mapOf(
+                "https://test.org" to aWellKnown().copy(slidingSyncProxy = null),
+            )
+        )
+        val changeServerPresenter = ChangeServerPresenter(
+            FakeAuthenticationService(),
+            AccountProviderDataSource()
+        )
+        val presenter = SearchAccountProviderPresenter(
+            HomeserverResolver(testCoroutineDispatchers(), fakeWellknownRequest),
+            changeServerPresenter
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(SearchAccountProviderEvents.UserInput("test"))
+            val withInputState = awaitItem()
+            assertThat(withInputState.userInput).isEqualTo("test")
+            assertThat(initialState.userInputResult).isEqualTo(Async.Uninitialized)
+            assertThat(awaitItem().userInputResult).isInstanceOf(Async.Loading::class.java)
+            assertThat(awaitItem().userInputResult).isEqualTo(
+                Async.Success(
+                    listOf(
+                        aHomeserverData(homeserverUrl = "https://test.org", isWellknownValid = true, supportSlidingSync = false)
+                    )
+                )
+            )
+        }
+    }
+
+    @Test
+    fun `present - enter text one result with sliding sync`() = runTest {
+        val fakeWellknownRequest = FakeWellknownRequest()
+        fakeWellknownRequest.givenResultMap(
+            mapOf(
+                "https://test.io" to aWellKnown(),
+            )
+        )
+        val changeServerPresenter = ChangeServerPresenter(
+            FakeAuthenticationService(),
+            AccountProviderDataSource()
+        )
+        val presenter = SearchAccountProviderPresenter(
+            HomeserverResolver(testCoroutineDispatchers(), fakeWellknownRequest),
+            changeServerPresenter
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(SearchAccountProviderEvents.UserInput("test"))
+            val withInputState = awaitItem()
+            assertThat(withInputState.userInput).isEqualTo("test")
+            assertThat(initialState.userInputResult).isEqualTo(Async.Uninitialized)
+            assertThat(awaitItem().userInputResult).isInstanceOf(Async.Loading::class.java)
+            assertThat(awaitItem().userInputResult).isEqualTo(
+                Async.Success(
+                    listOf(
+                        aHomeserverData(homeserverUrl = "https://test.io")
+                    )
+                )
+            )
+        }
+    }
+
+    private fun aWellKnown(): WellKnown {
+        return WellKnown(
+            homeServer = WellKnownBaseConfig(
+                baseURL = A_HOMESERVER_URL
+            ),
+            identityServer = WellKnownBaseConfig(
+                baseURL = A_HOMESERVER_URL
+            ),
+            slidingSyncProxy = WellKnownSlidingSyncConfig(
+                url = A_HOMESERVER_URL
+            )
+        )
+    }
+}

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/TimelineItemsFactory.kt

@@ -26,6 +26,7 @@ import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.collections.immutable.toPersistentList
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -45,7 +46,7 @@ class TimelineItemsFactory @Inject constructor(
     private val timelineItemGrouper: TimelineItemGrouper,
 ) {
 
-    private val timelineItems = MutableStateFlow(emptyList<TimelineItem>().toImmutableList())
+    private val timelineItems = MutableStateFlow(persistentListOf<TimelineItem>())
     private val timelineItemsCache = arrayListOf<TimelineItem?>()
 
     // Items from rust sdk, used for diffing
@@ -95,7 +96,7 @@ class TimelineItemsFactory @Inject constructor(
         Timber.v("Time to apply diff on new list of ${newTimelineItems.size} items: $timeToDiff ms")
     }
 
-    private suspend fun buildAndCacheItem(
+    private fun buildAndCacheItem(
         timelineItems: List<MatrixTimelineItem>,
         index: Int
     ): TimelineItem? {

features/messages/impl/src/test/kotlin/io/element/android/features/messages/MessagesPresenterTest.kt

@@ -330,7 +330,7 @@ class MessagesPresenterTest {
             networkMonitor = FakeNetworkMonitor(),
             snackbarDispatcher = SnackbarDispatcher(),
             messageSummaryFormatter = FakeMessageSummaryFormatter(),
-            dispatchers = testCoroutineDispatchers(testScheduler),
+            dispatchers = testCoroutineDispatchers(),
         )
     }
 }

features/messages/impl/src/test/kotlin/io/element/android/features/messages/fixtures/timelineItemsFactory.kt

@@ -37,8 +37,9 @@ import io.element.android.libraries.dateformatter.test.FakeDaySeparatorFormatter
 import io.element.android.libraries.eventformatter.api.TimelineEventFormatter
 import io.element.android.libraries.matrix.api.timeline.item.event.EventTimelineItem
 import io.element.android.tests.testutils.testCoroutineDispatchers
+import kotlinx.coroutines.test.TestScope
 
-internal fun aTimelineItemsFactory(): TimelineItemsFactory {
+internal fun TestScope.aTimelineItemsFactory(): TimelineItemsFactory {
     val timelineEventFormatter = aTimelineEventFormatter()
     return TimelineItemsFactory(
         dispatchers = testCoroutineDispatchers(),

features/messages/impl/src/test/kotlin/io/element/android/features/messages/media/viewer/MediaViewerPresenterTest.kt

@@ -23,7 +23,6 @@ import app.cash.molecule.RecompositionClock
 import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
-import io.element.android.features.messages.impl.media.local.MediaInfo
 import io.element.android.features.messages.impl.media.local.aFileInfo
 import io.element.android.features.messages.impl.media.viewer.MediaViewerEvents
 import io.element.android.features.messages.impl.media.viewer.MediaViewerNode
@@ -49,8 +48,8 @@ class MediaViewerPresenterTest {
 
     @Test
     fun `present - download media success scenario`() = runTest {
-        val coroutineDispatchers = testCoroutineDispatchers(testScheduler, useUnconfinedTestDispatcher = false)
-        val mediaLoader = FakeMediaLoader(coroutineDispatchers)
+        val coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = false)
+        val mediaLoader = FakeMediaLoader()
         val mediaActions = FakeLocalMediaActions(coroutineDispatchers)
         val presenter = aMediaViewerPresenter(mediaLoader, mediaActions)
         moleculeFlow(RecompositionClock.Immediate) {
@@ -70,8 +69,8 @@ class MediaViewerPresenterTest {
 
     @Test
     fun `present - check all actions `() = runTest {
-        val coroutineDispatchers = testCoroutineDispatchers(testScheduler, useUnconfinedTestDispatcher = false)
-        val mediaLoader = FakeMediaLoader(coroutineDispatchers)
+        val coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = false)
+        val mediaLoader = FakeMediaLoader()
         val mediaActions = FakeLocalMediaActions(coroutineDispatchers)
         val presenter = aMediaViewerPresenter(mediaLoader, mediaActions)
         moleculeFlow(RecompositionClock.Immediate) {
@@ -119,8 +118,8 @@ class MediaViewerPresenterTest {
 
     @Test
     fun `present - download media failure then retry with success scenario`() = runTest {
-        val coroutineDispatchers = testCoroutineDispatchers(testScheduler, useUnconfinedTestDispatcher = false)
-        val mediaLoader = FakeMediaLoader(coroutineDispatchers)
+        val coroutineDispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = false)
+        val mediaLoader = FakeMediaLoader()
         val mediaActions = FakeLocalMediaActions(coroutineDispatchers)
         val presenter = aMediaViewerPresenter(mediaLoader, mediaActions)
         moleculeFlow(RecompositionClock.Immediate) {

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

@@ -53,6 +53,7 @@ class OnBoardingNode @AssistedInject constructor(
             state = state,
             modifier = modifier,
             onSignIn = ::onSignIn,
+            onCreateAccount = ::onSignUp,
         )
     }
 }

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

@@ -120,9 +120,7 @@ private fun OnBoardingButtons(
     ButtonColumnMolecule(modifier = modifier) {
         if (state.canLoginWithQrCode) {
             Button(
-                onClick = {
-                    onSignInWithQrCode()
-                },
+                onClick = onSignInWithQrCode,
                 enabled = true,
                 modifier = Modifier
                     .fillMaxWidth()
@@ -136,9 +134,7 @@ private fun OnBoardingButtons(
             }
         }
         Button(
-            onClick = {
-                onSignIn()
-            },
+            onClick = onSignIn,
             enabled = true,
             modifier = Modifier
                 .fillMaxWidth()
@@ -148,9 +144,7 @@ private fun OnBoardingButtons(
         }
         if (state.canCreateAccount) {
             OutlinedButton(
-                onClick = {
-                    onCreateAccount()
-                },
+                onClick = onCreateAccount,
                 enabled = true,
                 modifier = Modifier
                     .fillMaxWidth()

features/onboarding/impl/src/main/res/values/localazy.xml

@@ -4,6 +4,6 @@
   <string name="screen_onboarding_sign_in_with_qr_code">"Sign in with QR code"</string>
   <string name="screen_onboarding_sign_up">"Create account"</string>
   <string name="screen_onboarding_subtitle">"Communicate and collaborate securely"</string>
-  <string name="screen_onboarding_welcome_subtitle">"Welcome to the %1$s Beta. Supercharged, for speed and simplicity."</string>
+  <string name="screen_onboarding_welcome_subtitle">"Welcome to %1$s. Supercharged, for speed and simplicity."</string>
   <string name="screen_onboarding_welcome_title">"Be in your Element"</string>
 </resources>

features/rageshake/impl/src/main/kotlin/io/element/android/features/rageshake/impl/bugreport/BugReportView.kt

@@ -81,12 +81,9 @@ fun BugReportView(
             .systemBarsPadding()
             .imePadding()
     ) {
-        val scrollState = rememberScrollState()
         Column(
             modifier = Modifier
-                .verticalScroll(
-                    state = scrollState,
-                )
+                .verticalScroll(state = rememberScrollState())
                 .padding(horizontal = 16.dp),
         ) {
             val isError = state.sending is Async.Failure

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/invite/RoomInviteMembersView.kt

@@ -147,7 +147,7 @@ private fun RoomInviteMembersSearchBar(
     selectedUsers: ImmutableList<MatrixUser>,
     active: Boolean,
     modifier: Modifier = Modifier,
-    placeHolderTitle: String = stringResource(io.element.android.libraries.ui.strings.R.string.common_search_for_someone),
+    placeHolderTitle: String = stringResource(StringR.string.common_search_for_someone),
     onActiveChanged: (Boolean) -> Unit = {},
     onTextChanged: (String) -> Unit = {},
     onUserToggled: (MatrixUser) -> Unit = {},

features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/RoomDetailsPresenterTests.kt

@@ -252,7 +252,7 @@ class RoomDetailsPresenterTests {
 
 fun aMatrixClient(
     sessionId: SessionId = A_SESSION_ID,
-) = FakeMatrixClient()
+) = FakeMatrixClient(sessionId = sessionId)
 
 fun aMatrixRoom(
     roomId: RoomId = A_ROOM_ID,

features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/impl/invite/RoomInviteMembersPresenterTest.kt

@@ -38,6 +38,7 @@ import io.element.android.libraries.usersearch.api.UserSearchResult
 import io.element.android.libraries.usersearch.test.FakeUserRepository
 import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.collections.immutable.ImmutableList
+import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 
@@ -368,7 +369,7 @@ internal class RoomInviteMembersPresenterTest {
         }
     }
 
-    private fun createDataSource(
+    private fun TestScope.createDataSource(
         matrixRoom: MatrixRoom = aMatrixRoom().apply {
             givenRoomMembersState(MatrixRoomMembersState.Ready(aRoomMemberList()))
         },

features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/members/RoomMemberListPresenterTests.kt

@@ -35,6 +35,7 @@ import io.element.android.libraries.matrix.api.room.MatrixRoomMembersState
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
 import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 
@@ -165,7 +166,7 @@ class RoomMemberListPresenterTests {
 }
 
 @ExperimentalCoroutinesApi
-private fun createDataSource(
+private fun TestScope.createDataSource(
     matrixRoom: MatrixRoom = aMatrixRoom().apply {
         givenRoomMembersState(MatrixRoomMembersState.Ready(aRoomMemberList()))
     },
@@ -173,7 +174,7 @@ private fun createDataSource(
 ) = RoomMemberListDataSource(matrixRoom, coroutineDispatchers)
 
 @ExperimentalCoroutinesApi
-private fun createPresenter(
+private fun TestScope.createPresenter(
     matrixRoom: MatrixRoom = FakeMatrixRoom(),
     roomMemberListDataSource: RoomMemberListDataSource = createDataSource(),
     coroutineDispatchers: CoroutineDispatchers = testCoroutineDispatchers()

gradle/libs.versions.toml

@@ -139,7 +139,7 @@ jsoup = { module = "org.jsoup:jsoup", version.ref = "jsoup" }
 appyx_core = { module = "com.bumble.appyx:core", version.ref = "appyx" }
 molecule-runtime = { module = "app.cash.molecule:molecule-runtime", version.ref = "molecule" }
 timber = "com.jakewharton.timber:timber:5.0.1"
-matrix_sdk = "org.matrix.rustcomponents:sdk-android:0.1.17"
+matrix_sdk = "org.matrix.rustcomponents:sdk-android:0.1.18"
 sqldelight-driver-android = { module = "com.squareup.sqldelight:android-driver", version.ref = "sqldelight" }
 sqldelight-driver-jvm = { module = "com.squareup.sqldelight:sqlite-driver", version.ref = "sqldelight" }
 sqldelight-coroutines = { module = "com.squareup.sqldelight:coroutines-extensions", version.ref = "sqldelight" }

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/atomic/atoms/RoundedIconAtom.kt

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.designsystem.atomic.atoms
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Home
+import androidx.compose.material3.MaterialTheme
+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.graphics.vector.ImageVector
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.LocalColors
+import io.element.android.libraries.designsystem.theme.components.Icon
+
+/**
+ * RoundedIconAtom is an atom which displays an icon inside a rounded container.
+ *
+ * @param modifier the modifier to apply to this layout
+ * @param size the size of the icon
+ * @param resourceId the resource id of the icon to display, exclusive with [imageVector]
+ * @param imageVector the image vector of the icon to display, exclusive with [resourceId]
+ * @param tint the tint to apply to the icon
+ */
+@Composable
+fun RoundedIconAtom(
+    modifier: Modifier = Modifier,
+    size: RoundedIconAtomSize = RoundedIconAtomSize.Large,
+    resourceId: Int? = null,
+    imageVector: ImageVector? = null,
+    tint: Color = MaterialTheme.colorScheme.secondary
+) {
+    Box(
+        modifier = modifier
+            .size(size.toContainerSize())
+            .background(
+                color = LocalColors.current.quinary,
+                shape = RoundedCornerShape(size.toCornerSize())
+            )
+    ) {
+        Icon(
+            modifier = Modifier
+                .align(Alignment.Center)
+                .size(size.toIconSize()),
+            tint = tint,
+            resourceId = resourceId,
+            imageVector = imageVector,
+            contentDescription = "",
+        )
+    }
+}
+
+private fun RoundedIconAtomSize.toContainerSize(): Dp {
+    return when (this) {
+        RoundedIconAtomSize.Medium -> 30.dp
+        RoundedIconAtomSize.Large -> 70.dp
+    }
+}
+
+private fun RoundedIconAtomSize.toCornerSize(): Dp {
+    return when (this) {
+        RoundedIconAtomSize.Medium -> 8.dp
+        RoundedIconAtomSize.Large -> 14.dp
+    }
+}
+
+private fun RoundedIconAtomSize.toIconSize(): Dp {
+    return when (this) {
+        RoundedIconAtomSize.Medium -> 16.dp
+        RoundedIconAtomSize.Large -> 48.dp
+    }
+}
+
+@Preview
+@Composable
+internal fun RoundedIconAtomLightPreview() =
+    ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+internal fun RoundedIconAtomDarkPreview() =
+    ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        RoundedIconAtom(
+            size = RoundedIconAtomSize.Medium,
+            imageVector = Icons.Filled.Home,
+        )
+        RoundedIconAtom(
+            size = RoundedIconAtomSize.Large,
+            imageVector = Icons.Filled.Home,
+        )
+    }
+}
+
+enum class RoundedIconAtomSize {
+    Medium,
+    Large
+}

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/atomic/molecules/IconTitleSubtitleMolecule.kt

@@ -16,55 +16,55 @@
 
 package io.element.android.libraries.designsystem.atomic.molecules
 
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.MaterialTheme
 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.graphics.vector.ImageVector
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import io.element.android.libraries.designsystem.ElementTextStyles
 import io.element.android.libraries.designsystem.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.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
-import io.element.android.libraries.designsystem.theme.LocalColors
-import io.element.android.libraries.designsystem.theme.components.Icon
 import io.element.android.libraries.designsystem.theme.components.Text
 
+/**
+ * IconTitleSubtitleMolecule is a molecule which displays an icon, a title and a subtitle.
+ *
+ * @param title the title to display
+ * @param subTitle the subtitle to display
+ * @param modifier the modifier to apply to this layout
+ * @param iconResourceId the resource id of the icon to display, exclusive with [iconImageVector]
+ * @param iconImageVector the image vector of the icon to display, exclusive with [iconResourceId]
+ * @param iconTint the tint to apply to the icon
+ */
 @Composable
 fun IconTitleSubtitleMolecule(
-    iconResourceId: Int,
     title: String,
     subTitle: String,
     modifier: Modifier = Modifier,
+    iconResourceId: Int? = null,
+    iconImageVector: ImageVector? = null,
+    iconTint: Color = MaterialTheme.colorScheme.primary,
 ) {
     Column(modifier) {
-        Box(
+        RoundedIconAtom(
             modifier = Modifier
-                .size(width = 70.dp, height = 70.dp)
-                .align(Alignment.CenterHorizontally)
-                .background(
-                    color = LocalColors.current.quinary,
-                    shape = RoundedCornerShape(14.dp)
-                )
-        ) {
-            Icon(
-                modifier = Modifier
-                    .align(Alignment.Center)
-                    .size(width = 48.dp, height = 48.dp),
-                tint = MaterialTheme.colorScheme.secondary,
-                resourceId = iconResourceId,
-                contentDescription = "",
-            )
-        }
+                .align(Alignment.CenterHorizontally),
+            size = RoundedIconAtomSize.Large,
+            resourceId = iconResourceId,
+            imageVector = iconImageVector,
+            tint = iconTint,
+        )
         Spacer(modifier = Modifier.height(16.dp))
         Text(
             text = title,

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

@@ -37,8 +37,8 @@ fun LabelledTextField(
     value: String,
     modifier: Modifier = Modifier,
     placeholder: String? = null,
-    maxLines: Int = Int.MAX_VALUE,
     singleLine: Boolean = false,
+    maxLines: Int = if (singleLine) 1 else Int.MAX_VALUE,
     onValueChange: (String) -> Unit = {},
 ) {
     Column(

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/components/async/AsyncFailure.kt

@@ -24,12 +24,14 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
 import io.element.android.libraries.designsystem.theme.components.Button
 import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.ui.strings.R as StringR
 
 @Composable
 fun AsyncFailure(
@@ -43,11 +45,11 @@ fun AsyncFailure(
             .padding(vertical = 32.dp),
         horizontalAlignment = Alignment.CenterHorizontally,
     ) {
-        Text(text = throwable.message ?: "An error occurred")
+        Text(text = throwable.message ?: stringResource(id = StringR.string.error_unknown))
         if (onRetry != null) {
             Spacer(modifier = Modifier.height(24.dp))
             Button(onClick = onRetry) {
-                Text(text = "Retry")
+                Text(text = stringResource(id = StringR.string.action_retry))
             }
         }
     }

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/components/form/TextFieldLocalState.kt

@@ -22,5 +22,5 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 
 @Composable
-public fun textFieldState(stateValue: String): MutableState<String> =
+fun textFieldState(stateValue: String): MutableState<String> =
     remember(stateValue) { mutableStateOf(stateValue) }

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/components/preferences/PreferenceScreen.kt

@@ -69,14 +69,11 @@ fun PreferenceView(
             )
         },
         content = {
-            val scrollState = rememberScrollState()
             Column(
                 modifier = Modifier
                     .padding(it)
                     .consumeWindowInsets(it)
-                    .verticalScroll(
-                        state = scrollState,
-                    )
+                    .verticalScroll(state = rememberScrollState())
             ) {
                 content()
             }

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/theme/components/Icon.kt

@@ -30,6 +30,54 @@ import androidx.compose.ui.tooling.preview.Preview
 import io.element.android.libraries.designsystem.preview.ElementThemedPreview
 import io.element.android.libraries.designsystem.preview.PreviewGroup
 
+/**
+ * Icon is a wrapper around [androidx.compose.material3.Icon] which allows to use
+ * [ImageVector], [ImageBitmap] or [DrawableRes] as icon source.
+ *
+ * @param contentDescription the content description to be used for accessibility
+ * @param modifier the modifier to apply to this layout
+ * @param tint the tint to apply to the icon
+ * @param imageVector the image vector of the icon to display, exclusive with [bitmap] and [resourceId]
+ * @param bitmap the bitmap of the icon to display, exclusive with [imageVector] and [resourceId]
+ * @param resourceId the resource id of the icon to display, exclusive with [imageVector] and [bitmap]
+ */
+@Composable
+fun Icon(
+    contentDescription: String?,
+    modifier: Modifier = Modifier,
+    tint: Color = LocalContentColor.current,
+    imageVector: ImageVector? = null,
+    bitmap: ImageBitmap? = null,
+    @DrawableRes resourceId: Int? = null,
+) {
+    when {
+        imageVector != null -> {
+            Icon(
+                imageVector = imageVector,
+                contentDescription = contentDescription,
+                modifier = modifier,
+                tint = tint
+            )
+        }
+        bitmap != null -> {
+            Icon(
+                bitmap = bitmap,
+                contentDescription = contentDescription,
+                modifier = modifier,
+                tint = tint
+            )
+        }
+        resourceId != null -> {
+            Icon(
+                resourceId = resourceId,
+                contentDescription = contentDescription,
+                modifier = modifier,
+                tint = tint
+            )
+        }
+    }
+}
+
 @Composable
 fun Icon(
     imageVector: ImageVector,

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/theme/components/OutlinedTextField.kt

@@ -67,7 +67,7 @@ fun OutlinedTextField(
     keyboardOptions: KeyboardOptions = KeyboardOptions.Default,
     keyboardActions: KeyboardActions = KeyboardActions.Default,
     singleLine: Boolean = false,
-    maxLines: Int = Int.MAX_VALUE,
+    maxLines: Int = if (singleLine) 1 else Int.MAX_VALUE,
     interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
     shape: Shape = OutlinedTextFieldDefaults.shape,
     colors: TextFieldColors = OutlinedTextFieldDefaults.colors()

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/theme/components/TextField.kt

@@ -68,7 +68,7 @@ fun TextField(
     keyboardOptions: KeyboardOptions = KeyboardOptions.Default,
     keyboardActions: KeyboardActions = KeyboardActions.Default,
     singleLine: Boolean = false,
-    maxLines: Int = Int.MAX_VALUE,
+    maxLines: Int = if (singleLine) 1 else Int.MAX_VALUE,
     interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
     shape: Shape = TextFieldDefaults.shape,
     colors: TextFieldColors = TextFieldDefaults.colors()

libraries/eventformatter/impl/src/main/kotlin/io/element/android/libraries/eventformatter/impl/StateContentFormatter.kt

@@ -22,6 +22,7 @@ import io.element.android.libraries.matrix.api.timeline.item.event.StateContent
 import io.element.android.services.toolbox.api.strings.StringProvider
 import timber.log.Timber
 import javax.inject.Inject
+import io.element.android.libraries.ui.strings.R as StringR
 
 class StateContentFormatter @Inject constructor(
     private val sp: StringProvider,
@@ -49,7 +50,7 @@ class StateContentFormatter @Inject constructor(
                     sp.getString(R.string.state_event_room_created, senderDisplayName)
                 }
             }
-            is OtherState.RoomEncryption -> sp.getString(io.element.android.libraries.ui.strings.R.string.common_encryption_enabled)
+            is OtherState.RoomEncryption -> sp.getString(StringR.string.common_encryption_enabled)
             is OtherState.RoomName -> {
                 val hasRoomName = content.name != null
                 when {

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/MatrixTimeline.kt

@@ -42,4 +42,6 @@ interface MatrixTimeline {
     suspend fun editMessage(originalEventId: EventId, message: String): Result<Unit>
 
     suspend fun replyMessage(inReplyToEventId: EventId, message: String): Result<Unit>
+
+    suspend fun fetchDetailsForEvent(eventId: EventId): Result<Unit>
 }

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

@@ -34,7 +34,6 @@ import io.element.android.libraries.matrix.impl.media.map
 import io.element.android.libraries.matrix.impl.timeline.RustMatrixTimeline
 import io.element.android.services.toolbox.api.systemclock.SystemClock
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -259,7 +258,7 @@ class RustMatrixRoom(
         }
     }
 
-    override suspend fun sendReaction(emoji: String, eventId: EventId): Result<Unit> = withContext(Dispatchers.IO) {
+    override suspend fun sendReaction(emoji: String, eventId: EventId): Result<Unit> = withContext(coroutineDispatchers.io) {
         runCatching {
             innerRoom.sendReaction(key = emoji, eventId = eventId.value)
         }
@@ -267,28 +266,28 @@ class RustMatrixRoom(
 
     @OptIn(ExperimentalUnsignedTypes::class)
     override suspend fun updateAvatar(mimeType: String, data: ByteArray): Result<Unit> =
-        withContext(Dispatchers.IO) {
+        withContext(coroutineDispatchers.io) {
             runCatching {
                 innerRoom.uploadAvatar(mimeType, data.toUByteArray().toList())
             }
         }
 
     override suspend fun removeAvatar(): Result<Unit> =
-        withContext(Dispatchers.IO) {
+        withContext(coroutineDispatchers.io) {
             runCatching {
                 innerRoom.removeAvatar()
             }
         }
 
     override suspend fun setName(name: String): Result<Unit> =
-        withContext(Dispatchers.IO) {
+        withContext(coroutineDispatchers.io) {
             runCatching {
                 innerRoom.setName(name)
             }
         }
 
     override suspend fun setTopic(topic: String): Result<Unit> =
-        withContext(Dispatchers.IO) {
+        withContext(coroutineDispatchers.io) {
             runCatching {
                 innerRoom.setTopic(topic)
             }

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

@@ -22,15 +22,13 @@ import io.element.android.libraries.matrix.impl.timeline.item.event.EventTimelin
 import io.element.android.libraries.matrix.impl.timeline.item.virtual.VirtualTimelineItemMapper
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import org.matrix.rustcomponents.sdk.Room
 import org.matrix.rustcomponents.sdk.TimelineItem
-import timber.log.Timber
 
 class MatrixTimelineItemMapper(
-    private val room: Room,
+    private val fetchDetailsForEvent: suspend (EventId) -> Result<Unit>,
     private val coroutineScope: CoroutineScope,
     private val virtualTimelineItemMapper: VirtualTimelineItemMapper = VirtualTimelineItemMapper(),
-    private val eventTimelineItemMapper: EventTimelineItemMapper= EventTimelineItemMapper(),
+    private val eventTimelineItemMapper: EventTimelineItemMapper = EventTimelineItemMapper(),
 ) {
 
     fun map(timelineItem: TimelineItem): MatrixTimelineItem = timelineItem.use {
@@ -40,7 +38,7 @@ class MatrixTimelineItemMapper(
 
 
             if (eventTimelineItem.hasNotLoadedInReplyTo() && eventTimelineItem.eventId != null) {
-                fetchDetailsForEvent(eventTimelineItem.eventId!!)
+                fetchEventDetails(eventTimelineItem.eventId!!)
             }
 
             return MatrixTimelineItem.Event(eventTimelineItem)
@@ -53,12 +51,7 @@ class MatrixTimelineItemMapper(
         return MatrixTimelineItem.Other
     }
 
-    private fun fetchDetailsForEvent(eventId: EventId) = coroutineScope.launch {
-        runCatching {
-            room.fetchDetailsForEvent(eventId.value)
-        }.onFailure {
-            Timber.e(it)
-        }
+    private fun fetchEventDetails(eventId: EventId) = coroutineScope.launch {
+        fetchDetailsForEvent(eventId)
     }
-
 }

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

@@ -63,7 +63,7 @@ class RustMatrixTimeline(
     )
 
     private val timelineItemFactory = MatrixTimelineItemMapper(
-        room = innerRoom,
+        fetchDetailsForEvent = this::fetchDetailsForEvent,
         coroutineScope = coroutineScope,
         virtualTimelineItemMapper = VirtualTimelineItemMapper(),
         eventTimelineItemMapper = EventTimelineItemMapper(
@@ -130,6 +130,12 @@ class RustMatrixTimeline(
         return matrixRoom.replyMessage(inReplyToEventId, message)
     }
 
+    override suspend fun fetchDetailsForEvent(eventId: EventId): Result<Unit> = withContext(coroutineDispatchers.io) {
+        runCatching {
+            innerRoom.fetchDetailsForEvent(eventId.value)
+        }
+    }
+
     override suspend fun paginateBackwards(requestSize: Int, untilNumberOfItems: Int): Result<Unit> = withContext(coroutineDispatchers.io) {
         runCatching {
             Timber.v("Start back paginating for room ${matrixRoom.roomId} ")

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

@@ -37,18 +37,15 @@ import io.element.android.libraries.matrix.test.pushers.FakePushersService
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
 import io.element.android.libraries.matrix.test.room.FakeRoomSummaryDataSource
 import io.element.android.libraries.matrix.test.verification.FakeSessionVerificationService
-import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.test.StandardTestDispatcher
 
 class FakeMatrixClient(
     override val sessionId: SessionId = A_SESSION_ID,
-    private val coroutineDispatchers: CoroutineDispatchers = testCoroutineDispatchers(),
     private val userDisplayName: Result<String> = Result.success(A_USER_NAME),
     private val userAvatarURLString: Result<String> = Result.success(AN_AVATAR_URL),
     override val roomSummaryDataSource: RoomSummaryDataSource = FakeRoomSummaryDataSource(),
     override val invitesDataSource: RoomSummaryDataSource = FakeRoomSummaryDataSource(),
-    override val mediaLoader: MatrixMediaLoader = FakeMediaLoader(coroutineDispatchers),
+    override val mediaLoader: MatrixMediaLoader = FakeMediaLoader(),
     private val sessionVerificationService: FakeSessionVerificationService = FakeSessionVerificationService(),
     private val pushersService: FakePushersService = FakePushersService(),
     private val notificationService: FakeNotificationService = FakeNotificationService(),

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/media/FakeMediaLoader.kt

@@ -16,37 +16,37 @@
 
 package io.element.android.libraries.matrix.test.media
 
-import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
 import io.element.android.libraries.matrix.api.media.MediaFile
 import io.element.android.libraries.matrix.api.media.MediaSource
 import io.element.android.libraries.matrix.test.FAKE_DELAY_IN_MS
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.withContext
-import kotlin.coroutines.coroutineContext
 
-class FakeMediaLoader(private val coroutineDispatchers: CoroutineDispatchers) : MatrixMediaLoader {
+class FakeMediaLoader : MatrixMediaLoader {
 
     var shouldFail = false
 
-    override suspend fun loadMediaContent(source: MediaSource): Result<ByteArray> = withContext(coroutineDispatchers.io){
-        if (shouldFail) {
+    override suspend fun loadMediaContent(source: MediaSource): Result<ByteArray> {
+        delay(FAKE_DELAY_IN_MS)
+        return if (shouldFail) {
             Result.failure(RuntimeException())
         } else {
             Result.success(ByteArray(0))
         }
     }
 
-    override suspend fun loadMediaThumbnail(source: MediaSource, width: Long, height: Long): Result<ByteArray>  = withContext(coroutineDispatchers.io){
-        if (shouldFail) {
+    override suspend fun loadMediaThumbnail(source: MediaSource, width: Long, height: Long): Result<ByteArray> {
+        delay(FAKE_DELAY_IN_MS)
+        return if (shouldFail) {
             Result.failure(RuntimeException())
         } else {
             Result.success(ByteArray(0))
         }
     }
 
-    override suspend fun downloadMediaFile(source: MediaSource, mimeType: String?, body: String?): Result<MediaFile> = withContext(coroutineDispatchers.io){
-        if (shouldFail) {
+    override suspend fun downloadMediaFile(source: MediaSource, mimeType: String?, body: String?): Result<MediaFile> {
+        delay(FAKE_DELAY_IN_MS)
+        return if (shouldFail) {
             Result.failure(RuntimeException())
         } else {
             Result.success(FakeMediaFile(""))

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/timeline/FakeMatrixTimeline.kt

@@ -82,4 +82,8 @@ class FakeMatrixTimeline(
     override suspend fun replyMessage(inReplyToEventId: EventId, message: String): Result<Unit> {
         return Result.success(Unit)
     }
+
+    override suspend fun fetchDetailsForEvent(eventId: EventId): Result<Unit> {
+        return Result.success(Unit)
+    }
 }