fix(login): start the browser login again if the pending one was lost

After process death the in-memory pending login is gone, so the recreated
BrowserLoginActivity in resume mode only showed an error. The resume intent
now also carries the base URL, reauthorize flag and account, and the login
is started again from them when there is nothing to continue.

Assisted-by: Claude Code:claude-opus-5-5
Signed-off-by: Marcel Hibbe <dev@mhibbe.de>

Author: mahibi

app/src/main/java/com/nextcloud/talk/account/BrowserLoginActivity.kt

@@ -146,9 +146,10 @@ class BrowserLoginActivity : BaseActivity() {
         // The account to reauthorize, so a login with another account doesn't change it.
         val accountToReauthorize = extras.getLong(BundleKeys.KEY_INTERNAL_USER_ID, 0L).takeIf { it != 0L }
 
-        if (extras.getBoolean(BundleKeys.KEY_RESUME_BROWSER_LOGIN, false)) {
-            viewModel.resumeWebBrowserLogin()
-        } else if (extras.containsKey(BundleKeys.KEY_FROM_QR)) {
+        // If the saved login can't be continued, it is started again below with the same extras.
+        if (extras.getBoolean(BundleKeys.KEY_RESUME_BROWSER_LOGIN, false) && viewModel.resumeWebBrowserLogin()) return
+
+        if (extras.containsKey(BundleKeys.KEY_FROM_QR)) {
             val uri = extras.getString(BundleKeys.KEY_FROM_QR)!!
 
             if (uri.startsWith(LoginRepository.ONE_TIME_PREFIX)) {

app/src/main/java/com/nextcloud/talk/account/data/PendingBrowserLoginStore.kt

@@ -14,6 +14,7 @@ import com.nextcloud.talk.account.data.model.LoginResponse
  */
 data class PendingBrowserLogin(
     val response: LoginResponse,
+    val baseUrl: String,
     val reAuth: Boolean,
     val accountToReauthorize: Long?,
     val startedAtMillis: Long
@@ -35,8 +36,8 @@ object PendingBrowserLoginStore {
     @Volatile
     private var pending: PendingBrowserLogin? = null
 
-    fun save(response: LoginResponse, reAuth: Boolean, accountToReauthorize: Long?) {
-        pending = PendingBrowserLogin(response, reAuth, accountToReauthorize, clock())
+    fun save(response: LoginResponse, baseUrl: String, reAuth: Boolean, accountToReauthorize: Long?) {
+        pending = PendingBrowserLogin(response, baseUrl, reAuth, accountToReauthorize, clock())
     }
 
     /** The unfinished login, or null if there is none or it expired. */

app/src/main/java/com/nextcloud/talk/account/viewmodels/BrowserLoginActivityViewModel.kt

@@ -79,7 +79,7 @@ class BrowserLoginActivityViewModel @Inject constructor(val repository: LoginRep
             }
 
             // Survives this view model, see PendingBrowserLoginStore.
-            PendingBrowserLoginStore.save(response, reAuth, accountToReauthorize)
+            PendingBrowserLoginStore.save(response, baseUrl, reAuth, accountToReauthorize)
 
             _initialLoginRequestState.value =
                 InitialLoginViewState.InitialLoginRequestSuccess(response.loginUrl)
@@ -89,17 +89,19 @@ class BrowserLoginActivityViewModel @Inject constructor(val repository: LoginRep
     /**
      * Continues the browser login that a destroyed [com.nextcloud.talk.account.BrowserLoginActivity] left unfinished:
      * no new login request and no new browser, only the polling of the saved response.
+     *
+     * Returns false if there is nothing to continue (expired, or lost by process death), then the login has to be
+     * started again.
      */
-    fun resumeWebBrowserLogin() {
-        if (!startLoginOnce()) return
-        val pending = PendingBrowserLoginStore.active()
-        if (pending == null) {
-            _postLoginState.value = PostLoginViewState.PostLoginError
-            return
+    fun resumeWebBrowserLogin(): Boolean {
+        if (!isLoginStarted) {
+            val pending = PendingBrowserLoginStore.active() ?: return false
+            startLoginOnce()
+            savedResponse = pending.response
+            repository.resumeLoginFlow(pending.reAuth, pending.accountToReauthorize)
+            handleWebBrowserLogin()
         }
-        savedResponse = pending.response
-        repository.resumeLoginFlow(pending.reAuth, pending.accountToReauthorize)
-        handleWebBrowserLogin()
+        return true
     }
 
     fun handleWebBrowserLogin() {

app/src/main/java/com/nextcloud/talk/activities/MainActivity.kt

@@ -26,6 +26,7 @@ import com.nextcloud.talk.BuildConfig
 import com.nextcloud.talk.R
 import com.nextcloud.talk.account.BrowserLoginActivity
 import com.nextcloud.talk.account.ServerSelectionActivity
+import com.nextcloud.talk.account.data.PendingBrowserLogin
 import com.nextcloud.talk.account.data.PendingBrowserLoginStore
 import com.nextcloud.talk.api.NcApi
 import com.nextcloud.talk.application.NextcloudTalkApplication
@@ -120,9 +121,13 @@ class MainActivity :
      * The app was opened again (e.g. by the launcher icon) while a login via the browser was unfinished. That
      * destroyed the login screens, so they are opened again, with the saved login continued instead of a new one.
      */
-    private fun resumeBrowserLogin(hasAccounts: Boolean) {
+    private fun resumeBrowserLogin(pending: PendingBrowserLogin, hasAccounts: Boolean) {
         val loginIntent = Intent(context, BrowserLoginActivity::class.java)
         loginIntent.putExtra(BundleKeys.KEY_RESUME_BROWSER_LOGIN, true)
+        // To start the login again if the saved one is lost by process death.
+        loginIntent.putExtra(BundleKeys.KEY_BASE_URL, pending.baseUrl)
+        loginIntent.putExtra(BundleKeys.KEY_REAUTHORIZE_ACCOUNT, pending.reAuth)
+        pending.accountToReauthorize?.let { loginIntent.putExtra(BundleKeys.KEY_INTERNAL_USER_ID, it) }
 
         val screenBelow = when {
             hasAccounts -> Intent(context, ConversationsListActivity::class.java)
@@ -301,8 +306,9 @@ class MainActivity :
                     }
                     if (isFinishing || isDestroyed) return@launch
 
-                    if (PendingBrowserLoginStore.active() != null) {
-                        resumeBrowserLogin(users.isNotEmpty())
+                    val pendingBrowserLogin = PendingBrowserLoginStore.active()
+                    if (pendingBrowserLogin != null) {
+                        resumeBrowserLogin(pendingBrowserLogin, users.isNotEmpty())
                     } else if (users.isNotEmpty()) {
                         openConversationList()
                     } else {

app/src/test/java/com/nextcloud/talk/account/viewmodels/BrowserLoginActivityViewModelTest.kt

@@ -17,8 +17,10 @@ import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.setMain
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import org.mockito.kotlin.any
@@ -113,8 +115,8 @@ class BrowserLoginActivityViewModelTest {
         wheneverBlocking { newRepository.pollLogin(any()) }.thenReturn(null)
         val newViewModel = BrowserLoginActivityViewModel(newRepository)
 
-        newViewModel.resumeWebBrowserLogin()
-        newViewModel.resumeWebBrowserLogin()
+        assertTrue(newViewModel.resumeWebBrowserLogin())
+        assertTrue(newViewModel.resumeWebBrowserLogin())
 
         verifyBlocking(newRepository, times(1)) { pollLogin(any()) }
     }
@@ -149,11 +151,21 @@ class BrowserLoginActivityViewModelTest {
         val newRepository: LoginRepository = mock()
         val newViewModel = BrowserLoginActivityViewModel(newRepository)
 
-        newViewModel.resumeWebBrowserLogin()
+        assertFalse(newViewModel.resumeWebBrowserLogin())
 
         assertNull(PendingBrowserLoginStore.active())
         verifyBlocking(newRepository, never()) { pollLogin(any()) }
-        assertEquals(BrowserLoginActivityViewModel.PostLoginViewState.PostLoginError, newViewModel.postLoginState.value)
+    }
+
+    @Test
+    fun `without a saved login the login can be started again`() {
+        wheneverBlocking { repository.startLoginFlow(any(), any(), anyOrNull()) }.thenReturn(loginResponse)
+
+        assertFalse(viewModel.resumeWebBrowserLogin())
+        viewModel.startWebBrowserLogin(BASE_URL, reAuth = true, accountToReauthorize = ACCOUNT)
+
+        verifyBlocking(repository) { startLoginFlow(BASE_URL, true, ACCOUNT) }
+        assertEquals(BASE_URL, PendingBrowserLoginStore.active()!!.baseUrl)
     }
 
     @Test