Show the site selector and set up my site screen after the application password login

WordPress/src/main/java/org/wordpress/android/ui/accounts/applicationpassword/ApplicationPasswordLoginActivity.kt

@@ -2,15 +2,22 @@ package org.wordpress.android.ui.accounts.applicationpassword
 
 import android.content.Intent
 import android.os.Bundle
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.lifecycleScope
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import org.wordpress.android.R
-import org.wordpress.android.util.ToastUtils
+import org.wordpress.android.ui.ActivityLauncher
 import org.wordpress.android.ui.main.BaseAppCompatActivity
 import org.wordpress.android.ui.main.WPMainActivity
+import org.wordpress.android.util.ToastUtils
+import org.wordpress.android.util.extensions.setContent
 import javax.inject.Inject
 
 @AndroidEntryPoint
@@ -23,6 +30,14 @@ class ApplicationPasswordLoginActivity: BaseAppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         initViewModel()
+        setContent {
+            Box(
+                contentAlignment = Alignment.Center,
+                modifier = Modifier.fillMaxSize()
+            ) {
+                CircularProgressIndicator()
+            }
+        }
     }
 
     private fun initViewModel() {
@@ -31,13 +46,13 @@ class ApplicationPasswordLoginActivity: BaseAppCompatActivity() {
         viewModel!!.setupSite(intent.dataString.orEmpty())
     }
 
-    private fun openMainActivity(siteUrl: String?) {
-        if (siteUrl != null) {
+    private fun openMainActivity(navigationActionData: ApplicationPasswordLoginViewModel.NavigationActionData) {
+        if (!navigationActionData.isError && navigationActionData.siteUrl != null) {
             ToastUtils.showToast(
                 this,
                 getString(
                     R.string.application_password_credentials_stored,
-                    siteUrl
+                    navigationActionData.siteUrl
                 )
             )
             intent.setData(null)
@@ -46,17 +61,35 @@ class ApplicationPasswordLoginActivity: BaseAppCompatActivity() {
                 this,
                 getString(
                     R.string.application_password_credentials_storing_error,
-                    siteUrl
+                    navigationActionData.siteUrl
                 )
             )
         }
-        val mainActivityIntent =
-            Intent(this, WPMainActivity::class.java)
-        mainActivityIntent.setFlags(
-            (Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_NEW_TASK
-                    or Intent.FLAG_ACTIVITY_CLEAR_TASK)
-        )
-        startActivity(mainActivityIntent)
+
+        if (navigationActionData.isError) {
+            ActivityLauncher.showMainActivity(this)
+        } else if (navigationActionData.showSiteSelector) {
+            ActivityLauncher.showMainActivityAndLoginEpilogue(this, navigationActionData.oldSitesIDs, false)
+        } else if (navigationActionData.showPostSignupInterstitial) {
+            ActivityLauncher.showPostSignupInterstitial(this)
+        } else {
+            val mainActivityIntent = Intent(this, WPMainActivity::class.java)
+            mainActivityIntent.setFlags(
+                (Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_NEW_TASK
+                        or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+            )
+            startActivity(mainActivityIntent)
+        }
         finish()
     }
+
+    override fun onStart() {
+        super.onStart()
+        viewModel?.onStart()
+    }
+
+    override fun onStop() {
+        super.onStop()
+        viewModel?.onStop()
+    }
 }

WordPress/src/main/java/org/wordpress/android/ui/accounts/applicationpassword/ApplicationPasswordLoginViewModel.kt

@@ -1,71 +1,132 @@
 package org.wordpress.android.ui.accounts.applicationpassword
 
-import android.util.Log
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import org.greenrobot.eventbus.Subscribe
+import org.greenrobot.eventbus.ThreadMode
+import org.wordpress.android.fluxc.Dispatcher
 import org.wordpress.android.fluxc.generated.SiteActionBuilder
 import org.wordpress.android.fluxc.network.discovery.SelfHostedEndpointFinder
-import org.wordpress.android.fluxc.store.SiteStore.RefreshSitesXMLRPCPayload
 import org.wordpress.android.fluxc.store.SiteStore
+import org.wordpress.android.fluxc.store.SiteStore.OnProfileFetched
+import org.wordpress.android.fluxc.store.SiteStore.OnSiteChanged
+import org.wordpress.android.fluxc.store.SiteStore.RefreshSitesXMLRPCPayload
+import org.wordpress.android.fluxc.utils.AppLogWrapper
+import org.wordpress.android.login.util.SiteUtils
 import org.wordpress.android.modules.IO_THREAD
 import org.wordpress.android.ui.accounts.login.ApplicationPasswordLoginHelper
-
+import org.wordpress.android.ui.accounts.login.ApplicationPasswordLoginHelper.UriLogin
+import org.wordpress.android.ui.prefs.AppPrefsWrapper
+import org.wordpress.android.util.AppLog
+import org.wordpress.android.util.UrlUtils
 import javax.inject.Inject
 import javax.inject.Named
 
-private const val TAG = "ApplicationPasswordLoginViewModel"
-
 class ApplicationPasswordLoginViewModel @Inject constructor(
     @Named(IO_THREAD) private val ioDispatcher: CoroutineDispatcher,
+    // Dispatcher is the way to dispatch actions to Flux. It will call siteStore.onAction()
+    private val dispatcher: Dispatcher,
     private val applicationPasswordLoginHelper: ApplicationPasswordLoginHelper,
     private val selfHostedEndpointFinder: SelfHostedEndpointFinder,
     private val siteStore: SiteStore,
+    private val appPrefsWrapper: AppPrefsWrapper,
+    private val appLogWrapper: AppLogWrapper,
 ) : ViewModel() {
-    private val _onFinishedEvent = MutableSharedFlow<String?>()
+    private val _onFinishedEvent = MutableSharedFlow<NavigationActionData>()
     /**
      * A shared flow that emits the site URL when the setup is finished.
      * It can emit null if the site could not be set up.
      */
     val onFinishedEvent = _onFinishedEvent.asSharedFlow()
 
+    private var currentUrlLogin: UriLogin? = null
+    private var oldSitesIDs: ArrayList<Int>? = null
+
+    fun onStart() {
+        dispatcher.register(this)
+        oldSitesIDs = SiteUtils.getCurrentSiteIds(siteStore, false)
+    }
+
+    fun onStop() {
+        dispatcher.unregister(this)
+    }
+
     /**
      * This method is called to set up the site with the provided raw data.
      *
      * @param rawData The raw data containing the callback data from the application password login.
      */
     fun setupSite(rawData: String) {
         viewModelScope.launch {
+            if (rawData.isEmpty()) {
+                appLogWrapper.e(AppLog.T.MAIN, "Cannot store credentials: rawData is empty")
+                _onFinishedEvent.emit(
+                    NavigationActionData(
+                        showSiteSelector = false,
+                        showPostSignupInterstitial = false,
+                        siteUrl = "",
+                        oldSitesIDs = oldSitesIDs,
+                        isError = true
+                    )
+                )
+                return@launch
+            }
             val urlLogin = applicationPasswordLoginHelper.getSiteUrlLoginFromRawData(rawData)
             // Store credentials if the site already exists
             val credentialsStored = storeCredentials(rawData)
+            // If the site already exists, we can skip fetching it again
             if (credentialsStored) {
-                _onFinishedEvent.emit(urlLogin.siteUrl)
+                _onFinishedEvent.emit(
+                    NavigationActionData(
+                        showSiteSelector = false,
+                        showPostSignupInterstitial = false,
+                        siteUrl = urlLogin.siteUrl,
+                        oldSitesIDs = oldSitesIDs,
+                        isError = false
+                    )
+                )
+            } else {
+                fetchSites(urlLogin)
+                currentUrlLogin = urlLogin
+            }
+        }
+    }
+
+    @Suppress("TooGenericExceptionCaught")
+    private suspend fun storeCredentials(rawData: String): Boolean = withContext(ioDispatcher) {
+        try {
+            if (rawData.isEmpty()) {
+                appLogWrapper.e(AppLog.T.DB, "Cannot store credentials: rawData is empty")
+                false
             } else {
-                val siteFetched = fetchSites(urlLogin)
-                _onFinishedEvent.emit(if (siteFetched) urlLogin.siteUrl else null)
+                val credentialsStored = applicationPasswordLoginHelper.storeApplicationPasswordCredentialsFrom(rawData)
+                credentialsStored
             }
+        } catch (e: Exception) {
+            appLogWrapper.e(AppLog.T.DB, "Error storing credentials: ${e.stackTrace}")
+            false
         }
     }
 
     @Suppress("TooGenericExceptionCaught")
     private suspend fun fetchSites(
-        urlLogin: ApplicationPasswordLoginHelper.UriLogin
-    ): Boolean = withContext(ioDispatcher) {
+        urlLogin: UriLogin
+    ) = withContext(ioDispatcher) {
         try {
             if (urlLogin.user.isNullOrEmpty() ||
                 urlLogin.password.isNullOrEmpty() ||
                 urlLogin.siteUrl.isNullOrEmpty()) {
-                Log.e(TAG, "Cannot store credentials: rawData is empty")
-                false
+                appLogWrapper.e(AppLog.T.MAIN, "Cannot store credentials: rawData is empty")
+                emitErrorFetching(urlLogin)
             } else {
                 val xmlRpcEndpoint =
                     selfHostedEndpointFinder.verifyOrDiscoverXMLRPCEndpoint(urlLogin.siteUrl)
-                siteStore.onAction(
+                dispatcher.dispatch(
                     SiteActionBuilder.newFetchSitesXmlRpcFromApplicationPasswordAction(
                         RefreshSitesXMLRPCPayload(
                             username = urlLogin.user,
@@ -74,27 +135,68 @@ class ApplicationPasswordLoginViewModel @Inject constructor(
                         )
                     )
                 )
-                true
             }
         } catch (e: Exception) {
-            Log.e(TAG, "Error storing credentials", e)
-            false
+            appLogWrapper.e(AppLog.T.API, "Error storing credentials: ${e.stackTrace}")
+            emitErrorFetching(urlLogin)
         }
     }
 
-    @Suppress("TooGenericExceptionCaught")
-    private suspend fun storeCredentials(rawData: String): Boolean = withContext(ioDispatcher) {
-        try {
-            if (rawData.isEmpty()) {
-                Log.e(TAG, "Cannot store credentials: rawData is empty")
-                false
-            } else {
-                val credentialsStored = applicationPasswordLoginHelper.storeApplicationPasswordCredentialsFrom(rawData)
-                credentialsStored
+    private suspend fun emitErrorFetching(urlLogin: UriLogin) =  _onFinishedEvent.emit(
+        NavigationActionData(
+            showSiteSelector = false,
+            showPostSignupInterstitial = false,
+            siteUrl = urlLogin.siteUrl,
+            oldSitesIDs = oldSitesIDs,
+            isError = true
+        )
+    )
+
+    @SuppressWarnings("unused")
+    @Subscribe(threadMode = ThreadMode.BACKGROUND)
+    fun onSiteChanged(event: OnSiteChanged) {
+        val currentNormalizedUrl = UrlUtils.normalizeUrl(currentUrlLogin?.siteUrl)
+        val site = siteStore.sites.firstOrNull { UrlUtils.normalizeUrl(it.url) == currentNormalizedUrl }
+        if (site == null) {
+            appLogWrapper.e(AppLog.T.MAIN, "Site not found for URL: ${currentUrlLogin?.siteUrl}")
+            viewModelScope.launch {
+                _onFinishedEvent.emit(
+                    NavigationActionData(
+                        showSiteSelector = false,
+                        showPostSignupInterstitial = false,
+                        siteUrl = currentUrlLogin?.siteUrl,
+                        oldSitesIDs = oldSitesIDs,
+                        isError = true
+                    )
+                )
             }
-        } catch (e: Exception) {
-            Log.e(TAG, "Error storing credentials", e)
-            false
+        } else {
+            dispatcher.dispatch(SiteActionBuilder.newFetchProfileXmlRpcAction(site))
         }
     }
+
+    @SuppressWarnings("unused")
+    @Subscribe(threadMode = ThreadMode.BACKGROUND)
+    fun onProfileFetched(event: OnProfileFetched) {
+        viewModelScope.launch {
+            _onFinishedEvent.emit(
+                NavigationActionData(
+                    showSiteSelector = siteStore.hasSite(),
+                    showPostSignupInterstitial = !siteStore.hasSite()
+                            && appPrefsWrapper.shouldShowPostSignupInterstitial,
+                    siteUrl = event.site.url,
+                    oldSitesIDs = oldSitesIDs,
+                    isError = false
+                )
+            )
+        }
+    }
+
+    data class NavigationActionData(
+        val showSiteSelector: Boolean,
+        val showPostSignupInterstitial: Boolean,
+        val siteUrl: String?,
+        val oldSitesIDs: ArrayList<Int>?,
+        val isError: Boolean
+    )
 }

WordPress/src/main/java/org/wordpress/android/ui/accounts/login/ApplicationPasswordLoginHelper.kt

@@ -11,6 +11,7 @@ import org.wordpress.android.fluxc.utils.AppLogWrapper
 import org.wordpress.android.modules.BG_THREAD
 import org.wordpress.android.util.AppLog
 import org.wordpress.android.util.BuildConfigWrapper
+import org.wordpress.android.util.UrlUtils
 import rs.wordpress.api.kotlin.ApiDiscoveryResult
 import rs.wordpress.api.kotlin.WpLoginClient
 import javax.inject.Inject
@@ -77,7 +78,8 @@ class ApplicationPasswordLoginHelper @Inject constructor(
             if (uriLogin.user.isNullOrEmpty() || uriLogin.password.isNullOrEmpty() ) {
                 false
             } else {
-                val site = siteSqlUtils.getSites().firstOrNull { it.url == uriLogin.siteUrl }
+                val normalizedUrl = UrlUtils.normalizeUrl(uriLogin.siteUrl)
+                val site = siteSqlUtils.getSites().firstOrNull { UrlUtils.normalizeUrl(it.url) ==  normalizedUrl}
                 if (site != null) {
                     site.apply {
                         apiRestUsernamePlain = uriLogin.user