Merge branch 'master' of github.com:KotatsuApp/Kotatsu

Currently translated at 100.0% (398 of 398 strings)

Co-authored-by: Eric <hamburger1024@mailbox.org>
Translate-URL: https://hosted.weblate.org/projects/kotatsu/strings/zh_Hans/
Translation: Kotatsu/Strings

.github/FUNDING.yml

@@ -1 +1,2 @@
 custom: ["https://yoomoney.ru/to/410012543938752"]
+ko_fi: koitharu

.gitignore

@@ -7,6 +7,7 @@
 /.idea/modules.xml
 /.idea/misc.xml
 /.idea/discord.xml
+/.idea/compiler.xml
 /.idea/workspace.xml
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml

.idea/compiler.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="11" />
-  </component>
-</project>

.idea/kotlinc.xml

@@ -3,4 +3,7 @@
   <component name="Kotlin2JvmCompilerArguments">
     <option name="jvmTarget" value="1.8" />
   </component>
+  <component name="KotlinJpsPluginSettings">
+    <option name="version" value="1.7.20" />
+  </component>
 </project>

.idea/ktlint.xml

@@ -1,7 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="KtlintProjectConfiguration">
+    <enableKtlint>false</enableKtlint>
     <androidMode>true</androidMode>
     <treatAsErrors>false</treatAsErrors>
+    <disabledRules>
+      <list>
+        <option value="no-empty-first-line-in-method-block" />
+      </list>
+    </disabledRules>
   </component>
 </project>

app/build.gradle

