Replace LiveData with StateFlow

app/src/main/kotlin/org/koitharu/kotatsu/details/domain/DetailsInteractor.kt

@@ -6,23 +6,21 @@ import kotlinx.coroutines.flow.distinctUntilChangedBy
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
-import org.koitharu.kotatsu.core.model.DoubleManga
-import org.koitharu.kotatsu.core.model.isLocal
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.observeAsFlow
+import org.koitharu.kotatsu.details.domain.model.DoubleManga
 import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
-import org.koitharu.kotatsu.history.domain.HistoryRepository
-import org.koitharu.kotatsu.local.data.LocalManga
-import org.koitharu.kotatsu.local.domain.LocalMangaRepository
+import org.koitharu.kotatsu.history.data.HistoryRepository
+import org.koitharu.kotatsu.local.data.LocalMangaRepository
+import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import org.koitharu.kotatsu.scrobbling.common.domain.Scrobbler
 import org.koitharu.kotatsu.scrobbling.common.domain.model.ScrobblingInfo
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
-import org.koitharu.kotatsu.util.ext.printStackTraceDebug
-import java.io.IOException
 import javax.inject.Inject
 
+@Deprecated("")
 class DetailsInteractor @Inject constructor(
 	private val historyRepository: HistoryRepository,
 	private val favouritesRepository: FavouritesRepository,
@@ -56,18 +54,6 @@ class DetailsInteractor @Inject constructor(
 		}
 	}
 
