Draft double reader implementation

app/build.gradle

@@ -16,8 +16,8 @@ android {
 		applicationId 'org.koitharu.kotatsu'
 		minSdk = 21
 		targetSdk = 34
-		versionCode = 588
+		versionCode = 584
-		versionName = '6.2.1'
+		versionName = '6.1.6'
 		generatedDensities = []
 		testInstrumentationRunner "org.koitharu.kotatsu.HiltTestRunner"
 		ksp {
@@ -81,7 +81,7 @@ afterEvaluate {
 }
 dependencies {
 	//noinspection GradleDependency
-	implementation('com.github.KotatsuApp:kotatsu-parsers:0054d06e6e') {
+	implementation('com.github.KotatsuApp:kotatsu-parsers:400a90464e') {
 		exclude group: 'org.json', module: 'json'
 	}
 
@@ -132,7 +132,7 @@ dependencies {
 
 	implementation 'io.coil-kt:coil-base:2.4.0'
 	implementation 'io.coil-kt:coil-svg:2.4.0'
-	implementation 'com.github.KotatsuApp:subsampling-scale-image-view:cf089a264d'
+	implementation 'com.github.KotatsuApp:subsampling-scale-image-view:169806d928'
 	implementation 'com.github.solkin:disk-lru-cache:1.4'
 	implementation 'io.noties.markwon:core:4.6.2'
 

app/src/main/kotlin/org/koitharu/kotatsu/core/model/FavouriteCategory.kt

@@ -2,9 +2,9 @@ package org.koitharu.kotatsu.core.model
 
 import android.os.Parcelable
 import kotlinx.parcelize.Parcelize
-import org.koitharu.kotatsu.list.domain.ListSortOrder
 import org.koitharu.kotatsu.list.ui.ListModelDiffCallback
 import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import java.util.Date
 
 @Parcelize
@@ -12,7 +12,7 @@ data class FavouriteCategory(
 	val id: Long,
 	val title: String,
 	val sortKey: Int,
-	val order: ListSortOrder,
+	val order: SortOrder,
 	val createdAt: Date,
 	val isTrackingEnabled: Boolean,
 	val isVisibleInLibrary: Boolean,

app/src/main/kotlin/org/koitharu/kotatsu/core/network/GZipInterceptor.kt

@@ -2,7 +2,6 @@ package org.koitharu.kotatsu.core.network
 
 import okhttp3.Interceptor
 import okhttp3.Response
-import okio.IOException
 import org.koitharu.kotatsu.core.network.CommonHeaders.CONTENT_ENCODING
 
 class GZipInterceptor : Interceptor {
@@ -10,10 +9,6 @@ class GZipInterceptor : Interceptor {
 	override fun intercept(chain: Interceptor.Chain): Response {
 		val newRequest = chain.request().newBuilder()
 		newRequest.addHeader(CONTENT_ENCODING, "gzip")
-		return try {
+		return chain.proceed(newRequest.build())
-			chain.proceed(newRequest.build())
-		} catch (e: NullPointerException) {
-			throw IOException(e)
-		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/parser/MangaIntent.kt

@@ -43,7 +43,5 @@ class MangaIntent private constructor(
 
 		const val KEY_MANGA = "manga"
 		const val KEY_ID = "id"
-
-		fun of(manga: Manga) = MangaIntent(manga, manga.id, null)
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/parser/RemoteMangaRepository.kt

@@ -128,10 +128,6 @@ class RemoteMangaRepository(
 		return details.await()
 	}
 
-	suspend fun peekDetails(manga: Manga): Manga? {
-		return cache.getDetails(source, manga.url)
-	}
-
 	suspend fun find(manga: Manga): Manga? {
 		val list = getList(0, manga.title)
 		return list.find { x -> x.id == manga.id }

app/src/main/kotlin/org/koitharu/kotatsu/core/prefs/AppSettings.kt

@@ -22,7 +22,7 @@ import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.putEnumValue
 import org.koitharu.kotatsu.core.util.ext.takeIfReadable
 import org.koitharu.kotatsu.core.util.ext.toUriOrNull
-import org.koitharu.kotatsu.list.domain.ListSortOrder
+import org.koitharu.kotatsu.history.domain.model.HistoryOrder
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.util.find
 import org.koitharu.kotatsu.parsers.util.mapNotNullToSet
@@ -72,18 +72,6 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getInt(KEY_GRID_SIZE, 100)
 		set(value) = prefs.edit { putInt(KEY_GRID_SIZE, value) }
 
-	var historyListMode: ListMode
-		get() = prefs.getEnumValue(KEY_LIST_MODE_HISTORY, listMode)
-		set(value) = prefs.edit { putEnumValue(KEY_LIST_MODE_HISTORY, value) }
-
-	var suggestionsListMode: ListMode
-		get() = prefs.getEnumValue(KEY_LIST_MODE_SUGGESTIONS, listMode)
-		set(value) = prefs.edit { putEnumValue(KEY_LIST_MODE_SUGGESTIONS, value) }
-
-	var favoritesListMode: ListMode
-		get() = prefs.getEnumValue(KEY_LIST_MODE_FAVORITES, listMode)
-		set(value) = prefs.edit { putEnumValue(KEY_LIST_MODE_FAVORITES, value) }
-
 	var isNsfwContentDisabled: Boolean
 		get() = prefs.getBoolean(KEY_DISABLE_NSFW, false)
 		set(value) = prefs.edit { putBoolean(KEY_DISABLE_NSFW, value) }
@@ -188,7 +176,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		set(value) = prefs.edit { putBoolean(KEY_PROTECT_APP_BIOMETRIC, value) }
 
 	val isMirrorSwitchingAvailable: Boolean
-		get() = prefs.getBoolean(KEY_MIRROR_SWITCHING, false)
+		get() = prefs.getBoolean(KEY_MIRROR_SWITCHING, true)
 
 	val isExitConfirmationEnabled: Boolean
 		get() = prefs.getBoolean(KEY_EXIT_CONFIRM, false)
@@ -213,9 +201,6 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getBoolean(KEY_SOURCES_GRID, false)
 		set(value) = prefs.edit { putBoolean(KEY_SOURCES_GRID, value) }
 
-	val isNewSourcesTipEnabled: Boolean
-		get() = prefs.getBoolean(KEY_SOURCES_NEW, true)
-
 	val isPagesNumbersEnabled: Boolean
 		get() = prefs.getBoolean(KEY_PAGES_NUMBERS, false)
 
@@ -319,8 +304,8 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getEnumValue(KEY_LOCAL_LIST_ORDER, SortOrder.NEWEST)
 		set(value) = prefs.edit { putEnumValue(KEY_LOCAL_LIST_ORDER, value) }
 
-	var historySortOrder: ListSortOrder
+	var historySortOrder: HistoryOrder
-		get() = prefs.getEnumValue(KEY_HISTORY_ORDER, ListSortOrder.UPDATED)
+		get() = prefs.getEnumValue(KEY_HISTORY_ORDER, HistoryOrder.UPDATED)
 		set(value) = prefs.edit { putEnumValue(KEY_HISTORY_ORDER, value) }
 
 	val isRelatedMangaEnabled: Boolean
@@ -351,9 +336,6 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 			return policy.isNetworkAllowed(connectivityManager)
 		}
 
-	val is32BitColorsEnabled: Boolean
-		get() = prefs.getBoolean(KEY_32BIT_COLOR, false)
-
 	fun isTipEnabled(tip: String): Boolean {
 		return prefs.getStringSet(KEY_TIPS_CLOSED, emptySet())?.contains(tip) != true
 	}
@@ -419,9 +401,6 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val TRACK_FAVOURITES = "favourites"
 
 		const val KEY_LIST_MODE = "list_mode_2"
-		const val KEY_LIST_MODE_HISTORY = "list_mode_history"
-		const val KEY_LIST_MODE_FAVORITES = "list_mode_favorites"
-		const val KEY_LIST_MODE_SUGGESTIONS = "list_mode_suggestions"
 		const val KEY_THEME = "theme"
 		const val KEY_COLOR_THEME = "color_theme"
 		const val KEY_THEME_AMOLED = "amoled_theme"
@@ -495,7 +474,6 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_LOGGING_ENABLED = "logging"
 		const val KEY_LOGS_SHARE = "logs_share"
 		const val KEY_SOURCES_GRID = "sources_grid"
-		const val KEY_SOURCES_NEW = "sources_new"
 		const val KEY_UPDATES_UNSTABLE = "updates_unstable"
 		const val KEY_TIPS_CLOSED = "tips_closed"
 		const val KEY_SSL_BYPASS = "ssl_bypass"
@@ -513,7 +491,6 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_DISABLE_NSFW = "no_nsfw"
 		const val KEY_RELATED_MANGA = "related_manga"
 		const val KEY_NAV_MAIN = "nav_main"
-		const val KEY_32BIT_COLOR = "enhanced_colors"
 
 		// About
 		const val KEY_APP_UPDATE = "app_update"

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/BaseActivity.kt

@@ -126,10 +126,10 @@ abstract class BaseActivity<B : ViewBinding> :
 		val actionModeColor = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 			ColorUtils.compositeColors(
 				ContextCompat.getColor(this, com.google.android.material.R.color.m3_appbar_overlay_color),
-				getThemeColor(R.attr.m3ColorBackground),
+				getThemeColor(com.google.android.material.R.attr.colorSurface),
 			)
 		} else {
-			ContextCompat.getColor(this, R.color.kotatsu_m3_background)
+			ContextCompat.getColor(this, R.color.kotatsu_secondaryContainer)
 		}
 		val insets = ViewCompat.getRootWindowInsets(viewBinding.root)
 			?.getInsets(WindowInsetsCompat.Type.systemBars()) ?: return

app/src/main/kotlin/org/koitharu/kotatsu/core/util/CompositeMutex.kt

@@ -8,7 +8,6 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlin.coroutines.coroutineContext
 
-@Deprecated("", replaceWith = ReplaceWith("CompositeMutex2"))
 class CompositeMutex<T : Any> : Set<T> {
 
 	private val state = ArrayMap<T, MutableStateFlow<Boolean>>()

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ViewBadge.kt

@@ -15,7 +15,6 @@ class ViewBadge(
 ) : View.OnLayoutChangeListener, DefaultLifecycleObserver {
 
 	private var badgeDrawable: BadgeDrawable? = null
-	private var maxCharacterCount: Int = -1
 
 	var counter: Int
 		get() = badgeDrawable?.number ?: 0
@@ -49,16 +48,8 @@ class ViewBadge(
 		clearBadge()
 	}
 
-	fun setMaxCharacterCount(value: Int) {
-		maxCharacterCount = value
-		badgeDrawable?.maxCharacterCount = value
-	}
-
 	private fun initBadge(): BadgeDrawable {
 		val badge = BadgeDrawable.create(anchor.context)
-		if (maxCharacterCount > 0) {
-			badge.maxCharacterCount = maxCharacterCount
-		}
 		anchor.addOnLayoutChangeListener(this)
 		BadgeUtils.attachBadgeDrawable(badge, anchor)
 		badgeDrawable = badge

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Collections.kt

@@ -55,5 +55,3 @@ inline fun <reified E : Enum<E>> Collection<E>.toEnumSet(): EnumSet<E> = if (isE
 } else {
 	EnumSet.copyOf(this)
 }
-
-fun <E : Enum<E>> Collection<E>.sortedByOrdinal() = sortedBy { it.ordinal }

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Coroutines.kt

@@ -14,7 +14,6 @@ import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.suspendCancellableCoroutine
 import org.koitharu.kotatsu.core.util.RetainedLifecycleCoroutineScope
-import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
@@ -80,11 +79,3 @@ fun <T> Deferred<T>.getCompletionResultOrNull(): Result<T>? = if (isCompleted) {
 } else {
 	null
 }
-
-fun <T> Deferred<T>.peek(): T? = if (isCompleted) {
-	runCatchingCancellable {
-		getCompleted()
-	}.getOrNull()
-} else {
-	null
-}

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Flow.kt

@@ -26,17 +26,6 @@ fun <T> Flow<T>.onFirst(action: suspend (T) -> Unit): Flow<T> {
 	}
 }
 
-fun <T> Flow<T>.onEachWhile(action: suspend (T) -> Boolean): Flow<T> {
-	var isCalled = false
-	return onEach {
-		if (!isCalled) {
-			isCalled = action(it)
-		}
-	}.onCompletion {
-		isCalled = false
-	}
-}
-
 inline fun <T, R> Flow<List<T>>.mapItems(crossinline transform: (T) -> R): Flow<List<R>> {
 	return map { list -> list.map(transform) }
 }

app/src/main/kotlin/org/koitharu/kotatsu/details/data/MangaDetails.kt

@@ -1,43 +0,0 @@
-package org.koitharu.kotatsu.details.data
-
-import org.koitharu.kotatsu.core.model.isLocal
-import org.koitharu.kotatsu.local.domain.model.LocalManga
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.model.MangaChapter
-import org.koitharu.kotatsu.reader.data.filterChapters
-
-data class MangaDetails(
-	private val manga: Manga,
-	private val localManga: LocalManga?,
-	val description: CharSequence?,
-	val isLoaded: Boolean,
-) {
-
-	val id: Long
-		get() = manga.id
-
-	val chapters: Map<String?, List<MangaChapter>> = manga.chapters?.groupBy { it.branch }.orEmpty()
-
-	val branches: Set<String?>
-		get() = chapters.keys
-
-	val allChapters: List<MangaChapter>
-		get() = manga.chapters.orEmpty()
-
-	val isLocal
-		get() = manga.isLocal
-
-	val local: LocalManga?
-		get() = localManga ?: if (manga.isLocal) LocalManga(manga) else null
-
-	fun toManga() = manga
-
-	fun filterChapters(branch: String?) = MangaDetails(
-		manga = manga.filterChapters(branch),
-		localManga = localManga?.run {
-			copy(manga = manga.filterChapters(branch))
-		},
-		description = description,
-		isLoaded = isLoaded,
-	)
-}

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

@@ -8,7 +8,7 @@ import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.observeAsFlow
-import org.koitharu.kotatsu.details.data.MangaDetails
+import org.koitharu.kotatsu.details.domain.model.DoubleManga
 import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
 import org.koitharu.kotatsu.history.data.HistoryRepository
 import org.koitharu.kotatsu.local.data.LocalMangaRepository
@@ -20,7 +20,7 @@ import org.koitharu.kotatsu.scrobbling.common.domain.model.ScrobblingInfo
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import javax.inject.Inject
 
-/* TODO: remove */
+@Deprecated("")
 class DetailsInteractor @Inject constructor(
 	private val historyRepository: HistoryRepository,
 	private val favouritesRepository: FavouritesRepository,
@@ -66,26 +66,15 @@ class DetailsInteractor @Inject constructor(
 			}
 	}
 
-	suspend fun updateLocal(subject: MangaDetails?, localManga: LocalManga): MangaDetails? {
+	suspend fun updateLocal(subject: DoubleManga?, localManga: LocalManga): DoubleManga? {
-		subject ?: return null
+		return if (subject?.any?.id == localManga.manga.id) {
-		return if (subject.id == localManga.manga.id) {
+			subject.copy(
-			if (subject.isLocal) {
+				localManga = runCatchingCancellable {
-				subject.copy(
+					localMangaRepository.getDetails(localManga.manga)
-					manga = localManga.manga,
+				},
-				)
+			)
-			} else {
-				subject.copy(
-					localManga = runCatchingCancellable {
-						localManga.copy(
-							manga = localMangaRepository.getDetails(localManga.manga),
-						)
-					}.getOrNull() ?: subject.local,
-				)
-			}
 		} else {
 			subject
 		}
 	}
-
-	suspend fun findLocal(seed: Manga) = localMangaRepository.getRemoteManga(seed)
 }

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

@@ -1,85 +0,0 @@
-package org.koitharu.kotatsu.details.domain
-
-import android.text.Html
-import android.text.SpannableString
-import android.text.Spanned
-import android.text.style.ForegroundColorSpan
-import androidx.core.text.getSpans
-import androidx.core.text.parseAsHtml
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.channelFlow
-import kotlinx.coroutines.runInterruptible
-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.core.util.ext.peek
-import org.koitharu.kotatsu.core.util.ext.sanitize
-import org.koitharu.kotatsu.details.data.MangaDetails
-import org.koitharu.kotatsu.explore.domain.RecoverMangaUseCase
-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.recoverNotNull
-import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
-import javax.inject.Inject
-
-class DetailsLoadUseCase @Inject constructor(
-	private val mangaDataRepository: MangaDataRepository,
-	private val localMangaRepository: LocalMangaRepository,
-	private val mangaRepositoryFactory: MangaRepository.Factory,
-	private val recoverUseCase: RecoverMangaUseCase,
-	private val imageGetter: Html.ImageGetter,
-) {
-
-	operator fun invoke(intent: MangaIntent): Flow<MangaDetails> = channelFlow {
-		val manga = requireNotNull(mangaDataRepository.resolveIntent(intent)) {
-			"Cannot resolve intent $intent"
-		}
-		val local = if (!manga.isLocal) {
-			async {
-				localMangaRepository.findSavedManga(manga)
-			}
-		} else {
-			null
-		}
-		send(MangaDetails(manga, null, null, false))
-		val details = getDetails(manga)
-		send(MangaDetails(details, local?.peek(), details.description?.parseAsHtml(withImages = false), false))
-		send(MangaDetails(details, local?.await(), details.description?.parseAsHtml(withImages = true), true))
-	}
-
-	private suspend fun getDetails(seed: Manga) = runCatchingCancellable {
-		val repository = mangaRepositoryFactory.create(seed.source)
-		repository.getDetails(seed)
-	}.recoverNotNull { e ->
-		if (e is NotFoundException) {
-			recoverUseCase(seed)
-		} else {
-			null
-		}
-	}.getOrThrow()
-
-	private suspend fun String.parseAsHtml(withImages: Boolean): CharSequence? {
-		return if (withImages) {
-			runInterruptible(Dispatchers.IO) {
-				parseAsHtml(imageGetter = imageGetter)
-			}.filterSpans()
-		} else {
-			runInterruptible(Dispatchers.Default) {
-				parseAsHtml()
-			}.filterSpans().sanitize()
-		}.takeUnless { it.isBlank() }
-	}
-
-	private fun Spanned.filterSpans(): Spanned {
-		val spannable = SpannableString.valueOf(this)
-		val spans = spannable.getSpans<ForegroundColorSpan>()
-		for (span in spans) {
-			spannable.removeSpan(span)
-		}
-		return spannable
-	}
-}

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

@@ -0,0 +1,91 @@
+package org.koitharu.kotatsu.details.domain
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+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.explore.domain.RecoverMangaUseCase
+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.recoverNotNull
+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,
+	private val recoverUseCase: RecoverMangaUseCase,
+) {
+
+	operator fun invoke(manga: Manga): Flow<DoubleManga> = flow {
+		var lastValue: DoubleManga? = null
+		var emitted = false
+		invokeImpl(manga).collect {
+			lastValue = it
+			if (it.any != null) {
+				emitted = true
+				emit(it)
+			}
+		}
+		if (!emitted) {
+			lastValue?.requireAny()
+		}
+	}.flowOn(Dispatchers.Default)
+
+	operator fun invoke(mangaId: Long): Flow<DoubleManga> = flow {
+		emit(mangaDataRepository.findMangaById(mangaId) ?: throwNFE())
+	}.flatMapLatest { invoke(it) }
+
+	operator fun invoke(intent: MangaIntent): Flow<DoubleManga> = flow {
+		emit(mangaDataRepository.resolveIntent(intent) ?: throwNFE())
+	}.flatMapLatest { invoke(it) }
+
+	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)
+		}.recoverNotNull { e ->
+			if (e is NotFoundException) {
+				recoverUseCase(manga)
+			} else {
+				null
+			}
+		}
+	}
+
+	private fun invokeImpl(manga: Manga): Flow<DoubleManga> = combine(
+		flow { emit(null); emit(loadRemote(manga)) },
+		flow { emit(null); emit(loadLocal(manga)) },
+	) { remote, local ->
+		DoubleManga(
+			remoteManga = remote,
+			localManga = local,
+		)
+	}
+
+	private fun throwNFE(): Nothing = throw NotFoundException("Cannot find manga", "")
+}

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

@@ -1,55 +0,0 @@
-package org.koitharu.kotatsu.details.domain
-
-import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.model.findChapter
-import org.koitharu.kotatsu.core.model.isLocal
-import org.koitharu.kotatsu.core.parser.MangaRepository
-import org.koitharu.kotatsu.history.data.PROGRESS_NONE
-import org.koitharu.kotatsu.local.data.LocalMangaRepository
-import org.koitharu.kotatsu.parsers.model.Manga
-import javax.inject.Inject
-
-class ProgressUpdateUseCase @Inject constructor(
-	private val mangaRepositoryFactory: MangaRepository.Factory,
-	private val database: MangaDatabase,
-	private val localMangaRepository: LocalMangaRepository,
-) {
-
-	suspend operator fun invoke(manga: Manga): Float {
-		val history = database.historyDao.find(manga.id) ?: return PROGRESS_NONE
-		val seed = if (manga.isLocal) {
-			localMangaRepository.getRemoteManga(manga) ?: manga
-		} else {
-			manga
-		}
-		val repo = mangaRepositoryFactory.create(seed.source)
-		val details = if (manga.source != seed.source || seed.chapters.isNullOrEmpty()) {
-			repo.getDetails(seed)
-		} else {
-			seed
-		}
-		val chapter = details.findChapter(history.chapterId) ?: return PROGRESS_NONE
-		val chapters = details.getChapters(chapter.branch) ?: return PROGRESS_NONE
-		val chaptersCount = chapters.size
-		if (chaptersCount == 0) {
-			return PROGRESS_NONE
-		}
-		val chapterIndex = chapters.indexOfFirst { x -> x.id == history.chapterId }
-		val pagesCount = repo.getPages(chapter).size
-		if (pagesCount == 0) {
-			return PROGRESS_NONE
-		}
-		val pagePercent = (history.page + 1) / pagesCount.toFloat()
-		val ppc = 1f / chaptersCount
-		val result = ppc * chapterIndex + ppc * pagePercent
-		if (result != history.percent) {
-			database.historyDao.update(
-				history.copy(
-					chapterId = chapter.id,
-					percent = result,
-				),
-			)
-		}
-		return result
-	}
-}

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

@@ -0,0 +1,81 @@
+package org.koitharu.kotatsu.details.domain.model
+
+import org.koitharu.kotatsu.core.model.findById
+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 hasChapter(id: Long): Boolean {
+		return local?.chapters?.findById(id) != null || remote?.chapters?.findById(id) != null
+	}
+
+	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/ui/ChaptersMapper.kt

@@ -2,30 +2,33 @@ package org.koitharu.kotatsu.details.ui
 
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.core.model.MangaHistory
-import org.koitharu.kotatsu.details.data.MangaDetails
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem
 import org.koitharu.kotatsu.details.ui.model.toListItem
+import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.util.mapToSet
 
-fun MangaDetails.mapChapters(
+fun mapChapters(
+	remoteManga: Manga?,
+	localManga: Manga?,
 	history: MangaHistory?,
 	newCount: Int,
 	branch: String?,
 	bookmarks: List<Bookmark>,
 ): List<ChapterListItem> {
-	val remoteChapters = chapters[branch].orEmpty()
+	val remoteChapters = remoteManga?.getChapters(branch).orEmpty()
-	val localChapters = local?.manga?.getChapters(branch).orEmpty()
+	val localChapters = localManga?.getChapters(branch).orEmpty()
 	if (remoteChapters.isEmpty() && localChapters.isEmpty()) {
 		return emptyList()
 	}
 	val bookmarked = bookmarks.mapToSet { it.chapterId }
 	val currentId = history?.chapterId ?: 0L
 	val newFrom = if (newCount == 0 || remoteChapters.isEmpty()) Int.MAX_VALUE else remoteChapters.size - newCount
-	val ids = buildSet(maxOf(remoteChapters.size, localChapters.size)) {
+	val chaptersSize = maxOf(remoteChapters.size, localChapters.size)
+	val ids = buildSet(chaptersSize) {
 		remoteChapters.mapTo(this) { it.id }
 		localChapters.mapTo(this) { it.id }
 	}
-	val result = ArrayList<ChapterListItem>(ids.size)
+	val result = ArrayList<ChapterListItem>(chaptersSize)
 	val localMap = if (localChapters.isNotEmpty()) {
 		localChapters.associateByTo(LinkedHashMap(localChapters.size)) { it.id }
 	} else {
@@ -37,7 +40,7 @@ fun MangaDetails.mapChapters(
 		if (chapter.id == currentId) {
 			isUnread = true
 		}
-		result += (local ?: chapter).toListItem(
+		result += chapter.toListItem(
 			isCurrent = chapter.id == currentId,
 			isUnread = isUnread,
 			isNew = isUnread && result.size >= newFrom,
@@ -54,7 +57,7 @@ fun MangaDetails.mapChapters(
 				isCurrent = chapter.id == currentId,
 				isUnread = isUnread,
 				isNew = false,
-				isDownloaded = !isLocal,
+				isDownloaded = remoteManga != null,
 				isBookmarked = chapter.id in bookmarked,
 			)
 		}

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

@@ -39,6 +39,7 @@ import org.koitharu.kotatsu.core.os.AppShortcutManager
 import org.koitharu.kotatsu.core.parser.MangaIntent
 import org.koitharu.kotatsu.core.ui.BaseActivity
 import org.koitharu.kotatsu.core.ui.util.MenuInvalidator
+import org.koitharu.kotatsu.core.util.ViewBadge
 import org.koitharu.kotatsu.core.util.ext.doOnExpansionsChanged
 import org.koitharu.kotatsu.core.util.ext.getAnimationDuration
 import org.koitharu.kotatsu.core.util.ext.getThemeColor
@@ -74,6 +75,7 @@ class DetailsActivity :
 	@Inject
 	lateinit var appShortcutManager: AppShortcutManager
 
+	private lateinit var viewBadge: ViewBadge
 	private var buttonTip: WeakReference<ButtonTip>? = null
 
 	private val viewModel: DetailsViewModel by viewModels()
@@ -90,6 +92,7 @@ class DetailsActivity :
 		viewBinding.buttonRead.setOnLongClickListener(this)
 		viewBinding.buttonRead.setOnContextClickListenerCompat(this)
 		viewBinding.buttonDropdown.setOnClickListener(this)
+		viewBadge = ViewBadge(viewBinding.buttonRead, this)
 
 		if (viewBinding.layoutBottom != null) {
 			val behavior = BottomSheetBehavior.from(checkNotNull(viewBinding.layoutBottom))
@@ -110,6 +113,7 @@ class DetailsActivity :
 		onBackPressedDispatcher.addCallback(chaptersMenuProvider)
 
 		viewModel.manga.filterNotNull().observe(this, ::onMangaUpdated)
+		viewModel.newChaptersCount.observe(this, ::onNewChaptersChanged)
 		viewModel.onMangaRemoved.observeEvent(this, ::onMangaRemoved)
 		viewModel.onError.observeEvent(
 			this,
@@ -135,18 +139,16 @@ class DetailsActivity :
 		}
 		viewModel.isChaptersReversed.observe(
 			this,
-			MenuInvalidator(viewBinding.toolbarChapters ?: this),
+			MenuInvalidator(viewBinding.toolbarChapters ?: this)
 		)
-		val menuInvalidator = MenuInvalidator(this)
+		viewModel.favouriteCategories.observe(this, MenuInvalidator(this))
-		viewModel.favouriteCategories.observe(this, menuInvalidator)
-		viewModel.remoteManga.observe(this, menuInvalidator)
 		viewModel.branches.observe(this) {
 			viewBinding.buttonDropdown.isVisible = it.size > 1
 		}
 		viewModel.chapters.observe(this, PrefetchObserver(this))
 		viewModel.onDownloadStarted.observeEvent(
 			this,
-			DownloadStartedObserver(viewBinding.containerDetails),
+			DownloadStartedObserver(viewBinding.containerDetails)
 		)
 
 		addMenuProvider(
@@ -253,7 +255,7 @@ class DetailsActivity :
 			window.setNavigationBarTransparentCompat(
 				this,
 				viewBinding.layoutBottom?.elevation ?: 0f,
-				0.9f,
+				0.9f
 			)
 		}
 		viewBinding.cardChapters?.updateLayoutParams<MarginLayoutParams> {
@@ -279,20 +281,24 @@ class DetailsActivity :
 			info.currentChapter >= 0 -> getString(
 				R.string.chapter_d_of_d,
 				info.currentChapter + 1,
-				info.totalChapters,
+				info.totalChapters
 			)
 
 			info.totalChapters == 0 -> getString(R.string.no_chapters)
 			else -> resources.getQuantityString(
 				R.plurals.chapters,
 				info.totalChapters,
-				info.totalChapters,
+				info.totalChapters
 			)
 		}
 		viewBinding.toolbarChapters?.title = text
 		viewBinding.textViewTitle?.text = text
 	}
 
+	private fun onNewChaptersChanged(newChapters: Int) {
+		viewBadge.counter = newChapters
+	}
+
 	private fun showBranchPopupMenu(v: View) {
 		val menu = PopupMenu(v.context, v)
 		val branches = viewModel.branches.value
@@ -305,8 +311,8 @@ class DetailsActivity :
 					ForegroundColorSpan(
 						v.context.getThemeColor(
 							android.R.attr.textColorSecondary,
-							Color.LTGRAY,
+							Color.LTGRAY
-						),
+						)
 					),
 					RelativeSizeSpan(0.74f),
 				) {

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

@@ -11,8 +11,6 @@ import android.widget.Toast
 import androidx.appcompat.widget.PopupMenu
 import androidx.core.content.ContextCompat
 import androidx.core.graphics.Insets
-import androidx.core.text.buildSpannedString
-import androidx.core.text.color
 import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
@@ -23,7 +21,6 @@ import coil.request.SuccessResult
 import coil.util.CoilUtils
 import com.google.android.material.chip.Chip
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.filterNotNull
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
@@ -40,7 +37,6 @@ import org.koitharu.kotatsu.core.util.FileSize
 import org.koitharu.kotatsu.core.util.ext.crossfade
 import org.koitharu.kotatsu.core.util.ext.drawableTop
 import org.koitharu.kotatsu.core.util.ext.enqueueWith
-import org.koitharu.kotatsu.core.util.ext.getThemeColor
 import org.koitharu.kotatsu.core.util.ext.ifNullOrEmpty
 import org.koitharu.kotatsu.core.util.ext.isTextTruncated
 import org.koitharu.kotatsu.core.util.ext.observe
@@ -74,14 +70,13 @@ import org.koitharu.kotatsu.scrobbling.common.ui.selector.ScrobblingSelectorShee
 import org.koitharu.kotatsu.search.ui.MangaListActivity
 import org.koitharu.kotatsu.search.ui.SearchActivity
 import javax.inject.Inject
-import com.google.android.material.R as materialR
 
 @AndroidEntryPoint
 class DetailsFragment :
 	BaseFragment<FragmentDetailsBinding>(),
 	View.OnClickListener,
 	ChipsView.OnChipClickListener,
-	OnListItemClickListener<Bookmark>, ViewTreeObserver.OnDrawListener, View.OnLayoutChangeListener {
+	OnListItemClickListener<Bookmark>, ViewTreeObserver.OnDrawListener {
 
 	@Inject
 	lateinit var coil: ImageLoader
@@ -105,7 +100,6 @@ class DetailsFragment :
 		binding.buttonScrobblingMore.setOnClickListener(this)
 		binding.buttonRelatedMore.setOnClickListener(this)
 		binding.infoLayout.textViewSource.setOnClickListener(this)
-		binding.textViewDescription.addOnLayoutChangeListener(this)
 		binding.textViewDescription.viewTreeObserver.addOnDrawListener(this)
 		binding.textViewDescription.movementMethod = LinkMovementMethod.getInstance()
 		binding.chipsTags.onChipClickListener = this
@@ -119,9 +113,9 @@ class DetailsFragment :
 		viewModel.bookmarks.observe(viewLifecycleOwner, ::onBookmarksChanged)
 		viewModel.scrobblingInfo.observe(viewLifecycleOwner, ::onScrobblingInfoChanged)
 		viewModel.description.observe(viewLifecycleOwner, ::onDescriptionChanged)
+		viewModel.chapters.observe(viewLifecycleOwner, ::onChaptersChanged)
 		viewModel.localSize.observe(viewLifecycleOwner, ::onLocalSizeChanged)
 		viewModel.relatedManga.observe(viewLifecycleOwner, ::onRelatedMangaChanged)
-		combine(viewModel.chapters, viewModel.newChaptersCount, ::Pair).observe(viewLifecycleOwner, ::onChaptersChanged)
 	}
 
 	override fun onItemClick(item: Bookmark, view: View) {
@@ -151,22 +145,6 @@ class DetailsFragment :
 		}
 	}
 
-	override fun onLayoutChange(
-		v: View?,
-		left: Int,
-		top: Int,
-		right: Int,
-		bottom: Int,
-		oldLeft: Int,
-		oldTop: Int,
-		oldRight: Int,
-		oldBottom: Int
-	) {
-		with(viewBinding ?: return) {
-			buttonDescriptionMore.isVisible = textViewDescription.isTextTruncated
-		}
-	}
-
 	private fun onMangaUpdated(manga: Manga) {
 		with(requireViewBinding()) {
 			// Main
@@ -213,28 +191,14 @@ class DetailsFragment :
 		}
 	}
 
-	private fun onChaptersChanged(data: Pair<List<ChapterListItem>?, Int>) {
+	private fun onChaptersChanged(chapters: List<ChapterListItem>?) {
-		val (chapters, newChapters) = data
 		val infoLayout = requireViewBinding().infoLayout
 		if (chapters.isNullOrEmpty()) {
 			infoLayout.textViewChapters.isVisible = false
 		} else {
 			val count = chapters.countChaptersByBranch()
 			infoLayout.textViewChapters.isVisible = true
-			val chaptersText = resources.getQuantityString(R.plurals.chapters, count, count)
+			infoLayout.textViewChapters.text = resources.getQuantityString(R.plurals.chapters, count, count)
-			infoLayout.textViewChapters.text = if (newChapters == 0) {
-				chaptersText
-			} else {
-				buildSpannedString {
-					append(chaptersText)
-					append(' ')
-					color(infoLayout.textViewChapters.context.getThemeColor(materialR.attr.colorError)) {
-						append("(+")
-						append(newChapters.toString())
-						append(')')
-					}
-				}
-			}
 		}
 	}
 
@@ -245,6 +209,7 @@ class DetailsFragment :
 		} else {
 			tv.text = description
 		}
+		requireViewBinding().buttonDescriptionMore.isVisible = tv.isTextTruncated
 	}
 
 	private fun onLocalSizeChanged(size: Long) {

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

@@ -42,7 +42,6 @@ class DetailsMenuProvider(
 		menu.findItem(R.id.action_browser).isVisible = manga?.source != MangaSource.LOCAL
 		menu.findItem(R.id.action_shortcut).isVisible = ShortcutManagerCompat.isRequestPinShortcutSupported(activity)
 		menu.findItem(R.id.action_scrobbling).isVisible = viewModel.isScrobblingAvailable
-		menu.findItem(R.id.action_online).isVisible = viewModel.remoteManga.value != null
 		menu.findItem(R.id.action_favourite).setIcon(
 			if (viewModel.favouriteCategories.value) R.drawable.ic_heart else R.drawable.ic_heart_outline,
 		)
@@ -89,12 +88,6 @@ class DetailsMenuProvider(
 				}
 			}
 
-			R.id.action_online -> {
-				viewModel.remoteManga.value?.let {
-					activity.startActivity(DetailsActivity.newIntent(activity, it))
-				}
-			}
-
 			R.id.action_related -> {
 				viewModel.manga.value?.let {
 					activity.startActivity(MultiSearchActivity.newIntent(activity, it.title))

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

@@ -1,5 +1,12 @@
 package org.koitharu.kotatsu.details.ui
 
+import android.text.Html
+import android.text.SpannableString
+import android.text.Spanned
+import android.text.style.ForegroundColorSpan
+import androidx.core.net.toUri
+import androidx.core.text.getSpans
+import androidx.core.text.parseAsHtml
 import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
@@ -10,21 +17,22 @@ import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.distinctUntilChangedBy
 import kotlinx.coroutines.flow.filterNot
 import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.mapLatest
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.transformLatest
 import kotlinx.coroutines.flow.update
 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.getPreferredBranch
+import org.koitharu.kotatsu.core.os.NetworkState
 import org.koitharu.kotatsu.core.parser.MangaIntent
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.ListMode
@@ -32,15 +40,17 @@ import org.koitharu.kotatsu.core.prefs.observeAsStateFlow
 import org.koitharu.kotatsu.core.ui.BaseViewModel
 import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
 import org.koitharu.kotatsu.core.util.ext.call
+import org.koitharu.kotatsu.core.util.ext.combine
 import org.koitharu.kotatsu.core.util.ext.computeSize
-import org.koitharu.kotatsu.core.util.ext.onEachWhile
+import org.koitharu.kotatsu.core.util.ext.onFirst
 import org.koitharu.kotatsu.core.util.ext.requireValue
-import org.koitharu.kotatsu.details.data.MangaDetails
+import org.koitharu.kotatsu.core.util.ext.sanitize
+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.DetailsLoadUseCase
+import org.koitharu.kotatsu.details.domain.DoubleMangaLoadUseCase
-import org.koitharu.kotatsu.details.domain.ProgressUpdateUseCase
 import org.koitharu.kotatsu.details.domain.RelatedMangaUseCase
+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
@@ -64,19 +74,22 @@ class DetailsViewModel @Inject constructor(
 	private val bookmarksRepository: BookmarksRepository,
 	private val settings: AppSettings,
 	private val scrobblers: Set<@JvmSuppressWildcards Scrobbler>,
+	private val imageGetter: Html.ImageGetter,
 	@LocalStorageChanges private val localStorageChanges: SharedFlow<LocalManga?>,
 	private val downloadScheduler: DownloadWorker.Scheduler,
 	private val interactor: DetailsInteractor,
 	savedStateHandle: SavedStateHandle,
 	private val deleteLocalMangaUseCase: DeleteLocalMangaUseCase,
+	private val doubleMangaLoadUseCase: DoubleMangaLoadUseCase,
 	private val relatedMangaUseCase: RelatedMangaUseCase,
 	private val extraProvider: ListExtraProvider,
-	private val detailsLoadUseCase: DetailsLoadUseCase,
+	networkState: NetworkState,
-	private val progressUpdateUseCase: ProgressUpdateUseCase,
 ) : BaseViewModel() {
 
 	private val intent = MangaIntent(savedStateHandle)
 	private val mangaId = intent.mangaId
+	private val doubleManga: MutableStateFlow<DoubleManga?> =
+		MutableStateFlow(intent.manga?.let { DoubleManga(it) })
 	private var loadingJob: Job
 
 	val onShowToast = MutableEventFlow<Int>()
@@ -84,9 +97,8 @@ class DetailsViewModel @Inject constructor(
 	val onSelectChapter = MutableEventFlow<Long>()
 	val onDownloadStarted = MutableEventFlow<Unit>()
 
-	val details = MutableStateFlow(intent.manga?.let { MangaDetails(it, null, null, false) })
+	val manga = doubleManga.map { it?.any }
-	val manga = details.map { x -> x?.toManga() }
+		.stateIn(viewModelScope, SharingStarted.Eagerly, doubleManga.value?.any)
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, null)
 
 	val history = historyRepository.observeOne(mangaId)
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, null)
@@ -94,15 +106,8 @@ class DetailsViewModel @Inject constructor(
 	val favouriteCategories = interactor.observeIsFavourite(mangaId)
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, false)
 
-	val remoteManga = MutableStateFlow<Manga?>(null)
+	val newChaptersCount = interactor.observeNewChapters(mangaId)
-
+		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, 0)
-	val newChaptersCount = details.flatMapLatest { d ->
-		if (d?.isLocal == false) {
-			interactor.observeNewChapters(mangaId)
-		} else {
-			flowOf(0)
-		}
-	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, 0)
 
 	private val chaptersQuery = MutableStateFlow("")
 	val selectedBranch = MutableStateFlow<String?>(null)
@@ -130,17 +135,28 @@ class DetailsViewModel @Inject constructor(
 		if (it != null) bookmarksRepository.observeBookmarks(it) else flowOf(emptyList())
 	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Lazily, emptyList())
 
-	val localSize = details
+	val localSize = doubleManga
-		.map { it?.local }
+		.map {
-		.distinctUntilChanged()
+			val local = it?.local
-		.map { local ->
+			if (local != null) {
-			local?.file?.computeSize() ?: 0L
+				val file = local.url.toUri().toFileOrNull()
+				file?.computeSize() ?: 0L
+			} else {
+				0L
+			}
 		}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.WhileSubscribed(), 0)
 
-	@Deprecated("")
+	val description = manga
-	val description = details
+		.distinctUntilChangedBy { it?.description.orEmpty() }
-		.map { it?.description }
+		.transformLatest {
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Lazily, null)
+			val description = it?.description
+			if (description.isNullOrEmpty()) {
+				emit(null)
+			} else {
+				emit(description.parseAsHtml().filterSpans().sanitize())
+				emit(description.parseAsHtml(imageGetter = imageGetter).filterSpans())
+			}
+		}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.WhileSubscribed(5000), null)
 
 	val onMangaRemoved = MutableEventFlow<Manga>()
 	val isScrobblingAvailable: Boolean
@@ -149,7 +165,9 @@ class DetailsViewModel @Inject constructor(
 	val scrobblingInfo: StateFlow<List<ScrobblingInfo>> = interactor.observeScrobblingInfo(mangaId)
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, emptyList())
 
-	val relatedManga: StateFlow<List<MangaItemModel>> = manga
+	val relatedManga: StateFlow<List<MangaItemModel>> = doubleManga.map {
+		it?.remote
+	}.distinctUntilChangedBy { it?.id }
 		.mapLatest {
 			if (it != null && settings.isRelatedMangaEnabled) {
 				relatedMangaUseCase.invoke(it)?.toUi(ListMode.GRID, extraProvider).orEmpty()
@@ -160,32 +178,40 @@ class DetailsViewModel @Inject constructor(
 		.stateIn(viewModelScope, SharingStarted.Lazily, emptyList())
 
 	val branches: StateFlow<List<MangaBranch>> = combine(
-		details,
+		doubleManga,
 		selectedBranch,
 	) { m, b ->
-		(m?.chapters ?: return@combine emptyList())
+		val chapters = m?.chapters
+		if (chapters.isNullOrEmpty()) return@combine emptyList()
+		chapters.groupBy { x -> x.branch }
 			.map { x -> MangaBranch(x.key, x.value.size, x.key == b) }
 			.sortedWith(BranchComparator())
 	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, emptyList())
 
-	val isChaptersEmpty: StateFlow<Boolean> = details.map {
+	val isChaptersEmpty: StateFlow<Boolean> = combine(
-		it != null && it.isLoaded && it.allChapters.isEmpty()
+		doubleManga,
+		isLoading,
+	) { manga, loading ->
+		manga?.any != null && manga.chapters.isNullOrEmpty() && !loading
 	}.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), false)
 
 	val chapters = combine(
 		combine(
-			details,
+			doubleManga,
 			history,
 			selectedBranch,
 			newChaptersCount,
 			bookmarks,
-		) { manga, history, branch, news, bookmarks ->
+			networkState,
-			manga?.mapChapters(
+		) { manga, history, branch, news, bookmarks, isOnline ->
+			mapChapters(
+				manga?.remote?.takeIf { isOnline },
+				manga?.local,
 				history,
 				news,
 				branch,
 				bookmarks,
-			).orEmpty()
+			)
 		},
 		isChaptersReversed,
 		chaptersQuery,
@@ -208,17 +234,6 @@ class DetailsViewModel @Inject constructor(
 				onShowTip.call(Unit)
 			}
 		}
-		launchJob(Dispatchers.Default) {
-			val manga = details.firstOrNull { !it?.chapters.isNullOrEmpty() } ?: return@launchJob
-			val h = history.firstOrNull()
-			if (h != null) {
-				progressUpdateUseCase(manga.toManga())
-			}
-		}
-		launchJob(Dispatchers.Default) {
-			val manga = details.firstOrNull { it != null && it.isLocal } ?: return@launchJob
-			remoteManga.value = interactor.findLocal(manga.toManga())
-		}
 	}
 
 	fun reload() {
@@ -227,7 +242,7 @@ class DetailsViewModel @Inject constructor(
 	}
 
 	fun deleteLocal() {
-		val m = details.value?.local?.manga
+		val m = doubleManga.value?.local
 		if (m == null) {
 			onShowToast.call(R.string.file_not_found)
 			return
@@ -280,13 +295,13 @@ class DetailsViewModel @Inject constructor(
 
 	fun markChapterAsCurrent(chapterId: Long) {
 		launchJob(Dispatchers.Default) {
-			val manga = checkNotNull(details.value)
+			val manga = checkNotNull(doubleManga.value)
-			val chapters = checkNotNull(manga.chapters[selectedBranchValue])
+			val chapters = checkNotNull(manga.filterChapters(selectedBranchValue).chapters)
 			val chapterIndex = chapters.indexOfFirst { it.id == chapterId }
 			check(chapterIndex in chapters.indices) { "Chapter not found" }
 			val percent = chapterIndex / chapters.size.toFloat()
 			historyRepository.addOrUpdate(
-				manga = manga.toManga(),
+				manga = manga.requireAny(),
 				chapterId = chapterId,
 				page = 0,
 				scroll = 0,
@@ -298,7 +313,7 @@ class DetailsViewModel @Inject constructor(
 	fun download(chaptersIds: Set<Long>?) {
 		launchJob(Dispatchers.Default) {
 			downloadScheduler.schedule(
-				details.requireValue().toManga(),
+				doubleManga.requireValue().requireAny(),
 				chaptersIds,
 			)
 			onDownloadStarted.call(Unit)
@@ -318,18 +333,14 @@ class DetailsViewModel @Inject constructor(
 	}
 
 	private fun doLoad() = launchLoadingJob(Dispatchers.Default) {
-		detailsLoadUseCase.invoke(intent)
+		doubleMangaLoadUseCase.invoke(intent)
-			.onEachWhile {
+			.onFirst {
-				if (it.allChapters.isEmpty()) {
+				val manga = it.requireAny()
-					return@onEachWhile false
-				}
-				val manga = it.toManga()
 				// find default branch
 				val hist = historyRepository.getOne(manga)
 				selectedBranch.value = manga.getPreferredBranch(hist)
-				true
 			}.collect {
-				details.value = it
+				doubleManga.value = it
 			}
 	}
 
@@ -345,12 +356,21 @@ class DetailsViewModel @Inject constructor(
 	private suspend fun onDownloadComplete(downloadedManga: LocalManga?) {
 		downloadedManga ?: return
 		launchJob {
-			details.update {
+			doubleManga.update {
 				interactor.updateLocal(it, downloadedManga)
 			}
 		}
 	}
 
+	private fun Spanned.filterSpans(): CharSequence {
+		val spannable = SpannableString.valueOf(this)
+		val spans = spannable.getSpans<ForegroundColorSpan>()
+		for (span in spans) {
+			spannable.removeSpan(span)
+		}
+		return spannable.trim()
+	}
+
 	private fun getScrobbler(index: Int): Scrobbler? {
 		val info = scrobblingInfo.value.getOrNull(index)
 		val scrobbler = if (info != null) {

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

@@ -6,7 +6,6 @@ import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.list.AdapterDelegateClickListenerAdapter
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
-import org.koitharu.kotatsu.core.util.ext.drawableEnd
 import org.koitharu.kotatsu.core.util.ext.drawableStart
 import org.koitharu.kotatsu.core.util.ext.getThemeColor
 import org.koitharu.kotatsu.core.util.ext.textAndVisible
@@ -48,6 +47,7 @@ fun chapterListItemAD(
 		}
 		binding.imageViewBookmarked.isVisible = item.isBookmarked
 		binding.imageViewDownloaded.isVisible = item.isDownloaded
+		// binding.imageViewNew.isVisible = item.isNew
 		binding.textViewTitle.drawableStart = if (item.isNew) {
 			ContextCompat.getDrawable(context, R.drawable.ic_new)
 		} else {

app/src/main/kotlin/org/koitharu/kotatsu/download/domain/DownloadState.kt

@@ -19,7 +19,6 @@ data class DownloadState(
 	val eta: Long = -1L,
 	val localManga: LocalManga? = null,
 	val downloadedChapters: LongArray = LongArray(0),
-	val scheduledChapters: LongArray = LongArray(0),
 	val timestamp: Long = System.currentTimeMillis(),
 ) {
 
@@ -43,7 +42,6 @@ data class DownloadState(
 		.putLong(DATA_TIMESTAMP, timestamp)
 		.putString(DATA_ERROR, error)
 		.putLongArray(DATA_CHAPTERS, downloadedChapters)
-		.putLongArray(DATA_CHAPTERS_SRC, scheduledChapters)
 		.putBoolean(DATA_INDETERMINATE, isIndeterminate)
 		.putBoolean(DATA_PAUSED, isPaused)
 		.build()
@@ -66,13 +64,10 @@ data class DownloadState(
 		if (eta != other.eta) return false
 		if (localManga != other.localManga) return false
 		if (!downloadedChapters.contentEquals(other.downloadedChapters)) return false
-		if (!scheduledChapters.contentEquals(other.scheduledChapters)) return false
 		if (timestamp != other.timestamp) return false
 		if (max != other.max) return false
 		if (progress != other.progress) return false
-		if (percent != other.percent) return false
+		return percent == other.percent
-
-		return true
 	}
 
 	override fun hashCode(): Int {
@@ -88,7 +83,6 @@ data class DownloadState(
 		result = 31 * result + eta.hashCode()
 		result = 31 * result + (localManga?.hashCode() ?: 0)
 		result = 31 * result + downloadedChapters.contentHashCode()
-		result = 31 * result + scheduledChapters.contentHashCode()
 		result = 31 * result + timestamp.hashCode()
 		result = 31 * result + max
 		result = 31 * result + progress
@@ -96,14 +90,12 @@ data class DownloadState(
 		return result
 	}
 
-
 	companion object {
 
 		private const val DATA_MANGA_ID = "manga_id"
 		private const val DATA_MAX = "max"
 		private const val DATA_PROGRESS = "progress"
 		private const val DATA_CHAPTERS = "chapter"
-		private const val DATA_CHAPTERS_SRC = "chapters_src"
 		private const val DATA_ETA = "eta"
 		private const val DATA_TIMESTAMP = "timestamp"
 		private const val DATA_ERROR = "error"
@@ -127,7 +119,5 @@ data class DownloadState(
 		fun getTimestamp(data: Data): Date = Date(data.getLong(DATA_TIMESTAMP, 0L))
 
 		fun getDownloadedChapters(data: Data): LongArray = data.getLongArray(DATA_CHAPTERS) ?: LongArray(0)
-
-		fun getScheduledChapters(data: Data): LongArray = data.getLongArray(DATA_CHAPTERS_SRC) ?: LongArray(0)
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/download/ui/list/DownloadItemAD.kt

@@ -1,29 +1,18 @@
 package org.koitharu.kotatsu.download.ui.list
 
-import android.transition.TransitionManager
 import android.view.View
-import androidx.core.content.ContextCompat
 import androidx.core.view.isVisible
 import androidx.lifecycle.LifecycleOwner
-import androidx.recyclerview.widget.DividerItemDecoration
-import androidx.recyclerview.widget.RecyclerView
 import androidx.work.WorkInfo
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.ui.BaseListAdapter
 import org.koitharu.kotatsu.core.ui.image.TrimTransformation
-import org.koitharu.kotatsu.core.util.ext.drawableEnd
 import org.koitharu.kotatsu.core.util.ext.enqueueWith
-import org.koitharu.kotatsu.core.util.ext.isAnimationsEnabled
 import org.koitharu.kotatsu.core.util.ext.newImageRequest
 import org.koitharu.kotatsu.core.util.ext.source
 import org.koitharu.kotatsu.core.util.ext.textAndVisible
 import org.koitharu.kotatsu.databinding.ItemDownloadBinding
-import org.koitharu.kotatsu.download.ui.list.chapters.DownloadChapter
-import org.koitharu.kotatsu.download.ui.list.chapters.downloadChapterAD
-import org.koitharu.kotatsu.list.ui.ListModelDiffCallback
-import org.koitharu.kotatsu.list.ui.adapter.ListItemType
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.parsers.util.format
 
@@ -36,9 +25,6 @@ fun downloadItemAD(
 ) {
 
 	val percentPattern = context.resources.getString(R.string.percent_string_pattern)
-	val expandIcon = ContextCompat.getDrawable(context, R.drawable.ic_expand_collapse)
-	val chaptersAdapter = BaseListAdapter<DownloadChapter>()
-		.addDelegate(ListItemType.CHAPTER, downloadChapterAD())
 
 	val clickListener = object : View.OnClickListener, View.OnLongClickListener {
 		override fun onClick(v: View) {
@@ -59,13 +45,8 @@ fun downloadItemAD(
 	binding.buttonResume.setOnClickListener(clickListener)
 	itemView.setOnClickListener(clickListener)
 	itemView.setOnLongClickListener(clickListener)
-	binding.recyclerViewChapters.addItemDecoration(DividerItemDecoration(context, RecyclerView.VERTICAL))
-	binding.recyclerViewChapters.adapter = chaptersAdapter
 
 	bind { payloads ->
-		if (ListModelDiffCallback.PAYLOAD_CHECKED_CHANGED in payloads && context.isAnimationsEnabled) {
-			TransitionManager.beginDelayedTransition(binding.constraintLayout)
-		}
 		binding.textViewTitle.text = item.manga.title
 		binding.imageViewCover.newImageRequest(lifecycleOwner, item.manga.coverUrl)?.apply {
 			placeholder(R.drawable.ic_placeholder)
@@ -76,10 +57,6 @@ fun downloadItemAD(
 			source(item.manga.source)
 			enqueueWith(coil)
 		}
-		binding.textViewTitle.isChecked = item.isExpanded
-		binding.textViewTitle.drawableEnd = if (item.isExpandable) expandIcon else null
-		binding.cardDetails.isVisible = item.isExpanded
-		chaptersAdapter.items = item.chapters
 		when (item.workState) {
 			WorkInfo.State.ENQUEUED,
 			WorkInfo.State.BLOCKED -> {

app/src/main/kotlin/org/koitharu/kotatsu/download/ui/list/DownloadItemModel.kt

@@ -2,8 +2,6 @@ package org.koitharu.kotatsu.download.ui.list
 
 import android.text.format.DateUtils
 import androidx.work.WorkInfo
-import org.koitharu.kotatsu.download.ui.list.chapters.DownloadChapter
-import org.koitharu.kotatsu.list.ui.ListModelDiffCallback
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.parsers.model.Manga
 import java.util.Date
@@ -21,8 +19,6 @@ data class DownloadItemModel(
 	val progress: Int,
 	val eta: Long,
 	val timestamp: Date,
-	val chapters: List<DownloadChapter>,
-	val isExpanded: Boolean,
 ) : ListModel, Comparable<DownloadItemModel> {
 
 	val percent: Float
@@ -37,9 +33,6 @@ data class DownloadItemModel(
 	val canResume: Boolean
 		get() = workState == WorkInfo.State.RUNNING && isPaused
 
-	val isExpandable: Boolean
-		get() = chapters.isNotEmpty()
-
 	fun getEtaString(): CharSequence? = if (hasEta) {
 		DateUtils.getRelativeTimeSpanString(
 			eta,
@@ -58,10 +51,17 @@ data class DownloadItemModel(
 		return other is DownloadItemModel && other.id == id
 	}
 
-	override fun getChangePayload(previousState: ListModel): Any? = when {
+	override fun getChangePayload(previousState: ListModel): Any? {
-		previousState !is DownloadItemModel -> super.getChangePayload(previousState)
+		return when (previousState) {
-		workState != previousState.workState -> null
+			is DownloadItemModel -> {
-		isExpanded != previousState.isExpanded -> ListModelDiffCallback.PAYLOAD_CHECKED_CHANGED
+				if (workState == previousState.workState) {
-		else -> ListModelDiffCallback.PAYLOAD_ANYTHING_CHANGED
+					Unit
+				} else {
+					null
+				}
+			}
+
+			else -> super.getChangePayload(previousState)
+		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/download/ui/list/DownloadsActivity.kt

@@ -82,11 +82,7 @@ class DownloadsActivity : BaseActivity<ActivityDownloadsBinding>(),
 		if (selectionController.onItemClick(item.id.mostSignificantBits)) {
 			return
 		}
-		if (item.isExpandable) {
+		startActivity(DetailsActivity.newIntent(view.context, item.manga))
-			viewModel.expandCollapse(item)
-		} else {
-			startActivity(DetailsActivity.newIntent(view.context, item.manga))
-		}
 	}
 
 	override fun onItemLongClick(item: DownloadItemModel, view: View): Boolean {

app/src/main/kotlin/org/koitharu/kotatsu/download/ui/list/DownloadsViewModel.kt

@@ -8,19 +8,15 @@ import androidx.work.Data
 import androidx.work.WorkInfo
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapLatest
 import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.plus
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.parser.MangaDataRepository
-import org.koitharu.kotatsu.core.parser.MangaRepository
-import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.core.ui.BaseViewModel
 import org.koitharu.kotatsu.core.ui.model.DateTimeAgo
 import org.koitharu.kotatsu.core.ui.util.ReversibleAction
@@ -28,7 +24,6 @@ import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
 import org.koitharu.kotatsu.core.util.ext.call
 import org.koitharu.kotatsu.core.util.ext.daysDiff
 import org.koitharu.kotatsu.download.domain.DownloadState
-import org.koitharu.kotatsu.download.ui.list.chapters.DownloadChapter
 import org.koitharu.kotatsu.download.ui.worker.DownloadWorker
 import org.koitharu.kotatsu.list.ui.model.EmptyState
 import org.koitharu.kotatsu.list.ui.model.ListHeader
@@ -36,7 +31,6 @@ import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.LoadingState
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.util.mapToSet
-import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import java.util.Date
 import java.util.LinkedList
 import java.util.UUID
@@ -47,18 +41,13 @@ import javax.inject.Inject
 class DownloadsViewModel @Inject constructor(
 	private val workScheduler: DownloadWorker.Scheduler,
 	private val mangaDataRepository: MangaDataRepository,
-	private val mangaRepositoryFactory: MangaRepository.Factory,
 ) : BaseViewModel() {
 
 	private val mangaCache = LongSparseArray<Manga>()
 	private val cacheMutex = Mutex()
-	private val expanded = MutableStateFlow(emptySet<UUID>())
+	private val works = workScheduler.observeWorks()
-	private val works = combine(
+		.mapLatest { it.toDownloadsList() }
-		workScheduler.observeWorks(),
+		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, null)
-		expanded,
-	) { list, exp ->
-		list.toDownloadsList(exp)
-	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, null)
 
 	val onActionDone = MutableEventFlow<ReversibleAction>()
 
@@ -180,21 +169,11 @@ class DownloadsViewModel @Inject constructor(
 		it.id.mostSignificantBits
 	} ?: emptySet()
 
-	fun expandCollapse(item: DownloadItemModel) {
+	private suspend fun List<WorkInfo>.toDownloadsList(): List<DownloadItemModel> {
-		expanded.update {
-			if (item.id in it) {
-				it - item.id
-			} else {
-				it + item.id
-			}
-		}
-	}
-
-	private suspend fun List<WorkInfo>.toDownloadsList(exp: Set<UUID>): List<DownloadItemModel> {
 		if (isEmpty()) {
 			return emptyList()
 		}
-		val list = mapNotNullTo(ArrayList(size)) { it.toUiModel(it.id in exp) }
+		val list = mapNotNullTo(ArrayList(size)) { it.toUiModel() }
 		list.sortByDescending { it.timestamp }
 		return list
 	}
@@ -234,13 +213,11 @@ class DownloadsViewModel @Inject constructor(
 		return destination
 	}
 
-	private suspend fun WorkInfo.toUiModel(isExpanded: Boolean): DownloadItemModel? {
+	private suspend fun WorkInfo.toUiModel(): DownloadItemModel? {
 		val workData = if (outputData == Data.EMPTY) progress else outputData
 		val mangaId = DownloadState.getMangaId(workData)
 		if (mangaId == 0L) return null
 		val manga = getManga(mangaId) ?: return null
-		val downloadedChapters = DownloadState.getDownloadedChapters(workData)
-		val scheduledChapters = DownloadState.getScheduledChapters(workData).toSet()
 		return DownloadItemModel(
 			id = id,
 			workState = state,
@@ -252,19 +229,7 @@ class DownloadsViewModel @Inject constructor(
 			progress = DownloadState.getProgress(workData),
 			eta = DownloadState.getEta(workData),
 			timestamp = DownloadState.getTimestamp(workData),
-			totalChapters = downloadedChapters.size,
+			totalChapters = DownloadState.getDownloadedChapters(workData).size,
-			isExpanded = isExpanded,
-			chapters = manga.chapters?.mapNotNull {
-				if (it.id in scheduledChapters) {
-					DownloadChapter(
-						number = it.number,
-						name = it.name,
-						isDownloaded = it.id in downloadedChapters,
-					)
-				} else {
-					null
-				}
-			}.orEmpty(),
 		)
 	}
 
@@ -296,16 +261,8 @@ class DownloadsViewModel @Inject constructor(
 		}
 		return cacheMutex.withLock {
 			mangaCache.getOrElse(mangaId) {
-				mangaDataRepository.findMangaById(mangaId)?.let {
+				mangaDataRepository.findMangaById(mangaId)?.also { mangaCache[mangaId] = it } ?: return null
-					tryLoad(it) ?: it
-				}?.also {
-					mangaCache[mangaId] = it
-				} ?: return null
 			}
 		}
 	}
-
-	private suspend fun tryLoad(manga: Manga) = runCatchingCancellable {
-		(mangaRepositoryFactory.create(manga.source) as RemoteMangaRepository).peekDetails(manga)
-	}.getOrNull()
 }

app/src/main/kotlin/org/koitharu/kotatsu/download/ui/list/chapters/DownloadChapter.kt

@@ -1,14 +0,0 @@
-package org.koitharu.kotatsu.download.ui.list.chapters
-
-import org.koitharu.kotatsu.list.ui.model.ListModel
-
-data class DownloadChapter(
-	val number: Int,
-	val name: String,
-	val isDownloaded: Boolean,
-) : ListModel {
-
-	override fun areItemsTheSame(other: ListModel): Boolean {
-		return other is DownloadChapter && other.name == name
-	}
-}

app/src/main/kotlin/org/koitharu/kotatsu/download/ui/list/chapters/DownloadChapterAD.kt

@@ -1,20 +0,0 @@
-package org.koitharu.kotatsu.download.ui.list.chapters
-
-import androidx.core.content.ContextCompat
-import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.util.ext.drawableEnd
-import org.koitharu.kotatsu.databinding.ItemChapterDownloadBinding
-
-fun downloadChapterAD() = adapterDelegateViewBinding<DownloadChapter, DownloadChapter, ItemChapterDownloadBinding>(
-	{ layoutInflater, parent -> ItemChapterDownloadBinding.inflate(layoutInflater, parent, false) },
-) {
-
-	val iconDone = ContextCompat.getDrawable(context, R.drawable.ic_check)
-
-	bind {
-		binding.textViewNumber.text = item.number.toString()
-		binding.textViewTitle.text = item.name
-		binding.textViewTitle.drawableEnd = if (item.isDownloaded) iconDone else null
-	}
-}

app/src/main/kotlin/org/koitharu/kotatsu/download/ui/worker/DownloadWorker.kt

@@ -178,9 +178,6 @@ class DownloadWorker @AssistedInject constructor(
 					}
 				}
 				val chapters = getChapters(mangaDetails, includedIds)
-				publishState(
-					currentState.copy(scheduledChapters = LongArray(chapters.size) { i -> chapters[i].id }),
-				)
 				for ((chapterIndex, chapter) in chapters.withIndex()) {
 					if (chaptersToSkip.remove(chapter.id)) {
 						publishState(

app/src/main/kotlin/org/koitharu/kotatsu/explore/data/MangaSourcesRepository.kt

@@ -6,7 +6,6 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.db.MangaDatabase
@@ -93,25 +92,19 @@ class MangaSourcesRepository @Inject constructor(
 		}
 	}
 
-	fun observeNewSources(): Flow<Set<MangaSource>> = observeIsNewSourcesEnabled().flatMapLatest {
+	fun observeNewSources(): Flow<Set<MangaSource>> = combine(
-		if (it) {
+		dao.observeAll(),
-			combine(
+		observeIsNsfwDisabled(),
-				dao.observeAll(),
+	) { entities, skipNsfw ->
-				observeIsNsfwDisabled(),
+		val result = EnumSet.copyOf(remoteSources)
-			) { entities, skipNsfw ->
+		for (e in entities) {
-				val result = EnumSet.copyOf(remoteSources)
+			result.remove(MangaSource(e.source))
-				for (e in entities) {
-					result.remove(MangaSource(e.source))
-				}
-				if (skipNsfw) {
-					result.removeAll { x -> x.isNsfw() }
-				}
-				result
-			}.distinctUntilChanged()
-		} else {
-			flowOf(emptySet())
 		}
-	}
+		if (skipNsfw) {
+			result.removeAll { x -> x.isNsfw() }
+		}
+		result
+	}.distinctUntilChanged()
 
 	suspend fun assimilateNewSources(): Set<MangaSource> {
 		val new = getNewSources()
@@ -163,8 +156,4 @@ class MangaSourcesRepository @Inject constructor(
 	private fun observeIsNsfwDisabled() = settings.observeAsFlow(AppSettings.KEY_DISABLE_NSFW) {
 		isNsfwContentDisabled
 	}
-
-	private fun observeIsNewSourcesEnabled() = settings.observeAsFlow(AppSettings.KEY_SOURCES_NEW) {
-		isNewSourcesTipEnabled
-	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/favourites/data/EntityMapping.kt

@@ -1,16 +1,17 @@
 package org.koitharu.kotatsu.favourites.data
 
+import org.koitharu.kotatsu.core.db.entity.SortOrder
 import org.koitharu.kotatsu.core.db.entity.toManga
 import org.koitharu.kotatsu.core.db.entity.toMangaTags
 import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.list.domain.ListSortOrder
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import java.util.Date
 
 fun FavouriteCategoryEntity.toFavouriteCategory(id: Long = categoryId.toLong()) = FavouriteCategory(
 	id = id,
 	title = title,
 	sortKey = sortKey,
-	order = ListSortOrder(order, ListSortOrder.NEWEST),
+	order = SortOrder(order, SortOrder.NEWEST),
 	createdAt = Date(createdAt),
 	isTrackingEnabled = track,
 	isVisibleInLibrary = isVisibleInLibrary,

app/src/main/kotlin/org/koitharu/kotatsu/favourites/data/FavouritesDao.kt

@@ -1,19 +1,13 @@
 package org.koitharu.kotatsu.favourites.data
 
-import androidx.room.Dao
+import androidx.room.*
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import androidx.room.RawQuery
-import androidx.room.Transaction
-import androidx.room.Upsert
 import androidx.sqlite.db.SimpleSQLiteQuery
 import androidx.sqlite.db.SupportSQLiteQuery
 import kotlinx.coroutines.flow.Flow
 import org.intellij.lang.annotations.Language
 import org.koitharu.kotatsu.core.db.entity.MangaEntity
 import org.koitharu.kotatsu.favourites.domain.model.Cover
-import org.koitharu.kotatsu.list.domain.ListSortOrder
+import org.koitharu.kotatsu.parsers.model.SortOrder
 
 @Dao
 abstract class FavouritesDao {
@@ -28,7 +22,7 @@ abstract class FavouritesDao {
 	@Query("SELECT * FROM favourites WHERE deleted_at = 0 GROUP BY manga_id ORDER BY created_at DESC LIMIT :limit")
 	abstract suspend fun findLast(limit: Int): List<FavouriteManga>
 
-	fun observeAll(order: ListSortOrder): Flow<List<FavouriteManga>> {
+	fun observeAll(order: SortOrder): Flow<List<FavouriteManga>> {
 		val orderBy = getOrderBy(order)
 
 		@Language("RoomSql")
@@ -53,7 +47,7 @@ abstract class FavouritesDao {
 	)
 	abstract suspend fun findAll(categoryId: Long): List<FavouriteManga>
 
-	fun observeAll(categoryId: Long, order: ListSortOrder): Flow<List<FavouriteManga>> {
+	fun observeAll(categoryId: Long, order: SortOrder): Flow<List<FavouriteManga>> {
 		val orderBy = getOrderBy(order)
 
 		@Language("RoomSql")
@@ -78,14 +72,13 @@ abstract class FavouritesDao {
 	)
 	abstract suspend fun findAllManga(categoryId: Int): List<MangaEntity>
 
-	suspend fun findCovers(categoryId: Long, order: ListSortOrder): List<Cover> {
+	suspend fun findCovers(categoryId: Long, order: SortOrder): List<Cover> {
 		val orderBy = getOrderBy(order)
 
 		@Language("RoomSql")
 		val query = SimpleSQLiteQuery(
-			"SELECT manga.cover_url AS url, manga.source AS source FROM favourites " +
+			"SELECT m.cover_url AS url, m.source AS source FROM favourites AS f LEFT JOIN manga AS m ON f.manga_id = m.manga_id " +
-				"LEFT JOIN manga ON favourites.manga_id = manga.manga_id " +
+				"WHERE f.category_id = ? AND deleted_at = 0 ORDER BY $orderBy",
-				"WHERE favourites.category_id = ? AND deleted_at = 0 ORDER BY $orderBy",
 			arrayOf<Any>(categoryId),
 		)
 		return findCoversImpl(query)
@@ -164,12 +157,13 @@ abstract class FavouritesDao {
 	@Query("UPDATE favourites SET deleted_at = :deletedAt WHERE category_id = :categoryId AND deleted_at = 0")
 	protected abstract suspend fun setDeletedAtAll(categoryId: Long, deletedAt: Long)
 
-	private fun getOrderBy(sortOrder: ListSortOrder) = when (sortOrder) {
+	private fun getOrderBy(sortOrder: SortOrder) = when (sortOrder) {
-		ListSortOrder.RATING -> "manga.rating DESC"
+		SortOrder.RATING -> "rating DESC"
-		ListSortOrder.NEWEST -> "favourites.created_at DESC"
+		SortOrder.NEWEST,
-		ListSortOrder.ALPHABETIC -> "manga.title ASC"
+		SortOrder.UPDATED,
-		ListSortOrder.NEW_CHAPTERS -> "(SELECT chapters_new FROM tracks WHERE tracks.manga_id = manga.manga_id) DESC"
+		-> "created_at DESC"
-		ListSortOrder.PROGRESS -> "(SELECT percent FROM history WHERE history.manga_id = manga.manga_id) DESC"
+
+		SortOrder.ALPHABETICAL -> "title ASC"
 		else -> throw IllegalArgumentException("Sort order $sortOrder is not supported")
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/favourites/domain/FavouritesRepository.kt

@@ -8,6 +8,7 @@ import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.db.entity.SortOrder
 import org.koitharu.kotatsu.core.db.entity.toEntities
 import org.koitharu.kotatsu.core.db.entity.toEntity
 import org.koitharu.kotatsu.core.model.FavouriteCategory
@@ -19,8 +20,8 @@ import org.koitharu.kotatsu.favourites.data.toFavouriteCategory
 import org.koitharu.kotatsu.favourites.data.toManga
 import org.koitharu.kotatsu.favourites.data.toMangaList
 import org.koitharu.kotatsu.favourites.domain.model.Cover
-import org.koitharu.kotatsu.list.domain.ListSortOrder
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.tracker.work.TrackerNotificationChannels
 import javax.inject.Inject
 
@@ -40,7 +41,7 @@ class FavouritesRepository @Inject constructor(
 		return entities.toMangaList()
 	}
 
-	fun observeAll(order: ListSortOrder): Flow<List<Manga>> {
+	fun observeAll(order: SortOrder): Flow<List<Manga>> {
 		return db.favouritesDao.observeAll(order)
 			.mapItems { it.toManga() }
 	}
@@ -50,7 +51,7 @@ class FavouritesRepository @Inject constructor(
 		return entities.toMangaList()
 	}
 
-	fun observeAll(categoryId: Long, order: ListSortOrder): Flow<List<Manga>> {
+	fun observeAll(categoryId: Long, order: SortOrder): Flow<List<Manga>> {
 		return db.favouritesDao.observeAll(categoryId, order)
 			.mapItems { it.toManga() }
 	}
@@ -104,7 +105,7 @@ class FavouritesRepository @Inject constructor(
 
 	suspend fun createCategory(
 		title: String,
-		sortOrder: ListSortOrder,
+		sortOrder: SortOrder,
 		isTrackerEnabled: Boolean,
 		isVisibleOnShelf: Boolean,
 	): FavouriteCategory {
@@ -127,7 +128,7 @@ class FavouritesRepository @Inject constructor(
 	suspend fun updateCategory(
 		id: Long,
 		title: String,
-		sortOrder: ListSortOrder,
+		sortOrder: SortOrder,
 		isTrackerEnabled: Boolean,
 		isVisibleOnShelf: Boolean,
 	) {
@@ -155,7 +156,7 @@ class FavouritesRepository @Inject constructor(
 		}
 	}
 
-	suspend fun setCategoryOrder(id: Long, order: ListSortOrder) {
+	suspend fun setCategoryOrder(id: Long, order: SortOrder) {
 		db.favouriteCategoriesDao.updateOrder(id, order.name)
 	}
 
@@ -204,10 +205,10 @@ class FavouritesRepository @Inject constructor(
 		return ReversibleHandle { recoverToCategory(categoryId, ids) }
 	}
 
-	private fun observeOrder(categoryId: Long): Flow<ListSortOrder> {
+	private fun observeOrder(categoryId: Long): Flow<SortOrder> {
 		return db.favouriteCategoriesDao.observe(categoryId)
 			.filterNotNull()
-			.map { x -> ListSortOrder(x.order, ListSortOrder.NEWEST) }
+			.map { x -> SortOrder(x.order, SortOrder.NEWEST) }
 			.distinctUntilChanged()
 	}
 

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/categories/FavouriteCategoriesActivity.kt

@@ -27,6 +27,7 @@ import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEdit
 import org.koitharu.kotatsu.list.ui.adapter.ListStateHolderListener
 import org.koitharu.kotatsu.list.ui.adapter.TypedListSpacingDecoration
 import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import javax.inject.Inject
 
 @AndroidEntryPoint
@@ -175,6 +176,12 @@ class FavouriteCategoriesActivity :
 
 	companion object {
 
+		val SORT_ORDERS = arrayOf(
+			SortOrder.ALPHABETICAL,
+			SortOrder.NEWEST,
+			SortOrder.RATING,
+		)
+
 		fun newIntent(context: Context) = Intent(context, FavouriteCategoriesActivity::class.java)
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/categories/edit/FavouritesCategoryEditActivity.kt

@@ -18,15 +18,16 @@ import dagger.hilt.android.AndroidEntryPoint
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.model.FavouriteCategory
 import org.koitharu.kotatsu.core.ui.BaseActivity
+import org.koitharu.kotatsu.core.ui.model.titleRes
 import org.koitharu.kotatsu.core.ui.util.DefaultTextWatcher
 import org.koitharu.kotatsu.core.util.ext.getDisplayMessage
 import org.koitharu.kotatsu.core.util.ext.getSerializableCompat
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
 import org.koitharu.kotatsu.core.util.ext.setChecked
-import org.koitharu.kotatsu.core.util.ext.sortedByOrdinal
 import org.koitharu.kotatsu.databinding.ActivityCategoryEditBinding
-import org.koitharu.kotatsu.list.domain.ListSortOrder
+import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesActivity
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import com.google.android.material.R as materialR
 
 @AndroidEntryPoint
@@ -37,8 +38,7 @@ class FavouritesCategoryEditActivity :
 	DefaultTextWatcher {
 
 	private val viewModel by viewModels<FavouritesCategoryEditViewModel>()
-	private var selectedSortOrder: ListSortOrder? = null
+	private var selectedSortOrder: SortOrder? = null
-	private val sortOrders = ListSortOrder.FAVORITES.sortedByOrdinal()
 
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
@@ -68,7 +68,7 @@ class FavouritesCategoryEditActivity :
 
 	override fun onRestoreInstanceState(savedInstanceState: Bundle) {
 		super.onRestoreInstanceState(savedInstanceState)
-		val order = savedInstanceState.getSerializableCompat<ListSortOrder>(KEY_SORT_ORDER)
+		val order = savedInstanceState.getSerializableCompat<SortOrder>(KEY_SORT_ORDER)
 		if (order != null) {
 			selectedSortOrder = order
 		}
@@ -103,7 +103,7 @@ class FavouritesCategoryEditActivity :
 	}
 
 	override fun onItemClick(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
-		selectedSortOrder = sortOrders.getOrNull(position)
+		selectedSortOrder = FavouriteCategoriesActivity.SORT_ORDERS.getOrNull(position)
 	}
 
 	private fun onCategoryChanged(category: FavouriteCategory?) {
@@ -113,7 +113,7 @@ class FavouritesCategoryEditActivity :
 		}
 		viewBinding.editName.setText(category?.title)
 		selectedSortOrder = category?.order
-		val sortText = getString((category?.order ?: ListSortOrder.NEWEST).titleResId)
+		val sortText = getString((category?.order ?: SortOrder.NEWEST).titleRes)
 		viewBinding.editSort.setText(sortText, false)
 		viewBinding.switchTracker.setChecked(category?.isTrackingEnabled ?: true, false)
 		viewBinding.switchShelf.setChecked(category?.isVisibleInLibrary ?: true, false)
@@ -135,17 +135,17 @@ class FavouritesCategoryEditActivity :
 	}
 
 	private fun initSortSpinner() {
-		val entries = sortOrders.map { getString(it.titleResId) }
+		val entries = FavouriteCategoriesActivity.SORT_ORDERS.map { getString(it.titleRes) }
 		val adapter = SortAdapter(this, entries)
 		viewBinding.editSort.setAdapter(adapter)
 		viewBinding.editSort.onItemClickListener = this
 	}
 
-	private fun getSelectedSortOrder(): ListSortOrder {
+	private fun getSelectedSortOrder(): SortOrder {
 		selectedSortOrder?.let { return it }
-		val entries = sortOrders.map { getString(it.titleResId) }
+		val entries = FavouriteCategoriesActivity.SORT_ORDERS.map { getString(it.titleRes) }
 		val index = entries.indexOf(viewBinding.editSort.text.toString())
-		return sortOrders.getOrNull(index) ?: ListSortOrder.NEWEST
+		return FavouriteCategoriesActivity.SORT_ORDERS.getOrNull(index) ?: SortOrder.NEWEST
 	}
 
 	private class SortAdapter(

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/categories/edit/FavouritesCategoryEditViewModel.kt

@@ -17,7 +17,7 @@ import org.koitharu.kotatsu.core.util.ext.call
 import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
 import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity.Companion.EXTRA_ID
 import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity.Companion.NO_ID
-import org.koitharu.kotatsu.list.domain.ListSortOrder
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import javax.inject.Inject
 
 @HiltViewModel
@@ -48,7 +48,7 @@ class FavouritesCategoryEditViewModel @Inject constructor(
 
 	fun save(
 		title: String,
-		sortOrder: ListSortOrder,
+		sortOrder: SortOrder,
 		isTrackerEnabled: Boolean,
 		isVisibleOnShelf: Boolean,
 	) {

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/list/FavouritesListFragment.kt

@@ -10,11 +10,13 @@ import androidx.fragment.app.viewModels
 import dagger.hilt.android.AndroidEntryPoint
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.list.ListSelectionController
+import org.koitharu.kotatsu.core.ui.model.titleRes
+import org.koitharu.kotatsu.core.ui.util.MenuInvalidator
 import org.koitharu.kotatsu.core.util.ext.addMenuProvider
-import org.koitharu.kotatsu.core.util.ext.sortedByOrdinal
+import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.withArgs
 import org.koitharu.kotatsu.databinding.FragmentListBinding
-import org.koitharu.kotatsu.list.domain.ListSortOrder
+import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesActivity
 import org.koitharu.kotatsu.list.ui.MangaListFragment
 import org.koitharu.kotatsu.parsers.model.MangaSource
 
@@ -25,14 +27,12 @@ class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickLis
 
 	override val isSwipeRefreshEnabled = false
 
-	val categoryId
-		get() = viewModel.categoryId
-
 	override fun onViewBindingCreated(binding: FragmentListBinding, savedInstanceState: Bundle?) {
 		super.onViewBindingCreated(binding, savedInstanceState)
 		if (viewModel.categoryId != NO_ID) {
 			addMenuProvider(FavouritesListMenuProvider(binding.root.context, viewModel))
 		}
+		viewModel.sortOrder.observe(viewLifecycleOwner, MenuInvalidator(requireActivity()))
 	}
 
 	override fun onScrolledToEnd() = Unit
@@ -40,15 +40,14 @@ class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickLis
 	override fun onFilterClick(view: View?) {
 		val menu = PopupMenu(view?.context ?: return, view)
 		menu.setOnMenuItemClickListener(this)
-		val orders = ListSortOrder.FAVORITES.sortedByOrdinal()
+		for ((i, item) in FavouriteCategoriesActivity.SORT_ORDERS.withIndex()) {
-		for ((i, item) in orders.withIndex()) {
+			menu.menu.add(Menu.NONE, Menu.NONE, i, item.titleRes)
-			menu.menu.add(Menu.NONE, Menu.NONE, i, item.titleResId)
 		}
 		menu.show()
 	}
 
 	override fun onMenuItemClick(item: MenuItem): Boolean {
-		val order = ListSortOrder.FAVORITES.sortedByOrdinal().getOrNull(item.order) ?: return false
+		val order = FavouriteCategoriesActivity.SORT_ORDERS.getOrNull(item.order) ?: return false
 		viewModel.setSortOrder(order)
 		return true
 	}

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/list/FavouritesListMenuProvider.kt

@@ -5,8 +5,12 @@ import android.view.Menu
 import android.view.MenuInflater
 import android.view.MenuItem
 import androidx.core.view.MenuProvider
+import androidx.core.view.forEach
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.model.titleRes
+import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesActivity
 import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity
+import org.koitharu.kotatsu.parsers.model.SortOrder
 
 class FavouritesListMenuProvider(
 	private val context: Context,
@@ -15,12 +19,34 @@ class FavouritesListMenuProvider(
 
 	override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
 		menuInflater.inflate(R.menu.opt_favourites, menu)
+		val subMenu = menu.findItem(R.id.action_order)?.subMenu ?: return
+		for (order in FavouriteCategoriesActivity.SORT_ORDERS) {
+			subMenu.add(R.id.group_order, Menu.NONE, order.ordinal, order.titleRes)
+		}
+		subMenu.setGroupCheckable(R.id.group_order, true, true)
+	}
+
+	override fun onPrepareMenu(menu: Menu) {
+		super.onPrepareMenu(menu)
+		val order = viewModel.sortOrder.value ?: return
+		menu.findItem(R.id.action_order)?.subMenu?.forEach { item ->
+			if (item.order == order.ordinal) {
+				item.isChecked = true
+			}
+		}
 	}
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+		if (menuItem.groupId == R.id.group_order) {
+			val order = SortOrder.entries[menuItem.order]
+			viewModel.setSortOrder(order)
+			return true
+		}
 		return when (menuItem.itemId) {
 			R.id.action_edit -> {
-				context.startActivity(FavouritesCategoryEditActivity.newIntent(context, viewModel.categoryId))
+				context.startActivity(
+					FavouritesCategoryEditActivity.newIntent(context, viewModel.categoryId),
+				)
 				true
 			}
 

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/list/FavouritesListViewModel.kt

@@ -14,7 +14,6 @@ import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.observeAsFlow
 import org.koitharu.kotatsu.core.ui.util.ReversibleAction
 import org.koitharu.kotatsu.core.util.ext.call
 import org.koitharu.kotatsu.download.ui.worker.DownloadWorker
@@ -22,12 +21,12 @@ import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
 import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment.Companion.ARG_CATEGORY_ID
 import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment.Companion.NO_ID
 import org.koitharu.kotatsu.list.domain.ListExtraProvider
-import org.koitharu.kotatsu.list.domain.ListSortOrder
 import org.koitharu.kotatsu.list.ui.MangaListViewModel
 import org.koitharu.kotatsu.list.ui.model.EmptyState
 import org.koitharu.kotatsu.list.ui.model.LoadingState
 import org.koitharu.kotatsu.list.ui.model.toErrorState
 import org.koitharu.kotatsu.list.ui.model.toUi
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import javax.inject.Inject
 
 @HiltViewModel
@@ -41,10 +40,7 @@ class FavouritesListViewModel @Inject constructor(
 
 	val categoryId: Long = savedStateHandle[ARG_CATEGORY_ID] ?: NO_ID
 
-	override val listMode = settings.observeAsFlow(AppSettings.KEY_LIST_MODE_FAVORITES) { favoritesListMode }
+	val sortOrder: StateFlow<SortOrder?> = if (categoryId == NO_ID) {
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, settings.favoritesListMode)
-
-	val sortOrder: StateFlow<ListSortOrder?> = if (categoryId == NO_ID) {
 		MutableStateFlow(null)
 	} else {
 		repository.observeCategory(categoryId)
@@ -54,7 +50,7 @@ class FavouritesListViewModel @Inject constructor(
 
 	override val content = combine(
 		if (categoryId == NO_ID) {
-			repository.observeAll(ListSortOrder.NEWEST)
+			repository.observeAll(SortOrder.NEWEST)
 		} else {
 			repository.observeAll(categoryId)
 		},
@@ -98,7 +94,7 @@ class FavouritesListViewModel @Inject constructor(
 		}
 	}
 
-	fun setSortOrder(order: ListSortOrder) {
+	fun setSortOrder(order: SortOrder) {
 		if (categoryId == NO_ID) {
 			return
 		}

app/src/main/kotlin/org/koitharu/kotatsu/filter/ui/FilterCoordinator.kt

@@ -25,7 +25,6 @@ import org.koitharu.kotatsu.core.ui.widgets.ChipsView
 import org.koitharu.kotatsu.core.util.ext.lifecycleScope
 import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import org.koitharu.kotatsu.core.util.ext.require
-import org.koitharu.kotatsu.core.util.ext.sortedByOrdinal
 import org.koitharu.kotatsu.filter.ui.model.FilterHeaderModel
 import org.koitharu.kotatsu.filter.ui.model.FilterItem
 import org.koitharu.kotatsu.filter.ui.model.FilterState
@@ -208,7 +207,7 @@ class FilterCoordinator @Inject constructor(
 		state: FilterState,
 		query: String,
 	): List<ListModel> {
-		val sortOrders = repository.sortOrders.sortedByOrdinal()
+		val sortOrders = repository.sortOrders.sortedBy { it.ordinal }
 		val tags = mergeTags(state.tags, allTags.tags).toList()
 		val list = ArrayList<ListModel>(tags.size + sortOrders.size + 3)
 		if (query.isEmpty()) {

app/src/main/kotlin/org/koitharu/kotatsu/history/data/HistoryDao.kt

@@ -12,7 +12,7 @@ import kotlinx.coroutines.flow.Flow
 import org.intellij.lang.annotations.Language
 import org.koitharu.kotatsu.core.db.entity.MangaEntity
 import org.koitharu.kotatsu.core.db.entity.TagEntity
-import org.koitharu.kotatsu.list.domain.ListSortOrder
+import org.koitharu.kotatsu.history.domain.model.HistoryOrder
 
 @Dao
 abstract class HistoryDao {
@@ -33,14 +33,12 @@ abstract class HistoryDao {
 	@Query("SELECT * FROM history WHERE deleted_at = 0 ORDER BY updated_at DESC LIMIT :limit")
 	abstract fun observeAll(limit: Int): Flow<List<HistoryWithManga>>
 
-	fun observeAll(order: ListSortOrder): Flow<List<HistoryWithManga>> {
+	fun observeAll(order: HistoryOrder): Flow<List<HistoryWithManga>> {
 		val orderBy = when (order) {
-			ListSortOrder.UPDATED -> "history.updated_at DESC"
+			HistoryOrder.UPDATED -> "history.updated_at DESC"
-			ListSortOrder.NEWEST -> "history.created_at DESC"
+			HistoryOrder.CREATED -> "history.created_at DESC"
-			ListSortOrder.PROGRESS -> "history.percent DESC"
+			HistoryOrder.PROGRESS -> "history.percent DESC"
-			ListSortOrder.ALPHABETIC -> "manga.title"
+			HistoryOrder.ALPHABETIC -> "manga.title"
-			ListSortOrder.NEW_CHAPTERS -> "(SELECT chapters_new FROM tracks WHERE tracks.manga_id = manga.manga_id) DESC"
-			else -> throw IllegalArgumentException("Sort order $order is not supported")
 		}
 
 		@Language("RoomSql")

app/src/main/kotlin/org/koitharu/kotatsu/history/data/HistoryRepository.kt

@@ -18,8 +18,8 @@ import org.koitharu.kotatsu.core.model.findById
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.ui.util.ReversibleHandle
 import org.koitharu.kotatsu.core.util.ext.mapItems
+import org.koitharu.kotatsu.history.domain.model.HistoryOrder
 import org.koitharu.kotatsu.history.domain.model.MangaWithHistory
-import org.koitharu.kotatsu.list.domain.ListSortOrder
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaTag
 import org.koitharu.kotatsu.scrobbling.common.domain.Scrobbler
@@ -66,7 +66,7 @@ class HistoryRepository @Inject constructor(
 		}
 	}
 
-	fun observeAllWithHistory(order: ListSortOrder): Flow<List<MangaWithHistory>> {
+	fun observeAllWithHistory(order: HistoryOrder): Flow<List<MangaWithHistory>> {
 		return db.historyDao.observeAll(order).mapItems {
 			MangaWithHistory(
 				it.manga.toManga(it.tags.toMangaTags()),
@@ -93,11 +93,8 @@ class HistoryRepository @Inject constructor(
 		}
 		val tags = manga.tags.toEntities()
 		db.withTransaction {
-			val existing = db.mangaDao.find(manga.id)?.manga
+			db.tagsDao.upsert(tags)
-			if (existing == null || existing.source == manga.source.name) {
+			db.mangaDao.upsert(manga.toEntity(), tags)
-				db.tagsDao.upsert(tags)
-				db.mangaDao.upsert(manga.toEntity(), tags)
-			}
 			db.historyDao.upsert(
 				HistoryEntity(
 					mangaId = manga.id,

app/src/main/kotlin/org/koitharu/kotatsu/history/domain/model/HistoryOrder.kt

@@ -0,0 +1,16 @@
+package org.koitharu.kotatsu.history.domain.model
+
+import androidx.annotation.StringRes
+import org.koitharu.kotatsu.R
+
+enum class HistoryOrder(
+	@StringRes val titleResId: Int,
+) {
+
+	UPDATED(R.string.updated),
+	CREATED(R.string.order_added),
+	PROGRESS(R.string.progress),
+	ALPHABETIC(R.string.by_name);
+
+	fun isGroupingSupported() = this == UPDATED || this == CREATED || this == PROGRESS
+}

app/src/main/kotlin/org/koitharu/kotatsu/history/ui/HistoryListFragment.kt

@@ -9,7 +9,9 @@ import dagger.hilt.android.AndroidEntryPoint
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.os.NetworkManageIntent
 import org.koitharu.kotatsu.core.ui.list.ListSelectionController
+import org.koitharu.kotatsu.core.ui.util.MenuInvalidator
 import org.koitharu.kotatsu.core.util.ext.addMenuProvider
+import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.databinding.FragmentListBinding
 import org.koitharu.kotatsu.list.ui.MangaListFragment
 import org.koitharu.kotatsu.list.ui.size.DynamicItemSizeResolver
@@ -24,6 +26,9 @@ class HistoryListFragment : MangaListFragment() {
 	override fun onViewBindingCreated(binding: FragmentListBinding, savedInstanceState: Bundle?) {
 		super.onViewBindingCreated(binding, savedInstanceState)
 		addMenuProvider(HistoryListMenuProvider(binding.root.context, viewModel))
+		val menuInvalidator = MenuInvalidator(requireActivity())
+		viewModel.isGroupingEnabled.observe(viewLifecycleOwner, menuInvalidator)
+		viewModel.sortOrder.observe(viewLifecycleOwner, menuInvalidator)
 	}
 
 	override fun onScrolledToEnd() = Unit

app/src/main/kotlin/org/koitharu/kotatsu/history/ui/HistoryListMenuProvider.kt

@@ -5,10 +5,12 @@ import android.view.Menu
 import android.view.MenuInflater
 import android.view.MenuItem
 import androidx.core.view.MenuProvider
+import androidx.core.view.forEach
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.dialog.RememberSelectionDialogListener
 import org.koitharu.kotatsu.core.util.ext.startOfDay
+import org.koitharu.kotatsu.history.domain.model.HistoryOrder
 import java.util.Date
 import java.util.concurrent.TimeUnit
 import com.google.android.material.R as materialR
@@ -20,19 +22,47 @@ class HistoryListMenuProvider(
 
 	override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
 		menuInflater.inflate(R.menu.opt_history, menu)
+		val subMenu = menu.findItem(R.id.action_order)?.subMenu ?: return
+		for (order in HistoryOrder.entries) {
+			subMenu.add(R.id.group_order, Menu.NONE, order.ordinal, order.titleResId)
+		}
+		subMenu.setGroupCheckable(R.id.group_order, true, true)
 	}
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+		if (menuItem.groupId == R.id.group_order) {
+			val order = HistoryOrder.entries[menuItem.order]
+			viewModel.setSortOrder(order)
+			return true
+		}
 		return when (menuItem.itemId) {
 			R.id.action_clear_history -> {
 				showClearHistoryDialog()
 				true
 			}
 
+			R.id.action_history_grouping -> {
+				viewModel.setGrouping(!menuItem.isChecked)
+				true
+			}
+
 			else -> false
 		}
 	}
 
+	override fun onPrepareMenu(menu: Menu) {
+		val order = viewModel.sortOrder.value
+		menu.findItem(R.id.action_order)?.subMenu?.forEach { item ->
+			if (item.order == order.ordinal) {
+				item.isChecked = true
+			}
+		}
+		menu.findItem(R.id.action_history_grouping)?.run {
+			isChecked = viewModel.isGroupingEnabled.value == true
+			isEnabled = order.isGroupingSupported()
+		}
+	}
+
 	private fun showClearHistoryDialog() {
 		val selectionListener = RememberSelectionDialogListener(2)
 		MaterialAlertDialogBuilder(context, materialR.style.ThemeOverlay_Material3_MaterialAlertDialog_Centered)

app/src/main/kotlin/org/koitharu/kotatsu/history/ui/HistoryListViewModel.kt

@@ -26,9 +26,9 @@ import org.koitharu.kotatsu.core.util.ext.daysDiff
 import org.koitharu.kotatsu.core.util.ext.onFirst
 import org.koitharu.kotatsu.download.ui.worker.DownloadWorker
 import org.koitharu.kotatsu.history.data.HistoryRepository
+import org.koitharu.kotatsu.history.domain.model.HistoryOrder
 import org.koitharu.kotatsu.history.domain.model.MangaWithHistory
 import org.koitharu.kotatsu.list.domain.ListExtraProvider
-import org.koitharu.kotatsu.list.domain.ListSortOrder
 import org.koitharu.kotatsu.list.ui.MangaListViewModel
 import org.koitharu.kotatsu.list.ui.model.EmptyHint
 import org.koitharu.kotatsu.list.ui.model.EmptyState
@@ -54,21 +54,22 @@ class HistoryListViewModel @Inject constructor(
 	downloadScheduler: DownloadWorker.Scheduler,
 ) : MangaListViewModel(settings, downloadScheduler) {
 
-	private val sortOrder: StateFlow<ListSortOrder> = settings.observeAsStateFlow(
+	val sortOrder: StateFlow<HistoryOrder> = settings.observeAsStateFlow(
 		scope = viewModelScope + Dispatchers.IO,
 		key = AppSettings.KEY_HISTORY_ORDER,
 		valueProducer = { historySortOrder },
 	)
 
-	override val listMode = settings.observeAsFlow(AppSettings.KEY_LIST_MODE_HISTORY) { historyListMode }
+	val isGroupingEnabled = settings.observeAsFlow(
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, settings.historyListMode)
-
-	private val isGroupingEnabled = settings.observeAsFlow(
 		key = AppSettings.KEY_HISTORY_GROUPING,
 		valueProducer = { isHistoryGroupingEnabled },
 	).combine(sortOrder) { g, s ->
 		g && s.isGroupingSupported()
-	}
+	}.stateIn(
+		scope = viewModelScope + Dispatchers.Default,
+		started = SharingStarted.Eagerly,
+		initialValue = settings.isHistoryGroupingEnabled && sortOrder.value.isGroupingSupported(),
+	)
 
 	override val content = combine(
 		sortOrder.flatMapLatest { repository.observeAllWithHistory(it) },
@@ -100,6 +101,10 @@ class HistoryListViewModel @Inject constructor(
 
 	override fun onRetry() = Unit
 
+	fun setSortOrder(order: HistoryOrder) {
+		settings.historySortOrder = order
+	}
+
 	fun clearHistory(minDate: Long) {
 		launchJob(Dispatchers.Default) {
 			val stringRes = if (minDate <= 0) {
@@ -123,6 +128,10 @@ class HistoryListViewModel @Inject constructor(
 		}
 	}
 
+	fun setGrouping(isGroupingEnabled: Boolean) {
+		settings.isHistoryGroupingEnabled = isGroupingEnabled
+	}
+
 	private suspend fun mapList(
 		list: List<MangaWithHistory>,
 		grouped: Boolean,
@@ -164,10 +173,10 @@ class HistoryListViewModel @Inject constructor(
 		return result
 	}
 
-	private fun MangaHistory.header(order: ListSortOrder): ListHeader? = when (order) {
+	private fun MangaHistory.header(order: HistoryOrder): ListHeader? = when (order) {
-		ListSortOrder.UPDATED -> ListHeader(timeAgo(updatedAt))
+		HistoryOrder.UPDATED -> ListHeader(timeAgo(updatedAt))
-		ListSortOrder.NEWEST -> ListHeader(timeAgo(createdAt))
+		HistoryOrder.CREATED -> ListHeader(timeAgo(createdAt))
-		ListSortOrder.PROGRESS -> ListHeader(
+		HistoryOrder.PROGRESS -> ListHeader(
 			when (percent) {
 				1f -> R.string.status_completed
 				in 0f..0.01f -> R.string.status_planned
@@ -176,10 +185,7 @@ class HistoryListViewModel @Inject constructor(
 			},
 		)
 
-		ListSortOrder.ALPHABETIC,
+		HistoryOrder.ALPHABETIC -> null
-		ListSortOrder.RELEVANCE,
-		ListSortOrder.NEW_CHAPTERS,
-		ListSortOrder.RATING -> null
 	}
 
 	private fun timeAgo(date: Date): DateTimeAgo {

app/src/main/kotlin/org/koitharu/kotatsu/list/domain/ListSortOrder.kt

@@ -1,31 +0,0 @@
-package org.koitharu.kotatsu.list.domain
-
-import androidx.annotation.StringRes
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.parsers.util.find
-import java.util.EnumSet
-
-enum class ListSortOrder(
-	@StringRes val titleResId: Int,
-) {
-
-	UPDATED(R.string.updated),
-	NEWEST(R.string.order_added),
-	PROGRESS(R.string.progress),
-	ALPHABETIC(R.string.by_name),
-	RATING(R.string.by_rating),
-	RELEVANCE(R.string.by_relevance),
-	NEW_CHAPTERS(R.string.new_chapters),
-	;
-
-	fun isGroupingSupported() = this == UPDATED || this == NEWEST || this == PROGRESS
-
-	companion object {
-
-		val HISTORY: Set<ListSortOrder> = EnumSet.of(UPDATED, NEWEST, PROGRESS, ALPHABETIC, NEW_CHAPTERS)
-		val FAVORITES: Set<ListSortOrder> = EnumSet.of(ALPHABETIC, NEWEST, RATING, NEW_CHAPTERS, PROGRESS)
-		val SUGGESTIONS: Set<ListSortOrder> = EnumSet.of(RELEVANCE)
-
-		operator fun invoke(value: String, fallback: ListSortOrder) = entries.find(value) ?: fallback
-	}
-}

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/ListModeBottomSheet.kt

@@ -0,0 +1,78 @@
+package org.koitharu.kotatsu.list.ui
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.core.view.isVisible
+import androidx.fragment.app.FragmentManager
+import com.google.android.material.button.MaterialButtonToggleGroup
+import com.google.android.material.slider.Slider
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.prefs.ListMode
+import org.koitharu.kotatsu.core.ui.sheet.BaseAdaptiveSheet
+import org.koitharu.kotatsu.core.util.ext.setValueRounded
+import org.koitharu.kotatsu.core.util.ext.showDistinct
+import org.koitharu.kotatsu.core.util.progress.IntPercentLabelFormatter
+import org.koitharu.kotatsu.databinding.DialogListModeBinding
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class ListModeBottomSheet :
+	BaseAdaptiveSheet<DialogListModeBinding>(),
+	Slider.OnChangeListener,
+	MaterialButtonToggleGroup.OnButtonCheckedListener {
+
+	@Inject
+	lateinit var settings: AppSettings
+
+	override fun onCreateViewBinding(
+		inflater: LayoutInflater,
+		container: ViewGroup?,
+	) = DialogListModeBinding.inflate(inflater, container, false)
+
+	override fun onViewBindingCreated(binding: DialogListModeBinding, savedInstanceState: Bundle?) {
+		super.onViewBindingCreated(binding, savedInstanceState)
+		val mode = settings.listMode
+		binding.buttonList.isChecked = mode == ListMode.LIST
+		binding.buttonListDetailed.isChecked = mode == ListMode.DETAILED_LIST
+		binding.buttonGrid.isChecked = mode == ListMode.GRID
+		binding.textViewGridTitle.isVisible = mode == ListMode.GRID
+		binding.sliderGrid.isVisible = mode == ListMode.GRID
+
+		binding.sliderGrid.setLabelFormatter(IntPercentLabelFormatter(binding.root.context))
+		binding.sliderGrid.setValueRounded(settings.gridSize.toFloat())
+		binding.sliderGrid.addOnChangeListener(this)
+
+		binding.checkableGroup.addOnButtonCheckedListener(this)
+	}
+
+	override fun onButtonChecked(group: MaterialButtonToggleGroup?, checkedId: Int, isChecked: Boolean) {
+		if (!isChecked) {
+			return
+		}
+		val mode = when (checkedId) {
+			R.id.button_list -> ListMode.LIST
+			R.id.button_list_detailed -> ListMode.DETAILED_LIST
+			R.id.button_grid -> ListMode.GRID
+			else -> return
+		}
+		requireViewBinding().textViewGridTitle.isVisible = mode == ListMode.GRID
+		requireViewBinding().sliderGrid.isVisible = mode == ListMode.GRID
+		settings.listMode = mode
+	}
+
+	override fun onValueChange(slider: Slider, value: Float, fromUser: Boolean) {
+		if (fromUser) {
+			settings.gridSize = value.toInt()
+		}
+	}
+
+	companion object {
+
+		private const val TAG = "ListModeSelectDialog"
+
+		fun show(fm: FragmentManager) = ListModeBottomSheet().showDistinct(fm, TAG)
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/MangaListMenuProvider.kt

@@ -6,11 +6,6 @@ import android.view.MenuItem
 import androidx.core.view.MenuProvider
 import androidx.fragment.app.Fragment
 import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment
-import org.koitharu.kotatsu.history.ui.HistoryListFragment
-import org.koitharu.kotatsu.list.ui.config.ListConfigBottomSheet
-import org.koitharu.kotatsu.list.ui.config.ListConfigSection
-import org.koitharu.kotatsu.suggestions.ui.SuggestionsFragment
 
 class MangaListMenuProvider(
 	private val fragment: Fragment,
@@ -22,13 +17,7 @@ class MangaListMenuProvider(
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean = when (menuItem.itemId) {
 		R.id.action_list_mode -> {
-			val section: ListConfigSection = when (fragment) {
+			ListModeBottomSheet.show(fragment.childFragmentManager)
-				is HistoryListFragment -> ListConfigSection.History
-				is SuggestionsFragment -> ListConfigSection.Suggestions
-				is FavouritesListFragment -> ListConfigSection.Favorites(fragment.categoryId)
-				else -> ListConfigSection.General
-			}
-			ListConfigBottomSheet.show(fragment.childFragmentManager, section)
 			true
 		}
 

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/MangaListViewModel.kt

@@ -24,7 +24,7 @@ abstract class MangaListViewModel(
 ) : BaseViewModel() {
 
 	abstract val content: StateFlow<List<ListModel>>
-	open val listMode = settings.observeAsFlow(AppSettings.KEY_LIST_MODE) { listMode }
+	val listMode = settings.observeAsFlow(AppSettings.KEY_LIST_MODE) { listMode }
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, settings.listMode)
 	val onActionDone = MutableEventFlow<ReversibleAction>()
 	val gridScale = settings.observeAsStateFlow(

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/adapter/ListItemType.kt

@@ -26,5 +26,4 @@ enum class ListItemType {
 	CATEGORY_LARGE,
 	MANGA_SCROBBLING,
 	NAV_ITEM,
-	CHAPTER,
 }

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/adapter/TypedListSpacingDecoration.kt

@@ -59,7 +59,6 @@ class TypedListSpacingDecoration(
 			ListItemType.MANGA_NESTED_GROUP,
 			ListItemType.CATEGORY_LARGE,
 			ListItemType.NAV_ITEM,
-			ListItemType.CHAPTER,
 			null,
 			-> outRect.set(0)
 
@@ -78,6 +77,6 @@ class TypedListSpacingDecoration(
 	private fun Rect.set(spacing: Int) = set(spacing, spacing, spacing, spacing)
 
 	private fun ListItemType?.isEdgeToEdge() = this == ListItemType.MANGA_NESTED_GROUP
-		|| this == ListItemType.FILTER_SORT
+			|| this == ListItemType.FILTER_SORT
-		|| this == ListItemType.FILTER_TAG
+			|| this == ListItemType.FILTER_TAG
 }

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/config/ListConfigBottomSheet.kt

@@ -1,132 +0,0 @@
-package org.koitharu.kotatsu.list.ui.config
-
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import android.widget.AdapterView
-import android.widget.ArrayAdapter
-import android.widget.CompoundButton
-import androidx.core.view.isVisible
-import androidx.fragment.app.FragmentManager
-import androidx.fragment.app.viewModels
-import com.google.android.material.button.MaterialButtonToggleGroup
-import com.google.android.material.slider.Slider
-import dagger.hilt.android.AndroidEntryPoint
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.ListMode
-import org.koitharu.kotatsu.core.ui.sheet.BaseAdaptiveSheet
-import org.koitharu.kotatsu.core.util.ext.setValueRounded
-import org.koitharu.kotatsu.core.util.ext.showDistinct
-import org.koitharu.kotatsu.core.util.ext.withArgs
-import org.koitharu.kotatsu.core.util.progress.IntPercentLabelFormatter
-import org.koitharu.kotatsu.databinding.SheetListModeBinding
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class ListConfigBottomSheet :
-	BaseAdaptiveSheet<SheetListModeBinding>(),
-	Slider.OnChangeListener,
-	MaterialButtonToggleGroup.OnButtonCheckedListener, CompoundButton.OnCheckedChangeListener,
-	AdapterView.OnItemSelectedListener {
-
-	@Inject
-	@Deprecated("")
-	lateinit var settings: AppSettings
-
-	private val viewModel by viewModels<ListConfigViewModel>()
-
-	override fun onCreateViewBinding(
-		inflater: LayoutInflater,
-		container: ViewGroup?,
-	) = SheetListModeBinding.inflate(inflater, container, false)
-
-	override fun onViewBindingCreated(binding: SheetListModeBinding, savedInstanceState: Bundle?) {
-		super.onViewBindingCreated(binding, savedInstanceState)
-		val mode = viewModel.listMode
-		binding.buttonList.isChecked = mode == ListMode.LIST
-		binding.buttonListDetailed.isChecked = mode == ListMode.DETAILED_LIST
-		binding.buttonGrid.isChecked = mode == ListMode.GRID
-		binding.textViewGridTitle.isVisible = mode == ListMode.GRID
-		binding.sliderGrid.isVisible = mode == ListMode.GRID
-
-		binding.sliderGrid.setLabelFormatter(IntPercentLabelFormatter(binding.root.context))
-		binding.sliderGrid.setValueRounded(viewModel.gridSize.toFloat())
-		binding.sliderGrid.addOnChangeListener(this)
-
-		binding.checkableGroup.addOnButtonCheckedListener(this)
-
-		binding.switchGrouping.isVisible = viewModel.isGroupingAvailable
-		if (viewModel.isGroupingAvailable) {
-			binding.switchGrouping.isEnabled = settings.historySortOrder.isGroupingSupported()
-		}
-		binding.switchGrouping.isChecked = settings.isHistoryGroupingEnabled
-		binding.switchGrouping.setOnCheckedChangeListener(this)
-
-		val sortOrders = viewModel.getSortOrders()
-		if (sortOrders != null) {
-			binding.textViewOrderTitle.isVisible = true
-			binding.spinnerOrder.adapter = ArrayAdapter(
-				binding.spinnerOrder.context,
-				android.R.layout.simple_spinner_dropdown_item,
-				android.R.id.text1,
-				sortOrders.map { binding.spinnerOrder.context.getString(it.titleResId) },
-			)
-			val selected = sortOrders.indexOf(viewModel.getSelectedSortOrder())
-			if (selected >= 0) {
-				binding.spinnerOrder.setSelection(selected, false)
-			}
-			binding.spinnerOrder.onItemSelectedListener = this
-			binding.cardOrder.isVisible = true
-		}
-	}
-
-	override fun onButtonChecked(group: MaterialButtonToggleGroup?, checkedId: Int, isChecked: Boolean) {
-		if (!isChecked) {
-			return
-		}
-		val mode = when (checkedId) {
-			R.id.button_list -> ListMode.LIST
-			R.id.button_list_detailed -> ListMode.DETAILED_LIST
-			R.id.button_grid -> ListMode.GRID
-			else -> return
-		}
-		requireViewBinding().textViewGridTitle.isVisible = mode == ListMode.GRID
-		requireViewBinding().sliderGrid.isVisible = mode == ListMode.GRID
-		viewModel.listMode = mode
-	}
-
-	override fun onCheckedChanged(buttonView: CompoundButton, isChecked: Boolean) {
-		when (buttonView.id) {
-			R.id.switch_grouping -> settings.isHistoryGroupingEnabled = isChecked
-		}
-	}
-
-	override fun onValueChange(slider: Slider, value: Float, fromUser: Boolean) {
-		if (fromUser) {
-			viewModel.gridSize = value.toInt()
-		}
-	}
-
-	override fun onItemSelected(parent: AdapterView<*>, view: View?, position: Int, id: Long) {
-		when (parent.id) {
-			R.id.spinner_order -> {
-				viewModel.setSortOrder(position)
-				viewBinding?.switchGrouping?.isEnabled = settings.historySortOrder.isGroupingSupported()
-			}
-		}
-	}
-
-	override fun onNothingSelected(parent: AdapterView<*>?) = Unit
-
-	companion object {
-
-		private const val TAG = "ListModeSelectDialog"
-		const val ARG_SECTION = "section"
-
-		fun show(fm: FragmentManager, section: ListConfigSection) = ListConfigBottomSheet().withArgs(1) {
-			putParcelable(ARG_SECTION, section)
-		}.showDistinct(fm, TAG)
-	}
-}

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/config/ListConfigSection.kt

@@ -1,21 +0,0 @@
-package org.koitharu.kotatsu.list.ui.config
-
-import android.os.Parcelable
-import kotlinx.parcelize.Parcelize
-
-sealed interface ListConfigSection : Parcelable {
-
-	@Parcelize
-	data object History : ListConfigSection
-
-	@Parcelize
-	data object General : ListConfigSection
-
-	@Parcelize
-	data class Favorites(
-		val categoryId: Long,
-	) : ListConfigSection
-
-	@Parcelize
-	data object Suggestions : ListConfigSection
-}

app/src/main/kotlin/org/koitharu/kotatsu/list/ui/config/ListConfigViewModel.kt

@@ -1,76 +0,0 @@
-package org.koitharu.kotatsu.list.ui.config
-
-import androidx.lifecycle.SavedStateHandle
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.runBlocking
-import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.ListMode
-import org.koitharu.kotatsu.core.ui.BaseViewModel
-import org.koitharu.kotatsu.core.util.ext.require
-import org.koitharu.kotatsu.core.util.ext.sortedByOrdinal
-import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
-import org.koitharu.kotatsu.list.domain.ListSortOrder
-import javax.inject.Inject
-
-@HiltViewModel
-class ListConfigViewModel @Inject constructor(
-	savedStateHandle: SavedStateHandle,
-	private val settings: AppSettings,
-	private val favouritesRepository: FavouritesRepository,
-) : BaseViewModel() {
-
-	val section = savedStateHandle.require<ListConfigSection>(ListConfigBottomSheet.ARG_SECTION)
-
-	var listMode: ListMode
-		get() = when (section) {
-			is ListConfigSection.Favorites -> settings.favoritesListMode
-			ListConfigSection.General -> settings.listMode
-			ListConfigSection.History -> settings.historyListMode
-			ListConfigSection.Suggestions -> settings.suggestionsListMode
-		}
-		set(value) {
-			when (section) {
-				is ListConfigSection.Favorites -> settings.favoritesListMode = value
-				ListConfigSection.General -> settings.listMode = value
-				ListConfigSection.History -> settings.historyListMode = value
-				ListConfigSection.Suggestions -> settings.suggestionsListMode = value
-			}
-		}
-
-	var gridSize: Int
-		get() = settings.gridSize
-		set(value) {
-			settings.gridSize = value
-		}
-
-	val isGroupingAvailable: Boolean
-		get() = section == ListConfigSection.History
-
-	fun getSortOrders(): List<ListSortOrder>? = when (section) {
-		is ListConfigSection.Favorites -> ListSortOrder.FAVORITES
-		ListConfigSection.General -> null
-		ListConfigSection.History -> ListSortOrder.HISTORY
-		ListConfigSection.Suggestions -> ListSortOrder.SUGGESTIONS
-	}?.sortedByOrdinal()
-
-	fun getSelectedSortOrder(): ListSortOrder? = when (section) {
-		is ListConfigSection.Favorites -> runBlocking { favouritesRepository.getCategory(section.categoryId).order }
-		ListConfigSection.General -> null
-		ListConfigSection.History -> settings.historySortOrder
-		ListConfigSection.Suggestions -> ListSortOrder.RELEVANCE // TODO
-	}
-
-	fun setSortOrder(position: Int) {
-		val value = getSortOrders()?.getOrNull(position) ?: return
-		when (section) {
-			is ListConfigSection.Favorites -> launchJob {
-				favouritesRepository.setCategoryOrder(section.categoryId, value)
-			}
-
-			ListConfigSection.General -> Unit
-			ListConfigSection.History -> settings.historySortOrder = value
-
-			ListConfigSection.Suggestions -> Unit
-		}
-	}
-}

app/src/main/kotlin/org/koitharu/kotatsu/local/data/LocalMangaRepository.kt

@@ -14,7 +14,7 @@ import kotlinx.coroutines.runInterruptible
 import org.koitharu.kotatsu.core.model.isLocal
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.util.CompositeMutex2
+import org.koitharu.kotatsu.core.util.CompositeMutex
 import org.koitharu.kotatsu.core.util.ext.children
 import org.koitharu.kotatsu.core.util.ext.deleteAwait
 import org.koitharu.kotatsu.core.util.ext.filterWith
@@ -45,7 +45,7 @@ class LocalMangaRepository @Inject constructor(
 ) : MangaRepository {
 
 	override val source = MangaSource.LOCAL
-	private val locks = CompositeMutex2<Long>()
+	private val locks = CompositeMutex<Long>()
 
 	override val sortOrders: Set<SortOrder> = EnumSet.of(SortOrder.ALPHABETICAL, SortOrder.RATING, SortOrder.NEWEST)
 
@@ -122,18 +122,14 @@ class LocalMangaRepository @Inject constructor(
 
 	suspend fun getRemoteManga(localManga: Manga): Manga? {
 		return runCatchingCancellable {
-			LocalMangaInput.of(localManga).getMangaInfo()?.takeUnless { it.isLocal }
+			LocalMangaInput.of(localManga).getMangaInfo()
 		}.onFailure {
 			it.printStackTraceDebug()
 		}.getOrNull()
 	}
 
 	suspend fun findSavedManga(remoteManga: Manga): LocalManga? {
-		// fast path
+		// TODO fast path by name
-		LocalMangaInput.find(storageManager.getReadableDirs(), remoteManga)?.let {
-			return it.getManga()
-		}
-		// slow path
 		val files = getAllFiles()
 		return channelFlow {
 			for (file in files) {

app/src/main/kotlin/org/koitharu/kotatsu/local/data/MangaIndex.kt

@@ -4,7 +4,6 @@ import androidx.annotation.WorkerThread
 import org.json.JSONArray
 import org.json.JSONObject
 import org.koitharu.kotatsu.BuildConfig
-import org.koitharu.kotatsu.core.model.isLocal
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.parsers.model.MangaSource
@@ -22,8 +21,7 @@ class MangaIndex(source: String?) {
 
 	private val json: JSONObject = source?.let(::JSONObject) ?: JSONObject()
 
-	fun setMangaInfo(manga: Manga) {
+	fun setMangaInfo(manga: Manga, append: Boolean) {
-		require(!manga.isLocal) { "Local manga information cannot be stored" }
 		json.put("id", manga.id)
 		json.put("title", manga.title)
 		json.put("title_alt", manga.altTitle)
@@ -48,7 +46,7 @@ class MangaIndex(source: String?) {
 				}
 			},
 		)
-		if (!json.has("chapters")) {
+		if (!append || !json.has("chapters")) {
 			json.put("chapters", JSONObject())
 		}
 		json.put("app_id", BuildConfig.APPLICATION_ID)

app/src/main/kotlin/org/koitharu/kotatsu/local/data/input/LocalMangaDirInput.kt

@@ -40,15 +40,13 @@ class LocalMangaDirInput(root: File) : LocalMangaInput(root) {
 		val mangaUri = root.toUri().toString()
 		val chapterFiles = getChaptersFiles()
 		val info = index?.getMangaInfo()
-		val cover = fileUri(
-			root,
-			index?.getCoverEntry() ?: findFirstImageEntry().orEmpty(),
-		)
 		val manga = info?.copy2(
 			source = MangaSource.LOCAL,
 			url = mangaUri,
-			coverUrl = cover,
+			coverUrl = fileUri(
-			largeCoverUrl = cover,
+				root,
+				index.getCoverEntry() ?: findFirstImageEntry().orEmpty(),
+			),
 			chapters = info.chapters?.mapIndexed { i, c ->
 				c.copy(url = chapterFiles[i].toUri().toString(), source = MangaSource.LOCAL)
 			},

app/src/main/kotlin/org/koitharu/kotatsu/local/data/input/LocalMangaInput.kt

@@ -2,18 +2,12 @@ package org.koitharu.kotatsu.local.data.input
 
 import android.net.Uri
 import androidx.core.net.toFile
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.channelFlow
-import kotlinx.coroutines.flow.firstOrNull
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.local.data.CbzFilter
 import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.util.toFileNameSafe
 import java.io.File
 
 sealed class LocalMangaInput(
@@ -43,35 +37,16 @@ sealed class LocalMangaInput(
 			else -> null
 		}
 
-		suspend fun find(roots: Iterable<File>, manga: Manga): LocalMangaInput? = channelFlow {
-			val fileName = manga.title.toFileNameSafe()
-			for (root in roots) {
-				launch {
-					val dir = File(root, fileName)
-					val zip = File(root, "$fileName.cbz")
-					val input = when {
-						dir.isDirectory -> LocalMangaDirInput(dir)
-						zip.isFile -> LocalMangaZipInput(zip)
-						else -> null
-					}
-					if (input?.getMangaInfo()?.id == manga.id) {
-						send(input)
-					}
-				}
-			}
-		}.flowOn(Dispatchers.Default).firstOrNull()
-
 		@JvmStatic
 		protected fun zipUri(file: File, entryName: String): String =
 			Uri.fromParts("cbz", file.path, entryName).toString()
 
 		@JvmStatic
 		protected fun Manga.copy2(
-			url: String,
+			url: String = this.url,
-			coverUrl: String,
+			coverUrl: String = this.coverUrl,
-			largeCoverUrl: String,
+			chapters: List<MangaChapter>? = this.chapters,
-			chapters: List<MangaChapter>?,
+			source: MangaSource = this.source,
-			source: MangaSource,
 		) = Manga(
 			id = id,
 			title = title,
@@ -92,8 +67,8 @@ sealed class LocalMangaInput(
 
 		@JvmStatic
 		protected fun MangaChapter.copy(
-			url: String,
+			url: String = this.url,
-			source: MangaSource,
+			source: MangaSource = this.source,
 		) = MangaChapter(
 			id = id,
 			name = name,

app/src/main/kotlin/org/koitharu/kotatsu/local/data/input/LocalMangaZipInput.kt

@@ -41,15 +41,14 @@ class LocalMangaZipInput(root: File) : LocalMangaInput(root) {
 				val index = entry?.let(zip::readText)?.let(::MangaIndex)
 				val info = index?.getMangaInfo()
 				if (info != null) {
-					val cover = zipUri(
-						root,
-						entryName = index.getCoverEntry() ?: findFirstImageEntry(zip.entries())?.name.orEmpty(),
-					)
 					return@use info.copy2(
 						source = MangaSource.LOCAL,
 						url = fileUri,
-						coverUrl = cover,
+						coverUrl = zipUri(
-						largeCoverUrl = cover,
+							root,
+							entryName = index.getCoverEntry()
+								?: findFirstImageEntry(zip.entries())?.name.orEmpty(),
+						),
 						chapters = info.chapters?.map { c ->
 							c.copy(url = fileUri, source = MangaSource.LOCAL)
 						},

app/src/main/kotlin/org/koitharu/kotatsu/local/data/output/LocalMangaDirOutput.kt

@@ -3,7 +3,6 @@ package org.koitharu.kotatsu.local.data.output
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import org.koitharu.kotatsu.core.model.findById
-import org.koitharu.kotatsu.core.model.isLocal
 import org.koitharu.kotatsu.core.util.ext.deleteAwait
 import org.koitharu.kotatsu.core.util.ext.takeIfReadable
 import org.koitharu.kotatsu.core.zip.ZipOutput
@@ -22,9 +21,7 @@ class LocalMangaDirOutput(
 	private val index = MangaIndex(File(rootFile, ENTRY_NAME_INDEX).takeIfReadable()?.readText())
 
 	init {
-		if (!manga.isLocal) {
+		index.setMangaInfo(manga, append = true)
-			index.setMangaInfo(manga)
-		}
 	}
 
 	override suspend fun mergeWithExisting() = Unit

app/src/main/kotlin/org/koitharu/kotatsu/local/data/output/LocalMangaZipOutput.kt

@@ -3,7 +3,6 @@ package org.koitharu.kotatsu.local.data.output
 import androidx.annotation.WorkerThread
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
-import org.koitharu.kotatsu.core.model.isLocal
 import org.koitharu.kotatsu.core.util.ext.deleteAwait
 import org.koitharu.kotatsu.core.util.ext.readText
 import org.koitharu.kotatsu.core.zip.ZipOutput
@@ -22,9 +21,7 @@ class LocalMangaZipOutput(
 	private val index = MangaIndex(null)
 
 	init {
-		if (!manga.isLocal) {
+		index.setMangaInfo(manga, false)
-			index.setMangaInfo(manga)
-		}
 	}
 
 	override suspend fun mergeWithExisting() {

app/src/main/kotlin/org/koitharu/kotatsu/local/ui/LocalChaptersRemoveService.kt

@@ -47,7 +47,7 @@ class LocalChaptersRemoveService : CoroutineIntentService() {
 		startForeground()
 		val mangaWithChapters = localMangaRepository.getDetails(manga)
 		localMangaRepository.deleteChapters(mangaWithChapters, chaptersIds)
-		localStorageChanges.emit(LocalManga(localMangaRepository.getDetails(manga)))
+		localStorageChanges.emit(LocalManga(manga))
 		ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
 	}
 

app/src/main/kotlin/org/koitharu/kotatsu/local/ui/LocalListMenuProvider.kt

@@ -24,7 +24,7 @@ class LocalListMenuProvider(
 				true
 			}
 
-			R.id.action_directories -> {
+			R.id.action_settings -> {
 				context.startActivity(MangaDirectoriesActivity.newIntent(context))
 				true
 			}

app/src/main/kotlin/org/koitharu/kotatsu/reader/domain/ChaptersLoader.kt

@@ -2,10 +2,16 @@ package org.koitharu.kotatsu.reader.domain
 
 import android.util.LongSparseArray
 import dagger.hilt.android.scopes.ViewModelScoped
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import org.koitharu.kotatsu.core.parser.MangaRepository
-import org.koitharu.kotatsu.details.data.MangaDetails
+import org.koitharu.kotatsu.details.domain.model.DoubleManga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
 import javax.inject.Inject
@@ -17,24 +23,32 @@ class ChaptersLoader @Inject constructor(
 	private val mangaRepositoryFactory: MangaRepository.Factory,
 ) {
 
-	private val chapters = LongSparseArray<MangaChapter>()
+	private val chapters = MutableStateFlow(LongSparseArray<MangaChapter>(0))
 	private val chapterPages = ChapterPages()
 	private val mutex = Mutex()
 
-	val size: Int
+	val size: Int // TODO flow
-		get() = chapters.size()
+		get() = chapters.value.size()
 
-	suspend fun init(manga: MangaDetails) = mutex.withLock {
+	fun init(scope: CoroutineScope, manga: Flow<DoubleManga>) = scope.launch {
-		chapters.clear()
+		manga.collect {
-		manga.allChapters.forEach {
+			val ch = it.chapters.orEmpty()
-			chapters.put(it.id, it)
+			val longSparseArray = LongSparseArray<MangaChapter>(ch.size)
+			ch.forEach { x -> longSparseArray.put(x.id, x) }
+			mutex.withLock {
+				chapters.value = longSparseArray
+			}
 		}
 	}
 
-	suspend fun loadPrevNextChapter(manga: MangaDetails, currentId: Long, isNext: Boolean) {
+	suspend fun loadPrevNextChapter(manga: DoubleManga, currentId: Long, isNext: Boolean) {
-		val chapters = manga.allChapters
+		val chapters = manga.chapters ?: return
 		val predicate: (MangaChapter) -> Boolean = { it.id == currentId }
-		val index = if (isNext) chapters.indexOfFirst(predicate) else chapters.indexOfLast(predicate)
+		val index = if (isNext) {
+			chapters.indexOfFirst(predicate)
+		} else {
+			chapters.indexOfLast(predicate)
+		}
 		if (index == -1) return
 		val newChapter = chapters.getOrNull(if (isNext) index + 1 else index - 1) ?: return
 		val newPages = loadChapter(newChapter.id)
@@ -65,7 +79,11 @@ class ChaptersLoader @Inject constructor(
 		}
 	}
 
-	fun peekChapter(chapterId: Long): MangaChapter? = chapters[chapterId]
+	fun peekChapter(chapterId: Long): MangaChapter? = chapters.value[chapterId]
+
+	suspend fun awaitChapter(chapterId: Long): MangaChapter? = chapters.mapNotNull { x ->
+		x[chapterId]
+	}.firstOrNull()
 
 	fun getPages(chapterId: Long): List<ReaderPage> {
 		return chapterPages.subList(chapterId)
@@ -82,7 +100,7 @@ class ChaptersLoader @Inject constructor(
 	fun snapshot() = chapterPages.toList()
 
 	private suspend fun loadChapter(chapterId: Long): List<ReaderPage> {
-		val chapter = checkNotNull(chapters[chapterId]) { "Requested chapter not found" }
+		val chapter = checkNotNull(awaitChapter(chapterId)) { "Requested chapter not found" }
 		val repo = mangaRepositoryFactory.create(chapter.source)
 		return repo.getPages(chapter).mapIndexed { index, page ->
 			ReaderPage(page, index, chapterId)

app/src/main/kotlin/org/koitharu/kotatsu/reader/domain/DetectReaderModeUseCase.kt

@@ -13,11 +13,11 @@ import org.koitharu.kotatsu.core.parser.MangaDataRepository
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.ReaderMode
+import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import org.koitharu.kotatsu.reader.ui.ReaderState
-import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import java.io.InputStream
 import java.util.zip.ZipFile
 import javax.inject.Inject

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ChaptersSheet.kt

@@ -33,11 +33,13 @@ class ChaptersSheet : BaseAdaptiveSheet<SheetChaptersBinding>(),
 	override fun onCreateViewBinding(
 		inflater: LayoutInflater,
 		container: ViewGroup?,
-	) = SheetChaptersBinding.inflate(inflater, container, false)
+	): SheetChaptersBinding {
+		return SheetChaptersBinding.inflate(inflater, container, false)
+	}
 
 	override fun onViewBindingCreated(binding: SheetChaptersBinding, savedInstanceState: Bundle?) {
 		super.onViewBindingCreated(binding, savedInstanceState)
-		val chapters = viewModel.manga?.allChapters
+		val chapters = viewModel.manga?.chapters
 		if (chapters.isNullOrEmpty()) {
 			dismissAllowingStateLoss()
 			return
@@ -59,7 +61,7 @@ class ChaptersSheet : BaseAdaptiveSheet<SheetChaptersBinding>(),
 				val offset =
 					(resources.getDimensionPixelSize(R.dimen.chapter_list_item_height) * 0.6).roundToInt()
 				adapter.setItems(
-					items, RecyclerViewScrollCallback(binding.recyclerView, targetPosition, offset),
+					items, RecyclerViewScrollCallback(binding.recyclerView, targetPosition, offset)
 				)
 			} else {
 				adapter.items = items

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ReaderActivity.kt

@@ -103,7 +103,7 @@ class ReaderActivity :
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
 		setContentView(ActivityReaderBinding.inflate(layoutInflater))
-		readerManager = ReaderManager(supportFragmentManager, R.id.container)
+		readerManager = ReaderManager(supportFragmentManager, viewBinding.container)
 		supportActionBar?.setDisplayHomeAsUpEnabled(true)
 		touchHelper = GridTouchHelper(this, this)
 		scrollTimer = scrollTimerFactory.create(this, this)
@@ -189,7 +189,7 @@ class ReaderActivity :
 				val state = viewModel.getCurrentState() ?: return false
 				PagesThumbnailsSheet.show(
 					supportFragmentManager,
-					viewModel.manga?.toManga() ?: return false,
+					viewModel.manga?.any ?: return false,
 					state.chapterId,
 					state.page,
 				)

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ReaderManager.kt

@@ -1,10 +1,12 @@
 package org.koitharu.kotatsu.reader.ui
 
-import androidx.annotation.IdRes
+import androidx.fragment.app.FragmentContainerView
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.commit
+import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.prefs.ReaderMode
 import org.koitharu.kotatsu.reader.ui.pager.BaseReaderFragment
+import org.koitharu.kotatsu.reader.ui.pager.doublepage.DoublePageReaderFragment
 import org.koitharu.kotatsu.reader.ui.pager.reversed.ReversedReaderFragment
 import org.koitharu.kotatsu.reader.ui.pager.standard.PagerReaderFragment
 import org.koitharu.kotatsu.reader.ui.pager.webtoon.WebtoonReaderFragment
@@ -12,19 +14,24 @@ import java.util.EnumMap
 
 class ReaderManager(
 	private val fragmentManager: FragmentManager,
-	@IdRes private val containerResId: Int,
+	private val container: FragmentContainerView,
 ) {
 
 	private val modeMap = EnumMap<ReaderMode, Class<out BaseReaderFragment<*>>>(ReaderMode::class.java)
 
 	init {
-		modeMap[ReaderMode.STANDARD] = PagerReaderFragment::class.java
+		val isTablet = container.resources.getBoolean(R.bool.is_tablet)
+		modeMap[ReaderMode.STANDARD] = if (isTablet) {
+			DoublePageReaderFragment::class.java
+		} else {
+			PagerReaderFragment::class.java
+		}
 		modeMap[ReaderMode.REVERSED] = ReversedReaderFragment::class.java
 		modeMap[ReaderMode.WEBTOON] = WebtoonReaderFragment::class.java
 	}
 
 	val currentReader: BaseReaderFragment<*>?
-		get() = fragmentManager.findFragmentById(containerResId) as? BaseReaderFragment<*>
+		get() = fragmentManager.findFragmentById(container.id) as? BaseReaderFragment<*>
 
 	val currentMode: ReaderMode?
 		get() {
@@ -36,14 +43,14 @@ class ReaderManager(
 		val readerClass = requireNotNull(modeMap[newMode])
 		fragmentManager.commit {
 			setReorderingAllowed(true)
-			replace(containerResId, readerClass, null, null)
+			replace(container.id, readerClass, null, null)
 		}
 	}
 
-	fun replace(reader: BaseReaderFragment<*>) {
+	/*fun replace(reader: BaseReaderFragment<*>) {
 		fragmentManager.commit {
 			setReorderingAllowed(true)
 			replace(containerResId, reader)
 		}
-	}
+	}*/
 }

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ReaderViewModel.kt

@@ -44,11 +44,12 @@ import org.koitharu.kotatsu.core.util.ext.call
 import org.koitharu.kotatsu.core.util.ext.ifNullOrEmpty
 import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import org.koitharu.kotatsu.core.util.ext.requireValue
-import org.koitharu.kotatsu.details.data.MangaDetails
+import org.koitharu.kotatsu.details.domain.DoubleMangaLoadUseCase
-import org.koitharu.kotatsu.details.domain.DetailsLoadUseCase
+import org.koitharu.kotatsu.details.domain.model.DoubleManga
 import org.koitharu.kotatsu.history.data.HistoryRepository
 import org.koitharu.kotatsu.history.data.PROGRESS_NONE
 import org.koitharu.kotatsu.history.domain.HistoryUpdateUseCase
+import org.koitharu.kotatsu.parsers.exception.NotFoundException
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.reader.domain.ChaptersLoader
@@ -73,7 +74,7 @@ class ReaderViewModel @Inject constructor(
 	private val pageLoader: PageLoader,
 	private val chaptersLoader: ChaptersLoader,
 	private val appShortcutManager: AppShortcutManager,
-	private val detailsLoadUseCase: DetailsLoadUseCase,
+	private val doubleMangaLoadUseCase: DoubleMangaLoadUseCase,
 	private val historyUpdateUseCase: HistoryUpdateUseCase,
 	private val detectReaderModeUseCase: DetectReaderModeUseCase,
 ) : BaseViewModel() {
@@ -87,9 +88,9 @@ class ReaderViewModel @Inject constructor(
 	private var bookmarkJob: Job? = null
 	private var stateChangeJob: Job? = null
 	private val currentState = MutableStateFlow<ReaderState?>(savedStateHandle[ReaderActivity.EXTRA_STATE])
-	private val mangaData = MutableStateFlow(intent.manga?.let { MangaDetails(it, null, null, false) })
+	private val mangaData = MutableStateFlow(intent.manga?.let { DoubleManga(it) })
 	private val mangaFlow: Flow<Manga?>
-		get() = mangaData.map { it?.toManga() }
+		get() = mangaData.map { it?.any }
 
 	val readerMode = MutableStateFlow<ReaderMode?>(null)
 	val onPageSaved = MutableEventFlow<Uri?>()
@@ -97,7 +98,7 @@ class ReaderViewModel @Inject constructor(
 	val uiState = MutableStateFlow<ReaderUiState?>(null)
 
 	val content = MutableStateFlow(ReaderContent(emptyList(), null))
-	val manga: MangaDetails?
+	val manga: DoubleManga?
 		get() = mangaData.value
 
 	val pageAnimation = settings.observeAsStateFlow(
@@ -147,7 +148,7 @@ class ReaderViewModel @Inject constructor(
 	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Lazily, false)
 
 	val isBookmarkAdded = currentState.flatMapLatest { state ->
-		val manga = mangaData.value?.toManga()
+		val manga = mangaData.value?.any
 		if (state == null || manga == null) {
 			flowOf(false)
 		} else {
@@ -177,7 +178,7 @@ class ReaderViewModel @Inject constructor(
 
 	fun switchMode(newMode: ReaderMode) {
 		launchJob {
-			val manga = checkNotNull(mangaData.value?.toManga())
+			val manga = checkNotNull(mangaData.value?.any)
 			dataRepository.saveReaderMode(
 				manga = manga,
 				mode = newMode,
@@ -198,7 +199,7 @@ class ReaderViewModel @Inject constructor(
 		}
 		val readerState = state ?: currentState.value ?: return
 		historyUpdateUseCase.invokeAsync(
-			manga = mangaData.value?.toManga() ?: return,
+			manga = mangaData.value?.any ?: return,
 			readerState = readerState,
 			percent = computePercent(readerState.chapterId, readerState.page),
 		)
@@ -294,7 +295,7 @@ class ReaderViewModel @Inject constructor(
 			val state = checkNotNull(currentState.value)
 			val page = checkNotNull(getCurrentPage()) { "Page not found" }
 			val bookmark = Bookmark(
-				manga = mangaData.requireValue().toManga(),
+				manga = checkNotNull(mangaData.value?.any),
 				pageId = page.id,
 				chapterId = state.chapterId,
 				page = state.page,
@@ -314,7 +315,7 @@ class ReaderViewModel @Inject constructor(
 		}
 		bookmarkJob = launchJob {
 			loadingJob?.join()
-			val manga = mangaData.requireValue().toManga()
+			val manga = checkNotNull(mangaData.value?.any)
 			val state = checkNotNull(getCurrentState())
 			bookmarksRepository.removeBookmark(manga.id, state.chapterId, state.page)
 			onShowToast.call(R.string.bookmark_removed)
@@ -323,19 +324,25 @@ class ReaderViewModel @Inject constructor(
 
 	private fun loadImpl() {
 		loadingJob = launchLoadingJob(Dispatchers.Default) {
-			val details = detailsLoadUseCase.invoke(intent).first { x -> x.isLoaded }
+			var manga = DoubleManga(
-			mangaData.value = details
+				dataRepository.resolveIntent(intent)
-			chaptersLoader.init(details)
+					?: throw NotFoundException("Cannot find manga", ""),
-			val manga = details.toManga()
+			)
+			mangaData.value = manga
+			val mangaFlow = doubleMangaLoadUseCase(intent)
+			manga = mangaFlow.first { x -> x.any != null }
+			chaptersLoader.init(viewModelScope, mangaFlow.withErrorHandling())
+			// determine mode
+			val singleManga = manga.requireAny()
 			// obtain state
 			if (currentState.value == null) {
-				currentState.value = historyRepository.getOne(manga)?.let {
+				currentState.value = historyRepository.getOne(singleManga)?.let {
 					ReaderState(it)
-				} ?: ReaderState(manga, preselectedBranch)
+				} ?: ReaderState(singleManga, preselectedBranch)
 			}
-			val mode = detectReaderModeUseCase.invoke(manga, currentState.value)
+			val mode = detectReaderModeUseCase.invoke(singleManga, currentState.value)
-			val branch = chaptersLoader.peekChapter(currentState.value?.chapterId ?: 0L)?.branch
+			val branch = chaptersLoader.awaitChapter(currentState.value?.chapterId ?: 0L)?.branch
-			mangaData.value = details.filterChapters(branch)
+			mangaData.value = manga.filterChapters(branch)
 			readerMode.value = mode
 
 			chaptersLoader.loadSingleChapter(requireNotNull(currentState.value).chapterId)
@@ -343,7 +350,7 @@ class ReaderViewModel @Inject constructor(
 			if (!isIncognito) {
 				currentState.value?.let {
 					val percent = computePercent(it.chapterId, it.page)
-					historyUpdateUseCase.invoke(manga, it, percent)
+					historyUpdateUseCase.invoke(singleManga, it, percent)
 				}
 			}
 			notifyStateChanged()
@@ -376,11 +383,11 @@ class ReaderViewModel @Inject constructor(
 		val state = getCurrentState()
 		val chapter = state?.chapterId?.let { chaptersLoader.peekChapter(it) }
 		val newState = ReaderUiState(
-			mangaName = manga?.toManga()?.title,
+			mangaName = manga?.any?.title,
 			branch = chapter?.branch,
 			chapterName = chapter?.name,
 			chapterNumber = chapter?.number ?: 0,
-			chaptersTotal = manga?.chapters?.get(chapter?.branch)?.size ?: 0,
+			chaptersTotal = manga?.any?.getChapters(chapter?.branch)?.size ?: 0,
 			totalPages = if (chapter != null) chaptersLoader.getPagesCount(chapter.id) else 0,
 			currentPage = state?.page ?: 0,
 			isSliderEnabled = settings.isReaderSliderEnabled,
@@ -391,7 +398,7 @@ class ReaderViewModel @Inject constructor(
 
 	private fun computePercent(chapterId: Long, pageIndex: Int): Float {
 		val branch = chaptersLoader.peekChapter(chapterId)?.branch
-		val chapters = manga?.chapters?.get(branch) ?: return PROGRESS_NONE
+		val chapters = manga?.any?.getChapters(branch) ?: return PROGRESS_NONE
 		val chaptersCount = chapters.size
 		val chapterIndex = chapters.indexOfFirst { x -> x.id == chapterId }
 		val pagesCount = chaptersLoader.getPagesCount(chapterId)

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/colorfilter/ColorFilterConfigActivity.kt

@@ -3,7 +3,6 @@ package org.koitharu.kotatsu.reader.ui.colorfilter
 import android.content.Context
 import android.content.Intent
 import android.content.res.Resources
-import android.graphics.Bitmap
 import android.os.Bundle
 import android.view.View
 import android.view.ViewGroup
@@ -122,10 +121,10 @@ class ColorFilterConfigActivity :
 			.scale(Scale.FILL)
 			.decodeRegion()
 			.tag(page.source)
-			.bitmapConfig(if (viewModel.is32BitColorsEnabled) Bitmap.Config.ARGB_8888 else Bitmap.Config.RGB_565)
 			.indicator(listOf(viewBinding.progressBefore, viewBinding.progressAfter))
 			.error(R.drawable.ic_error_placeholder)
 			.size(ViewSizeResolver(viewBinding.imageViewBefore))
+			.allowRgb565(false)
 			.target(DoubleViewTarget(viewBinding.imageViewBefore, viewBinding.imageViewAfter))
 			.enqueueWith(coil)
 	}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/colorfilter/ColorFilterConfigViewModel.kt

@@ -7,7 +7,6 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableMangaPage
 import org.koitharu.kotatsu.core.parser.MangaDataRepository
-import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.ui.BaseViewModel
 import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
 import org.koitharu.kotatsu.core.util.ext.call
@@ -19,7 +18,6 @@ import javax.inject.Inject
 @HiltViewModel
 class ColorFilterConfigViewModel @Inject constructor(
 	savedStateHandle: SavedStateHandle,
-	private val settings: AppSettings,
 	private val mangaDataRepository: MangaDataRepository,
 ) : BaseViewModel() {
 
@@ -33,9 +31,6 @@ class ColorFilterConfigViewModel @Inject constructor(
 	val isChanged: Boolean
 		get() = colorFilter.value != initialColorFilter
 
-	val is32BitColorsEnabled: Boolean
-		get() = settings.is32BitColorsEnabled
-
 	init {
 		launchLoadingJob {
 			initialColorFilter = mangaDataRepository.getColorFilter(manga.id)

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/config/ReaderConfigSheet.kt

@@ -118,7 +118,7 @@ class ReaderConfigSheet :
 
 			R.id.button_color_filter -> {
 				val page = viewModel.getCurrentPage() ?: return
-				val manga = viewModel.manga?.toManga() ?: return
+				val manga = viewModel.manga?.any ?: return
 				startActivity(ColorFilterConfigActivity.newIntent(v.context, manga, page))
 			}
 		}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/config/ReaderSettings.kt

@@ -1,14 +1,8 @@
 package org.koitharu.kotatsu.reader.ui.config
 
 import android.content.SharedPreferences
-import android.graphics.Bitmap
 import android.view.View
-import androidx.annotation.CheckResult
 import androidx.lifecycle.MediatorLiveData
-import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
-import com.davemorrissey.labs.subscaleview.decoder.SkiaImageDecoder
-import com.davemorrissey.labs.subscaleview.decoder.SkiaImageRegionDecoder
-import com.davemorrissey.labs.subscaleview.decoder.SkiaPooledImageRegionDecoder
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -18,7 +12,6 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.core.model.ZoomMode
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.util.ext.isLowRamDevice
 import org.koitharu.kotatsu.reader.domain.ReaderColorFilter
 
 class ReaderSettings(
@@ -36,13 +29,6 @@ class ReaderSettings(
 	val colorFilter: ReaderColorFilter?
 		get() = colorFilterFlow.value?.takeUnless { it.isEmpty }
 
-	val bitmapConfig: Bitmap.Config
-		get() = if (settings.is32BitColorsEnabled) {
-			Bitmap.Config.ARGB_8888
-		} else {
-			Bitmap.Config.RGB_565
-		}
-
 	val isPagesNumbersEnabled: Boolean
 		get() = settings.isPagesNumbersEnabled
 
@@ -54,22 +40,6 @@ class ReaderSettings(
 		view.background = bg.resolve(view.context)
 	}
 
-	@CheckResult
-	fun applyBitmapConfig(ssiv: SubsamplingScaleImageView): Boolean {
-		val config = bitmapConfig
-		return if (ssiv.regionDecoderFactory.bitmapConfig != config) {
-			ssiv.regionDecoderFactory = if (ssiv.context.isLowRamDevice()) {
-				SkiaImageRegionDecoder.Factory(config)
-			} else {
-				SkiaPooledImageRegionDecoder.Factory(config)
-			}
-			ssiv.bitmapDecoderFactory = SkiaImageDecoder.Factory(config)
-			true
-		} else {
-			false
-		}
-	}
-
 	override fun onInactive() {
 		super.onInactive()
 		settings.unsubscribe(internalObserver)
@@ -108,8 +78,7 @@ class ReaderSettings(
 				key == AppSettings.KEY_PAGES_NUMBERS ||
 				key == AppSettings.KEY_WEBTOON_ZOOM ||
 				key == AppSettings.KEY_READER_ZOOM_BUTTONS ||
-				key == AppSettings.KEY_READER_BACKGROUND ||
+				key == AppSettings.KEY_READER_BACKGROUND
-				key == AppSettings.KEY_32BIT_COLOR
 			) {
 				notifyChanged()
 			}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/PageHolderDelegate.kt

@@ -84,14 +84,6 @@ class PageHolderDelegate(
 		job?.cancel()
 	}
 
-	fun reload() {
-		if (state == State.SHOWN ) {
-			file?.let {
-				callback.onImageReady(it.toUri())
-			}
-		}
-	}
-
 	override fun onReady() {
 		state = State.SHOWING
 		error = null

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/doublepage/DoublePageHolder.kt

@@ -0,0 +1,48 @@
+package org.koitharu.kotatsu.reader.ui.pager.doublepage
+
+import android.graphics.PointF
+import android.view.Gravity
+import android.widget.FrameLayout
+import androidx.lifecycle.LifecycleOwner
+import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
+import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
+import org.koitharu.kotatsu.core.os.NetworkState
+import org.koitharu.kotatsu.databinding.ItemPageBinding
+import org.koitharu.kotatsu.reader.domain.PageLoader
+import org.koitharu.kotatsu.reader.ui.config.ReaderSettings
+import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
+import org.koitharu.kotatsu.reader.ui.pager.standard.PageHolder
+
+class DoublePageHolder(
+	owner: LifecycleOwner,
+	binding: ItemPageBinding,
+	loader: PageLoader,
+	settings: ReaderSettings,
+	networkState: NetworkState,
+	exceptionResolver: ExceptionResolver,
+) : PageHolder(owner, binding, loader, settings, networkState, exceptionResolver) {
+
+	private val isEven: Boolean
+		get() = bindingAdapterPosition and 1 == 0
+
+	override fun onBind(data: ReaderPage) {
+		super.onBind(data)
+		(binding.textViewNumber.layoutParams as FrameLayout.LayoutParams)
+			.gravity = (if (isEven) Gravity.START else Gravity.END) or Gravity.BOTTOM
+	}
+
+	override fun onImageShowing(settings: ReaderSettings) {
+		with(binding.ssiv) {
+			maxScale = 2f * maxOf(
+				width / sWidth.toFloat(),
+				height / sHeight.toFloat(),
+			)
+			binding.ssiv.colorFilter = settings.colorFilter?.toColorFilter()
+			minimumScaleType = SubsamplingScaleImageView.SCALE_TYPE_CENTER_INSIDE
+			setScaleAndCenter(
+				minScale,
+				PointF(if (isEven) sWidth.toFloat() else 0f, 0f),
+			)
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/doublepage/DoublePageLayoutManager.kt

@@ -0,0 +1,19 @@
+package org.koitharu.kotatsu.reader.ui.pager.doublepage
+
+import android.content.Context
+import android.util.AttributeSet
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+
+class DoublePageLayoutManager(
+	context: Context,
+	attrs: AttributeSet?,
+	defStyleAttr: Int,
+	defStyleRes: Int,
+) : LinearLayoutManager(context, attrs, defStyleAttr, defStyleRes) {
+
+	override fun checkLayoutParams(lp: RecyclerView.LayoutParams?): Boolean {
+		lp?.width = width / 2
+		return super.checkLayoutParams(lp)
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/doublepage/DoublePageReaderFragment.kt

@@ -0,0 +1,128 @@
+package org.koitharu.kotatsu.reader.ui.pager.doublepage
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.google.android.material.snackbar.Snackbar
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.yield
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.os.NetworkState
+import org.koitharu.kotatsu.core.util.ext.firstVisibleItemPosition
+import org.koitharu.kotatsu.databinding.FragmentReaderDoubleBinding
+import org.koitharu.kotatsu.parsers.util.toIntUp
+import org.koitharu.kotatsu.reader.domain.PageLoader
+import org.koitharu.kotatsu.reader.ui.ReaderState
+import org.koitharu.kotatsu.reader.ui.pager.BaseReaderAdapter
+import org.koitharu.kotatsu.reader.ui.pager.BaseReaderFragment
+import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
+import javax.inject.Inject
+import kotlin.math.absoluteValue
+
+@AndroidEntryPoint
+class DoublePageReaderFragment : BaseReaderFragment<FragmentReaderDoubleBinding>() {
+
+	@Inject
+	lateinit var networkState: NetworkState
+
+	@Inject
+	lateinit var pageLoader: PageLoader
+
+	override fun onCreateViewBinding(
+		inflater: LayoutInflater,
+		container: ViewGroup?,
+	) = FragmentReaderDoubleBinding.inflate(inflater, container, false)
+
+	override fun onViewBindingCreated(
+		binding: FragmentReaderDoubleBinding,
+		savedInstanceState: Bundle?,
+	) {
+		super.onViewBindingCreated(binding, savedInstanceState)
+		with(binding.recyclerView) {
+			adapter = readerAdapter
+			addOnScrollListener(PageScrollListener())
+			DoublePageSnapHelper().attachToRecyclerView(this)
+		}
+	}
+
+	override fun onDestroyView() {
+		requireViewBinding().recyclerView.adapter = null
+		super.onDestroyView()
+	}
+
+	override suspend fun onPagesChanged(pages: List<ReaderPage>, pendingState: ReaderState?) =
+		coroutineScope {
+			val items = async {
+				requireAdapter().setItems(pages)
+				yield()
+			}
+			if (pendingState != null) {
+				val position = pages.indexOfFirst {
+					it.chapterId == pendingState.chapterId && it.index == pendingState.page
+				}
+				items.await()
+				if (position != -1) {
+					requireViewBinding().recyclerView.firstVisibleItemPosition = position or 1
+					notifyPageChanged(position)
+				} else {
+					Snackbar.make(requireView(), R.string.not_found_404, Snackbar.LENGTH_SHORT)
+						.show()
+				}
+			} else {
+				items.await()
+			}
+		}
+
+	override fun onCreateAdapter() = DoublePagesAdapter(
+		lifecycleOwner = viewLifecycleOwner,
+		loader = pageLoader,
+		settings = viewModel.readerSettings,
+		networkState = networkState,
+		exceptionResolver = exceptionResolver,
+	)
+
+	override fun switchPageBy(delta: Int) {
+		switchPageTo((requireViewBinding().recyclerView.currentItem() + delta) or 1, delta.absoluteValue > 1)
+	}
+
+	override fun switchPageTo(position: Int, smooth: Boolean) {
+		requireViewBinding().recyclerView.firstVisibleItemPosition = position or 1
+	}
+
+	override fun getCurrentState(): ReaderState? = viewBinding?.run {
+		val adapter = recyclerView.adapter as? BaseReaderAdapter<*>
+		val page = adapter?.getItemOrNull(recyclerView.currentItem()) ?: return@run null
+		ReaderState(
+			chapterId = page.chapterId,
+			page = page.index,
+			scroll = 0,
+		)
+	}
+
+	private fun notifyPageChanged(page: Int) {
+		viewModel.onCurrentPageChanged(page)
+	}
+
+	private fun RecyclerView.currentItem(): Int {
+		val lm = layoutManager as LinearLayoutManager
+		return ((lm.findFirstVisibleItemPosition() + lm.findLastVisibleItemPosition()) / 2f).toIntUp()
+	}
+
+	private inner class PageScrollListener : RecyclerView.OnScrollListener() {
+
+		private var lastPage = RecyclerView.NO_POSITION
+
+		override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+			super.onScrolled(recyclerView, dx, dy)
+			val page = recyclerView.currentItem()
+			if (page != lastPage) {
+				lastPage = page
+				notifyPageChanged(page)
+			}
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/doublepage/DoublePageSnapHelper.kt

@@ -0,0 +1,280 @@
+package org.koitharu.kotatsu.reader.ui.pager.doublepage
+
+import android.util.DisplayMetrics
+import android.view.View
+import android.view.animation.Interpolator
+import android.widget.Scroller
+import androidx.core.view.ViewCompat
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.LinearSmoothScroller
+import androidx.recyclerview.widget.OrientationHelper
+import androidx.recyclerview.widget.RecyclerView
+import androidx.recyclerview.widget.RecyclerView.SmoothScroller.ScrollVectorProvider
+import androidx.recyclerview.widget.SnapHelper
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.roundToInt
+
+class DoublePageSnapHelper : SnapHelper() {
+
+	private lateinit var recyclerView: RecyclerView
+
+	// Total number of items in a block of view in the RecyclerView
+	private var blockSize = 2
+
+	// Maximum number of positions to move on a fling.
+	private var maxPositionsToMove = 0
+
+	// Width of a RecyclerView item if orientation is horizontal; height of the item if vertical
+	private var itemDimension = 0
+
+	// Maxim blocks to move during most vigorous fling.
+	private val maxFlingBlocks = 2
+
+	// When snapping, used to determine direction of snap.
+	private var priorFirstPosition = RecyclerView.NO_POSITION
+
+	// Our private scroller
+	private var scroller: Scroller? = null
+
+	// Horizontal/vertical layout helper
+	private lateinit var orientationHelper: OrientationHelper
+
+	// LTR/RTL helper
+	private lateinit var layoutDirectionHelper: LayoutDirectionHelper
+
+	private val snapInterpolator = Interpolator { input ->
+		var t = input
+		t -= 1.0f
+		t * t * t + 1.0f
+	}
+
+	@Throws(IllegalStateException::class)
+	override fun attachToRecyclerView(target: RecyclerView?) {
+		if (target != null) {
+			recyclerView = target
+			val layoutManager = recyclerView.layoutManager as LinearLayoutManager
+			check(layoutManager.canScrollHorizontally()) { "RecyclerView must be scrollable" }
+			orientationHelper = OrientationHelper.createHorizontalHelper(layoutManager)
+			layoutDirectionHelper = LayoutDirectionHelper(ViewCompat.getLayoutDirection(recyclerView))
+			scroller = Scroller(target.context, snapInterpolator)
+			initItemDimensionIfNeeded(layoutManager)
+		}
+		super.attachToRecyclerView(recyclerView)
+	}
+
+	override fun calculateDistanceToFinalSnap(
+		layoutManager: RecyclerView.LayoutManager,
+		targetView: View
+	): IntArray {
+		val out = IntArray(2)
+		if (layoutManager.canScrollHorizontally()) {
+			out[0] = layoutDirectionHelper.getScrollToAlignView(targetView)
+		}
+		if (layoutManager.canScrollVertically()) {
+			out[1] = layoutDirectionHelper.getScrollToAlignView(targetView)
+		}
+		return out
+	}
+
+	// We are flinging and need to know where we are heading.
+	override fun findTargetSnapPosition(
+		layoutManager: RecyclerView.LayoutManager,
+		velocityX: Int, velocityY: Int
+	): Int {
+		val lm = layoutManager as LinearLayoutManager
+		initItemDimensionIfNeeded(layoutManager)
+		scroller!!.fling(0, 0, velocityX, velocityY, Int.MIN_VALUE, Int.MAX_VALUE, Int.MIN_VALUE, Int.MAX_VALUE)
+		if (velocityX != 0) {
+			return layoutDirectionHelper
+				.getPositionsToMove(lm, scroller!!.finalX, itemDimension)
+		}
+		return if (velocityY != 0) {
+			layoutDirectionHelper
+				.getPositionsToMove(lm, scroller!!.finalY, itemDimension)
+		} else RecyclerView.NO_POSITION
+	}
+
+	// We have scrolled to the neighborhood where we will snap. Determine the snap position.
+	override fun findSnapView(layoutManager: RecyclerView.LayoutManager): View? {
+		// Snap to a view that is either 1) toward the bottom of the data and therefore on screen,
+		// or, 2) toward the top of the data and may be off-screen.
+		val snapPos: Int = calcTargetPosition(layoutManager as LinearLayoutManager)
+		return if (snapPos == RecyclerView.NO_POSITION) null else layoutManager.findViewByPosition(snapPos)
+	}
+
+	// Does the heavy lifting for findSnapView.
+	private fun calcTargetPosition(layoutManager: LinearLayoutManager): Int {
+		val snapPos: Int
+		val firstVisiblePos = layoutManager.findFirstVisibleItemPosition()
+		if (firstVisiblePos == RecyclerView.NO_POSITION) {
+			return RecyclerView.NO_POSITION
+		}
+		initItemDimensionIfNeeded(layoutManager)
+		if (firstVisiblePos >= priorFirstPosition) {
+			// Scrolling toward bottom of data
+			val firstCompletePosition = layoutManager.findFirstCompletelyVisibleItemPosition()
+			snapPos = if (firstCompletePosition != RecyclerView.NO_POSITION
+				&& firstCompletePosition % blockSize == 0
+			) {
+				firstCompletePosition
+			} else {
+				roundDownToBlockSize(firstVisiblePos + blockSize)
+			}
+		} else {
+			// Scrolling toward top of data
+			snapPos = roundDownToBlockSize(firstVisiblePos)
+			// Check to see if target view exists. If it doesn't, force a smooth scroll.
+			// SnapHelper only snaps to existing views and will not scroll to a non-existent one.
+			// If limiting fling to single block, then the following is not needed since the
+			// views are likely to be in the RecyclerView pool.
+			if (layoutManager.findViewByPosition(snapPos) == null) {
+				val toScroll: IntArray = layoutDirectionHelper.calculateDistanceToScroll(layoutManager, snapPos)
+				recyclerView.smoothScrollBy(toScroll[0], toScroll[1], snapInterpolator)
+			}
+		}
+		priorFirstPosition = firstVisiblePos
+		return snapPos
+	}
+
+	private fun initItemDimensionIfNeeded(layoutManager: RecyclerView.LayoutManager) {
+		if (itemDimension != 0) {
+			return
+		}
+		val child: View = layoutManager.getChildAt(0) ?: return
+		if (layoutManager.canScrollHorizontally()) {
+			itemDimension = child.width
+			blockSize = getSpanCount(layoutManager) * (recyclerView.width / itemDimension)
+		} else if (layoutManager.canScrollVertically()) {
+			itemDimension = child.height
+			blockSize = getSpanCount(layoutManager) * (recyclerView.height / itemDimension)
+		}
+		maxPositionsToMove = blockSize * maxFlingBlocks
+	}
+
+	private fun getSpanCount(layoutManager: RecyclerView.LayoutManager): Int {
+		return if (layoutManager is GridLayoutManager) layoutManager.spanCount else 1
+	}
+
+	private fun roundDownToBlockSize(trialPosition: Int): Int {
+		return trialPosition - trialPosition % blockSize
+	}
+
+	private fun roundUpToBlockSize(trialPosition: Int): Int {
+		return roundDownToBlockSize(trialPosition + blockSize - 1)
+	}
+
+	override fun createScroller(layoutManager: RecyclerView.LayoutManager): RecyclerView.SmoothScroller? {
+		return if (layoutManager !is ScrollVectorProvider) {
+			null
+		} else object : LinearSmoothScroller(recyclerView.context) {
+			override fun onTargetFound(targetView: View, state: RecyclerView.State, action: Action) {
+				val snapDistances = calculateDistanceToFinalSnap(
+					recyclerView.layoutManager!!,
+					targetView,
+				)
+				val dx = snapDistances[0]
+				val dy = snapDistances[1]
+				val time = calculateTimeForDeceleration(
+					max(abs(dx.toDouble()), abs(dy.toDouble()))
+						.toInt(),
+				)
+				if (time > 0) {
+					action.update(dx, dy, time, snapInterpolator)
+				}
+			}
+
+			override fun calculateSpeedPerPixel(displayMetrics: DisplayMetrics): Float {
+				return 40f / displayMetrics.densityDpi
+			}
+		}
+	}
+
+	/*
+		Helper class that handles calculations for LTR and RTL layouts.
+	 */
+	private inner class LayoutDirectionHelper(direction: Int) {
+
+		// Is the layout an RTL one?
+		private val mIsRTL: Boolean
+
+		init {
+			mIsRTL = direction == View.LAYOUT_DIRECTION_RTL
+		}
+
+		/*
+			Calculate the amount of scroll needed to align the target view with the layout edge.
+		 */
+		fun getScrollToAlignView(targetView: View?): Int {
+			return if (mIsRTL) orientationHelper.getDecoratedEnd(targetView) - recyclerView.width else orientationHelper.getDecoratedStart(
+				targetView,
+			)
+		}
+
+		/**
+		 * Calculate the distance to final snap position when the view corresponding to the snap
+		 * position is not currently available.
+		 *
+		 * @param layoutManager LinearLayoutManager or descendant class
+		 * @param targetPos     - Adapter position to snap to
+		 * @return int[2] {x-distance in pixels, y-distance in pixels}
+		 */
+		fun calculateDistanceToScroll(layoutManager: LinearLayoutManager, targetPos: Int): IntArray {
+			val out = IntArray(2)
+			val firstVisiblePos = layoutManager.findFirstVisibleItemPosition()
+			if (layoutManager.canScrollHorizontally()) {
+				if (targetPos <= firstVisiblePos) { // scrolling toward top of data
+					if (mIsRTL) {
+						val lastView = layoutManager.findViewByPosition(layoutManager.findLastVisibleItemPosition())
+						out[0] = (orientationHelper.getDecoratedEnd(lastView)
+							+ (firstVisiblePos - targetPos) * itemDimension)
+					} else {
+						val firstView = layoutManager.findViewByPosition(firstVisiblePos)
+						out[0] = (orientationHelper.getDecoratedStart(firstView)
+							- (firstVisiblePos - targetPos) * itemDimension)
+					}
+				}
+			}
+			if (layoutManager.canScrollVertically()) {
+				if (targetPos <= firstVisiblePos) { // scrolling toward top of data
+					val firstView = layoutManager.findViewByPosition(firstVisiblePos)
+					out[1] = firstView!!.top - (firstVisiblePos - targetPos) * itemDimension
+				}
+			}
+			return out
+		}
+
+		/*
+			Calculate the number of positions to move in the RecyclerView given a scroll amount
+			and the size of the items to be scrolled. Return integral multiple of mBlockSize not
+			equal to zero.
+		 */
+		fun getPositionsToMove(llm: LinearLayoutManager, scroll: Int, itemSize: Int): Int {
+			var positionsToMove: Int
+			positionsToMove = roundUpToBlockSize(abs((scroll.toDouble()) / itemSize).roundToInt())
+			if (positionsToMove < blockSize) {
+				// Must move at least one block
+				positionsToMove = blockSize
+			} else if (positionsToMove > maxPositionsToMove) {
+				// Clamp number of positions to move, so we don't get wild flinging.
+				positionsToMove = maxPositionsToMove
+			}
+			if (scroll < 0) {
+				positionsToMove *= -1
+			}
+			if (mIsRTL) {
+				positionsToMove *= -1
+			}
+			return if (layoutDirectionHelper.isDirectionToBottom(scroll < 0)) {
+				// Scrolling toward the bottom of data.
+				roundDownToBlockSize(llm.findFirstVisibleItemPosition()) + positionsToMove
+			} else roundDownToBlockSize(llm.findLastVisibleItemPosition()) + positionsToMove
+			// Scrolling toward the top of the data.
+		}
+
+		fun isDirectionToBottom(velocityNegative: Boolean): Boolean {
+			return if (mIsRTL) velocityNegative else !velocityNegative
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/doublepage/DoublePagesAdapter.kt

@@ -0,0 +1,35 @@
+package org.koitharu.kotatsu.reader.ui.pager.doublepage
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.lifecycle.LifecycleOwner
+import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
+import org.koitharu.kotatsu.core.os.NetworkState
+import org.koitharu.kotatsu.databinding.ItemPageBinding
+import org.koitharu.kotatsu.reader.domain.PageLoader
+import org.koitharu.kotatsu.reader.ui.config.ReaderSettings
+import org.koitharu.kotatsu.reader.ui.pager.BaseReaderAdapter
+
+class DoublePagesAdapter(
+	private val lifecycleOwner: LifecycleOwner,
+	loader: PageLoader,
+	settings: ReaderSettings,
+	networkState: NetworkState,
+	exceptionResolver: ExceptionResolver,
+) : BaseReaderAdapter<DoublePageHolder>(loader, settings, networkState, exceptionResolver) {
+
+	override fun onCreateViewHolder(
+		parent: ViewGroup,
+		loader: PageLoader,
+		settings: ReaderSettings,
+		networkState: NetworkState,
+		exceptionResolver: ExceptionResolver,
+	) = DoublePageHolder(
+		owner = lifecycleOwner,
+		binding = ItemPageBinding.inflate(LayoutInflater.from(parent.context), parent, false),
+		loader = loader,
+		settings = settings,
+		networkState = networkState,
+		exceptionResolver = exceptionResolver,
+	)
+}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/standard/PageHolder.kt

@@ -46,10 +46,6 @@ open class PageHolder(
 	override fun onConfigChanged() {
 		super.onConfigChanged()
 		binding.zoomControl.isVisible = settings.isZoomControlsEnabled
-		@Suppress("SENSELESS_COMPARISON")
-		if (settings.applyBitmapConfig(binding.ssiv) && delegate != null) {
-			delegate.reload()
-		}
 	}
 
 	@SuppressLint("SetTextI18n")

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/webtoon/WebtoonHolder.kt

@@ -6,6 +6,7 @@ import androidx.core.view.isVisible
 import androidx.lifecycle.LifecycleOwner
 import com.davemorrissey.labs.subscaleview.ImageSource
 import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
+import com.davemorrissey.labs.subscaleview.decoder.SkiaPooledImageRegionDecoder
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.os.NetworkState
@@ -33,19 +34,12 @@ class WebtoonHolder(
 
 	init {
 		binding.ssiv.bindToLifecycle(owner)
+		binding.ssiv.regionDecoderFactory = SkiaPooledImageRegionDecoder.Factory()
 		binding.ssiv.addOnImageEventListener(delegate)
 		bindingInfo.buttonRetry.setOnClickListener(this)
 		bindingInfo.buttonErrorDetails.setOnClickListener(this)
 	}
 
-	override fun onConfigChanged() {
-		super.onConfigChanged()
-		@Suppress("SENSELESS_COMPARISON")
-		if (settings.applyBitmapConfig(binding.ssiv) && delegate != null) {
-			delegate.reload()
-		}
-	}
-
 	override fun onBind(data: ReaderPage) {
 		delegate.onBind(data.toMangaPage())
 	}

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/thumbnails/PagesThumbnailsViewModel.kt

@@ -7,17 +7,17 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import org.koitharu.kotatsu.core.model.findById
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
-import org.koitharu.kotatsu.core.parser.MangaIntent
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.ui.BaseViewModel
 import org.koitharu.kotatsu.core.util.ext.firstNotNull
 import org.koitharu.kotatsu.core.util.ext.require
-import org.koitharu.kotatsu.details.domain.DetailsLoadUseCase
+import org.koitharu.kotatsu.details.domain.DoubleMangaLoadUseCase
 import org.koitharu.kotatsu.list.ui.model.ListHeader
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.reader.domain.ChaptersLoader
@@ -28,7 +28,7 @@ class PagesThumbnailsViewModel @Inject constructor(
 	savedStateHandle: SavedStateHandle,
 	mangaRepositoryFactory: MangaRepository.Factory,
 	private val chaptersLoader: ChaptersLoader,
-	detailsLoadUseCase: DetailsLoadUseCase,
+	doubleMangaLoadUseCase: DoubleMangaLoadUseCase,
 ) : BaseViewModel() {
 
 	private val currentPageIndex: Int =
@@ -37,7 +37,7 @@ class PagesThumbnailsViewModel @Inject constructor(
 	val manga = savedStateHandle.require<ParcelableManga>(PagesThumbnailsSheet.ARG_MANGA).manga
 
 	private val repository = mangaRepositoryFactory.create(manga.source)
-	private val mangaDetails = detailsLoadUseCase(MangaIntent.of(manga)).map {
+	private val mangaDetails = doubleMangaLoadUseCase(manga).map {
 		val b = manga.chapters?.findById(initialChapterId)?.branch
 		branch.value = b
 		it.filterChapters(b)
@@ -52,7 +52,8 @@ class PagesThumbnailsViewModel @Inject constructor(
 
 	init {
 		loadingJob = launchLoadingJob(Dispatchers.Default) {
-			chaptersLoader.init(checkNotNull(mangaDetails.first { x -> x?.isLoaded == true }))
+			chaptersLoader.init(viewModelScope, mangaDetails.filterNotNull())
+			mangaDetails.first { x -> x?.hasChapter(initialChapterId) == true }
 			chaptersLoader.loadSingleChapter(initialChapterId)
 			updateList()
 		}
@@ -78,13 +79,13 @@ class PagesThumbnailsViewModel @Inject constructor(
 		updateList()
 	}
 
-	private fun updateList() {
+	private suspend fun updateList() {
 		val snapshot = chaptersLoader.snapshot()
 		val pages = buildList(snapshot.size + chaptersLoader.size + 2) {
 			var previousChapterId = 0L
 			for (page in snapshot) {
 				if (page.chapterId != previousChapterId) {
-					chaptersLoader.peekChapter(page.chapterId)?.let {
+					chaptersLoader.awaitChapter(page.chapterId)?.let {
 						add(ListHeader(it.name))
 					}
 					previousChapterId = page.chapterId

app/src/main/kotlin/org/koitharu/kotatsu/remotelist/ui/RemoteListViewModel.kt

@@ -18,7 +18,6 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.model.distinctById
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
@@ -68,7 +67,7 @@ open class RemoteListViewModel @Inject constructor(
 	private var randomJob: Job? = null
 
 	override val content = combine(
-		mangaList.map { it?.distinctById()?.skipNsfwIfNeeded() },
+		mangaList.map { it?.skipNsfwIfNeeded() },
 		listMode,
 		listError,
 		hasNextPage,
@@ -139,7 +138,7 @@ open class RemoteListViewModel @Inject constructor(
 				} else if (list.isNotEmpty()) {
 					mangaList.value = mangaList.value?.plus(list) ?: list
 				}
-				hasNextPage.value = list.isNotEmpty() // TODO check if new ids added
+				hasNextPage.value = list.isNotEmpty()
 			} catch (e: CancellationException) {
 				throw e
 			} catch (e: Throwable) {

app/src/main/kotlin/org/koitharu/kotatsu/suggestions/ui/SuggestionsViewModel.kt

@@ -11,7 +11,6 @@ import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.observeAsFlow
 import org.koitharu.kotatsu.core.util.ext.onFirst
 import org.koitharu.kotatsu.download.ui.worker.DownloadWorker
 import org.koitharu.kotatsu.list.domain.ListExtraProvider
@@ -32,9 +31,6 @@ class SuggestionsViewModel @Inject constructor(
 	private val suggestionsScheduler: SuggestionsWorker.Scheduler,
 ) : MangaListViewModel(settings, downloadScheduler) {
 
-	override val listMode = settings.observeAsFlow(AppSettings.KEY_LIST_MODE_SUGGESTIONS) { suggestionsListMode }
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, settings.suggestionsListMode)
-
 	override val content = combine(
 		repository.observeAll(),
 		listMode,

app/src/main/res/color-v23/dim_statusbar.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+	<item android:alpha="0.6" android:color="?android:colorBackground" />
+</selector>

app/src/main/res/color/dim_statusbar.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+	<item android:alpha="0.6" android:color="@android:color/black" />
+</selector>

app/src/main/res/color/navigation_bar_scrim.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
-	<item android:alpha="0.7" android:color="?attr/m3ColorBottomMenuBackground" />
+	<item android:alpha="0.7" android:color="?attr/m3ColorBackground" />
 </selector>

app/src/main/res/drawable-v23/toolbar_background.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+	<!-- Fills the entire area with the divider's color first... -->
+	<item>
+		<shape
+			android:shape="rectangle">
+			<solid android:color="?attr/colorOutline"/>
+		</shape>
+	</item>
+	<!-- ..., then draws a rectangle with the container color to cover the area not for the divider. -->
+	<item
+		android:bottom="1dp">
+		<shape
+			android:shape="rectangle">
+			<solid android:color="?attr/m3ColorBackground"/>
+		</shape>
+	</item>
+</layer-list>

app/src/main/res/drawable/ic_list_group.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector
-	xmlns:android="http://schemas.android.com/apk/res/android"
-	android:width="24dp"
-	android:height="24dp"
-	android:tint="?colorControlNormal"
-	android:viewportWidth="24"
-	android:viewportHeight="24">
-	<path
-		android:fillColor="#000000"
-		android:pathData="M5 5V19H7V21H3V3H7V5H5M20 7H7V9H20V7M20 11H7V13H20V11M20 15H7V17H20V15Z" />
-</vector>

app/src/main/res/drawable/toolbar_background.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+	<!-- Fills the entire area with the divider's color first... -->
+	<item>
+		<shape
+			android:shape="rectangle">
+			<solid android:color="@color/kotatsu_primaryContainer"/>
+		</shape>
+	</item>
+	<!-- ..., then draws a rectangle with the container color to cover the area not for the divider. -->
+	<item
+		android:bottom="1dp">
+		<shape
+			android:shape="rectangle">
+			<solid android:color="@color/kotatsu_m3_background"/>
+		</shape>
+	</item>
+</layer-list>

app/src/main/res/layout/activity_details.xml

@@ -21,6 +21,7 @@
 			android:id="@id/toolbar"
 			android:layout_width="match_parent"
 			android:layout_height="?attr/actionBarSize"
+			android:background="@drawable/toolbar_background"
 			android:theme="?attr/actionBarTheme"
 			app:layout_scrollFlags="noScroll"
 			tools:ignore="PrivateResource" />

app/src/main/res/layout/dialog_list_mode.xml

@@ -12,13 +12,11 @@
 		android:id="@+id/headerBar"
 		android:layout_width="match_parent"
 		android:layout_height="wrap_content"
-		app:title="@string/list_options" />
+		app:title="@string/options" />
 
 	<androidx.core.widget.NestedScrollView
 		android:layout_width="match_parent"
-		android:layout_height="wrap_content"
+		android:layout_height="wrap_content">
-		android:scrollIndicators="top"
-		android:scrollbars="vertical">
 
 		<LinearLayout
 			android:layout_width="match_parent"
@@ -99,56 +97,6 @@
 				tools:value="100"
 				tools:visibility="visible" />
 
-			<TextView
-				android:id="@+id/textView_order_title"
-				android:layout_width="match_parent"
-				android:layout_height="wrap_content"
-				android:layout_marginHorizontal="@dimen/margin_normal"
-				android:layout_marginTop="@dimen/margin_normal"
-				android:singleLine="true"
-				android:text="@string/sort_order"
-				android:textAppearance="?textAppearanceTitleSmall"
-				android:visibility="gone"
-				tools:visibility="visible" />
-
-			<com.google.android.material.card.MaterialCardView
-				android:id="@+id/card_order"
-				style="?materialCardViewOutlinedStyle"
-				android:layout_width="match_parent"
-				android:layout_height="wrap_content"
-				android:layout_marginHorizontal="16dp"
-				android:layout_marginTop="@dimen/margin_normal"
-				android:visibility="gone"
-				app:shapeAppearance="?shapeAppearanceCornerMedium"
-				app:strokeColor="@color/m3_button_outline_color_selector"
-				app:strokeWidth="@dimen/m3_comp_outlined_button_outline_width"
-				tools:visibility="visible">
-
-				<Spinner
-					android:id="@+id/spinner_order"
-					android:layout_width="match_parent"
-					android:layout_height="wrap_content"
-					android:minHeight="?listPreferredItemHeightSmall" />
-
-			</com.google.android.material.card.MaterialCardView>
-
-			<com.google.android.material.materialswitch.MaterialSwitch
-				android:id="@+id/switch_grouping"
-				android:layout_width="match_parent"
-				android:layout_height="?android:listPreferredItemHeightSmall"
-				android:layout_marginTop="@dimen/margin_normal"
-				android:drawablePadding="?android:listPreferredItemPaddingStart"
-				android:ellipsize="end"
-				android:paddingStart="?android:listPreferredItemPaddingStart"
-				android:paddingEnd="?android:listPreferredItemPaddingEnd"
-				android:singleLine="true"
-				android:text="@string/group"
-				android:textAppearance="?attr/textAppearanceButton"
-				android:textColor="?colorOnSurfaceVariant"
-				android:visibility="gone"
-				app:drawableStartCompat="@drawable/ic_list_group"
-				tools:visibility="visible" />
-
 		</LinearLayout>
 	</androidx.core.widget.NestedScrollView>
 </LinearLayout>

app/src/main/res/layout/fragment_details.xml

@@ -7,7 +7,6 @@
 	android:layout_width="match_parent"
 	android:layout_height="match_parent"
 	android:clipToPadding="false"
-	android:scrollIndicators="top"
 	android:scrollbars="vertical"
 	app:layout_behavior="@string/appbar_scrolling_view_behavior">
 

app/src/main/res/layout/fragment_reader_double.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.recyclerview.widget.RecyclerView
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	xmlns:app="http://schemas.android.com/apk/res-auto"
+	android:id="@+id/recyclerView"
+	android:layout_width="match_parent"
+	android:layout_height="match_parent"
+	android:defaultFocusHighlightEnabled="false"
+	android:orientation="horizontal"
+	app:layoutManager="org.koitharu.kotatsu.reader.ui.pager.doublepage.DoublePageLayoutManager" />

app/src/main/res/layout/item_chapter_download.xml

@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout
-	xmlns:android="http://schemas.android.com/apk/res/android"
-	xmlns:app="http://schemas.android.com/apk/res-auto"
-	xmlns:tools="http://schemas.android.com/tools"
-	android:layout_width="match_parent"
-	android:layout_height="wrap_content"
-	android:baselineAligned="false"
-	android:gravity="center_vertical"
-	android:orientation="horizontal"
-	android:paddingVertical="4dp">
-
-	<TextView
-		android:id="@+id/textView_number"
-		android:layout_width="24dp"
-		android:layout_height="24dp"
-		android:layout_marginStart="?android:listPreferredItemPaddingStart"
-		android:background="@drawable/bg_badge_default"
-		android:ellipsize="none"
-		android:gravity="center"
-		android:singleLine="true"
-		android:textAlignment="center"
-		android:textColor="?attr/colorOnPrimary"
-		android:textSize="12sp"
-		tools:text="13" />
-
-	<TextView
-		android:id="@+id/textView_title"
-		android:layout_width="match_parent"
-		android:layout_height="wrap_content"
-		android:layout_marginStart="?android:listPreferredItemPaddingStart"
-		android:layout_marginEnd="?android:listPreferredItemPaddingEnd"
-		android:drawablePadding="4dp"
-		android:ellipsize="end"
-		android:gravity="center_vertical"
-		android:singleLine="true"
-		android:textAppearance="?attr/textAppearanceBodySmall"
-		app:drawableTint="?colorControlNormal"
-		tools:drawableEnd="@drawable/ic_check"
-		tools:text="@tools:sample/lorem[15]" />
-
-</LinearLayout>

app/src/main/res/layout/item_download.xml

@@ -8,7 +8,6 @@
 	android:layout_height="wrap_content">
 
 	<androidx.constraintlayout.widget.ConstraintLayout
-		android:id="@+id/constraintLayout"
 		android:layout_width="match_parent"
 		android:layout_height="match_parent"
 		android:paddingBottom="12dp">
@@ -25,7 +24,7 @@
 			app:shapeAppearanceOverlay="@style/ShapeAppearanceOverlay.Kotatsu.Cover.Medium"
 			tools:src="@tools:sample/backgrounds/scenic" />
 
-		<CheckedTextView
+		<TextView
 			android:id="@+id/textView_title"
 			android:layout_width="0dp"
 			android:layout_height="wrap_content"
@@ -33,14 +32,11 @@
 			android:layout_marginTop="12dp"
 			android:layout_marginEnd="12dp"
 			android:ellipsize="end"
-			android:gravity="center_vertical"
 			android:singleLine="true"
 			android:textAppearance="?attr/textAppearanceTitleSmall"
-			app:drawableTint="?android:colorControlNormal"
 			app:layout_constraintEnd_toEndOf="parent"
 			app:layout_constraintStart_toEndOf="@id/imageView_cover"
 			app:layout_constraintTop_toTopOf="parent"
-			tools:drawableEndCompat="@drawable/ic_expand_collapse"
 			tools:text="@tools:sample/lorem" />
 
 		<androidx.constraintlayout.widget.Barrier
@@ -104,31 +100,6 @@
 			app:layout_constraintTop_toBottomOf="@id/textView_status"
 			tools:text="@tools:sample/lorem[3]" />
 
-		<com.google.android.material.card.MaterialCardView
-			android:id="@+id/card_details"
-			android:layout_width="0dp"
-			android:layout_height="0dp"
-			android:layout_marginHorizontal="12dp"
-			android:layout_marginTop="12dp"
-			app:layout_constraintEnd_toEndOf="parent"
-			app:layout_constraintHeight_default="wrap"
-			app:layout_constraintHeight_max="280dp"
-			app:layout_constraintStart_toStartOf="parent"
-			app:layout_constraintTop_toBottomOf="@id/progressBar"
-			app:shapeAppearance="?shapeAppearanceCornerMedium">
-
-			<androidx.recyclerview.widget.RecyclerView
-				android:id="@+id/recyclerView_chapters"
-				android:layout_width="match_parent"
-				android:layout_height="match_parent"
-				android:orientation="vertical"
-				android:scrollbars="vertical"
-				app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
-				tools:itemCount="200"
-				tools:listitem="@layout/item_chapter_download" />
-
-		</com.google.android.material.card.MaterialCardView>
-
 		<Button
 			android:id="@+id/button_pause"
 			style="?materialButtonOutlinedStyle"
@@ -139,7 +110,7 @@
 			android:text="@string/pause"
 			android:visibility="gone"
 			app:layout_constraintEnd_toStartOf="@id/button_resume"
-			app:layout_constraintTop_toBottomOf="@id/card_details"
+			app:layout_constraintTop_toBottomOf="@id/progressBar"
 			tools:visibility="visible" />
 
 		<Button
@@ -152,7 +123,7 @@
 			android:text="@string/resume"
 			android:visibility="gone"
 			app:layout_constraintEnd_toStartOf="@id/button_cancel"
-			app:layout_constraintTop_toBottomOf="@id/card_details" />
+			app:layout_constraintTop_toBottomOf="@id/progressBar" />
 
 		<Button
 			android:id="@+id/button_cancel"
@@ -164,7 +135,7 @@
 			android:text="@android:string/cancel"
 			android:visibility="gone"
 			app:layout_constraintEnd_toEndOf="parent"
-			app:layout_constraintTop_toBottomOf="@id/card_details"
+			app:layout_constraintTop_toBottomOf="@id/progressBar"
 			tools:visibility="visible" />
 
 	</androidx.constraintlayout.widget.ConstraintLayout>