MangaPresenter: Fix state updates when opening a new manga entry (#7379)

app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaPresenter.kt

@@ -24,7 +24,6 @@ import eu.kanade.tachiyomi.data.database.models.toDomainChapter
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.download.model.Download
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
-import eu.kanade.tachiyomi.data.saver.ImageSaver
 import eu.kanade.tachiyomi.data.track.EnhancedTrackService
 import eu.kanade.tachiyomi.data.track.TrackManager
 import eu.kanade.tachiyomi.data.track.TrackService
@@ -52,6 +51,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.supervisorScope
 import logcat.LogPriority
 import rx.Observable
@@ -60,7 +60,6 @@ import rx.android.schedulers.AndroidSchedulers
 import rx.schedulers.Schedulers
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import uy.kohesive.injekt.injectLazy
 import java.text.DateFormat
 import eu.kanade.domain.chapter.model.Chapter as DomainChapter
 import eu.kanade.domain.manga.model.Manga as DomainManga
@@ -108,8 +107,6 @@ class MangaPresenter(
 
     private val loggedServices by lazy { trackManager.services.filter { it.isLogged } }
 
-    private val imageSaver: ImageSaver by injectLazy()
-
     private var trackSubscription: Subscription? = null
     private var searchTrackerJob: Job? = null
     private var refreshTrackersJob: Job? = null
@@ -126,6 +123,13 @@ class MangaPresenter(
     val processedChapters: Sequence<ChapterItem>?
         get() = successState?.processedChapters
 
+    /**
+     * Helper function to update the UI state only if it's currently in success state
+     */
+    private fun updateSuccessState(func: (MangaScreenState.Success) -> MangaScreenState.Success) {
+        _state.update { if (it is MangaScreenState.Success) func(it) else it }
+    }
+
     override fun onCreate(savedState: Bundle?) {
         super.onCreate(savedState)
 
@@ -139,8 +143,8 @@ class MangaPresenter(
             getMangaAndChapters.subscribe(mangaId)
                 .collectLatest { (manga, chapters) ->
                     val chapterItems = chapters.toChapterItems(manga)
-                    val currentState = _state.value
+                    _state.update { currentState ->
-                    _state.value = when (currentState) {
+                        when (currentState) {
                             // Initialize success state
                             MangaScreenState.Loading -> MangaScreenState.Success(
                                 manga = manga,
@@ -153,7 +157,7 @@ class MangaPresenter(
                             ).also {
                                 getTrackingObservable(manga)
                                     .subscribeLatestCache(
-                                    { _, count -> successState?.let { _state.value = it.copy(trackingCount = count) } },
+                                        { _, count -> updateSuccessState { it.copy(trackingCount = count) } },
                                         { _, error -> logcat(LogPriority.ERROR, error) },
                                     )
                             }
@@ -161,6 +165,7 @@ class MangaPresenter(
                             // Update state
                             is MangaScreenState.Success -> currentState.copy(manga = manga, chapters = chapterItems)
                         }
+                    }
 
                     fetchTrackers()
                     observeDownloads()
@@ -173,17 +178,13 @@ class MangaPresenter(
 
         preferences.incognitoMode()
             .asImmediateFlow { incognito ->
-                successState?.let {
+                updateSuccessState { it.copy(isIncognitoMode = incognito) }
-                    _state.value = it.copy(isIncognitoMode = incognito)
-                }
             }
             .launchIn(presenterScope)
 
         preferences.downloadedOnly()
             .asImmediateFlow { downloadedOnly ->
-                successState?.let {
+                updateSuccessState { it.copy(isDownloadedOnlyMode = downloadedOnly) }
-                    _state.value = it.copy(isDownloadedOnlyMode = downloadedOnly)
-                }
             }
             .launchIn(presenterScope)
     }
@@ -213,16 +214,17 @@ class MangaPresenter(
      */
     private fun fetchMangaFromSource(manualFetch: Boolean = false) {
         if (fetchMangaJob?.isActive == true) return
-        val successState = successState ?: return
         fetchMangaJob = presenterScope.launchIO {
-            _state.value = successState.copy(isRefreshingInfo = true)
+            updateSuccessState { it.copy(isRefreshingInfo = true) }
             try {
-                val networkManga = successState.source.getMangaDetails(successState.manga.toMangaInfo())
+                successState?.let {
-                updateManga.awaitUpdateFromSource(successState.manga, networkManga, manualFetch)
+                    val networkManga = it.source.getMangaDetails(it.manga.toMangaInfo())
+                    updateManga.awaitUpdateFromSource(it.manga, networkManga, manualFetch)
+                }
             } catch (e: Throwable) {
                 withUIContext { view?.onFetchMangaInfoError(e) }
             }
-            _state.value = successState.copy(isRefreshingInfo = false)
+            updateSuccessState { it.copy(isRefreshingInfo = false) }
         }
     }
 
@@ -402,15 +404,16 @@ class MangaPresenter(
     }
 
     private fun updateDownloadState(download: Download) {
-        val successState = successState ?: return
+        updateSuccessState { successState ->
             val modifiedIndex = successState.chapters.indexOfFirst { it.chapter.id == download.chapter.id }
-        if (modifiedIndex >= 0) {
+            if (modifiedIndex < 0) return@updateSuccessState successState
+
             val newChapters = successState.chapters.toMutableList().apply {
                 val item = removeAt(modifiedIndex)
                     .copy(downloadState = download.status, downloadProgress = download.progress)
                 add(modifiedIndex, item)
             }
-            _state.value = successState.copy(chapters = newChapters)
+            successState.copy(chapters = newChapters)
         }
     }
 
@@ -436,11 +439,10 @@ class MangaPresenter(
      */
     private fun fetchChaptersFromSource(manualFetch: Boolean = false) {
         if (fetchChaptersJob?.isActive == true) return
-        val successState = successState ?: return
-
         fetchChaptersJob = presenterScope.launchIO {
-            _state.value = successState.copy(isRefreshingChapter = true)
+            updateSuccessState { it.copy(isRefreshingChapter = true) }
             try {
+                successState?.let { successState ->
                     val chapters = successState.source.getChapterList(successState.manga.toMangaInfo())
                         .map { it.toSChapter() }
 
@@ -454,10 +456,11 @@ class MangaPresenter(
                         val dbChapters = newChapters.map { it.toDbChapter() }
                         downloadNewChapters(dbChapters)
                     }
+                }
             } catch (e: Throwable) {
                 withUIContext { view?.onFetchChaptersError(e) }
             }
-            _state.value = successState.copy(isRefreshingChapter = false)
+            updateSuccessState { it.copy(isRefreshingChapter = false) }
         }
     }
 
@@ -551,15 +554,15 @@ class MangaPresenter(
      * @param chapters the list of chapters to delete.
      */
     fun deleteChapters(chapters: List<DomainChapter>) {
-        val successState = successState ?: return
         launchIO {
             val chapters2 = chapters.map { it.toDbChapter() }
             try {
+                updateSuccessState { successState ->
                     val deletedIds = downloadManager
                         .deleteChapters(chapters2, successState.manga.toDbManga(), successState.source)
                         .map { it.id }
                     val deletedChapters = successState.chapters.filter { deletedIds.contains(it.chapter.id) }
-                if (deletedChapters.isEmpty()) return@launchIO
+                    if (deletedChapters.isEmpty()) return@updateSuccessState successState
 
                     // TODO: Don't do this fake status update
                     val newChapters = successState.chapters.toMutableList().apply {
@@ -570,7 +573,8 @@ class MangaPresenter(
                             add(index, toAdd)
                         }
                     }
-                _state.value = successState.copy(chapters = newChapters)
+                    successState.copy(chapters = newChapters)
+                }
             } catch (e: Throwable) {
                 logcat(LogPriority.ERROR, e)
             }