-	suspend fun deleteLocalManga(manga: Manga) {
-		val victim = if (manga.isLocal) manga else localMangaRepository.findSavedManga(manga)?.manga
-		checkNotNull(victim) { "Cannot find saved manga for ${manga.title}" }
-		val original = if (manga.isLocal) localMangaRepository.getRemoteManga(manga) else manga
-		localMangaRepository.delete(victim) || throw IOException("Unable to delete file")
-		runCatchingCancellable {
-			historyRepository.deleteOrSwap(victim, original)
-		}.onFailure {
-			it.printStackTraceDebug()
-		}
-	}
-
 	fun observeIncognitoMode(mangaFlow: Flow<Manga?>): Flow<Boolean> {
 		return mangaFlow
 			.distinctUntilChangedBy { it?.isNsfw }

app/src/main/kotlin/org/koitharu/kotatsu/details/domain/DoubleMangaLoadUseCase.kt

@@ -0,0 +1,65 @@
+package org.koitharu.kotatsu.details.domain
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+import org.koitharu.kotatsu.core.model.isLocal
+import org.koitharu.kotatsu.core.parser.MangaDataRepository
+import org.koitharu.kotatsu.core.parser.MangaIntent
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.details.domain.model.DoubleManga
+import org.koitharu.kotatsu.local.data.LocalMangaRepository
+import org.koitharu.kotatsu.parsers.exception.NotFoundException
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
+import javax.inject.Inject
+
+class DoubleMangaLoadUseCase @Inject constructor(
+	private val mangaDataRepository: MangaDataRepository,
+	private val localMangaRepository: LocalMangaRepository,
+	private val mangaRepositoryFactory: MangaRepository.Factory,
+) {
+
+	suspend operator fun invoke(manga: Manga): DoubleManga = coroutineScope {
+		val remoteDeferred = async(Dispatchers.Default) { loadRemote(manga) }
+		val localDeferred = async(Dispatchers.Default) { loadLocal(manga) }
+		DoubleManga(
+			remoteManga = remoteDeferred.await(),
+			localManga = localDeferred.await(),
+		)
+	}
+
+	suspend operator fun invoke(mangaId: Long): DoubleManga {
+		val manga = mangaDataRepository.findMangaById(mangaId) ?: throwNFE()
+		return invoke(manga)
+	}
+
+	suspend operator fun invoke(intent: MangaIntent): DoubleManga {
+		val manga = mangaDataRepository.resolveIntent(intent) ?: throwNFE()
+		return invoke(manga)
+	}
+
+	private suspend fun loadLocal(manga: Manga): Result<Manga>? {
+		return runCatchingCancellable {
+			if (manga.isLocal) {
+				localMangaRepository.getDetails(manga)
+			} else {
+				localMangaRepository.findSavedManga(manga)?.manga
+			} ?: return null
+		}
+	}
+
+	private suspend fun loadRemote(manga: Manga): Result<Manga>? {
+		return runCatchingCancellable {
+			val seed = if (manga.isLocal) {
+				localMangaRepository.getRemoteManga(manga)
+			} else {
+				manga
+			} ?: return null
+			val repository = mangaRepositoryFactory.create(seed.source)
+			repository.getDetails(seed)
+		}
+	}
+
+	private fun throwNFE(): Nothing = throw NotFoundException("Cannot find manga", "")
+}

app/src/main/kotlin/org/koitharu/kotatsu/details/domain/model/DoubleManga.kt

@@ -0,0 +1,76 @@
+package org.koitharu.kotatsu.details.domain.model
+
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.reader.data.filterChapters
+
+data class DoubleManga(
+	private val remoteManga: Result<Manga>?,
+	private val localManga: Result<Manga>?,
+) {
+
+	constructor(manga: Manga) : this(
+		remoteManga = if (manga.source != MangaSource.LOCAL) Result.success(manga) else null,
+		localManga = if (manga.source == MangaSource.LOCAL) Result.success(manga) else null,
+	)
+
+	val remote: Manga?
+		get() = remoteManga?.getOrNull()
+
+	val local: Manga?
+		get() = localManga?.getOrNull()
+
+	val any: Manga?
+		get() = remote ?: local
+
+	val hasRemote: Boolean
+		get() = remoteManga?.isSuccess == true
+
+	val hasLocal: Boolean
+		get() = localManga?.isSuccess == true
+
+	val chapters: List<MangaChapter>? by lazy(LazyThreadSafetyMode.PUBLICATION) {
+		mergeChapters()
+	}
+
+	fun requireAny(): Manga {
+		val result = remoteManga?.getOrNull() ?: localManga?.getOrNull()
+		if (result != null) {
+			return result
+		}
+		throw (
+			remoteManga?.exceptionOrNull()
+				?: localManga?.exceptionOrNull()
+				?: IllegalStateException("No online either local manga available")
+			)
+	}
+
+	fun filterChapters(branch: String?) = DoubleManga(
+		remoteManga?.map { it.filterChapters(branch) },
+		localManga?.map { it.filterChapters(branch) },
+	)
+
+	private fun mergeChapters(): List<MangaChapter>? {
+		val remoteChapters = remote?.chapters
+		val localChapters = local?.chapters
+		if (localChapters == null && remoteChapters == null) {
+			return null
+		}
+		val localMap = if (!localChapters.isNullOrEmpty()) {
+			localChapters.associateByTo(LinkedHashMap(localChapters.size)) { it.id }
+		} else {
+			null
+		}
+		val result = ArrayList<MangaChapter>(maxOf(remoteChapters?.size ?: 0, localChapters?.size ?: 0))
+		remoteChapters?.forEach { r ->
+			localMap?.remove(r.id)?.let { l ->
+				result.add(l)
+			} ?: result.add(r)
+		}
+		localMap?.values?.let {
+			result.addAll(it)
+		}
+		return result
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/details/service/MangaPrefetchService.kt

@@ -10,7 +10,7 @@ import org.koitharu.kotatsu.core.model.parcelable.ParcelableMangaChapters
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.ui.CoroutineIntentService
 import org.koitharu.kotatsu.core.util.ext.getParcelableExtraCompat
-import org.koitharu.kotatsu.history.domain.HistoryRepository
+import org.koitharu.kotatsu.history.data.HistoryRepository
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.parsers.model.MangaSource

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/ChaptersFragment.kt

@@ -16,6 +16,7 @@ import org.koitharu.kotatsu.core.ui.BaseFragment
 import org.koitharu.kotatsu.core.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.util.RecyclerViewScrollCallback
+import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.scaleUpActivityOptionsOf
 import org.koitharu.kotatsu.databinding.FragmentChaptersBinding
 import org.koitharu.kotatsu.details.ui.adapter.ChaptersAdapter

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/DetailsActivity.kt

@@ -18,10 +18,11 @@ import androidx.core.graphics.Insets
 import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
-import androidx.lifecycle.Observer
 import com.google.android.material.snackbar.BaseTransientBottomBar
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.filterNotNull
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.exceptions.resolve.SnackbarErrorObserver
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
@@ -32,6 +33,8 @@ import org.koitharu.kotatsu.core.ui.dialog.RecyclerViewAlertDialog
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.ui.widgets.BottomSheetHeaderBar
 import org.koitharu.kotatsu.core.util.ViewBadge
+import org.koitharu.kotatsu.core.util.ext.observe
+import org.koitharu.kotatsu.core.util.ext.observeEvent
 import org.koitharu.kotatsu.core.util.ext.setNavigationBarTransparentCompat
 import org.koitharu.kotatsu.core.util.ext.textAndVisible
 import org.koitharu.kotatsu.databinding.ActivityDetailsBinding
@@ -90,10 +93,10 @@ class DetailsActivity :
 			ChaptersMenuProvider(viewModel, null)
 		}
 
-		viewModel.manga.observe(this, ::onMangaUpdated)
+		viewModel.manga.filterNotNull().observe(this, ::onMangaUpdated)
 		viewModel.newChaptersCount.observe(this, ::onNewChaptersChanged)
-		viewModel.onMangaRemoved.observe(this, ::onMangaRemoved)
-		viewModel.onError.observe(
+		viewModel.onMangaRemoved.observeEvent(this, ::onMangaRemoved)
+		viewModel.onError.observeEvent(
 			this,
 			SnackbarErrorObserver(
 				host = viewBinding.containerDetails,
@@ -106,11 +109,11 @@ class DetailsActivity :
 				},
 			),
 		)
-		viewModel.onShowToast.observe(this) {
+		viewModel.onShowToast.observeEvent(this) {
 			makeSnackbar(getString(it), Snackbar.LENGTH_SHORT).show()
 		}
 		viewModel.historyInfo.observe(this, ::onHistoryChanged)
-		viewModel.selectedBranchName.observe(this) {
+		viewModel.selectedBranch.observe(this) {
 			viewBinding.headerChapters?.subtitle = it
 			viewBinding.textViewSubtitle?.textAndVisible = it
 		}
@@ -124,7 +127,7 @@ class DetailsActivity :
 			viewBinding.buttonDropdown.isVisible = it.size > 1
 		}
 		viewModel.chapters.observe(this, PrefetchObserver(this))
-		viewModel.onDownloadStarted.observe(this, DownloadStartedObserver(viewBinding.containerDetails))
+		viewModel.onDownloadStarted.observeEvent(this, DownloadStartedObserver(viewBinding.containerDetails))
 
 		addMenuProvider(
 			DetailsMenuProvider(
@@ -165,12 +168,12 @@ class DetailsActivity :
 			}
 
 			R.id.action_pages_thumbs -> {
-				val history = viewModel.historyInfo.value?.history
+				val history = viewModel.historyInfo.value.history
 				PagesThumbnailsSheet.show(
 					fm = supportFragmentManager,
 					manga = viewModel.manga.value ?: return false,
 					chapterId = history?.chapterId
-						?: viewModel.chapters.value?.firstOrNull()?.chapter?.id
+						?: viewModel.chapters.value.firstOrNull()?.chapter?.id
 						?: return false,
 					currentPage = history?.page ?: 0,
 				)
@@ -253,14 +256,14 @@ class DetailsActivity :
 			.setCancelable(true)
 			.setNegativeButton(android.R.string.cancel, null)
 			.setTitle(R.string.translations)
-			.setItems(viewModel.branches.value.orEmpty())
+			.setItems(viewModel.branches.value)
 			.create()
 			.also { it.show() }
 	}
 
 	private fun openReader(isIncognitoMode: Boolean) {
 		val manga = viewModel.manga.value ?: return
-		val chapterId = viewModel.historyInfo.value?.history?.chapterId
+		val chapterId = viewModel.historyInfo.value.history?.chapterId
 		if (chapterId != null && manga.chapters?.none { x -> x.id == chapterId } == true) {
 			val snackbar = makeSnackbar(getString(R.string.chapter_is_missing), Snackbar.LENGTH_SHORT)
 			snackbar.show()
@@ -301,11 +304,11 @@ class DetailsActivity :
 
 	private class PrefetchObserver(
 		private val context: Context,
-	) : Observer<List<ChapterListItem>?> {
+	) : FlowCollector<List<ChapterListItem>?> {
 
 		private var isCalled = false
 
-		override fun onChanged(value: List<ChapterListItem>?) {
+		override suspend fun emit(value: List<ChapterListItem>?) {
 			if (value.isNullOrEmpty()) {
 				return
 			}

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/DetailsFragment.kt

@@ -18,6 +18,7 @@ import coil.request.ImageRequest
 import coil.util.CoilUtils
 import com.google.android.material.chip.Chip
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.flow.filterNotNull
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.bookmarks.ui.adapter.BookmarksAdapter
@@ -34,6 +35,7 @@ import org.koitharu.kotatsu.core.util.ext.drawableTop
 import org.koitharu.kotatsu.core.util.ext.enqueueWith
 import org.koitharu.kotatsu.core.util.ext.ifNullOrEmpty
 import org.koitharu.kotatsu.core.util.ext.measureHeight
+import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.resolveDp
 import org.koitharu.kotatsu.core.util.ext.scaleUpActivityOptionsOf
 import org.koitharu.kotatsu.core.util.ext.textAndVisible
@@ -42,7 +44,7 @@ import org.koitharu.kotatsu.details.ui.model.ChapterListItem
 import org.koitharu.kotatsu.details.ui.model.HistoryInfo
 import org.koitharu.kotatsu.details.ui.scrobbling.ScrobblingItemDecoration
 import org.koitharu.kotatsu.details.ui.scrobbling.ScrollingInfoAdapter
-import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
+import org.koitharu.kotatsu.history.data.PROGRESS_NONE
 import org.koitharu.kotatsu.image.ui.ImageActivity
 import org.koitharu.kotatsu.main.ui.owners.NoModalBottomSheetOwner
 import org.koitharu.kotatsu.parsers.model.Manga
@@ -82,7 +84,7 @@ class DetailsFragment :
 		binding.infoLayout.textViewSource.setOnClickListener(this)
 		binding.textViewDescription.movementMethod = LinkMovementMethod.getInstance()
 		binding.chipsTags.onChipClickListener = this
-		viewModel.manga.observe(viewLifecycleOwner, ::onMangaUpdated)
+		viewModel.manga.filterNotNull().observe(viewLifecycleOwner, ::onMangaUpdated)
 		viewModel.isLoading.observe(viewLifecycleOwner, ::onLoadingStateChanged)
 		viewModel.historyInfo.observe(viewLifecycleOwner, ::onHistoryChanged)
 		viewModel.bookmarks.observe(viewLifecycleOwner, ::onBookmarksChanged)

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/DetailsViewModel.kt

@@ -7,10 +7,7 @@ import android.text.style.ForegroundColorSpan
 import androidx.core.net.toUri
 import androidx.core.text.getSpans
 import androidx.core.text.parseAsHtml
-import androidx.lifecycle.LiveData
 import androidx.lifecycle.SavedStateHandle
-import androidx.lifecycle.asFlow
-import androidx.lifecycle.asLiveData
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
@@ -18,9 +15,9 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChangedBy
-import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
@@ -31,27 +28,28 @@ import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.bookmarks.domain.BookmarksRepository
-import org.koitharu.kotatsu.core.model.DoubleManga
 import org.koitharu.kotatsu.core.model.getPreferredBranch
 import org.koitharu.kotatsu.core.parser.MangaIntent
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.observeAsFlow
+import org.koitharu.kotatsu.core.prefs.observeAsStateFlow
 import org.koitharu.kotatsu.core.ui.BaseViewModel
-import org.koitharu.kotatsu.core.util.SingleLiveEvent
-import org.koitharu.kotatsu.core.util.asFlowLiveData
+import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
+import org.koitharu.kotatsu.core.util.ext.call
 import org.koitharu.kotatsu.core.util.ext.computeSize
 import org.koitharu.kotatsu.core.util.ext.requireValue
 import org.koitharu.kotatsu.core.util.ext.toFileOrNull
 import org.koitharu.kotatsu.details.domain.BranchComparator
 import org.koitharu.kotatsu.details.domain.DetailsInteractor
+import org.koitharu.kotatsu.details.domain.DoubleMangaLoadUseCase
+import org.koitharu.kotatsu.details.domain.model.DoubleManga
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem
 import org.koitharu.kotatsu.details.ui.model.HistoryInfo
 import org.koitharu.kotatsu.details.ui.model.MangaBranch
 import org.koitharu.kotatsu.download.ui.worker.DownloadWorker
-import org.koitharu.kotatsu.history.domain.HistoryRepository
-import org.koitharu.kotatsu.local.data.LocalManga
+import org.koitharu.kotatsu.history.data.HistoryRepository
 import org.koitharu.kotatsu.local.data.LocalStorageChanges
-import org.koitharu.kotatsu.local.domain.DoubleMangaLoader
+import org.koitharu.kotatsu.local.domain.DeleteLocalMangaUseCase
+import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.scrobbling.common.domain.Scrobbler
 import org.koitharu.kotatsu.scrobbling.common.domain.model.ScrobblingInfo
@@ -69,7 +67,8 @@ class DetailsViewModel @Inject constructor(
 	private val downloadScheduler: DownloadWorker.Scheduler,
 	private val interactor: DetailsInteractor,
 	savedStateHandle: SavedStateHandle,
-	private val mangaLoader: DoubleMangaLoader,
+	private val deleteLocalMangaUseCase: DeleteLocalMangaUseCase,
+	private val doubleMangaLoadUseCase: DoubleMangaLoadUseCase,
 ) : BaseViewModel() {
 
 	private val intent = MangaIntent(savedStateHandle)
@@ -77,47 +76,46 @@ class DetailsViewModel @Inject constructor(
 	private val doubleManga: MutableStateFlow<DoubleManga?> = MutableStateFlow(intent.manga?.let { DoubleManga(it) })
 	private var loadingJob: Job
 
-	val onShowToast = SingleLiveEvent<Int>()
-	val onDownloadStarted = SingleLiveEvent<Unit>()
+	val onShowToast = MutableEventFlow<Int>()
+	val onDownloadStarted = MutableEventFlow<Unit>()
 
-	private val mangaData = doubleManga.map { it?.any }
+	val manga = doubleManga.map { it?.any }
 		.stateIn(viewModelScope, SharingStarted.Eagerly, doubleManga.value?.any)
 
-	private val history = historyRepository.observeOne(mangaId)
+	val history = historyRepository.observeOne(mangaId)
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, null)
 
-	private val favourite = interactor.observeIsFavourite(mangaId)
+	val favouriteCategories = interactor.observeIsFavourite(mangaId)
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, false)
 
-	private val newChapters = interactor.observeNewChapters(mangaId)
+	val newChaptersCount = interactor.observeNewChapters(mangaId)
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, 0)
 
 	private val chaptersQuery = MutableStateFlow("")
-	private val selectedBranch = MutableStateFlow<String?>(null)
+	val selectedBranch = MutableStateFlow<String?>(null)
 
-	private val chaptersReversed = settings.observeAsFlow(AppSettings.KEY_REVERSE_CHAPTERS) { chaptersReverse }
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, false)
-
-	val manga = mangaData.filterNotNull().asLiveData(viewModelScope.coroutineContext)
-	val favouriteCategories = favourite.asLiveData(viewModelScope.coroutineContext)
-	val newChaptersCount = newChapters.asLiveData(viewModelScope.coroutineContext)
-	val isChaptersReversed = chaptersReversed.asLiveData(viewModelScope.coroutineContext)
-
-	val historyInfo: LiveData<HistoryInfo> = combine(
-		mangaData,
-		selectedBranch,
-		history,
-		interactor.observeIncognitoMode(mangaData),
-	) { m, b, h, im ->
-		HistoryInfo(m, b, h, im)
-	}.asFlowLiveData(
-		context = viewModelScope.coroutineContext + Dispatchers.Default,
-		defaultValue = HistoryInfo(null, null, null, false),
+	val isChaptersReversed = settings.observeAsStateFlow(
+		scope = viewModelScope + Dispatchers.Default,
+		key = AppSettings.KEY_REVERSE_CHAPTERS,
+		valueProducer = { chaptersReverse },
 	)
 
-	val bookmarks = mangaData.flatMapLatest {
+	val historyInfo: StateFlow<HistoryInfo> = combine(
+		manga,
+		selectedBranch,
+		history,
+		interactor.observeIncognitoMode(manga),
+	) { m, b, h, im ->
+		HistoryInfo(m, b, h, im)
+	}.stateIn(
+		scope = viewModelScope + Dispatchers.Default,
+		started = SharingStarted.Eagerly,
+		initialValue = HistoryInfo(null, null, null, false),
+	)
+
+	val bookmarks = manga.flatMapLatest {
 		if (it != null) bookmarksRepository.observeBookmarks(it) else flowOf(emptyList())
-	}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, emptyList())
+	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Lazily, emptyList())
 
 	val localSize = doubleManga
 		.map {
@@ -128,9 +126,9 @@ class DetailsViewModel @Inject constructor(
 			} else {
 				0L
 			}
-		}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, 0)
+		}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.WhileSubscribed(), 0)
 
-	val description = mangaData
+	val description = manga
 		.distinctUntilChangedBy { it?.description.orEmpty() }
 		.transformLatest {
 			val description = it?.description
@@ -140,16 +138,16 @@ class DetailsViewModel @Inject constructor(
 				emit(description.parseAsHtml().filterSpans())
 				emit(description.parseAsHtml(imageGetter = imageGetter).filterSpans())
 			}
-		}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, null)
+		}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.WhileSubscribed(5000), null)
 
-	val onMangaRemoved = SingleLiveEvent<Manga>()
+	val onMangaRemoved = MutableEventFlow<Manga>()
 	val isScrobblingAvailable: Boolean
 		get() = scrobblers.any { it.isAvailable }
 
-	val scrobblingInfo: LiveData<List<ScrobblingInfo>> = interactor.observeScrobblingInfo(mangaId)
-		.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, emptyList())
+	val scrobblingInfo: StateFlow<List<ScrobblingInfo>> = interactor.observeScrobblingInfo(mangaId)
+		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, emptyList())
 
