Restore OIDC support.

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

@@ -17,6 +17,7 @@
 package io.element.android.features.login.impl.screens.confirmaccountprovider
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
@@ -26,8 +27,11 @@ import androidx.compose.runtime.rememberCoroutineScope
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
+import io.element.android.features.login.api.oidc.OidcAction
+import io.element.android.features.login.impl.DefaultLoginUserStory
 import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
 import io.element.android.features.login.impl.error.ChangeServerError
+import io.element.android.features.login.impl.oidc.customtab.DefaultOidcActionFlow
 import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.architecture.runCatchingUpdatingState
@@ -40,7 +44,9 @@ import java.net.URL
 class ConfirmAccountProviderPresenter @AssistedInject constructor(
     @Assisted private val params: Params,
     private val accountProviderDataSource: AccountProviderDataSource,
-    private val authenticationService: MatrixAuthenticationService
+    private val authenticationService: MatrixAuthenticationService,
+    private val defaultOidcActionFlow: DefaultOidcActionFlow,
+    private val defaultLoginUserStory: DefaultLoginUserStory,
 ) : Presenter<ConfirmAccountProviderState> {
 
     data class Params(
@@ -61,6 +67,14 @@ class ConfirmAccountProviderPresenter @AssistedInject constructor(
             mutableStateOf(Async.Uninitialized)
         }
 
+        LaunchedEffect(Unit) {
+            launch {
+                defaultOidcActionFlow.collect {
+                    onOidcAction(it, loginFlowAction)
+                }
+            }
+        }
+
         fun handleEvents(event: ConfirmAccountProviderEvents) {
             when (event) {
                 ConfirmAccountProviderEvents.Continue -> {
@@ -97,4 +111,33 @@ class ConfirmAccountProviderPresenter @AssistedInject constructor(
             }.getOrThrow()
         }.runCatchingUpdatingState(loginFlowAction, errorTransform = ChangeServerError::from)
     }
+
+    private suspend fun onOidcAction(
+        oidcAction: OidcAction?,
+        loginFlowAction: MutableState<Async<LoginFlow>>,
+    ) {
+        oidcAction ?: return
+        loginFlowAction.value = Async.Loading()
+        when (oidcAction) {
+            OidcAction.GoBack -> {
+                authenticationService.cancelOidcLogin()
+                    .onSuccess {
+                        loginFlowAction.value = Async.Uninitialized
+                    }
+                    .onFailure { failure ->
+                        loginFlowAction.value = Async.Failure(failure)
+                    }
+            }
+            is OidcAction.Success -> {
+                authenticationService.loginWithOidc(oidcAction.url)
+                    .onSuccess { _ ->
+                        defaultLoginUserStory.setLoginFlowIsDone(true)
+                    }
+                    .onFailure { failure ->
+                        loginFlowAction.value = Async.Failure(failure)
+                    }
+            }
+        }
+        defaultOidcActionFlow.reset()
+    }
 }

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

@@ -21,7 +21,7 @@ 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 DEFAULT_HOMESERVER_URL = "matrix.org"
     const val SLIDING_SYNC_READ_MORE_URL = "https://github.com/matrix-org/sliding-sync/blob/main/docs/Landing.md"
 }
 

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

@@ -20,9 +20,12 @@ import app.cash.molecule.RecompositionMode
 import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
+import io.element.android.features.login.impl.DefaultLoginUserStory
 import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource
+import io.element.android.features.login.impl.oidc.customtab.DefaultOidcActionFlow
 import io.element.android.features.login.impl.util.defaultAccountProvider
 import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 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
@@ -33,11 +36,7 @@ import org.junit.Test
 class ConfirmAccountProviderPresenterTest {
     @Test
     fun `present - initial test`() = runTest {
-        val presenter = ConfirmAccountProviderPresenter(
-            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
-            AccountProviderDataSource(),
-            FakeAuthenticationService(),
-        )
+        val presenter = createConfirmAccountProviderPresenter()
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -51,13 +50,11 @@ class ConfirmAccountProviderPresenterTest {
 
     @Test
     fun `present - continue password login`() = runTest {
-        val authServer = FakeAuthenticationService()
-        val presenter = ConfirmAccountProviderPresenter(
-            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
-            AccountProviderDataSource(),
-            authServer,
+        val authenticationService = FakeAuthenticationService()
+        val presenter = createConfirmAccountProviderPresenter(
+            matrixAuthenticationService = authenticationService,
         )
-        authServer.givenHomeserver(A_HOMESERVER)
+        authenticationService.givenHomeserver(A_HOMESERVER)
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -75,13 +72,11 @@ class ConfirmAccountProviderPresenterTest {
 
     @Test
     fun `present - continue oidc`() = runTest {
-        val authServer = FakeAuthenticationService()
-        val presenter = ConfirmAccountProviderPresenter(
-            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
-            AccountProviderDataSource(),
-            authServer,
+        val authenticationService = FakeAuthenticationService()
+        val presenter = createConfirmAccountProviderPresenter(
+            matrixAuthenticationService = authenticationService,
         )
-        authServer.givenHomeserver(A_HOMESERVER_OIDC)
+        authenticationService.givenHomeserver(A_HOMESERVER_OIDC)
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -99,17 +94,15 @@ class ConfirmAccountProviderPresenterTest {
 
     @Test
     fun `present - submit fails`() = runTest {
-        val authServer = FakeAuthenticationService()
-        val presenter = ConfirmAccountProviderPresenter(
-            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
-            AccountProviderDataSource(),
-            authServer,
+        val authenticationService = FakeAuthenticationService()
+        val presenter = createConfirmAccountProviderPresenter(
+            matrixAuthenticationService = authenticationService,
         )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
             val initialState = awaitItem()
-            authServer.givenChangeServerError(Throwable())
+            authenticationService.givenChangeServerError(Throwable())
             initialState.eventSink.invoke(ConfirmAccountProviderEvents.Continue)
             skipItems(1) // Loading
             val failureState = awaitItem()
@@ -121,10 +114,8 @@ class ConfirmAccountProviderPresenterTest {
     @Test
     fun `present - clear error`() = runTest {
         val authenticationService = FakeAuthenticationService()
-        val presenter = ConfirmAccountProviderPresenter(
-            ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
-            AccountProviderDataSource(),
-            authenticationService,
+        val presenter = createConfirmAccountProviderPresenter(
+            matrixAuthenticationService = authenticationService,
         )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
@@ -147,4 +138,18 @@ class ConfirmAccountProviderPresenterTest {
             assertThat(clearedState.loginFlow).isEqualTo(Async.Uninitialized)
         }
     }
+
+    private fun createConfirmAccountProviderPresenter(
+        params: ConfirmAccountProviderPresenter.Params = ConfirmAccountProviderPresenter.Params(isAccountCreation = false),
+        accountProviderDataSource: AccountProviderDataSource = AccountProviderDataSource(),
+        matrixAuthenticationService: MatrixAuthenticationService = FakeAuthenticationService(),
+        defaultOidcActionFlow: DefaultOidcActionFlow = DefaultOidcActionFlow(),
+        defaultLoginUserStory: DefaultLoginUserStory = DefaultLoginUserStory(),
+    ) = ConfirmAccountProviderPresenter(
+        params = params,
+        accountProviderDataSource = accountProviderDataSource,
+        authenticationService = matrixAuthenticationService,
+        defaultOidcActionFlow = defaultOidcActionFlow,
+        defaultLoginUserStory = defaultLoginUserStory,
+    )
 }