@@ -15,8 +15,8 @@ android {
 		applicationId 'org.koitharu.kotatsu'
 		minSdkVersion 21
 		targetSdkVersion 33
-		versionCode 492
-		versionName '4.0-a3'
+		versionCode 500
+		versionName '4.0'
 		generatedDensities = []
 		testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
@@ -60,6 +60,7 @@ android {
 			'-opt-in=kotlinx.coroutines.FlowPreview',
 			'-opt-in=kotlin.contracts.ExperimentalContracts',
 			'-opt-in=coil.annotation.ExperimentalCoilApi',
+			'-opt-in=com.google.android.material.badge.ExperimentalBadgeUtils',
 		]
 	}
 	lint {
@@ -82,15 +83,15 @@ afterEvaluate {
 	}
 }
 dependencies {
-	implementation('com.github.KotatsuApp:kotatsu-parsers:f112a06ab6') {
+	implementation('com.github.KotatsuApp:kotatsu-parsers:a1441e7ed7') {
 		exclude group: 'org.json', module: 'json'
 	}
 
 	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
 
-	implementation 'androidx.core:core-ktx:1.8.0'
-	implementation 'androidx.activity:activity-ktx:1.5.1'
-	implementation 'androidx.fragment:fragment-ktx:1.5.2'
+	implementation 'androidx.core:core-ktx:1.9.0'
+	implementation 'androidx.activity:activity-ktx:1.6.0'
+	implementation 'androidx.fragment:fragment-ktx:1.5.3'
 	implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1'
 	implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.5.1'
 	implementation 'androidx.lifecycle:lifecycle-service:2.5.1'
@@ -101,8 +102,8 @@ dependencies {
 	implementation 'androidx.viewpager2:viewpager2:1.1.0-beta01'
 	implementation 'androidx.preference:preference-ktx:1.2.0'
 	implementation 'androidx.work:work-runtime-ktx:2.7.1'
-	implementation 'androidx.biometric:biometric-ktx:1.2.0-alpha04'
-	implementation 'com.google.android.material:material:1.7.0-beta01'
+	implementation 'androidx.biometric:biometric-ktx:1.2.0-alpha05'
+	implementation 'com.google.android.material:material:1.7.0'
 	//noinspection LifecycleAnnotationProcessorWithJava8
 	kapt 'androidx.lifecycle:lifecycle-compiler:2.5.1'
 
@@ -117,15 +118,14 @@ dependencies {
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl:4.3.2'
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl-viewbinding:4.3.2'
 
-	implementation "com.google.dagger:hilt-android:2.43.2"
-	kapt "com.google.dagger:hilt-compiler:2.43.2"
+	implementation "com.google.dagger:hilt-android:2.44"
+	kapt "com.google.dagger:hilt-compiler:2.44"
 	implementation 'androidx.hilt:hilt-work:1.0.0'
 	kapt 'androidx.hilt:hilt-compiler:1.0.0'
 
-	implementation 'io.coil-kt:coil-base:2.2.0'
-	implementation 'io.coil-kt:coil-svg:2.2.0'
-//	implementation 'com.davemorrissey.labs:subsampling-scale-image-view-androidx:3.10.0'
-	implementation 'com.github.KotatsuApp:subsampling-scale-image-view:2942b797a2'
+	implementation 'io.coil-kt:coil-base:2.2.2'
+	implementation 'io.coil-kt:coil-svg:2.2.2'
+	implementation 'com.github.KotatsuApp:subsampling-scale-image-view:0ff0278f0f'
 	implementation 'com.github.solkin:disk-lru-cache:1.4'
 
 	implementation 'ch.acra:acra-http:5.9.6'
@@ -134,7 +134,7 @@ dependencies {
 	debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.9.1'
 
 	testImplementation 'junit:junit:4.13.2'
-	testImplementation 'org.json:json:20220320'
+	testImplementation 'org.json:json:20220924'
 	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
 
 	androidTestImplementation 'androidx.test:runner:1.4.0'
@@ -145,8 +145,8 @@ dependencies {
 	androidTestImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
 
 	androidTestImplementation 'androidx.room:room-testing:2.4.3'
-	androidTestImplementation 'com.squareup.moshi:moshi-kotlin:1.13.0'
+	androidTestImplementation 'com.squareup.moshi:moshi-kotlin:1.14.0'
 
-	androidTestImplementation 'com.google.dagger:hilt-android-testing:2.43.2'
-	kaptAndroidTest 'com.google.dagger:hilt-android-compiler:2.43.2'
+	androidTestImplementation 'com.google.dagger:hilt-android-testing:2.44'
+	kaptAndroidTest 'com.google.dagger:hilt-android-compiler:2.44'
 }

app/proguard-rules.pro

@@ -13,3 +13,4 @@
 -dontwarn okhttp3.internal.platform.ConscryptPlatform
 
 -keep class org.koitharu.kotatsu.core.exceptions.* { *; }
+-keep class org.koitharu.kotatsu.settings.NotificationSettingsLegacyFragment

app/src/main/AndroidManifest.xml

@@ -68,6 +68,9 @@
 		<activity
 			android:name="org.koitharu.kotatsu.history.ui.HistoryActivity"
 			android:label="@string/history" />
+		<activity
+			android:name="org.koitharu.kotatsu.tracker.ui.updates.UpdatesActivity"
+			android:label="@string/updates" />
 		<activity
 			android:name="org.koitharu.kotatsu.favourites.ui.FavouritesActivity"
 			android:label="@string/favourites" />
@@ -133,6 +136,9 @@
 		<activity
 			android:name="org.koitharu.kotatsu.sync.ui.SyncAuthActivity"
 			android:label="@string/sync" />
+		<activity
+			android:name="org.koitharu.kotatsu.reader.ui.colorfilter.ColorFilterConfigActivity"
+			android:label="@string/color_correction" />
 
 		<service
 			android:name="org.koitharu.kotatsu.download.ui.service.DownloadService"

app/src/main/java/org/koitharu/kotatsu/KotatsuApp.kt

@@ -10,7 +10,6 @@ import androidx.hilt.work.HiltWorkerFactory
 import androidx.room.InvalidationTracker
 import androidx.work.Configuration
 import dagger.hilt.android.HiltAndroidApp
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import org.acra.ReportField
@@ -25,6 +24,7 @@ import org.koitharu.kotatsu.local.data.PagesCache
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.utils.ext.processLifecycleScope
+import javax.inject.Inject
 
 @HiltAndroidApp
 class KotatsuApp : Application(), Configuration.Provider {
@@ -72,6 +72,7 @@ class KotatsuApp : Application(), Configuration.Provider {
 			}
 			reportContent = listOf(
 				ReportField.PACKAGE_NAME,
+				ReportField.INSTALLATION_ID,
 				ReportField.APP_VERSION_CODE,
 				ReportField.APP_VERSION_NAME,
 				ReportField.ANDROID_VERSION,

app/src/main/java/org/koitharu/kotatsu/base/domain/MangaDataRepository.kt

@@ -10,6 +10,9 @@ import java.util.zip.ZipFile
 import javax.inject.Inject
 import kotlin.math.roundToInt
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.runInterruptible
 import okhttp3.OkHttpClient
 import okhttp3.Request
@@ -23,6 +26,7 @@ import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.model.MangaTag
 import org.koitharu.kotatsu.parsers.util.await
+import org.koitharu.kotatsu.reader.domain.ReaderColorFilter
 
 private const val MIN_WEBTOON_RATIO = 2
 
@@ -31,15 +35,22 @@ class MangaDataRepository @Inject constructor(
 	private val db: MangaDatabase,
 ) {
 
-	suspend fun savePreferences(manga: Manga, mode: ReaderMode) {
-		val tags = manga.tags.toEntities()
+	suspend fun saveReaderMode(manga: Manga, mode: ReaderMode) {
 		db.withTransaction {
-			db.tagsDao.upsert(tags)
-			db.mangaDao.upsert(manga.toEntity(), tags)
+			storeManga(manga)
+			val entity = db.preferencesDao.find(manga.id) ?: newEntity(manga.id)
+			db.preferencesDao.upsert(entity.copy(mode = mode.id))
+		}
+	}
+
+	suspend fun saveColorFilter(manga: Manga, colorFilter: ReaderColorFilter?) {
+		db.withTransaction {
+			storeManga(manga)
+			val entity = db.preferencesDao.find(manga.id) ?: newEntity(manga.id)
 			db.preferencesDao.upsert(
-				MangaPrefsEntity(
-					mangaId = manga.id,
-					mode = mode.id,
+				entity.copy(
+					cfBrightness = colorFilter?.brightness ?: 0f,
+					cfContrast = colorFilter?.contrast ?: 0f,
 				),
 			)
 		}
@@ -49,6 +60,16 @@ class MangaDataRepository @Inject constructor(
 		return db.preferencesDao.find(mangaId)?.let { ReaderMode.valueOf(it.mode) }
 	}
 
+	suspend fun getColorFilter(mangaId: Long): ReaderColorFilter? {
+		return db.preferencesDao.find(mangaId)?.getColorFilterOrNull()
+	}
+
+	fun observeColorFilter(mangaId: Long): Flow<ReaderColorFilter?> {
+		return db.preferencesDao.observe(mangaId)
+			.map { it?.getColorFilterOrNull() }
+			.distinctUntilChanged()
+	}
+
 	suspend fun findMangaById(mangaId: Long): Manga? {
 		return db.mangaDao.find(mangaId)?.toManga()
 	}
@@ -71,6 +92,14 @@ class MangaDataRepository @Inject constructor(
 		return db.tagsDao.findTags(source.name).toMangaTags()
 	}
 
+	private fun MangaPrefsEntity.getColorFilterOrNull(): ReaderColorFilter? {
+		return if (cfBrightness != 0f || cfContrast != 0f) {
+			ReaderColorFilter(cfBrightness, cfContrast)
+		} else {
+			null
+		}
+	}
+
 	/**
 	 * Automatic determine type of manga by page size
 	 * @return ReaderMode.WEBTOON if page is wide
@@ -104,6 +133,13 @@ class MangaDataRepository @Inject constructor(
 		return size.width * MIN_WEBTOON_RATIO < size.height
 	}
 
+	private fun newEntity(mangaId: Long) = MangaPrefsEntity(
+		mangaId = mangaId,
+		mode = -1,
+		cfBrightness = 0f,
+		cfContrast = 0f,
+	)
+
 	companion object {
 
 		suspend fun getImageMimeType(file: File): String? = runInterruptible(Dispatchers.IO) {

app/src/main/java/org/koitharu/kotatsu/base/domain/ReversibleHandle.kt

@@ -1,9 +1,12 @@
 package org.koitharu.kotatsu.base.domain
 
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.processLifecycleScope
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
 fun interface ReversibleHandle {
 
@@ -11,8 +14,10 @@ fun interface ReversibleHandle {
 }
 
 fun ReversibleHandle.reverseAsync() = processLifecycleScope.launch(Dispatchers.Default) {
-	runCatching {
-		reverse()
+	runCatchingCancellable {
+		withContext(NonCancellable) {
+			reverse()
+		}
 	}.onFailure {
 		it.printStackTraceDebug()
 	}
@@ -21,4 +26,4 @@ fun ReversibleHandle.reverseAsync() = processLifecycleScope.launch(Dispatchers.D
 operator fun ReversibleHandle.plus(other: ReversibleHandle) = ReversibleHandle {
 	this.reverse()
 	other.reverse()
-}
+}

app/src/main/java/org/koitharu/kotatsu/base/ui/BaseActivity.kt

@@ -12,7 +12,6 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.view.ActionMode
 import androidx.appcompat.widget.ActionBarContextView
 import androidx.appcompat.widget.Toolbar
-import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
 import androidx.core.graphics.ColorUtils
 import androidx.core.view.ViewCompat
@@ -21,7 +20,6 @@ import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updateLayoutParams
 import androidx.viewbinding.ViewBinding
 import dagger.hilt.android.EntryPointAccessors
-import javax.inject.Inject
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.util.ActionModeDelegate
@@ -31,6 +29,7 @@ import org.koitharu.kotatsu.base.ui.util.inject
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.utils.ext.getThemeColor
+import javax.inject.Inject
 
 abstract class BaseActivity<B : ViewBinding> :
 	AppCompatActivity(),
@@ -92,7 +91,8 @@ abstract class BaseActivity<B : ViewBinding> :
 
 	override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
 		if (BuildConfig.DEBUG && keyCode == KeyEvent.KEYCODE_VOLUME_UP) { // TODO remove
-			ActivityCompat.recreate(this)
+			// ActivityCompat.recreate(this)
+			TODO("Test error")
 			return true
 		}
 		return super.onKeyDown(keyCode, event)
@@ -134,6 +134,7 @@ abstract class BaseActivity<B : ViewBinding> :
 		window.statusBarColor = getThemeColor(android.R.attr.statusBarColor)
 	}
 
+	@Suppress("OVERRIDE_DEPRECATION", "DEPRECATION")
 	override fun onBackPressed() {
 		if ( // https://issuetracker.google.com/issues/139738913
 			Build.VERSION.SDK_INT == Build.VERSION_CODES.Q &&

app/src/main/java/org/koitharu/kotatsu/base/ui/CoroutineIntentService.kt

@@ -4,11 +4,13 @@ import android.app.Service
 import android.content.Intent
 import androidx.lifecycle.lifecycleScope
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 
 abstract class CoroutineIntentService : BaseService() {
 
@@ -21,11 +23,13 @@ abstract class CoroutineIntentService : BaseService() {
 		return Service.START_REDELIVER_INTENT
 	}
 
-	private fun launchCoroutine(intent: Intent?, startId: Int) = lifecycleScope.launch {
+	private fun launchCoroutine(intent: Intent?, startId: Int) = lifecycleScope.launch(errorHandler(startId)) {
 		mutex.withLock {
 			try {
-				withContext(dispatcher) {
-					processIntent(intent)
+				if (intent != null) {
+					withContext(dispatcher) {
+						processIntent(startId, intent)
+					}
 				}
 			} finally {
 				stopSelf(startId)
@@ -33,5 +37,12 @@ abstract class CoroutineIntentService : BaseService() {
 		}
 	}
 
-	protected abstract suspend fun processIntent(intent: Intent?)
+	protected abstract suspend fun processIntent(startId: Int, intent: Intent)
+
+	protected abstract fun onError(startId: Int, error: Throwable)
+
+	private fun errorHandler(startId: Int) = CoroutineExceptionHandler { _, throwable ->
+		throwable.printStackTraceDebug()
+		onError(startId, throwable)
+	}
 }

app/src/main/java/org/koitharu/kotatsu/base/ui/DefaultActivityLifecycleCallbacks.kt

@@ -0,0 +1,22 @@
+package org.koitharu.kotatsu.base.ui
+
+import android.app.Activity
+import android.app.Application.ActivityLifecycleCallbacks
+import android.os.Bundle
+
+interface DefaultActivityLifecycleCallbacks : ActivityLifecycleCallbacks {
+
+	override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+
+	override fun onActivityStarted(activity: Activity) = Unit
+
+	override fun onActivityResumed(activity: Activity) = Unit
+
+	override fun onActivityPaused(activity: Activity) = Unit
+
+	override fun onActivityStopped(activity: Activity) = Unit
+
+	override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+
+	override fun onActivityDestroyed(activity: Activity) = Unit
+}

app/src/main/java/org/koitharu/kotatsu/base/ui/list/SectionedSelectionController.kt

@@ -60,7 +60,19 @@ class SectionedSelectionController<T : Any>(
 			startActionMode()
 			notifySelectionChanged()
 		}
-		recyclerView.addItemDecoration(decoration)
+		var shouldAddDecoration = true
+		for (i in (0 until recyclerView.itemDecorationCount).reversed()) {
+			val decor = recyclerView.getItemDecorationAt(i)
+			if (decor === decoration) {
+				shouldAddDecoration = false
+				break
+			} else if (decor.javaClass == decoration.javaClass) {
+				recyclerView.removeItemDecorationAt(i)
+			}
+		}
+		if (shouldAddDecoration) {
+			recyclerView.addItemDecoration(decoration)
+		}
 		if (pendingData?.isEmpty() == true) {
 			pendingData = null
 		}

app/src/main/java/org/koitharu/kotatsu/base/ui/list/fastscroll/ScrollbarAnimator.kt

@@ -33,6 +33,7 @@ class ScrollbarAnimator(
 			.animate()
 			.translationX(0f)
 			.alpha(1f)
+			.setListener(null)
 			.setDuration(animationDuration)
 	}
 

app/src/main/java/org/koitharu/kotatsu/base/ui/util/ActivityRecreationHandle.kt

@@ -1,14 +1,14 @@
 package org.koitharu.kotatsu.base.ui.util
 
 import android.app.Activity
-import android.app.Application.ActivityLifecycleCallbacks
 import android.os.Bundle
-import java.util.*
+import org.koitharu.kotatsu.base.ui.DefaultActivityLifecycleCallbacks
+import java.util.WeakHashMap
 import javax.inject.Inject
 import javax.inject.Singleton
 
 @Singleton
-class ActivityRecreationHandle @Inject constructor() : ActivityLifecycleCallbacks {
+class ActivityRecreationHandle @Inject constructor() : DefaultActivityLifecycleCallbacks {
 
 	private val activities = WeakHashMap<Activity, Unit>()
 
@@ -16,16 +16,6 @@ class ActivityRecreationHandle @Inject constructor() : ActivityLifecycleCallback
 		activities[activity] = Unit
 	}
 
-	override fun onActivityStarted(activity: Activity) = Unit
-
-	override fun onActivityResumed(activity: Activity) = Unit
-
-	override fun onActivityPaused(activity: Activity) = Unit
-
-	override fun onActivityStopped(activity: Activity) = Unit
-
-	override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
-
 	override fun onActivityDestroyed(activity: Activity) {
 		activities.remove(activity)
 	}

app/src/main/java/org/koitharu/kotatsu/base/ui/widgets/BottomSheetHeaderBar.kt

@@ -26,6 +26,8 @@ import org.koitharu.kotatsu.utils.ext.getAnimationDuration
 import org.koitharu.kotatsu.utils.ext.getThemeDrawable
 import org.koitharu.kotatsu.utils.ext.parents
 
+private const val THROTTLE_DELAY = 200L
+
 class BottomSheetHeaderBar @JvmOverloads constructor(
 	context: Context,
 	attrs: AttributeSet? = null,
@@ -35,6 +37,7 @@ class BottomSheetHeaderBar @JvmOverloads constructor(
 	private val binding = LayoutSheetHeaderBinding.inflate(LayoutInflater.from(context), this)
 	private val closeDrawable = context.getThemeDrawable(materialR.attr.actionModeCloseDrawable)
 	private val bottomSheetCallback = Callback()
+	private val adjustStateRunnable = Runnable { adjustState() }
 	private var bottomSheetBehavior: BottomSheetBehavior<*>? = null
 	private val locationBuffer = IntArray(2)
 	private val expansionListeners = LinkedList<OnExpansionChangeListener>()
@@ -43,6 +46,8 @@ class BottomSheetHeaderBar @JvmOverloads constructor(
 	private val maxHandleHeight = context.resources.getDimensionPixelSize(R.dimen.bottom_sheet_handle_size_max)
 	private var isLayoutSuppressedCompat = false
 	private var isLayoutCalledWhileSuppressed = false
+	private var isBsExpanded = false
+	private var stateAdjustedAt = 0L
 
 	@Deprecated("")
 	val toolbar: MaterialToolbar
@@ -173,16 +178,11 @@ class BottomSheetHeaderBar @JvmOverloads constructor(
 	}
 
 	private fun onBottomSheetStateChanged(newState: Int) {
-		val isExpanded = newState == BottomSheetBehavior.STATE_EXPANDED && isOnTopOfScreen()
-		if (isExpanded == binding.dragHandle.isGone) {
-			return
+		val expanded = newState == BottomSheetBehavior.STATE_EXPANDED && isOnTopOfScreen()
+		if (isBsExpanded != expanded) {
+			isBsExpanded = expanded
+			postAdjustState()
 		}
-		suppressLayoutCompat(true)
-		binding.toolbar.navigationIcon = (if (isExpanded) closeDrawable else null)
-		binding.dragHandle.isGone = isExpanded
-		expansionListeners.forEach { it.onExpansionStateChanged(this, isExpanded) }
-		dispatchInsets(ViewCompat.getRootWindowInsets(this))
-		suppressLayoutCompat(false)
 	}
 
 	private fun suppressLayoutCompat(suppress: Boolean) {
@@ -262,6 +262,26 @@ class BottomSheetHeaderBar @JvmOverloads constructor(
 		}
 	}
 
+	private fun postAdjustState() {
+		removeCallbacks(adjustStateRunnable)
+		val now = System.currentTimeMillis()
+		if (stateAdjustedAt + THROTTLE_DELAY < now) {
+			adjustState()
+		} else {
+			postDelayed(adjustStateRunnable, THROTTLE_DELAY)
+		}
+	}
+
+	private fun adjustState() {
+		suppressLayoutCompat(true)
+		binding.toolbar.navigationIcon = (if (isBsExpanded) closeDrawable else null)
+		binding.dragHandle.isGone = isBsExpanded
+		expansionListeners.forEach { it.onExpansionStateChanged(this, isBsExpanded) }
+		dispatchInsets(ViewCompat.getRootWindowInsets(this))
+		stateAdjustedAt = System.currentTimeMillis()
+		suppressLayoutCompat(false)
+	}
+
 	private inner class Callback : BottomSheetBehavior.BottomSheetCallback(), View.OnClickListener {
 
 		override fun onStateChanged(bottomSheet: View, newState: Int) {

app/src/main/java/org/koitharu/kotatsu/bookmarks/ui/adapter/BookmarksGroupAdapter.kt

@@ -5,6 +5,7 @@ import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.RecyclerView
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
+import kotlin.jvm.internal.Intrinsics
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.base.ui.list.SectionedSelectionController
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
@@ -12,7 +13,6 @@ import org.koitharu.kotatsu.bookmarks.ui.model.BookmarksGroup
 import org.koitharu.kotatsu.list.ui.adapter.*
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.parsers.model.Manga
-import kotlin.jvm.internal.Intrinsics
 
 class BookmarksGroupAdapter(
 	coil: ImageLoader,
@@ -34,11 +34,11 @@ class BookmarksGroupAdapter(
 					selectionController = selectionController,
 					bookmarkClickListener = bookmarkClickListener,
 					groupClickListener = groupClickListener,
-				)
+				),
 			)
 			.addDelegate(loadingStateAD())
 			.addDelegate(loadingFooterAD())
-			.addDelegate(emptyStateListAD(listener))
+			.addDelegate(emptyStateListAD(coil, listener))
 			.addDelegate(errorStateListAD(listener))
 	}
 
@@ -64,4 +64,4 @@ class BookmarksGroupAdapter(
 			}
 		}
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/browser/cloudflare/CloudFlareDialog.kt

@@ -55,6 +55,7 @@ class CloudFlareDialog : AlertDialogFragment<FragmentCloudflareBinding>(), Cloud
 
 	override fun onDestroyView() {
 		binding.webView.stopLoading()
+		binding.webView.destroy()
 		super.onDestroyView()
 	}
 
@@ -83,7 +84,7 @@ class CloudFlareDialog : AlertDialogFragment<FragmentCloudflareBinding>(), Cloud
 
 	override fun onCheckPassed() {
 		pendingResult.putBoolean(EXTRA_RESULT, true)
-		dismiss()
+		dismissAllowingStateLoss()
 	}
 
 	companion object {

app/src/main/java/org/koitharu/kotatsu/core/AppModule.kt

@@ -18,8 +18,6 @@ import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import dagger.multibindings.ElementsIntoSet
-import java.util.concurrent.TimeUnit
-import javax.inject.Singleton
 import kotlinx.coroutines.Dispatchers
 import okhttp3.CookieJar
 import okhttp3.OkHttpClient
@@ -40,9 +38,12 @@ import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.search.ui.MangaSuggestionsProvider
 import org.koitharu.kotatsu.settings.backup.BackupObserver
 import org.koitharu.kotatsu.sync.domain.SyncController
+import org.koitharu.kotatsu.utils.IncognitoModeIndicator
 import org.koitharu.kotatsu.utils.ext.isLowRamDevice
 import org.koitharu.kotatsu.utils.image.CoilImageGetter
 import org.koitharu.kotatsu.widget.WidgetUpdater
+import java.util.concurrent.TimeUnit
+import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
@@ -152,9 +153,11 @@ interface AppModule {
 		fun provideActivityLifecycleCallbacks(
 			appProtectHelper: AppProtectHelper,
 			activityRecreationHandle: ActivityRecreationHandle,
+			incognitoModeIndicator: IncognitoModeIndicator,
 		): Set<@JvmSuppressWildcards Application.ActivityLifecycleCallbacks> = arraySetOf(
 			appProtectHelper,
 			activityRecreationHandle,
+			incognitoModeIndicator,
 		)
 	}
 }

app/src/main/java/org/koitharu/kotatsu/core/backup/BackupRepository.kt

@@ -1,13 +1,14 @@
 package org.koitharu.kotatsu.core.backup
 
 import androidx.room.withTransaction
-import javax.inject.Inject
 import org.json.JSONArray
 import org.json.JSONObject
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.parsers.util.json.JSONIterator
 import org.koitharu.kotatsu.parsers.util.json.mapJSON
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import javax.inject.Inject
 
 private const val PAGE_SIZE = 10
 
@@ -85,7 +86,7 @@ class BackupRepository @Inject constructor(private val db: MangaDatabase) {
 				JsonDeserializer(it).toTagEntity()
 			}
 			val history = JsonDeserializer(item).toHistoryEntity()
-			result += runCatching {
+			result += runCatchingCancellable {
 				db.withTransaction {
 					db.tagsDao.upsert(tags)
 					db.mangaDao.upsert(manga, tags)
@@ -100,7 +101,7 @@ class BackupRepository @Inject constructor(private val db: MangaDatabase) {
 		val result = CompositeResult()
 		for (item in entry.data.JSONIterator()) {
 			val category = JsonDeserializer(item).toFavouriteCategoryEntity()
-			result += runCatching {
+			result += runCatchingCancellable {
 				db.favouriteCategoriesDao.upsert(category)
 			}
 		}
@@ -116,7 +117,7 @@ class BackupRepository @Inject constructor(private val db: MangaDatabase) {
 				JsonDeserializer(it).toTagEntity()
 			}
 			val favourite = JsonDeserializer(item).toFavouriteEntity()
-			result += runCatching {
+			result += runCatchingCancellable {
 				db.withTransaction {
 					db.tagsDao.upsert(tags)
 					db.mangaDao.upsert(manga, tags)

app/src/main/java/org/koitharu/kotatsu/core/db/MangaDatabase.kt

@@ -35,7 +35,7 @@ import org.koitharu.kotatsu.tracker.data.TrackLogEntity
 import org.koitharu.kotatsu.tracker.data.TracksDao
 import org.koitharu.kotatsu.utils.ext.processLifecycleScope
 
-const val DATABASE_VERSION = 14
+const val DATABASE_VERSION = 15
 
 @Database(
 	entities = [
@@ -86,6 +86,7 @@ val databaseMigrations: Array<Migration>
 		Migration11To12(),
 		Migration12To13(),
 		Migration13To14(),
+		Migration14To15(),
 	)
 
 fun MangaDatabase(context: Context): MangaDatabase = Room

app/src/main/java/org/koitharu/kotatsu/core/db/dao/PreferencesDao.kt

@@ -1,6 +1,7 @@
 package org.koitharu.kotatsu.core.db.dao
 
 import androidx.room.*
+import kotlinx.coroutines.flow.Flow
 import org.koitharu.kotatsu.core.db.entity.MangaPrefsEntity
 
 @Dao
@@ -9,6 +10,9 @@ abstract class PreferencesDao {
 	@Query("SELECT * FROM preferences WHERE manga_id = :mangaId")
 	abstract suspend fun find(mangaId: Long): MangaPrefsEntity?
 
+	@Query("SELECT * FROM preferences WHERE manga_id = :mangaId")
+	abstract fun observe(mangaId: Long): Flow<MangaPrefsEntity?>
+
 	@Insert(onConflict = OnConflictStrategy.IGNORE)
 	abstract suspend fun insert(pref: MangaPrefsEntity): Long
 
@@ -21,4 +25,4 @@ abstract class PreferencesDao {
 			insert(pref)
 		}
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/core/db/entity/MangaPrefsEntity.kt

@@ -12,12 +12,15 @@ import androidx.room.PrimaryKey
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],
 			childColumns = ["manga_id"],
-			onDelete = ForeignKey.CASCADE
-		)
-	]
+			onDelete = ForeignKey.CASCADE,
+		),
+	],
 )
-class MangaPrefsEntity(
+data class MangaPrefsEntity(
 	@PrimaryKey(autoGenerate = false)
-	@ColumnInfo(name = "manga_id") val mangaId: Long,
-	@ColumnInfo(name = "mode") val mode: Int
-)
+	@ColumnInfo(name = "manga_id")
+	val mangaId: Long,
+	@ColumnInfo(name = "mode") val mode: Int,
+	@ColumnInfo(name = "cf_brightness") val cfBrightness: Float,
+	@ColumnInfo(name = "cf_contrast") val cfContrast: Float,
+)

app/src/main/java/org/koitharu/kotatsu/core/db/migrations/Migration14To15.kt

@@ -0,0 +1,12 @@
+package org.koitharu.kotatsu.core.db.migrations
+
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+
+class Migration14To15 : Migration(14, 15) {
+
+	override fun migrate(database: SupportSQLiteDatabase) {
+		database.execSQL("ALTER TABLE preferences ADD COLUMN `cf_brightness` REAL NOT NULL DEFAULT 0")
+		database.execSQL("ALTER TABLE preferences ADD COLUMN `cf_contrast` REAL NOT NULL DEFAULT 0")
+	}
+}

app/src/main/java/org/koitharu/kotatsu/core/exceptions/resolve/ExceptionResolver.kt

@@ -6,6 +6,9 @@ import androidx.activity.result.ActivityResultLauncher
 import androidx.annotation.StringRes
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
 import kotlinx.coroutines.suspendCancellableCoroutine
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.browser.BrowserActivity
@@ -17,9 +20,6 @@ import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.settings.sources.auth.SourceAuthActivity
 import org.koitharu.kotatsu.utils.TaggedActivityResult
 import org.koitharu.kotatsu.utils.isSuccess
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 
 class ExceptionResolver private constructor(
 	private val activity: FragmentActivity?,
@@ -65,7 +65,7 @@ class ExceptionResolver private constructor(
 			cont.invokeOnCancellation {
 				continuations.remove(CloudFlareDialog.TAG, cont)
 				fm.clearFragmentResultListener(CloudFlareDialog.TAG)
-				dialog.dismiss()
+				dialog.dismissAllowingStateLoss()
 			}
 		}
 	}
@@ -94,4 +94,4 @@ class ExceptionResolver private constructor(
 
 		fun canResolve(e: Throwable) = getResolveStringId(e) != 0
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/core/github/AppUpdateRepository.kt

@@ -4,13 +4,6 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.content.pm.PackageManager
 import dagger.hilt.android.qualifiers.ApplicationContext
-import java.io.ByteArrayInputStream
-import java.io.InputStream
-import java.security.MessageDigest
-import java.security.cert.CertificateFactory
-import java.security.cert.X509Certificate
-import javax.inject.Inject
-import javax.inject.Singleton
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -24,6 +17,14 @@ import org.koitharu.kotatsu.parsers.util.json.mapJSONNotNull
 import org.koitharu.kotatsu.parsers.util.parseJsonArray
 import org.koitharu.kotatsu.utils.ext.asArrayList
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import java.io.ByteArrayInputStream
+import java.io.InputStream
+import java.security.MessageDigest
+import java.security.cert.CertificateFactory
+import java.security.cert.X509Certificate
+import javax.inject.Inject
+import javax.inject.Singleton
 
 private const val CERT_SHA1 = "2C:19:C7:E8:07:61:2B:8E:94:51:1B:FD:72:67:07:64:5D:C2:58:AE"
 
@@ -59,7 +60,7 @@ class AppUpdateRepository @Inject constructor(
 		if (!isUpdateSupported()) {
 			return@withContext null
 		}
-		runCatching {
+		runCatchingCancellable {
 			val currentVersion = VersionId(BuildConfig.VERSION_NAME)
 			val available = getAvailableVersions().asArrayList()
 			available.sortBy { it.versionId }

app/src/main/java/org/koitharu/kotatsu/core/model/parcelable/Parcelable.kt

@@ -2,7 +2,12 @@ package org.koitharu.kotatsu.core.model.parcelable
 
 import android.os.Parcel
 import androidx.core.os.ParcelCompat
-import org.koitharu.kotatsu.parsers.model.*
+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.MangaTag
+import org.koitharu.kotatsu.utils.ext.readParcelableCompat
+import org.koitharu.kotatsu.utils.ext.readSerializableCompat
 
 fun Manga.writeToParcel(out: Parcel, flags: Int, withChapters: Boolean) {
 	out.writeLong(id)
@@ -37,11 +42,11 @@ fun Parcel.readManga() = Manga(
 	coverUrl = requireNotNull(readString()),
 	largeCoverUrl = readString(),
 	description = readString(),
-	tags = requireNotNull(readParcelable<ParcelableMangaTags>(ParcelableMangaTags::class.java.classLoader)).tags,
-	state = readSerializable() as MangaState?,
+	tags = requireNotNull(readParcelableCompat<ParcelableMangaTags>()).tags,
+	state = readSerializableCompat(),
 	author = readString(),
-	chapters = readParcelable<ParcelableMangaChapters>(ParcelableMangaChapters::class.java.classLoader)?.chapters,
-	source = readSerializable() as MangaSource,
+	chapters = readParcelableCompat<ParcelableMangaChapters>()?.chapters,
+	source = checkNotNull(readSerializableCompat()),
 )
 
 fun MangaPage.writeToParcel(out: Parcel) {
@@ -57,7 +62,7 @@ fun Parcel.readMangaPage() = MangaPage(
 	url = requireNotNull(readString()),
 	referer = requireNotNull(readString()),
 	preview = readString(),
-	source = readSerializable() as MangaSource,
+	source = checkNotNull(readSerializableCompat()),
 )
 
 fun MangaChapter.writeToParcel(out: Parcel) {
@@ -79,7 +84,7 @@ fun Parcel.readMangaChapter() = MangaChapter(
 	scanlator = readString(),
 	uploadDate = readLong(),
 	branch = readString(),
-	source = readSerializable() as MangaSource,
+	source = checkNotNull(readSerializableCompat()),
 )
 
 fun MangaTag.writeToParcel(out: Parcel) {
@@ -91,5 +96,5 @@ fun MangaTag.writeToParcel(out: Parcel) {
 fun Parcel.readMangaTag() = MangaTag(
 	title = requireNotNull(readString()),
 	key = requireNotNull(readString()),
-	source = readSerializable() as MangaSource,
-)
+	source = checkNotNull(readSerializableCompat()),
+)

app/src/main/java/org/koitharu/kotatsu/core/model/parcelable/ParcelableManga.kt

@@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.Manga
 
 // Limits to avoid TransactionTooLargeException
 private const val MAX_SAFE_SIZE = 1024 * 512 // Assume that 512 kb is safe parcel size
-private const val MAX_SAFE_CHAPTERS_COUNT = 40 // this is 100% safe
+private const val MAX_SAFE_CHAPTERS_COUNT = 32 // this is 100% safe
 
 class ParcelableManga(
 	val manga: Manga,
@@ -50,4 +50,4 @@ class ParcelableManga(
 			return arrayOfNulls(size)
 		}
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/core/os/NetworkStateObserver.kt

@@ -0,0 +1,64 @@
+package org.koitharu.kotatsu.core.os
+
+import android.content.Context
+import android.net.ConnectivityManager.NetworkCallback
+import android.net.Network
+import android.net.NetworkRequest
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.channels.ProducerScope
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.channels.trySendBlocking
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.callbackFlow
+import org.koitharu.kotatsu.utils.ext.connectivityManager
+import org.koitharu.kotatsu.utils.ext.isNetworkAvailable
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class NetworkStateObserver @Inject constructor(
+	@ApplicationContext context: Context,
+) : StateFlow<Boolean> {
+
+	private val connectivityManager = context.connectivityManager
+
+	override val replayCache: List<Boolean>
+		get() = listOf(value)
+
+	override var value: Boolean = connectivityManager.isNetworkAvailable
+
+	override suspend fun collect(collector: FlowCollector<Boolean>): Nothing {
+		collector.emit(value)
+		while (true) {
+			observeImpl().collect(collector)
+		}
+	}
+
+	private fun observeImpl() = callbackFlow<Boolean> {
+		val request = NetworkRequest.Builder().build()
+		val callback = FlowNetworkCallback(this)
+		connectivityManager.registerNetworkCallback(request, callback)
+		awaitClose {
+			connectivityManager.unregisterNetworkCallback(callback)
+		}
+	}
+
+	inner class FlowNetworkCallback(
+		private val producerScope: ProducerScope<Boolean>,
+	) : NetworkCallback() {
+		override fun onAvailable(network: Network) = update()
+
+		override fun onLost(network: Network) = update()
+
+		override fun onUnavailable() = update()
+
+		private fun update() {
+			val newValue = connectivityManager.isNetworkAvailable
+			if (value != newValue) {
+				value = newValue
+				producerScope.trySendBlocking(newValue)
+			}
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/core/os/ShortcutsUpdater.kt

@@ -2,10 +2,11 @@ package org.koitharu.kotatsu.core.os
 
 import android.app.ActivityManager
 import android.content.Context
+import android.content.SharedPreferences
 import android.content.pm.ShortcutManager
-import android.media.ThumbnailUtils
 import android.os.Build
 import android.util.Size
+import androidx.annotation.RequiresApi
 import androidx.annotation.VisibleForTesting
 import androidx.core.content.pm.ShortcutInfoCompat
 import androidx.core.content.pm.ShortcutManagerCompat
@@ -13,21 +14,25 @@ import androidx.core.graphics.drawable.IconCompat
 import androidx.room.InvalidationTracker
 import coil.ImageLoader
 import coil.request.ImageRequest
+import coil.size.Precision
+import coil.size.Scale
 import dagger.hilt.android.qualifiers.ApplicationContext
-import javax.inject.Inject
-import javax.inject.Singleton
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
 import org.koitharu.kotatsu.core.db.TABLE_HISTORY
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.reader.ui.ReaderActivity
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.processLifecycleScope
 import org.koitharu.kotatsu.utils.ext.requireBitmap
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import javax.inject.Inject
+import javax.inject.Singleton
 
 @Singleton
 class ShortcutsUpdater @Inject constructor(
@@ -35,13 +40,18 @@ class ShortcutsUpdater @Inject constructor(
 	private val coil: ImageLoader,
 	private val historyRepository: HistoryRepository,
 	private val mangaRepository: MangaDataRepository,
-) : InvalidationTracker.Observer(TABLE_HISTORY) {
+	private val settings: AppSettings,
+) : InvalidationTracker.Observer(TABLE_HISTORY), SharedPreferences.OnSharedPreferenceChangeListener {
 
 	private val iconSize by lazy { getIconSize(context) }
 	private var shortcutsUpdateJob: Job? = null
 
-	override fun onInvalidated(tables: MutableSet<String>) {
-		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N_MR1) {
+	init {
+		settings.subscribe(this)
+	}
+
+	override fun onInvalidated(tables: Set<String>) {
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N_MR1 || !settings.isDynamicShortcutsEnabled) {
 			return
 		}
 		val prevJob = shortcutsUpdateJob
@@ -51,6 +61,16 @@ class ShortcutsUpdater @Inject constructor(
 		}
 	}
 
+	override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences?, key: String?) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1 && key == AppSettings.KEY_SHORTCUTS) {
+			if (settings.isDynamicShortcutsEnabled) {
+				onInvalidated(emptySet())
+			} else {
+				clearShortcuts()
+			}
+		}
+	}
+
 	suspend fun requestPinShortcut(manga: Manga): Boolean {
 		return ShortcutManagerCompat.requestPinShortcut(
 			context,
@@ -64,7 +84,16 @@ class ShortcutsUpdater @Inject constructor(
 		return shortcutsUpdateJob?.join() != null
 	}
 
-	private suspend fun updateShortcutsImpl() = runCatching {
+	fun isDynamicShortcutsAvailable(): Boolean {
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N_MR1) {
+			return false
+		}
+		val manager = context.getSystemService(Context.SHORTCUT_SERVICE) as ShortcutManager
+		return manager.maxShortcutCountPerActivity > 0
+	}
+
+	@RequiresApi(Build.VERSION_CODES.N_MR1)
+	private suspend fun updateShortcutsImpl() = runCatchingCancellable {
 		val manager = context.getSystemService(Context.SHORTCUT_SERVICE) as ShortcutManager
 		val shortcuts = historyRepository.getList(0, manager.maxShortcutCountPerActivity)
 			.filter { x -> x.title.isNotEmpty() }
@@ -74,15 +103,25 @@ class ShortcutsUpdater @Inject constructor(
 		it.printStackTraceDebug()
 	}
 
+	@RequiresApi(Build.VERSION_CODES.N_MR1)
+	private fun clearShortcuts() {
+		val manager = context.getSystemService(Context.SHORTCUT_SERVICE) as ShortcutManager
+		try {
+			manager.removeAllDynamicShortcuts()
+		} catch (_: IllegalStateException) {
+		}
+	}
+
 	private suspend fun buildShortcutInfo(manga: Manga): ShortcutInfoCompat.Builder {
-		val icon = runCatching {
-			val bmp = coil.execute(
+		val icon = runCatchingCancellable {
+			coil.execute(
 				ImageRequest.Builder(context)
 					.data(manga.coverUrl)
 					.size(iconSize.width, iconSize.height)
+					.precision(Precision.EXACT)
+					.scale(Scale.FILL)
 					.build(),
 			).requireBitmap()
-			ThumbnailUtils.extractThumbnail(bmp, iconSize.width, iconSize.height, 0)
 		}.fold(
 			onSuccess = { IconCompat.createWithAdaptiveBitmap(it) },
 			onFailure = { IconCompat.createWithResource(context, R.drawable.ic_shortcut_default) },

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

@@ -11,20 +11,23 @@ import androidx.core.content.edit
 import androidx.preference.PreferenceManager
 import com.google.android.material.color.DynamicColors
 import dagger.hilt.android.qualifiers.ApplicationContext
-import java.io.File
-import java.text.DateFormat
-import java.text.SimpleDateFormat
-import java.util.*
-import javax.inject.Inject
-import javax.inject.Singleton
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.model.ZoomMode
 import org.koitharu.kotatsu.core.network.DoHProvider
 import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.utils.ext.getEnumValue
 import org.koitharu.kotatsu.utils.ext.observe
 import org.koitharu.kotatsu.utils.ext.putEnumValue
 import org.koitharu.kotatsu.utils.ext.toUriOrNull
+import java.io.File
+import java.text.DateFormat
+import java.text.SimpleDateFormat
+import java.util.Collections
+import java.util.EnumSet
+import java.util.Locale
+import javax.inject.Inject
+import javax.inject.Singleton
 
 @Singleton
 class AppSettings @Inject constructor(@ApplicationContext context: Context) {
@@ -65,6 +68,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val readerPageSwitch: Set<String>
 		get() = prefs.getStringSet(KEY_READER_SWITCHERS, null) ?: setOf(PAGE_SWITCH_TAPS)
 
+	val isReaderTapsAdaptive: Boolean
+		get() = !prefs.getBoolean(KEY_READER_TAPS_LTR, false)
+
 	var isTrafficWarningEnabled: Boolean
 		get() = prefs.getBoolean(KEY_TRAFFIC_WARNING, true)
 		set(value) = prefs.edit { putBoolean(KEY_TRAFFIC_WARNING, value) }
@@ -134,6 +140,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isExitConfirmationEnabled: Boolean
 		get() = prefs.getBoolean(KEY_EXIT_CONFIRM, false)
 
+	val isDynamicShortcutsEnabled: Boolean
+		get() = prefs.getBoolean(KEY_SHORTCUTS, true)
+
 	var sourcesOrder: List<String>
 		get() = prefs.getString(KEY_SOURCES_ORDER, null)
 			?.split('|')
@@ -199,9 +208,19 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isReaderBarEnabled: Boolean
 		get() = prefs.getBoolean(KEY_READER_BAR, true)
 
+	val isReaderSliderEnabled: Boolean
+		get() = prefs.getBoolean(KEY_READER_SLIDER, true)
+
 	val dnsOverHttps: DoHProvider
 		get() = prefs.getEnumValue(KEY_DOH, DoHProvider.NONE)
 
+	var localListOrder: SortOrder
+		get() = prefs.getEnumValue(KEY_LOCAL_LIST_ORDER, SortOrder.NEWEST)
+		set(value) = prefs.edit { putEnumValue(KEY_LOCAL_LIST_ORDER, value) }
+
+	val isWebtoonZoomEnable: Boolean
+		get() = prefs.getBoolean(KEY_WEBTOON_ZOOM, true)
+
 	fun isPagesPreloadAllowed(cm: ConnectivityManager): Boolean {
 		return when (prefs.getString(KEY_PAGES_PRELOAD, null)?.toIntOrNull()) {
 			NETWORK_ALWAYS -> true
@@ -317,6 +336,11 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_INCOGNITO_MODE = "incognito"
 		const val KEY_SYNC = "sync"
 		const val KEY_READER_BAR = "reader_bar"
+		const val KEY_READER_SLIDER = "reader_slider"
+		const val KEY_SHORTCUTS = "dynamic_shortcuts"
+		const val KEY_READER_TAPS_LTR = "reader_taps_ltr"
+		const val KEY_LOCAL_LIST_ORDER = "local_order"
+		const val KEY_WEBTOON_ZOOM = "webtoon_zoom"
 
 		// About
 		const val KEY_APP_UPDATE = "app_update"

app/src/main/java/org/koitharu/kotatsu/core/ui/MangaErrorDialog.kt

@@ -54,7 +54,7 @@ class MangaErrorDialog : AlertDialogFragment<DialogMangaErrorBinding>() {
 			.setNegativeButton(android.R.string.cancel, null)
 			.setPositiveButton(R.string.report) { _, _ ->
 				dismiss()
-				error.report(TAG)
+				error.report()
 			}.setTitle(R.string.error_occurred)
 	}
 

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

@@ -6,8 +6,6 @@ import androidx.appcompat.view.ActionMode
 import androidx.coordinatorlayout.widget.CoordinatorLayout
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
-import androidx.core.view.updateLayoutParams
-import androidx.core.view.updatePadding
 import androidx.fragment.app.activityViewModels
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.snackbar.Snackbar
@@ -202,18 +200,4 @@ class ChaptersFragment :
 	private fun onLoadingStateChanged(isLoading: Boolean) {
 		binding.progressBar.isVisible = isLoading
 	}
-
-	private fun findBottomSheetBehavior(): BottomSheetBehavior<*>? {
-		val v = view ?: return null
-		for (p in v.parents) {
-			val layoutParams = (p as? View)?.layoutParams
-			if (layoutParams is CoordinatorLayout.LayoutParams) {
-				val behavior = layoutParams.behavior
-				if (behavior is BottomSheetBehavior<*>) {
-					return behavior
-				}
-			}
-		}
-		return null
-	}
 }

app/src/main/java/org/koitharu/kotatsu/details/ui/ChaptersMenuProvider.kt

@@ -23,8 +23,8 @@ class ChaptersMenuProvider(
 	}
 
 	override fun onPrepareMenu(menu: Menu) {
-		menu.findItem(R.id.action_reversed).isChecked = viewModel.isChaptersReversed.value == true
-		menu.findItem(R.id.action_search).isVisible = viewModel.isChaptersEmpty.value == false
+		menu.findItem(R.id.action_reversed)?.isChecked = viewModel.isChaptersReversed.value == true
+		menu.findItem(R.id.action_search)?.isVisible = viewModel.isChaptersEmpty.value == false
 	}
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean = when (menuItem.itemId) {

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

@@ -19,12 +19,10 @@ import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
 import androidx.lifecycle.lifecycleScope
-import com.google.android.material.badge.BadgeDrawable
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.snackbar.BaseTransientBottomBar
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.MangaIntent
@@ -37,12 +35,17 @@ import org.koitharu.kotatsu.core.ui.MangaErrorDialog
 import org.koitharu.kotatsu.databinding.ActivityDetailsBinding
 import org.koitharu.kotatsu.details.ui.model.HistoryInfo
 import org.koitharu.kotatsu.download.ui.service.DownloadService
-import org.koitharu.kotatsu.list.ui.adapter.bindBadge
 import org.koitharu.kotatsu.main.ui.owners.NoModalBottomSheetOwner
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.reader.ui.ReaderActivity
 import org.koitharu.kotatsu.reader.ui.ReaderState
-import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.ViewBadge
+import org.koitharu.kotatsu.utils.ext.assistedViewModels
+import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.isReportable
+import org.koitharu.kotatsu.utils.ext.setNavigationBarTransparentCompat
+import org.koitharu.kotatsu.utils.ext.textAndVisible
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class DetailsActivity :
@@ -60,7 +63,7 @@ class DetailsActivity :
 	@Inject
 	lateinit var shortcutsUpdater: ShortcutsUpdater
 
-	private var badge: BadgeDrawable? = null
+	private lateinit var viewBadge: ViewBadge
 
 	private val viewModel: DetailsViewModel by assistedViewModels {
 		viewModelFactory.create(MangaIntent(intent))
@@ -83,6 +86,7 @@ class DetailsActivity :
 		}
 		binding.buttonRead.setOnClickListener(this)
 		binding.buttonDropdown.setOnClickListener(this)
+		viewBadge = ViewBadge(binding.buttonRead, this)
 
 		chaptersMenuProvider = if (binding.layoutBottom != null) {
 			val bsMediator = ChaptersBottomSheetMediator(checkNotNull(binding.layoutBottom))
@@ -151,6 +155,7 @@ class DetailsActivity :
 					)
 				}
 			}
+
 			R.id.button_dropdown -> showBranchPopupMenu()
 		}
 	}
@@ -188,10 +193,12 @@ class DetailsActivity :
 			ExceptionResolver.canResolve(e) -> {
 				resolveError(e)
 			}
+
 			manga == null -> {
 				Toast.makeText(this, e.getDisplayMessage(resources), Toast.LENGTH_LONG).show()
 				finishAfterTransition()
 			}
+
 			else -> {
 				val snackbar = makeSnackbar(
 					e.getDisplayMessage(resources),
@@ -242,7 +249,7 @@ class DetailsActivity :
 	}
 
 	private fun onNewChaptersChanged(newChapters: Int) {
-		badge = binding.buttonRead.bindBadge(badge, newChapters)
+		viewBadge.counter = newChapters
 	}
 
 	fun showChapterMissingDialog(chapterId: Long) {

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

@@ -45,6 +45,7 @@ import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.asFlowLiveData
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
 class DetailsViewModel @AssistedInject constructor(
 	@Assisted intent: MangaIntent,
@@ -189,7 +190,7 @@ class DetailsViewModel @AssistedInject constructor(
 			checkNotNull(manga) { "Cannot find saved manga for ${m.title}" }
 			val original = localMangaRepository.getRemoteManga(manga)
 			localMangaRepository.delete(manga) || throw IOException("Unable to delete file")
-			runCatching {
+			runCatchingCancellable {
 				historyRepository.deleteOrSwap(manga, original)
 			}
 			onMangaRemoved.postCall(manga)
@@ -228,7 +229,7 @@ class DetailsViewModel @AssistedInject constructor(
 			reload()
 		} else {
 			viewModelScope.launch(Dispatchers.Default) {
-				runCatching {
+				runCatchingCancellable {
 					localMangaRepository.getDetails(downloadedManga)
 				}.onSuccess {
 					delegate.relatedManga.value = it

app/src/main/java/org/koitharu/kotatsu/details/ui/MangaDetailsDelegate.kt

@@ -17,6 +17,7 @@ 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.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
 class MangaDetailsDelegate(
 	private val intent: MangaIntent,
@@ -45,9 +46,9 @@ class MangaDetailsDelegate(
 		val hist = historyRepository.getOne(manga)
 		selectedBranch.value = manga.getPreferredBranch(hist)
 		mangaData.value = manga
-		relatedManga.value = runCatching {
+		relatedManga.value = runCatchingCancellable {
 			if (manga.source == MangaSource.LOCAL) {
-				val m = localMangaRepository.getRemoteManga(manga) ?: return@runCatching null
+				val m = localMangaRepository.getRemoteManga(manga) ?: return@runCatchingCancellable null
 				mangaRepositoryFactory.create(m.source).getDetails(m)
 			} else {
 				localMangaRepository.findSavedManga(manga)

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

@@ -34,7 +34,7 @@ fun chapterListItemAD(
 		when (item.status) {
 			FLAG_UNREAD -> {
 				binding.textViewNumber.setBackgroundResource(R.drawable.bg_badge_default)
-				binding.textViewNumber.setTextColor(context.getThemeColor(android.R.attr.textColorSecondaryInverse))
+				binding.textViewNumber.setTextColor(context.getThemeColor(com.google.android.material.R.attr.colorOnTertiary))
 			}
 			FLAG_CURRENT -> {
 				binding.textViewNumber.setBackgroundResource(R.drawable.bg_badge_accent)
@@ -53,4 +53,4 @@ fun chapterListItemAD(
 		binding.imageViewDownloaded.isVisible = item.hasFlag(FLAG_DOWNLOADED)
 		binding.imageViewNew.isVisible = item.hasFlag(FLAG_NEW)
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/download/domain/DownloadManager.kt

@@ -9,11 +9,18 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import dagger.hilt.android.qualifiers.ApplicationContext
-import java.io.File
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
+import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.internal.closeQuietly
@@ -32,7 +39,9 @@ import org.koitharu.kotatsu.parsers.util.await
 import org.koitharu.kotatsu.utils.ext.deleteAwait
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.referer
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 import org.koitharu.kotatsu.utils.progress.PausingProgressJob
+import java.io.File
 
 private const val MAX_FAILSAFE_ATTEMPTS = 2
 private const val DOWNLOAD_ERROR_DELAY = 500L
@@ -155,7 +164,7 @@ class DownloadManager @AssistedInject constructor(
 					}
 					outState.value = DownloadState.PostProcessing(startId, data, cover)
 					output.mergeWithExisting()
-					output.finalize()
+					output.finish()
 					val localManga = localMangaRepository.getFromFile(output.file)
 					outState.value = DownloadState.Done(startId, data, cover, localManga)
 				} catch (e: CancellationException) {
@@ -231,7 +240,7 @@ class DownloadManager @AssistedInject constructor(
 			)
 		}
 
-	private suspend fun loadCover(manga: Manga) = runCatching {
+	private suspend fun loadCover(manga: Manga) = runCatchingCancellable {
 		imageLoader.execute(
 			ImageRequest.Builder(context)
 				.data(manga.coverUrl)

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

@@ -34,7 +34,7 @@ class DownloadsActivity : BaseActivity<ActivityDownloadsBinding>() {
 		setContentView(ActivityDownloadsBinding.inflate(layoutInflater))
 		supportActionBar?.setDisplayHomeAsUpEnabled(true)
 		val adapter = DownloadsAdapter(lifecycleScope, coil)
-		val spacing = resources.getDimensionPixelOffset(R.dimen.grid_spacing)
+		val spacing = resources.getDimensionPixelOffset(R.dimen.list_spacing)
 		binding.recyclerView.addItemDecoration(SpacingItemDecoration(spacing))
 		binding.recyclerView.setHasFixedSize(true)
 		binding.recyclerView.adapter = adapter

app/src/main/java/org/koitharu/kotatsu/download/ui/service/DownloadService.kt

@@ -16,10 +16,12 @@ import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import dagger.hilt.android.AndroidEntryPoint
-import java.util.concurrent.TimeUnit
-import javax.inject.Inject
-import kotlin.collections.set
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.transformWhile
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.R
@@ -28,10 +30,14 @@ import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
 import org.koitharu.kotatsu.download.domain.DownloadManager
 import org.koitharu.kotatsu.download.domain.DownloadState
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.utils.ext.getParcelableExtraCompat
 import org.koitharu.kotatsu.utils.ext.throttle
 import org.koitharu.kotatsu.utils.progress.PausingProgressJob
 import org.koitharu.kotatsu.utils.progress.ProgressJob
 import org.koitharu.kotatsu.utils.progress.TimeLeftEstimator
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+import kotlin.collections.set
 
 @AndroidEntryPoint
 class DownloadService : BaseService() {
@@ -65,7 +71,7 @@ class DownloadService : BaseService() {
 
 	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
 		super.onStartCommand(intent, flags, startId)
-		val manga = intent?.getParcelableExtra<ParcelableManga>(EXTRA_MANGA)?.manga
+		val manga = intent?.getParcelableExtraCompat<ParcelableManga>(EXTRA_MANGA)?.manga
 		val chapters = intent?.getLongArrayExtra(EXTRA_CHAPTERS_IDS)
 		return if (manga != null) {
 			jobs[startId] = downloadManga(startId, manga, chapters)
@@ -84,7 +90,9 @@ class DownloadService : BaseService() {
 
 	override fun onDestroy() {
 		unregisterReceiver(controlReceiver)
-		wakeLock.release()
+		if (wakeLock.isHeld) {
+			wakeLock.release()
+		}
 		isRunning = false
 		super.onDestroy()
 	}
@@ -168,6 +176,7 @@ class DownloadService : BaseService() {
 					val cancelId = intent.getIntExtra(EXTRA_CANCEL_ID, 0)
 					jobs[cancelId]?.cancel()
 				}
+
 				ACTION_DOWNLOAD_RESUME -> {
 					val cancelId = intent.getIntExtra(EXTRA_CANCEL_ID, 0)
 					jobs[cancelId]?.resume()
@@ -254,7 +263,7 @@ class DownloadService : BaseService() {
 
 		fun getDownloadedManga(intent: Intent?): Manga? {
 			if (intent?.action == ACTION_DOWNLOAD_COMPLETE) {
-				return intent.getParcelableExtra<ParcelableManga>(EXTRA_MANGA)?.manga
+				return intent.getParcelableExtraCompat<ParcelableManga>(EXTRA_MANGA)?.manga
 			}
 			return null
 		}

app/src/main/java/org/koitharu/kotatsu/explore/ui/ExploreViewModel.kt

@@ -61,7 +61,7 @@ class ExploreViewModel @Inject constructor(
 			sources.mapTo(result) { ExploreItem.Source(it) }
 		} else {
 			result += ExploreItem.EmptyHint(
-				icon = R.drawable.ic_empty_search,
+				icon = R.drawable.ic_empty_common,
 				textPrimary = R.string.no_manga_sources,
 				textSecondary = R.string.no_manga_sources_text,
 				actionStringRes = R.string.manage,

app/src/main/java/org/koitharu/kotatsu/explore/ui/model/ExploreItem.kt

@@ -1,6 +1,5 @@
 package org.koitharu.kotatsu.explore.ui.model
 
-import android.net.Uri
 import androidx.annotation.DrawableRes
 import androidx.annotation.StringRes
 import org.koitharu.kotatsu.list.ui.model.EmptyState
@@ -73,6 +72,7 @@ sealed interface ExploreItem : ListModel {
 		}
 	}
 
+	@Deprecated("")
 	class EmptyHint(
 		@DrawableRes icon: Int,
 		@StringRes textPrimary: Int,
@@ -81,4 +81,4 @@ sealed interface ExploreItem : ListModel {
 	) : EmptyState(icon, textPrimary, textSecondary, actionStringRes), ExploreItem
 
 	object Loading : ExploreItem
-}
+}

app/src/main/java/org/koitharu/kotatsu/favourites/ui/FavouritesActivity.kt

@@ -13,6 +13,7 @@ import org.koitharu.kotatsu.core.model.FavouriteCategory
 import org.koitharu.kotatsu.databinding.ActivityContainerBinding
 import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment
 import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment.Companion.NO_ID
+import kotlin.text.Typography.dagger
 
 @AndroidEntryPoint
 class FavouritesActivity : BaseActivity<ActivityContainerBinding>() {
@@ -28,6 +29,7 @@ class FavouritesActivity : BaseActivity<ActivityContainerBinding>() {
 		val fm = supportFragmentManager
 		if (fm.findFragmentById(R.id.container) == null) {
 			fm.commit {
+				setReorderingAllowed(true)
 				val fragment = FavouritesListFragment.newInstance(intent.getLongExtra(EXTRA_CATEGORY_ID, NO_ID))
 				replace(R.id.container, fragment)
 			}

app/src/main/java/org/koitharu/kotatsu/favourites/ui/categories/adapter/CategoriesAdapter.kt

@@ -4,12 +4,12 @@ import androidx.lifecycle.LifecycleOwner
 import androidx.recyclerview.widget.DiffUtil
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
+import kotlin.jvm.internal.Intrinsics
 import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesListListener
 import org.koitharu.kotatsu.list.ui.adapter.ListStateHolderListener
 import org.koitharu.kotatsu.list.ui.adapter.emptyStateListAD
 import org.koitharu.kotatsu.list.ui.adapter.loadingStateAD
 import org.koitharu.kotatsu.list.ui.model.ListModel
-import kotlin.jvm.internal.Intrinsics
 
 class CategoriesAdapter(
 	coil: ImageLoader,
@@ -20,7 +20,7 @@ class CategoriesAdapter(
 
 	init {
 		delegatesManager.addDelegate(categoryAD(coil, lifecycleOwner, onItemClickListener))
-			.addDelegate(emptyStateListAD(listListener))
+			.addDelegate(emptyStateListAD(coil, listListener))
 			.addDelegate(loadingStateAD())
 	}
 
@@ -56,4 +56,4 @@ class CategoriesAdapter(
 			}
 		}
 	}
-}
+}

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

@@ -14,6 +14,7 @@ import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.core.view.updateLayoutParams
 import androidx.core.view.updatePadding
+import com.google.android.material.R as materialR
 import dagger.hilt.android.AndroidEntryPoint
 import javax.inject.Inject
 import org.koitharu.kotatsu.R
@@ -47,7 +48,7 @@ class FavouritesCategoryEditActivity :
 		setContentView(ActivityCategoryEditBinding.inflate(layoutInflater))
 		supportActionBar?.run {
 			setDisplayHomeAsUpEnabled(true)
-			setHomeAsUpIndicator(com.google.android.material.R.drawable.abc_ic_clear_material)
+			setHomeAsUpIndicator(materialR.drawable.abc_ic_clear_material)
 		}
 		initSortSpinner()
 		binding.buttonDone.setOnClickListener(this)

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

@@ -28,6 +28,7 @@ import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.asFlowLiveData
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
 class FavouritesListViewModel @AssistedInject constructor(
 	@Assisted private val categoryId: Long,
@@ -69,6 +70,7 @@ class FavouritesListViewModel @AssistedInject constructor(
 					actionStringRes = 0,
 				),
 			)
+
 			else -> list.toUi(mode, this)
 		}
 	}.catch {
@@ -79,7 +81,7 @@ class FavouritesListViewModel @AssistedInject constructor(
 		if (categoryId != NO_ID) {
 			launchJob {
 				categoryName = withContext(Dispatchers.Default) {
-					runCatching {
+					runCatchingCancellable {
 						repository.getCategory(categoryId).title
 					}.getOrNull()
 				}

app/src/main/java/org/koitharu/kotatsu/history/ui/HistoryActivity.kt

@@ -12,6 +12,7 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseActivity
 import org.koitharu.kotatsu.databinding.ActivityContainerBinding
 import org.koitharu.kotatsu.main.ui.owners.AppBarOwner
+import kotlin.text.Typography.dagger
 
 @AndroidEntryPoint
 class HistoryActivity :
@@ -28,6 +29,7 @@ class HistoryActivity :
 		val fm = supportFragmentManager
 		if (fm.findFragmentById(R.id.container) == null) {
 			fm.commit {
+				setReorderingAllowed(true)
 				val fragment = HistoryListFragment.newInstance()
 				replace(R.id.container, fragment)
 			}

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

@@ -5,9 +5,9 @@ import android.view.Menu
 import android.view.MenuInflater
 import android.view.MenuItem
 import androidx.core.view.MenuProvider
+import com.google.android.material.R as materialR
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import org.koitharu.kotatsu.R
-import com.google.android.material.R as materialR
 
 class HistoryListMenuProvider(
 	private val context: Context,
@@ -38,6 +38,6 @@ class HistoryListMenuProvider(
 	}
 
 	override fun onPrepareMenu(menu: Menu) {
-		menu.findItem(R.id.action_history_grouping).isChecked = viewModel.isGroupingEnabled.value == true
+		menu.findItem(R.id.action_history_grouping)?.isChecked = viewModel.isGroupingEnabled.value == true
 	}
 }

app/src/main/java/org/koitharu/kotatsu/image/ui/ImageActivity.kt

@@ -79,7 +79,7 @@ class ImageActivity : BaseActivity<ActivityImageBinding>() {
 
 		private fun setDrawable(drawable: Drawable?) {
 			if (drawable != null) {
-				view.setImage(ImageSource.bitmap(drawable.toBitmap()))
+				view.setImage(ImageSource.Bitmap(drawable.toBitmap()))
 			} else {
 				view.recycle()
 			}

app/src/main/java/org/koitharu/kotatsu/library/domain/LibraryRepository.kt

@@ -1,38 +0,0 @@
-package org.koitharu.kotatsu.library.domain
-
-import javax.inject.Inject
-import kotlinx.coroutines.flow.*
-import org.koitharu.kotatsu.core.db.MangaDatabase
-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.favourites.data.FavouriteCategoryEntity
-import org.koitharu.kotatsu.favourites.data.toFavouriteCategory
-import org.koitharu.kotatsu.parsers.model.Manga
-
-class LibraryRepository @Inject constructor(
-	private val db: MangaDatabase,
-) {
-
-	fun observeFavourites(): Flow<Map<FavouriteCategory, List<Manga>>> {
-		return db.favouriteCategoriesDao.observeAll()
-			.flatMapLatest { categories ->
-				val cats = categories.filter { it.isVisibleInLibrary }
-				if (cats.isEmpty()) {
-					flowOf(emptyMap())
-				} else {
-					observeCategoriesContent(cats)
-				}
-			}
-	}
-
-	private fun observeCategoriesContent(
-		categories: List<FavouriteCategoryEntity>,
-	) = combine<Pair<FavouriteCategory, List<Manga>>, Map<FavouriteCategory, List<Manga>>>(
-		categories.map { cat ->
-			val category = cat.toFavouriteCategory()
-			db.favouritesDao.observeAll(category.id, category.order)
-				.map { category to it.map { x -> x.manga.toManga(x.tags.toMangaTags()) } }
-		},
-	) { array -> array.toMap() }
-}

app/src/main/java/org/koitharu/kotatsu/library/ui/adapter/LibraryListEventListener.kt

@@ -1,15 +0,0 @@
-package org.koitharu.kotatsu.library.ui.adapter
-
-import android.view.View
-import org.koitharu.kotatsu.library.ui.model.LibrarySectionModel
-import org.koitharu.kotatsu.list.ui.adapter.ListStateHolderListener
-import org.koitharu.kotatsu.parsers.model.Manga
-
-interface LibraryListEventListener : ListStateHolderListener {
-
-	fun onItemClick(item: Manga, section: LibrarySectionModel, view: View)
-
-	fun onItemLongClick(item: Manga, section: LibrarySectionModel, view: View): Boolean
-
-	fun onSectionClick(section: LibrarySectionModel, view: View)
-}

app/src/main/java/org/koitharu/kotatsu/library/ui/model/LibrarySectionModel.kt

@@ -1,94 +0,0 @@
-package org.koitharu.kotatsu.library.ui.model
-
-import android.content.res.Resources
-import androidx.annotation.StringRes
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.core.ui.DateTimeAgo
-import org.koitharu.kotatsu.list.ui.model.ListModel
-import org.koitharu.kotatsu.list.ui.model.MangaItemModel
-
-sealed class LibrarySectionModel(
-	val items: List<MangaItemModel>,
-	@StringRes val showAllButtonText: Int,
-) : ListModel {
-
-	abstract val key: Any
-	abstract fun getTitle(resources: Resources): CharSequence
-
-	class History(
-		items: List<MangaItemModel>,
-		val timeAgo: DateTimeAgo?,
-		showAllButtonText: Int,
-	) : LibrarySectionModel(items, showAllButtonText) {
-
-		override val key: Any
-			get() = timeAgo?.javaClass ?: this::class.java
-
-		override fun getTitle(resources: Resources): CharSequence {
-			return timeAgo?.format(resources) ?: resources.getString(R.string.history)
-		}
-
-		override fun equals(other: Any?): Boolean {
-			if (this === other) return true
-			if (javaClass != other?.javaClass) return false
-
-			other as History
-
-			if (timeAgo != other.timeAgo) return false
-			if (showAllButtonText != other.showAllButtonText) return false
-			if (items != other.items) return false
-
-			return true
-		}
-
-		override fun hashCode(): Int {
-			var result = items.hashCode()
-			result = 31 * result + (timeAgo?.hashCode() ?: 0)
-			result = 31 * result + showAllButtonText.hashCode()
-			return result
-		}
-
-		override fun toString(): String {
-			return "hist_$timeAgo"
-		}
-	}
-
-	class Favourites(
-		items: List<MangaItemModel>,
-		val category: FavouriteCategory,
-		showAllButtonText: Int,
-	) : LibrarySectionModel(items, showAllButtonText) {
-
-		override val key: Any
-			get() = category.id
-
-		override fun getTitle(resources: Resources): CharSequence {
-			return category.title
-		}
-
-		override fun equals(other: Any?): Boolean {
-			if (this === other) return true
-			if (javaClass != other?.javaClass) return false
-
-			other as Favourites
-
-			if (category != other.category) return false
-			if (showAllButtonText != other.showAllButtonText) return false
-			if (items != other.items) return false
-
-			return true
-		}
-
-		override fun hashCode(): Int {
-			var result = items.hashCode()
-			result = 31 * result + category.hashCode()
-			result = 31 * result + showAllButtonText.hashCode()
-			return result
-		}
-
-		override fun toString(): String {
-			return "fav_${category.id}"
-		}
-	}
-}

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

@@ -6,24 +6,23 @@ import android.view.View
 import android.view.ViewGroup
 import androidx.core.view.isVisible
 import androidx.fragment.app.FragmentManager
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.button.MaterialButtonToggleGroup
 import com.google.android.material.slider.Slider
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.base.ui.AlertDialogFragment
-import org.koitharu.kotatsu.base.ui.widgets.CheckableButtonGroup
+import org.koitharu.kotatsu.base.ui.BaseBottomSheet
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.ListMode
 import org.koitharu.kotatsu.databinding.DialogListModeBinding
 import org.koitharu.kotatsu.utils.ext.setValueRounded
 import org.koitharu.kotatsu.utils.progress.IntPercentLabelFormatter
+import javax.inject.Inject
 
 @AndroidEntryPoint
-class ListModeSelectDialog :
-	AlertDialogFragment<DialogListModeBinding>(),
-	CheckableButtonGroup.OnCheckedChangeListener,
-	Slider.OnChangeListener {
+class ListModeBottomSheet :
+	BaseBottomSheet<DialogListModeBinding>(),
+	Slider.OnChangeListener,
+	MaterialButtonToggleGroup.OnButtonCheckedListener {
 
 	@Inject
 	lateinit var settings: AppSettings
@@ -33,13 +32,6 @@ class ListModeSelectDialog :
 		container: ViewGroup?,
 	) = DialogListModeBinding.inflate(inflater, container, false)
 
-	override fun onBuildDialog(builder: MaterialAlertDialogBuilder): MaterialAlertDialogBuilder {
-		return super.onBuildDialog(builder)
-			.setTitle(R.string.list_mode)
-			.setPositiveButton(R.string.done, null)
-			.setCancelable(true)
-	}
-
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
 		val mode = settings.listMode
@@ -53,10 +45,10 @@ class ListModeSelectDialog :
 		binding.sliderGrid.setValueRounded(settings.gridSize.toFloat())
 		binding.sliderGrid.addOnChangeListener(this)
 
-		binding.checkableGroup.onCheckedChangeListener = this
+		binding.checkableGroup.addOnButtonCheckedListener(this)
 	}
 
-	override fun onCheckedChanged(group: CheckableButtonGroup, checkedId: Int) {
+	override fun onButtonChecked(group: MaterialButtonToggleGroup?, checkedId: Int, isChecked: Boolean) {
 		val mode = when (checkedId) {
 			R.id.button_list -> ListMode.LIST
 			R.id.button_list_detailed -> ListMode.DETAILED_LIST
@@ -78,6 +70,6 @@ class ListModeSelectDialog :
 
 		private const val TAG = "ListModeSelectDialog"
 
-		fun show(fm: FragmentManager) = ListModeSelectDialog().show(fm, TAG)
+		fun show(fm: FragmentManager) = ListModeBottomSheet().show(fm, TAG)
 	}
 }

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

@@ -17,9 +17,10 @@ class MangaListMenuProvider(
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean = when (menuItem.itemId) {
 		R.id.action_list_mode -> {
-			ListModeSelectDialog.show(fragment.childFragmentManager)
+			ListModeBottomSheet.show(fragment.childFragmentManager)
 			true
 		}
+
 		else -> false
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/list/ui/adapter/BadgeADUtil.kt

@@ -1,13 +1,13 @@
-@file:SuppressLint("UnsafeOptInUsageError")
 package org.koitharu.kotatsu.list.ui.adapter
 
-import android.annotation.SuppressLint
 import android.view.View
+import androidx.annotation.CheckResult
 import androidx.core.view.doOnNextLayout
 import com.google.android.material.badge.BadgeDrawable
 import com.google.android.material.badge.BadgeUtils
 import org.koitharu.kotatsu.R
 
+@CheckResult
 fun View.bindBadge(badge: BadgeDrawable?, counter: Int): BadgeDrawable? {
 	return if (counter > 0) {
 		val badgeDrawable = badge ?: initBadge(this)
@@ -39,4 +39,4 @@ private fun initBadge(anchor: View): BadgeDrawable {
 private fun BadgeDrawable.align() {
 	horizontalOffset = intrinsicWidth
 	verticalOffset = intrinsicHeight
-}
+}

app/src/main/java/org/koitharu/kotatsu/list/ui/adapter/EmptyHintAD.kt

@@ -0,0 +1,23 @@
+package org.koitharu.kotatsu.list.ui.adapter
+
+import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
+import org.koitharu.kotatsu.databinding.ItemEmptyCardBinding
+import org.koitharu.kotatsu.list.ui.model.EmptyHint
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.utils.ext.setTextAndVisible
+
+fun emptyHintAD(
+	listener: ListStateHolderListener,
+) = adapterDelegateViewBinding<EmptyHint, ListModel, ItemEmptyCardBinding>(
+	{ inflater, parent -> ItemEmptyCardBinding.inflate(inflater, parent, false) },
+) {
+
+	binding.buttonRetry.setOnClickListener { listener.onEmptyActionClick() }
+
+	bind {
+		binding.icon.setImageResource(item.icon)
+		binding.textPrimary.setText(item.textPrimary)
+		binding.textSecondary.setTextAndVisible(item.textSecondary)
+		binding.buttonRetry.setTextAndVisible(item.actionStringRes)
+	}
+}

app/src/main/java/org/koitharu/kotatsu/list/ui/adapter/EmptyStateListAD.kt

@@ -1,23 +1,31 @@
 package org.koitharu.kotatsu.list.ui.adapter
 
+import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.databinding.ItemEmptyStateBinding
 import org.koitharu.kotatsu.list.ui.model.EmptyState
 import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.utils.ext.disposeImageRequest
+import org.koitharu.kotatsu.utils.ext.enqueueWith
+import org.koitharu.kotatsu.utils.ext.newImageRequest
 import org.koitharu.kotatsu.utils.ext.setTextAndVisible
 
 fun emptyStateListAD(
+	coil: ImageLoader,
 	listener: ListStateHolderListener,
 ) = adapterDelegateViewBinding<EmptyState, ListModel, ItemEmptyStateBinding>(
-	{ inflater, parent -> ItemEmptyStateBinding.inflate(inflater, parent, false) }
+	{ inflater, parent -> ItemEmptyStateBinding.inflate(inflater, parent, false) },
 ) {
-
 	binding.buttonRetry.setOnClickListener { listener.onEmptyActionClick() }
 
 	bind {
-		binding.icon.setImageResource(item.icon)
+		binding.icon.newImageRequest(item.icon)?.enqueueWith(coil)
 		binding.textPrimary.setText(item.textPrimary)
 		binding.textSecondary.setTextAndVisible(item.textSecondary)
 		binding.buttonRetry.setTextAndVisible(item.actionStringRes)
 	}
-}
+
+	onViewRecycled {
+		binding.icon.disposeImageRequest()
+	}
+}

app/src/main/java/org/koitharu/kotatsu/list/ui/adapter/MangaListAdapter.kt

@@ -4,9 +4,9 @@ import androidx.lifecycle.LifecycleOwner
 import androidx.recyclerview.widget.DiffUtil
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
+import kotlin.jvm.internal.Intrinsics
 import org.koitharu.kotatsu.core.ui.DateTimeAgo
 import org.koitharu.kotatsu.list.ui.model.*
-import kotlin.jvm.internal.Intrinsics
 
 open class MangaListAdapter(
 	coil: ImageLoader,
@@ -24,7 +24,7 @@ open class MangaListAdapter(
 			.addDelegate(ITEM_TYPE_DATE, relatedDateItemAD())
 			.addDelegate(ITEM_TYPE_ERROR_STATE, errorStateListAD(listener))
 			.addDelegate(ITEM_TYPE_ERROR_FOOTER, errorFooterAD(listener))
-			.addDelegate(ITEM_TYPE_EMPTY, emptyStateListAD(listener))
+			.addDelegate(ITEM_TYPE_EMPTY, emptyStateListAD(coil, listener))
 			.addDelegate(ITEM_TYPE_HEADER, listHeaderAD(listener))
 			.addDelegate(ITEM_TYPE_HEADER_2, listHeader2AD(listener))
 	}

app/src/main/java/org/koitharu/kotatsu/list/ui/adapter/MangaListDetailedItemAD.kt

@@ -46,7 +46,7 @@ fun mangaListDetailedItemAD(
 		}
 		binding.textViewRating.textAndVisible = item.rating
 		binding.textViewTags.text = item.tags
-		itemView.bindBadge(badge, item.counter)
+		badge = itemView.bindBadge(badge, item.counter)
 	}
 
 	onViewRecycled {

app/src/main/java/org/koitharu/kotatsu/list/ui/adapter/MangaListItemAD.kt

@@ -40,7 +40,7 @@ fun mangaListItemAD(
 			lifecycle(lifecycleOwner)
 			enqueueWith(coil)
 		}
-		itemView.bindBadge(badge, item.counter)
+		badge = itemView.bindBadge(badge, item.counter)
 	}
 
 	onViewRecycled {

app/src/main/java/org/koitharu/kotatsu/list/ui/filter/FilterAdapter.kt

@@ -1,9 +1,11 @@
 package org.koitharu.kotatsu.list.ui.filter
 
+import androidx.recyclerview.widget.AsyncListDiffer.ListListener
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
 
 class FilterAdapter(
 	listener: OnFilterChangedListener,
+	listListener: ListListener<FilterItem>,
 ) : AsyncListDifferDelegationAdapter<FilterItem>(
 	FilterDiffCallback(),
 	filterSortDelegate(listener),
@@ -11,4 +13,9 @@ class FilterAdapter(
 	filterHeaderDelegate(),
 	filterLoadingDelegate(),
 	filterErrorDelegate(),
-)
+) {
+
+	init {
+		differ.addListListener(listListener)
+	}
+}

app/src/main/java/org/koitharu/kotatsu/list/ui/filter/FilterBottomSheet.kt

@@ -6,17 +6,21 @@ import android.os.Bundle
 import android.view.*
 import androidx.appcompat.widget.SearchView
 import androidx.fragment.app.FragmentManager
+import androidx.recyclerview.widget.AsyncListDiffer
+import androidx.recyclerview.widget.LinearLayoutManager
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseBottomSheet
 import org.koitharu.kotatsu.databinding.SheetFilterBinding
 import org.koitharu.kotatsu.remotelist.ui.RemoteListViewModel
+import org.koitharu.kotatsu.utils.ext.isScrolledToTop
 import org.koitharu.kotatsu.utils.ext.parentFragmentViewModels
 
 class FilterBottomSheet :
 	BaseBottomSheet<SheetFilterBinding>(),
 	MenuItem.OnActionExpandListener,
 	SearchView.OnQueryTextListener,
-	DialogInterface.OnKeyListener {
+	DialogInterface.OnKeyListener,
+	AsyncListDiffer.ListListener<FilterItem> {
 
 	private val viewModel by parentFragmentViewModels<RemoteListViewModel>()
 
@@ -32,7 +36,7 @@ class FilterBottomSheet :
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
-		val adapter = FilterAdapter(viewModel)
+		val adapter = FilterAdapter(viewModel, this)
 		binding.recyclerView.adapter = adapter
 		viewModel.filterItems.observe(viewLifecycleOwner, adapter::setItems)
 		initOptionsMenu()
@@ -70,6 +74,12 @@ class FilterBottomSheet :
 		return false
 	}
 
+	override fun onCurrentListChanged(previousList: MutableList<FilterItem>, currentList: MutableList<FilterItem>) {
+		if (currentList.size > previousList.size && view != null) {
+			(binding.recyclerView.layoutManager as LinearLayoutManager).scrollToPositionWithOffset(0, 0)
+		}
+	}
+
 	private fun initOptionsMenu() {
 		binding.headerBar.toolbar.inflateMenu(R.menu.opt_filter)
 		val searchMenuItem = binding.headerBar.toolbar.menu.findItem(R.id.action_search)

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

@@ -6,15 +6,22 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.update
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
 import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.parsers.model.MangaTag
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 import java.text.Collator
-import java.util.*
+import java.util.Locale
+import java.util.TreeSet
 
 class FilterCoordinator(
 	private val repository: RemoteMangaRepository,
@@ -153,7 +160,7 @@ class FilterCoordinator(
 	}
 
 	private fun loadTagsAsync() = coroutineScope.async(Dispatchers.Default, CoroutineStart.LAZY) {
-		runCatching {
+		runCatchingCancellable {
 			repository.getTags()
 		}.onFailure { error ->
 			error.printStackTraceDebug()
@@ -204,4 +211,4 @@ class FilterCoordinator(
 			return collator?.compare(t1, t2) ?: compareValues(t1, t2)
 		}
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/list/ui/model/EmptyHint.kt

@@ -0,0 +1,14 @@
+package org.koitharu.kotatsu.list.ui.model
+
+import androidx.annotation.DrawableRes
+import androidx.annotation.StringRes
+
+class EmptyHint(
+	@DrawableRes icon: Int,
+	@StringRes textPrimary: Int,
+	@StringRes textSecondary: Int,
+	@StringRes actionStringRes: Int,
+) : EmptyState(icon, textPrimary, textSecondary, actionStringRes) {
+
+	fun toState() = EmptyState(icon, textPrimary, textSecondary, actionStringRes)
+}

app/src/main/java/org/koitharu/kotatsu/local/domain/CbzMangaOutput.kt

@@ -62,7 +62,7 @@ class CbzMangaOutput(
 		index.addChapter(chapter)
 	}
 
-	suspend fun finalize() {
+	suspend fun finish() {
 		runInterruptible(Dispatchers.IO) {
 			output.put(ENTRY_NAME_INDEX, index.toString())
 			output.finish()

app/src/main/java/org/koitharu/kotatsu/local/domain/LocalManga.kt

@@ -0,0 +1,48 @@
+package org.koitharu.kotatsu.local.domain
+
+import java.io.File
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaTag
+
+class LocalManga(
+	val manga: Manga,
+	val file: File,
+) {
+
+	var createdAt: Long = -1L
+		get() {
+			if (field == -1L) {
+				field = file.lastModified()
+			}
+			return field
+		}
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as LocalManga
+
+		if (manga != other.manga) return false
+		if (file != other.file) return false
+
+		return true
+	}
+
+	override fun hashCode(): Int {
+		var result = manga.hashCode()
+		result = 31 * result + file.hashCode()
+		return result
+	}
+}
+
+fun Collection<LocalManga>.unwrap(): List<Manga> = map { it.manga }
+
+fun LocalManga.isMatchesQuery(query: String): Boolean {
+	return manga.title.contains(query, ignoreCase = true) ||
+		manga.altTitle?.contains(query, ignoreCase = true) == true
+}
+
+fun LocalManga.containsTags(tags: Set<MangaTag>): Boolean {
+	return manga.tags.containsAll(tags)
+}

app/src/main/java/org/koitharu/kotatsu/local/domain/LocalMangaRepository.kt

@@ -7,28 +7,40 @@ import androidx.annotation.WorkerThread
 import androidx.collection.ArraySet
 import androidx.core.net.toFile
 import androidx.core.net.toUri
-import java.io.File
-import java.util.*
-import java.util.zip.ZipEntry
-import java.util.zip.ZipFile
-import javax.inject.Inject
-import javax.inject.Singleton
-import kotlin.coroutines.CoroutineContext
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.filterNot
+import kotlinx.coroutines.runInterruptible
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.local.data.CbzFilter
 import org.koitharu.kotatsu.local.data.LocalStorageManager
 import org.koitharu.kotatsu.local.data.MangaIndex
 import org.koitharu.kotatsu.local.data.TempFileFilter
-import org.koitharu.kotatsu.parsers.model.*
+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.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.util.toCamelCase
 import org.koitharu.kotatsu.utils.AlphanumComparator
 import org.koitharu.kotatsu.utils.CompositeMutex
 import org.koitharu.kotatsu.utils.ext.deleteAwait
 import org.koitharu.kotatsu.utils.ext.longHashCode
 import org.koitharu.kotatsu.utils.ext.readText
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import java.io.File
+import java.util.Enumeration
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlin.coroutines.CoroutineContext
 
 private const val MAX_PARALLELISM = 4
 
@@ -45,12 +57,9 @@ class LocalMangaRepository @Inject constructor(private val storageManager: Local
 		}
 		val list = getRawList()
 		if (query.isNotEmpty()) {
-			list.retainAll { x ->
-				x.title.contains(query, ignoreCase = true) ||
-					x.altTitle?.contains(query, ignoreCase = true) == true
-			}
+			list.retainAll { x -> x.isMatchesQuery(query) }
 		}
-		return list
+		return list.unwrap()
 	}
 
 	override suspend fun getList(offset: Int, tags: Set<MangaTag>?, sortOrder: SortOrder?): List<Manga> {
@@ -59,17 +68,25 @@ class LocalMangaRepository @Inject constructor(private val storageManager: Local
 		}
 		val list = getRawList()
 		if (!tags.isNullOrEmpty()) {
-			list.retainAll { x ->
-				x.tags.containsAll(tags)
-			}
+			list.retainAll { x -> x.containsTags(tags) }
 		}
-		return list
+		when (sortOrder) {
+			SortOrder.ALPHABETICAL -> list.sortWith(compareBy(AlphanumComparator()) { x -> x.manga.title })
+			SortOrder.RATING -> list.sortByDescending { it.manga.rating }
+			SortOrder.NEWEST,
+			SortOrder.UPDATED,
+			-> list.sortByDescending { it.createdAt }
+
+			else -> Unit
+		}
+		return list.unwrap()
 	}
 
 	override suspend fun getDetails(manga: Manga) = when {
 		manga.source != MangaSource.LOCAL -> requireNotNull(findSavedManga(manga)) {
 			"Manga is not local or saved"
 		}
+
 		else -> getFromFile(Uri.parse(manga.url).toFile())
 	}
 
@@ -231,9 +248,9 @@ class LocalMangaRepository @Inject constructor(private val storageManager: Local
 	private fun CoroutineScope.getFromFileAsync(
 		file: File,
 		context: CoroutineContext,
-	): Deferred<Manga?> = async(context) {
+	): Deferred<LocalManga?> = async(context) {
 		runInterruptible {
-			runCatching { getFromFile(file) }.getOrNull()
+			runCatchingCancellable { LocalManga(getFromFile(file), file) }.getOrNull()
 		}
 	}
 
@@ -250,7 +267,7 @@ class LocalMangaRepository @Inject constructor(private val storageManager: Local
 		}
 	}
 
-	override val sortOrders = setOf(SortOrder.ALPHABETICAL)
+	override val sortOrders = setOf(SortOrder.ALPHABETICAL, SortOrder.RATING)
 
 	override suspend fun getPageUrl(page: MangaPage) = page.url
 
@@ -279,7 +296,7 @@ class LocalMangaRepository @Inject constructor(private val storageManager: Local
 		locks.unlock(id)
 	}
 
-	private suspend fun getRawList(): ArrayList<Manga> {
+	private suspend fun getRawList(): ArrayList<LocalManga> {
 		val files = getAllFiles()
 		return coroutineScope {
 			val dispatcher = Dispatchers.IO.limitedParallelism(MAX_PARALLELISM)

app/src/main/java/org/koitharu/kotatsu/local/domain/importer/DirMangaImporter.kt

@@ -43,7 +43,7 @@ class DirMangaImporter(
 				)
 				it.sortChaptersByName()
 				it.mergeWithExisting()
-				it.finalize()
+				it.finish()
 				it.file
 			}
 			return localMangaRepository.getFromFile(dest)

app/src/main/java/org/koitharu/kotatsu/local/ui/ImportService.kt

@@ -23,7 +23,12 @@ import org.koitharu.kotatsu.download.ui.service.DownloadService
 import org.koitharu.kotatsu.local.domain.importer.MangaImporter
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.utils.PendingIntentCompat
-import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.ext.asArrayList
+import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.referer
+import org.koitharu.kotatsu.utils.ext.report
+import org.koitharu.kotatsu.utils.ext.toBitmapOrNull
 import javax.inject.Inject
 
 @AndroidEntryPoint
@@ -48,8 +53,8 @@ class ImportService : CoroutineIntentService() {
 		super.onDestroy()
 	}
 
-	override suspend fun processIntent(intent: Intent?) {
-		val uris = intent?.getParcelableArrayListExtra<Uri>(EXTRA_URIS)
+	override suspend fun processIntent(startId: Int, intent: Intent) {
+		val uris = intent.getParcelableArrayListExtra<Uri>(EXTRA_URIS)
 		if (uris.isNullOrEmpty()) {
 			return
 		}
@@ -69,6 +74,10 @@ class ImportService : CoroutineIntentService() {
 		ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
 	}
 
+	override fun onError(startId: Int, error: Throwable) {
+		error.report()
+	}
+
 	private suspend fun importImpl(uri: Uri): Manga {
 		val importer = importerFactory.create(uri)
 		return importer.import(uri)

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

@@ -9,13 +9,15 @@ import androidx.core.app.NotificationCompat
 import androidx.core.app.ServiceCompat
 import androidx.core.content.ContextCompat
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.CoroutineIntentService
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
 import org.koitharu.kotatsu.download.ui.service.DownloadService
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.getParcelableExtraCompat
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class LocalChaptersRemoveService : CoroutineIntentService() {
@@ -33,8 +35,8 @@ class LocalChaptersRemoveService : CoroutineIntentService() {
 		super.onDestroy()
 	}
 
-	override suspend fun processIntent(intent: Intent?) {
-		val manga = intent?.getParcelableExtra<ParcelableManga>(EXTRA_MANGA)?.manga ?: return
+	override suspend fun processIntent(startId: Int, intent: Intent) {
+		val manga = intent.getParcelableExtraCompat<ParcelableManga>(EXTRA_MANGA)?.manga ?: return
 		val chaptersIds = intent.getLongArrayExtra(EXTRA_CHAPTERS_IDS)?.toSet() ?: return
 		startForeground()
 		val mangaWithChapters = localMangaRepository.getDetails(manga)
@@ -46,6 +48,21 @@ class LocalChaptersRemoveService : CoroutineIntentService() {
 		ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
 	}
 
+	override fun onError(startId: Int, error: Throwable) {
+		val notification = NotificationCompat.Builder(this, CHANNEL_ID)
+			.setContentTitle(getString(R.string.error_occurred))
+			.setPriority(NotificationCompat.PRIORITY_DEFAULT)
+			.setDefaults(0)
+			.setColor(ContextCompat.getColor(this, R.color.blue_primary_dark))
+			.setSilent(true)
+			.setContentText(error.getDisplayMessage(resources))
+			.setSmallIcon(android.R.drawable.stat_notify_error)
+			.setAutoCancel(true)
+			.build()
+		val nm = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+		nm.notify(NOTIFICATION_ID + startId, notification)
+	}
+
 	private fun startForeground() {
 		val title = getString(R.string.local_manga_processing)
 		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

app/src/main/java/org/koitharu/kotatsu/local/ui/LocalListFragment.kt

@@ -5,6 +5,7 @@ import android.view.Menu
 import android.view.MenuItem
 import android.view.View
 import androidx.appcompat.view.ActionMode
+import androidx.appcompat.widget.PopupMenu
 import androidx.core.net.toFile
 import androidx.core.net.toUri
 import androidx.fragment.app.viewModels
@@ -13,10 +14,11 @@ import com.google.android.material.snackbar.Snackbar
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.list.ListSelectionController
 import org.koitharu.kotatsu.list.ui.MangaListFragment
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.utils.ShareHelper
 import org.koitharu.kotatsu.utils.ext.addMenuProvider
 
-class LocalListFragment : MangaListFragment() {
+class LocalListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickListener {
 
 	override val viewModel by viewModels<LocalListViewModel>()
 
@@ -30,6 +32,14 @@ class LocalListFragment : MangaListFragment() {
 		ImportDialogFragment.show(childFragmentManager)
 	}
 
+	override fun onFilterClick(view: View?) {
+		super.onFilterClick(view)
+		val menu = PopupMenu(requireContext(), view ?: binding.recyclerView)
+		menu.inflate(R.menu.popup_order)
+		menu.setOnMenuItemClickListener(this)
+		menu.show()
+	}
+
 	override fun onScrolledToEnd() = Unit
 
 	override fun onCreateActionMode(controller: ListSelectionController, mode: ActionMode, menu: Menu): Boolean {
@@ -53,6 +63,17 @@ class LocalListFragment : MangaListFragment() {
 		}
 	}
 
+	override fun onMenuItemClick(item: MenuItem): Boolean {
+		val order = when (item.itemId) {
+			R.id.action_order_new -> SortOrder.NEWEST
+			R.id.action_order_abs -> SortOrder.ALPHABETICAL
+			R.id.action_order_rating -> SortOrder.RATING
+			else -> return false
+		}
+		viewModel.setSortOrder(order)
+		return true
+	}
+
 	private fun showDeletionConfirm(ids: Set<Long>, mode: ActionMode) {
 		MaterialAlertDialogBuilder(context ?: return)
 			.setTitle(R.string.delete_manga)

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

@@ -23,4 +23,4 @@ class LocalListMenuProvider(
 			else -> false
 		}
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/local/ui/LocalListViewModel.kt

@@ -1,47 +1,58 @@
 package org.koitharu.kotatsu.local.ui
 
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.asFlow
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import java.io.IOException
+import java.util.*
 import javax.inject.Inject
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.ui.widgets.ChipsView
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.download.ui.service.DownloadService
 import org.koitharu.kotatsu.history.domain.HistoryRepository
+import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
+import org.koitharu.kotatsu.list.domain.ListExtraProvider
 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.list.ui.model.*
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
 @HiltViewModel
 class LocalListViewModel @Inject constructor(
 	private val repository: LocalMangaRepository,
 	private val historyRepository: HistoryRepository,
-	settings: AppSettings,
-) : MangaListViewModel(settings) {
+	private val trackingRepository: TrackingRepository,
+	private val settings: AppSettings,
+) : MangaListViewModel(settings), ListExtraProvider {
 
 	val onMangaRemoved = SingleLiveEvent<Unit>()
+	val sortOrder = MutableLiveData(settings.localListOrder)
 	private val listError = MutableStateFlow<Throwable?>(null)
 	private val mangaList = MutableStateFlow<List<Manga>?>(null)
+	private val selectedTags = MutableStateFlow<Set<MangaTag>>(emptySet())
+	private var refreshJob: Job? = null
 
 	override val content = combine(
 		mangaList,
 		createListModeFlow(),
+		sortOrder.asFlow(),
+		selectedTags,
 		listError,
-	) { list, mode, error ->
+	) { list, mode, order, tags, error ->
 		when {
 			error != null -> listOf(error.toErrorState(canRetry = true))
 			list == null -> listOf(LoadingState)
@@ -53,7 +64,11 @@ class LocalListViewModel @Inject constructor(
 					actionStringRes = R.string._import,
 				),
 			)
-			else -> list.toUi(mode)
+
+			else -> buildList(list.size + 1) {
+				add(createHeader(list, tags, order))
+				list.toUi(this, mode, this@LocalListViewModel)
+			}
 		}
 	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default, listOf(LoadingState))
 
@@ -63,14 +78,27 @@ class LocalListViewModel @Inject constructor(
 		watchDirectories()
 	}
 
+	override fun onUpdateFilter(tags: Set<MangaTag>) {
+		selectedTags.value = tags
+		onRefresh()
+	}
+
 	override fun onRefresh() {
-		launchLoadingJob(Dispatchers.Default) {
+		val prevJob = refreshJob
+		refreshJob = launchLoadingJob(Dispatchers.Default) {
+			prevJob?.cancelAndJoin()
 			doRefresh()
 		}
 	}
 
 	override fun onRetry() = onRefresh()
 
+	fun setSortOrder(value: SortOrder) {
+		sortOrder.value = value
+		settings.localListOrder = value
+		onRefresh()
+	}
+
 	fun delete(ids: Set<Long>) {
 		launchLoadingJob {
 			withContext(Dispatchers.Default) {
@@ -78,7 +106,7 @@ class LocalListViewModel @Inject constructor(
 				for (manga in itemsToRemove) {
 					val original = repository.getRemoteManga(manga)
 					repository.delete(manga) || throw IOException("Unable to delete file")
-					runCatching {
+					runCatchingCancellable {
 						historyRepository.deleteOrSwap(manga, original)
 					}
 					mangaList.update { list ->
@@ -93,7 +121,9 @@ class LocalListViewModel @Inject constructor(
 	private suspend fun doRefresh() {
 		try {
 			listError.value = null
-			mangaList.value = repository.getList(0, null, null)
+			mangaList.value = repository.getList(0, selectedTags.value, sortOrder.value)
+		} catch (e: CancellationException) {
+			throw e
 		} catch (e: Throwable) {
 			listError.value = e
 		}
@@ -102,7 +132,7 @@ class LocalListViewModel @Inject constructor(
 	private fun cleanup() {
 		if (!DownloadService.isRunning && !ImportService.isRunning && !LocalChaptersRemoveService.isRunning) {
 			viewModelScope.launch {
-				runCatching {
+				runCatchingCancellable {
 					repository.cleanup()
 				}.onFailure { error ->
 					error.printStackTraceDebug()
@@ -119,4 +149,46 @@ class LocalListViewModel @Inject constructor(
 				}
 		}
 	}
+
+	private fun createHeader(mangaList: List<Manga>, selectedTags: Set<MangaTag>, order: SortOrder): ListHeader2 {
+		val tags = HashMap<MangaTag, Int>()
+		for (item in mangaList) {
+			for (tag in item.tags) {
+				tags[tag] = tags[tag]?.plus(1) ?: 1
+			}
+		}
+		val topTags = tags.entries.sortedByDescending { it.value }.take(6)
+		val chips = LinkedList<ChipsView.ChipModel>()
+		for ((tag, _) in topTags) {
+			val model = ChipsView.ChipModel(
+				icon = 0,
+				title = tag.title,
+				isCheckable = true,
+				isChecked = tag in selectedTags,
+				data = tag,
+			)
+			if (model.isChecked) {
+				chips.addFirst(model)
+			} else {
+				chips.addLast(model)
+			}
+		}
+		return ListHeader2(
+			chips = chips,
+			sortOrder = order,
+			hasSelectedTags = selectedTags.isNotEmpty(),
+		)
+	}
+
+	override suspend fun getCounter(mangaId: Long): Int {
+		return trackingRepository.getNewChaptersCount(mangaId)
+	}
+
+	override suspend fun getProgress(mangaId: Long): Float {
+		return if (settings.isReadingIndicatorsEnabled) {
+			historyRepository.getProgress(mangaId)
+		} else {
+			PROGRESS_NONE
+		}
+	}
 }

app/src/main/java/org/koitharu/kotatsu/main/ui/MainActivity.kt

@@ -15,25 +15,31 @@ import androidx.core.app.ActivityOptionsCompat
 import androidx.core.content.ContextCompat
 import androidx.core.graphics.Insets
 import androidx.core.util.size
-import androidx.core.view.*
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.isVisible
+import androidx.core.view.updateLayoutParams
+import androidx.core.view.updatePadding
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentTransaction
 import androidx.fragment.app.commit
 import androidx.lifecycle.lifecycleScope
 import androidx.transition.TransitionManager
-import com.google.android.material.R as materialR
 import com.google.android.material.appbar.AppBarLayout
-import com.google.android.material.appbar.AppBarLayout.LayoutParams.*
+import com.google.android.material.appbar.AppBarLayout.LayoutParams.SCROLL_FLAG_ENTER_ALWAYS
+import com.google.android.material.appbar.AppBarLayout.LayoutParams.SCROLL_FLAG_NO_SCROLL
+import com.google.android.material.appbar.AppBarLayout.LayoutParams.SCROLL_FLAG_SCROLL
+import com.google.android.material.appbar.AppBarLayout.LayoutParams.SCROLL_FLAG_SNAP
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseActivity
 import org.koitharu.kotatsu.base.ui.widgets.SlidingBottomNavigationView
 import org.koitharu.kotatsu.databinding.ActivityMainBinding
 import org.koitharu.kotatsu.details.ui.DetailsActivity
-import org.koitharu.kotatsu.library.ui.LibraryFragment
 import org.koitharu.kotatsu.main.ui.owners.AppBarOwner
 import org.koitharu.kotatsu.main.ui.owners.BottomNavOwner
 import org.koitharu.kotatsu.parsers.model.Manga
@@ -47,10 +53,18 @@ import org.koitharu.kotatsu.search.ui.suggestion.SearchSuggestionListener
 import org.koitharu.kotatsu.search.ui.suggestion.SearchSuggestionViewModel
 import org.koitharu.kotatsu.settings.newsources.NewSourcesDialogFragment
 import org.koitharu.kotatsu.settings.onboard.OnboardDialogFragment
+import org.koitharu.kotatsu.shelf.ui.ShelfFragment
 import org.koitharu.kotatsu.suggestions.ui.SuggestionsWorker
 import org.koitharu.kotatsu.tracker.work.TrackWorker
 import org.koitharu.kotatsu.utils.VoiceInputContract
-import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.ext.drawableEnd
+import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.hideKeyboard
+import org.koitharu.kotatsu.utils.ext.resolve
+import org.koitharu.kotatsu.utils.ext.scaleUpActivityOptionsOf
+import org.koitharu.kotatsu.utils.ext.setNavigationBarTransparentCompat
+import org.koitharu.kotatsu.utils.ext.tryLaunch
+import com.google.android.material.R as materialR
 
 private const val TAG_SEARCH = "search"
 
@@ -114,6 +128,7 @@ class MainActivity :
 		viewModel.isLoading.observe(this, this::onLoadingStateChanged)
 		viewModel.isResumeEnabled.observe(this, this::onResumeEnabledChanged)
 		viewModel.counters.observe(this, ::onCountersChanged)
+		viewModel.isFeedAvailable.observe(this, ::onFeedAvailabilityChanged)
 	}
 
 	override fun onRestoreInstanceState(savedInstanceState: Bundle) {
@@ -126,20 +141,18 @@ class MainActivity :
 		binding.searchView.clearFocus()
 		when {
 			fragment != null -> supportFragmentManager.commit {
+				setReorderingAllowed(true)
 				remove(fragment)
 				setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
 				runOnCommit { onSearchClosed() }
 			}
+
 			else -> super.onBackPressed()
 		}
 	}
 
 	override fun onFragmentChanged(fragment: Fragment, fromUser: Boolean) {
-		if (fragment is LibraryFragment) {
-			binding.fab?.show()
-		} else {
-			binding.fab?.hide()
-		}
+		adjustFabVisibility(topFragment = fragment)
 		if (fromUser) {
 			binding.appbar.setExpanded(true)
 		}
@@ -172,6 +185,7 @@ class MainActivity :
 		if (v?.id == R.id.searchView && hasFocus) {
 			if (fragment == null) {
 				supportFragmentManager.commit {
+					setReorderingAllowed(true)
 					add(R.id.container, SearchSuggestionFragment.newInstance(), TAG_SEARCH)
 					setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
 					runOnCommit { onSearchOpened() }
@@ -256,6 +270,10 @@ class MainActivity :
 		}
 	}
 
+	private fun onFeedAvailabilityChanged(isFeedAvailable: Boolean) {
+		navigationDelegate.setItemVisibility(R.id.nav_feed, isFeedAvailable)
+	}
+
 	private fun onLoadingStateChanged(isLoading: Boolean) {
 		binding.fab?.isEnabled = !isLoading
 	}
@@ -289,16 +307,16 @@ class MainActivity :
 	}
 
 	private fun onFirstStart() {
-		lifecycleScope.launchWhenResumed {
+		lifecycleScope.launch(Dispatchers.Main) { // not a default `Main.immediate` dispatcher
+			when {
+				!settings.isSourcesSelected -> OnboardDialogFragment.showWelcome(supportFragmentManager)
+				settings.newSources.isNotEmpty() -> NewSourcesDialogFragment.show(supportFragmentManager)
+			}
 			withContext(Dispatchers.Default) {
 				TrackWorker.setup(applicationContext)
 				SuggestionsWorker.setup(applicationContext)
 			}
 			requestNotificationsPermission()
-			when {
-				!settings.isSourcesSelected -> OnboardDialogFragment.showWelcome(supportFragmentManager)
-				settings.newSources.isNotEmpty() -> NewSourcesDialogFragment.show(supportFragmentManager)
-			}
 		}
 	}
 
@@ -307,18 +325,18 @@ class MainActivity :
 		topFragment: Fragment? = navigationDelegate.primaryFragment,
 		isSearchOpened: Boolean = isSearchOpened(),
 	) {
-		val fab = binding.fab
+		val fab = binding.fab ?: return
 		if (
 			isResumeEnabled &&
 			!actionModeDelegate.isActionModeStarted &&
 			!isSearchOpened &&
-			topFragment is LibraryFragment
+			topFragment is ShelfFragment
 		) {
-			if (fab?.isVisible == false) {
+			if (!fab.isVisible) {
 				fab.show()
 			}
 		} else {
-			if (fab?.isVisible == true) {
+			if (fab.isVisible) {
 				fab.hide()
 			}
 		}

app/src/main/java/org/koitharu/kotatsu/main/ui/MainNavigationDelegate.kt

@@ -3,6 +3,7 @@ package org.koitharu.kotatsu.main.ui
 import android.os.Bundle
 import android.view.MenuItem
 import androidx.annotation.IdRes
+import androidx.core.view.iterator
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.FragmentTransaction
@@ -10,10 +11,10 @@ import com.google.android.material.navigation.NavigationBarView
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.util.RecyclerViewOwner
 import org.koitharu.kotatsu.explore.ui.ExploreFragment
-import org.koitharu.kotatsu.library.ui.LibraryFragment
 import org.koitharu.kotatsu.settings.tools.ToolsFragment
-import org.koitharu.kotatsu.tracker.ui.FeedFragment
-import java.util.*
+import org.koitharu.kotatsu.shelf.ui.ShelfFragment
+import org.koitharu.kotatsu.tracker.ui.feed.FeedFragment
+import java.util.LinkedList
 
 private const val TAG_PRIMARY = "primary"
 
@@ -62,6 +63,14 @@ class MainNavigationDelegate(
 		}
 	}
 
+	fun setItemVisibility(@IdRes itemId: Int, isVisible: Boolean) {
+		val item = navBar.menu.findItem(itemId) ?: return
+		item.isVisible = isVisible
+		if (item.isChecked && !isVisible) {
+			navBar.selectedItemId = firstItem()?.itemId ?: return
+		}
+	}
+
 	fun addOnFragmentChangedListener(listener: OnFragmentChangedListener) {
 		listeners.add(listener)
 	}
@@ -73,7 +82,7 @@ class MainNavigationDelegate(
 	private fun onNavigationItemSelected(@IdRes itemId: Int): Boolean {
 		setPrimaryFragment(
 			when (itemId) {
-				R.id.nav_library -> LibraryFragment.newInstance()
+				R.id.nav_shelf -> ShelfFragment.newInstance()
 				R.id.nav_explore -> ExploreFragment.newInstance()
 				R.id.nav_feed -> FeedFragment.newInstance()
 				R.id.nav_tools -> ToolsFragment.newInstance()
@@ -85,6 +94,7 @@ class MainNavigationDelegate(
 
 	private fun setPrimaryFragment(fragment: Fragment) {
 		fragmentManager.beginTransaction()
+			.setReorderingAllowed(true)
 			.replace(R.id.container, fragment, TAG_PRIMARY)
 			.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
 			.commit()
@@ -95,6 +105,14 @@ class MainNavigationDelegate(
 		listeners.forEach { it.onFragmentChanged(fragment, fromUser) }
 	}
 
+	private fun firstItem(): MenuItem? {
+		val menu = navBar.menu
+		for (item in menu) {
+			if (item.isVisible) return item
+		}
+		return null
+	}
+
 	interface OnFragmentChangedListener {
 
 		fun onFragmentChanged(fragment: Fragment, fromUser: Boolean)

app/src/main/java/org/koitharu/kotatsu/main/ui/MainViewModel.kt

@@ -4,7 +4,6 @@ import android.util.SparseIntArray
 import androidx.core.util.set
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.combine
 import org.koitharu.kotatsu.R
@@ -12,12 +11,16 @@ import org.koitharu.kotatsu.base.ui.BaseViewModel
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.exceptions.EmptyHistoryException
 import org.koitharu.kotatsu.core.github.AppUpdateRepository
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.prefs.observeAsLiveData
 import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.sync.domain.SyncController
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.SingleLiveEvent
+import org.koitharu.kotatsu.utils.asFlowLiveData
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
+import javax.inject.Inject
 
 @HiltViewModel
 class MainViewModel @Inject constructor(
@@ -26,13 +29,20 @@ class MainViewModel @Inject constructor(
 	private val trackingRepository: TrackingRepository,
 	syncController: SyncController,
 	database: MangaDatabase,
+	private val settings: AppSettings,
 ) : BaseViewModel() {
 
 	val onOpenReader = SingleLiveEvent<Manga>()
 
 	val isResumeEnabled = historyRepository
 		.observeHasItems()
-		.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default, false)
+		.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, false)
+
+	val isFeedAvailable = settings.observeAsLiveData(
+		context = viewModelScope.coroutineContext + Dispatchers.Default,
+		key = AppSettings.KEY_TRACKER_ENABLED,
+		valueProducer = { isTrackerEnabled },
+	)
 
 	val counters = combine(
 		appUpdateRepository.observeAvailableUpdate(),

app/src/main/java/org/koitharu/kotatsu/main/ui/protect/AppProtectHelper.kt

@@ -1,20 +1,21 @@
 package org.koitharu.kotatsu.main.ui.protect
 
 import android.app.Activity
-import android.app.Application
 import android.content.Intent
 import android.os.Bundle
+import org.acra.dialog.CrashReportDialog
+import org.koitharu.kotatsu.base.ui.DefaultActivityLifecycleCallbacks
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import javax.inject.Inject
 import javax.inject.Singleton
-import org.koitharu.kotatsu.core.prefs.AppSettings
 
 @Singleton
-class AppProtectHelper @Inject constructor(private val settings: AppSettings) : Application.ActivityLifecycleCallbacks {
+class AppProtectHelper @Inject constructor(private val settings: AppSettings) : DefaultActivityLifecycleCallbacks {
 
 	private var isUnlocked = settings.appPassword.isNullOrEmpty()
 
 	override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
-		if (activity !is ProtectActivity && !isUnlocked) {
+		if (!isUnlocked && activity !is ProtectActivity && activity !is CrashReportDialog) {
 			val sourceIntent = Intent(activity, activity.javaClass)
 			activity.intent?.let {
 				sourceIntent.putExtras(it)
@@ -26,16 +27,6 @@ class AppProtectHelper @Inject constructor(private val settings: AppSettings) :
 		}
 	}
 
-	override fun onActivityStarted(activity: Activity) = Unit
-
-	override fun onActivityResumed(activity: Activity) = Unit
-
-	override fun onActivityPaused(activity: Activity) = Unit
-
-	override fun onActivityStopped(activity: Activity) = Unit
-
-	override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
-
 	override fun onActivityDestroyed(activity: Activity) {
 		if (activity !is ProtectActivity && activity.isFinishing && activity.isTaskRoot) {
 			restoreLock()

app/src/main/java/org/koitharu/kotatsu/main/ui/protect/ProtectActivity.kt

@@ -49,7 +49,10 @@ class ProtectActivity :
 			startActivity(intent)
 			finishAfterTransition()
 		}
+	}
 
+	override fun onStart() {
+		super.onStart()
 		if (!useFingerprint()) {
 			binding.editPassword.requestFocus()
 		}

app/src/main/java/org/koitharu/kotatsu/reader/domain/PageLoader.kt

@@ -7,14 +7,16 @@ import android.net.Uri
 import androidx.collection.LongSparseArray
 import androidx.collection.set
 import dagger.hilt.android.qualifiers.ApplicationContext
-import java.io.File
-import java.util.*
-import java.util.concurrent.atomic.AtomicInteger
-import java.util.zip.ZipFile
-import javax.inject.Inject
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import okhttp3.OkHttpClient
@@ -30,7 +32,15 @@ import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.util.await
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
 import org.koitharu.kotatsu.utils.ext.connectivityManager
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.progress.ProgressDeferred
+import java.io.File
+import java.util.LinkedList
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.zip.ZipFile
+import javax.inject.Inject
+import kotlin.coroutines.AbstractCoroutineContextElement
+import kotlin.coroutines.CoroutineContext
 
 private const val PROGRESS_UNDEFINED = -1f
 private const val PREFETCH_LIMIT_DEFAULT = 10
@@ -43,7 +53,7 @@ class PageLoader @Inject constructor(
 	private val mangaRepositoryFactory: MangaRepository.Factory,
 ) : Closeable {
 
-	val loaderScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+	val loaderScope = CoroutineScope(SupervisorJob() + InternalErrorHandler() + Dispatchers.Default)
 
 	private val connectivityManager = context.connectivityManager
 	private val tasks = LongSparseArray<ProgressDeferred<File, Float>>()
@@ -197,4 +207,13 @@ class PageLoader @Inject constructor(
 		val deferred = CompletableDeferred(file)
 		return ProgressDeferred(deferred, emptyProgressFlow)
 	}
+
+	private class InternalErrorHandler : AbstractCoroutineContextElement(CoroutineExceptionHandler),
+		CoroutineExceptionHandler {
+
+		override fun handleException(context: CoroutineContext, exception: Throwable) {
+			exception.printStackTraceDebug()
+		}
+
+	}
 }

app/src/main/java/org/koitharu/kotatsu/reader/domain/ReaderColorFilter.kt

@@ -0,0 +1,52 @@
+package org.koitharu.kotatsu.reader.domain
+
+import android.graphics.ColorMatrix
+import android.graphics.ColorMatrixColorFilter
+
+class ReaderColorFilter(
+	val brightness: Float,
+	val contrast: Float,
+) {
+
+	val isEmpty: Boolean
+		get() = brightness == 0f && contrast == 0f
+
+	fun toColorFilter(): ColorMatrixColorFilter {
+		val cm = ColorMatrix()
+		val scale = brightness + 1f
+		cm.setScale(scale, scale, scale, 1f)
+		cm.setContrast(contrast)
+		return ColorMatrixColorFilter(cm)
+	}
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as ReaderColorFilter
+
+		if (brightness != other.brightness) return false
+		if (contrast != other.contrast) return false
+
+		return true
+	}
+
+	override fun hashCode(): Int {
+		var result = brightness.hashCode()
+		result = 31 * result + contrast.hashCode()
+		return result
+	}
+
+	private fun ColorMatrix.setContrast(contrast: Float) {
+		val scale = contrast + 1f
+		val translate = (-.5f * scale + .5f) * 255f
+		val array = floatArrayOf(
+			scale, 0f, 0f, 0f, translate,
+			0f, scale, 0f, 0f, translate,
+			0f, 0f, scale, 0f, translate,
+			0f, 0f, 0f, 1f, 0f,
+		)
+		val matrix = ColorMatrix(array)
+		postConcat(matrix)
+	}
+}

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

@@ -9,15 +9,23 @@ import android.transition.Fade
 import android.transition.Slide
 import android.transition.TransitionManager
 import android.transition.TransitionSet
-import android.view.*
+import android.view.Gravity
+import android.view.KeyEvent
+import android.view.Menu
+import android.view.MenuItem
+import android.view.MotionEvent
+import android.view.View
+import android.view.WindowManager
 import androidx.core.graphics.Insets
-import androidx.core.view.*
+import androidx.core.view.OnApplyWindowInsetsListener
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.isGone
+import androidx.core.view.isVisible
+import androidx.core.view.updatePadding
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
-import java.util.concurrent.TimeUnit
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -42,7 +50,16 @@ import org.koitharu.kotatsu.settings.SettingsActivity
 import org.koitharu.kotatsu.utils.GridTouchHelper
 import org.koitharu.kotatsu.utils.IdlingDetector
 import org.koitharu.kotatsu.utils.ShareHelper
-import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.ext.assistedViewModels
+import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.getParcelableExtraCompat
+import org.koitharu.kotatsu.utils.ext.hasGlobalPoint
+import org.koitharu.kotatsu.utils.ext.isReportable
+import org.koitharu.kotatsu.utils.ext.observeWithPrevious
+import org.koitharu.kotatsu.utils.ext.postDelayed
+import org.koitharu.kotatsu.utils.ext.report
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class ReaderActivity :
@@ -74,6 +91,9 @@ class ReaderActivity :
 			pageSwitchTimer.delaySec = value
 		}
 
+	override val readerMode: ReaderMode?
+		get() = readerManager.currentMode
+
 	private lateinit var pageSwitchTimer: PageSwitchTimer
 	private lateinit var touchHelper: GridTouchHelper
 	private lateinit var controlDelegate: ReaderControlDelegate
@@ -88,7 +108,7 @@ class ReaderActivity :
 		supportActionBar?.setDisplayHomeAsUpEnabled(true)
 		touchHelper = GridTouchHelper(this, this)
 		pageSwitchTimer = PageSwitchTimer(this, this)
-		controlDelegate = ReaderControlDelegate(lifecycleScope, settings, this)
+		controlDelegate = ReaderControlDelegate(settings, this, this)
 		binding.toolbarBottom.setOnMenuItemClickListener(::onOptionsItemSelected)
 		binding.slider.setLabelFormatter(PageLabelFormatter())
 		ReaderSliderListener(this, viewModel).attachToSlider(binding.slider)
@@ -142,6 +162,7 @@ class ReaderActivity :
 			R.id.action_settings -> {
 				startActivity(SettingsActivity.newReaderSettingsIntent(this))
 			}
+
 			R.id.action_chapters -> {
 				ChaptersBottomSheet.show(
 					supportFragmentManager,
@@ -149,6 +170,7 @@ class ReaderActivity :
 					viewModel.getCurrentState()?.chapterId ?: 0L,
 				)
 			}
+
 			R.id.action_pages_thumbs -> {
 				val pages = viewModel.getCurrentChapterPages()
 				if (!pages.isNullOrEmpty()) {
@@ -162,6 +184,7 @@ class ReaderActivity :
 					return false
 				}
 			}
+
 			R.id.action_bookmark -> {
 				if (viewModel.isBookmarkAdded.value == true) {
 					viewModel.removeBookmark()
@@ -169,11 +192,13 @@ class ReaderActivity :
 					viewModel.addBookmark()
 				}
 			}
+
 			R.id.action_options -> {
 				viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
 				val currentMode = readerManager.currentMode ?: return false
 				ReaderConfigBottomSheet.show(supportFragmentManager, currentMode)
 			}
+
 			else -> return super.onOptionsItemSelected(item)
 		}
 		return true
@@ -202,7 +227,7 @@ class ReaderActivity :
 		val resolveTextId = ExceptionResolver.getResolveStringId(e)
 		if (resolveTextId != 0) {
 			dialog.setPositiveButton(resolveTextId, listener)
-		} else {
+		} else if (e.isReportable()) {
 			dialog.setPositiveButton(R.string.report, listener)
 		}
 		dialog.show()
@@ -361,7 +386,7 @@ class ReaderActivity :
 				binding.toastView.showTemporary(uiState.chapterName, TOAST_DURATION)
 			}
 		}
-		if (uiState.totalPages > 1 && uiState.currentPage < uiState.totalPages) {
+		if (uiState.isSliderAvailable()) {
 			binding.slider.valueTo = uiState.totalPages.toFloat() - 1
 			binding.slider.value = uiState.currentPage.toFloat()
 			binding.slider.isVisible = true
@@ -380,7 +405,7 @@ class ReaderActivity :
 				if (ExceptionResolver.canResolve(exception)) {
 					tryResolve(exception)
 				} else {
-					exception.report("ReaderActivity::onError")
+					exception.report()
 				}
 			} else {
 				onCancel(dialog)

app/src/main/java/org/koitharu/kotatsu/reader/ui/ReaderConfigDialog.kt

@@ -1,83 +0,0 @@
-package org.koitharu.kotatsu.reader.ui
-
-import android.content.DialogInterface
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.fragment.app.FragmentManager
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.base.ui.AlertDialogFragment
-import org.koitharu.kotatsu.base.ui.widgets.CheckableButtonGroup
-import org.koitharu.kotatsu.core.prefs.ReaderMode
-import org.koitharu.kotatsu.databinding.DialogReaderConfigBinding
-import org.koitharu.kotatsu.utils.ext.withArgs
-
-@Deprecated("Not in use")
-class ReaderConfigDialog :
-	AlertDialogFragment<DialogReaderConfigBinding>(),
-	CheckableButtonGroup.OnCheckedChangeListener {
-
-	private lateinit var mode: ReaderMode
-
-	override fun onInflateView(
-		inflater: LayoutInflater,
-		container: ViewGroup?,
-	) = DialogReaderConfigBinding.inflate(inflater, container, false)
-
-	override fun onCreate(savedInstanceState: Bundle?) {
-		super.onCreate(savedInstanceState)
-		mode = arguments?.getInt(ARG_MODE)
-			?.let { ReaderMode.valueOf(it) }
-			?: ReaderMode.STANDARD
-	}
-
-	override fun onBuildDialog(builder: MaterialAlertDialogBuilder): MaterialAlertDialogBuilder {
-		return super.onBuildDialog(builder)
-			.setTitle(R.string.read_mode)
-			.setPositiveButton(R.string.done, null)
-			.setCancelable(true)
-	}
-
-	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-		super.onViewCreated(view, savedInstanceState)
-		binding.buttonStandard.isChecked = mode == ReaderMode.STANDARD
-		binding.buttonReversed.isChecked = mode == ReaderMode.REVERSED
-		binding.buttonWebtoon.isChecked = mode == ReaderMode.WEBTOON
-
-		binding.checkableGroup.onCheckedChangeListener = this
-	}
-
-	override fun onDismiss(dialog: DialogInterface) {
-		(
-			(parentFragment as? Callback)
-				?: (activity as? Callback)
-			)?.onReaderModeChanged(mode)
-		super.onDismiss(dialog)
-	}
-
-	override fun onCheckedChanged(group: CheckableButtonGroup, checkedId: Int) {
-		mode = when (checkedId) {
-			R.id.button_standard -> ReaderMode.STANDARD
-			R.id.button_webtoon -> ReaderMode.WEBTOON
-			R.id.button_reversed -> ReaderMode.REVERSED
-			else -> return
-		}
-	}
-
-	interface Callback {
-
-		fun onReaderModeChanged(mode: ReaderMode)
-	}
-
-	companion object {
-
-		private const val TAG = "ReaderConfigDialog"
-		private const val ARG_MODE = "mode"
-
-		fun show(fm: FragmentManager, mode: ReaderMode) = ReaderConfigDialog().withArgs(1) {
-			putInt(ARG_MODE, mode.id)
-		}.show(fm, TAG)
-	}
-}

app/src/main/java/org/koitharu/kotatsu/reader/ui/ReaderControlDelegate.kt

@@ -1,33 +1,39 @@
 package org.koitharu.kotatsu.reader.ui
 
+import android.content.SharedPreferences
 import android.view.KeyEvent
 import android.view.SoundEffectConstants
 import android.view.View
-import androidx.lifecycle.LifecycleCoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.observeAsFlow
+import org.koitharu.kotatsu.core.prefs.ReaderMode
 import org.koitharu.kotatsu.utils.GridTouchHelper
 
 class ReaderControlDelegate(
-	scope: LifecycleCoroutineScope,
-	settings: AppSettings,
+	private val settings: AppSettings,
 	private val listener: OnInteractionListener,
-) {
+	owner: LifecycleOwner,
+) : DefaultLifecycleObserver, SharedPreferences.OnSharedPreferenceChangeListener {
 
 	private var isTapSwitchEnabled: Boolean = true
 	private var isVolumeKeysSwitchEnabled: Boolean = false
+	private var isReaderTapsAdaptive: Boolean = true
 
 	init {
-		settings.observeAsFlow(AppSettings.KEY_READER_SWITCHERS) { readerPageSwitch }
-			.flowOn(Dispatchers.Default)
-			.onEach {
-				isTapSwitchEnabled = AppSettings.PAGE_SWITCH_TAPS in it
-				isVolumeKeysSwitchEnabled = AppSettings.PAGE_SWITCH_VOLUME_KEYS in it
-			}.launchIn(scope)
+		owner.lifecycle.addObserver(this)
+		settings.subscribe(this)
+		updateSettings()
+	}
+
+	override fun onDestroy(owner: LifecycleOwner) {
+		settings.unsubscribe(this)
+		owner.lifecycle.removeObserver(this)
+		super.onDestroy(owner)
+	}
+
+	override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences?, key: String?) {
+		updateSettings()
 	}
 
 	fun onGridTouch(area: Int, view: View) {
@@ -41,7 +47,7 @@ class ReaderControlDelegate(
 				view.playSoundEffect(SoundEffectConstants.NAVIGATION_UP)
 			}
 			GridTouchHelper.AREA_LEFT -> if (isTapSwitchEnabled) {
-				listener.switchPageBy(-1)
+				listener.switchPageBy(if (isReaderTapsReversed()) 1 else -1)
 				view.playSoundEffect(SoundEffectConstants.NAVIGATION_LEFT)
 			}
 			GridTouchHelper.AREA_BOTTOM -> if (isTapSwitchEnabled) {
@@ -49,7 +55,7 @@ class ReaderControlDelegate(
 				view.playSoundEffect(SoundEffectConstants.NAVIGATION_DOWN)
 			}
 			GridTouchHelper.AREA_RIGHT -> if (isTapSwitchEnabled) {
-				listener.switchPageBy(1)
+				listener.switchPageBy(if (isReaderTapsReversed()) -1 else 1)
 				view.playSoundEffect(SoundEffectConstants.NAVIGATION_RIGHT)
 			}
 		}
@@ -72,19 +78,25 @@ class ReaderControlDelegate(
 		KeyEvent.KEYCODE_PAGE_DOWN,
 		KeyEvent.KEYCODE_SYSTEM_NAVIGATION_DOWN,
 		KeyEvent.KEYCODE_DPAD_DOWN,
-		KeyEvent.KEYCODE_DPAD_RIGHT,
 		-> {
 			listener.switchPageBy(1)
 			true
 		}
+		KeyEvent.KEYCODE_DPAD_RIGHT -> {
+			listener.switchPageBy(if (isReaderTapsReversed()) -1 else 1)
+			true
+		}
 		KeyEvent.KEYCODE_PAGE_UP,
 		KeyEvent.KEYCODE_SYSTEM_NAVIGATION_UP,
 		KeyEvent.KEYCODE_DPAD_UP,
-		KeyEvent.KEYCODE_DPAD_LEFT,
 		-> {
 			listener.switchPageBy(-1)
 			true
 		}
+		KeyEvent.KEYCODE_DPAD_LEFT -> {
+			listener.switchPageBy(if (isReaderTapsReversed()) 1 else -1)
+			true
+		}
 		KeyEvent.KEYCODE_DPAD_CENTER -> {
 			listener.toggleUiVisibility()
 			true
@@ -99,8 +111,21 @@ class ReaderControlDelegate(
 			)
 	}
 
+	private fun updateSettings() {
+		val switch = settings.readerPageSwitch
+		isTapSwitchEnabled = AppSettings.PAGE_SWITCH_TAPS in switch
+		isVolumeKeysSwitchEnabled = AppSettings.PAGE_SWITCH_VOLUME_KEYS in switch
+		isReaderTapsAdaptive = settings.isReaderTapsAdaptive
+	}
+
+	private fun isReaderTapsReversed(): Boolean {
+		return isReaderTapsAdaptive && listener.readerMode == ReaderMode.REVERSED
+	}
+
 	interface OnInteractionListener {
 
+		val readerMode: ReaderMode?
+
 		fun switchPageBy(delta: Int)
 
 		fun toggleUiVisibility()

app/src/main/java/org/koitharu/kotatsu/reader/ui/ReaderInfoBarView.kt

@@ -10,8 +10,11 @@ import android.graphics.Paint
 import android.graphics.Rect
 import android.util.AttributeSet
 import android.view.View
+import android.view.WindowInsets
 import androidx.annotation.AttrRes
 import androidx.core.graphics.ColorUtils
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
 import com.google.android.material.R as materialR
 import java.text.SimpleDateFormat
 import java.util.*
@@ -36,6 +39,8 @@ class ReaderInfoBarView @JvmOverloads constructor(
 	private var insetLeft: Int = 0
 	private var insetRight: Int = 0
 	private var insetTop: Int = 0
+	private var cutoutInsetLeft = 0
+	private var cutoutInsetRight = 0
 	private val colorText = ColorUtils.setAlphaComponent(
 		context.getThemeColor(materialR.attr.colorOnSurface, Color.BLACK),
 		200,
@@ -57,8 +62,9 @@ class ReaderInfoBarView @JvmOverloads constructor(
 	init {
 		paint.strokeWidth = context.resources.resolveDp(2f)
 		val insetCorner = getSystemUiDimensionOffset("rounded_corner_content_padding")
-		val insetStart = getSystemUiDimensionOffset("status_bar_padding_start") + insetCorner
-		val insetEnd = getSystemUiDimensionOffset("status_bar_padding_end") + insetCorner
+		val fallbackInset = resources.getDimensionPixelOffset(R.dimen.reader_bar_inset_fallback)
+		val insetStart = getSystemUiDimensionOffset("status_bar_padding_start", fallbackInset) + insetCorner
+		val insetEnd = getSystemUiDimensionOffset("status_bar_padding_end", fallbackInset) + insetCorner
 		val isRtl = layoutDirection == LAYOUT_DIRECTION_RTL
 		insetLeft = if (isRtl) insetEnd else insetStart
 		insetRight = if (isRtl) insetStart else insetEnd
@@ -78,19 +84,34 @@ class ReaderInfoBarView @JvmOverloads constructor(
 		super.onDraw(canvas)
 		val ty = innerHeight / 2f + textBounds.height() / 2f - textBounds.bottom
 		paint.textAlign = Paint.Align.LEFT
-		canvas.drawTextOutline(text, (paddingLeft + insetLeft).toFloat(), paddingTop + insetTop + ty)
+		canvas.drawTextOutline(
+			text,
+			(paddingLeft + insetLeft + cutoutInsetLeft).toFloat(),
+			paddingTop + insetTop + ty,
+		)
 		paint.textAlign = Paint.Align.RIGHT
-		canvas.drawTextOutline(timeText, (width - paddingRight - insetRight).toFloat(), paddingTop + insetTop + ty)
+		canvas.drawTextOutline(
+			timeText,
+			(width - paddingRight - insetRight - cutoutInsetRight).toFloat(),
+			paddingTop + insetTop + ty,
+		)
 	}
 
 	override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
 		super.onSizeChanged(w, h, oldw, oldh)
+		updateCutoutInsets(ViewCompat.getRootWindowInsets(this))
 		updateTextSize()
 	}
 
+	override fun onApplyWindowInsets(insets: WindowInsets): WindowInsets {
+		updateCutoutInsets(WindowInsetsCompat.toWindowInsetsCompat(insets))
+		return super.onApplyWindowInsets(insets)
+	}
+
 	override fun onAttachedToWindow() {
 		super.onAttachedToWindow()
 		context.registerReceiver(timeReceiver, IntentFilter(Intent.ACTION_TIME_TICK))
+		updateCutoutInsets(ViewCompat.getRootWindowInsets(this))
 	}
 
 	override fun onDetachedFromWindow() {
@@ -137,6 +158,20 @@ class ReaderInfoBarView @JvmOverloads constructor(
 		drawText(text, x, y, paint)
 	}
 
+	private fun updateCutoutInsets(insetsCompat: WindowInsetsCompat?) {
+		val cutouts = (insetsCompat ?: return).displayCutout?.boundingRects.orEmpty()
+		cutoutInsetLeft = 0
+		cutoutInsetRight = 0
+		for (rect in cutouts) {
+			if (rect.left <= paddingLeft) {
+				cutoutInsetLeft += rect.width()
+			}
+			if (rect.right >= width - paddingRight) {
+				cutoutInsetRight += rect.width()
+			}
+		}
+	}
+
 	private inner class TimeReceiver : BroadcastReceiver() {
 
 		override fun onReceive(context: Context?, intent: Intent?) {
@@ -145,12 +180,12 @@ class ReaderInfoBarView @JvmOverloads constructor(
 		}
 	}
 
-	private fun getSystemUiDimensionOffset(name: String): Int = runCatching {
+	private fun getSystemUiDimensionOffset(name: String, fallback: Int = 0): Int = runCatching {
 		val manager = context.packageManager
 		val resources = manager.getResourcesForApplication("com.android.systemui")
 		val resId = resources.getIdentifier(name, "dimen", "com.android.systemui")
 		resources.getDimensionPixelOffset(resId)
 	}.onFailure {
 		it.printStackTraceDebug()
-	}.getOrDefault(0)
+	}.getOrDefault(fallback)
 }

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

@@ -8,7 +8,7 @@ import org.koitharu.kotatsu.reader.ui.pager.BaseReader
 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
-import java.util.*
+import java.util.EnumMap
 
 class ReaderManager(
 	private val fragmentManager: FragmentManager,
@@ -35,11 +35,15 @@ class ReaderManager(
 	fun replace(newMode: ReaderMode) {
 		val readerClass = requireNotNull(modeMap[newMode])
 		fragmentManager.commit {
+			setReorderingAllowed(true)
 			replace(containerResId, readerClass, null, null)
 		}
 	}
 
 	fun replace(reader: BaseReader<*>) {
-		fragmentManager.commit { replace(containerResId, reader) }
+		fragmentManager.commit {
+			setReorderingAllowed(true)
+			replace(containerResId, reader)
+		}
 	}
-}
+}

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

@@ -10,10 +10,22 @@ import androidx.lifecycle.viewModelScope
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
-import java.util.*
-import javax.inject.Provider
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
 import org.koitharu.kotatsu.base.domain.MangaIntent
@@ -21,7 +33,11 @@ import org.koitharu.kotatsu.base.ui.BaseViewModel
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.bookmarks.domain.BookmarksRepository
 import org.koitharu.kotatsu.core.parser.MangaRepository
-import org.koitharu.kotatsu.core.prefs.*
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.prefs.ReaderMode
+import org.koitharu.kotatsu.core.prefs.ScreenshotsPolicy
+import org.koitharu.kotatsu.core.prefs.observeAsFlow
+import org.koitharu.kotatsu.core.prefs.observeAsLiveData
 import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
 import org.koitharu.kotatsu.parsers.exception.NotFoundException
@@ -31,12 +47,16 @@ import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.reader.data.filterChapters
 import org.koitharu.kotatsu.reader.domain.ChaptersLoader
 import org.koitharu.kotatsu.reader.domain.PageLoader
+import org.koitharu.kotatsu.reader.ui.config.ReaderSettings
 import org.koitharu.kotatsu.reader.ui.pager.ReaderUiState
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.asFlowLiveData
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.processLifecycleScope
 import org.koitharu.kotatsu.utils.ext.requireValue
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import java.util.Date
+import javax.inject.Provider
 
 private const val BOUNDS_PAGE_OFFSET = 2
 private const val PREFETCH_LIMIT = 10
@@ -86,6 +106,20 @@ class ReaderViewModel @AssistedInject constructor(
 		valueProducer = { isReaderBarEnabled },
 	)
 
+	val isWebtoonZoomEnabled = settings.observeAsLiveData(
+		context = viewModelScope.coroutineContext + Dispatchers.Default,
+		key = AppSettings.KEY_WEBTOON_ZOOM,
+		valueProducer = { isWebtoonZoomEnable },
+	)
+
+	val readerSettings = ReaderSettings(
+		parentScope = viewModelScope,
+		settings = settings,
+		colorFilterFlow = mangaData.flatMapLatest {
+			if (it == null) flowOf(null) else dataRepository.observeColorFilter(it.id)
+		}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, null),
+	)
+
 	val isScreenshotsBlockEnabled = combine(
 		mangaData,
 		settings.observeAsFlow(AppSettings.KEY_SCREENSHOTS_POLICY) { screenshotsPolicy },
@@ -94,8 +128,6 @@ class ReaderViewModel @AssistedInject constructor(
 			(policy == ScreenshotsPolicy.BLOCK_NSFW && manga != null && manga.isNsfw)
 	}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, false)
 
-	val onZoomChanged = SingleLiveEvent<Unit>()
-
 	val isBookmarkAdded: LiveData<Boolean> = currentState.flatMapLatest { state ->
 		val manga = mangaData.value
 		if (state == null || manga == null) {
@@ -108,7 +140,10 @@ class ReaderViewModel @AssistedInject constructor(
 
 	init {
 		loadImpl()
-		subscribeToSettings()
+		settings.observe()
+			.onEach { key ->
+				if (key == AppSettings.KEY_READER_SLIDER) notifyStateChanged()
+			}.launchIn(viewModelScope)
 	}
 
 	override fun onCleared() {
@@ -124,7 +159,7 @@ class ReaderViewModel @AssistedInject constructor(
 	fun switchMode(newMode: ReaderMode) {
 		launchJob {
 			val manga = checkNotNull(mangaData.value)
-			dataRepository.savePreferences(
+			dataRepository.saveReaderMode(
 				manga = manga,
 				mode = newMode,
 			)
@@ -300,13 +335,6 @@ class ReaderViewModel @AssistedInject constructor(
 		}
 	}
 
-	private fun subscribeToSettings() {
-		settings.observe()
-			.onEach { key ->
-				if (key == AppSettings.KEY_ZOOM_MODE) onZoomChanged.postCall(Unit)
-			}.launchIn(viewModelScope + Dispatchers.Default)
-	}
-
 	private fun <T> List<T>.trySublist(fromIndex: Int, toIndex: Int): List<T> {
 		val fromIndexBounded = fromIndex.coerceAtMost(lastIndex)
 		val toIndexBounded = toIndex.coerceIn(fromIndexBounded, lastIndex)
@@ -327,11 +355,11 @@ class ReaderViewModel @AssistedInject constructor(
 			?: manga.chapters?.randomOrNull()
 			?: error("There are no chapters in this manga")
 		val pages = repo.getPages(chapter)
-		return runCatching {
+		return runCatchingCancellable {
 			val isWebtoon = dataRepository.determineMangaIsWebtoon(repo, pages)
 			if (isWebtoon) ReaderMode.WEBTOON else defaultMode
 		}.onSuccess {
-			dataRepository.savePreferences(manga, it)
+			dataRepository.saveReaderMode(manga, it)
 		}.onFailure {
 			it.printStackTraceDebug()
 		}.getOrDefault(defaultMode)
@@ -348,6 +376,7 @@ class ReaderViewModel @AssistedInject constructor(
 			chaptersTotal = chapters.size(),
 			totalPages = if (chapter != null) chaptersLoader.getPagesCount(chapter.id) else 0,
 			currentPage = state?.page ?: 0,
+			isSliderEnabled = settings.isReaderSliderEnabled,
 		)
 		uiState.postValue(newState)
 	}
@@ -382,7 +411,7 @@ class ReaderViewModel @AssistedInject constructor(
  */
 private fun HistoryRepository.saveStateAsync(manga: Manga, state: ReaderState, percent: Float): Job {
 	return processLifecycleScope.launch(Dispatchers.Default) {
-		runCatching {
+		runCatchingCancellable {
 			addOrUpdate(
 				manga = manga,
 				chapterId = state.chapterId,

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

@@ -0,0 +1,151 @@
+package org.koitharu.kotatsu.reader.ui.colorfilter
+
+import android.content.Context
+import android.content.Intent
+import android.content.res.Resources
+import android.os.Bundle
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.graphics.Insets
+import androidx.core.view.updateLayoutParams
+import androidx.core.view.updatePadding
+import coil.ImageLoader
+import coil.request.ImageRequest
+import coil.size.Scale
+import coil.size.ViewSizeResolver
+import com.google.android.material.R as materialR
+import com.google.android.material.slider.LabelFormatter
+import com.google.android.material.slider.Slider
+import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.ui.BaseActivity
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableMangaPages
+import org.koitharu.kotatsu.databinding.ActivityColorFilterBinding
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.util.format
+import org.koitharu.kotatsu.reader.domain.ReaderColorFilter
+import org.koitharu.kotatsu.utils.ext.*
+
+@AndroidEntryPoint
+class ColorFilterConfigActivity :
+	BaseActivity<ActivityColorFilterBinding>(),
+	Slider.OnChangeListener,
+	View.OnClickListener {
+
+	@Inject
+	lateinit var coil: ImageLoader
+
+	@Inject
+	lateinit var viewModelFactory: ColorFilterConfigViewModel.Factory
+
+	private val viewModel: ColorFilterConfigViewModel by assistedViewModels {
+		viewModelFactory.create(
+			manga = checkNotNull(intent.getParcelableExtraCompat<ParcelableManga>(EXTRA_MANGA)?.manga),
+			page = checkNotNull(intent.getParcelableExtraCompat<ParcelableMangaPages>(EXTRA_PAGES)?.pages?.firstOrNull()),
+		)
+	}
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		setContentView(ActivityColorFilterBinding.inflate(layoutInflater))
+		supportActionBar?.run {
+			setDisplayHomeAsUpEnabled(true)
+			setHomeAsUpIndicator(materialR.drawable.abc_ic_clear_material)
+		}
+		binding.sliderBrightness.addOnChangeListener(this)
+		binding.sliderContrast.addOnChangeListener(this)
+		val formatter = PercentLabelFormatter(resources)
+		binding.sliderContrast.setLabelFormatter(formatter)
+		binding.sliderBrightness.setLabelFormatter(formatter)
+		binding.buttonDone.setOnClickListener(this)
+		binding.buttonReset.setOnClickListener(this)
+
+		onBackPressedDispatcher.addCallback(ColorFilterConfigBackPressedDispatcher(this, viewModel))
+
+		viewModel.colorFilter.observe(this, this::onColorFilterChanged)
+		viewModel.isLoading.observe(this, this::onLoadingChanged)
+		viewModel.preview.observe(this, this::onPreviewChanged)
+		viewModel.onDismiss.observe(this) {
+			finishAfterTransition()
+		}
+	}
+
+	override fun onValueChange(slider: Slider, value: Float, fromUser: Boolean) {
+		if (fromUser) {
+			when (slider.id) {
+				R.id.slider_brightness -> viewModel.setBrightness(value)
+				R.id.slider_contrast -> viewModel.setContrast(value)
+			}
+		}
+	}
+
+	override fun onClick(v: View) {
+		when (v.id) {
+			R.id.button_done -> viewModel.save()
+			R.id.button_reset -> viewModel.reset()
+		}
+	}
+
+	override fun onWindowInsetsChanged(insets: Insets) {
+		binding.root.updatePadding(
+			left = insets.left,
+			right = insets.right,
+		)
+		binding.scrollView.updatePadding(
+			bottom = insets.bottom,
+		)
+		binding.toolbar.updateLayoutParams<ViewGroup.MarginLayoutParams> {
+			topMargin = insets.top
+		}
+	}
+
+	private fun onColorFilterChanged(readerColorFilter: ReaderColorFilter?) {
+		binding.sliderBrightness.value = readerColorFilter?.brightness ?: 0f
+		binding.sliderContrast.value = readerColorFilter?.contrast ?: 0f
+		binding.imageViewAfter.colorFilter = readerColorFilter?.toColorFilter()
+	}
+
+	private fun onPreviewChanged(preview: MangaPage?) {
+		if (preview == null) return
+		ImageRequest.Builder(this@ColorFilterConfigActivity)
+			.data(preview.url)
+			.referer(preview.referer)
+			.scale(Scale.FILL)
+			.decodeRegion()
+			.error(R.drawable.ic_error_placeholder)
+			.size(ViewSizeResolver(binding.imageViewBefore))
+			.allowRgb565(false)
+			.target(ShadowViewTarget(binding.imageViewBefore, binding.imageViewAfter))
+			.enqueueWith(coil)
+	}
+
+	private fun onLoadingChanged(isLoading: Boolean) {
+		binding.sliderContrast.isEnabled = !isLoading
+		binding.sliderBrightness.isEnabled = !isLoading
+		binding.buttonDone.isEnabled = !isLoading
+	}
+
+	private class PercentLabelFormatter(resources: Resources) : LabelFormatter {
+
+		private val pattern = resources.getString(R.string.percent_string_pattern)
+
+		override fun getFormattedValue(value: Float): String {
+			val percent = ((value + 1f) * 100).format(0)
+			return pattern.format(percent)
+		}
+	}
+
+	companion object {
+
+		private const val EXTRA_PAGES = "pages"
+		private const val EXTRA_MANGA = "manga_id"
+
+		fun newIntent(context: Context, manga: Manga, page: MangaPage) =
+			Intent(context, ColorFilterConfigActivity::class.java)
+				.putExtra(EXTRA_MANGA, ParcelableManga(manga, false))
+				.putExtra(EXTRA_PAGES, ParcelableMangaPages(listOf(page)))
+	}
+}

app/src/main/java/org/koitharu/kotatsu/reader/ui/colorfilter/ColorFilterConfigBackPressedDispatcher.kt

@@ -0,0 +1,39 @@
+package org.koitharu.kotatsu.reader.ui.colorfilter
+
+import android.content.Context
+import android.content.DialogInterface
+import androidx.activity.OnBackPressedCallback
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import org.koitharu.kotatsu.R
+
+class ColorFilterConfigBackPressedDispatcher(
+	private val context: Context,
+	private val viewModel: ColorFilterConfigViewModel,
+) : OnBackPressedCallback(true), DialogInterface.OnClickListener {
+
+	override fun handleOnBackPressed() {
+		if (viewModel.isChanged) {
+			showConfirmation()
+		} else {
+			viewModel.onDismiss.call(Unit)
+		}
+	}
+
+	override fun onClick(dialog: DialogInterface, which: Int) {
+		when (which) {
+			DialogInterface.BUTTON_NEGATIVE -> viewModel.onDismiss.call(Unit)
+			DialogInterface.BUTTON_NEUTRAL -> dialog.dismiss()
+			DialogInterface.BUTTON_POSITIVE -> viewModel.save()
+		}
+	}
+
+	private fun showConfirmation() {
+		MaterialAlertDialogBuilder(context)
+			.setTitle(R.string.color_correction)
+			.setMessage(R.string.text_unsaved_changes_prompt)
+			.setNegativeButton(R.string.discard, this)
+			.setNeutralButton(android.R.string.cancel, this)
+			.setPositiveButton(R.string.save, this)
+			.show()
+	}
+}

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

@@ -0,0 +1,74 @@
+package org.koitharu.kotatsu.reader.ui.colorfilter
+
+import androidx.lifecycle.MutableLiveData
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import org.koitharu.kotatsu.base.domain.MangaDataRepository
+import org.koitharu.kotatsu.base.ui.BaseViewModel
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.reader.domain.ReaderColorFilter
+import org.koitharu.kotatsu.utils.SingleLiveEvent
+
+class ColorFilterConfigViewModel @AssistedInject constructor(
+	@Assisted private val manga: Manga,
+	@Assisted page: MangaPage,
+	private val mangaRepositoryFactory: MangaRepository.Factory,
+	private val mangaDataRepository: MangaDataRepository,
+) : BaseViewModel() {
+
+	private var initialColorFilter: ReaderColorFilter? = null
+	val colorFilter = MutableLiveData<ReaderColorFilter?>(null)
+	val onDismiss = SingleLiveEvent<Unit>()
+	val preview = MutableLiveData<MangaPage?>(null)
+
+	val isChanged: Boolean
+		get() = colorFilter.value != initialColorFilter
+
+	init {
+		launchLoadingJob {
+			initialColorFilter = mangaDataRepository.getColorFilter(manga.id)
+			colorFilter.value = initialColorFilter
+		}
+		launchLoadingJob {
+			val repository = mangaRepositoryFactory.create(page.source)
+			val url = repository.getPageUrl(page)
+			preview.value = MangaPage(
+				id = page.id,
+				url = url,
+				referer = page.referer,
+				preview = page.preview,
+				source = page.source,
+			)
+		}
+	}
+
+	fun setBrightness(brightness: Float) {
+		val cf = colorFilter.value
+		colorFilter.value = ReaderColorFilter(brightness, cf?.contrast ?: 0f).takeUnless { it.isEmpty }
+	}
+
+	fun setContrast(contrast: Float) {
+		val cf = colorFilter.value
+		colorFilter.value = ReaderColorFilter(cf?.brightness ?: 0f, contrast).takeUnless { it.isEmpty }
+	}
+
+	fun reset() {
+		colorFilter.value = null
+	}
+
+	fun save() {
+		launchLoadingJob {
+			mangaDataRepository.saveColorFilter(manga, colorFilter.value)
+			onDismiss.call(Unit)
+		}
+	}
+
+	@AssistedFactory
+	interface Factory {
+
+		fun create(manga: Manga, page: MangaPage): ColorFilterConfigViewModel
+	}
+}

app/src/main/java/org/koitharu/kotatsu/reader/ui/colorfilter/ShadowViewTarget.kt

@@ -0,0 +1,18 @@
+package org.koitharu.kotatsu.reader.ui.colorfilter
+
+import android.graphics.drawable.Drawable
+import android.widget.ImageView
+import coil.target.ImageViewTarget
+
+class ShadowViewTarget(
+	view: ImageView,
+	private val shadowView: ImageView,
+) : ImageViewTarget(view) {
+
+	override var drawable: Drawable?
+		get() = super.drawable
+		set(value) {
+			super.drawable = value
+			shadowView.setImageDrawable(value?.constantState?.newDrawable())
+		}
+}

app/src/main/java/org/koitharu/kotatsu/reader/ui/config/ReaderConfigBottomSheet.kt

@@ -20,6 +20,7 @@ import org.koitharu.kotatsu.core.prefs.ReaderMode
 import org.koitharu.kotatsu.databinding.SheetReaderConfigBinding
 import org.koitharu.kotatsu.reader.ui.PageSaveContract
 import org.koitharu.kotatsu.reader.ui.ReaderViewModel
+import org.koitharu.kotatsu.reader.ui.colorfilter.ColorFilterConfigActivity
 import org.koitharu.kotatsu.settings.SettingsActivity
 import org.koitharu.kotatsu.utils.ScreenOrientationHelper
 import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
@@ -59,6 +60,7 @@ class ReaderConfigBottomSheet :
 		binding.buttonSavePage.setOnClickListener(this)
 		binding.buttonScreenRotate.setOnClickListener(this)
 		binding.buttonSettings.setOnClickListener(this)
+		binding.buttonColorFilter.setOnClickListener(this)
 		binding.sliderTimer.addOnSliderTouchListener(this)
 		binding.sliderTimer.setLabelFormatter(PageSwitchTimer.DelayLabelFormatter(view.resources))
 
@@ -80,6 +82,11 @@ class ReaderConfigBottomSheet :
 			R.id.button_screen_rotate -> {
 				orientationHelper?.toggleOrientation()
 			}
+			R.id.button_color_filter -> {
+				val page = viewModel.getCurrentPage() ?: return
+				val manga = viewModel.manga ?: return
+				startActivity(ColorFilterConfigActivity.newIntent(v.context, manga, page))
+			}
 		}
 	}
 

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

@@ -0,0 +1,72 @@
+package org.koitharu.kotatsu.reader.ui.config
+
+import android.content.SharedPreferences
+import androidx.lifecycle.MediatorLiveData
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.StateFlow
+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.reader.domain.ReaderColorFilter
+
+class ReaderSettings(
+	private val parentScope: CoroutineScope,
+	private val settings: AppSettings,
+	private val colorFilterFlow: StateFlow<ReaderColorFilter?>,
+) : MediatorLiveData<ReaderSettings>() {
+
+	private val internalObserver = InternalObserver()
+	private var collectJob: Job? = null
+
+	val zoomMode: ZoomMode
+		get() = settings.zoomMode
+
+	val colorFilter: ReaderColorFilter?
+		get() = colorFilterFlow.value
+
+	val isPagesNumbersEnabled: Boolean
+		get() = settings.isPagesNumbersEnabled
+
+	override fun onInactive() {
+		super.onInactive()
+		settings.unsubscribe(internalObserver)
+		collectJob?.cancel()
+		collectJob = null
+	}
+
+	override fun onActive() {
+		super.onActive()
+		settings.subscribe(internalObserver)
+		collectJob?.cancel()
+		collectJob = parentScope.launch {
+			colorFilterFlow.collect(internalObserver)
+		}
+	}
+
+	override fun getValue() = this
+
+	private fun notifyChanged() {
+		value = value
+	}
+
+	private inner class InternalObserver :
+		FlowCollector<ReaderColorFilter?>,
+		SharedPreferences.OnSharedPreferenceChangeListener {
+
+		override suspend fun emit(value: ReaderColorFilter?) {
+			withContext(Dispatchers.Main.immediate) {
+				notifyChanged()
+			}
+		}
+
+		override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences?, key: String?) {
+			if (key == AppSettings.KEY_ZOOM_MODE || key == AppSettings.KEY_PAGES_NUMBERS || key == AppSettings.KEY_WEBTOON_ZOOM) {
+				notifyChanged()
+			}
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/reader/ui/pager/BasePageHolder.kt

@@ -5,15 +5,15 @@ import androidx.annotation.CallSuper
 import androidx.recyclerview.widget.RecyclerView
 import androidx.viewbinding.ViewBinding
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
-import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.databinding.LayoutPageInfoBinding
 import org.koitharu.kotatsu.reader.domain.PageLoader
+import org.koitharu.kotatsu.reader.ui.config.ReaderSettings
 
 abstract class BasePageHolder<B : ViewBinding>(
 	protected val binding: B,
 	loader: PageLoader,
-	settings: AppSettings,
-	exceptionResolver: ExceptionResolver
+	settings: ReaderSettings,
+	exceptionResolver: ExceptionResolver,
 ) : RecyclerView.ViewHolder(binding.root), PageHolderDelegate.Callback {
 
 	@Suppress("LeakingThis")
@@ -37,8 +37,18 @@ abstract class BasePageHolder<B : ViewBinding>(
 
 	protected abstract fun onBind(data: ReaderPage)
 
+	@CallSuper
+	open fun onAttachedToWindow() {
+		delegate.onAttachedToWindow()
+	}
+
+	@CallSuper
+	open fun onDetachedFromWindow() {
+		delegate.onDetachedFromWindow()
+	}
+
 	@CallSuper
 	open fun onRecycled() {
 		delegate.onRecycle()
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/reader/ui/pager/BaseReaderAdapter.kt

@@ -4,17 +4,17 @@ import android.view.ViewGroup
 import androidx.recyclerview.widget.AsyncListDiffer
 import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.RecyclerView
-import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
-import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.reader.domain.PageLoader
-import org.koitharu.kotatsu.utils.ext.resetTransformations
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
+import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
+import org.koitharu.kotatsu.reader.domain.PageLoader
+import org.koitharu.kotatsu.reader.ui.config.ReaderSettings
+import org.koitharu.kotatsu.utils.ext.resetTransformations
 
 @Suppress("LeakingThis")
 abstract class BaseReaderAdapter<H : BasePageHolder<*>>(
 	private val loader: PageLoader,
-	private val settings: AppSettings,
+	private val readerSettings: ReaderSettings,
 	private val exceptionResolver: ExceptionResolver,
 ) : RecyclerView.Adapter<H>() {
 
@@ -35,6 +35,16 @@ abstract class BaseReaderAdapter<H : BasePageHolder<*>>(
 		super.onViewRecycled(holder)
 	}
 
+	override fun onViewAttachedToWindow(holder: H) {
+		super.onViewAttachedToWindow(holder)
+		holder.onAttachedToWindow()
+	}
+
+	override fun onViewDetachedFromWindow(holder: H) {
+		holder.onDetachedFromWindow()
+		super.onViewDetachedFromWindow(holder)
+	}
+
 	open fun getItem(position: Int): ReaderPage = differ.currentList[position]
 
 	open fun getItemOrNull(position: Int) = differ.currentList.getOrNull(position)
@@ -45,8 +55,8 @@ abstract class BaseReaderAdapter<H : BasePageHolder<*>>(
 
 	final override fun onCreateViewHolder(
 		parent: ViewGroup,
-		viewType: Int
-	): H = onCreateViewHolder(parent, loader, settings, exceptionResolver)
+		viewType: Int,
+	): H = onCreateViewHolder(parent, loader, readerSettings, exceptionResolver)
 
 	suspend fun setItems(items: List<ReaderPage>) = suspendCoroutine<Unit> { cont ->
 		differ.submitList(items) {
@@ -57,8 +67,8 @@ abstract class BaseReaderAdapter<H : BasePageHolder<*>>(
 	protected abstract fun onCreateViewHolder(
 		parent: ViewGroup,
 		loader: PageLoader,
-		settings: AppSettings,
-		exceptionResolver: ExceptionResolver
+		settings: ReaderSettings,
+		exceptionResolver: ExceptionResolver,
 	): H
 
 	private class DiffCallback : DiffUtil.ItemCallback<ReaderPage>() {
@@ -70,6 +80,5 @@ abstract class BaseReaderAdapter<H : BasePageHolder<*>>(
 		override fun areContentsTheSame(oldItem: ReaderPage, newItem: ReaderPage): Boolean {
 			return oldItem == newItem
 		}
-
 	}
-}
+}

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

@@ -2,26 +2,32 @@ package org.koitharu.kotatsu.reader.ui.pager
 
 import android.net.Uri
 import androidx.core.net.toUri
-import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
-import kotlinx.coroutines.*
+import androidx.lifecycle.Observer
+import com.davemorrissey.labs.subscaleview.DefaultOnImageEventListener
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
-import org.koitharu.kotatsu.core.model.ZoomMode
-import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.reader.domain.PageLoader
+import org.koitharu.kotatsu.reader.ui.config.ReaderSettings
 import java.io.File
 import java.io.IOException
 
 class PageHolderDelegate(
 	private val loader: PageLoader,
-	private val settings: AppSettings,
+	private val readerSettings: ReaderSettings,
 	private val callback: Callback,
-	private val exceptionResolver: ExceptionResolver
-) : SubsamplingScaleImageView.DefaultOnImageEventListener() {
+	private val exceptionResolver: ExceptionResolver,
+) : DefaultOnImageEventListener, Observer<ReaderSettings> {
 
 	private val scope = loader.loaderScope + Dispatchers.Main.immediate
 	private var state = State.EMPTY
@@ -49,6 +55,14 @@ class PageHolderDelegate(
 		}
 	}
 
+	fun onAttachedToWindow() {
+		readerSettings.observeForever(this)
+	}
+
+	fun onDetachedFromWindow() {
+		readerSettings.removeObserver(this)
+	}
+
 	fun onRecycle() {
 		state = State.EMPTY
 		file = null
@@ -59,7 +73,7 @@ class PageHolderDelegate(
 	override fun onReady() {
 		state = State.SHOWING
 		error = null
-		callback.onImageShowing(settings.zoomMode)
+		callback.onImageShowing(readerSettings)
 	}
 
 	override fun onImageLoaded() {
@@ -68,7 +82,7 @@ class PageHolderDelegate(
 		callback.onImageShown()
 	}
 
-	override fun onImageLoadError(e: Exception) {
+	override fun onImageLoadError(e: Throwable) {
 		val file = this.file
 		error = e
 		if (state == State.LOADED && e is IOException && file != null && file.exists()) {
@@ -79,6 +93,12 @@ class PageHolderDelegate(
 		}
 	}
 
+	override fun onChanged(t: ReaderSettings?) {
+		if (state == State.SHOWN) {
+			callback.onImageShowing(readerSettings)
+		}
+	}
+
 	private fun tryConvert(file: File, e: Exception) {
 		val prevJob = job
 		job = scope.launch {
@@ -88,6 +108,8 @@ class PageHolderDelegate(
 				loader.convertInPlace(file)
 				state = State.CONVERTED
 				callback.onImageReady(file.toUri())
+			} catch (ce: CancellationException) {
+				throw ce
 			} catch (e2: Throwable) {
 				e.addSuppressed(e2)
 				state = State.ERROR
@@ -110,7 +132,7 @@ class PageHolderDelegate(
 			callback.onImageReady(file.toUri())
 		} catch (e: CancellationException) {
 			throw e
-		} catch (e: Exception) {
+		} catch (e: Throwable) {
 			state = State.ERROR
 			error = e
 			callback.onError(e)
@@ -134,10 +156,10 @@ class PageHolderDelegate(
 
 		fun onImageReady(uri: Uri)
 
-		fun onImageShowing(zoom: ZoomMode)
+		fun onImageShowing(settings: ReaderSettings)
 
 		fun onImageShown()
 
 		fun onProgressChanged(progress: Int)
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/reader/ui/pager/ReaderUiState.kt

@@ -7,8 +7,13 @@ data class ReaderUiState(
 	val chaptersTotal: Int,
 	val currentPage: Int,
 	val totalPages: Int,
+	private val isSliderEnabled: Boolean,
 ) {
 
+	fun isSliderAvailable(): Boolean {
+		return isSliderEnabled && totalPages > 1 && currentPage < totalPages
+	}
+
 	fun computePercent(): Float {
 		val ppc = 1f / chaptersTotal
 		val chapterIndex = chapterNumber - 1

app/src/main/java/org/koitharu/kotatsu/reader/ui/pager/reversed/ReversedPageHolder.kt

@@ -6,16 +6,16 @@ import android.widget.FrameLayout
 import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.model.ZoomMode
-import org.koitharu.kotatsu.core.prefs.AppSettings
 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.standard.PageHolder
 
 class ReversedPageHolder(
 	binding: ItemPageBinding,
 	loader: PageLoader,
-	settings: AppSettings,
-	exceptionResolver: ExceptionResolver
+	settings: ReaderSettings,
+	exceptionResolver: ExceptionResolver,
 ) : PageHolder(binding, loader, settings, exceptionResolver) {
 
 	init {
@@ -23,41 +23,42 @@ class ReversedPageHolder(
 			.gravity = Gravity.START or Gravity.BOTTOM
 	}
 
-	override fun onImageShowing(zoom: ZoomMode) {
+	override fun onImageShowing(settings: ReaderSettings) {
 		with(binding.ssiv) {
 			maxScale = 2f * maxOf(
 				width / sWidth.toFloat(),
-				height / sHeight.toFloat()
+				height / sHeight.toFloat(),
 			)
-			when (zoom) {
+			binding.ssiv.colorFilter = settings.colorFilter?.toColorFilter()
+			when (settings.zoomMode) {
 				ZoomMode.FIT_CENTER -> {
-					setMinimumScaleType(SubsamplingScaleImageView.SCALE_TYPE_CENTER_INSIDE)
+					minimumScaleType = SubsamplingScaleImageView.SCALE_TYPE_CENTER_INSIDE
 					resetScaleAndCenter()
 				}
 				ZoomMode.FIT_HEIGHT -> {
-					setMinimumScaleType(SubsamplingScaleImageView.SCALE_TYPE_CUSTOM)
+					minimumScaleType = SubsamplingScaleImageView.SCALE_TYPE_CUSTOM
 					minScale = height / sHeight.toFloat()
 					setScaleAndCenter(
 						minScale,
-						PointF(sWidth.toFloat(), sHeight / 2f)
+						PointF(sWidth.toFloat(), sHeight / 2f),
 					)
 				}
 				ZoomMode.FIT_WIDTH -> {
-					setMinimumScaleType(SubsamplingScaleImageView.SCALE_TYPE_CUSTOM)
+					minimumScaleType = SubsamplingScaleImageView.SCALE_TYPE_CUSTOM
 					minScale = width / sWidth.toFloat()
 					setScaleAndCenter(
 						minScale,
-						PointF(sWidth / 2f, 0f)
+						PointF(sWidth / 2f, 0f),
 					)
 				}
 				ZoomMode.KEEP_START -> {
-					setMinimumScaleType(SubsamplingScaleImageView.SCALE_TYPE_CENTER_INSIDE)
+					minimumScaleType = SubsamplingScaleImageView.SCALE_TYPE_CENTER_INSIDE
 					setScaleAndCenter(
 						maxScale,
-						PointF(sWidth.toFloat(), 0f)
+						PointF(sWidth.toFloat(), 0f),
 					)
 				}
 			}
 		}
 	}
-}
+}