-	val branches: LiveData<List<MangaBranch>> = combine(
+	val branches: StateFlow<List<MangaBranch>> = combine(
 		doubleManga,
 		selectedBranch,
 	) { m, b ->
@@ -158,32 +156,29 @@ class DetailsViewModel @Inject constructor(
 		chapters.groupBy { x -> x.branch }
 			.map { x -> MangaBranch(x.key, x.value.size, x.key == b) }
 			.sortedWith(BranchComparator())
-	}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, emptyList())
+	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, emptyList())
 
-	val selectedBranchName = selectedBranch
-		.asFlowLiveData(viewModelScope.coroutineContext, null)
-
-	val isChaptersEmpty: LiveData<Boolean> = combine(
+	val isChaptersEmpty: StateFlow<Boolean> = combine(
 		doubleManga,
-		isLoading.asFlow(),
+		isLoading,
 	) { manga, loading ->
 		manga?.any != null && manga.chapters.isNullOrEmpty() && !loading
-	}.asFlowLiveData(viewModelScope.coroutineContext, false)
+	}.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), false)
 
 	val chapters = combine(
 		combine(
 			doubleManga,
 			history,
 			selectedBranch,
-			newChapters,
+			newChaptersCount,
 		) { manga, history, branch, news ->
 			mapChapters(manga?.remote, manga?.local, history, news, branch)
 		},
-		chaptersReversed,
+		isChaptersReversed,
 		chaptersQuery,
 	) { list, reversed, query ->
 		(if (reversed) list.asReversed() else list).filterSearch(query)
-	}.asLiveData(viewModelScope.coroutineContext + Dispatchers.Default)
+	}.stateIn(viewModelScope, SharingStarted.Eagerly, emptyList())
 
 	val selectedBranchValue: String?
 		get() = selectedBranch.value
