fix: deckpicker viewmodel errors

AnkiDroid/src/main/java/com/ichi2/anki/CoroutineHelpers.kt

@@ -157,48 +157,57 @@ suspend fun <T> FragmentActivity.runCatching(
             showError(exc.localizedMessage!!, exc.toCrashReportData(this, reportException = false))
             return null
         }
-        when (exc) {
-            is CancellationException -> {
-                throw exc // CancellationException should be re-thrown to propagate it to the parent coroutine
-            }
-            is BackendInterruptedException -> {
-                Timber.w(exc, errorMessage)
-                exc.localizedMessage?.let { showSnackbar(it) }
-            }
-            is StorageNotConfiguredException -> {
-                // expected before first-run setup completes: no crash report
-                // edge case when 'ensureStorageIsReady' was insufficient
-                Timber.w(exc, errorMessage)
-                if (!isFinishing) redirectToMainEntryPoint()
-            }
-            is BackendNetworkException, is BackendSyncException, is StorageAccessException, is BackendCardTypeException,
-            is CollectionLockedException,
-            -> {
-                // these exceptions do not generate worthwhile crash reports
-                Timber.i("Showing error dialog but not sending a crash report.")
-                showError(exc.localizedMessage!!, exc.toCrashReportData(this, reportException = false))
-            }
-            // must precede `is BackendException`: BackendDbCorruptException is a subclass
-            is SQLiteDatabaseCorruptException, is BackendDbCorruptException -> {
-                Timber.e(exc, errorMessage)
-                DatabaseCorruption.isDetected = true
-                if (callerTrace != null) Timber.e(callerTrace)
-                (this as? AnkiActivity)
-                    ?.showDatabaseErrorDialog(
-                        errorDialogType = DatabaseErrorDialogType.DIALOG_LOAD_FAILED,
-                        exceptionData = DatabaseErrorDialog.CustomExceptionData.fromException(exc),
-                    )
-            }
-            is BackendException -> {
-                Timber.e(exc, errorMessage)
-                if (callerTrace != null) Timber.e(callerTrace)
-                showError(exc.localizedMessage!!, exc.toCrashReportData(this))
-            }
-            else -> {
-                Timber.e(exc, errorMessage)
-                if (callerTrace != null) Timber.e(callerTrace)
-                showError(exc)
-            }
+        if (exc is CancellationException) {
+            throw exc // CancellationException should be re-thrown to propagate it to the parent coroutine
+        }
+        showException(exc, errorMessage, callerTrace)
+    }
+    return null
+}
+
+fun FragmentActivity.showException(
+    exc: Exception,
+    errorMessage: String? = null,
+    callerTrace: String? = null,
+): AlertDialog? {
+    when (exc) {
+        is BackendInterruptedException -> {
+            Timber.w(exc, errorMessage)
+            exc.localizedMessage?.let { showSnackbar(it) }
+        }
+        is StorageNotConfiguredException -> {
+            // expected before first-run setup completes: no crash report
+            // edge case when 'ensureStorageIsReady' was insufficient
+            Timber.w(exc, errorMessage)
+            if (!isFinishing) redirectToMainEntryPoint()
+        }
+        is BackendNetworkException, is BackendSyncException, is StorageAccessException, is BackendCardTypeException,
+        is CollectionLockedException,
+        -> {
+            // these exceptions do not generate worthwhile crash reports
+            Timber.i("Showing error dialog but not sending a crash report.")
+            return showError(exc.localizedMessage!!, exc.toCrashReportData(this, reportException = false))
+        }
+        // must precede `is BackendException`: BackendDbCorruptException is a subclass
+        is SQLiteDatabaseCorruptException, is BackendDbCorruptException -> {
+            Timber.e(exc, errorMessage)
+            DatabaseCorruption.isDetected = true
+            if (callerTrace != null) Timber.e(callerTrace)
+            (this as? AnkiActivity)
+                ?.showDatabaseErrorDialog(
+                    errorDialogType = DatabaseErrorDialogType.DIALOG_LOAD_FAILED,
+                    exceptionData = DatabaseErrorDialog.CustomExceptionData.fromException(exc),
+                )
+        }
+        is BackendException -> {
+            Timber.e(exc, errorMessage)
+            if (callerTrace != null) Timber.e(callerTrace)
+            return showError(exc.localizedMessage!!, exc.toCrashReportData(this))
+        }
+        else -> {
+            Timber.e(exc, errorMessage)
+            if (callerTrace != null) Timber.e(callerTrace)
+            return showError(exc)
         }
     }
     return null
@@ -322,14 +331,14 @@ fun Fragment.launchCatchingViewTask(
 fun Context.showError(
     message: CharSequence,
     crashReportData: CrashReportData?,
-) {
+): AlertDialog? {
     crashReportData.throwIfDialogUnusable(message.toString())
 
     Timber.i("Error dialog displayed")
 
     val helpAction = crashReportData?.helpAction?.takeIf { it.canExecute(this) }
 
-    try {
+    return try {
         AlertDialog
             .Builder(this)
             .create {
@@ -357,6 +366,7 @@ fun Context.showError(
         // issue 12718: activity provided by `context` was not running
         Timber.w(ex, "unable to display error dialog")
         crashReportData?.sendCrashReport()
+        null
     }
 }
 

AnkiDroid/src/main/java/com/ichi2/anki/DeckPicker.kt

@@ -16,6 +16,7 @@ import android.content.Context
 import android.content.Intent
 import android.content.SharedPreferences
 import android.database.SQLException
+import android.database.sqlite.SQLiteDatabaseCorruptException
 import android.graphics.Color
 import android.graphics.PixelFormat
 import android.os.Build
@@ -68,6 +69,7 @@ import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.flowWithLifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
+import androidx.lifecycle.withStarted
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 import androidx.work.NetworkType
@@ -137,6 +139,7 @@ import com.ichi2.anki.deckpicker.SyncIconState
 import com.ichi2.anki.dialogs.AsyncDialogFragment
 import com.ichi2.anki.dialogs.BackupPromptDialog
 import com.ichi2.anki.dialogs.CreateDeckDialog
+import com.ichi2.anki.dialogs.DatabaseErrorDialog
 import com.ichi2.anki.dialogs.DatabaseErrorDialog.CustomExceptionData
 import com.ichi2.anki.dialogs.DatabaseErrorDialog.DatabaseErrorDialogType
 import com.ichi2.anki.dialogs.DeckPickerAnalyticsOptInDialog
@@ -197,6 +200,7 @@ import com.ichi2.anki.ui.internationalization.sentenceCase
 import com.ichi2.anki.ui.windows.permissions.PermissionsActivity
 import com.ichi2.anki.utils.Destination
 import com.ichi2.anki.utils.ShortcutUtils
+import com.ichi2.anki.utils.awaitDismissal
 import com.ichi2.anki.utils.ext.dismissAllDialogFragments
 import com.ichi2.anki.utils.ext.doOnScrolled
 import com.ichi2.anki.utils.ext.launchCollectionInLifecycleScope
@@ -205,6 +209,7 @@ import com.ichi2.anki.utils.ext.positionIsVisible
 import com.ichi2.anki.utils.ext.setFragmentResultListener
 import com.ichi2.anki.utils.ext.setImageDrawableSafe
 import com.ichi2.anki.utils.ext.showDialogFragment
+import com.ichi2.anki.utils.observeMessages
 import com.ichi2.anki.widgets.DeckAdapter
 import com.ichi2.anki.widgets.DeckHierarchyLinesDecoration
 import com.ichi2.anki.worker.SyncMediaWorker
@@ -231,8 +236,11 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.awaitCancellation
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.yield
+import net.ankiweb.rsdroid.BackendException.BackendDbException.BackendDbCorruptException
 import net.ankiweb.rsdroid.Translations
 import net.ankiweb.rsdroid.exceptions.BackendInvalidInputException.BackendCollectionNotOpenException
 import timber.log.Timber
@@ -498,6 +506,34 @@ open class DeckPicker :
         )
     }
 
+    private fun findDatabaseRecovery() =
+        supportFragmentManager.fragments.filterIsInstance<DatabaseErrorDialog>().firstOrNull {
+            it.lifecycle.currentState != Lifecycle.State.DESTROYED
+        }
+
+    private suspend fun awaitDatabaseRecovery(): Boolean {
+        var corruptionPromptClosed = false
+        while (true) {
+            val recovery = findDatabaseRecovery() ?: return corruptionPromptClosed
+            if (recovery.requireDialogType() == DatabaseErrorDialogType.DIALOG_LOAD_FAILED) corruptionPromptClosed = true
+            recovery.lifecycle.currentStateFlow.first { it == Lifecycle.State.DESTROYED }
+            yield()
+        }
+    }
+
+    private suspend fun withStartedAfterRecovery(block: (afterCorruptionPrompt: Boolean) -> Unit) {
+        var afterCorruptionPrompt = false
+        do {
+            if (awaitDatabaseRecovery()) afterCorruptionPrompt = true
+            val recoveryOpened =
+                withStarted {
+                    val opened = findDatabaseRecovery() != null
+                    if (!opened) block(afterCorruptionPrompt)
+                    opened
+                }
+        } while (recoveryOpened)
+    }
+
     // ----------------------------------------------------------------------------
     // ANDROID ACTIVITY METHODS
     // ----------------------------------------------------------------------------
@@ -951,6 +987,12 @@ open class DeckPicker :
             fragment?.refreshInterface()
         }
 
+        fun onCreatedDeckSelected(param: Unit) {
+            updateDeckList()
+            tryShowStudyOptionsPanel()
+            invalidateOptionsMenu()
+        }
+
         fun onStartupResponse(response: StartupResponse) {
             Timber.d("onStartupResponse: %s", response)
             when (response) {
@@ -992,11 +1034,15 @@ open class DeckPicker :
         }
 
         fun onError(errorMessage: String) {
-            AlertDialog
-                .Builder(this)
-                .setTitle(CommonString.vague_error)
-                .setMessage(errorMessage)
-                .show()
+            launchCatchingTask {
+                withStartedAfterRecovery {
+                    AlertDialog
+                        .Builder(this@DeckPicker)
+                        .setTitle(CommonString.vague_error)
+                        .setMessage(errorMessage)
+                        .show()
+                }
+            }
         }
 
         viewModel.deckDeletedNotification.launchCollectionInLifecycleScope(::onDeckDeleted)
@@ -1015,6 +1061,14 @@ open class DeckPicker :
         viewModel.flowOfCreateShortcut.launchCollectionInLifecycleScope(::createIcon)
         viewModel.flowOfDisableShortcuts.launchCollectionInLifecycleScope(::disableDeckAndChildrenShortcuts)
         viewModel.onError.launchCollectionInLifecycleScope(::onError)
+        observeMessages(viewModel.pendingErrors, viewModel::errorShown) { error ->
+            var dialog: AlertDialog? = null
+            withStartedAfterRecovery { afterCorruptionPrompt ->
+                val corruption = error is BackendDbCorruptException || error is SQLiteDatabaseCorruptException
+                if (!afterCorruptionPrompt || !corruption) dialog = showException(error)
+            }
+            dialog?.awaitDismissal()
+        }
         viewModel.flowOfPromptUserToUpdateScheduler.launchCollectionInLifecycleScope(::onPromptUserToUpdateScheduler)
         viewModel.flowOfOptionsMenuState.filterNotNull().launchCollectionInLifecycleScope(::onOptionsMenuUpdated)
         viewModel.flowOfStudiedTodayStats.launchCollectionInLifecycleScope(::onStudiedTodayChanged)
@@ -1025,6 +1079,7 @@ open class DeckPicker :
         viewModel.flowOfFocusedDeck.launchCollectionInLifecycleScope(::onFocusedDeckChanged)
         viewModel.flowOfResizingDividerVisible.launchCollectionInLifecycleScope(::onResizingDividerVisibilityChanged)
         viewModel.flowOfDecksReloaded.launchCollectionInLifecycleScope(::onDecksReloaded)
+        viewModel.flowOfCreatedDeckSelected.launchCollectionInLifecycleScope(::onCreatedDeckSelected)
         viewModel.flowOfStartupResponse.filterNotNull().launchCollectionInLifecycleScope(::onStartupResponse)
         viewModel.flowOfShowContextMenu.launchCollectionInLifecycleScope(::showDeckPickerContextMenu)
         viewModel.flowOfShowRightClickContextMenu.launchCollectionInLifecycleScope(::showDeckPickerRightClickContextMenu)
@@ -2299,12 +2354,12 @@ open class DeckPicker :
         val study =
             withCol {
                 decks.select(did)
+                viewModel.focusedDeck = did
                 currentDeckStudyState()
             }
         deckListAdapter.updateSelectedDeck(did)
         // Also forget the last deck used by the Browser
         CardBrowser.clearLastDeckId()
-        viewModel.focusedDeck = did
 
         if (study.availability == StudyAvailability.CardsAvailable) {
             openReviewerOrStudyOptions(selectionType)
@@ -2415,41 +2470,22 @@ open class DeckPicker :
      * [StudyOptionsFragment] panel follow the new deck instead of the previously current deck, which
      * is often the hidden Default deck.
      */
-    private fun onDeckCreated(deckId: DeckId) =
-        launchCatchingTask {
-            viewModel.selectDeck(deckId).join()
-            updateDeckList()
-            tryShowStudyOptionsPanel()
-            invalidateOptionsMenu()
-        }
+    private fun onDeckCreated(deckId: DeckId) = viewModel.selectCreatedDeck(deckId)
 
     /**
      * Deletes the provided deck, child decks, and all cards inside.
      * @param did ID of the deck to delete
      */
-    fun deleteDeck(did: DeckId) =
-        launchCatchingTask {
-            viewModel.deleteDeck(did).join()
-        }
+    fun deleteDeck(did: DeckId) = viewModel.deleteDeck(did)
 
-    private fun deleteSelectedDeck() =
-        launchCatchingTask {
-            viewModel.deleteSelectedDeck().join()
-        }
+    private fun deleteSelectedDeck() = viewModel.deleteSelectedDeck(shownDeckId = fragment?.shownDeckId)
 
-    @NeedsTest("14285: regression test to ensure UI is updated after this call")
     fun rebuildFiltered(did: DeckId) {
-        launchCatchingTask {
-            viewModel.rebuildFilteredDeck(did).join()
-            updateDeckList()
-            tryShowStudyOptionsPanel()
-        }
+        viewModel.rebuildFilteredDeck(did)
     }
 
     private fun emptyFiltered(did: DeckId) {
-        launchCatchingTask {
-            viewModel.emptyFilteredDeck(did).join()
-        }
+        viewModel.emptyFilteredDeck(did)
     }
 
     override fun onAttachedToWindow() {

AnkiDroid/src/main/java/com/ichi2/anki/StudyOptionsFragment.kt

@@ -57,6 +57,7 @@ import com.ichi2.anki.utils.ext.launchCollectionInViewLifecycleScope
 import com.ichi2.anki.utils.ext.setFragmentResultListener
 import com.ichi2.anki.utils.ext.showDialogFragment
 import com.ichi2.ui.CollectionMediaImageGetter
+import kotlinx.coroutines.CancellationException
 import org.intellij.lang.annotations.Language
 import timber.log.Timber
 
@@ -76,6 +77,11 @@ class StudyOptionsFragment :
     @VisibleForTesting
     internal val viewModel: StudyOptionsViewModel by viewModels()
 
+    val selectedDeckId: DeckId get() = viewModel.selectedDeckId
+
+    var shownDeckId: DeckId? = null
+        private set
+
     private lateinit var deckInfoLayout: Group
     private lateinit var buttonStart: Button
     private lateinit var textDeckName: TextView
@@ -351,7 +357,16 @@ class StudyOptionsFragment :
 
     fun refreshInterface() {
         Timber.d("Refreshing StudyOptionsFragment")
-        launchCatchingViewTask { viewModel.refreshData() }
+        launchCatchingViewTask {
+            try {
+                viewModel.refreshData()
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                val deckPicker = activity as? DeckPicker ?: throw e
+                deckPicker.viewModel.reportError(e)
+            }
+        }
     }
 
     private fun rebuildUi(state: StudyOptionsState) {
@@ -374,6 +389,7 @@ class StudyOptionsFragment :
         displayedDeckId = viewModel.selectedDeckId
 
         updateDeckNameView(state)
+        shownDeckId = state.deckIdOrNull()
 
         when (state) {
             is StudyOptionsState.Empty -> {