Restore Link Sign Up viewmodel and tests

link/src/main/java/com/stripe/android/link/account/DefaultLinkAccountManager.kt

@@ -144,10 +144,7 @@ internal class DefaultLinkAccountManager @Inject constructor(
         }
     }
 
-    /**
-     * Registers the user for a new Link account.
-     */
-    private suspend fun signUp(
+    override suspend fun signUp(
         email: String,
         phone: String,
         country: String,

link/src/main/java/com/stripe/android/link/account/LinkAccountManager.kt

@@ -3,6 +3,7 @@ package com.stripe.android.link.account
 import com.stripe.android.link.LinkPaymentDetails
 import com.stripe.android.link.model.AccountStatus
 import com.stripe.android.link.model.LinkAccount
+import com.stripe.android.link.ui.inline.SignUpConsentAction
 import com.stripe.android.link.ui.inline.UserInput
 import com.stripe.android.model.ConsumerSession
 import com.stripe.android.model.ConsumerSessionLookup
@@ -29,6 +30,17 @@ internal interface LinkAccountManager {
         startSession: Boolean = true,
     ): Result<LinkAccount?>
 
+    /**
+     * Registers the user for a new Link account.
+     */
+    suspend fun signUp(
+        email: String,
+        phone: String,
+        country: String,
+        name: String?,
+        consentAction: SignUpConsentAction
+    ): Result<LinkAccount>
+
     /**
      * Use the user input in memory to sign in to an existing account or sign up for a new Link
      * account, starting verification if needed.

link/src/main/java/com/stripe/android/link/analytics/DefaultLinkEventsReporter.kt

@@ -34,6 +34,10 @@ internal class DefaultLinkEventsReporter @Inject constructor(
         fireEvent(LinkEvent.SignUpCheckboxChecked)
     }
 
+    override fun onSignupFlowPresented() {
+        fireEvent(LinkEvent.SignUpFlowPresented)
+    }
+
     override fun onSignupStarted(isInline: Boolean) {
         durationProvider.start(DurationProvider.Key.LinkSignup)
         fireEvent(LinkEvent.SignUpStart)

link/src/main/java/com/stripe/android/link/analytics/LinkEvent.kt

@@ -8,6 +8,10 @@ internal sealed class LinkEvent : AnalyticsEvent {
         override val eventName = "link.signup.checkbox_checked"
     }
 
+    data object SignUpFlowPresented : LinkEvent() {
+        override val eventName = "link.signup.flow_presented"
+    }
+
     object SignUpStart : LinkEvent() {
         override val eventName = "link.signup.start"
     }

link/src/main/java/com/stripe/android/link/analytics/LinkEventsReporter.kt

@@ -7,6 +7,7 @@ internal interface LinkEventsReporter {
     fun onInvalidSessionState(state: SessionState)
 
     fun onInlineSignupCheckboxChecked()
+    fun onSignupFlowPresented()
     fun onSignupStarted(isInline: Boolean = false)
     fun onSignupCompleted(isInline: Boolean = false)
     fun onSignupFailure(isInline: Boolean = false, error: Throwable)

link/src/main/java/com/stripe/android/link/ui/signup/SignUpScreenState.kt

@@ -0,0 +1,11 @@
+package com.stripe.android.link.ui.signup
+
+import androidx.compose.runtime.Immutable
+import com.stripe.android.core.strings.ResolvableString
+
+@Immutable
+internal data class SignUpScreenState(
+    val signUpEnabled: Boolean,
+    val signUpState: SignUpState = SignUpState.InputtingPrimaryField,
+    val errorMessage: ResolvableString? = null
+)

link/src/main/java/com/stripe/android/link/ui/signup/SignUpViewModel.kt

@@ -0,0 +1,195 @@
+package com.stripe.android.link.ui.signup
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import androidx.navigation.NavHostController
+import com.stripe.android.core.Logger
+import com.stripe.android.core.model.CountryCode
+import com.stripe.android.core.strings.resolvableString
+import com.stripe.android.link.LinkActivityContract
+import com.stripe.android.link.LinkScreen
+import com.stripe.android.link.account.LinkAccountManager
+import com.stripe.android.link.analytics.LinkEventsReporter
+import com.stripe.android.link.model.LinkAccount
+import com.stripe.android.link.ui.ErrorMessage
+import com.stripe.android.link.ui.getErrorMessage
+import com.stripe.android.link.ui.inline.SignUpConsentAction
+import com.stripe.android.model.PaymentIntent
+import com.stripe.android.model.SetupIntent
+import com.stripe.android.uicore.elements.EmailConfig
+import com.stripe.android.uicore.elements.NameConfig
+import com.stripe.android.uicore.elements.PhoneNumberController
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapLatest
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+import kotlin.time.Duration.Companion.seconds
+
+internal class SignUpViewModel @Inject constructor(
+    private val args: LinkActivityContract.Args,
+    private val linkAccountManager: LinkAccountManager,
+    private val linkEventsReporter: LinkEventsReporter,
+    private val logger: Logger
+) : ViewModel() {
+    internal var navController: NavHostController? = null
+    val emailController = EmailConfig.createController(
+        initialValue = args.configuration.customerInfo.email
+    )
+    val phoneNumberController = PhoneNumberController.createPhoneNumberController(
+        initialValue = args.configuration.customerInfo.phone.orEmpty(),
+        initiallySelectedCountryCode = args.configuration.customerInfo.billingCountryCode
+    )
+    val nameController = NameConfig.createController(
+        initialValue = args.configuration.customerInfo.name
+    )
+    private val _state = MutableStateFlow(
+        value = SignUpScreenState(
+            signUpEnabled = false
+        )
+    )
+
+    val state: StateFlow<SignUpScreenState> = _state
+
+    private val requiresNameCollection: Boolean
+        get() {
+            val countryCode = when (val stripeIntent = args.configuration.stripeIntent) {
+                is PaymentIntent -> stripeIntent.countryCode
+                is SetupIntent -> stripeIntent.countryCode
+            }
+            return countryCode != CountryCode.US.value
+        }
+
+    init {
+        viewModelScope.launch {
+            signUpEnabledListener()
+        }
+        viewModelScope.launch {
+            emailListener()
+        }
+        linkEventsReporter.onSignupFlowPresented()
+    }
+
+    private suspend fun signUpEnabledListener() {
+        combine(
+            flow = nameController.fieldState.map {
+                if (requiresNameCollection) {
+                    it.isValid()
+                } else {
+                    true
+                }
+            },
+            flow2 = emailController.fieldState.map { it.isValid() },
+            flow3 = phoneNumberController.isComplete
+        ) { nameComplete, emailComplete, phoneComplete ->
+            nameComplete && emailComplete && phoneComplete
+        }.collectLatest { formValid ->
+            updateState { it.copy(signUpEnabled = formValid) }
+        }
+    }
+
+    private suspend fun emailListener() {
+        emailController.formFieldValue.mapLatest { entry ->
+            entry.takeIf { it.isComplete }?.value
+        }.collectLatest { email ->
+            delay(LOOKUP_DEBOUNCE)
+            if (email != null) {
+                updateSignUpState(SignUpState.VerifyingEmail)
+                lookupConsumerEmail(email)
+            } else {
+                updateSignUpState(SignUpState.InputtingPrimaryField)
+            }
+        }
+    }
+
+    fun onSignUpClick() {
+        clearError()
+        viewModelScope.launch {
+            linkAccountManager.signUp(
+                email = emailController.fieldValue.value,
+                phone = phoneNumberController.fieldValue.value,
+                country = phoneNumberController.getCountryCode(),
+                name = nameController.fieldValue.value,
+                consentAction = SignUpConsentAction.Implied
+            ).fold(
+                onSuccess = {
+                    onAccountFetched(it)
+                    linkEventsReporter.onSignupCompleted()
+                },
+                onFailure = {
+                    onError(it)
+                    linkEventsReporter.onSignupFailure(error = it)
+                }
+            )
+        }
+    }
+
+    private fun onAccountFetched(linkAccount: LinkAccount?) {
+        if (linkAccount?.isVerified == true) {
+            navController?.popBackStack(LinkScreen.Wallet.route, inclusive = false)
+        } else {
+            navController?.navigate(LinkScreen.Verification.route)
+            // The sign up screen stays in the back stack.
+            // Clean up the state in case the user comes back.
+            emailController.onValueChange("")
+        }
+    }
+
+    private suspend fun lookupConsumerEmail(email: String) {
+        clearError()
+        linkAccountManager.lookupConsumer(email).fold(
+            onSuccess = {
+                if (it != null) {
+                    onAccountFetched(it)
+                } else {
+                    updateSignUpState(SignUpState.InputtingRemainingFields)
+                    linkEventsReporter.onSignupStarted()
+                }
+            },
+            onFailure = {
+                updateSignUpState(SignUpState.InputtingPrimaryField)
+                onError(it)
+            }
+        )
+    }
+
+    private fun onError(error: Throwable) {
+        logger.error("Error: ", error)
+        updateState {
+            it.copy(
+                errorMessage = when (val errorMessage = error.getErrorMessage()) {
+                    is ErrorMessage.FromResources -> {
+                        errorMessage.stringResId.resolvableString
+                    }
+                    is ErrorMessage.Raw -> {
+                        errorMessage.errorMessage.resolvableString
+                    }
+                }
+            )
+        }
+    }
+
+    private fun clearError() {
+        updateState { it.copy(errorMessage = null) }
+    }
+
+    private fun updateState(produceValue: (SignUpScreenState) -> SignUpScreenState) {
+        _state.update(produceValue)
+    }
+
+    private fun updateSignUpState(signUpState: SignUpState) {
+        updateState { old ->
+            old.copy(signUpState = signUpState)
+        }
+    }
+
+    companion object {
+        // How long to wait before triggering a call to lookup the email
+        internal val LOOKUP_DEBOUNCE = 1.seconds
+    }
+}

link/src/test/java/com/stripe/android/link/account/FakeLinkAccountManager.kt

@@ -3,6 +3,7 @@ package com.stripe.android.link.account
 import com.stripe.android.link.LinkPaymentDetails
 import com.stripe.android.link.model.AccountStatus
 import com.stripe.android.link.model.LinkAccount
+import com.stripe.android.link.ui.inline.SignUpConsentAction
 import com.stripe.android.link.ui.inline.UserInput
 import com.stripe.android.model.ConsumerPaymentDetails
 import com.stripe.android.model.ConsumerSession
@@ -21,6 +22,7 @@ internal open class FakeLinkAccountManager : LinkAccountManager {
     override val accountStatus: Flow<AccountStatus> = _accountStatus
 
     var lookupConsumerResult: Result<LinkAccount?> = Result.success(null)
+    var signUpResult: Result<LinkAccount> = Result.success(LinkAccount(ConsumerSession("", "", "", "")))
     var signInWithUserInputResult: Result<LinkAccount> = Result.success(LinkAccount(ConsumerSession("", "", "", "")))
     var logOutResult: Result<ConsumerSession> = Result.success(ConsumerSession("", "", "", ""))
     var createCardPaymentDetailsResult: Result<LinkPaymentDetails> = Result.success(
@@ -47,6 +49,16 @@ internal open class FakeLinkAccountManager : LinkAccountManager {
         return lookupConsumerResult
     }
 
+    override suspend fun signUp(
+        email: String,
+        phone: String,
+        country: String,
+        name: String?,
+        consentAction: SignUpConsentAction
+    ): Result<LinkAccount> {
+        return signUpResult
+    }
+
     override suspend fun signInWithUserInput(userInput: UserInput): Result<LinkAccount> {
         return signInWithUserInputResult
     }

link/src/test/java/com/stripe/android/link/analytics/FakeLinkEventsReporter.kt

@@ -0,0 +1,56 @@
+package com.stripe.android.link.analytics
+
+internal open class FakeLinkEventsReporter : LinkEventsReporter {
+    var calledCount = 0
+    override fun onInvalidSessionState(state: LinkEventsReporter.SessionState) {
+        throw NotImplementedError()
+    }
+
+    override fun onInlineSignupCheckboxChecked() {
+        throw NotImplementedError()
+    }
+
+    override fun onSignupFlowPresented() {
+        throw NotImplementedError()
+    }
+
+    override fun onSignupStarted(isInline: Boolean) {
+        throw NotImplementedError()
+    }
+
+    override fun onSignupCompleted(isInline: Boolean) {
+        throw NotImplementedError()
+    }
+
+    override fun onSignupFailure(isInline: Boolean, error: Throwable) {
+        throw NotImplementedError()
+    }
+
+    override fun onAccountLookupFailure(error: Throwable) {
+        throw NotImplementedError()
+    }
+
+    override fun onPopupShow() {
+        throw NotImplementedError()
+    }
+
+    override fun onPopupSuccess() {
+        throw NotImplementedError()
+    }
+
+    override fun onPopupCancel() {
+        throw NotImplementedError()
+    }
+
+    override fun onPopupError(error: Throwable) {
+        throw NotImplementedError()
+    }
+
+    override fun onPopupLogout() {
+        throw NotImplementedError()
+    }
+
+    override fun onPopupSkipped() {
+        throw NotImplementedError()
+    }
+}