chore(auth): Move hosted UI sign in to use case (#3242)

Author: mattcreaser

aws-auth-cognito/src/main/java/com/amplifyframework/auth/cognito/AWSCognitoAuthPlugin.kt

@@ -260,28 +260,36 @@ class AWSCognitoAuthPlugin : AuthPlugin<AWSCognitoAuthService>() {
         callingActivity: Activity,
         onSuccess: Consumer<AuthSignInResult>,
         onError: Consumer<AuthException>
-    ) = enqueue(onSuccess, onError) { queueFacade.signInWithSocialWebUI(provider, callingActivity) }
+    ) = enqueue(onSuccess, onError) {
+        useCaseFactory.webUiSignIn().execute(callingActivity, provider)
+    }
 
     override fun signInWithSocialWebUI(
         provider: AuthProvider,
         callingActivity: Activity,
         options: AuthWebUISignInOptions,
         onSuccess: Consumer<AuthSignInResult>,
         onError: Consumer<AuthException>
-    ) = enqueue(onSuccess, onError) { queueFacade.signInWithSocialWebUI(provider, callingActivity, options) }
+    ) = enqueue(onSuccess, onError) {
+        useCaseFactory.webUiSignIn().execute(callingActivity, provider, options)
+    }
 
     override fun signInWithWebUI(
         callingActivity: Activity,
         onSuccess: Consumer<AuthSignInResult>,
         onError: Consumer<AuthException>
-    ) = enqueue(onSuccess, onError) { queueFacade.signInWithWebUI(callingActivity) }
+    ) = enqueue(onSuccess, onError) {
+        useCaseFactory.webUiSignIn().execute(callingActivity = callingActivity)
+    }
 
     override fun signInWithWebUI(
         callingActivity: Activity,
         options: AuthWebUISignInOptions,
         onSuccess: Consumer<AuthSignInResult>,
         onError: Consumer<AuthException>
-    ) = enqueue(onSuccess, onError) { queueFacade.signInWithWebUI(callingActivity, options) }
+    ) = enqueue(onSuccess, onError) {
+        useCaseFactory.webUiSignIn().execute(callingActivity = callingActivity, options = options)
+    }
 
     override fun handleWebUISignInResponse(intent: Intent?) {
         pluginScope.launch {

aws-auth-cognito/src/main/java/com/amplifyframework/auth/cognito/KotlinAuthFacadeInternal.kt

@@ -15,60 +15,14 @@
 
 package com.amplifyframework.auth.cognito
 
-import android.app.Activity
-import com.amplifyframework.auth.AuthProvider
 import com.amplifyframework.auth.AuthSession
 import com.amplifyframework.auth.options.AuthFetchSessionOptions
-import com.amplifyframework.auth.options.AuthWebUISignInOptions
-import com.amplifyframework.auth.result.AuthSignInResult
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 import kotlin.coroutines.suspendCoroutine
 
 internal class KotlinAuthFacadeInternal(private val delegate: RealAWSCognitoAuthPlugin) {
 
-    suspend fun signInWithSocialWebUI(provider: AuthProvider, callingActivity: Activity): AuthSignInResult =
-        suspendCoroutine { continuation ->
-            delegate.signInWithSocialWebUI(
-                provider,
-                callingActivity,
-                { continuation.resume(it) },
-                { continuation.resumeWithException(it) }
-            )
-        }
-
-    suspend fun signInWithSocialWebUI(
-        provider: AuthProvider,
-        callingActivity: Activity,
-        options: AuthWebUISignInOptions
-    ): AuthSignInResult = suspendCoroutine { continuation ->
-        delegate.signInWithSocialWebUI(
-            provider,
-            callingActivity,
-            options,
-            { continuation.resume(it) },
-            { continuation.resumeWithException(it) }
-        )
-    }
-
-    suspend fun signInWithWebUI(callingActivity: Activity): AuthSignInResult = suspendCoroutine { continuation ->
-        delegate.signInWithWebUI(
-            callingActivity,
-            { continuation.resume(it) },
-            { continuation.resumeWithException(it) }
-        )
-    }
-
-    suspend fun signInWithWebUI(callingActivity: Activity, options: AuthWebUISignInOptions): AuthSignInResult =
-        suspendCoroutine { continuation ->
-            delegate.signInWithWebUI(
-                callingActivity,
-                options,
-                { continuation.resume(it) },
-                { continuation.resumeWithException(it) }
-            )
-        }
-
     suspend fun fetchAuthSession(): AuthSession = suspendCoroutine { continuation ->
         delegate.fetchAuthSession(
             { continuation.resume(it) },

aws-auth-cognito/src/main/java/com/amplifyframework/auth/cognito/RealAWSCognitoAuthPlugin.kt

@@ -15,21 +15,14 @@
 
 package com.amplifyframework.auth.cognito
 
-import android.app.Activity
 import androidx.annotation.WorkerThread
 import com.amplifyframework.AmplifyException
 import com.amplifyframework.annotations.InternalAmplifyApi
 import com.amplifyframework.auth.AWSCognitoAuthMetadataType
 import com.amplifyframework.auth.AuthChannelEventName
 import com.amplifyframework.auth.AuthException
-import com.amplifyframework.auth.AuthProvider
 import com.amplifyframework.auth.AuthSession
-import com.amplifyframework.auth.cognito.exceptions.configuration.InvalidOauthConfigurationException
-import com.amplifyframework.auth.cognito.exceptions.configuration.InvalidUserPoolConfigurationException
-import com.amplifyframework.auth.cognito.exceptions.invalidstate.SignedInException
 import com.amplifyframework.auth.cognito.exceptions.service.InvalidAccountTypeException
-import com.amplifyframework.auth.cognito.helpers.HostedUIHelper
-import com.amplifyframework.auth.cognito.options.AWSCognitoAuthWebUISignInOptions
 import com.amplifyframework.auth.exceptions.ConfigurationException
 import com.amplifyframework.auth.exceptions.InvalidStateException
 import com.amplifyframework.auth.exceptions.NotAuthorizedException
@@ -38,26 +31,18 @@ import com.amplifyframework.auth.exceptions.SessionExpiredException
 import com.amplifyframework.auth.exceptions.SignedOutException
 import com.amplifyframework.auth.exceptions.UnknownException
 import com.amplifyframework.auth.options.AuthFetchSessionOptions
-import com.amplifyframework.auth.options.AuthWebUISignInOptions
-import com.amplifyframework.auth.result.AuthSignInResult
-import com.amplifyframework.auth.result.step.AuthNextSignInStep
-import com.amplifyframework.auth.result.step.AuthSignInStep
 import com.amplifyframework.core.Amplify
 import com.amplifyframework.core.Consumer
 import com.amplifyframework.hub.HubChannel
 import com.amplifyframework.hub.HubEvent
 import com.amplifyframework.logging.Logger
 import com.amplifyframework.statemachine.StateChangeListenerToken
 import com.amplifyframework.statemachine.codegen.data.AmplifyCredential
-import com.amplifyframework.statemachine.codegen.data.SignInData
 import com.amplifyframework.statemachine.codegen.errors.SessionError
 import com.amplifyframework.statemachine.codegen.events.AuthEvent
-import com.amplifyframework.statemachine.codegen.events.AuthenticationEvent
 import com.amplifyframework.statemachine.codegen.events.AuthorizationEvent
 import com.amplifyframework.statemachine.codegen.states.AuthState
-import com.amplifyframework.statemachine.codegen.states.AuthenticationState
 import com.amplifyframework.statemachine.codegen.states.AuthorizationState
-import com.amplifyframework.statemachine.codegen.states.HostedUISignInState
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.flow.collect
@@ -111,172 +96,6 @@ internal class RealAWSCognitoAuthPlugin(
         authStateMachine.state.takeWhile { it !is AuthState.Configured && it !is AuthState.Error }.collect()
     }
 
-    fun signInWithSocialWebUI(
-        provider: AuthProvider,
-        callingActivity: Activity,
-        onSuccess: Consumer<AuthSignInResult>,
-        onError: Consumer<AuthException>
-    ) {
-        signInWithSocialWebUI(
-            provider,
-            callingActivity,
-            AWSCognitoAuthWebUISignInOptions.builder().build(),
-            onSuccess,
-            onError
-        )
-    }
-
-    fun signInWithSocialWebUI(
-        provider: AuthProvider,
-        callingActivity: Activity,
-        options: AuthWebUISignInOptions,
-        onSuccess: Consumer<AuthSignInResult>,
-        onError: Consumer<AuthException>
-    ) {
-        signInWithHostedUI(
-            provider = provider,
-            callingActivity = callingActivity,
-            options = options,
-            onSuccess = onSuccess,
-            onError = onError
-        )
-    }
-
-    fun signInWithWebUI(
-        callingActivity: Activity,
-        onSuccess: Consumer<AuthSignInResult>,
-        onError: Consumer<AuthException>
-    ) {
-        signInWithWebUI(callingActivity, AuthWebUISignInOptions.builder().build(), onSuccess, onError)
-    }
-
-    fun signInWithWebUI(
-        callingActivity: Activity,
-        options: AuthWebUISignInOptions,
-        onSuccess: Consumer<AuthSignInResult>,
-        onError: Consumer<AuthException>
-    ) {
-        signInWithHostedUI(
-            callingActivity = callingActivity,
-            options = options,
-            onSuccess = onSuccess,
-            onError = onError
-        )
-    }
-
-    private fun signInWithHostedUI(
-        provider: AuthProvider? = null,
-        callingActivity: Activity,
-        options: AuthWebUISignInOptions,
-        onSuccess: Consumer<AuthSignInResult>,
-        onError: Consumer<AuthException>
-    ) {
-        authStateMachine.getCurrentState { authState ->
-            when (authState.authNState) {
-                is AuthenticationState.NotConfigured -> onError.accept(
-                    InvalidUserPoolConfigurationException()
-                )
-                // Continue sign in
-                is AuthenticationState.SignedOut -> {
-                    if (configuration.oauth == null) {
-                        onError.accept(InvalidOauthConfigurationException())
-                        return@getCurrentState
-                    }
-
-                    _signInWithHostedUI(
-                        callingActivity = callingActivity,
-                        options = options,
-                        onSuccess = onSuccess,
-                        onError = onError,
-                        provider = provider
-                    )
-                }
-                is AuthenticationState.SignedIn -> onError.accept(SignedInException())
-                is AuthenticationState.SigningIn -> {
-                    val token = StateChangeListenerToken()
-                    authStateMachine.listen(
-                        token,
-                        { authState ->
-                            when (authState.authNState) {
-                                is AuthenticationState.SignedOut -> {
-                                    authStateMachine.cancel(token)
-                                    _signInWithHostedUI(
-                                        callingActivity = callingActivity,
-                                        options = options,
-                                        onSuccess = onSuccess,
-                                        onError = onError,
-                                        provider = provider
-                                    )
-                                }
-                                else -> Unit
-                            }
-                        },
-                        {
-                            authStateMachine.send(AuthenticationEvent(AuthenticationEvent.EventType.CancelSignIn()))
-                        }
-                    )
-                }
-                else -> onError.accept(InvalidStateException())
-            }
-        }
-    }
-
-    private fun _signInWithHostedUI(
-        callingActivity: Activity,
-        options: AuthWebUISignInOptions,
-        onSuccess: Consumer<AuthSignInResult>,
-        onError: Consumer<AuthException>,
-        provider: AuthProvider? = null
-    ) {
-        val token = StateChangeListenerToken()
-        authStateMachine.listen(
-            token,
-            { authState ->
-                val authNState = authState.authNState
-                val authZState = authState.authZState
-                when {
-                    authNState is AuthenticationState.SigningIn -> {
-                        val hostedUISignInState = authNState.signInState.hostedUISignInState
-                        if (hostedUISignInState is HostedUISignInState.Error) {
-                            authStateMachine.cancel(token)
-                            val exception = hostedUISignInState.exception
-                            onError.accept(
-                                if (exception is AuthException) {
-                                    exception
-                                } else {
-                                    UnknownException("Sign in failed", exception)
-                                }
-                            )
-                            authStateMachine.send(AuthenticationEvent(AuthenticationEvent.EventType.CancelSignIn()))
-                        }
-                    }
-                    authNState is AuthenticationState.SignedIn &&
-                        authZState is AuthorizationState.SessionEstablished -> {
-                        authStateMachine.cancel(token)
-                        val authSignInResult =
-                            AuthSignInResult(
-                                true,
-                                AuthNextSignInStep(AuthSignInStep.DONE, mapOf(), null, null, null, null)
-                            )
-                        onSuccess.accept(authSignInResult)
-                        sendHubEvent(AuthChannelEventName.SIGNED_IN.toString())
-                    }
-                    else -> Unit
-                }
-            },
-            {
-                val hostedUIOptions = HostedUIHelper.createHostedUIOptions(callingActivity, provider, options)
-                authStateMachine.send(
-                    AuthenticationEvent(
-                        AuthenticationEvent.EventType.SignInRequested(
-                            SignInData.HostedUISignInData(hostedUIOptions)
-                        )
-                    )
-                )
-            }
-        )
-    }
-
     fun fetchAuthSession(onSuccess: Consumer<AuthSession>, onError: Consumer<AuthException>) {
         fetchAuthSession(AuthFetchSessionOptions.defaults(), onSuccess, onError)
     }

aws-auth-cognito/src/main/java/com/amplifyframework/auth/cognito/usecases/AuthUseCaseFactory.kt

@@ -179,6 +179,11 @@ internal class AuthUseCaseFactory(
         signOut = signOut()
     )
 
+    fun webUiSignIn() = WebUiSignInUseCase(
+        stateMachine = stateMachine,
+        configuration = authEnvironment.configuration
+    )
+
     fun webUISignInResponse() = WebUiSignInResponseUseCase(
         stateMachine = stateMachine,
         authEnvironment = authEnvironment