@@ -208,8 +203,8 @@ class DetailsViewModel @Inject constructor(
 			return
 		}
 		launchLoadingJob(Dispatchers.Default) {
-			interactor.deleteLocalManga(m)
-			onMangaRemoved.emitCall(m)
+			deleteLocalMangaUseCase(m)
+			onMangaRemoved.call(m)
 		}
 	}
 
@@ -276,12 +271,12 @@ class DetailsViewModel @Inject constructor(
 				doubleManga.requireValue().requireAny(),
 				chaptersIds,
 			)
-			onDownloadStarted.emitCall(Unit)
+			onDownloadStarted.call(Unit)
 		}
 	}
 
 	private fun doLoad() = launchLoadingJob(Dispatchers.Default) {
-		val result = mangaLoader.load(intent)
+		val result = doubleMangaLoadUseCase(intent)
 		val manga = result.requireAny()
 		// find default branch
 		val hist = historyRepository.getOne(manga)
@@ -317,7 +312,7 @@ class DetailsViewModel @Inject constructor(
 	}
 
 	private fun getScrobbler(index: Int): Scrobbler? {
-		val info = scrobblingInfo.value?.getOrNull(index)
+		val info = scrobblingInfo.value.getOrNull(index)
 		val scrobbler = if (info != null) {
 			scrobblers.find { it.scrobblerService == info.scrobbler && it.isAvailable }
 		} else {

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/scrobbling/ScrobblingInfoBottomSheet.kt

@@ -21,6 +21,8 @@ import org.koitharu.kotatsu.core.ui.BaseBottomSheet
 import org.koitharu.kotatsu.core.util.ext.enqueueWith
 import org.koitharu.kotatsu.core.util.ext.getDisplayMessage
 import org.koitharu.kotatsu.core.util.ext.newImageRequest
+import org.koitharu.kotatsu.core.util.ext.observe
+import org.koitharu.kotatsu.core.util.ext.observeEvent
 import org.koitharu.kotatsu.core.util.ext.scaleUpActivityOptionsOf
 import org.koitharu.kotatsu.core.util.ext.withArgs
 import org.koitharu.kotatsu.databinding.SheetScrobblingBinding
@@ -59,7 +61,7 @@ class ScrobblingInfoBottomSheet :
 	override fun onViewBindingCreated(binding: SheetScrobblingBinding, savedInstanceState: Bundle?) {
 		super.onViewBindingCreated(binding, savedInstanceState)
 		viewModel.scrobblingInfo.observe(viewLifecycleOwner, ::onScrobblingInfoChanged)
-		viewModel.onError.observe(viewLifecycleOwner) {
+		viewModel.onError.observeEvent(viewLifecycleOwner) {
 			Toast.makeText(binding.root.context, it.getDisplayMessage(binding.root.resources), Toast.LENGTH_SHORT)
 				.show()
 		}
@@ -105,7 +107,7 @@ class ScrobblingInfoBottomSheet :
 		when (v.id) {
 			R.id.button_menu -> menu?.show()
 			R.id.imageView_cover -> {
-				val coverUrl = viewModel.scrobblingInfo.value?.getOrNull(scrobblerIndex)?.coverUrl ?: return
+				val coverUrl = viewModel.scrobblingInfo.value.getOrNull(scrobblerIndex)?.coverUrl ?: return
 				val options = scaleUpActivityOptionsOf(v)
 				startActivity(ImageActivity.newIntent(v.context, coverUrl, null), options.toBundle())
 			}
@@ -135,7 +137,7 @@ class ScrobblingInfoBottomSheet :
 	override fun onMenuItemClick(item: MenuItem): Boolean {
 		when (item.itemId) {
 			R.id.action_browser -> {
-				val url = viewModel.scrobblingInfo.value?.getOrNull(scrobblerIndex)?.externalUrl ?: return false
+				val url = viewModel.scrobblingInfo.value.getOrNull(scrobblerIndex)?.externalUrl ?: return false
 				val intent = Intent(Intent.ACTION_VIEW, url.toUri())
 				startActivity(
 					Intent.createChooser(intent, getString(R.string.open_in_browser)),
@@ -149,7 +151,7 @@ class ScrobblingInfoBottomSheet :
 
 			R.id.action_edit -> {
 				val manga = viewModel.manga.value ?: return false
-				val scrobblerService = viewModel.scrobblingInfo.value?.getOrNull(scrobblerIndex)?.scrobbler
+				val scrobblerService = viewModel.scrobblingInfo.value.getOrNull(scrobblerIndex)?.scrobbler
 				ScrobblingSelectorBottomSheet.show(parentFragmentManager, manga, scrobblerService)
 				dismiss()
 			}