Update readme

Currently translated at 99.8% (895 of 896 strings)

Co-authored-by: Milo Ivir <mail@milotype.de>
Translate-URL: https://hosted.weblate.org/projects/kotatsu/strings/hr/
Translation: Kotatsu/Strings

.editorconfig

@@ -4,7 +4,7 @@ root = true
 charset = utf-8
 end_of_line = lf
 indent_size = 4
-indent_style = tab
+indent_style = space
 insert_final_newline = true
 max_line_length = 120
 tab_width = 4

.gitignore

@@ -6,6 +6,7 @@
 /.idea/dictionaries
 /.idea/modules.xml
 /.idea/misc.xml
+/.idea/markdown.xml
 /.idea/discord.xml
 /.idea/compiler.xml
 /.idea/workspace.xml

.idea/.gitignore

@@ -3,3 +3,5 @@
 /workspace.xml
 /migrations.xml
 /runConfigurations.xml
+/appInsightsSettings.xml
+/kotlinCodeInsightSettings.xml

.idea/appInsightsSettings.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AppInsightsSettings">
+    <option name="tabSettings">
+      <map>
+        <entry key="Firebase Crashlytics">
+          <value>
+            <InsightsFilterSettings>
+              <option name="connection">
+                <ConnectionSetting>
+                  <option name="appId" value="PLACEHOLDER" />
+                  <option name="mobileSdkAppId" value="" />
+                  <option name="projectId" value="" />
+                  <option name="projectNumber" value="" />
+                </ConnectionSetting>
+              </option>
+              <option name="signal" value="SIGNAL_UNSPECIFIED" />
+              <option name="timeIntervalDays" value="THIRTY_DAYS" />
+              <option name="visibilityType" value="ALL" />
+            </InsightsFilterSettings>
+          </value>
+        </entry>
+      </map>
+    </option>
+  </component>
+</project>

.idea/codeStyles/Project.xml

@@ -1,9 +1,7 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
     <option name="OTHER_INDENT_OPTIONS">
-      <value>
+      <value />
-        <option name="USE_TAB_CHARACTER" value="true" />
-      </value>
     </option>
     <AndroidXmlCodeStyleSettings>
       <option name="LAYOUT_SETTINGS">
@@ -22,40 +20,46 @@
         </value>
       </option>
     </AndroidXmlCodeStyleSettings>
+    <JavaCodeStyleSettings>
+      <option name="IMPORT_LAYOUT_TABLE">
+        <value>
+          <package name="android" withSubpackages="true" static="true" />
+          <package name="androidx" withSubpackages="true" static="true" />
+          <package name="com" withSubpackages="true" static="true" />
+          <package name="junit" withSubpackages="true" static="true" />
+          <package name="net" withSubpackages="true" static="true" />
+          <package name="org" withSubpackages="true" static="true" />
+          <package name="java" withSubpackages="true" static="true" />
+          <package name="javax" withSubpackages="true" static="true" />
+          <package name="" withSubpackages="true" static="true" />
+          <emptyLine />
+          <package name="android" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="androidx" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="com" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="junit" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="net" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="org" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="java" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="javax" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="" withSubpackages="true" static="false" />
+          <emptyLine />
+        </value>
+      </option>
+    </JavaCodeStyleSettings>
     <JetCodeStyleSettings>
       <option name="ALLOW_TRAILING_COMMA" value="true" />
+      <option name="ALLOW_TRAILING_COMMA_COLLECTION_LITERAL_EXPRESSION" value="true" />
+      <option name="ALLOW_TRAILING_COMMA_VALUE_ARGUMENT_LIST" value="true" />
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
-    <codeStyleSettings language="CMake">
-      <indentOptions>
-        <option name="USE_TAB_CHARACTER" value="true" />
-      </indentOptions>
-    </codeStyleSettings>
-    <codeStyleSettings language="Groovy">
-      <indentOptions>
-        <option name="USE_TAB_CHARACTER" value="true" />
-      </indentOptions>
-    </codeStyleSettings>
-    <codeStyleSettings language="HTML">
-      <indentOptions>
-        <option name="USE_TAB_CHARACTER" value="true" />
-      </indentOptions>
-    </codeStyleSettings>
-    <codeStyleSettings language="JAVA">
-      <indentOptions>
-        <option name="USE_TAB_CHARACTER" value="true" />
-      </indentOptions>
-    </codeStyleSettings>
-    <codeStyleSettings language="JSON">
-      <indentOptions>
-        <option name="USE_TAB_CHARACTER" value="true" />
-      </indentOptions>
-    </codeStyleSettings>
-    <codeStyleSettings language="ObjectiveC">
-      <indentOptions>
-        <option name="USE_TAB_CHARACTER" value="true" />
-      </indentOptions>
-    </codeStyleSettings>
     <codeStyleSettings language="Shell Script">
       <indentOptions>
         <option name="USE_TAB_CHARACTER" value="true" />
@@ -64,7 +68,6 @@
     <codeStyleSettings language="XML">
       <indentOptions>
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
-        <option name="USE_TAB_CHARACTER" value="true" />
       </indentOptions>
       <arrangement>
         <rules>
@@ -179,9 +182,6 @@
       <option name="LINE_COMMENT_AT_FIRST_COLUMN" value="false" />
       <option name="BLOCK_COMMENT_AT_FIRST_COLUMN" value="false" />
       <option name="LINE_COMMENT_ADD_SPACE" value="true" />
-      <indentOptions>
-        <option name="USE_TAB_CHARACTER" value="true" />
-      </indentOptions>
     </codeStyleSettings>
   </code_scheme>
 </component>

.idea/gradle.xml

@@ -6,7 +6,7 @@
       <GradleProjectSettings>
         <option name="testRunner" value="CHOOSE_PER_TEST" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="jbr-21" />
+        <option name="gradleJvm" value="#GRADLE_LOCAL_JAVA_HOME" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />

README.md

@@ -1,24 +1,16 @@
-<div align="center">
+> [!IMPORTANT]
-
+> In light of recent challenges — including threating actions from Kakao Entertainment Corp and upcoming Google’s
-<a href="https://kotatsu.app">
+> [new sideloading policy](https://f-droid.org/ru/2025/10/28/sideloading.html) — we’ve made the difficult decision to shut down Kotatsu and end its support. We’re deeply grateful
-    <img src="./.github/assets/vtuber.png" alt="Kotatsu Logo" title="Kotatsu" width="600"/>
+> to everyone who contributed and to the amazing community that grew around this project.
-</a>
-
-# [Kotatsu](https://kotatsu.app)
-
-**[Kotatsu](https://github.com/KotatsuApp/Kotatsu) is a free and open-source manga reader for Android with built-in online content sources.**
 
-![Downloads count](https://img.shields.io/github/downloads/KotatsuApp/Kotatsu/total?color=1976d2) ![Latest Stable version](https://img.shields.io/github/v/release/KotatsuApp/Kotatsu?color=2596be&label=latest) ![Android 5.0](https://img.shields.io/badge/android-5.0+-brightgreen) [![Sources count](https://img.shields.io/badge/dynamic/yaml?url=https%3A%2F%2Fraw.githubusercontent.com%2FKotatsuApp%2Fkotatsu-parsers%2Frefs%2Fheads%2Fmaster%2F.github%2Fsummary.yaml&query=total&label=manga%20sources&color=%23E9321C)](https://github.com/KotatsuApp/kotatsu-parsers) [![weblate](https://hosted.weblate.org/widgets/kotatsu/-/strings/svg-badge.svg)](https://hosted.weblate.org/engage/kotatsu/) [![Discord](https://img.shields.io/discord/898363402467045416?color=5865f2&label=discord)](https://discord.gg/NNJ5RgVBC5) [![Telegram](https://img.shields.io/badge/chat-telegram-60ACFF?)](https://t.me/kotatsuapp) [![License](https://img.shields.io/github/license/KotatsuApp/Kotatsu)](https://github.com/KotatsuApp/Kotatsu/blob/devel/LICENSE)
+---
 
-### Download
+<div align="center">
-
-<div align="left">
 
-* **Recommended:** Download and install APK from [GitHub Releases](https://github.com/KotatsuApp/Kotatsu/releases/latest). Application has a built-in self-updating feature.
+**[Kotatsu](https://github.com/KotatsuApp/Kotatsu) is a free and open-source manga reader for Android with built-in
-* Get it on [F-Droid](https://f-droid.org/packages/org.koitharu.kotatsu). The F-Droid build may be a bit outdated and some fixes might be missing.
+online content sources.**
-* Also [nightly builds](https://github.com/KotatsuApp/Kotatsu-nightly/releases) are available (Unstable, use at your own risk). Application has a built-in self-updating feature.
 
-</div>
+![Android 6.0](https://img.shields.io/badge/android-6.0+-brightgreen) [![Sources count](https://img.shields.io/badge/dynamic/yaml?url=https%3A%2F%2Fraw.githubusercontent.com%2FKotatsuApp%2Fkotatsu-parsers%2Frefs%2Fheads%2Fmaster%2F.github%2Fsummary.yaml&query=total&label=manga%20sources&color=%23E9321C)](https://github.com/KotatsuApp/kotatsu-parsers) [![weblate](https://hosted.weblate.org/widgets/kotatsu/-/strings/svg-badge.svg)](https://hosted.weblate.org/engage/kotatsu/) [![Discord](https://img.shields.io/discord/898363402467045416?color=5865f2&label=discord)](https://discord.gg/NNJ5RgVBC5) [![Telegram](https://img.shields.io/badge/chat-telegram-60ACFF?)](https://t.me/kotatsuapp) [![License](https://img.shields.io/github/license/KotatsuApp/Kotatsu)](https://github.com/KotatsuApp/Kotatsu/blob/devel/LICENSE)
 
 ### Main Features
 
@@ -35,7 +27,7 @@
 * Integration with manga tracking services: Shikimori, AniList, MyAnimeList, Kitsu
 * Password / fingerprint-protected access to the app
 * Automatically sync app data with other devices on the same account
-* Support for older devices running Android 5.0+
+* Support for older devices running Android 6.0+
 
 </div>
 
@@ -86,7 +78,8 @@ please head over to the [Weblate project page](https://hosted.weblate.org/engage
 
 </br>
 
-**📌 Pull requests are welcome, if you want: See [CONTRIBUTING.md](https://github.com/KotatsuApp/Kotatsu/blob/devel/CONTRIBUTING.md) for the guidelines**
+**📌 Pull requests are welcome, if you want:
+See [CONTRIBUTING.md](https://github.com/KotatsuApp/Kotatsu/blob/devel/CONTRIBUTING.md) for the guidelines**
 
 ### Certificate fingerprints
 
@@ -104,7 +97,9 @@ please head over to the [Weblate project page](https://hosted.weblate.org/engage
 
 <div align="left">
 
-You may copy, distribute and modify the software as long as you track changes/dates in source files. Any modifications to or software including (via compiler) GPL-licensed code must also be made available under the GPL along with build & install instructions.
+You may copy, distribute and modify the software as long as you track changes/dates in source files. Any modifications
+to or software including (via compiler) GPL-licensed code must also be made available under the GPL along with build &
+install instructions.
 
 </div>
 
@@ -112,6 +107,9 @@ You may copy, distribute and modify the software as long as you track changes/da
 
 <div align="left">
 
-The developers of this application do not have any affiliation with the content available in the app. It collects content from sources that are freely available through any web browser.
+The developers of this application do not have any affiliation with the content available in the app and does not store
+or distribute any content. This application should be considered a web browser, all content that can be found using this
+application is freely available on the Internet. All DMCA takedown requests should be sent to the owners of the website
+where the content is hosted.
 
 </div>

app/build.gradle

@@ -19,10 +19,10 @@ android {
 
 	defaultConfig {
 		applicationId 'org.koitharu.kotatsu'
-		minSdk = 21
+		minSdk = 23
 		targetSdk = 36
-		versionCode = 1028
+		versionCode = 1033
-		versionName = '9.1.4'
+		versionName = '9.4.1'
 		generatedDensities = []
 		testInstrumentationRunner 'org.koitharu.kotatsu.HiltTestRunner'
 		ksp {
@@ -87,6 +87,7 @@ android {
 			'-opt-in=coil3.annotation.InternalCoilApi',
 			'-opt-in=kotlinx.serialization.ExperimentalSerializationApi',
 			'-Xjspecify-annotations=strict',
+			'-Xannotation-default-target=first-only',
 			'-Xtype-enhancement-improvements-strict-mode'
 		]
 	}
@@ -154,6 +155,9 @@ dependencies {
 	implementation libs.androidx.work.runtime
 	implementation libs.guava
 
+    // Foldable/Window layout
+    implementation libs.androidx.window
+
 	implementation libs.androidx.room.runtime
 	implementation libs.androidx.room.ktx
 	ksp libs.androidx.room.compiler

app/proguard-rules.pro

@@ -8,8 +8,7 @@
 	public static void checkParameterIsNotNull(...);
 	public static void checkNotNullParameter(...);
 }
--keep public class ** extends org.koitharu.kotatsu.core.ui.BaseFragment
+
--keep class org.koitharu.kotatsu.core.db.entity.* { *; }
 -dontwarn okhttp3.internal.platform.**
 -dontwarn org.conscrypt.**
 -dontwarn org.bouncycastle.**
@@ -17,8 +16,10 @@
 -dontwarn com.google.j2objc.annotations.**
 -dontwarn coil3.PlatformContext
 
--keep class org.koitharu.kotatsu.core.exceptions.* { *; }
 -keep class org.koitharu.kotatsu.settings.NotificationSettingsLegacyFragment
+-keep class org.koitharu.kotatsu.settings.about.changelog.ChangelogFragment
+
+-keep class org.koitharu.kotatsu.core.exceptions.* { *; }
 -keep class org.koitharu.kotatsu.core.prefs.ScreenshotsPolicy { *; }
 -keep class org.koitharu.kotatsu.backups.ui.periodical.PeriodicalBackupSettingsFragment { *; }
 -keep class org.jsoup.parser.Tag

app/src/debug/kotlin/org/koitharu/kotatsu/KotatsuApp.kt

@@ -41,8 +41,8 @@ class KotatsuApp : BaseApp() {
 				detectNetwork()
 				detectDiskWrites()
 				detectCustomSlowCalls()
+				detectResourceMismatches()
 				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) detectUnbufferedIo()
-				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) detectResourceMismatches()
 				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) detectExplicitGc()
 				penaltyLog()
 				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && notifier != null) {

app/src/debug/kotlin/org/koitharu/kotatsu/core/parser/TestMangaRepository.kt

@@ -0,0 +1,57 @@
+package org.koitharu.kotatsu.core.parser
+
+import org.koitharu.kotatsu.core.cache.MemoryContentCache
+import org.koitharu.kotatsu.core.model.TestMangaSource
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaListFilter
+import org.koitharu.kotatsu.parsers.model.MangaListFilterCapabilities
+import org.koitharu.kotatsu.parsers.model.MangaListFilterOptions
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import java.util.EnumSet
+
+/*
+ This class is for parser development and testing purposes
+ You can open it in the app via Settings -> Debug
+ */
+class TestMangaRepository(
+	@Suppress("unused") private val loaderContext: MangaLoaderContext,
+	cache: MemoryContentCache
+) : CachingMangaRepository(cache) {
+
+	override val source = TestMangaSource
+
+	override val sortOrders: Set<SortOrder> = EnumSet.allOf(SortOrder::class.java)
+
+	override var defaultSortOrder: SortOrder
+		get() = sortOrders.first()
+		set(value) = Unit
+
+	override val filterCapabilities = MangaListFilterCapabilities()
+
+	override suspend fun getFilterOptions() = MangaListFilterOptions()
+
+	override suspend fun getList(
+		offset: Int,
+		order: SortOrder?,
+		filter: MangaListFilter?
+	): List<Manga> = TODO("Get manga list by filter")
+
+	override suspend fun getDetailsImpl(
+		manga: Manga
+	): Manga = TODO("Fetch manga details")
+
+	override suspend fun getPagesImpl(
+		chapter: MangaChapter
+	): List<MangaPage> = TODO("Get pages for specific chapter")
+
+	override suspend fun getPageUrl(
+		page: MangaPage
+	): String = TODO("Return direct url of page image or page.url if it is already a direct url")
+
+	override suspend fun getRelatedMangaImpl(
+		seed: Manga
+	): List<Manga> = TODO("Get list of related manga. This method is optional and parser library has a default implementation")
+}

app/src/debug/kotlin/org/koitharu/kotatsu/settings/DebugSettingsFragment.kt

@@ -5,6 +5,8 @@ import androidx.preference.Preference
 import leakcanary.LeakCanary
 import org.koitharu.kotatsu.KotatsuApp
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.model.TestMangaSource
+import org.koitharu.kotatsu.core.nav.router
 import org.koitharu.kotatsu.core.ui.BasePreferenceFragment
 import org.koitharu.kotatsu.settings.utils.SplitSwitchPreference
 import org.koitharu.workinspector.WorkInspector
@@ -35,6 +37,11 @@ class DebugSettingsFragment : BasePreferenceFragment(R.string.debug), Preference
 			true
 		}
 
+		KEY_TEST_PARSER -> {
+			router.openList(TestMangaSource, null, null)
+			true
+		}
+
 		else -> super.onPreferenceTreeClick(preference)
 	}
 
@@ -60,5 +67,6 @@ class DebugSettingsFragment : BasePreferenceFragment(R.string.debug), Preference
 
 		const val KEY_LEAK_CANARY = "leak_canary"
 		const val KEY_WORK_INSPECTOR = "work_inspector"
+		const val KEY_TEST_PARSER = "test_parser"
 	}
 }

app/src/debug/res/xml/pref_debug.xml

@@ -1,17 +1,23 @@
 <?xml version="1.0" encoding="utf-8"?>
 <androidx.preference.PreferenceScreen
-	xmlns:android="http://schemas.android.com/apk/res/android">
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	xmlns:app="http://schemas.android.com/apk/res-auto">
 
 	<org.koitharu.kotatsu.settings.utils.SplitSwitchPreference
-		android:id="@+id/action_leakcanary"
 		android:key="leak_canary"
 		android:persistent="false"
 		android:title="LeakCanary" />
 
 	<Preference
-		android:id="@+id/action_works"
 		android:key="work_inspector"
 		android:persistent="false"
 		android:title="@string/wi_lib_name" />
 
+	<Preference
+		android:key="test_parser"
+		android:persistent="false"
+		android:title="@string/test_parser"
+		app:allowDividerAbove="true" />
+
+
 </androidx.preference.PreferenceScreen>

app/src/main/AndroidManifest.xml

@@ -51,9 +51,11 @@
 		android:backupAgent="org.koitharu.kotatsu.backups.domain.AppBackupAgent"
 		android:dataExtractionRules="@xml/backup_rules"
 		android:enableOnBackInvokedCallback="@bool/is_predictive_back_enabled"
+		android:extractNativeLibs="true"
 		android:fullBackupContent="@xml/backup_content"
 		android:fullBackupOnly="true"
 		android:hasFragileUserData="true"
+		android:restoreAnyVersion="true"
 		android:icon="@mipmap/ic_launcher"
 		android:label="@string/app_name"
 		android:largeHeap="true"

app/src/main/kotlin/org/koitharu/kotatsu/backups/data/BackupRepository.kt

@@ -26,12 +26,17 @@ import org.koitharu.kotatsu.backups.data.model.CategoryBackup
 import org.koitharu.kotatsu.backups.data.model.FavouriteBackup
 import org.koitharu.kotatsu.backups.data.model.HistoryBackup
 import org.koitharu.kotatsu.backups.data.model.MangaBackup
+import org.koitharu.kotatsu.backups.data.model.ScrobblingBackup
 import org.koitharu.kotatsu.backups.data.model.SourceBackup
+import org.koitharu.kotatsu.backups.data.model.StatisticBackup
 import org.koitharu.kotatsu.backups.domain.BackupSection
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.CompositeResult
 import org.koitharu.kotatsu.core.util.progress.Progress
+import org.koitharu.kotatsu.explore.data.MangaSourcesRepository
+import org.koitharu.kotatsu.filter.data.PersistableFilter
+import org.koitharu.kotatsu.filter.data.SavedFiltersRepository
 import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import org.koitharu.kotatsu.reader.data.TapGridSettings
 import java.io.InputStream
@@ -43,220 +48,267 @@ import javax.inject.Inject
 
 @Reusable
 class BackupRepository @Inject constructor(
-	private val database: MangaDatabase,
+    private val database: MangaDatabase,
-	private val settings: AppSettings,
+    private val settings: AppSettings,
-	private val tapGridSettings: TapGridSettings,
+    private val tapGridSettings: TapGridSettings,
+    private val mangaSourcesRepository: MangaSourcesRepository,
+    private val savedFiltersRepository: SavedFiltersRepository,
 ) {
 
-	private val json = Json {
+    private val json = Json {
-		allowSpecialFloatingPointValues = true
+        allowSpecialFloatingPointValues = true
-		coerceInputValues = true
+        coerceInputValues = true
-		encodeDefaults = true
+        encodeDefaults = true
-		ignoreUnknownKeys = true
+        ignoreUnknownKeys = true
-		useAlternativeNames = false
+        useAlternativeNames = false
-	}
+    }
-
+
-	suspend fun createBackup(
+    suspend fun createBackup(
-		output: ZipOutputStream,
+        output: ZipOutputStream,
-		progress: FlowCollector<Progress>?,
+        progress: FlowCollector<Progress>?,
-	) {
+    ) {
-		progress?.emit(Progress.INDETERMINATE)
+        progress?.emit(Progress.INDETERMINATE)
-		var commonProgress = Progress(0, BackupSection.entries.size)
+        var commonProgress = Progress(0, BackupSection.entries.size)
-		for (section in BackupSection.entries) {
+        for (section in BackupSection.entries) {
-			when (section) {
+            when (section) {
-				BackupSection.INDEX -> output.writeJsonArray(
+                BackupSection.INDEX -> output.writeJsonArray(
-					section = BackupSection.INDEX,
+                    section = BackupSection.INDEX,
-					data = flowOf(BackupIndex()),
+                    data = flowOf(BackupIndex()),
-					serializer = serializer(),
+                    serializer = serializer(),
-				)
+                )
-
+
-				BackupSection.HISTORY -> output.writeJsonArray(
+                BackupSection.HISTORY -> output.writeJsonArray(
-					section = BackupSection.HISTORY,
+                    section = BackupSection.HISTORY,
-					data = database.getHistoryDao().dump().map { HistoryBackup(it) },
+                    data = database.getHistoryDao().dump().map { HistoryBackup(it) },
-					serializer = serializer(),
+                    serializer = serializer(),
-				)
+                )
-
+
-				BackupSection.CATEGORIES -> output.writeJsonArray(
+                BackupSection.CATEGORIES -> output.writeJsonArray(
-					section = BackupSection.CATEGORIES,
+                    section = BackupSection.CATEGORIES,
-					data = database.getFavouriteCategoriesDao().findAll().asFlow().map { CategoryBackup(it) },
+                    data = database.getFavouriteCategoriesDao().findAll().asFlow().map { CategoryBackup(it) },
-					serializer = serializer(),
+                    serializer = serializer(),
-				)
+                )
-
+
-				BackupSection.FAVOURITES -> output.writeJsonArray(
+                BackupSection.FAVOURITES -> output.writeJsonArray(
-					section = BackupSection.FAVOURITES,
+                    section = BackupSection.FAVOURITES,
-					data = database.getFavouritesDao().dump().map { FavouriteBackup(it) },
+                    data = database.getFavouritesDao().dump().map { FavouriteBackup(it) },
-					serializer = serializer(),
+                    serializer = serializer(),
-				)
+                )
-
+
-				BackupSection.SETTINGS -> output.writeString(
+                BackupSection.SETTINGS -> output.writeString(
-					section = BackupSection.SETTINGS,
+                    section = BackupSection.SETTINGS,
-					data = dumpSettings(),
+                    data = dumpSettings(),
-				)
+                )
-
+
-				BackupSection.SETTINGS_READER_GRID -> output.writeString(
+                BackupSection.SETTINGS_READER_GRID -> output.writeString(
-					section = BackupSection.SETTINGS_READER_GRID,
+                    section = BackupSection.SETTINGS_READER_GRID,
-					data = dumpReaderGridSettings(),
+                    data = dumpReaderGridSettings(),
-				)
+                )
-
+
-				BackupSection.BOOKMARKS -> output.writeJsonArray(
+                BackupSection.BOOKMARKS -> output.writeJsonArray(
-					section = BackupSection.BOOKMARKS,
+                    section = BackupSection.BOOKMARKS,
-					data = database.getBookmarksDao().dump().map { BookmarkBackup(it.first, it.second) },
+                    data = database.getBookmarksDao().dump().map { BookmarkBackup(it.first, it.second) },
-					serializer = serializer(),
+                    serializer = serializer(),
-				)
+                )
-
+
-				BackupSection.SOURCES -> output.writeJsonArray(
+                BackupSection.SOURCES -> output.writeJsonArray(
-					section = BackupSection.SOURCES,
+                    section = BackupSection.SOURCES,
-					data = database.getSourcesDao().dumpEnabled().map { SourceBackup(it) },
+                    data = database.getSourcesDao().dumpEnabled().map { SourceBackup(it) },
-					serializer = serializer(),
+                    serializer = serializer(),
-				)
+                )
-			}
+
-			progress?.emit(commonProgress)
+                BackupSection.SCROBBLING -> output.writeJsonArray(
-			commonProgress++
+                    section = BackupSection.SCROBBLING,
-		}
+                    data = database.getScrobblingDao().dumpEnabled().map { ScrobblingBackup(it) },
-		progress?.emit(commonProgress)
+                    serializer = serializer(),
-	}
+                )
-
+
-	suspend fun restoreBackup(
+                BackupSection.STATS -> output.writeJsonArray(
-		input: ZipInputStream,
+                    section = BackupSection.STATS,
-		sections: Set<BackupSection>,
+                    data = database.getStatsDao().dumpEnabled().map { StatisticBackup(it) },
-		progress: FlowCollector<Progress>?,
+                    serializer = serializer(),
-	): CompositeResult {
+                )
-		progress?.emit(Progress.INDETERMINATE)
+
-		var commonProgress = Progress(0, sections.size)
+                BackupSection.SAVED_FILTERS -> {
-		var entry = input.nextEntry
+                    val sources = mangaSourcesRepository.getEnabledSources()
-		var result = CompositeResult.EMPTY
+                    val filters = sources.flatMap { source ->
-		while (entry != null) {
+                        savedFiltersRepository.getAll(source)
-			val section = BackupSection.of(entry)
+                    }
-			if (section in sections) {
+                    output.writeJsonArray(
-				result = result + when (section) {
+                        section = BackupSection.SAVED_FILTERS,
-					BackupSection.INDEX -> CompositeResult.EMPTY // useless in our case
+                        data = filters.asFlow(),
-					BackupSection.HISTORY -> input.readJsonArray<HistoryBackup>(serializer()).restoreToDb {
+                        serializer = serializer(),
-						upsertManga(it.manga)
+                    )
-						getHistoryDao().upsert(it.toEntity())
+                }
-					}
+            }
-
+            progress?.emit(commonProgress)
-					BackupSection.CATEGORIES -> input.readJsonArray<CategoryBackup>(serializer()).restoreToDb {
+            commonProgress++
-						getFavouriteCategoriesDao().upsert(it.toEntity())
+        }
-					}
+        progress?.emit(commonProgress)
-
+    }
-					BackupSection.FAVOURITES -> input.readJsonArray<FavouriteBackup>(serializer()).restoreToDb {
+
-						upsertManga(it.manga)
+    suspend fun restoreBackup(
-						getFavouritesDao().upsert(it.toEntity())
+        input: ZipInputStream,
-					}
+        sections: Set<BackupSection>,
-
+        progress: FlowCollector<Progress>?,
-					BackupSection.SETTINGS -> input.readMap().let {
+    ): CompositeResult {
-						settings.upsertAll(it)
+        progress?.emit(Progress.INDETERMINATE)
-						CompositeResult.success()
+        var commonProgress = Progress(0, sections.size)
-					}
+        var entry = input.nextEntry
-
+        var result = CompositeResult.EMPTY
-					BackupSection.SETTINGS_READER_GRID -> input.readMap().let {
+        while (entry != null) {
-						tapGridSettings.upsertAll(it)
+            val section = BackupSection.of(entry)
-						CompositeResult.success()
+            if (section in sections) {
-					}
+                result += when (section) {
-
+                    BackupSection.INDEX -> CompositeResult.EMPTY // useless in our case
-					BackupSection.BOOKMARKS -> input.readJsonArray<BookmarkBackup>(serializer()).restoreToDb {
+                    BackupSection.HISTORY -> input.readJsonArray<HistoryBackup>(serializer()).restoreToDb {
-						upsertManga(it.manga)
+                        upsertManga(it.manga)
-						getBookmarksDao().upsert(it.bookmarks.map { b -> b.toEntity() })
+                        getHistoryDao().upsert(it.toEntity())
-					}
+                    }
-
+
-					BackupSection.SOURCES -> input.readJsonArray<SourceBackup>(serializer()).restoreToDb {
+                    BackupSection.CATEGORIES -> input.readJsonArray<CategoryBackup>(serializer()).restoreToDb {
-						getSourcesDao().upsert(it.toEntity())
+                        getFavouriteCategoriesDao().upsert(it.toEntity())
-					}
+                    }
-
+
-					null -> CompositeResult.EMPTY // skip unknown entries
+                    BackupSection.FAVOURITES -> input.readJsonArray<FavouriteBackup>(serializer()).restoreToDb {
-				}
+                        upsertManga(it.manga)
-				progress?.emit(commonProgress)
+                        getFavouritesDao().upsert(it.toEntity())
-				commonProgress++
+                    }
-			}
+
-			input.closeEntry()
+                    BackupSection.SETTINGS -> input.readMap().let {
-			entry = input.nextEntry
+                        settings.upsertAll(it)
-		}
+                        CompositeResult.success()
-		progress?.emit(commonProgress)
+                    }
-		return result
+
-	}
+                    BackupSection.SETTINGS_READER_GRID -> input.readMap().let {
-
+                        tapGridSettings.upsertAll(it)
-	private suspend fun <T> ZipOutputStream.writeJsonArray(
+                        CompositeResult.success()
-		section: BackupSection,
+                    }
-		data: Flow<T>,
+
-		serializer: SerializationStrategy<T>,
+                    BackupSection.BOOKMARKS -> input.readJsonArray<BookmarkBackup>(serializer()).restoreToDb {
-	) {
+                        upsertManga(it.manga)
-		data.onStart {
+                        getBookmarksDao().upsert(it.bookmarks.map { b -> b.toEntity() })
-			putNextEntry(ZipEntry(section.entryName))
+                    }
-			write("[")
+
-		}.onCompletion { error ->
+                    BackupSection.SOURCES -> input.readJsonArray<SourceBackup>(serializer()).restoreToDb {
-			if (error == null) {
+                        getSourcesDao().upsert(it.toEntity())
-				write("]")
+                    }
-			}
+
-			closeEntry()
+                    BackupSection.SCROBBLING -> input.readJsonArray<ScrobblingBackup>(serializer()).restoreToDb {
-			flush()
+                        getScrobblingDao().upsert(it.toEntity())
-		}.collectIndexed { index, value ->
+                    }
-			if (index > 0) {
+
-				write(",")
+                    BackupSection.STATS -> input.readJsonArray<StatisticBackup>(serializer()).restoreToDb {
-			}
+                        getStatsDao().upsert(it.toEntity())
-			json.encodeToStream(serializer, value, this)
+                    }
-		}
+
-	}
+                    BackupSection.SAVED_FILTERS -> input.readJsonArray<PersistableFilter>(serializer())
-
+                        .restoreWithoutTransaction {
-	private fun <T> InputStream.readJsonArray(
+                            savedFiltersRepository.save(it)
-		serializer: DeserializationStrategy<T>,
+                        }
-	): Sequence<T> = json.decodeToSequence(this, serializer, DecodeSequenceMode.ARRAY_WRAPPED)
+
-
+                    null -> CompositeResult.EMPTY // skip unknown entries
-	private fun InputStream.readMap(): Map<String, Any?> {
+                }
-		val jo = JSONArray(readString()).getJSONObject(0)
+                progress?.emit(commonProgress)
-		val map = ArrayMap<String, Any?>(jo.length())
+                commonProgress++
-		val keys = jo.keys()
+            }
-		while (keys.hasNext()) {
+            input.closeEntry()
-			val key = keys.next()
+            entry = input.nextEntry
-			map[key] = jo.get(key)
+        }
-		}
+        progress?.emit(commonProgress)
-		return map
+        return result
-	}
+    }
-
+
-	private fun ZipOutputStream.writeString(
+    private suspend fun <T> ZipOutputStream.writeJsonArray(
-		section: BackupSection,
+        section: BackupSection,
-		data: String,
+        data: Flow<T>,
-	) {
+        serializer: SerializationStrategy<T>,
-		putNextEntry(ZipEntry(section.entryName))
+    ) {
-		try {
+        data.onStart {
-			write("[")
+            putNextEntry(ZipEntry(section.entryName))
-			write(data)
+            write("[")
-			write("]")
+        }.onCompletion { error ->
-		} finally {
+            if (error == null) {
-			closeEntry()
+                write("]")
-			flush()
+            }
-		}
+            closeEntry()
-	}
+            flush()
-
+        }.collectIndexed { index, value ->
-	private fun OutputStream.write(str: String) = write(str.toByteArray())
+            if (index > 0) {
-
+                write(",")
-	private fun InputStream.readString(): String = readBytes().decodeToString()
+            }
-
+            json.encodeToStream(serializer, value, this)
-	private fun dumpSettings(): String {
+        }
-		val map = settings.getAllValues().toMutableMap()
+    }
-		map.remove(AppSettings.KEY_APP_PASSWORD)
+
-		map.remove(AppSettings.KEY_PROXY_PASSWORD)
+    private fun <T> InputStream.readJsonArray(
-		map.remove(AppSettings.KEY_PROXY_LOGIN)
+        serializer: DeserializationStrategy<T>,
-		map.remove(AppSettings.KEY_INCOGNITO_MODE)
+    ): Sequence<T> = json.decodeToSequence(this, serializer, DecodeSequenceMode.ARRAY_WRAPPED)
-		return JSONObject(map).toString()
+
-	}
+    private fun InputStream.readMap(): Map<String, Any?> {
-
+        val jo = JSONArray(readString()).getJSONObject(0)
-	private fun dumpReaderGridSettings(): String {
+        val map = ArrayMap<String, Any?>(jo.length())
-		return JSONObject(tapGridSettings.getAllValues()).toString()
+        val keys = jo.keys()
-	}
+        while (keys.hasNext()) {
-
+            val key = keys.next()
-	private suspend fun MangaDatabase.upsertManga(manga: MangaBackup) {
+            map[key] = jo.get(key)
-		val tags = manga.tags.map { it.toEntity() }
+        }
-		getTagsDao().upsert(tags)
+        return map
-		getMangaDao().upsert(manga.toEntity(), tags)
+    }
-	}
+
-
+    private fun ZipOutputStream.writeString(
-	private suspend inline fun <T> Sequence<T>.restoreToDb(crossinline block: suspend MangaDatabase.(T) -> Unit): CompositeResult {
+        section: BackupSection,
-		return fold(CompositeResult.EMPTY) { result, item ->
+        data: String,
-			result + runCatchingCancellable {
+    ) {
-				database.withTransaction {
+        putNextEntry(ZipEntry(section.entryName))
-					database.block(item)
+        try {
-				}
+            write("[")
-			}
+            write(data)
-		}
+            write("]")
-	}
+        } finally {
+            closeEntry()
+            flush()
+        }
+    }
+
+    private fun OutputStream.write(str: String) = write(str.toByteArray())
+
+    private fun InputStream.readString(): String = readBytes().decodeToString()
+
+    private fun dumpSettings(): String {
+        val map = settings.getAllValues().toMutableMap()
+        map.remove(AppSettings.KEY_APP_PASSWORD)
+        map.remove(AppSettings.KEY_PROXY_PASSWORD)
+        map.remove(AppSettings.KEY_PROXY_LOGIN)
+        map.remove(AppSettings.KEY_INCOGNITO_MODE)
+        return JSONObject(map).toString()
+    }
+
+    private fun dumpReaderGridSettings(): String {
+        return JSONObject(tapGridSettings.getAllValues()).toString()
+    }
+
+    private suspend fun MangaDatabase.upsertManga(manga: MangaBackup) {
+        val tags = manga.tags.map { it.toEntity() }
+        getTagsDao().upsert(tags)
+        getMangaDao().upsert(manga.toEntity(), tags)
+    }
+
+    private suspend inline fun <T> Sequence<T>.restoreToDb(crossinline block: suspend MangaDatabase.(T) -> Unit): CompositeResult {
+        return fold(CompositeResult.EMPTY) { result, item ->
+            result + runCatchingCancellable {
+                database.withTransaction {
+                    database.block(item)
+                }
+            }
+        }
+    }
+
+    private suspend inline fun <T> Sequence<T>.restoreWithoutTransaction(crossinline block: suspend (T) -> Unit): CompositeResult {
+        return fold(CompositeResult.EMPTY) { result, item ->
+            result + runCatchingCancellable {
+                block(item)
+            }
+        }
+    }
 }

app/src/main/kotlin/org/koitharu/kotatsu/backups/data/model/ScrobblingBackup.kt

@@ -0,0 +1,40 @@
+package org.koitharu.kotatsu.backups.data.model
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import org.koitharu.kotatsu.scrobbling.common.data.ScrobblingEntity
+
+@Serializable
+class ScrobblingBackup(
+	@SerialName("scrobbler") val scrobbler: Int,
+	@SerialName("id") val id: Int,
+	@SerialName("manga_id") val mangaId: Long,
+	@SerialName("target_id") val targetId: Long,
+	@SerialName("status") val status: String?,
+	@SerialName("chapter") val chapter: Int,
+	@SerialName("comment") val comment: String?,
+	@SerialName("rating") val rating: Float,
+) {
+
+	constructor(entity: ScrobblingEntity) : this(
+		scrobbler = entity.scrobbler,
+		id = entity.id,
+		mangaId = entity.mangaId,
+		targetId = entity.targetId,
+		status = entity.status,
+		chapter = entity.chapter,
+		comment = entity.comment,
+		rating = entity.rating,
+	)
+
+	fun toEntity() = ScrobblingEntity(
+		scrobbler = scrobbler,
+		id = id,
+		mangaId = mangaId,
+		targetId = targetId,
+		status = status,
+		chapter = chapter,
+		comment = comment,
+		rating = rating,
+	)
+}

app/src/main/kotlin/org/koitharu/kotatsu/backups/data/model/StatisticBackup.kt

@@ -0,0 +1,28 @@
+package org.koitharu.kotatsu.backups.data.model
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import org.koitharu.kotatsu.stats.data.StatsEntity
+
+@Serializable
+class StatisticBackup(
+	@SerialName("manga_id") val mangaId: Long,
+	@SerialName("started_at") val startedAt: Long,
+	@SerialName("duration") val duration: Long,
+	@SerialName("pages") val pages: Int,
+) {
+
+	constructor(entity: StatsEntity) : this(
+		mangaId = entity.mangaId,
+		startedAt = entity.startedAt,
+		duration = entity.duration,
+		pages = entity.pages,
+	)
+
+	fun toEntity() = StatsEntity(
+		mangaId = mangaId,
+		startedAt = startedAt,
+		duration = duration,
+		pages = pages,
+	)
+}

app/src/main/kotlin/org/koitharu/kotatsu/backups/domain/AppBackupAgent.kt

@@ -12,6 +12,8 @@ import kotlinx.coroutines.runBlocking
 import org.koitharu.kotatsu.backups.data.BackupRepository
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.explore.data.MangaSourcesRepository
+import org.koitharu.kotatsu.filter.data.SavedFiltersRepository
 import org.koitharu.kotatsu.reader.data.TapGridSettings
 import java.io.File
 import java.io.FileDescriptor
@@ -36,15 +38,22 @@ class AppBackupAgent : BackupAgent() {
 
 	override fun onFullBackup(data: FullBackupDataOutput) {
 		super.onFullBackup(data)
-		val file =
+		val file = createBackupFile(
-			createBackupFile(
+			this,
-				this,
+			BackupRepository(
-				BackupRepository(
+				database = MangaDatabase(context = applicationContext),
-					MangaDatabase(context = applicationContext),
+				settings = AppSettings(applicationContext),
-					AppSettings(applicationContext),
+				tapGridSettings = TapGridSettings(applicationContext),
-					TapGridSettings(applicationContext),
+				mangaSourcesRepository = MangaSourcesRepository(
+					context = applicationContext,
+					db = MangaDatabase(context = applicationContext),
+					settings = AppSettings(applicationContext),
 				),
-			)
+				savedFiltersRepository = SavedFiltersRepository(
+					context = applicationContext,
+				),
+			),
+		)
 		try {
 			fullBackupFile(file, data)
 		} finally {
@@ -68,6 +77,14 @@ class AppBackupAgent : BackupAgent() {
 					database = MangaDatabase(applicationContext),
 					settings = AppSettings(applicationContext),
 					tapGridSettings = TapGridSettings(applicationContext),
+					mangaSourcesRepository = MangaSourcesRepository(
+						context = applicationContext,
+						db = MangaDatabase(context = applicationContext),
+						settings = AppSettings(applicationContext),
+					),
+					savedFiltersRepository = SavedFiltersRepository(
+						context = applicationContext,
+					),
 				),
 			)
 			destination.delete()
@@ -90,8 +107,12 @@ class AppBackupAgent : BackupAgent() {
 	@VisibleForTesting
 	fun restoreBackupFile(fd: FileDescriptor, size: Long, repository: BackupRepository) {
 		ZipInputStream(ByteStreams.limit(FileInputStream(fd), size)).use { input ->
+			val sections = EnumSet.allOf(BackupSection::class.java)
+			// managed externally
+			sections.remove(BackupSection.SETTINGS)
+			sections.remove(BackupSection.SETTINGS_READER_GRID)
 			runBlocking {
-				repository.restoreBackup(input, EnumSet.allOf(BackupSection::class.java), null)
+				repository.restoreBackup(input, sections, null)
 			}
 		}
 	}

app/src/main/kotlin/org/koitharu/kotatsu/backups/domain/BackupSection.kt

@@ -15,13 +15,16 @@ enum class BackupSection(
 	SETTINGS_READER_GRID("reader_grid"),
 	BOOKMARKS("bookmarks"),
 	SOURCES("sources"),
+	SCROBBLING("scrobbling"),
+	STATS("statistics"),
+	SAVED_FILTERS("saved_filters"),
 	;
 
 	companion object {
 
 		fun of(entry: ZipEntry): BackupSection? {
 			val name = entry.name.lowercase(Locale.ROOT)
-			return entries.first { x -> x.entryName == name }
+			return entries.find { x -> x.entryName == name }
 		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/backups/ui/periodical/TelegramBackupUploader.kt

@@ -36,7 +36,7 @@ class TelegramBackupUploader @Inject constructor(
 	suspend fun uploadBackup(file: File) {
 		val requestBody = file.asRequestBody("application/zip".toMediaTypeOrNull())
 		val multipartBody = MultipartBody.Builder()
-			.setType(MultipartBody.Companion.FORM)
+			.setType(MultipartBody.FORM)
 			.addFormDataPart("chat_id", requireChatId())
 			.addFormDataPart("document", file.name, requestBody)
 			.build()

app/src/main/kotlin/org/koitharu/kotatsu/backups/ui/restore/BackupSectionModel.kt

@@ -23,6 +23,9 @@ data class BackupSectionModel(
 			BackupSection.SETTINGS_READER_GRID -> R.string.reader_actions
 			BackupSection.BOOKMARKS -> R.string.bookmarks
 			BackupSection.SOURCES -> R.string.remote_sources
+			BackupSection.SCROBBLING -> R.string.tracking
+			BackupSection.STATS -> R.string.statistics
+			BackupSection.SAVED_FILTERS -> R.string.saved_filters
 		}
 
 	override fun areItemsTheSame(other: ListModel): Boolean {

app/src/main/kotlin/org/koitharu/kotatsu/core/BaseApp.kt

@@ -8,11 +8,11 @@ import androidx.appcompat.app.AppCompatDelegate
 import androidx.hilt.work.HiltWorkerFactory
 import androidx.room.InvalidationTracker
 import androidx.work.Configuration
-import androidx.work.WorkManager
 import dagger.hilt.android.HiltAndroidApp
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.launch
+import okhttp3.internal.platform.PlatformRegistry
 import org.acra.ACRA
 import org.acra.ReportField
 import org.acra.config.dialog
@@ -27,7 +27,6 @@ import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.os.AppValidator
 import org.koitharu.kotatsu.core.os.RomCompat
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.util.WorkServiceStopHelper
 import org.koitharu.kotatsu.core.util.ext.processLifecycleScope
 import org.koitharu.kotatsu.local.data.LocalStorageChanges
 import org.koitharu.kotatsu.local.data.index.LocalMangaIndex
@@ -62,9 +61,6 @@ open class BaseApp : Application(), Configuration.Provider {
 	@Inject
 	lateinit var workScheduleManager: WorkScheduleManager
 
-	@Inject
-	lateinit var workManagerProvider: Provider<WorkManager>
-
 	@Inject
 	lateinit var localMangaIndexProvider: Provider<LocalMangaIndex>
 
@@ -79,6 +75,7 @@ open class BaseApp : Application(), Configuration.Provider {
 
 	override fun onCreate() {
 		super.onCreate()
+		PlatformRegistry.applicationContext = this // TODO replace with OkHttp.initialize
 		if (ACRA.isACRASenderServiceProcess()) {
 			return
 		}
@@ -97,7 +94,6 @@ open class BaseApp : Application(), Configuration.Provider {
 			localStorageChanges.collect(localMangaIndexProvider.get())
 		}
 		workScheduleManager.init()
-		WorkServiceStopHelper(workManagerProvider).setup()
 	}
 
 	override fun attachBaseContext(base: Context) {

app/src/main/kotlin/org/koitharu/kotatsu/core/db/dao/MangaDao.kt

@@ -34,6 +34,9 @@ abstract class MangaDao {
 	@Query("SELECT author FROM manga WHERE author LIKE :query GROUP BY author ORDER BY COUNT(author) DESC LIMIT :limit")
 	abstract suspend fun findAuthors(query: String, limit: Int): List<String>
 
+    @Query("SELECT author FROM manga WHERE manga.source = :source AND author IS NOT NULL AND author != '' GROUP BY author ORDER BY COUNT(author) DESC LIMIT :limit")
+    abstract suspend fun findAuthorsBySource(source: String, limit: Int): List<String>
+
 	@Transaction
 	@Query("SELECT * FROM manga WHERE (title LIKE :query OR alt_title LIKE :query) AND manga_id IN (SELECT manga_id FROM favourites UNION SELECT manga_id FROM history) LIMIT :limit")
 	abstract suspend fun searchByTitle(query: String, limit: Int): List<MangaWithTags>

app/src/main/kotlin/org/koitharu/kotatsu/core/exceptions/EmptyMangaException.kt

@@ -0,0 +1,10 @@
+package org.koitharu.kotatsu.core.exceptions
+
+import org.koitharu.kotatsu.details.ui.pager.EmptyMangaReason
+import org.koitharu.kotatsu.parsers.model.Manga
+
+class EmptyMangaException(
+    val reason: EmptyMangaReason?,
+    val manga: Manga,
+    cause: Throwable?
+) : IllegalStateException(cause)

app/src/main/kotlin/org/koitharu/kotatsu/core/exceptions/resolve/CaptchaHandler.kt

@@ -7,6 +7,7 @@ import android.content.Context
 import android.content.Intent
 import android.os.Build
 import android.provider.Settings
+import androidx.annotation.CheckResult
 import androidx.annotation.RequiresPermission
 import androidx.collection.MutableScatterMap
 import androidx.core.app.NotificationChannelCompat
@@ -43,6 +44,7 @@ import org.koitharu.kotatsu.core.model.UnknownMangaSource
 import org.koitharu.kotatsu.core.model.getTitle
 import org.koitharu.kotatsu.core.model.isNsfw
 import org.koitharu.kotatsu.core.nav.AppRouter
+import org.koitharu.kotatsu.core.network.webview.WebViewExecutor
 import org.koitharu.kotatsu.core.parser.favicon.faviconUri
 import org.koitharu.kotatsu.core.prefs.SourceSettings
 import org.koitharu.kotatsu.core.util.ext.checkNotificationPermission
@@ -65,11 +67,13 @@ class CaptchaHandler @Inject constructor(
 	@LocalizedAppContext private val context: Context,
 	private val databaseProvider: Provider<MangaDatabase>,
 	private val coilProvider: Provider<ImageLoader>,
+	private val webViewExecutor: WebViewExecutor,
 ) : EventListener() {
 
 	private val exceptionMap = MutableScatterMap<MangaSource, CloudFlareProtectedException>()
 	private val mutex = Mutex()
 
+	@CheckResult
 	suspend fun handle(exception: CloudFlareException): Boolean = handleException(exception.source, exception, true)
 
 	suspend fun discard(source: MangaSource) {
@@ -79,10 +83,18 @@ class CaptchaHandler @Inject constructor(
 	override fun onError(request: ImageRequest, result: ErrorResult) {
 		super.onError(request, result)
 		val e = result.throwable
-		if (e is CloudFlareException && request.extras[ignoreCaptchaKey] != true) {
+		if (e is CloudFlareException) {
 			val scope = request.lifecycle?.coroutineScope ?: processLifecycleScope
 			scope.launch {
-				handleException(e.source, e, true)
+				if (
+					handleException(
+						source = e.source,
+						exception = e,
+						notify = request.extras[suppressCaptchaKey] != true,
+					)
+				) {
+					coilProvider.get().enqueue(request) // TODO check if ok
+				}
 			}
 		}
 	}
@@ -90,11 +102,14 @@ class CaptchaHandler @Inject constructor(
 	private suspend fun handleException(
 		source: MangaSource,
 		exception: CloudFlareException?,
-		notify: Boolean
+		notify: Boolean,
 	): Boolean = withContext(Dispatchers.Default) {
 		if (source == UnknownMangaSource) {
 			return@withContext false
 		}
+		if (exception != null && webViewExecutor.tryResolveCaptcha(exception, RESOLVE_TIMEOUT)) {
+			return@withContext true
+		}
 		mutex.withLock {
 			var removedException: CloudFlareProtectedException? = null
 			if (exception is CloudFlareProtectedException) {
@@ -119,7 +134,7 @@ class CaptchaHandler @Inject constructor(
 				notify(exceptions)
 			}
 		}
-		true
+		false
 	}
 
 	@RequiresPermission(Manifest.permission.POST_NOTIFICATIONS)
@@ -234,7 +249,7 @@ class CaptchaHandler @Inject constructor(
 				.data(source.faviconUri())
 				.allowHardware(false)
 				.allowConversionToBitmap(true)
-				.ignoreCaptchaErrors()
+				.suppressCaptchaErrors()
 				.mangaSourceExtra(source)
 				.size(context.resources.getNotificationIconSize())
 				.scale(Scale.FILL)
@@ -260,11 +275,11 @@ class CaptchaHandler @Inject constructor(
 
 	companion object {
 
-		fun ImageRequest.Builder.ignoreCaptchaErrors() = apply {
+		fun ImageRequest.Builder.suppressCaptchaErrors() = apply {
-			extras[ignoreCaptchaKey] = true
+			extras[suppressCaptchaKey] = true
 		}
 
-		val ignoreCaptchaKey = Extras.Key(false)
+		private val suppressCaptchaKey = Extras.Key(false)
 
 		private const val CHANNEL_ID = "captcha"
 		private const val TAG = CHANNEL_ID
@@ -272,5 +287,6 @@ class CaptchaHandler @Inject constructor(
 		private const val GROUP_NOTIFICATION_ID = 34
 		private const val SETTINGS_ACTION_CODE = 3
 		private const val ACTION_DISCARD = "org.koitharu.kotatsu.CAPTCHA_DISCARD"
+		private const val RESOLVE_TIMEOUT = 20_000L
 	}
 }

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

@@ -8,13 +8,15 @@ import androidx.collection.MutableScatterMap
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
 import androidx.fragment.app.FragmentManager
-import dagger.assisted.Assisted
+import androidx.lifecycle.Lifecycle
-import dagger.assisted.AssistedFactory
+import androidx.lifecycle.LifecycleOwner
-import dagger.assisted.AssistedInject
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.async
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.browser.BrowserActivity
 import org.koitharu.kotatsu.browser.cloudflare.CloudFlareActivity
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
+import org.koitharu.kotatsu.core.exceptions.EmptyMangaException
 import org.koitharu.kotatsu.core.exceptions.InteractiveActionRequiredException
 import org.koitharu.kotatsu.core.exceptions.ProxyConfigException
 import org.koitharu.kotatsu.core.exceptions.UnsupportedSourceException
@@ -24,6 +26,7 @@ import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.ui.dialog.buildAlertDialog
 import org.koitharu.kotatsu.core.util.ext.isHttpUrl
 import org.koitharu.kotatsu.core.util.ext.restartApplication
+import org.koitharu.kotatsu.details.ui.pager.EmptyMangaReason
 import org.koitharu.kotatsu.parsers.exception.AuthRequiredException
 import org.koitharu.kotatsu.parsers.exception.NotFoundException
 import org.koitharu.kotatsu.parsers.model.Manga
@@ -32,164 +35,221 @@ import org.koitharu.kotatsu.scrobbling.common.domain.ScrobblerAuthRequiredExcept
 import org.koitharu.kotatsu.scrobbling.common.ui.ScrobblerAuthHelper
 import org.koitharu.kotatsu.settings.sources.auth.SourceAuthActivity
 import java.security.cert.CertPathValidatorException
+import javax.inject.Inject
 import javax.inject.Provider
 import javax.net.ssl.SSLException
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 
-class ExceptionResolver @AssistedInject constructor(
+class ExceptionResolver private constructor(
-	@Assisted private val host: Host,
+    private val host: Host,
-	private val settings: AppSettings,
+    private val settings: AppSettings,
-	private val scrobblerAuthHelperProvider: Provider<ScrobblerAuthHelper>,
+    private val scrobblerAuthHelperProvider: Provider<ScrobblerAuthHelper>,
 ) {
-	private val continuations = MutableScatterMap<String, Continuation<Boolean>>(1)
+    private val continuations = MutableScatterMap<String, Continuation<Boolean>>(1)
-
+
-	private val browserActionContract = host.registerForActivityResult(BrowserActivity.Contract()) {
+    private val browserActionContract = host.registerForActivityResult(BrowserActivity.Contract()) {
-		handleActivityResult(BrowserActivity.TAG, true)
+        handleActivityResult(BrowserActivity.TAG, true)
-	}
+    }
-	private val sourceAuthContract = host.registerForActivityResult(SourceAuthActivity.Contract()) {
+    private val sourceAuthContract = host.registerForActivityResult(SourceAuthActivity.Contract()) {
-		handleActivityResult(SourceAuthActivity.TAG, it)
+        handleActivityResult(SourceAuthActivity.TAG, it)
-	}
+    }
-	private val cloudflareContract = host.registerForActivityResult(CloudFlareActivity.Contract()) {
+    private val cloudflareContract = host.registerForActivityResult(CloudFlareActivity.Contract()) {
-		handleActivityResult(CloudFlareActivity.TAG, it)
+        handleActivityResult(CloudFlareActivity.TAG, it)
-	}
+    }
-
+
-	fun showErrorDetails(e: Throwable, url: String? = null) {
+    fun showErrorDetails(e: Throwable, url: String? = null) {
-		host.router()?.showErrorDialog(e, url)
+        host.router.showErrorDialog(e, url)
-	}
+    }
-
+
-	suspend fun resolve(e: Throwable): Boolean = when (e) {
+    suspend fun resolve(e: Throwable): Boolean = host.lifecycleScope.async {
-		is CloudFlareProtectedException -> resolveCF(e)
+        when (e) {
-		is AuthRequiredException -> resolveAuthException(e.source)
+            is CloudFlareProtectedException -> resolveCF(e)
-		is SSLException,
+            is AuthRequiredException -> resolveAuthException(e.source)
-		is CertPathValidatorException -> {
+            is SSLException,
-			showSslErrorDialog()
+            is CertPathValidatorException -> {
-			false
+                showSslErrorDialog()
-		}
+                false
-
+            }
-		is InteractiveActionRequiredException -> resolveBrowserAction(e)
+
-
+            is InteractiveActionRequiredException -> resolveBrowserAction(e)
-		is ProxyConfigException -> {
+
-			host.router()?.openProxySettings()
+            is ProxyConfigException -> {
-			false
+                host.router.openProxySettings()
-		}
+                false
-
+            }
-		is NotFoundException -> {
+
-			openInBrowser(e.url)
+            is NotFoundException -> {
-			false
+                openInBrowser(e.url)
-		}
+                false
-
+            }
-		is UnsupportedSourceException -> {
+
-			e.manga?.let { openAlternatives(it) }
+            is EmptyMangaException -> {
-			false
+                when (e.reason) {
-		}
+                    EmptyMangaReason.NO_CHAPTERS -> openAlternatives(e.manga)
-
+                    EmptyMangaReason.LOADING_ERROR -> Unit
-		is ScrobblerAuthRequiredException -> {
+                    EmptyMangaReason.RESTRICTED -> host.router.openBrowser(e.manga)
-			val authHelper = scrobblerAuthHelperProvider.get()
+                    else -> Unit
-			if (authHelper.isAuthorized(e.scrobbler)) {
+                }
-				true
+                false
-			} else {
+            }
-				host.withContext {
+
-					authHelper.startAuth(this, e.scrobbler).onFailure(::showErrorDetails)
+            is UnsupportedSourceException -> {
-				}
+                e.manga?.let { openAlternatives(it) }
-				false
+                false
-			}
+            }
-		}
+
-
+            is ScrobblerAuthRequiredException -> {
-		else -> false
+                val authHelper = scrobblerAuthHelperProvider.get()
-	}
+                if (authHelper.isAuthorized(e.scrobbler)) {
-
+                    true
-	private suspend fun resolveBrowserAction(
+                } else {
-		e: InteractiveActionRequiredException
+                    host.withContext {
-	): Boolean = suspendCoroutine { cont ->
+                        authHelper.startAuth(this, e.scrobbler).onFailure(::showErrorDetails)
-		continuations[BrowserActivity.TAG] = cont
+                    }
-		browserActionContract.launch(e)
+                    false
-	}
+                }
-
+            }
-	private suspend fun resolveCF(e: CloudFlareProtectedException): Boolean = suspendCoroutine { cont ->
+
-		continuations[CloudFlareActivity.TAG] = cont
+            else -> false
-		cloudflareContract.launch(e)
+        }
-	}
+    }.await()
-
+
-	private suspend fun resolveAuthException(source: MangaSource): Boolean = suspendCoroutine { cont ->
+    private suspend fun resolveBrowserAction(
-		continuations[SourceAuthActivity.TAG] = cont
+        e: InteractiveActionRequiredException
-		sourceAuthContract.launch(source)
+    ): Boolean = suspendCoroutine { cont ->
-	}
+        continuations[BrowserActivity.TAG] = cont
-
+        browserActionContract.launch(e)
-	private fun openInBrowser(url: String) {
+    }
-		host.router()?.openBrowser(url, null, null)
+
-	}
+    private suspend fun resolveCF(e: CloudFlareProtectedException): Boolean = suspendCoroutine { cont ->
-
+        continuations[CloudFlareActivity.TAG] = cont
-	private fun openAlternatives(manga: Manga) {
+        cloudflareContract.launch(e)
-		host.router()?.openAlternatives(manga)
+    }
-	}
+
-
+    private suspend fun resolveAuthException(source: MangaSource): Boolean = suspendCoroutine { cont ->
-	private fun handleActivityResult(tag: String, result: Boolean) {
+        continuations[SourceAuthActivity.TAG] = cont
-		continuations.remove(tag)?.resume(result)
+        sourceAuthContract.launch(source)
-	}
+    }
-
+
-	private fun showSslErrorDialog() {
+    private fun openInBrowser(url: String) {
-		val ctx = host.getContext() ?: return
+        host.router.openBrowser(url, null, null)
-		if (settings.isSSLBypassEnabled) {
+    }
-			Toast.makeText(ctx, R.string.operation_not_supported, Toast.LENGTH_SHORT).show()
+
-			return
+    private fun openAlternatives(manga: Manga) {
-		}
+        host.router.openAlternatives(manga)
-		buildAlertDialog(ctx) {
+    }
-			setTitle(R.string.ignore_ssl_errors)
+
-			setMessage(R.string.ignore_ssl_errors_summary)
+    private fun handleActivityResult(tag: String, result: Boolean) {
-			setPositiveButton(R.string.apply) { _, _ ->
+        continuations.remove(tag)?.resume(result)
-				settings.isSSLBypassEnabled = true
+    }
-				Toast.makeText(ctx, R.string.settings_apply_restart_required, Toast.LENGTH_LONG).show()
+
-				ctx.restartApplication()
+    private fun showSslErrorDialog() {
-			}
+        val ctx = host.context ?: return
-			setNegativeButton(android.R.string.cancel, null)
+        if (settings.isSSLBypassEnabled) {
-		}.show()
+            Toast.makeText(ctx, R.string.operation_not_supported, Toast.LENGTH_SHORT).show()
-	}
+            return
-
+        }
-	private inline fun Host.withContext(block: Context.() -> Unit) {
+        buildAlertDialog(ctx) {
-		getContext()?.apply(block)
+            setTitle(R.string.ignore_ssl_errors)
-	}
+            setMessage(R.string.ignore_ssl_errors_summary)
-
+            setPositiveButton(R.string.apply) { _, _ ->
-	private fun Host.router(): AppRouter? = when (this) {
+                settings.isSSLBypassEnabled = true
-		is FragmentActivity -> router
+                Toast.makeText(ctx, R.string.settings_apply_restart_required, Toast.LENGTH_LONG).show()
-		is Fragment -> router
+                ctx.restartApplication()
-		else -> null
+            }
-	}
+            setNegativeButton(android.R.string.cancel, null)
-
+        }.show()
-	interface Host : ActivityResultCaller {
+    }
-
+
-		fun getChildFragmentManager(): FragmentManager
+    class Factory @Inject constructor(
-
+        private val settings: AppSettings,
-		fun getContext(): Context?
+        private val scrobblerAuthHelperProvider: Provider<ScrobblerAuthHelper>,
-	}
+    ) {
-
+
-	@AssistedFactory
+        fun create(fragment: Fragment) = ExceptionResolver(
-	interface Factory {
+            host = Host.FragmentHost(fragment),
-
+            settings = settings,
-		fun create(host: Host): ExceptionResolver
+            scrobblerAuthHelperProvider = scrobblerAuthHelperProvider,
-	}
+        )
-
+
-	companion object {
+        fun create(activity: FragmentActivity) = ExceptionResolver(
-
+            host = Host.ActivityHost(activity),
-		@StringRes
+            settings = settings,
-		fun getResolveStringId(e: Throwable) = when (e) {
+            scrobblerAuthHelperProvider = scrobblerAuthHelperProvider,
-			is CloudFlareProtectedException -> R.string.captcha_solve
+        )
-			is ScrobblerAuthRequiredException,
+    }
-			is AuthRequiredException -> R.string.sign_in
+
-
+    private sealed interface Host : ActivityResultCaller, LifecycleOwner {
-			is NotFoundException -> if (e.url.isHttpUrl()) R.string.open_in_browser else 0
+
-			is UnsupportedSourceException -> if (e.manga != null) R.string.alternatives else 0
+        val context: Context?
-			is SSLException,
+
-			is CertPathValidatorException -> R.string.fix
+        val router: AppRouter
-
+
-			is ProxyConfigException -> R.string.settings
+        val fragmentManager: FragmentManager
-
+
-			is InteractiveActionRequiredException -> R.string._continue
+        inline fun withContext(block: Context.() -> Unit) {
-
+            context?.apply(block)
-			else -> 0
+        }
-		}
+
-
+        class ActivityHost(val activity: FragmentActivity) : Host,
-		fun canResolve(e: Throwable) = getResolveStringId(e) != 0
+            ActivityResultCaller by activity,
-	}
+            LifecycleOwner by activity {
+
+            override val context: Context
+                get() = activity
+
+            override val router: AppRouter
+                get() = activity.router
+
+            override val fragmentManager: FragmentManager
+                get() = activity.supportFragmentManager
+        }
+
+        class FragmentHost(val fragment: Fragment) : Host,
+            ActivityResultCaller by fragment {
+
+            override val context: Context?
+                get() = fragment.context
+
+            override val router: AppRouter
+                get() = fragment.router
+
+            override val fragmentManager: FragmentManager
+                get() = fragment.childFragmentManager
+
+            override val lifecycle: Lifecycle
+                get() = fragment.viewLifecycleOwner.lifecycle
+        }
+    }
+
+    companion object {
+
+        @StringRes
+        fun getResolveStringId(e: Throwable) = when (e) {
+            is CloudFlareProtectedException -> R.string.captcha_solve
+            is ScrobblerAuthRequiredException,
+            is AuthRequiredException -> R.string.sign_in
+
+            is NotFoundException -> if (e.url.isHttpUrl()) R.string.open_in_browser else 0
+            is UnsupportedSourceException -> if (e.manga != null) R.string.alternatives else 0
+            is SSLException,
+            is CertPathValidatorException -> R.string.fix
+
+            is ProxyConfigException -> R.string.settings
+
+            is InteractiveActionRequiredException -> R.string._continue
+
+            is EmptyMangaException -> when (e.reason) {
+                EmptyMangaReason.RESTRICTED -> if (e.manga.publicUrl.isHttpUrl()) R.string.open_in_browser else 0
+                EmptyMangaReason.NO_CHAPTERS -> R.string.alternatives
+                else -> 0
+            }
+
+            else -> 0
+        }
+
+        fun canResolve(e: Throwable) = getResolveStringId(e) != 0
+    }
 }

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

@@ -28,11 +28,15 @@ data object UnknownMangaSource : MangaSource {
 	override val name = "UNKNOWN"
 }
 
+data object TestMangaSource : MangaSource {
+	override val name = "TEST"
+}
+
 fun MangaSource(name: String?): MangaSource {
 	when (name ?: return UnknownMangaSource) {
 		UnknownMangaSource.name -> return UnknownMangaSource
-
 		LocalMangaSource.name -> return LocalMangaSource
+		TestMangaSource.name -> return TestMangaSource
 	}
 	if (name.startsWith("content:")) {
 		val parts = name.substringAfter(':').splitTwoParts('/') ?: return UnknownMangaSource
@@ -92,6 +96,7 @@ fun MangaSource.getSummary(context: Context): String? = when (val source = unwra
 fun MangaSource.getTitle(context: Context): String = when (val source = unwrap()) {
 	is MangaParserSource -> source.title
 	LocalMangaSource -> context.getString(R.string.local_storage)
+	TestMangaSource -> context.getString(R.string.test_parser)
 	is ExternalMangaSource -> source.resolveName(context)
 	else -> context.getString(R.string.unknown)
 }

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

@@ -0,0 +1,20 @@
+package org.koitharu.kotatsu.core.model
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.descriptors.serialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+object MangaSourceSerializer : KSerializer<MangaSource> {
+
+    override val descriptor: SerialDescriptor = serialDescriptor<String>()
+
+    override fun serialize(
+        encoder: Encoder,
+        value: MangaSource
+    ) = encoder.encodeString(value.name)
+
+    override fun deserialize(decoder: Decoder): MangaSource = MangaSource(decoder.decodeString())
+}

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

@@ -5,7 +5,6 @@ import androidx.annotation.WorkerThread
 import androidx.core.util.Predicate
 import okhttp3.Cookie
 import okhttp3.HttpUrl
-import org.koitharu.kotatsu.parsers.util.newBuilder
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 

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

@@ -0,0 +1,30 @@
+package org.koitharu.kotatsu.core.network.webview
+
+import android.graphics.Bitmap
+import android.webkit.WebView
+import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
+import org.koitharu.kotatsu.parsers.network.CloudFlareHelper
+import kotlin.coroutines.Continuation
+
+class CaptchaContinuationClient(
+	private val cookieJar: MutableCookieJar,
+	private val targetUrl: String,
+	continuation: Continuation<Unit>,
+) : ContinuationResumeWebViewClient(continuation) {
+
+	private val oldClearance = CloudFlareHelper.getClearanceCookie(cookieJar, targetUrl)
+
+	override fun onPageFinished(view: WebView?, url: String?) = Unit
+
+	override fun onPageStarted(view: WebView?, url: String?, favicon: Bitmap?) {
+		super.onPageStarted(view, url, favicon)
+		checkClearance(view)
+	}
+
+	private fun checkClearance(view: WebView?) {
+		val clearance = CloudFlareHelper.getClearanceCookie(cookieJar, targetUrl)
+		if (clearance != null && clearance != oldClearance) {
+			resumeContinuation(view)
+		}
+	}
+}

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

@@ -2,15 +2,22 @@ package org.koitharu.kotatsu.core.network.webview
 
 import android.webkit.WebView
 import android.webkit.WebViewClient
+import kotlinx.coroutines.CancellableContinuation
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 
-class ContinuationResumeWebViewClient(
+open class ContinuationResumeWebViewClient(
 	private val continuation: Continuation<Unit>,
 ) : WebViewClient() {
 
 	override fun onPageFinished(view: WebView?, url: String?) {
-		view?.webViewClient = WebViewClient() // reset to default
+		resumeContinuation(view)
-		continuation.resume(Unit)
+	}
+
+	protected fun resumeContinuation(view: WebView?) {
+		if (continuation !is CancellableContinuation || continuation.isActive) {
+			view?.webViewClient = WebViewClient() // reset to default
+			continuation.resume(Unit)
+		}
 	}
 }

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

@@ -1,58 +1,134 @@
 package org.koitharu.kotatsu.core.network.webview
 
 import android.content.Context
+import android.util.AndroidRuntimeException
+import android.webkit.WebSettings
 import android.webkit.WebView
+import android.webkit.WebViewClient
 import androidx.annotation.MainThread
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+import org.koitharu.kotatsu.core.exceptions.CloudFlareException
+import org.koitharu.kotatsu.core.network.CommonHeaders
+import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
+import org.koitharu.kotatsu.core.network.proxy.ProxyProvider
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.core.parser.ParserMangaRepository
 import org.koitharu.kotatsu.core.util.ext.configureForParser
 import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
-import org.koitharu.kotatsu.core.util.ext.sanitizeHeaderValue
+import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.util.nullIfEmpty
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import java.lang.ref.WeakReference
 import javax.inject.Inject
+import javax.inject.Provider
 import javax.inject.Singleton
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 
 @Singleton
 class WebViewExecutor @Inject constructor(
-	@ApplicationContext private val context: Context
+	@ApplicationContext private val context: Context,
+	private val proxyProvider: ProxyProvider,
+	private val cookieJar: MutableCookieJar,
+	private val mangaRepositoryFactoryProvider: Provider<MangaRepository.Factory>,
 ) {
 
 	private var webViewCached: WeakReference<WebView>? = null
 	private val mutex = Mutex()
 
+	val defaultUserAgent: String? by lazy {
+		try {
+			WebSettings.getDefaultUserAgent(context)
+		} catch (e: AndroidRuntimeException) {
+			e.printStackTraceDebug()
+			// Probably WebView is not available
+			null
+		}
+	}
+
 	suspend fun evaluateJs(baseUrl: String?, script: String): String? = mutex.withLock {
 		withContext(Dispatchers.Main.immediate) {
 			val webView = obtainWebView()
-			if (!baseUrl.isNullOrEmpty()) {
+			try {
+				if (!baseUrl.isNullOrEmpty()) {
+					suspendCoroutine { cont ->
+						webView.webViewClient = ContinuationResumeWebViewClient(cont)
+						webView.loadDataWithBaseURL(baseUrl, " ", "text/html", null, null)
+					}
+				}
 				suspendCoroutine { cont ->
-					webView.webViewClient = ContinuationResumeWebViewClient(cont)
+					webView.evaluateJavascript(script) { result ->
-					webView.loadDataWithBaseURL(baseUrl, " ", "text/html", null, null)
+						cont.resume(result?.takeUnless { it == "null" })
+					}
 				}
+			} finally {
+				webView.reset()
 			}
-			suspendCoroutine { cont ->
+		}
-				webView.evaluateJavascript(script) { result ->
+	}
-					cont.resume(result?.takeUnless { it == "null" })
+
+	suspend fun tryResolveCaptcha(exception: CloudFlareException, timeout: Long): Boolean = mutex.withLock {
+		runCatchingCancellable {
+			withContext(Dispatchers.Main.immediate) {
+				val webView = obtainWebView()
+				try {
+					exception.source.getUserAgent()?.let {
+						webView.settings.userAgentString = it
+					}
+					withTimeout(timeout) {
+						suspendCancellableCoroutine { cont ->
+							webView.webViewClient = CaptchaContinuationClient(
+								cookieJar = cookieJar,
+								targetUrl = exception.url,
+								continuation = cont,
+							)
+							webView.loadUrl(exception.url)
+						}
+					}
+				} finally {
+					webView.reset()
 				}
 			}
+		}.onFailure { e ->
+			exception.addSuppressed(e)
+			e.printStackTraceDebug()
+		}.isSuccess
+	}
+
+	private suspend fun obtainWebView(): WebView {
+		webViewCached?.get()?.let {
+			return it
+		}
+		return withContext(Dispatchers.Main.immediate) {
+			webViewCached?.get()?.let {
+				return@withContext it
+			}
+			WebView(context).also {
+				it.configureForParser(null)
+				webViewCached = WeakReference(it)
+				proxyProvider.applyWebViewConfig()
+				it.onResume()
+				it.resumeTimers()
+			}
 		}
 	}
 
-	@MainThread
+	private fun MangaSource.getUserAgent(): String? {
-	fun getDefaultUserAgent() = runCatching {
+		val repository = mangaRepositoryFactoryProvider.get().create(this) as? ParserMangaRepository
-		obtainWebView().settings.userAgentString.sanitizeHeaderValue().trim().nullIfEmpty()
+		return repository?.getRequestHeaders()?.get(CommonHeaders.USER_AGENT)
-	}.onFailure { e ->
+	}
-		e.printStackTraceDebug()
-	}.getOrNull()
 
 	@MainThread
-	private fun obtainWebView(): WebView = webViewCached?.get() ?: WebView(context).also {
+	private fun WebView.reset() {
-		it.configureForParser(null)
+		stopLoading()
-		webViewCached = WeakReference(it)
+		webViewClient = WebViewClient()
+		settings.userAgentString = defaultUserAgent
+		loadDataWithBaseURL(null, " ", "text/html", null, null)
+		clearHistory()
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/os/NetworkState.kt

@@ -80,12 +80,7 @@ class NetworkState(
 			if (settings.isOfflineCheckDisabled) {
 				return true
 			}
-			return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+			return activeNetwork?.let { isOnline(it) } == true
-				activeNetwork?.let { isOnline(it) } == true
-			} else {
-				@Suppress("DEPRECATION")
-				activeNetworkInfo?.isConnected == true
-			}
 		}
 
 		private fun ConnectivityManager.isOnline(network: Network): Boolean {

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

@@ -1,46 +0,0 @@
-package org.koitharu.kotatsu.core.parser
-
-import org.koitharu.kotatsu.core.exceptions.UnsupportedSourceException
-import org.koitharu.kotatsu.parsers.MangaLoaderContext
-import org.koitharu.kotatsu.parsers.config.ConfigKey
-import org.koitharu.kotatsu.parsers.core.AbstractMangaParser
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.model.MangaChapter
-import org.koitharu.kotatsu.parsers.model.MangaListFilter
-import org.koitharu.kotatsu.parsers.model.MangaListFilterCapabilities
-import org.koitharu.kotatsu.parsers.model.MangaListFilterOptions
-import org.koitharu.kotatsu.parsers.model.MangaPage
-import org.koitharu.kotatsu.parsers.model.MangaParserSource
-import org.koitharu.kotatsu.parsers.model.SortOrder
-import java.util.EnumSet
-
-/**
- * This parser is just for parser development, it should not be used in releases
- */
-class DummyParser(context: MangaLoaderContext) : AbstractMangaParser(context, MangaParserSource.DUMMY) {
-
-	override val configKeyDomain: ConfigKey.Domain
-		get() = ConfigKey.Domain("localhost")
-
-	override val availableSortOrders: Set<SortOrder>
-		get() = EnumSet.allOf(SortOrder::class.java)
-
-	override val filterCapabilities: MangaListFilterCapabilities
-		get() = MangaListFilterCapabilities()
-
-	override suspend fun getDetails(manga: Manga): Manga = stub(manga)
-
-	override suspend fun getFilterOptions(): MangaListFilterOptions = stub(null)
-
-	override suspend fun getList(
-		offset: Int,
-		order: SortOrder,
-		filter: MangaListFilter
-	): List<Manga> = stub(null)
-
-	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> = stub(null)
-
-	private fun stub(manga: Manga?): Nothing {
-		throw UnsupportedSourceException("Usage of Dummy parser", manga)
-	}
-}

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

@@ -11,7 +11,7 @@ import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import java.util.EnumSet
 
-class EmptyMangaRepository(override val source: MangaSource) : MangaRepository {
+open class EmptyMangaRepository(override val source: MangaSource) : MangaRepository {
 
 	override val sortOrders: Set<SortOrder>
 		get() = EnumSet.allOf(SortOrder::class.java)

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

@@ -9,6 +9,8 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.db.TABLE_FAVOURITES
+import org.koitharu.kotatsu.core.db.TABLE_FAVOURITE_CATEGORIES
 import org.koitharu.kotatsu.core.db.TABLE_PREFERENCES
 import org.koitharu.kotatsu.core.db.entity.ContentRating
 import org.koitharu.kotatsu.core.db.entity.MangaPrefsEntity
@@ -189,6 +191,11 @@ class MangaDataRepository @Inject constructor(
 		emitInitialState = emitInitialState,
 	)
 
+	fun observeFavoritesTrigger(emitInitialState: Boolean) = db.invalidationTracker.createFlow(
+		tables = arrayOf(TABLE_FAVOURITES, TABLE_FAVOURITE_CATEGORIES),
+		emitInitialState = emitInitialState,
+	)
+
 	private suspend fun Manga.withCachedChaptersIfNeeded(flag: Boolean): Manga = if (flag && !isLocal && chapters.isNullOrEmpty()) {
 		val cachedChapters = db.getChaptersDao().findAll(id)
 		if (cachedChapters.isEmpty()) {

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

@@ -5,8 +5,6 @@ import android.content.Context
 import android.util.Base64
 import androidx.core.os.LocaleListCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withTimeout
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
@@ -33,7 +31,6 @@ import java.util.Locale
 import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 import javax.inject.Singleton
-import kotlin.coroutines.EmptyCoroutineContext
 
 @Singleton
 class MangaLoaderContextImpl @Inject constructor(
@@ -43,7 +40,6 @@ class MangaLoaderContextImpl @Inject constructor(
 	private val webViewExecutor: WebViewExecutor,
 ) : MangaLoaderContext() {
 
-	private val webViewUserAgent by lazy { obtainWebViewUserAgent() }
 	private val jsTimeout = TimeUnit.SECONDS.toMillis(4)
 
 	@Deprecated("Provide a base url")
@@ -54,7 +50,7 @@ class MangaLoaderContextImpl @Inject constructor(
 		webViewExecutor.evaluateJs(baseUrl, script)
 	}
 
-	override fun getDefaultUserAgent(): String = webViewUserAgent
+	override fun getDefaultUserAgent(): String = webViewExecutor.defaultUserAgent ?: UserAgents.FIREFOX_MOBILE
 
 	override fun getConfig(source: MangaSource): MangaSourceConfig {
 		return SourceSettings(androidContext, source)
@@ -91,15 +87,4 @@ class MangaLoaderContextImpl @Inject constructor(
 	}
 
 	override fun createBitmap(width: Int, height: Int): Bitmap = BitmapWrapper.create(width, height)
-
-	private fun obtainWebViewUserAgent(): String {
-		val mainDispatcher = Dispatchers.Main.immediate
-		return if (!mainDispatcher.isDispatchNeeded(EmptyCoroutineContext)) {
-			webViewExecutor.getDefaultUserAgent()
-		} else {
-			runBlocking(mainDispatcher) {
-				webViewExecutor.getDefaultUserAgent()
-			}
-		} ?: UserAgents.FIREFOX_MOBILE
-	}
 }

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

@@ -1,12 +0,0 @@
-package org.koitharu.kotatsu.core.parser
-
-import org.koitharu.kotatsu.parsers.MangaLoaderContext
-import org.koitharu.kotatsu.parsers.MangaParser
-import org.koitharu.kotatsu.parsers.model.MangaParserSource
-
-fun MangaParser(source: MangaParserSource, loaderContext: MangaLoaderContext): MangaParser {
-	return when (source) {
-		MangaParserSource.DUMMY -> DummyParser(loaderContext)
-		else -> loaderContext.newParserInstance(source)
-	}
-}

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

@@ -7,6 +7,7 @@ import dagger.hilt.android.qualifiers.ApplicationContext
 import org.koitharu.kotatsu.core.cache.MemoryContentCache
 import org.koitharu.kotatsu.core.model.LocalMangaSource
 import org.koitharu.kotatsu.core.model.MangaSourceInfo
+import org.koitharu.kotatsu.core.model.TestMangaSource
 import org.koitharu.kotatsu.core.model.UnknownMangaSource
 import org.koitharu.kotatsu.core.parser.external.ExternalMangaRepository
 import org.koitharu.kotatsu.core.parser.external.ExternalMangaSource
@@ -85,11 +86,16 @@ interface MangaRepository {
 
 		private fun createRepository(source: MangaSource): MangaRepository? = when (source) {
 			is MangaParserSource -> ParserMangaRepository(
-				parser = MangaParser(source, loaderContext),
+				parser = loaderContext.newParserInstance(source),
 				cache = contentCache,
 				mirrorSwitcher = mirrorSwitcher,
 			)
 
+			TestMangaSource -> TestMangaRepository(
+				loaderContext = loaderContext,
+				cache = contentCache,
+			)
+
 			is ExternalMangaSource -> if (source.isAvailable(context)) {
 				ExternalMangaRepository(
 					contentResolver = context.contentResolver,

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

@@ -19,6 +19,7 @@ import coil3.request.Options
 import coil3.size.pxOrElse
 import coil3.toAndroidUri
 import coil3.toBitmap
+import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.runInterruptible
 import okio.FileSystem
@@ -41,7 +42,6 @@ import org.koitharu.kotatsu.local.data.LocalStorageCache
 import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import java.io.File
 import javax.inject.Inject
-import kotlin.coroutines.coroutineContext
 import coil3.Uri as CoilUri
 
 class FaviconFetcher(
@@ -88,7 +88,7 @@ class FaviconFetcher(
 		var favicons = repository.getFavicons()
 		var lastError: Exception? = null
 		while (favicons.isNotEmpty()) {
-			coroutineContext.ensureActive()
+			currentCoroutineContext().ensureActive()
 			val icon = favicons.find(sizePx) ?: throwNSEE(lastError)
 			try {
 				val result = imageLoader.fetch(icon.url, options)

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

@@ -138,6 +138,15 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getBoolean(KEY_READER_DOUBLE_PAGES, false)
 		set(value) = prefs.edit { putBoolean(KEY_READER_DOUBLE_PAGES, value) }
 
+	var isReaderDoubleOnFoldable: Boolean
+		get() = prefs.getBoolean(KEY_READER_DOUBLE_FOLDABLE, false)
+		set(value) = prefs.edit { putBoolean(KEY_READER_DOUBLE_FOLDABLE, value) }
+
+	@get:FloatRange(0.0, 1.0)
+	var readerDoublePagesSensitivity: Float
+		get() = prefs.getFloat(KEY_READER_DOUBLE_PAGES_SENSITIVITY, 0.5f)
+		set(@FloatRange(0.0, 1.0) value) = prefs.edit { putFloat(KEY_READER_DOUBLE_PAGES_SENSITIVITY, value) }
+
 	val readerScreenOrientation: Int
 		get() = prefs.getString(KEY_READER_ORIENTATION, null)?.toIntOrNull()
 			?: ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
@@ -404,6 +413,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isReaderBarTransparent: Boolean
 		get() = prefs.getBoolean(KEY_READER_BAR_TRANSPARENT, true)
 
+	val isReaderChapterToastEnabled: Boolean
+		get() = prefs.getBoolean(KEY_READER_CHAPTER_TOAST, true)
+
 	val isReaderKeepScreenOn: Boolean
 		get() = prefs.getBoolean(KEY_READER_SCREEN_ON, true)
 
@@ -488,6 +500,10 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getBoolean(KEY_WEBTOON_GAPS, false)
 		set(value) = prefs.edit { putBoolean(KEY_WEBTOON_GAPS, value) }
 
+	var isWebtoonPullGestureEnabled: Boolean
+		get() = prefs.getBoolean(KEY_WEBTOON_PULL_GESTURE, false)
+		set(value) = prefs.edit { putBoolean(KEY_WEBTOON_PULL_GESTURE, value) }
+
 	@get:FloatRange(from = 0.0, to = 0.5)
 	val defaultWebtoonZoomOut: Float
 		get() = prefs.getInt(KEY_WEBTOON_ZOOM_OUT, 0).coerceIn(0, 50) / 100f
@@ -534,11 +550,11 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isPeriodicalBackupEnabled: Boolean
 		get() = prefs.getBoolean(KEY_BACKUP_PERIODICAL_ENABLED, false)
 
-	val periodicalBackupFrequency: Long
+	val periodicalBackupFrequency: Float
-		get() = prefs.getString(KEY_BACKUP_PERIODICAL_FREQUENCY, null)?.toLongOrNull() ?: 7L
+		get() = prefs.getString(KEY_BACKUP_PERIODICAL_FREQUENCY, null)?.toFloatOrNull() ?: 7f
 
 	val periodicalBackupFrequencyMillis: Long
-		get() = TimeUnit.DAYS.toMillis(periodicalBackupFrequency)
+		get() = (TimeUnit.DAYS.toMillis(1) * periodicalBackupFrequency).toLong()
 
 	val periodicalBackupMaxCount: Int
 		get() = if (prefs.getBoolean(KEY_BACKUP_PERIODICAL_TRIM, true)) {
@@ -669,6 +685,8 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_REMOTE_SOURCES = "remote_sources"
 		const val KEY_LOCAL_STORAGE = "local_storage"
 		const val KEY_READER_DOUBLE_PAGES = "reader_double_pages"
+		const val KEY_READER_DOUBLE_PAGES_SENSITIVITY = "reader_double_pages_sensitivity_2"
+		const val KEY_READER_DOUBLE_FOLDABLE = "reader_double_foldable"
 		const val KEY_READER_ZOOM_BUTTONS = "reader_zoom_buttons"
 		const val KEY_READER_CONTROL_LTR = "reader_taps_ltr"
 		const val KEY_READER_NAVIGATION_INVERTED = "reader_navigation_inverted"
@@ -737,6 +755,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_SYNC_SETTINGS = "sync_settings"
 		const val KEY_READER_BAR = "reader_bar"
 		const val KEY_READER_BAR_TRANSPARENT = "reader_bar_transparent"
+		const val KEY_READER_CHAPTER_TOAST = "reader_chapter_toast"
 		const val KEY_READER_BACKGROUND = "reader_background"
 		const val KEY_READER_SCREEN_ON = "reader_screen_on"
 		const val KEY_SHORTCUTS = "dynamic_shortcuts"
@@ -748,6 +767,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_WEBTOON_GAPS = "webtoon_gaps"
 		const val KEY_WEBTOON_ZOOM = "webtoon_zoom"
 		const val KEY_WEBTOON_ZOOM_OUT = "webtoon_zoom_out"
+		const val KEY_WEBTOON_PULL_GESTURE = "webtoon_pull_gesture"
 		const val KEY_PREFETCH_CONTENT = "prefetch_content"
 		const val KEY_APP_LOCALE = "app_locale"
 		const val KEY_SOURCES_GRID = "sources_grid"

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

@@ -13,10 +13,14 @@ import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.util.ifNullOrEmpty
 import org.koitharu.kotatsu.parsers.util.nullIfEmpty
 import org.koitharu.kotatsu.settings.utils.validation.DomainValidator
+import java.io.File
 
 class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig {
 
-	private val prefs = context.getSharedPreferences(source.name, Context.MODE_PRIVATE)
+    private val prefs = context.getSharedPreferences(
+        source.name.replace(File.separatorChar, '$'),
+        Context.MODE_PRIVATE,
+    )
 
 	var defaultSortOrder: SortOrder?
 		get() = prefs.getEnumValue(KEY_SORT_ORDER, SortOrder::class.java)

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

@@ -33,7 +33,6 @@ import androidx.appcompat.R as appcompatR
 
 abstract class BaseActivity<B : ViewBinding> :
 	AppCompatActivity(),
-	ExceptionResolver.Host,
 	OnApplyWindowInsetsListener,
 	ScreenshotPolicyHelper.ContentContainer {
 
@@ -87,10 +86,6 @@ abstract class BaseActivity<B : ViewBinding> :
 	@Deprecated("Use ViewBinding", level = DeprecationLevel.ERROR)
 	override fun setContentView(view: View?) = throw UnsupportedOperationException()
 
-	override fun getContext() = this
-
-	override fun getChildFragmentManager(): FragmentManager = supportFragmentManager
-
 	protected fun setContentView(binding: B) {
 		this.viewBinding = binding
 		super.setContentView(binding.root)

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

@@ -15,8 +15,7 @@ import org.koitharu.kotatsu.core.ui.util.ActionModeDelegate
 
 abstract class BaseFragment<B : ViewBinding> :
 	OnApplyWindowInsetsListener,
-	Fragment(),
+	Fragment() {
-	ExceptionResolver.Host {
 
 	var viewBinding: B? = null
 		private set

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

@@ -36,8 +36,7 @@ import com.google.android.material.R as materialR
 abstract class BasePreferenceFragment(@StringRes private val titleId: Int) :
 	PreferenceFragmentCompat(),
 	OnApplyWindowInsetsListener,
-	RecyclerViewOwner,
+	RecyclerViewOwner {
-	ExceptionResolver.Host {
 
 	protected lateinit var exceptionResolver: ExceptionResolver
 		private set

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

@@ -1,8 +0,0 @@
-package org.koitharu.kotatsu.core.ui
-
-import android.view.View
-
-fun interface OnContextClickListenerCompat {
-
-	fun onContextClick(v: View): Boolean
-}

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

@@ -2,10 +2,17 @@ package org.koitharu.kotatsu.core.ui.dialog
 
 import android.content.Context
 import android.view.LayoutInflater
+import android.view.ViewGroup.LayoutParams.MATCH_PARENT
+import android.view.ViewGroup.LayoutParams.WRAP_CONTENT
+import android.view.inputmethod.EditorInfo
+import android.widget.ArrayAdapter
 import android.widget.CompoundButton.OnCheckedChangeListener
+import android.widget.EditText
+import android.widget.FrameLayout
 import androidx.annotation.StringRes
 import androidx.annotation.UiContext
 import androidx.appcompat.app.AlertDialog
+import androidx.appcompat.widget.AppCompatEditText
 import androidx.core.view.updatePadding
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
@@ -15,54 +22,103 @@ import com.hannesdorfmann.adapterdelegates4.AdapterDelegatesManager
 import com.hannesdorfmann.adapterdelegates4.ListDelegationAdapter
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.databinding.DialogCheckboxBinding
+import org.koitharu.kotatsu.databinding.ViewDialogAutocompleteBinding
 import com.google.android.material.R as materialR
 
 inline fun buildAlertDialog(
-	@UiContext context: Context,
+    @UiContext context: Context,
-	isCentered: Boolean = false,
+    isCentered: Boolean = false,
-	block: MaterialAlertDialogBuilder.() -> Unit,
+    block: MaterialAlertDialogBuilder.() -> Unit,
 ): AlertDialog = MaterialAlertDialogBuilder(
-	context,
+    context,
-	if (isCentered) materialR.style.ThemeOverlay_Material3_MaterialAlertDialog_Centered else 0,
+    if (isCentered) materialR.style.ThemeOverlay_Material3_MaterialAlertDialog_Centered else 0,
 ).apply(block).create()
 
 fun <B : AlertDialog.Builder> B.setCheckbox(
-	@StringRes textResId: Int,
+    @StringRes textResId: Int,
-	isChecked: Boolean,
+    isChecked: Boolean,
-	onCheckedChangeListener: OnCheckedChangeListener
+    onCheckedChangeListener: OnCheckedChangeListener
 ) = apply {
-	val binding = DialogCheckboxBinding.inflate(LayoutInflater.from(context))
+    val binding = DialogCheckboxBinding.inflate(LayoutInflater.from(context))
-	binding.checkbox.setText(textResId)
+    binding.checkbox.setText(textResId)
-	binding.checkbox.isChecked = isChecked
+    binding.checkbox.isChecked = isChecked
-	binding.checkbox.setOnCheckedChangeListener(onCheckedChangeListener)
+    binding.checkbox.setOnCheckedChangeListener(onCheckedChangeListener)
-	setView(binding.root)
+    setView(binding.root)
 }
 
 fun <B : AlertDialog.Builder, T> B.setRecyclerViewList(
-	list: List<T>,
+    list: List<T>,
-	delegate: AdapterDelegate<List<T>>,
+    delegate: AdapterDelegate<List<T>>,
 ) = apply {
-	val delegatesManager = AdapterDelegatesManager<List<T>>()
+    val delegatesManager = AdapterDelegatesManager<List<T>>()
-	delegatesManager.addDelegate(delegate)
+    delegatesManager.addDelegate(delegate)
-	setRecyclerViewList(ListDelegationAdapter(delegatesManager).also { it.items = list })
+    setRecyclerViewList(ListDelegationAdapter(delegatesManager).also { it.items = list })
 }
 
 fun <B : AlertDialog.Builder, T> B.setRecyclerViewList(
-	list: List<T>,
+    list: List<T>,
-	vararg delegates: AdapterDelegate<List<T>>,
+    vararg delegates: AdapterDelegate<List<T>>,
 ) = apply {
-	val delegatesManager = AdapterDelegatesManager<List<T>>()
+    val delegatesManager = AdapterDelegatesManager<List<T>>()
-	delegates.forEach { delegatesManager.addDelegate(it) }
+    delegates.forEach { delegatesManager.addDelegate(it) }
-	setRecyclerViewList(ListDelegationAdapter(delegatesManager).also { it.items = list })
+    setRecyclerViewList(ListDelegationAdapter(delegatesManager).also { it.items = list })
 }
 
 fun <B : AlertDialog.Builder> B.setRecyclerViewList(adapter: RecyclerView.Adapter<*>) = apply {
-	val recyclerView = RecyclerView(context)
+    val recyclerView = RecyclerView(context)
-	recyclerView.layoutManager = LinearLayoutManager(context)
+    recyclerView.layoutManager = LinearLayoutManager(context)
-	recyclerView.updatePadding(
+    recyclerView.updatePadding(
-		top = context.resources.getDimensionPixelOffset(R.dimen.list_spacing),
+        top = context.resources.getDimensionPixelOffset(R.dimen.list_spacing),
-	)
+    )
-	recyclerView.clipToPadding = false
+    recyclerView.clipToPadding = false
-	recyclerView.adapter = adapter
+    recyclerView.adapter = adapter
-	setView(recyclerView)
+    setView(recyclerView)
+}
+
+fun <B : AlertDialog.Builder> B.setEditText(
+    inputType: Int,
+    singleLine: Boolean,
+): EditText {
+    val editText = AppCompatEditText(context)
+    editText.inputType = inputType
+    if (singleLine) {
+        editText.setSingleLine()
+        editText.imeOptions = EditorInfo.IME_ACTION_DONE
+    }
+    val layout = FrameLayout(context)
+    val lp = FrameLayout.LayoutParams(MATCH_PARENT, WRAP_CONTENT)
+    val horizontalMargin = context.resources.getDimensionPixelOffset(R.dimen.screen_padding)
+    lp.setMargins(
+        horizontalMargin,
+        context.resources.getDimensionPixelOffset(R.dimen.margin_small),
+        horizontalMargin,
+        0,
+    )
+    layout.addView(editText, lp)
+    setView(layout)
+    return editText
+}
+
+fun <B : AlertDialog.Builder> B.setEditText(
+    entries: List<CharSequence>,
+    inputType: Int,
+    singleLine: Boolean,
+): EditText {
+    if (entries.isEmpty()) {
+        return setEditText(inputType, singleLine)
+    }
+    val binding = ViewDialogAutocompleteBinding.inflate(LayoutInflater.from(context))
+    binding.autoCompleteTextView.setAdapter(
+        ArrayAdapter(context, android.R.layout.simple_spinner_dropdown_item, entries),
+    )
+    binding.dropdown.setOnClickListener {
+        binding.autoCompleteTextView.showDropDown()
+    }
+    binding.autoCompleteTextView.inputType = inputType
+    if (singleLine) {
+        binding.autoCompleteTextView.setSingleLine()
+        binding.autoCompleteTextView.imeOptions = EditorInfo.IME_ACTION_DONE
+    }
+    setView(binding.root)
+    return binding.autoCompleteTextView
 }

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

@@ -10,7 +10,7 @@ import coil3.asImage
 import coil3.request.Disposable
 import coil3.request.ImageRequest
 import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.exceptions.resolve.CaptchaHandler.Companion.ignoreCaptchaErrors
+import org.koitharu.kotatsu.core.exceptions.resolve.CaptchaHandler.Companion.suppressCaptchaErrors
 import org.koitharu.kotatsu.core.image.CoilImageView
 import org.koitharu.kotatsu.core.parser.favicon.faviconUri
 import org.koitharu.kotatsu.core.util.ext.isAnimationsEnabled
@@ -57,7 +57,7 @@ class FaviconView @JvmOverloads constructor(
 				.fallback(fallbackFactory)
 				.placeholder(placeholderFactory)
 				.mangaSourceExtra(mangaSource)
-				.ignoreCaptchaErrors()
+				.suppressCaptchaErrors()
 				.build(),
 		)
 	}

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

@@ -2,17 +2,16 @@ package org.koitharu.kotatsu.core.ui.list
 
 import android.view.View
 import android.view.View.OnClickListener
+import android.view.View.OnContextClickListener
 import android.view.View.OnLongClickListener
 import androidx.core.util.Function
 import com.hannesdorfmann.adapterdelegates4.dsl.AdapterDelegateViewBindingViewHolder
-import org.koitharu.kotatsu.core.ui.OnContextClickListenerCompat
-import org.koitharu.kotatsu.core.util.ext.setOnContextClickListenerCompat
 
 class AdapterDelegateClickListenerAdapter<I, O>(
 	private val adapterDelegate: AdapterDelegateViewBindingViewHolder<out I, *>,
 	private val clickListener: OnListItemClickListener<O>,
 	private val itemMapper: Function<I, O>,
-) : OnClickListener, OnLongClickListener, OnContextClickListenerCompat {
+) : OnClickListener, OnLongClickListener, OnContextClickListener {
 
 	override fun onClick(v: View) {
 		clickListener.onItemClick(mappedItem(), v)
@@ -33,7 +32,7 @@ class AdapterDelegateClickListenerAdapter<I, O>(
 	fun attach(itemView: View) {
 		itemView.setOnClickListener(this)
 		itemView.setOnLongClickListener(this)
-		itemView.setOnContextClickListenerCompat(this)
+		itemView.setOnContextClickListener(this)
 	}
 
 	companion object {

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

@@ -186,6 +186,7 @@ class ListSelectionController(
 
 		override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
 			if (event == Lifecycle.Event.ON_CREATE) {
+				source.lifecycle.removeObserver(this)
 				val registry = registryOwner.savedStateRegistry
 				registry.registerSavedStateProvider(PROVIDER_NAME, this@ListSelectionController)
 				val state = registry.consumeRestoredStateForKey(PROVIDER_NAME)

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/list/decor/SpacingItemDecoration.kt

@@ -5,7 +5,10 @@ import android.view.View
 import androidx.annotation.Px
 import androidx.recyclerview.widget.RecyclerView
 
-class SpacingItemDecoration(@Px private val spacing: Int) : RecyclerView.ItemDecoration() {
+class SpacingItemDecoration(
+    @Px private val spacing: Int,
+    private val withBottomPadding: Boolean,
+) : RecyclerView.ItemDecoration() {
 
 	override fun getItemOffsets(
 		outRect: Rect,
@@ -13,6 +16,6 @@ class SpacingItemDecoration(@Px private val spacing: Int) : RecyclerView.ItemDec
 		parent: RecyclerView,
 		state: RecyclerView.State,
 	) {
-		outRect.set(spacing, spacing, spacing, spacing)
+		outRect.set(spacing, spacing, spacing, if (withBottomPadding) spacing else 0)
 	}
 }

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

@@ -32,8 +32,7 @@ import org.koitharu.kotatsu.core.ui.util.ActionModeDelegate
 import com.google.android.material.R as materialR
 
 abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment(),
-	OnApplyWindowInsetsListener,
+	OnApplyWindowInsetsListener {
-	ExceptionResolver.Host {
 
 	private var waitingForDismissAllowingStateLoss = false
 	private var isFitToContentsDisabled = false

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

@@ -1,7 +1,6 @@
 package org.koitharu.kotatsu.core.ui.util
 
 import android.graphics.Color
-import android.os.Build
 import android.view.ViewGroup
 import android.view.Window
 import androidx.activity.OnBackPressedCallback
@@ -14,7 +13,6 @@ import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updateLayoutParams
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
-import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.util.ext.getThemeColor
 import com.google.android.material.R as materialR
 
@@ -37,14 +35,10 @@ class ActionModeDelegate : OnBackPressedCallback(false) {
 		listeners?.forEach { it.onActionModeStarted(mode) }
 		if (window != null) {
 			val ctx = window.context
-			val actionModeColor = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+			val actionModeColor = ColorUtils.compositeColors(
-				ColorUtils.compositeColors(
+				ContextCompat.getColor(ctx, materialR.color.m3_appbar_overlay_color),
-					ContextCompat.getColor(ctx, materialR.color.m3_appbar_overlay_color),
+				ctx.getThemeColor(materialR.attr.colorSurface),
-					ctx.getThemeColor(materialR.attr.colorSurface),
+			)
-				)
-			} else {
-				ContextCompat.getColor(ctx, R.color.kotatsu_surface)
-			}
 			defaultStatusBarColor = window.statusBarColor
 			window.statusBarColor = actionModeColor
 			val insets = ViewCompat.getRootWindowInsets(window.decorView)

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

@@ -4,12 +4,10 @@ import android.view.MenuItem
 import android.view.View
 import androidx.appcompat.widget.PopupMenu
 import androidx.core.view.MenuProvider
-import org.koitharu.kotatsu.core.ui.OnContextClickListenerCompat
-import org.koitharu.kotatsu.core.util.ext.setOnContextClickListenerCompat
 
 class PopupMenuMediator(
 	private val provider: MenuProvider,
-) : View.OnLongClickListener, OnContextClickListenerCompat, PopupMenu.OnMenuItemClickListener,
+) : View.OnLongClickListener, View.OnContextClickListener, PopupMenu.OnMenuItemClickListener,
 	PopupMenu.OnDismissListener {
 
 	override fun onContextClick(v: View): Boolean = onLongClick(v)
@@ -37,6 +35,6 @@ class PopupMenuMediator(
 
 	fun attach(view: View) {
 		view.setOnLongClickListener(this)
-		view.setOnContextClickListenerCompat(this)
+		view.setOnContextClickListener(this)
 	}
 }

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

@@ -56,6 +56,11 @@ class ChipsView @JvmOverloads constructor(
 		val data = it.tag
 		onChipCloseClickListener?.onChipCloseClick(chip, data) ?: onChipClickListener?.onChipClick(chip, data)
 	}
+	private val chipOnLongClickListener = OnLongClickListener {
+		val chip = it as Chip
+		val data = it.tag
+		onChipLongClickListener?.onChipLongClick(chip, data) ?: false
+	}
 	private val chipStyle: Int
 	private val iconsVisible: Boolean
 	var onChipClickListener: OnChipClickListener? = null
@@ -66,6 +71,8 @@ class ChipsView @JvmOverloads constructor(
 		}
 	var onChipCloseClickListener: OnChipCloseClickListener? = null
 
+	var onChipLongClickListener: OnChipLongClickListener? = null
+
 	init {
 		val ta = context.obtainStyledAttributes(attrs, R.styleable.ChipsView, defStyleAttr, 0)
 		chipStyle = ta.getResourceId(R.styleable.ChipsView_chipStyle, R.style.Widget_Kotatsu_Chip)
@@ -145,6 +152,7 @@ class ChipsView @JvmOverloads constructor(
 			setOnCloseIconClickListener(chipOnCloseListener)
 			setEnsureMinTouchTargetSize(false)
 			setOnClickListener(chipOnClickListener)
+			setOnLongClickListener(chipOnLongClickListener)
 			isElegantTextHeight = false
 		}
 
@@ -276,4 +284,9 @@ class ChipsView @JvmOverloads constructor(
 
 		fun onChipCloseClick(chip: Chip, data: Any?)
 	}
+
+	fun interface OnChipLongClickListener {
+
+		fun onChipLongClick(chip: Chip, data: Any?): Boolean
+	}
 }

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

@@ -22,7 +22,7 @@ open class StackLayout @JvmOverloads constructor(
 		val h = b - t - paddingTop - paddingBottom
 		visibleChildren.clear()
 		children.filterNotTo(visibleChildren) { it.isGone }
-		if (w <= 0 || h <= 0 || visibleChildren.isEmpty) {
+		if (w <= 0 || h <= 0 || visibleChildren.isEmpty()) {
 			return
 		}
 		val xStep = w / (visibleChildren.size + 1)

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

@@ -0,0 +1,22 @@
+package org.koitharu.kotatsu.core.ui.widgets
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.MotionEvent
+import android.widget.FrameLayout
+
+class TouchBlockLayout @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null
+) : FrameLayout(context, attrs) {
+
+    var isTouchEventsAllowed = true
+
+    override fun onInterceptTouchEvent(
+        ev: MotionEvent?
+    ): Boolean = if (isTouchEventsAllowed) {
+        super.onInterceptTouchEvent(ev)
+    } else {
+        true
+    }
+}

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

@@ -1,46 +0,0 @@
-package org.koitharu.kotatsu.core.util
-
-import android.annotation.SuppressLint
-import androidx.work.WorkInfo
-import androidx.work.WorkManager
-import androidx.work.WorkQuery
-import androidx.work.impl.foreground.SystemForegroundService
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.launch
-import org.koitharu.kotatsu.core.util.ext.processLifecycleScope
-import javax.inject.Provider
-
-/**
- * Workaround for issue
- * https://issuetracker.google.com/issues/270245927
- * https://issuetracker.google.com/issues/280504155
- */
-class WorkServiceStopHelper(
-	private val workManagerProvider: Provider<WorkManager>,
-) {
-
-	fun setup() {
-		processLifecycleScope.launch(Dispatchers.Default) {
-			workManagerProvider.get()
-				.getWorkInfosFlow(WorkQuery.fromStates(WorkInfo.State.RUNNING))
-				.map { it.isEmpty() }
-				.distinctUntilChanged()
-				.collectLatest {
-					if (it) {
-						delay(1_000)
-						stopWorkerService()
-					}
-				}
-		}
-	}
-
-	@SuppressLint("RestrictedApi")
-	private fun stopWorkerService() {
-		SystemForegroundService.getInstance()?.stop()
-	}
-}
-

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

@@ -22,6 +22,7 @@ import org.koitharu.kotatsu.core.exceptions.CaughtException
 import org.koitharu.kotatsu.core.exceptions.CloudFlareBlockedException
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
 import org.koitharu.kotatsu.core.exceptions.EmptyHistoryException
+import org.koitharu.kotatsu.core.exceptions.EmptyMangaException
 import org.koitharu.kotatsu.core.exceptions.IncompatiblePluginException
 import org.koitharu.kotatsu.core.exceptions.InteractiveActionRequiredException
 import org.koitharu.kotatsu.core.exceptions.NoDataReceivedException
@@ -62,216 +63,219 @@ private const val IMAGE_FORMAT_NOT_SUPPORTED = "Image format not supported"
 private val FNFE_MESSAGE_REGEX = Regex("^(/[^\\s:]+)?.+?\\s([A-Z]{2,6})?\\s.+$")
 
 fun Throwable.getDisplayMessage(resources: Resources): String = getDisplayMessageOrNull(resources)
-	?: resources.getString(R.string.error_occurred)
+    ?: resources.getString(R.string.error_occurred)
 
 private fun Throwable.getDisplayMessageOrNull(resources: Resources): String? = when (this) {
-	is CancellationException -> cause?.getDisplayMessageOrNull(resources) ?: message
+    is CancellationException -> cause?.getDisplayMessageOrNull(resources) ?: message
-	is CaughtException -> cause.getDisplayMessageOrNull(resources)
+    is CaughtException -> cause.getDisplayMessageOrNull(resources)
-	is WrapperIOException -> cause.getDisplayMessageOrNull(resources)
+    is WrapperIOException -> cause.getDisplayMessageOrNull(resources)
-	is ScrobblerAuthRequiredException -> resources.getString(
+    is ScrobblerAuthRequiredException -> resources.getString(
-		R.string.scrobbler_auth_required,
+        R.string.scrobbler_auth_required,
-		resources.getString(scrobbler.titleResId),
+        resources.getString(scrobbler.titleResId),
-	)
+    )
 
-	is AuthRequiredException -> resources.getString(R.string.auth_required)
+    is AuthRequiredException -> resources.getString(R.string.auth_required)
-	is InteractiveActionRequiredException -> resources.getString(R.string.additional_action_required)
+    is InteractiveActionRequiredException -> resources.getString(R.string.additional_action_required)
-	is CloudFlareProtectedException -> resources.getString(R.string.captcha_required_message)
+    is CloudFlareProtectedException -> resources.getString(R.string.captcha_required_message)
-	is CloudFlareBlockedException -> resources.getString(R.string.blocked_by_server_message)
+    is CloudFlareBlockedException -> resources.getString(R.string.blocked_by_server_message)
-	is ActivityNotFoundException,
+    is ActivityNotFoundException,
-	is UnsupportedOperationException,
+    is UnsupportedOperationException,
-		-> resources.getString(R.string.operation_not_supported)
+        -> resources.getString(R.string.operation_not_supported)
 
-	is TooManyRequestExceptions -> {
+    is TooManyRequestExceptions -> {
-		val delay = getRetryDelay()
+        val delay = getRetryDelay()
-		val formattedTime = if (delay > 0L && delay < Long.MAX_VALUE) {
+        val formattedTime = if (delay > 0L && delay < Long.MAX_VALUE) {
-			resources.formatDurationShort(delay)
+            resources.formatDurationShort(delay)
-		} else {
+        } else {
-			null
+            null
-		}
+        }
-		if (formattedTime != null) {
+        if (formattedTime != null) {
-			resources.getString(R.string.too_many_requests_message_retry, formattedTime)
+            resources.getString(R.string.too_many_requests_message_retry, formattedTime)
-		} else {
+        } else {
-			resources.getString(R.string.too_many_requests_message)
+            resources.getString(R.string.too_many_requests_message)
-		}
+        }
-	}
+    }
 
-	is ZipException -> resources.getString(R.string.error_corrupted_zip, this.message.orEmpty())
+    is ZipException -> resources.getString(R.string.error_corrupted_zip, this.message.orEmpty())
-	is SQLiteFullException -> resources.getString(R.string.error_no_space_left)
+    is SQLiteFullException -> resources.getString(R.string.error_no_space_left)
-	is UnsupportedFileException -> resources.getString(R.string.text_file_not_supported)
+    is UnsupportedFileException -> resources.getString(R.string.text_file_not_supported)
-	is BadBackupFormatException -> resources.getString(R.string.unsupported_backup_message)
+    is BadBackupFormatException -> resources.getString(R.string.unsupported_backup_message)
-	is FileNotFoundException -> parseMessage(resources) ?: message
+    is FileNotFoundException -> parseMessage(resources) ?: message
-	is AccessDeniedException -> resources.getString(R.string.no_access_to_file)
+    is AccessDeniedException -> resources.getString(R.string.no_access_to_file)
-	is NonFileUriException -> resources.getString(R.string.error_non_file_uri)
+    is NonFileUriException -> resources.getString(R.string.error_non_file_uri)
-	is EmptyHistoryException -> resources.getString(R.string.history_is_empty)
+    is EmptyHistoryException -> resources.getString(R.string.history_is_empty)
-	is ProxyConfigException -> resources.getString(R.string.invalid_proxy_configuration)
+    is EmptyMangaException -> reason?.let { resources.getString(it.msgResId) } ?: cause?.getDisplayMessage(resources)
-	is SyncApiException,
+    is ProxyConfigException -> resources.getString(R.string.invalid_proxy_configuration)
-	is ContentUnavailableException -> message
+    is SyncApiException,
+    is ContentUnavailableException -> message
 
-	is ParseException -> shortMessage
+    is ParseException -> shortMessage
-	is ConnectException,
+    is ConnectException,
-	is UnknownHostException,
+    is UnknownHostException,
-	is NoRouteToHostException,
+    is NoRouteToHostException,
-	is SocketTimeoutException -> resources.getString(R.string.network_error)
+    is SocketTimeoutException -> resources.getString(R.string.network_error)
 
-	is ImageDecodeException -> {
+    is ImageDecodeException -> {
-		val type = format?.substringBefore('/')
+        val type = format?.substringBefore('/')
-		val formatString = format.ifNullOrEmpty { resources.getString(R.string.unknown).lowercase(Locale.getDefault()) }
+        val formatString = format.ifNullOrEmpty { resources.getString(R.string.unknown).lowercase(Locale.getDefault()) }
-		if (type.isNullOrEmpty() || type == "image") {
+        if (type.isNullOrEmpty() || type == "image") {
-			resources.getString(R.string.error_image_format, formatString)
+            resources.getString(R.string.error_image_format, formatString)
-		} else {
+        } else {
-			resources.getString(R.string.error_not_image, formatString)
+            resources.getString(R.string.error_not_image, formatString)
-		}
+        }
-	}
+    }
 
-	is NoDataReceivedException -> resources.getString(R.string.error_no_data_received)
+    is NoDataReceivedException -> resources.getString(R.string.error_no_data_received)
-	is IncompatiblePluginException -> {
+    is IncompatiblePluginException -> {
-		cause?.getDisplayMessageOrNull(resources)?.let {
+        cause?.getDisplayMessageOrNull(resources)?.let {
-			resources.getString(R.string.plugin_incompatible_with_cause, it)
+            resources.getString(R.string.plugin_incompatible_with_cause, it)
-		} ?: resources.getString(R.string.plugin_incompatible)
+        } ?: resources.getString(R.string.plugin_incompatible)
-	}
+    }
 
-	is WrongPasswordException -> resources.getString(R.string.wrong_password)
+    is WrongPasswordException -> resources.getString(R.string.wrong_password)
-	is NotFoundException -> resources.getString(R.string.not_found_404)
+    is NotFoundException -> resources.getString(R.string.not_found_404)
-	is UnsupportedSourceException -> resources.getString(R.string.unsupported_source)
+    is UnsupportedSourceException -> resources.getString(R.string.unsupported_source)
 
-	is HttpException -> getHttpDisplayMessage(response.code, resources)
+    is HttpException -> getHttpDisplayMessage(response.code, resources)
-	is HttpStatusException -> getHttpDisplayMessage(statusCode, resources)
+    is HttpStatusException -> getHttpDisplayMessage(statusCode, resources)
 
-	else -> mapDisplayMessage(message, resources) ?: message
+    else -> mapDisplayMessage(message, resources) ?: message
 }.takeUnless { it.isNullOrBlank() }
 
 @DrawableRes
 fun Throwable.getDisplayIcon(): Int = when (this) {
-	is AuthRequiredException -> R.drawable.ic_auth_key_large
+    is AuthRequiredException -> R.drawable.ic_auth_key_large
-	is CloudFlareProtectedException -> R.drawable.ic_bot_large
+    is CloudFlareProtectedException -> R.drawable.ic_bot_large
-	is UnknownHostException,
+    is UnknownHostException,
-	is SocketTimeoutException,
+    is SocketTimeoutException,
-	is ConnectException,
+    is ConnectException,
-	is NoRouteToHostException,
+    is NoRouteToHostException,
-	is ProtocolException -> R.drawable.ic_plug_large
+    is ProtocolException -> R.drawable.ic_plug_large
 
-	is CloudFlareBlockedException -> R.drawable.ic_denied_large
+    is CloudFlareBlockedException -> R.drawable.ic_denied_large
 
-	is InteractiveActionRequiredException -> R.drawable.ic_interaction_large
+    is InteractiveActionRequiredException -> R.drawable.ic_interaction_large
-	else -> R.drawable.ic_error_large
+    else -> R.drawable.ic_error_large
 }
 
 fun Throwable.getCauseUrl(): String? = when (this) {
-	is ParseException -> url
+    is ParseException -> url
-	is NotFoundException -> url
+    is NotFoundException -> url
-	is TooManyRequestExceptions -> url
+    is TooManyRequestExceptions -> url
-	is CaughtException -> cause.getCauseUrl()
+    is CaughtException -> cause.getCauseUrl()
-	is WrapperIOException -> cause.getCauseUrl()
+    is WrapperIOException -> cause.getCauseUrl()
-	is NoDataReceivedException -> url
+    is NoDataReceivedException -> url
-	is CloudFlareBlockedException -> url
+    is CloudFlareBlockedException -> url
-	is CloudFlareProtectedException -> url
+    is CloudFlareProtectedException -> url
-	is InteractiveActionRequiredException -> url
+    is InteractiveActionRequiredException -> url
-	is HttpStatusException -> url
+    is HttpStatusException -> url
-	is HttpException -> (response.delegate as? Response)?.request?.url?.toString()
+    is UnsupportedSourceException -> manga?.publicUrl?.takeIf { it.isHttpUrl() }
-	else -> null
+    is EmptyMangaException -> manga.publicUrl.takeIf { it.isHttpUrl() }
+    is HttpException -> (response.delegate as? Response)?.request?.url?.toString()
+    else -> null
 }
 
 private fun getHttpDisplayMessage(statusCode: Int, resources: Resources): String? = when (statusCode) {
-	HttpURLConnection.HTTP_NOT_FOUND -> resources.getString(R.string.not_found_404)
+    HttpURLConnection.HTTP_NOT_FOUND -> resources.getString(R.string.not_found_404)
-	HttpURLConnection.HTTP_FORBIDDEN -> resources.getString(R.string.access_denied_403)
+    HttpURLConnection.HTTP_FORBIDDEN -> resources.getString(R.string.access_denied_403)
-	HttpURLConnection.HTTP_GATEWAY_TIMEOUT -> resources.getString(R.string.network_unavailable)
+    HttpURLConnection.HTTP_GATEWAY_TIMEOUT -> resources.getString(R.string.network_unavailable)
-	in 500..599 -> resources.getString(R.string.server_error, statusCode)
+    in 500..599 -> resources.getString(R.string.server_error, statusCode)
-	else -> null
+    else -> null
 }
 
 private fun mapDisplayMessage(msg: String?, resources: Resources): String? = when {
-	msg.isNullOrEmpty() -> null
+    msg.isNullOrEmpty() -> null
-	msg.contains(MSG_NO_SPACE_LEFT) -> resources.getString(R.string.error_no_space_left)
+    msg.contains(MSG_NO_SPACE_LEFT) -> resources.getString(R.string.error_no_space_left)
-	msg.contains(IMAGE_FORMAT_NOT_SUPPORTED) -> resources.getString(R.string.error_corrupted_file)
+    msg.contains(IMAGE_FORMAT_NOT_SUPPORTED) -> resources.getString(R.string.error_corrupted_file)
-	msg == MSG_CONNECTION_RESET -> resources.getString(R.string.error_connection_reset)
+    msg == MSG_CONNECTION_RESET -> resources.getString(R.string.error_connection_reset)
-	msg == FILTER_MULTIPLE_GENRES_NOT_SUPPORTED -> resources.getString(R.string.error_multiple_genres_not_supported)
+    msg == FILTER_MULTIPLE_GENRES_NOT_SUPPORTED -> resources.getString(R.string.error_multiple_genres_not_supported)
-	msg == FILTER_MULTIPLE_STATES_NOT_SUPPORTED -> resources.getString(R.string.error_multiple_states_not_supported)
+    msg == FILTER_MULTIPLE_STATES_NOT_SUPPORTED -> resources.getString(R.string.error_multiple_states_not_supported)
-	msg == SEARCH_NOT_SUPPORTED -> resources.getString(R.string.error_search_not_supported)
+    msg == SEARCH_NOT_SUPPORTED -> resources.getString(R.string.error_search_not_supported)
-	msg == FILTER_BOTH_LOCALE_GENRES_NOT_SUPPORTED -> resources.getString(R.string.error_filter_locale_genre_not_supported)
+    msg == FILTER_BOTH_LOCALE_GENRES_NOT_SUPPORTED -> resources.getString(R.string.error_filter_locale_genre_not_supported)
-	msg == FILTER_BOTH_STATES_GENRES_NOT_SUPPORTED -> resources.getString(R.string.error_filter_states_genre_not_supported)
+    msg == FILTER_BOTH_STATES_GENRES_NOT_SUPPORTED -> resources.getString(R.string.error_filter_states_genre_not_supported)
-	else -> null
+    else -> null
 }
 
 fun Throwable.isReportable(): Boolean {
-	if (this is Error) {
+    if (this is Error) {
-		return true
+        return true
-	}
+    }
-	if (this is CaughtException) {
+    if (this is CaughtException) {
-		return cause.isReportable()
+        return cause.isReportable()
-	}
+    }
-	if (this is WrapperIOException) {
+    if (this is WrapperIOException) {
-		return cause.isReportable()
+        return cause.isReportable()
-	}
+    }
-	if (ExceptionResolver.canResolve(this)) {
+    if (ExceptionResolver.canResolve(this)) {
-		return false
+        return false
-	}
+    }
-	if (this is ParseException
+    if (this is ParseException
-		|| this.isNetworkError()
+        || this.isNetworkError()
-		|| this is CloudFlareBlockedException
+        || this is CloudFlareBlockedException
-		|| this is CloudFlareProtectedException
+        || this is CloudFlareProtectedException
-		|| this is BadBackupFormatException
+        || this is BadBackupFormatException
-		|| this is WrongPasswordException
+        || this is WrongPasswordException
-		|| this is TooManyRequestExceptions
+        || this is TooManyRequestExceptions
-		|| this is HttpStatusException
+        || this is HttpStatusException
-	) {
+    ) {
-		return false
+        return false
-	}
+    }
-	return true
+    return true
 }
 
 fun Throwable.isNetworkError(): Boolean {
-	return this is UnknownHostException
+    return this is UnknownHostException
-		|| this is SocketTimeoutException
+        || this is SocketTimeoutException
-		|| this is StreamResetException
+        || this is StreamResetException
-		|| this is SocketException
+        || this is SocketException
-		|| this is HttpException && response.code == HttpURLConnection.HTTP_GATEWAY_TIMEOUT
+        || this is HttpException && response.code == HttpURLConnection.HTTP_GATEWAY_TIMEOUT
 }
 
 fun Throwable.report(silent: Boolean = false) {
-	val exception = CaughtException(this)
+    val exception = CaughtException(this)
-	if (!silent) {
+    if (!silent) {
-		exception.sendWithAcra()
+        exception.sendWithAcra()
-	} else if (!BuildConfig.DEBUG) {
+    } else if (!BuildConfig.DEBUG) {
-		exception.sendSilentlyWithAcra()
+        exception.sendSilentlyWithAcra()
-	}
+    }
 }
 
 fun Throwable.isWebViewUnavailable(): Boolean {
-	val trace = stackTraceToString()
+    val trace = stackTraceToString()
-	return trace.contains("android.webkit.WebView.<init>")
+    return trace.contains("android.webkit.WebView.<init>")
 }
 
 @Suppress("FunctionName")
 fun NoSpaceLeftException() = IOException(MSG_NO_SPACE_LEFT)
 
 fun FileNotFoundException.getFile(): File? {
-	val groups = FNFE_MESSAGE_REGEX.matchEntire(message ?: return null)?.groupValues ?: return null
+    val groups = FNFE_MESSAGE_REGEX.matchEntire(message ?: return null)?.groupValues ?: return null
-	return groups.getOrNull(1)?.let { File(it) }
+    return groups.getOrNull(1)?.let { File(it) }
 }
 
 fun FileNotFoundException.parseMessage(resources: Resources): String? {
-	/*
+    /*
-	Examples:
+    Examples:
-	/storage/0000-0000/Android/media/d1f08350-0c25-460b-8f50-008e49de3873.jpg.tmp: open failed: EROFS (Read-only file system)
+    /storage/0000-0000/Android/media/d1f08350-0c25-460b-8f50-008e49de3873.jpg.tmp: open failed: EROFS (Read-only file system)
-	 /storage/emulated/0/Android/data/org.koitharu.kotatsu/cache/pages/fe06e192fa371e55918980f7a24c91ea.jpg: open failed: ENOENT (No such file or directory)
+     /storage/emulated/0/Android/data/org.koitharu.kotatsu/cache/pages/fe06e192fa371e55918980f7a24c91ea.jpg: open failed: ENOENT (No such file or directory)
-	 /storage/0000-0000/Android/data/org.koitharu.kotatsu/files/manga/e57d3af4-216e-48b2-8432-1541d58eea1e.tmp (I/O error)
+     /storage/0000-0000/Android/data/org.koitharu.kotatsu/files/manga/e57d3af4-216e-48b2-8432-1541d58eea1e.tmp (I/O error)
-	 */
+     */
-	val groups = FNFE_MESSAGE_REGEX.matchEntire(message ?: return null)?.groupValues ?: return null
+    val groups = FNFE_MESSAGE_REGEX.matchEntire(message ?: return null)?.groupValues ?: return null
-	val path = groups.getOrNull(1)
+    val path = groups.getOrNull(1)
-	val error = groups.getOrNull(2)
+    val error = groups.getOrNull(2)
-	val baseMessageIs = when (error) {
+    val baseMessageIs = when (error) {
-		"EROFS" -> R.string.no_write_permission_to_file
+        "EROFS" -> R.string.no_write_permission_to_file
-		"ENOENT" -> R.string.file_not_found
+        "ENOENT" -> R.string.file_not_found
-		else -> return null
+        else -> return null
-	}
+    }
-	return if (path.isNullOrEmpty()) {
+    return if (path.isNullOrEmpty()) {
-		resources.getString(baseMessageIs)
+        resources.getString(baseMessageIs)
-	} else {
+    } else {
-		resources.getString(
+        resources.getString(
-			R.string.inline_preference_pattern,
+            R.string.inline_preference_pattern,
-			resources.getString(baseMessageIs),
+            resources.getString(baseMessageIs),
-			path,
+            path,
-		)
+        )
-	}
+    }
 }
 

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

@@ -28,7 +28,6 @@ import com.google.android.material.progressindicator.BaseProgressIndicator
 import com.google.android.material.slider.RangeSlider
 import com.google.android.material.slider.Slider
 import com.google.android.material.tabs.TabLayout
-import org.koitharu.kotatsu.core.ui.OnContextClickListenerCompat
 import kotlin.math.roundToInt
 
 fun View.hasGlobalPoint(x: Int, y: Int): Boolean {
@@ -169,12 +168,6 @@ fun BaseProgressIndicator<*>.showOrHide(value: Boolean) {
 	}
 }
 
-fun View.setOnContextClickListenerCompat(listener: OnContextClickListenerCompat) {
-	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-		setOnContextClickListener(listener::onContextClick)
-	}
-}
-
 fun View.setTooltipCompat(tooltip: CharSequence?) {
 	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
 		tooltipText = tooltip

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

@@ -7,111 +7,115 @@ import org.koitharu.kotatsu.core.ui.model.MangaOverride
 import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaState
 import org.koitharu.kotatsu.parsers.util.ifNullOrEmpty
 import org.koitharu.kotatsu.parsers.util.nullIfEmpty
 import org.koitharu.kotatsu.reader.data.filterChapters
 import java.util.Locale
 
 data class MangaDetails(
-	private val manga: Manga,
+    private val manga: Manga,
-	private val localManga: LocalManga?,
+    private val localManga: LocalManga?,
-	private val override: MangaOverride?,
+    private val override: MangaOverride?,
-	val description: CharSequence?,
+    val description: CharSequence?,
-	val isLoaded: Boolean,
+    val isLoaded: Boolean,
 ) {
 
-	constructor(manga: Manga) : this(
+    constructor(manga: Manga) : this(
-		manga = manga,
+        manga = manga,
-		localManga = null,
+        localManga = null,
-		override = null,
+        override = null,
-		description = null,
+        description = null,
-		isLoaded = false,
+        isLoaded = false,
-	)
+    )
-
+
-	val id: Long
+    val id: Long
-		get() = manga.id
+        get() = manga.id
-
+
-	val allChapters: List<MangaChapter> by lazy { mergeChapters() }
+    val allChapters: List<MangaChapter> by lazy { mergeChapters() }
-
+
-	val chapters: Map<String?, List<MangaChapter>> by lazy {
+    val chapters: Map<String?, List<MangaChapter>> by lazy {
-		allChapters.groupBy { it.branch }
+        allChapters.groupBy { it.branch }
-	}
+    }
-
+
-	val isLocal
+    val isLocal
-		get() = manga.isLocal
+        get() = manga.isLocal
-
+
-	val local: LocalManga?
+    val local: LocalManga?
-		get() = localManga ?: if (manga.isLocal) LocalManga(manga) else null
+        get() = localManga ?: if (manga.isLocal) LocalManga(manga) else null
-
+
-	val coverUrl: String?
+    val coverUrl: String?
-		get() = override?.coverUrl
+        get() = override?.coverUrl
-			.ifNullOrEmpty { manga.largeCoverUrl }
+            .ifNullOrEmpty { manga.largeCoverUrl }
-			.ifNullOrEmpty { manga.coverUrl }
+            .ifNullOrEmpty { manga.coverUrl }
-			.ifNullOrEmpty { localManga?.manga?.coverUrl }
+            .ifNullOrEmpty { localManga?.manga?.coverUrl }
-			?.nullIfEmpty()
+            ?.nullIfEmpty()
-
+
-	private val mergedManga by lazy {
+    val isRestricted: Boolean
-		if (localManga == null) {
+        get() = manga.state == MangaState.RESTRICTED
-			// fast path
+
-			manga.withOverride(override)
+    private val mergedManga by lazy {
-		} else {
+        if (localManga == null) {
-			manga.copy(
+            // fast path
-				title = override?.title.ifNullOrEmpty { manga.title },
+            manga.withOverride(override)
-				coverUrl = override?.coverUrl.ifNullOrEmpty { manga.coverUrl },
+        } else {
-				largeCoverUrl = override?.coverUrl.ifNullOrEmpty { manga.largeCoverUrl },
+            manga.copy(
-				contentRating = override?.contentRating ?: manga.contentRating,
+                title = override?.title.ifNullOrEmpty { manga.title },
-				chapters = allChapters,
+                coverUrl = override?.coverUrl.ifNullOrEmpty { manga.coverUrl },
-			)
+                largeCoverUrl = override?.coverUrl.ifNullOrEmpty { manga.largeCoverUrl },
-		}
+                contentRating = override?.contentRating ?: manga.contentRating,
-	}
+                chapters = allChapters,
-
+            )
-	fun toManga() = mergedManga
+        }
-
+    }
-	fun getLocale(): Locale? {
+
-		findAppropriateLocale(chapters.keys.singleOrNull())?.let {
+    fun toManga() = mergedManga
-			return it
+
-		}
+    fun getLocale(): Locale? {
-		return manga.source.getLocale()
+        findAppropriateLocale(chapters.keys.singleOrNull())?.let {
-	}
+            return it
-
+        }
-	fun filterChapters(branch: String?) = copy(
+        return manga.source.getLocale()
-		manga = manga.filterChapters(branch),
+    }
-		localManga = localManga?.run {
+
-			copy(manga = manga.filterChapters(branch))
+    fun filterChapters(branch: String?) = copy(
-		},
+        manga = manga.filterChapters(branch),
-	)
+        localManga = localManga?.run {
-
+            copy(manga = manga.filterChapters(branch))
-	private fun mergeChapters(): List<MangaChapter> {
+        },
-		val chapters = manga.chapters
+    )
-		val localChapters = local?.manga?.chapters.orEmpty()
+
-		if (chapters.isNullOrEmpty()) {
+    private fun mergeChapters(): List<MangaChapter> {
-			return localChapters
+        val chapters = manga.chapters
-		}
+        val localChapters = local?.manga?.chapters.orEmpty()
-		val localMap = if (localChapters.isNotEmpty()) {
+        if (chapters.isNullOrEmpty()) {
-			localChapters.associateByTo(LinkedHashMap(localChapters.size)) { it.id }
+            return localChapters
-		} else {
+        }
-			null
+        val localMap = if (localChapters.isNotEmpty()) {
-		}
+            localChapters.associateByTo(LinkedHashMap(localChapters.size)) { it.id }
-		val result = ArrayList<MangaChapter>(chapters.size)
+        } else {
-		for (chapter in chapters) {
+            null
-			val local = localMap?.remove(chapter.id)
+        }
-			result += local ?: chapter
+        val result = ArrayList<MangaChapter>(chapters.size)
-		}
+        for (chapter in chapters) {
-		if (!localMap.isNullOrEmpty()) {
+            val local = localMap?.remove(chapter.id)
-			result.addAll(localMap.values)
+            result += local ?: chapter
-		}
+        }
-		return result
+        if (!localMap.isNullOrEmpty()) {
-	}
+            result.addAll(localMap.values)
-
+        }
-	private fun findAppropriateLocale(name: String?): Locale? {
+        return result
-		if (name.isNullOrEmpty()) {
+    }
-			return null
+
-		}
+    private fun findAppropriateLocale(name: String?): Locale? {
-		return Locale.getAvailableLocales().find { lc ->
+        if (name.isNullOrEmpty()) {
-			name.contains(lc.getDisplayName(lc), ignoreCase = true) ||
+            return null
-				name.contains(lc.getDisplayName(Locale.ENGLISH), ignoreCase = true) ||
+        }
-				name.contains(lc.getDisplayLanguage(lc), ignoreCase = true) ||
+        return Locale.getAvailableLocales().find { lc ->
-				name.contains(lc.getDisplayLanguage(Locale.ENGLISH), ignoreCase = true)
+            name.contains(lc.getDisplayName(lc), ignoreCase = true) ||
-		}
+                name.contains(lc.getDisplayName(Locale.ENGLISH), ignoreCase = true) ||
-	}
+                name.contains(lc.getDisplayLanguage(lc), ignoreCase = true) ||
+                name.contains(lc.getDisplayLanguage(Locale.ENGLISH), ignoreCase = true)
+        }
+    }
 }

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

@@ -1,13 +1,11 @@
 package org.koitharu.kotatsu.details.domain
 
-import android.util.Log
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChangedBy
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.onEach
 import org.koitharu.kotatsu.core.model.FavouriteCategory
 import org.koitharu.kotatsu.core.model.isNsfw
 import org.koitharu.kotatsu.core.prefs.AppSettings

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

@@ -34,12 +34,17 @@ class ProgressUpdateUseCase @Inject constructor(
 		}
 		val chapter = details.findChapterById(history.chapterId) ?: return PROGRESS_NONE
 		val chapters = details.getChapters(chapter.branch)
+		val chapterRepo = if (repo.source == chapter.source) {
+			repo
+		} else {
+			mangaRepositoryFactory.create(chapter.source)
+		}
 		val chaptersCount = chapters.size
 		if (chaptersCount == 0) {
 			return PROGRESS_NONE
 		}
 		val chapterIndex = chapters.indexOfFirst { x -> x.id == history.chapterId }
-		val pagesCount = repo.getPages(chapter).size
+		val pagesCount = chapterRepo.getPages(chapter).size
 		if (pagesCount == 0) {
 			return PROGRESS_NONE
 		}

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

@@ -27,7 +27,7 @@ class ReadingTimeUseCase @Inject constructor(
 		// Impossible task, I guess. Good luck on this.
 		var averageTimeSec: Int = 20 /* pages */ * getSecondsPerPage(manga.id) * chapters.size
 		if (isOnHistoryBranch) {
-			averageTimeSec = (averageTimeSec * (1f - checkNotNull(history).percent)).roundToInt()
+			averageTimeSec = (averageTimeSec * (1f - history.percent)).roundToInt()
 		}
 		if (averageTimeSec < 60) {
 			return null

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

@@ -2,7 +2,6 @@ package org.koitharu.kotatsu.details.ui
 
 import android.app.assist.AssistContent
 import android.content.Context
-import android.os.Build
 import android.os.Bundle
 import android.text.SpannedString
 import android.view.Gravity
@@ -209,9 +208,7 @@ class DetailsActivity :
 
 	override fun onProvideAssistContent(outContent: AssistContent) {
 		super.onProvideAssistContent(outContent)
-		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+		viewModel.getMangaOrNull()?.publicUrl?.toUriOrNull()?.let { outContent.webUri = it }
-			viewModel.getMangaOrNull()?.publicUrl?.toUriOrNull()?.let { outContent.webUri = it }
-		}
 	}
 
 	override fun isNsfwContent(): Flow<Boolean> = viewModel.manga.map { it?.contentRating == ContentRating.ADULT }

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

@@ -140,6 +140,7 @@ class DetailsViewModel @Inject constructor(
 		get() = scrobblers.any { it.isEnabled }
 
 	val scrobblingInfo: StateFlow<List<ScrobblingInfo>> = interactor.observeScrobblingInfo(mangaId)
+		.withErrorHandling()
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, emptyList())
 
 	val relatedManga: StateFlow<List<MangaListModel>> = manga.mapLatest {

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

@@ -99,10 +99,11 @@ class ChaptersPagesSheet : BaseAdaptiveSheet<SheetChaptersPagesBinding>(),
 	override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat = insets
 
 	override fun onStateChanged(sheet: View, newState: Int) {
-		if (newState == STATE_DRAGGING || newState == STATE_SETTLING) {
+        val binding = viewBinding ?: return
-			return
+        binding.layoutTouchBlock.isTouchEventsAllowed = dialog != null || newState != STATE_COLLAPSED
-		}
+        if (newState == STATE_DRAGGING || newState == STATE_SETTLING) {
-		val binding = viewBinding ?: return
+            return
+        }
 		val isActionModeStarted = actionModeDelegate?.isActionModeStarted == true
 		binding.toolbar.menuView?.isVisible = newState == STATE_EXPANDED && !isActionModeStarted
 		binding.splitButtonRead.isVisible = newState != STATE_EXPANDED && !isActionModeStarted

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/chapters/ChaptersSelectionCallback.kt

@@ -3,6 +3,7 @@ package org.koitharu.kotatsu.details.ui.pager.chapters
 import android.view.Menu
 import android.view.MenuInflater
 import android.view.MenuItem
+import android.widget.Toast
 import androidx.appcompat.view.ActionMode
 import androidx.recyclerview.widget.RecyclerView
 import com.google.android.material.snackbar.Snackbar
@@ -11,6 +12,7 @@ import org.koitharu.kotatsu.core.model.LocalMangaSource
 import org.koitharu.kotatsu.core.nav.AppRouter
 import org.koitharu.kotatsu.core.ui.list.BaseListSelectionCallback
 import org.koitharu.kotatsu.core.ui.list.ListSelectionController
+import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import org.koitharu.kotatsu.core.util.ext.toCollection
 import org.koitharu.kotatsu.core.util.ext.toSet
 import org.koitharu.kotatsu.details.ui.pager.ChaptersPagesViewModel
@@ -78,11 +80,20 @@ class ChaptersSelectionCallback(
 					ids.size == manga.chapters?.size -> viewModel.deleteLocal()
 					else -> {
 						LocalChaptersRemoveService.start(recyclerView.context, manga, ids.toSet())
-						Snackbar.make(
+						try {
-							recyclerView,
+							Snackbar.make(
-							R.string.chapters_will_removed_background,
+								recyclerView,
-							Snackbar.LENGTH_LONG,
+								R.string.chapters_will_removed_background,
-						).show()
+								Snackbar.LENGTH_LONG,
+							).show()
+						} catch (e: IllegalArgumentException) {
+							e.printStackTraceDebug()
+							Toast.makeText(
+								recyclerView.context,
+								R.string.chapters_will_removed_background,
+								Toast.LENGTH_SHORT,
+							).show()
+						}
 					}
 				}
 				mode?.finish()

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/pages/PagesViewModel.kt

@@ -105,7 +105,14 @@ class PagesViewModel @Inject constructor(
 			chaptersLoader.peekChapter(it) != null
 		} ?: state.details.allChapters.firstOrNull()?.id ?: return
 		if (!chaptersLoader.hasPages(initialChapterId)) {
-			chaptersLoader.loadSingleChapter(initialChapterId)
+			var hasPages = chaptersLoader.loadSingleChapter(initialChapterId)
+			while (!hasPages) {
+				if (chaptersLoader.loadPrevNextChapter(state.details, initialChapterId, isNext = true)) {
+					hasPages = chaptersLoader.snapshot().isNotEmpty()
+				} else {
+					break
+				}
+			}
 		}
 		updateList(state.readerState)
 	}

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

@@ -7,6 +7,7 @@ import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
@@ -25,6 +26,8 @@ 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.local.data.LocalStorageChanges
+import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.parsers.model.Manga
 import javax.inject.Inject
 
@@ -35,7 +38,8 @@ class RelatedListViewModel @Inject constructor(
 	settings: AppSettings,
 	private val mangaListMapper: MangaListMapper,
 	mangaDataRepository: MangaDataRepository,
-) : MangaListViewModel(settings, mangaDataRepository) {
+	@LocalStorageChanges localStorageChanges: SharedFlow<LocalManga?>,
+) : MangaListViewModel(settings, mangaDataRepository, localStorageChanges) {
 
 	private val seed = savedStateHandle.require<ParcelableManga>(AppRouter.KEY_MANGA).manga
 	private val repository = mangaRepositoryFactory.create(seed.source)

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

@@ -202,7 +202,7 @@ class DownloadWorker @AssistedInject constructor(
 						?: error("Cannot obtain remote manga instance")
 				}
 				val repo = mangaRepositoryFactory.create(manga.source)
-				val mangaDetails = if (manga.chapters.isNullOrEmpty()) repo.getDetails(manga) else manga
+				val mangaDetails = if (manga.chapters.isNullOrEmpty() || manga.description.isNullOrEmpty()) repo.getDetails(manga) else manga
 				output = LocalMangaOutput.getOrCreate(
 					root = destination,
 					manga = mangaDetails,

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

@@ -53,11 +53,9 @@ class MangaSourcesRepository @Inject constructor(
 		get() = db.getSourcesDao()
 
 	val allMangaSources: Set<MangaParserSource> = Collections.unmodifiableSet(
-		EnumSet.allOf(MangaParserSource::class.java).apply {
+		EnumSet.noneOf<MangaParserSource>(MangaParserSource::class.java).also {
-			if (!BuildConfig.DEBUG) {
+            MangaParserSource.entries.filterNotTo(it, MangaParserSource::isBroken)
-				remove(MangaParserSource.DUMMY)
+        }
-			}
-		},
 	)
 
 	suspend fun getEnabledSources(): List<MangaSource> {

app/src/main/kotlin/org/koitharu/kotatsu/explore/ui/adapter/ExploreAdapterDelegates.kt

@@ -1,7 +1,6 @@
 package org.koitharu.kotatsu.explore.ui.adapter
 
 import android.view.View
-import androidx.appcompat.widget.TooltipCompat
 import androidx.core.content.ContextCompat
 import androidx.core.text.bold
 import androidx.core.text.buildSpannedString

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

@@ -40,6 +40,9 @@ import org.koitharu.kotatsu.list.ui.model.toErrorState
 import org.koitharu.kotatsu.parsers.model.Manga
 import java.util.concurrent.atomic.AtomicBoolean
 import javax.inject.Inject
+import org.koitharu.kotatsu.local.data.LocalStorageChanges
+import org.koitharu.kotatsu.local.domain.model.LocalManga
+import kotlinx.coroutines.flow.SharedFlow
 
 private const val PAGE_SIZE = 16
 
@@ -52,7 +55,8 @@ class FavouritesListViewModel @Inject constructor(
 	quickFilterFactory: FavoritesListQuickFilter.Factory,
 	settings: AppSettings,
 	mangaDataRepository: MangaDataRepository,
-) : MangaListViewModel(settings, mangaDataRepository), QuickFilterListener {
+	@LocalStorageChanges localStorageChanges: SharedFlow<LocalManga?>,
+) : MangaListViewModel(settings, mangaDataRepository, localStorageChanges), QuickFilterListener {
 
 	val categoryId: Long = savedStateHandle[AppRouter.KEY_ID] ?: NO_ID
 	private val quickFilter = quickFilterFactory.create(categoryId)

app/src/main/kotlin/org/koitharu/kotatsu/filter/data/MangaListFilterSerializer.kt

@@ -0,0 +1,161 @@
+package org.koitharu.kotatsu.filter.data
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.SetSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.descriptors.buildClassSerialDescriptor
+import kotlinx.serialization.descriptors.element
+import kotlinx.serialization.encoding.CompositeDecoder
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.encoding.decodeStructure
+import kotlinx.serialization.encoding.encodeStructure
+import kotlinx.serialization.serializer
+import org.koitharu.kotatsu.core.model.MangaSource
+import org.koitharu.kotatsu.core.util.ext.toLocaleOrNull
+import org.koitharu.kotatsu.parsers.model.ContentRating
+import org.koitharu.kotatsu.parsers.model.ContentType
+import org.koitharu.kotatsu.parsers.model.Demographic
+import org.koitharu.kotatsu.parsers.model.MangaListFilter
+import org.koitharu.kotatsu.parsers.model.MangaState
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import java.util.Locale
+
+object MangaListFilterSerializer : KSerializer<MangaListFilter> {
+
+    override val descriptor: SerialDescriptor =
+        buildClassSerialDescriptor(MangaListFilter::class.java.name) {
+            element<String?>("query", isOptional = true)
+            element(
+                elementName = "tags",
+                descriptor = SetSerializer(MangaTagSerializer).descriptor,
+                isOptional = true,
+            )
+            element(
+                elementName = "tagsExclude",
+                descriptor = SetSerializer(MangaTagSerializer).descriptor,
+                isOptional = true,
+            )
+            element<String?>("locale", isOptional = true)
+            element<String?>("originalLocale", isOptional = true)
+            element<Set<MangaState>>("states", isOptional = true)
+            element<Set<ContentRating>>("contentRating", isOptional = true)
+            element<Set<ContentType>>("types", isOptional = true)
+            element<Set<Demographic>>("demographics", isOptional = true)
+            element<Int>("year", isOptional = true)
+            element<Int>("yearFrom", isOptional = true)
+            element<Int>("yearTo", isOptional = true)
+            element<String?>("author", isOptional = true)
+        }
+
+    override fun serialize(
+        encoder: Encoder,
+        value: MangaListFilter
+    ) = encoder.encodeStructure(descriptor) {
+        encodeNullableSerializableElement(descriptor, 0, String.serializer(), value.query)
+        encodeSerializableElement(descriptor, 1, SetSerializer(MangaTagSerializer), value.tags)
+        encodeSerializableElement(descriptor, 2, SetSerializer(MangaTagSerializer), value.tagsExclude)
+        encodeNullableSerializableElement(descriptor, 3, String.serializer(), value.locale?.toLanguageTag())
+        encodeNullableSerializableElement(descriptor, 4, String.serializer(), value.originalLocale?.toLanguageTag())
+        encodeSerializableElement(descriptor, 5, SetSerializer(serializer()), value.states)
+        encodeSerializableElement(descriptor, 6, SetSerializer(serializer()), value.contentRating)
+        encodeSerializableElement(descriptor, 7, SetSerializer(serializer()), value.types)
+        encodeSerializableElement(descriptor, 8, SetSerializer(serializer()), value.demographics)
+        encodeIntElement(descriptor, 9, value.year)
+        encodeIntElement(descriptor, 10, value.yearFrom)
+        encodeIntElement(descriptor, 11, value.yearTo)
+        encodeNullableSerializableElement(descriptor, 12, String.serializer(), value.author)
+    }
+
+    override fun deserialize(
+        decoder: Decoder
+    ): MangaListFilter = decoder.decodeStructure(descriptor) {
+        var query: String? = MangaListFilter.EMPTY.query
+        var tags: Set<MangaTag> = MangaListFilter.EMPTY.tags
+        var tagsExclude: Set<MangaTag> = MangaListFilter.EMPTY.tagsExclude
+        var locale: Locale? = MangaListFilter.EMPTY.locale
+        var originalLocale: Locale? = MangaListFilter.EMPTY.originalLocale
+        var states: Set<MangaState> = MangaListFilter.EMPTY.states
+        var contentRating: Set<ContentRating> = MangaListFilter.EMPTY.contentRating
+        var types: Set<ContentType> = MangaListFilter.EMPTY.types
+        var demographics: Set<Demographic> = MangaListFilter.EMPTY.demographics
+        var year: Int = MangaListFilter.EMPTY.year
+        var yearFrom: Int = MangaListFilter.EMPTY.yearFrom
+        var yearTo: Int = MangaListFilter.EMPTY.yearTo
+        var author: String? = MangaListFilter.EMPTY.author
+
+        while (true) {
+            when (decodeElementIndex(descriptor)) {
+                0 -> query = decodeNullableSerializableElement(descriptor, 0, serializer<String>())
+                1 -> tags = decodeSerializableElement(descriptor, 1, SetSerializer(MangaTagSerializer))
+                2 -> tagsExclude = decodeSerializableElement(descriptor, 2, SetSerializer(MangaTagSerializer))
+                3 -> locale = decodeNullableSerializableElement(descriptor, 3, serializer<String>())?.toLocaleOrNull()
+                4 -> originalLocale =
+                    decodeNullableSerializableElement(descriptor, 4, serializer<String>())?.toLocaleOrNull()
+
+                5 -> states = decodeSerializableElement(descriptor, 5, SetSerializer(serializer()))
+                6 -> contentRating = decodeSerializableElement(descriptor, 6, SetSerializer(serializer()))
+                7 -> types = decodeSerializableElement(descriptor, 7, SetSerializer(serializer()))
+                8 -> demographics = decodeSerializableElement(descriptor, 8, SetSerializer(serializer()))
+                9 -> year = decodeIntElement(descriptor, 9)
+                10 -> yearFrom = decodeIntElement(descriptor, 10)
+                11 -> yearTo = decodeIntElement(descriptor, 11)
+                12 -> author = decodeNullableSerializableElement(descriptor, 12, serializer<String>())
+                CompositeDecoder.DECODE_DONE -> break
+            }
+        }
+
+        MangaListFilter(
+            query = query,
+            tags = tags,
+            tagsExclude = tagsExclude,
+            locale = locale,
+            originalLocale = originalLocale,
+            states = states,
+            contentRating = contentRating,
+            types = types,
+            demographics = demographics,
+            year = year,
+            yearFrom = yearFrom,
+            yearTo = yearTo,
+            author = author,
+        )
+    }
+
+    private object MangaTagSerializer : KSerializer<MangaTag> {
+
+        override val descriptor: SerialDescriptor = buildClassSerialDescriptor(MangaTag::class.java.name) {
+            element<String>("title")
+            element<String>("key")
+            element<String>("source")
+        }
+
+        override fun serialize(encoder: Encoder, value: MangaTag) = encoder.encodeStructure(descriptor) {
+            encodeStringElement(descriptor, 0, value.title)
+            encodeStringElement(descriptor, 1, value.key)
+            encodeStringElement(descriptor, 2, value.source.name)
+        }
+
+        override fun deserialize(decoder: Decoder): MangaTag = decoder.decodeStructure(descriptor) {
+            var title: String? = null
+            var key: String? = null
+            var source: String? = null
+
+            while (true) {
+                when (decodeElementIndex(descriptor)) {
+                    0 -> title = decodeStringElement(descriptor, 0)
+                    1 -> key = decodeStringElement(descriptor, 1)
+                    2 -> source = decodeStringElement(descriptor, 2)
+                    CompositeDecoder.DECODE_DONE -> break
+                }
+            }
+
+            MangaTag(
+                title = title ?: error("Missing 'title' field"),
+                key = key ?: error("Missing 'key' field"),
+                source = MangaSource(source),
+            )
+        }
+    }
+}

app/src/main/kotlin/org/koitharu/kotatsu/filter/data/PersistableFilter.kt

@@ -0,0 +1,30 @@
+package org.koitharu.kotatsu.filter.data
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonIgnoreUnknownKeys
+import org.koitharu.kotatsu.core.model.MangaSourceSerializer
+import org.koitharu.kotatsu.parsers.model.MangaListFilter
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+@Serializable
+@JsonIgnoreUnknownKeys
+data class PersistableFilter(
+    @SerialName("name")
+    val name: String,
+    @Serializable(with = MangaSourceSerializer::class)
+    @SerialName("source")
+    val source: MangaSource,
+    @Serializable(with = MangaListFilterSerializer::class)
+    @SerialName("filter")
+    val filter: MangaListFilter,
+) {
+
+    val id: Int
+        get() = name.hashCode()
+
+    companion object {
+
+        const val MAX_TITLE_LENGTH = 18
+    }
+}

app/src/main/kotlin/org/koitharu/kotatsu/filter/data/SavedFiltersRepository.kt

@@ -0,0 +1,118 @@
+package org.koitharu.kotatsu.filter.data
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.core.content.edit
+import dagger.Reusable
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onStart
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import org.koitharu.kotatsu.core.util.ext.observeChanges
+import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
+import org.koitharu.kotatsu.parsers.model.MangaListFilter
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import java.io.File
+import javax.inject.Inject
+
+@Reusable
+class SavedFiltersRepository @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+
+    fun observeAll(source: MangaSource): Flow<List<PersistableFilter>> = getPrefs(source).observeChanges()
+        .onStart { emit(null) }
+        .map {
+            getAll(source)
+        }.distinctUntilChanged()
+        .flowOn(Dispatchers.Default)
+
+    suspend fun getAll(source: MangaSource): List<PersistableFilter> = withContext(Dispatchers.Default) {
+        val prefs = getPrefs(source)
+        val keys = prefs.all.keys.filter { it.startsWith(FILTER_PREFIX) }
+        keys.mapNotNull { key ->
+            val value = prefs.getString(key, null) ?: return@mapNotNull null
+            try {
+                Json.decodeFromString(value)
+            } catch (e: SerializationException) {
+                e.printStackTraceDebug()
+                null
+            }
+        }
+    }
+
+    suspend fun save(
+        source: MangaSource,
+        name: String,
+        filter: MangaListFilter,
+    ): PersistableFilter = withContext(Dispatchers.Default) {
+        val persistableFilter = PersistableFilter(
+            name = name,
+            source = source,
+            filter = filter,
+        )
+        persist(persistableFilter)
+        persistableFilter
+    }
+
+    suspend fun save(
+        filter: PersistableFilter,
+    ) = withContext(Dispatchers.Default) {
+        persist(filter)
+    }
+
+    suspend fun rename(source: MangaSource, id: Int, newName: String) = withContext(Dispatchers.Default) {
+        val filter = load(source, id) ?: return@withContext
+        val newFilter = filter.copy(name = newName)
+        val prefs = getPrefs(source)
+        prefs.edit(commit = true) {
+            remove(key(id))
+            putString(key(newFilter.id), Json.encodeToString(newFilter))
+        }
+        newFilter
+    }
+
+    suspend fun delete(source: MangaSource, id: Int) = withContext(Dispatchers.Default) {
+        val prefs = getPrefs(source)
+        prefs.edit(commit = true) {
+            remove(key(id))
+        }
+    }
+
+    private fun persist(persistableFilter: PersistableFilter) {
+        val prefs = getPrefs(persistableFilter.source)
+        val json = Json.encodeToString(persistableFilter)
+        prefs.edit(commit = true) {
+            putString(key(persistableFilter.id), json)
+        }
+    }
+
+    private fun load(source: MangaSource, id: Int): PersistableFilter? {
+        val prefs = getPrefs(source)
+        val json = prefs.getString(key(id), null) ?: return null
+        return try {
+            Json.decodeFromString<PersistableFilter>(json)
+        } catch (e: SerializationException) {
+            e.printStackTraceDebug()
+            null
+        }
+    }
+
+    private fun getPrefs(source: MangaSource): SharedPreferences {
+        val key = source.name.replace(File.separatorChar, '$')
+        return context.getSharedPreferences(key, Context.MODE_PRIVATE)
+    }
+
+    private companion object {
+
+        const val FILTER_PREFIX = "__pf_"
+
+        fun key(id: Int) = FILTER_PREFIX + id
+    }
+}

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

@@ -17,6 +17,7 @@ import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.core.model.MangaSource
 import org.koitharu.kotatsu.core.parser.MangaRepository
@@ -25,6 +26,8 @@ import org.koitharu.kotatsu.core.util.ext.asFlow
 import org.koitharu.kotatsu.core.util.ext.lifecycleScope
 import org.koitharu.kotatsu.core.util.ext.sortedByOrdinal
 import org.koitharu.kotatsu.core.util.ext.sortedWithSafe
+import org.koitharu.kotatsu.filter.data.PersistableFilter
+import org.koitharu.kotatsu.filter.data.SavedFiltersRepository
 import org.koitharu.kotatsu.filter.ui.model.FilterProperty
 import org.koitharu.kotatsu.filter.ui.tags.TagTitleComparator
 import org.koitharu.kotatsu.parsers.model.ContentRating
@@ -48,469 +51,502 @@ import javax.inject.Inject
 
 @ViewModelScoped
 class FilterCoordinator @Inject constructor(
-	savedStateHandle: SavedStateHandle,
+    savedStateHandle: SavedStateHandle,
-	mangaRepositoryFactory: MangaRepository.Factory,
+    mangaRepositoryFactory: MangaRepository.Factory,
-	private val searchRepository: MangaSearchRepository,
+    private val searchRepository: MangaSearchRepository,
-	lifecycle: ViewModelLifecycle,
+    private val savedFiltersRepository: SavedFiltersRepository,
+    lifecycle: ViewModelLifecycle,
 ) {
 
-	private val coroutineScope = lifecycle.lifecycleScope + Dispatchers.Default
+    private val coroutineScope = lifecycle.lifecycleScope + Dispatchers.Default
-	private val repository = mangaRepositoryFactory.create(MangaSource(savedStateHandle[RemoteListFragment.ARG_SOURCE]))
+    private val repository = mangaRepositoryFactory.create(MangaSource(savedStateHandle[RemoteListFragment.ARG_SOURCE]))
-	private val sourceLocale = (repository.source as? MangaParserSource)?.locale
+    private val sourceLocale = (repository.source as? MangaParserSource)?.locale
-
+
-	private val currentListFilter = MutableStateFlow(MangaListFilter.EMPTY)
+    private val currentListFilter = MutableStateFlow(MangaListFilter.EMPTY)
-	private val currentSortOrder = MutableStateFlow(repository.defaultSortOrder)
+    private val currentSortOrder = MutableStateFlow(repository.defaultSortOrder)
-
+
-	private val availableSortOrders = repository.sortOrders
+    private val availableSortOrders = repository.sortOrders
-	private val filterOptions = suspendLazy { repository.getFilterOptions() }
+    private val filterOptions = suspendLazy { repository.getFilterOptions() }
-	val capabilities = repository.filterCapabilities
+
-
+    val capabilities = repository.filterCapabilities
-	val mangaSource: MangaSource
+
-		get() = repository.source
+    val mangaSource: MangaSource
-
+        get() = repository.source
-	val isFilterApplied: Boolean
+
-		get() = currentListFilter.value.isNotEmpty()
+    val isFilterApplied: Boolean
-
+        get() = currentListFilter.value.isNotEmpty()
-	val query: StateFlow<String?> = currentListFilter.map { it.query }
+
-		.stateIn(coroutineScope, SharingStarted.Eagerly, null)
+    val query: StateFlow<String?> = currentListFilter.map { it.query }
-
+        .stateIn(coroutineScope, SharingStarted.Eagerly, null)
-	val sortOrder: StateFlow<FilterProperty<SortOrder>> = currentSortOrder.map { selected ->
+
-		FilterProperty(
+    val sortOrder: StateFlow<FilterProperty<SortOrder>> = currentSortOrder.map { selected ->
-			availableItems = availableSortOrders.sortedByOrdinal(),
+        FilterProperty(
-			selectedItem = selected,
+            availableItems = availableSortOrders.sortedByOrdinal(),
-		)
+            selectedItem = selected,
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+        )
-
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-	val tags: StateFlow<FilterProperty<MangaTag>> = combine(
+
-		getTopTags(TAGS_LIMIT),
+    val tags: StateFlow<FilterProperty<MangaTag>> = combine(
-		currentListFilter.distinctUntilChangedBy { it.tags },
+        getTopTags(TAGS_LIMIT),
-	) { available, selected ->
+        currentListFilter.distinctUntilChangedBy { it.tags },
-		available.fold(
+    ) { available, selected ->
-			onSuccess = {
+        available.fold(
-				FilterProperty(
+            onSuccess = {
-					availableItems = it.addFirstDistinct(selected.tags),
+                FilterProperty(
-					selectedItems = selected.tags,
+                    availableItems = it.addFirstDistinct(selected.tags),
-				)
+                    selectedItems = selected.tags,
-			},
+                )
-			onFailure = {
+            },
-				FilterProperty.error(it)
+            onFailure = {
-			},
+                FilterProperty.error(it)
-		)
+            },
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+        )
-
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-	val tagsExcluded: StateFlow<FilterProperty<MangaTag>> = if (capabilities.isTagsExclusionSupported) {
+
-		combine(
+    val tagsExcluded: StateFlow<FilterProperty<MangaTag>> = if (capabilities.isTagsExclusionSupported) {
-			getBottomTags(TAGS_LIMIT),
+        combine(
-			currentListFilter.distinctUntilChangedBy { it.tagsExclude },
+            getBottomTags(TAGS_LIMIT),
-		) { available, selected ->
+            currentListFilter.distinctUntilChangedBy { it.tagsExclude },
-			available.fold(
+        ) { available, selected ->
-				onSuccess = {
+            available.fold(
-					FilterProperty(
+                onSuccess = {
-						availableItems = it.addFirstDistinct(selected.tagsExclude),
+                    FilterProperty(
-						selectedItems = selected.tagsExclude,
+                        availableItems = it.addFirstDistinct(selected.tagsExclude),
-					)
+                        selectedItems = selected.tagsExclude,
-				},
+                    )
-				onFailure = {
+                },
-					FilterProperty.error(it)
+                onFailure = {
-				},
+                    FilterProperty.error(it)
-			)
+                },
-		}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+            )
-	} else {
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-		MutableStateFlow(FilterProperty.EMPTY)
+    } else {
-	}
+        MutableStateFlow(FilterProperty.EMPTY)
-
+    }
-	val states: StateFlow<FilterProperty<MangaState>> = combine(
+
-		filterOptions.asFlow(),
+    val authors: StateFlow<FilterProperty<String>> = if (capabilities.isAuthorSearchSupported) {
-		currentListFilter.distinctUntilChangedBy { it.states },
+        combine(
-	) { available, selected ->
+            flow { emit(searchRepository.getAuthors(repository.source, TAGS_LIMIT)) },
-		available.fold(
+            currentListFilter.distinctUntilChangedBy { it.author },
-			onSuccess = {
+        ) { available, selected ->
-				FilterProperty(
+            FilterProperty(
-					availableItems = it.availableStates.sortedByOrdinal(),
+                availableItems = available,
-					selectedItems = selected.states,
+                selectedItems = setOfNotNull(selected.author),
-				)
+            )
-			},
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-			onFailure = {
+    } else {
-				FilterProperty.error(it)
+        MutableStateFlow(FilterProperty.EMPTY)
-			},
+    }
-		)
+
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val states: StateFlow<FilterProperty<MangaState>> = combine(
-
+        filterOptions.asFlow(),
-	val contentRating: StateFlow<FilterProperty<ContentRating>> = combine(
+        currentListFilter.distinctUntilChangedBy { it.states },
-		filterOptions.asFlow(),
+    ) { available, selected ->
-		currentListFilter.distinctUntilChangedBy { it.contentRating },
+        available.fold(
-	) { available, selected ->
+            onSuccess = {
-		available.fold(
+                FilterProperty(
-			onSuccess = {
+                    availableItems = it.availableStates.sortedByOrdinal(),
-				FilterProperty(
+                    selectedItems = selected.states,
-					availableItems = it.availableContentRating.sortedByOrdinal(),
+                )
-					selectedItems = selected.contentRating,
+            },
-				)
+            onFailure = {
-			},
+                FilterProperty.error(it)
-			onFailure = {
+            },
-				FilterProperty.error(it)
+        )
-			},
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-		)
+
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val contentRating: StateFlow<FilterProperty<ContentRating>> = combine(
-
+        filterOptions.asFlow(),
-	val contentTypes: StateFlow<FilterProperty<ContentType>> = combine(
+        currentListFilter.distinctUntilChangedBy { it.contentRating },
-		filterOptions.asFlow(),
+    ) { available, selected ->
-		currentListFilter.distinctUntilChangedBy { it.types },
+        available.fold(
-	) { available, selected ->
+            onSuccess = {
-		available.fold(
+                FilterProperty(
-			onSuccess = {
+                    availableItems = it.availableContentRating.sortedByOrdinal(),
-				FilterProperty(
+                    selectedItems = selected.contentRating,
-					availableItems = it.availableContentTypes.sortedByOrdinal(),
+                )
-					selectedItems = selected.types,
+            },
-				)
+            onFailure = {
-			},
+                FilterProperty.error(it)
-			onFailure = {
+            },
-				FilterProperty.error(it)
+        )
-			},
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-		)
+
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val contentTypes: StateFlow<FilterProperty<ContentType>> = combine(
-
+        filterOptions.asFlow(),
-	val demographics: StateFlow<FilterProperty<Demographic>> = combine(
+        currentListFilter.distinctUntilChangedBy { it.types },
-		filterOptions.asFlow(),
+    ) { available, selected ->
-		currentListFilter.distinctUntilChangedBy { it.demographics },
+        available.fold(
-	) { available, selected ->
+            onSuccess = {
-		available.fold(
+                FilterProperty(
-			onSuccess = {
+                    availableItems = it.availableContentTypes.sortedByOrdinal(),
-				FilterProperty(
+                    selectedItems = selected.types,
-					availableItems = it.availableDemographics.sortedByOrdinal(),
+                )
-					selectedItems = selected.demographics,
+            },
-				)
+            onFailure = {
-			},
+                FilterProperty.error(it)
-			onFailure = {
+            },
-				FilterProperty.error(it)
+        )
-			},
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-		)
+
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val demographics: StateFlow<FilterProperty<Demographic>> = combine(
-
+        filterOptions.asFlow(),
-	val locale: StateFlow<FilterProperty<Locale?>> = combine(
+        currentListFilter.distinctUntilChangedBy { it.demographics },
-		filterOptions.asFlow(),
+    ) { available, selected ->
-		currentListFilter.distinctUntilChangedBy { it.locale },
+        available.fold(
-	) { available, selected ->
+            onSuccess = {
-		available.fold(
+                FilterProperty(
-			onSuccess = {
+                    availableItems = it.availableDemographics.sortedByOrdinal(),
-				FilterProperty(
+                    selectedItems = selected.demographics,
-					availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
+                )
-					selectedItems = setOfNotNull(selected.locale),
+            },
-				)
+            onFailure = {
-			},
+                FilterProperty.error(it)
-			onFailure = {
+            },
-				FilterProperty.error(it)
+        )
-			},
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-		)
+
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val locale: StateFlow<FilterProperty<Locale?>> = combine(
-
+        filterOptions.asFlow(),
-	val originalLocale: StateFlow<FilterProperty<Locale?>> = if (capabilities.isOriginalLocaleSupported) {
+        currentListFilter.distinctUntilChangedBy { it.locale },
-		combine(
+    ) { available, selected ->
-			filterOptions.asFlow(),
+        available.fold(
-			currentListFilter.distinctUntilChangedBy { it.originalLocale },
+            onSuccess = {
-		) { available, selected ->
+                FilterProperty(
-			available.fold(
+                    availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
-				onSuccess = {
+                    selectedItems = setOfNotNull(selected.locale),
-					FilterProperty(
+                )
-						availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
+            },
-						selectedItems = setOfNotNull(selected.originalLocale),
+            onFailure = {
-					)
+                FilterProperty.error(it)
-				},
+            },
-				onFailure = {
+        )
-					FilterProperty.error(it)
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-				},
+
-			)
+    val originalLocale: StateFlow<FilterProperty<Locale?>> = if (capabilities.isOriginalLocaleSupported) {
-		}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+        combine(
-	} else {
+            filterOptions.asFlow(),
-		MutableStateFlow(FilterProperty.EMPTY)
+            currentListFilter.distinctUntilChangedBy { it.originalLocale },
-	}
+        ) { available, selected ->
-
+            available.fold(
-	val year: StateFlow<FilterProperty<Int>> = if (capabilities.isYearSupported) {
+                onSuccess = {
-		currentListFilter.distinctUntilChangedBy { it.year }.map { selected ->
+                    FilterProperty(
-			FilterProperty(
+                        availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
-				availableItems = listOf(YEAR_MIN, MAX_YEAR),
+                        selectedItems = setOfNotNull(selected.originalLocale),
-				selectedItems = setOf(selected.year),
+                    )
-			)
+                },
-		}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+                onFailure = {
-	} else {
+                    FilterProperty.error(it)
-		MutableStateFlow(FilterProperty.EMPTY)
+                },
-	}
+            )
-
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-	val yearRange: StateFlow<FilterProperty<Int>> = if (capabilities.isYearRangeSupported) {
+    } else {
-		currentListFilter.distinctUntilChanged { old, new ->
+        MutableStateFlow(FilterProperty.EMPTY)
-			old.yearTo == new.yearTo && old.yearFrom == new.yearFrom
+    }
-		}.map { selected ->
+
-			FilterProperty(
+    val year: StateFlow<FilterProperty<Int>> = if (capabilities.isYearSupported) {
-				availableItems = listOf(YEAR_MIN, MAX_YEAR),
+        currentListFilter.distinctUntilChangedBy { it.year }.map { selected ->
-				selectedItems = setOf(selected.yearFrom.ifZero { YEAR_MIN }, selected.yearTo.ifZero { MAX_YEAR }),
+            FilterProperty(
-			)
+                availableItems = listOf(YEAR_MIN, MAX_YEAR),
-		}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+                selectedItems = setOf(selected.year),
-	} else {
+            )
-		MutableStateFlow(FilterProperty.EMPTY)
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-	}
+    } else {
-
+        MutableStateFlow(FilterProperty.EMPTY)
-	fun reset() {
+    }
-		currentListFilter.value = MangaListFilter.EMPTY
+
-	}
+    val yearRange: StateFlow<FilterProperty<Int>> = if (capabilities.isYearRangeSupported) {
-
+        currentListFilter.distinctUntilChanged { old, new ->
-	fun snapshot() = Snapshot(
+            old.yearTo == new.yearTo && old.yearFrom == new.yearFrom
-		sortOrder = currentSortOrder.value,
+        }.map { selected ->
-		listFilter = currentListFilter.value,
+            FilterProperty(
-	)
+                availableItems = listOf(YEAR_MIN, MAX_YEAR),
-
+                selectedItems = setOf(selected.yearFrom.ifZero { YEAR_MIN }, selected.yearTo.ifZero { MAX_YEAR }),
-	fun observe(): Flow<Snapshot> = combine(currentSortOrder, currentListFilter, ::Snapshot)
+            )
-
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-	fun setSortOrder(newSortOrder: SortOrder) {
+    } else {
-		currentSortOrder.value = newSortOrder
+        MutableStateFlow(FilterProperty.EMPTY)
-		repository.defaultSortOrder = newSortOrder
+    }
-	}
+
-
+    val savedFilters: StateFlow<FilterProperty<PersistableFilter>> = combine(
-	fun set(value: MangaListFilter) {
+        savedFiltersRepository.observeAll(repository.source),
-		currentListFilter.value = value
+        currentListFilter,
-	}
+    ) { available, applied ->
-
+        FilterProperty(
-	fun setAdjusted(value: MangaListFilter) {
+            availableItems = available,
-		var newFilter = value
+            selectedItems = setOfNotNull(available.find { it.filter == applied }),
-		if (!newFilter.author.isNullOrEmpty() && !capabilities.isAuthorSearchSupported) {
+        )
-			newFilter = newFilter.copy(
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.EMPTY)
-				query = newFilter.author,
+
-				author = null,
+    fun reset() {
-			)
+        currentListFilter.value = MangaListFilter.EMPTY
-		}
+    }
-		if (!capabilities.isSearchSupported && !newFilter.query.isNullOrEmpty()) {
+
-			newFilter = newFilter.copy(
+    fun snapshot() = Snapshot(
-				query = null,
+        sortOrder = currentSortOrder.value,
-			)
+        listFilter = currentListFilter.value,
-		}
+    )
-		if (!newFilter.query.isNullOrEmpty() && !newFilter.hasNonSearchOptions() && !capabilities.isSearchWithFiltersSupported) {
+
-			newFilter = MangaListFilter(query = newFilter.query)
+    fun observe(): Flow<Snapshot> = combine(currentSortOrder, currentListFilter, ::Snapshot)
-		}
+
-		set(newFilter)
+    fun setSortOrder(newSortOrder: SortOrder) {
-	}
+        currentSortOrder.value = newSortOrder
-
+        repository.defaultSortOrder = newSortOrder
-	fun setQuery(value: String?) {
+    }
-		val newQuery = value?.trim()?.nullIfEmpty()
+
-		currentListFilter.update { oldValue ->
+    fun set(value: MangaListFilter) {
-			if (capabilities.isSearchWithFiltersSupported || newQuery == null) {
+        currentListFilter.value = value
-				oldValue.copy(query = newQuery)
+    }
-			} else {
+
-				MangaListFilter(query = newQuery)
+    fun setAdjusted(value: MangaListFilter) {
-			}
+        var newFilter = value
-		}
+        if (!newFilter.author.isNullOrEmpty() && !capabilities.isAuthorSearchSupported) {
-	}
+            newFilter = newFilter.copy(
-
+                query = newFilter.author,
-	fun setLocale(value: Locale?) {
+                author = null,
-		currentListFilter.update { oldValue ->
+            )
-			oldValue.copy(
+        }
-				locale = value,
+        if (!newFilter.query.isNullOrEmpty() && !newFilter.hasNonSearchOptions() && !capabilities.isSearchWithFiltersSupported) {
-				query = oldValue.takeQueryIfSupported(),
+            newFilter = MangaListFilter(query = newFilter.query)
-			)
+        }
-		}
+        set(newFilter)
-	}
+    }
-
+
-	fun setAuthor(value: String?) {
+    fun saveCurrentFilter(name: String) = coroutineScope.launch {
-		currentListFilter.update { oldValue ->
+        savedFiltersRepository.save(repository.source, name, currentListFilter.value)
-			oldValue.copy(
+    }
-				author = value,
+
-				query = oldValue.takeQueryIfSupported(),
+    fun renameSavedFilter(id: Int, newName: String) = coroutineScope.launch {
-			)
+        savedFiltersRepository.rename(repository.source, id, newName)
-		}
+    }
-	}
+
-
+    fun deleteSavedFilter(id: Int) = coroutineScope.launch {
-	fun setOriginalLocale(value: Locale?) {
+        savedFiltersRepository.delete(repository.source, id)
-		currentListFilter.update { oldValue ->
+    }
-			oldValue.copy(
+
-				originalLocale = value,
+    fun setQuery(value: String?) {
-				query = oldValue.takeQueryIfSupported(),
+        val newQuery = value?.trim()?.nullIfEmpty()
-			)
+        currentListFilter.update { oldValue ->
-		}
+            if (capabilities.isSearchWithFiltersSupported || newQuery == null) {
-	}
+                oldValue.copy(query = newQuery)
-
+            } else {
-	fun setYear(value: Int) {
+                MangaListFilter(query = newQuery)
-		currentListFilter.update { oldValue ->
+            }
-			oldValue.copy(
+        }
-				year = value,
+    }
-				query = oldValue.takeQueryIfSupported(),
+
-			)
+    fun setLocale(value: Locale?) {
-		}
+        currentListFilter.update { oldValue ->
-	}
+            oldValue.copy(
-
+                locale = value,
-	fun setYearRange(valueFrom: Int, valueTo: Int) {
+                query = oldValue.takeQueryIfSupported(),
-		currentListFilter.update { oldValue ->
+            )
-			oldValue.copy(
+        }
-				yearFrom = valueFrom,
+    }
-				yearTo = valueTo,
+
-				query = oldValue.takeQueryIfSupported(),
+    fun setAuthor(value: String?) {
-			)
+        currentListFilter.update { oldValue ->
-		}
+            oldValue.copy(
-	}
+                author = value,
-
+                query = oldValue.takeQueryIfSupported(),
-	fun toggleState(value: MangaState, isSelected: Boolean) {
+            )
-		currentListFilter.update { oldValue ->
+        }
-			oldValue.copy(
+    }
-				states = if (isSelected) oldValue.states + value else oldValue.states - value,
+
-				query = oldValue.takeQueryIfSupported(),
+    fun setOriginalLocale(value: Locale?) {
-			)
+        currentListFilter.update { oldValue ->
-		}
+            oldValue.copy(
-	}
+                originalLocale = value,
-
+                query = oldValue.takeQueryIfSupported(),
-	fun toggleContentRating(value: ContentRating, isSelected: Boolean) {
+            )
-		currentListFilter.update { oldValue ->
+        }
-			oldValue.copy(
+    }
-				contentRating = if (isSelected) oldValue.contentRating + value else oldValue.contentRating - value,
+
-				query = oldValue.takeQueryIfSupported(),
+    fun setYear(value: Int) {
-			)
+        currentListFilter.update { oldValue ->
-		}
+            oldValue.copy(
-	}
+                year = value,
-
+                query = oldValue.takeQueryIfSupported(),
-	fun toggleDemographic(value: Demographic, isSelected: Boolean) {
+            )
-		currentListFilter.update { oldValue ->
+        }
-			oldValue.copy(
+    }
-				demographics = if (isSelected) oldValue.demographics + value else oldValue.demographics - value,
+
-				query = oldValue.takeQueryIfSupported(),
+    fun setYearRange(valueFrom: Int, valueTo: Int) {
-			)
+        currentListFilter.update { oldValue ->
-		}
+            oldValue.copy(
-	}
+                yearFrom = valueFrom,
-
+                yearTo = valueTo,
-	fun toggleContentType(value: ContentType, isSelected: Boolean) {
+                query = oldValue.takeQueryIfSupported(),
-		currentListFilter.update { oldValue ->
+            )
-			oldValue.copy(
+        }
-				types = if (isSelected) oldValue.types + value else oldValue.types - value,
+    }
-				query = oldValue.takeQueryIfSupported(),
+
-			)
+    fun toggleState(value: MangaState, isSelected: Boolean) {
-		}
+        currentListFilter.update { oldValue ->
-	}
+            oldValue.copy(
-
+                states = if (isSelected) oldValue.states + value else oldValue.states - value,
-	fun toggleTag(value: MangaTag, isSelected: Boolean) {
+                query = oldValue.takeQueryIfSupported(),
-		currentListFilter.update { oldValue ->
+            )
-			val newTags = if (capabilities.isMultipleTagsSupported) {
+        }
-				if (isSelected) oldValue.tags + value else oldValue.tags - value
+    }
-			} else {
+
-				if (isSelected) setOf(value) else emptySet()
+    fun toggleContentRating(value: ContentRating, isSelected: Boolean) {
-			}
+        currentListFilter.update { oldValue ->
-			oldValue.copy(
+            oldValue.copy(
-				tags = newTags,
+                contentRating = if (isSelected) oldValue.contentRating + value else oldValue.contentRating - value,
-				tagsExclude = oldValue.tagsExclude - newTags,
+                query = oldValue.takeQueryIfSupported(),
-				query = oldValue.takeQueryIfSupported(),
+            )
-			)
+        }
-		}
+    }
-	}
+
-
+    fun toggleDemographic(value: Demographic, isSelected: Boolean) {
-	fun toggleTagExclude(value: MangaTag, isSelected: Boolean) {
+        currentListFilter.update { oldValue ->
-		currentListFilter.update { oldValue ->
+            oldValue.copy(
-			val newTagsExclude = if (capabilities.isMultipleTagsSupported) {
+                demographics = if (isSelected) oldValue.demographics + value else oldValue.demographics - value,
-				if (isSelected) oldValue.tagsExclude + value else oldValue.tagsExclude - value
+                query = oldValue.takeQueryIfSupported(),
-			} else {
+            )
-				if (isSelected) setOf(value) else emptySet()
+        }
-			}
+    }
-			oldValue.copy(
+
-				tags = oldValue.tags - newTagsExclude,
+    fun toggleContentType(value: ContentType, isSelected: Boolean) {
-				tagsExclude = newTagsExclude,
+        currentListFilter.update { oldValue ->
-				query = oldValue.takeQueryIfSupported(),
+            oldValue.copy(
-			)
+                types = if (isSelected) oldValue.types + value else oldValue.types - value,
-		}
+                query = oldValue.takeQueryIfSupported(),
-	}
+            )
-
+        }
-	fun getAllTags(): Flow<Result<List<MangaTag>>> = filterOptions.asFlow().map {
+    }
-		it.map { x -> x.availableTags.sortedWithSafe(TagTitleComparator(sourceLocale)) }
+
-	}
+    fun toggleTag(value: MangaTag, isSelected: Boolean) {
-
+        currentListFilter.update { oldValue ->
-	private fun MangaListFilter.takeQueryIfSupported() = when {
+            val newTags = if (capabilities.isMultipleTagsSupported) {
-		capabilities.isSearchWithFiltersSupported -> query
+                if (isSelected) oldValue.tags + value else oldValue.tags - value
-		query.isNullOrEmpty() -> query
+            } else {
-		hasNonSearchOptions() -> null
+                if (isSelected) setOf(value) else emptySet()
-		else -> query
+            }
-	}
+            oldValue.copy(
-
+                tags = newTags,
-	private fun getTopTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
+                tagsExclude = oldValue.tagsExclude - newTags,
-		flow { emit(searchRepository.getTopTags(repository.source, limit)) },
+                query = oldValue.takeQueryIfSupported(),
-		filterOptions.asFlow(),
+            )
-	) { suggested, options ->
+        }
-		val all = options.getOrNull()?.availableTags.orEmpty()
+    }
-		val result = ArrayList<MangaTag>(limit)
+
-		result.addAll(suggested.take(limit))
+    fun toggleTagExclude(value: MangaTag, isSelected: Boolean) {
-		if (result.size < limit) {
+        currentListFilter.update { oldValue ->
-			result.addAll(all.shuffled().take(limit - result.size))
+            val newTagsExclude = if (capabilities.isMultipleTagsSupported) {
-		}
+                if (isSelected) oldValue.tagsExclude + value else oldValue.tagsExclude - value
-		if (result.isNotEmpty()) {
+            } else {
-			Result.success(result)
+                if (isSelected) setOf(value) else emptySet()
-		} else {
+            }
-			options.map { result }
+            oldValue.copy(
-		}
+                tags = oldValue.tags - newTagsExclude,
-	}.catch {
+                tagsExclude = newTagsExclude,
-		emit(Result.failure(it))
+                query = oldValue.takeQueryIfSupported(),
-	}
+            )
-
+        }
-	private fun getBottomTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
+    }
-		flow { emit(searchRepository.getRareTags(repository.source, limit)) },
+
-		filterOptions.asFlow(),
+    fun getAllTags(): Flow<Result<List<MangaTag>>> = filterOptions.asFlow().map {
-	) { suggested, options ->
+        it.map { x -> x.availableTags.sortedWithSafe(TagTitleComparator(sourceLocale)) }
-		val all = options.getOrNull()?.availableTags.orEmpty()
+    }
-		val result = ArrayList<MangaTag>(limit)
+
-		result.addAll(suggested.take(limit))
+    private fun MangaListFilter.takeQueryIfSupported() = when {
-		if (result.size < limit) {
+        capabilities.isSearchWithFiltersSupported -> query
-			result.addAll(all.shuffled().take(limit - result.size))
+        query.isNullOrEmpty() -> query
-		}
+        hasNonSearchOptions() -> null
-		if (result.isNotEmpty()) {
+        else -> query
-			Result.success(result)
+    }
-		} else {
+
-			options.map { result }
+    private fun getTopTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
-		}
+        flow { emit(searchRepository.getTopTags(repository.source, limit)) },
-	}.catch {
+        filterOptions.asFlow(),
-		emit(Result.failure(it))
+    ) { suggested, options ->
-	}
+        val all = options.getOrNull()?.availableTags.orEmpty()
-
+        val result = ArrayList<MangaTag>(limit)
-	private fun <T> List<T>.addFirstDistinct(other: Collection<T>): List<T> {
+        result.addAll(suggested.take(limit))
-		val result = ArrayDeque<T>(this.size + other.size)
+        if (result.size < limit) {
-		result.addAll(this)
+            result.addAll(all.shuffled().take(limit - result.size))
-		for (item in other) {
+        }
-			if (item !in result) {
+        if (result.isNotEmpty()) {
-				result.addFirst(item)
+            Result.success(result)
-			}
+        } else {
-		}
+            options.map { result }
-		return result
+        }
-	}
+    }.catch {
-
+        emit(Result.failure(it))
-	private fun <T> List<T>.addFirstDistinct(item: T): List<T> {
+    }
-		val result = ArrayDeque<T>(this.size + 1)
+
-		result.addAll(this)
+    private fun getBottomTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
-		if (item !in result) {
+        flow { emit(searchRepository.getRareTags(repository.source, limit)) },
-			result.addFirst(item)
+        filterOptions.asFlow(),
-		}
+    ) { suggested, options ->
-		return result
+        val all = options.getOrNull()?.availableTags.orEmpty()
-	}
+        val result = ArrayList<MangaTag>(limit)
-
+        result.addAll(suggested.take(limit))
-	data class Snapshot(
+        if (result.size < limit) {
-		val sortOrder: SortOrder,
+            result.addAll(all.shuffled().take(limit - result.size))
-		val listFilter: MangaListFilter,
+        }
-	)
+        if (result.isNotEmpty()) {
-
+            Result.success(result)
-	interface Owner {
+        } else {
-
+            options.map { result }
-		val filterCoordinator: FilterCoordinator
+        }
-	}
+    }.catch {
-
+        emit(Result.failure(it))
-	companion object {
+    }
-
+
-		private const val TAGS_LIMIT = 12
+    private fun <T> List<T>.addFirstDistinct(other: Collection<T>): List<T> {
-		private val MAX_YEAR = Calendar.getInstance()[Calendar.YEAR] + 1
+        val result = ArrayDeque<T>(this.size + other.size)
-
+        result.addAll(this)
-		fun find(fragment: Fragment): FilterCoordinator? {
+        for (item in other) {
-			(fragment.activity as? Owner)?.let {
+            if (item !in result) {
-				return it.filterCoordinator
+                result.addFirst(item)
-			}
+            }
-			var f = fragment
+        }
-			while (true) {
+        return result
-				(f as? Owner)?.let {
+    }
-					return it.filterCoordinator
+
-				}
+    private fun <T> List<T>.addFirstDistinct(item: T): List<T> {
-				f = f.parentFragment ?: break
+        val result = ArrayDeque<T>(this.size + 1)
-			}
+        result.addAll(this)
-			return null
+        if (item !in result) {
-		}
+            result.addFirst(item)
-
+        }
-		fun require(fragment: Fragment): FilterCoordinator {
+        return result
-			return find(fragment) ?: throw IllegalStateException("FilterCoordinator cannot be found")
+    }
-		}
+
- 	}
+    data class Snapshot(
+        val sortOrder: SortOrder,
+        val listFilter: MangaListFilter,
+    )
+
+    interface Owner {
+
+        val filterCoordinator: FilterCoordinator
+    }
+
+    companion object {
+
+        private const val TAGS_LIMIT = 12
+        private val MAX_YEAR = Calendar.getInstance()[Calendar.YEAR] + 1
+
+        fun find(fragment: Fragment): FilterCoordinator? {
+            (fragment.activity as? Owner)?.let {
+                return it.filterCoordinator
+            }
+            var f = fragment
+            while (true) {
+                (f as? Owner)?.let {
+                    return it.filterCoordinator
+                }
+                f = f.parentFragment ?: break
+            }
+            return null
+        }
+
+        fun require(fragment: Fragment): FilterCoordinator {
+            return find(fragment) ?: throw IllegalStateException("FilterCoordinator cannot be found")
+        }
+    }
 }

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

@@ -16,6 +16,7 @@ import org.koitharu.kotatsu.core.ui.widgets.ChipsView
 import org.koitharu.kotatsu.core.util.ext.isAnimationsEnabled
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.databinding.FragmentFilterHeaderBinding
+import org.koitharu.kotatsu.filter.data.PersistableFilter
 import org.koitharu.kotatsu.filter.ui.model.FilterHeaderModel
 import org.koitharu.kotatsu.parsers.model.ContentRating
 import org.koitharu.kotatsu.parsers.model.ContentType
@@ -28,69 +29,75 @@ import javax.inject.Inject
 
 @AndroidEntryPoint
 class FilterHeaderFragment : BaseFragment<FragmentFilterHeaderBinding>(), ChipsView.OnChipClickListener,
-	ChipsView.OnChipCloseClickListener {
+    ChipsView.OnChipCloseClickListener {
 
-	@Inject
+    @Inject
-	lateinit var filterHeaderProducer: FilterHeaderProducer
+    lateinit var filterHeaderProducer: FilterHeaderProducer
 
-	private val filter: FilterCoordinator
+    private val filter: FilterCoordinator
-		get() = (requireActivity() as FilterCoordinator.Owner).filterCoordinator
+        get() = (requireActivity() as FilterCoordinator.Owner).filterCoordinator
 
-	override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): FragmentFilterHeaderBinding {
+    override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): FragmentFilterHeaderBinding {
-		return FragmentFilterHeaderBinding.inflate(inflater, container, false)
+        return FragmentFilterHeaderBinding.inflate(inflater, container, false)
-	}
+    }
 
-	override fun onViewBindingCreated(binding: FragmentFilterHeaderBinding, savedInstanceState: Bundle?) {
+    override fun onViewBindingCreated(binding: FragmentFilterHeaderBinding, savedInstanceState: Bundle?) {
-		super.onViewBindingCreated(binding, savedInstanceState)
+        super.onViewBindingCreated(binding, savedInstanceState)
-		binding.chipsTags.onChipClickListener = this
+        binding.chipsTags.onChipClickListener = this
-		binding.chipsTags.onChipCloseClickListener = this
+        binding.chipsTags.onChipCloseClickListener = this
-		filterHeaderProducer.observeHeader(filter)
+        filterHeaderProducer.observeHeader(filter)
-			.flowOn(Dispatchers.Default)
+            .flowOn(Dispatchers.Default)
-			.observe(viewLifecycleOwner, ::onDataChanged)
+            .observe(viewLifecycleOwner, ::onDataChanged)
-	}
+    }
 
-	override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat = insets
+    override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat = insets
 
-	override fun onChipClick(chip: Chip, data: Any?) {
+    override fun onChipClick(chip: Chip, data: Any?) {
-		when (data) {
+        when (data) {
-			is MangaTag -> filter.toggleTag(data, !chip.isChecked)
+            is MangaTag -> filter.toggleTag(data, !chip.isChecked)
-			is String -> Unit
+            is PersistableFilter -> if (chip.isChecked) {
-			null -> router.showTagsCatalogSheet(excludeMode = false)
+                filter.reset()
-		}
+            } else {
-	}
+                filter.setAdjusted(data.filter)
+            }
 
-	override fun onChipCloseClick(chip: Chip, data: Any?) {
+            is String -> Unit
-		when (data) {
+            null -> router.showTagsCatalogSheet(excludeMode = false)
-			is String -> if (data == filter.snapshot().listFilter.author) {
+        }
-				filter.setAuthor(null)
+    }
-			} else {
-				filter.setQuery(null)
-			}
 
-			is ContentRating -> filter.toggleContentRating(data, false)
+    override fun onChipCloseClick(chip: Chip, data: Any?) {
-			is Demographic -> filter.toggleDemographic(data, false)
+        when (data) {
-			is ContentType -> filter.toggleContentType(data, false)
+            is String -> if (data == filter.snapshot().listFilter.author) {
-			is MangaState -> filter.toggleState(data, false)
+                filter.setAuthor(null)
-			is Locale -> filter.setLocale(null)
+            } else {
-			is Int -> filter.setYear(YEAR_UNKNOWN)
+                filter.setQuery(null)
-			is IntRange -> filter.setYearRange(YEAR_UNKNOWN, YEAR_UNKNOWN)
+            }
-		}
-	}
 
-	private fun onDataChanged(header: FilterHeaderModel) {
+            is ContentRating -> filter.toggleContentRating(data, false)
-		val binding = viewBinding ?: return
+            is Demographic -> filter.toggleDemographic(data, false)
-		val chips = header.chips
+            is ContentType -> filter.toggleContentType(data, false)
-		if (chips.isEmpty()) {
+            is MangaState -> filter.toggleState(data, false)
-			binding.chipsTags.setChips(emptyList())
+            is Locale -> filter.setLocale(null)
-			binding.root.isVisible = false
+            is Int -> filter.setYear(YEAR_UNKNOWN)
-			return
+            is IntRange -> filter.setYearRange(YEAR_UNKNOWN, YEAR_UNKNOWN)
-		}
+        }
-		binding.chipsTags.setChips(header.chips)
+    }
-		binding.root.isVisible = true
+
-		if (binding.root.context.isAnimationsEnabled) {
+    private fun onDataChanged(header: FilterHeaderModel) {
-			binding.scrollView.smoothScrollTo(0, 0)
+        val binding = viewBinding ?: return
-		} else {
+        val chips = header.chips
-			binding.scrollView.scrollTo(0, 0)
+        if (chips.isEmpty()) {
-		}
+            binding.chipsTags.setChips(emptyList())
-	}
+            binding.root.isVisible = false
+            return
+        }
+        binding.chipsTags.setChips(header.chips)
+        binding.root.isVisible = true
+        if (binding.root.context.isAnimationsEnabled) {
+            binding.scrollView.smoothScrollTo(0, 0)
+        } else {
+            binding.scrollView.scrollTo(0, 0)
+        }
+    }
 }

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

@@ -5,6 +5,7 @@ import kotlinx.coroutines.flow.combine
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.model.titleResId
 import org.koitharu.kotatsu.core.ui.widgets.ChipsView
+import org.koitharu.kotatsu.filter.data.PersistableFilter
 import org.koitharu.kotatsu.filter.ui.model.FilterHeaderModel
 import org.koitharu.kotatsu.filter.ui.model.FilterProperty
 import org.koitharu.kotatsu.parsers.model.MangaListFilter
@@ -17,143 +18,162 @@ import javax.inject.Inject
 import androidx.appcompat.R as appcompatR
 
 class FilterHeaderProducer @Inject constructor(
-	private val searchRepository: MangaSearchRepository,
+    private val searchRepository: MangaSearchRepository,
 ) {
 
-	fun observeHeader(filterCoordinator: FilterCoordinator): Flow<FilterHeaderModel> {
+    fun observeHeader(filterCoordinator: FilterCoordinator): Flow<FilterHeaderModel> {
-		return combine(filterCoordinator.tags, filterCoordinator.observe()) { tags, snapshot ->
+        return combine(
-			val chipList = createChipsList(
+            filterCoordinator.savedFilters,
-				source = filterCoordinator.mangaSource,
+            filterCoordinator.tags,
-				capabilities = filterCoordinator.capabilities,
+            filterCoordinator.observe(),
-				tagsProperty = tags,
+        ) { saved, tags, snapshot ->
-				snapshot = snapshot.listFilter,
+            val chipList = createChipsList(
-				limit = 12,
+                source = filterCoordinator.mangaSource,
-			)
+                capabilities = filterCoordinator.capabilities,
-			FilterHeaderModel(
+                savedFilters = saved,
-				chips = chipList,
+                tagsProperty = tags,
-				sortOrder = snapshot.sortOrder,
+                snapshot = snapshot.listFilter,
-				isFilterApplied = !snapshot.listFilter.isEmpty(),
+                limit = 12,
-			)
+            )
-		}
+            FilterHeaderModel(
-	}
+                chips = chipList,
+                sortOrder = snapshot.sortOrder,
+                isFilterApplied = !snapshot.listFilter.isEmpty(),
+            )
+        }
+    }
 
-	private suspend fun createChipsList(
+    private suspend fun createChipsList(
-		source: MangaSource,
+        source: MangaSource,
-		capabilities: MangaListFilterCapabilities,
+        capabilities: MangaListFilterCapabilities,
-		tagsProperty: FilterProperty<MangaTag>,
+        savedFilters: FilterProperty<PersistableFilter>,
-		snapshot: MangaListFilter,
+        tagsProperty: FilterProperty<MangaTag>,
-		limit: Int,
+        snapshot: MangaListFilter,
-	): List<ChipsView.ChipModel> {
+        limit: Int,
-		val result = ArrayDeque<ChipsView.ChipModel>(limit + 3)
+    ): List<ChipsView.ChipModel> {
-		if (snapshot.query.isNullOrEmpty() || capabilities.isSearchWithFiltersSupported) {
+        val result = ArrayDeque<ChipsView.ChipModel>(savedFilters.availableItems.size + limit + 3)
-			val selectedTags = tagsProperty.selectedItems.toMutableSet()
+        if (snapshot.query.isNullOrEmpty() || capabilities.isSearchWithFiltersSupported) {
-			var tags = if (selectedTags.isEmpty()) {
+            val selectedTags = tagsProperty.selectedItems.toMutableSet()
-				searchRepository.getTagsSuggestion("", limit, source)
+            var tags = if (selectedTags.isEmpty()) {
-			} else {
+                searchRepository.getTagsSuggestion("", limit, source)
-				searchRepository.getTagsSuggestion(selectedTags).take(limit)
+            } else {
-			}
+                searchRepository.getTagsSuggestion(selectedTags).take(limit)
-			if (tags.size < limit) {
+            }
-				tags = tags + tagsProperty.availableItems.take(limit - tags.size)
+            if (tags.size < limit) {
-			}
+                tags = tags + tagsProperty.availableItems.take(limit - tags.size)
-			if (tags.isEmpty() && selectedTags.isEmpty()) {
+            }
-				return emptyList()
+            if (tags.isEmpty() && selectedTags.isEmpty()) {
-			}
+                return emptyList()
-			for (tag in tags) {
+            }
-				val model = ChipsView.ChipModel(
+            for (saved in savedFilters.availableItems) {
-					title = tag.title,
+                val model = ChipsView.ChipModel(
-					isChecked = selectedTags.remove(tag),
+                    title = saved.name,
-					data = tag,
+                    isChecked = saved in savedFilters.selectedItems,
-				)
+                    data = saved,
-				if (model.isChecked) {
+                )
-					result.addFirst(model)
+                if (model.isChecked) {
-				} else {
+                    selectedTags.removeAll(saved.filter.tags)
-					result.addLast(model)
+                    result.addFirst(model)
-				}
+                } else {
-			}
+                    result.addLast(model)
-			for (tag in selectedTags) {
+                }
-				val model = ChipsView.ChipModel(
+            }
-					title = tag.title,
+            for (tag in tags) {
-					isChecked = true,
+                val model = ChipsView.ChipModel(
-					data = tag,
+                    title = tag.title,
-				)
+                    isChecked = selectedTags.remove(tag),
-				result.addFirst(model)
+                    data = tag,
-			}
+                )
-		}
+                if (model.isChecked) {
-		snapshot.locale?.let {
+                    result.addFirst(model)
-			result.addFirst(
+                } else {
-				ChipsView.ChipModel(
+                    result.addLast(model)
-					title = it.getDisplayName(it).toTitleCase(it),
+                }
-					icon = R.drawable.ic_language,
+            }
-					isCloseable = true,
+            for (tag in selectedTags) {
-					data = it,
+                val model = ChipsView.ChipModel(
-				),
+                    title = tag.title,
-			)
+                    isChecked = true,
-		}
+                    data = tag,
-		snapshot.types.forEach {
+                )
-			result.addFirst(
+                result.addFirst(model)
-				ChipsView.ChipModel(
+            }
-					titleResId = it.titleResId,
+        }
-					isCloseable = true,
+        snapshot.locale?.let {
-					data = it,
+            result.addFirst(
-				),
+                ChipsView.ChipModel(
-			)
+                    title = it.getDisplayName(it).toTitleCase(it),
-		}
+                    icon = R.drawable.ic_language,
-		snapshot.demographics.forEach {
+                    isCloseable = true,
-			result.addFirst(
+                    data = it,
-				ChipsView.ChipModel(
+                ),
-					titleResId = it.titleResId,
+            )
-					isCloseable = true,
+        }
-					data = it,
+        snapshot.types.forEach {
-				),
+            result.addFirst(
-			)
+                ChipsView.ChipModel(
-		}
+                    titleResId = it.titleResId,
-		snapshot.contentRating.forEach {
+                    isCloseable = true,
-			result.addFirst(
+                    data = it,
-				ChipsView.ChipModel(
+                ),
-					titleResId = it.titleResId,
+            )
-					isCloseable = true,
+        }
-					data = it,
+        snapshot.demographics.forEach {
-				),
+            result.addFirst(
-			)
+                ChipsView.ChipModel(
-		}
+                    titleResId = it.titleResId,
-		snapshot.states.forEach {
+                    isCloseable = true,
-			result.addFirst(
+                    data = it,
-				ChipsView.ChipModel(
+                ),
-					titleResId = it.titleResId,
+            )
-					isCloseable = true,
+        }
-					data = it,
+        snapshot.contentRating.forEach {
-				),
+            result.addFirst(
-			)
+                ChipsView.ChipModel(
-		}
+                    titleResId = it.titleResId,
-		if (!snapshot.query.isNullOrEmpty()) {
+                    isCloseable = true,
-			result.addFirst(
+                    data = it,
-				ChipsView.ChipModel(
+                ),
-					title = snapshot.query,
+            )
-					icon = appcompatR.drawable.abc_ic_search_api_material,
+        }
-					isCloseable = true,
+        snapshot.states.forEach {
-					data = snapshot.query,
+            result.addFirst(
-				),
+                ChipsView.ChipModel(
-			)
+                    titleResId = it.titleResId,
-		}
+                    isCloseable = true,
-		if (!snapshot.author.isNullOrEmpty()) {
+                    data = it,
-			result.addFirst(
+                ),
-				ChipsView.ChipModel(
+            )
-					title = snapshot.author,
+        }
-					icon = R.drawable.ic_user,
+        if (!snapshot.query.isNullOrEmpty()) {
-					isCloseable = true,
+            result.addFirst(
-					data = snapshot.author,
+                ChipsView.ChipModel(
-				),
+                    title = snapshot.query,
-			)
+                    icon = appcompatR.drawable.abc_ic_search_api_material,
-		}
+                    isCloseable = true,
-		val hasTags = result.any { it.data is MangaTag }
+                    data = snapshot.query,
-		if (hasTags) {
+                ),
-			result.addFirst(moreTagsChip())
+            )
-		}
+        }
-		return result
+        if (!snapshot.author.isNullOrEmpty()) {
-	}
+            result.addFirst(
+                ChipsView.ChipModel(
+                    title = snapshot.author,
+                    icon = R.drawable.ic_user,
+                    isCloseable = true,
+                    data = snapshot.author,
+                ),
+            )
+        }
+        val hasTags = result.any { it.data is MangaTag }
+        if (hasTags) {
+            result.addFirst(moreTagsChip())
+        }
+        return result
+    }
 
-	private fun moreTagsChip() = ChipsView.ChipModel(
+    private fun moreTagsChip() = ChipsView.ChipModel(
-		titleResId = R.string.genres,
+        titleResId = R.string.genres,
-		icon = R.drawable.ic_drawer_menu_open,
+        icon = R.drawable.ic_drawer_menu_open,
-	)
+    )
 }

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

@@ -1,24 +1,39 @@
 package org.koitharu.kotatsu.filter.ui.sheet
 
-import android.os.Build
 import android.os.Bundle
+import android.text.InputFilter
+import android.view.Gravity
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import android.view.inputmethod.EditorInfo
 import android.widget.AdapterView
 import android.widget.ArrayAdapter
+import android.widget.LinearLayout
+import android.widget.Toast
+import androidx.appcompat.widget.PopupMenu
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.isGone
+import androidx.core.view.isVisible
+import androidx.core.view.updateLayoutParams
 import androidx.core.view.updatePadding
 import com.google.android.material.chip.Chip
 import com.google.android.material.slider.RangeSlider
 import com.google.android.material.slider.Slider
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.model.titleResId
 import org.koitharu.kotatsu.core.nav.router
+import org.koitharu.kotatsu.core.ui.dialog.buildAlertDialog
+import org.koitharu.kotatsu.core.ui.dialog.setEditText
 import org.koitharu.kotatsu.core.ui.model.titleRes
 import org.koitharu.kotatsu.core.ui.sheet.BaseAdaptiveSheet
 import org.koitharu.kotatsu.core.ui.widgets.ChipsView
+import org.koitharu.kotatsu.core.util.AlphanumComparator
 import org.koitharu.kotatsu.core.util.ext.consume
 import org.koitharu.kotatsu.core.util.ext.getDisplayMessage
 import org.koitharu.kotatsu.core.util.ext.getDisplayName
@@ -27,6 +42,8 @@ import org.koitharu.kotatsu.core.util.ext.parentView
 import org.koitharu.kotatsu.core.util.ext.setValueRounded
 import org.koitharu.kotatsu.core.util.ext.setValuesRounded
 import org.koitharu.kotatsu.databinding.SheetFilterBinding
+import org.koitharu.kotatsu.filter.data.PersistableFilter
+import org.koitharu.kotatsu.filter.data.PersistableFilter.Companion.MAX_TITLE_LENGTH
 import org.koitharu.kotatsu.filter.ui.FilterCoordinator
 import org.koitharu.kotatsu.filter.ui.model.FilterProperty
 import org.koitharu.kotatsu.parsers.model.ContentRating
@@ -36,324 +53,499 @@ import org.koitharu.kotatsu.parsers.model.MangaState
 import org.koitharu.kotatsu.parsers.model.MangaTag
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.model.YEAR_UNKNOWN
+import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.parsers.util.toIntUp
 import java.util.Locale
+import java.util.TreeSet
 
 class FilterSheetFragment : BaseAdaptiveSheet<SheetFilterBinding>(),
-	AdapterView.OnItemSelectedListener,
+    AdapterView.OnItemSelectedListener,
-	ChipsView.OnChipClickListener {
+    View.OnClickListener,
-
+    ChipsView.OnChipClickListener,
-	override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): SheetFilterBinding {
+    ChipsView.OnChipLongClickListener,
-		return SheetFilterBinding.inflate(inflater, container, false)
+    ChipsView.OnChipCloseClickListener {
-	}
+
-
+    override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): SheetFilterBinding {
-	override fun onViewBindingCreated(binding: SheetFilterBinding, savedInstanceState: Bundle?) {
+        return SheetFilterBinding.inflate(inflater, container, false)
-		super.onViewBindingCreated(binding, savedInstanceState)
+    }
-		if (dialog == null) {
+
-			binding.layoutBody.updatePadding(top = binding.layoutBody.paddingBottom)
+    override fun onViewBindingCreated(binding: SheetFilterBinding, savedInstanceState: Bundle?) {
-			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        super.onViewBindingCreated(binding, savedInstanceState)
-				binding.scrollView.scrollIndicators = 0
+        if (dialog == null) {
-			}
+            binding.adjustForEmbeddedLayout()
-		}
+        }
-		val filter = FilterCoordinator.require(this)
+        val filter = FilterCoordinator.require(this)
-		filter.sortOrder.observe(viewLifecycleOwner, this::onSortOrderChanged)
+        filter.sortOrder.observe(viewLifecycleOwner, this::onSortOrderChanged)
-		filter.locale.observe(viewLifecycleOwner, this::onLocaleChanged)
+        filter.locale.observe(viewLifecycleOwner, this::onLocaleChanged)
-		filter.originalLocale.observe(viewLifecycleOwner, this::onOriginalLocaleChanged)
+        filter.originalLocale.observe(viewLifecycleOwner, this::onOriginalLocaleChanged)
-		filter.tags.observe(viewLifecycleOwner, this::onTagsChanged)
+        filter.tags.observe(viewLifecycleOwner, this::onTagsChanged)
-		filter.tagsExcluded.observe(viewLifecycleOwner, this::onTagsExcludedChanged)
+        filter.tagsExcluded.observe(viewLifecycleOwner, this::onTagsExcludedChanged)
-		filter.states.observe(viewLifecycleOwner, this::onStateChanged)
+        filter.authors.observe(viewLifecycleOwner, this::onAuthorsChanged)
-		filter.contentTypes.observe(viewLifecycleOwner, this::onContentTypesChanged)
+        filter.states.observe(viewLifecycleOwner, this::onStateChanged)
-		filter.contentRating.observe(viewLifecycleOwner, this::onContentRatingChanged)
+        filter.contentTypes.observe(viewLifecycleOwner, this::onContentTypesChanged)
-		filter.demographics.observe(viewLifecycleOwner, this::onDemographicsChanged)
+        filter.contentRating.observe(viewLifecycleOwner, this::onContentRatingChanged)
-		filter.year.observe(viewLifecycleOwner, this::onYearChanged)
+        filter.demographics.observe(viewLifecycleOwner, this::onDemographicsChanged)
-		filter.yearRange.observe(viewLifecycleOwner, this::onYearRangeChanged)
+        filter.year.observe(viewLifecycleOwner, this::onYearChanged)
-
+        filter.yearRange.observe(viewLifecycleOwner, this::onYearRangeChanged)
-		binding.layoutGenres.setTitle(
+        filter.savedFilters.observe(viewLifecycleOwner, ::onSavedPresetsChanged)
-			if (filter.capabilities.isMultipleTagsSupported) {
+
-				R.string.genres
+        binding.layoutGenres.setTitle(
-			} else {
+            if (filter.capabilities.isMultipleTagsSupported) {
-				R.string.genre
+                R.string.genres
-			},
+            } else {
-		)
+                R.string.genre
-		binding.spinnerLocale.onItemSelectedListener = this
+            },
-		binding.spinnerOriginalLocale.onItemSelectedListener = this
+        )
-		binding.spinnerOrder.onItemSelectedListener = this
+        binding.spinnerLocale.onItemSelectedListener = this
-		binding.chipsState.onChipClickListener = this
+        binding.spinnerOriginalLocale.onItemSelectedListener = this
-		binding.chipsTypes.onChipClickListener = this
+        binding.spinnerOrder.onItemSelectedListener = this
-		binding.chipsContentRating.onChipClickListener = this
+        binding.chipsSavedFilters.onChipClickListener = this
-		binding.chipsDemographics.onChipClickListener = this
+        binding.chipsState.onChipClickListener = this
-		binding.chipsGenres.onChipClickListener = this
+        binding.chipsTypes.onChipClickListener = this
-		binding.chipsGenresExclude.onChipClickListener = this
+        binding.chipsContentRating.onChipClickListener = this
-		binding.sliderYear.addOnChangeListener(this::onSliderValueChange)
+        binding.chipsDemographics.onChipClickListener = this
-		binding.sliderYearsRange.addOnChangeListener(this::onRangeSliderValueChange)
+        binding.chipsGenres.onChipClickListener = this
-		binding.layoutGenres.setOnMoreButtonClickListener {
+        binding.chipsGenresExclude.onChipClickListener = this
-			router.showTagsCatalogSheet(excludeMode = false)
+        binding.chipsAuthor.onChipClickListener = this
-		}
+        binding.chipsSavedFilters.onChipLongClickListener = this
-		binding.layoutGenresExclude.setOnMoreButtonClickListener {
+        binding.chipsSavedFilters.onChipCloseClickListener = this
-			router.showTagsCatalogSheet(excludeMode = true)
+        binding.sliderYear.addOnChangeListener(this::onSliderValueChange)
-		}
+        binding.sliderYearsRange.addOnChangeListener(this::onRangeSliderValueChange)
-	}
+        binding.layoutGenres.setOnMoreButtonClickListener {
-
+            router.showTagsCatalogSheet(excludeMode = false)
-	override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+        }
-		val typeMask = WindowInsetsCompat.Type.systemBars()
+        binding.layoutGenresExclude.setOnMoreButtonClickListener {
-		viewBinding?.scrollView?.updatePadding(
+            router.showTagsCatalogSheet(excludeMode = true)
-			bottom = insets.getInsets(typeMask).bottom,
+        }
-		)
+        combine(
-		return insets.consume(v, typeMask, bottom = true)
+            filter.observe().map { it.listFilter.isNotEmpty() }.distinctUntilChanged(),
-	}
+            filter.savedFilters.map { it.selectedItems.isEmpty() }.distinctUntilChanged(),
-
+            Boolean::and,
-	override fun onItemSelected(parent: AdapterView<*>, view: View?, position: Int, id: Long) {
+        ).flowOn(Dispatchers.Default)
-		val filter = FilterCoordinator.require(this)
+            .observe(viewLifecycleOwner) {
-		when (parent.id) {
+                binding.buttonSave.isEnabled = it
-			R.id.spinner_order -> filter.setSortOrder(filter.sortOrder.value.availableItems[position])
+            }
-			R.id.spinner_locale -> filter.setLocale(filter.locale.value.availableItems[position])
+        binding.buttonSave.setOnClickListener(this)
-			R.id.spinner_original_locale -> filter.setOriginalLocale(filter.originalLocale.value.availableItems[position])
+        binding.buttonDone.setOnClickListener(this)
-		}
+    }
-	}
+
-
+    private fun SheetFilterBinding.adjustForEmbeddedLayout() {
-	override fun onNothingSelected(parent: AdapterView<*>?) = Unit
+        layoutBody.updatePadding(top = layoutBody.paddingBottom)
-
+        scrollView.scrollIndicators = 0
-	private fun onSliderValueChange(slider: Slider, value: Float, fromUser: Boolean) {
+        buttonDone.isVisible = false
-		if (!fromUser) {
+        this.root.layoutParams?.height = ViewGroup.LayoutParams.MATCH_PARENT
-			return
+        buttonSave.updateLayoutParams<LinearLayout.LayoutParams> {
-		}
+            weight = 0f
-		val intValue = value.toInt()
+            width = LinearLayout.LayoutParams.WRAP_CONTENT
-		val filter = FilterCoordinator.require(this)
+            gravity = Gravity.END or Gravity.CENTER_VERTICAL
-		when (slider.id) {
+        }
-			R.id.slider_year -> filter.setYear(
+    }
-				if (intValue <= slider.valueFrom.toIntUp()) {
+
-					YEAR_UNKNOWN
+    override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
-				} else {
+        val typeMask = WindowInsetsCompat.Type.systemBars()
-					intValue
+        viewBinding?.layoutBottom?.updateLayoutParams<ViewGroup.MarginLayoutParams> {
-				},
+            bottomMargin = insets.getInsets(typeMask).bottom
-			)
+        }
-		}
+        return insets.consume(v, typeMask, bottom = true)
-	}
+    }
-
+
-	private fun onRangeSliderValueChange(slider: RangeSlider, value: Float, fromUser: Boolean) {
+    override fun onClick(v: View) {
-		if (!fromUser) {
+        when (v.id) {
-			return
+            R.id.button_done -> dismiss()
-		}
+            R.id.button_save -> onSaveFilterClick("")
-		val filter = FilterCoordinator.require(this)
+        }
-		when (slider.id) {
+    }
-			R.id.slider_yearsRange -> filter.setYearRange(
+
-				valueFrom = slider.values.firstOrNull()?.let {
+    override fun onItemSelected(parent: AdapterView<*>, view: View?, position: Int, id: Long) {
-					if (it <= slider.valueFrom) YEAR_UNKNOWN else it.toInt()
+        val filter = FilterCoordinator.require(this)
-				} ?: YEAR_UNKNOWN,
+        when (parent.id) {
-				valueTo = slider.values.lastOrNull()?.let {
+            R.id.spinner_order -> filter.setSortOrder(filter.sortOrder.value.availableItems[position])
-					if (it >= slider.valueTo) YEAR_UNKNOWN else it.toInt()
+            R.id.spinner_locale -> filter.setLocale(filter.locale.value.availableItems[position])
-				} ?: YEAR_UNKNOWN,
+            R.id.spinner_original_locale -> filter.setOriginalLocale(filter.originalLocale.value.availableItems[position])
-			)
+        }
-		}
+    }
-	}
+
-
+    override fun onNothingSelected(parent: AdapterView<*>?) = Unit
-	override fun onChipClick(chip: Chip, data: Any?) {
+
-		val filter = FilterCoordinator.require(this)
+    private fun onSliderValueChange(slider: Slider, value: Float, fromUser: Boolean) {
-		when (data) {
+        if (!fromUser) {
-			is MangaState -> filter.toggleState(data, !chip.isChecked)
+            return
-			is MangaTag -> if (chip.parentView?.id == R.id.chips_genresExclude) {
+        }
-				filter.toggleTagExclude(data, !chip.isChecked)
+        val intValue = value.toInt()
-			} else {
+        val filter = FilterCoordinator.require(this)
-				filter.toggleTag(data, !chip.isChecked)
+        when (slider.id) {
-			}
+            R.id.slider_year -> filter.setYear(
-
+                if (intValue <= slider.valueFrom.toIntUp()) {
-			is ContentType -> filter.toggleContentType(data, !chip.isChecked)
+                    YEAR_UNKNOWN
-			is ContentRating -> filter.toggleContentRating(data, !chip.isChecked)
+                } else {
-			is Demographic -> filter.toggleDemographic(data, !chip.isChecked)
+                    intValue
-			null -> router.showTagsCatalogSheet(excludeMode = chip.parentView?.id == R.id.chips_genresExclude)
+                },
-		}
+            )
-	}
+        }
-
+    }
-	private fun onSortOrderChanged(value: FilterProperty<SortOrder>) {
+
-		val b = viewBinding ?: return
+    private fun onRangeSliderValueChange(slider: RangeSlider, value: Float, fromUser: Boolean) {
-		b.layoutOrder.isGone = value.isEmpty()
+        if (!fromUser) {
-		if (value.isEmpty()) {
+            return
-			return
+        }
-		}
+        val filter = FilterCoordinator.require(this)
-		val selected = value.selectedItems.single()
+        when (slider.id) {
-		b.spinnerOrder.adapter = ArrayAdapter(
+            R.id.slider_yearsRange -> filter.setYearRange(
-			b.spinnerOrder.context,
+                valueFrom = slider.values.firstOrNull()?.let {
-			android.R.layout.simple_spinner_dropdown_item,
+                    if (it <= slider.valueFrom) YEAR_UNKNOWN else it.toInt()
-			android.R.id.text1,
+                } ?: YEAR_UNKNOWN,
-			value.availableItems.map { b.spinnerOrder.context.getString(it.titleRes) },
+                valueTo = slider.values.lastOrNull()?.let {
-		)
+                    if (it >= slider.valueTo) YEAR_UNKNOWN else it.toInt()
-		val selectedIndex = value.availableItems.indexOf(selected)
+                } ?: YEAR_UNKNOWN,
-		if (selectedIndex >= 0) {
+            )
-			b.spinnerOrder.setSelection(selectedIndex, false)
+        }
-		}
+    }
-	}
+
-
+    override fun onChipClick(chip: Chip, data: Any?) {
-	private fun onLocaleChanged(value: FilterProperty<Locale?>) {
+        val filter = FilterCoordinator.require(this)
-		val b = viewBinding ?: return
+        when (data) {
-		b.layoutLocale.isGone = value.isEmpty()
+            is MangaState -> filter.toggleState(data, !chip.isChecked)
-		if (value.isEmpty()) {
+            is MangaTag -> if (chip.parentView?.id == R.id.chips_genresExclude) {
-			return
+                filter.toggleTagExclude(data, !chip.isChecked)
-		}
+            } else {
-		val selected = value.selectedItems.singleOrNull()
+                filter.toggleTag(data, !chip.isChecked)
-		b.spinnerLocale.adapter = ArrayAdapter(
+            }
-			b.spinnerLocale.context,
+
-			android.R.layout.simple_spinner_dropdown_item,
+            is ContentType -> filter.toggleContentType(data, !chip.isChecked)
-			android.R.id.text1,
+            is ContentRating -> filter.toggleContentRating(data, !chip.isChecked)
-			value.availableItems.map { it.getDisplayName(b.spinnerLocale.context) },
+            is Demographic -> filter.toggleDemographic(data, !chip.isChecked)
-		)
+            is PersistableFilter -> filter.setAdjusted(data.filter)
-		val selectedIndex = value.availableItems.indexOf(selected)
+            is String -> if (chip.isChecked) {
-		if (selectedIndex >= 0) {
+                filter.setAuthor(null)
-			b.spinnerLocale.setSelection(selectedIndex, false)
+            } else {
-		}
+                filter.setAuthor(data)
-	}
+            }
-
+            null -> router.showTagsCatalogSheet(excludeMode = chip.parentView?.id == R.id.chips_genresExclude)
-	private fun onOriginalLocaleChanged(value: FilterProperty<Locale?>) {
+        }
-		val b = viewBinding ?: return
+    }
-		b.layoutOriginalLocale.isGone = value.isEmpty()
+
-		if (value.isEmpty()) {
+    override fun onChipLongClick(chip: Chip, data: Any?): Boolean {
-			return
+        return when (data) {
-		}
+            is PersistableFilter -> {
-		val selected = value.selectedItems.singleOrNull()
+                showSavedFilterMenu(chip, data)
-		b.spinnerOriginalLocale.adapter = ArrayAdapter(
+                true
-			b.spinnerOriginalLocale.context,
+            }
-			android.R.layout.simple_spinner_dropdown_item,
+
-			android.R.id.text1,
+            else -> false
-			value.availableItems.map { it.getDisplayName(b.spinnerOriginalLocale.context) },
+        }
-		)
+    }
-		val selectedIndex = value.availableItems.indexOf(selected)
+
-		if (selectedIndex >= 0) {
+    override fun onChipCloseClick(chip: Chip, data: Any?) {
-			b.spinnerOriginalLocale.setSelection(selectedIndex, false)
+        when (data) {
-		}
+            is PersistableFilter -> {
-	}
+                showSavedFilterMenu(chip, data)
-
+            }
-	private fun onTagsChanged(value: FilterProperty<MangaTag>) {
+        }
-		val b = viewBinding ?: return
+    }
-		b.layoutGenres.isGone = value.isEmptyAndSuccess()
+
-		b.layoutGenres.setError(value.error?.getDisplayMessage(resources))
+    private fun onSortOrderChanged(value: FilterProperty<SortOrder>) {
-		if (value.isEmpty()) {
+        val b = viewBinding ?: return
-			return
+        b.layoutOrder.isGone = value.isEmpty()
-		}
+        if (value.isEmpty()) {
-		val chips = value.availableItems.map { tag ->
+            return
-			ChipsView.ChipModel(
+        }
-				title = tag.title,
+        val selected = value.selectedItems.single()
-				isChecked = tag in value.selectedItems,
+        b.spinnerOrder.adapter = ArrayAdapter(
-				data = tag,
+            b.spinnerOrder.context,
-			)
+            android.R.layout.simple_spinner_dropdown_item,
-		}
+            android.R.id.text1,
-		b.chipsGenres.setChips(chips)
+            value.availableItems.map { b.spinnerOrder.context.getString(it.titleRes) },
-	}
+        )
-
+        val selectedIndex = value.availableItems.indexOf(selected)
-	private fun onTagsExcludedChanged(value: FilterProperty<MangaTag>) {
+        if (selectedIndex >= 0) {
-		val b = viewBinding ?: return
+            b.spinnerOrder.setSelection(selectedIndex, false)
-		b.layoutGenresExclude.isGone = value.isEmpty()
+        }
-		if (value.isEmpty()) {
+    }
-			return
+
-		}
+    private fun onLocaleChanged(value: FilterProperty<Locale?>) {
-		val chips = value.availableItems.map { tag ->
+        val b = viewBinding ?: return
-			ChipsView.ChipModel(
+        b.layoutLocale.isGone = value.isEmpty()
-				title = tag.title,
+        if (value.isEmpty()) {
-				isChecked = tag in value.selectedItems,
+            return
-				data = tag,
+        }
-			)
+        val selected = value.selectedItems.singleOrNull()
-		}
+        b.spinnerLocale.adapter = ArrayAdapter(
-		b.chipsGenresExclude.setChips(chips)
+            b.spinnerLocale.context,
-	}
+            android.R.layout.simple_spinner_dropdown_item,
-
+            android.R.id.text1,
-	private fun onStateChanged(value: FilterProperty<MangaState>) {
+            value.availableItems.map { it.getDisplayName(b.spinnerLocale.context) },
-		val b = viewBinding ?: return
+        )
-		b.layoutState.isGone = value.isEmpty()
+        val selectedIndex = value.availableItems.indexOf(selected)
-		if (value.isEmpty()) {
+        if (selectedIndex >= 0) {
-			return
+            b.spinnerLocale.setSelection(selectedIndex, false)
-		}
+        }
-		val chips = value.availableItems.map { state ->
+    }
-			ChipsView.ChipModel(
+
-				title = getString(state.titleResId),
+    private fun onOriginalLocaleChanged(value: FilterProperty<Locale?>) {
-				isChecked = state in value.selectedItems,
+        val b = viewBinding ?: return
-				data = state,
+        b.layoutOriginalLocale.isGone = value.isEmpty()
-			)
+        if (value.isEmpty()) {
-		}
+            return
-		b.chipsState.setChips(chips)
+        }
-	}
+        val selected = value.selectedItems.singleOrNull()
-
+        b.spinnerOriginalLocale.adapter = ArrayAdapter(
-	private fun onContentTypesChanged(value: FilterProperty<ContentType>) {
+            b.spinnerOriginalLocale.context,
-		val b = viewBinding ?: return
+            android.R.layout.simple_spinner_dropdown_item,
-		b.layoutTypes.isGone = value.isEmpty()
+            android.R.id.text1,
-		if (value.isEmpty()) {
+            value.availableItems.map { it.getDisplayName(b.spinnerOriginalLocale.context) },
-			return
+        )
-		}
+        val selectedIndex = value.availableItems.indexOf(selected)
-		val chips = value.availableItems.map { type ->
+        if (selectedIndex >= 0) {
-			ChipsView.ChipModel(
+            b.spinnerOriginalLocale.setSelection(selectedIndex, false)
-				title = getString(type.titleResId),
+        }
-				isChecked = type in value.selectedItems,
+    }
-				data = type,
+
-			)
+    private fun onTagsChanged(value: FilterProperty<MangaTag>) {
-		}
+        val b = viewBinding ?: return
-		b.chipsTypes.setChips(chips)
+        b.layoutGenres.isGone = value.isEmptyAndSuccess()
-	}
+        b.layoutGenres.setError(value.error?.getDisplayMessage(resources))
-
+        if (value.isEmpty()) {
-	private fun onContentRatingChanged(value: FilterProperty<ContentRating>) {
+            return
-		val b = viewBinding ?: return
+        }
-		b.layoutContentRating.isGone = value.isEmpty()
+        val chips = value.availableItems.map { tag ->
-		if (value.isEmpty()) {
+            ChipsView.ChipModel(
-			return
+                title = tag.title,
-		}
+                isChecked = tag in value.selectedItems,
-		val chips = value.availableItems.map { contentRating ->
+                data = tag,
-			ChipsView.ChipModel(
+            )
-				title = getString(contentRating.titleResId),
+        }
-				isChecked = contentRating in value.selectedItems,
+        b.chipsGenres.setChips(chips)
-				data = contentRating,
+    }
-			)
+
-		}
+    private fun onTagsExcludedChanged(value: FilterProperty<MangaTag>) {
-		b.chipsContentRating.setChips(chips)
+        val b = viewBinding ?: return
-	}
+        b.layoutGenresExclude.isGone = value.isEmpty()
-
+        if (value.isEmpty()) {
-	private fun onDemographicsChanged(value: FilterProperty<Demographic>) {
+            return
-		val b = viewBinding ?: return
+        }
-		b.layoutDemographics.isGone = value.isEmpty()
+        val chips = value.availableItems.map { tag ->
-		if (value.isEmpty()) {
+            ChipsView.ChipModel(
-			return
+                title = tag.title,
-		}
+                isChecked = tag in value.selectedItems,
-		val chips = value.availableItems.map { demographic ->
+                data = tag,
-			ChipsView.ChipModel(
+            )
-				title = getString(demographic.titleResId),
+        }
-				isChecked = demographic in value.selectedItems,
+        b.chipsGenresExclude.setChips(chips)
-				data = demographic,
+    }
-			)
+
-		}
+    private fun onAuthorsChanged(value: FilterProperty<String>) {
-		b.chipsDemographics.setChips(chips)
+        val b = viewBinding ?: return
-	}
+        b.layoutAuthor.isGone = value.isEmpty()
-
+        if (value.isEmpty()) {
-	private fun onYearChanged(value: FilterProperty<Int>) {
+            return
-		val b = viewBinding ?: return
+        }
-		b.layoutYear.isGone = value.isEmpty()
+        val chips = value.availableItems.map { author ->
-		if (value.isEmpty()) {
+            ChipsView.ChipModel(
-			return
+                title = author,
-		}
+                isChecked = author in value.selectedItems,
-		val currentValue = value.selectedItems.singleOrNull() ?: YEAR_UNKNOWN
+                data = author,
-		b.layoutYear.setValueText(
+            )
-			if (currentValue == YEAR_UNKNOWN) {
+        }
-				getString(R.string.any)
+        b.chipsAuthor.setChips(chips)
-			} else {
+    }
-				currentValue.toString()
+
-			},
+    private fun onStateChanged(value: FilterProperty<MangaState>) {
-		)
+        val b = viewBinding ?: return
-		b.sliderYear.valueFrom = value.availableItems.first().toFloat()
+        b.layoutState.isGone = value.isEmpty()
-		b.sliderYear.valueTo = value.availableItems.last().toFloat()
+        if (value.isEmpty()) {
-		b.sliderYear.setValueRounded(currentValue.toFloat())
+            return
-	}
+        }
-
+        val chips = value.availableItems.map { state ->
-	private fun onYearRangeChanged(value: FilterProperty<Int>) {
+            ChipsView.ChipModel(
-		val b = viewBinding ?: return
+                title = getString(state.titleResId),
-		b.layoutYearsRange.isGone = value.isEmpty()
+                isChecked = state in value.selectedItems,
-		if (value.isEmpty()) {
+                data = state,
-			return
+            )
-		}
+        }
-		b.sliderYearsRange.valueFrom = value.availableItems.first().toFloat()
+        b.chipsState.setChips(chips)
-		b.sliderYearsRange.valueTo = value.availableItems.last().toFloat()
+    }
-		val currentValueFrom = value.selectedItems.firstOrNull()?.toFloat() ?: b.sliderYearsRange.valueFrom
+
-		val currentValueTo = value.selectedItems.lastOrNull()?.toFloat() ?: b.sliderYearsRange.valueTo
+    private fun onContentTypesChanged(value: FilterProperty<ContentType>) {
-		b.layoutYearsRange.setValueText(
+        val b = viewBinding ?: return
-			getString(
+        b.layoutTypes.isGone = value.isEmpty()
-				R.string.memory_usage_pattern,
+        if (value.isEmpty()) {
-				currentValueFrom.toInt().toString(),
+            return
-				currentValueTo.toInt().toString(),
+        }
-			),
+        val chips = value.availableItems.map { type ->
-		)
+            ChipsView.ChipModel(
-		b.sliderYearsRange.setValuesRounded(currentValueFrom, currentValueTo)
+                title = getString(type.titleResId),
-	}
+                isChecked = type in value.selectedItems,
+                data = type,
+            )
+        }
+        b.chipsTypes.setChips(chips)
+    }
+
+    private fun onContentRatingChanged(value: FilterProperty<ContentRating>) {
+        val b = viewBinding ?: return
+        b.layoutContentRating.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val chips = value.availableItems.map { contentRating ->
+            ChipsView.ChipModel(
+                title = getString(contentRating.titleResId),
+                isChecked = contentRating in value.selectedItems,
+                data = contentRating,
+            )
+        }
+        b.chipsContentRating.setChips(chips)
+    }
+
+    private fun onDemographicsChanged(value: FilterProperty<Demographic>) {
+        val b = viewBinding ?: return
+        b.layoutDemographics.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val chips = value.availableItems.map { demographic ->
+            ChipsView.ChipModel(
+                title = getString(demographic.titleResId),
+                isChecked = demographic in value.selectedItems,
+                data = demographic,
+            )
+        }
+        b.chipsDemographics.setChips(chips)
+    }
+
+    private fun onYearChanged(value: FilterProperty<Int>) {
+        val b = viewBinding ?: return
+        b.layoutYear.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val currentValue = value.selectedItems.singleOrNull() ?: YEAR_UNKNOWN
+        b.layoutYear.setValueText(
+            if (currentValue == YEAR_UNKNOWN) {
+                getString(R.string.any)
+            } else {
+                currentValue.toString()
+            },
+        )
+        b.sliderYear.valueFrom = value.availableItems.first().toFloat()
+        b.sliderYear.valueTo = value.availableItems.last().toFloat()
+        b.sliderYear.setValueRounded(currentValue.toFloat())
+    }
+
+    private fun onYearRangeChanged(value: FilterProperty<Int>) {
+        val b = viewBinding ?: return
+        b.layoutYearsRange.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        b.sliderYearsRange.valueFrom = value.availableItems.first().toFloat()
+        b.sliderYearsRange.valueTo = value.availableItems.last().toFloat()
+        val currentValueFrom = value.selectedItems.firstOrNull()?.toFloat() ?: b.sliderYearsRange.valueFrom
+        val currentValueTo = value.selectedItems.lastOrNull()?.toFloat() ?: b.sliderYearsRange.valueTo
+        b.layoutYearsRange.setValueText(
+            getString(
+                R.string.memory_usage_pattern,
+                currentValueFrom.toInt().toString(),
+                currentValueTo.toInt().toString(),
+            ),
+        )
+        b.sliderYearsRange.setValuesRounded(currentValueFrom, currentValueTo)
+    }
+
+    private fun onSavedPresetsChanged(value: FilterProperty<PersistableFilter>) {
+        val b = viewBinding ?: return
+        b.layoutSavedFilters.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val chips = value.availableItems.map { f ->
+            ChipsView.ChipModel(
+                title = f.name,
+                isChecked = f in value.selectedItems,
+                data = f,
+                isDropdown = true,
+            )
+        }
+        b.chipsSavedFilters.setChips(chips)
+    }
+
+    private fun showSavedFilterMenu(anchor: View, preset: PersistableFilter) {
+        val menu = PopupMenu(context ?: return, anchor)
+        val filter = FilterCoordinator.require(this)
+        menu.inflate(R.menu.popup_saved_filter)
+        menu.setOnMenuItemClickListener { menuItem ->
+            when (menuItem.itemId) {
+                R.id.action_delete -> filter.deleteSavedFilter(preset.id)
+                R.id.action_rename -> onRenameFilterClick(preset)
+            }
+            true
+        }
+        menu.show()
+    }
+
+    private fun onSaveFilterClick(name: String) {
+        val filter = FilterCoordinator.require(this)
+        val existingNames = filter.savedFilters.value.availableItems
+            .mapTo(TreeSet(AlphanumComparator()), PersistableFilter::name)
+        buildAlertDialog(context ?: return) {
+            val input = setEditText(
+                entries = existingNames.toList(),
+                inputType = EditorInfo.TYPE_CLASS_TEXT or EditorInfo.TYPE_TEXT_FLAG_CAP_SENTENCES,
+                singleLine = true,
+            )
+            input.setHint(R.string.enter_name)
+            input.setText(name)
+            input.filters += InputFilter.LengthFilter(MAX_TITLE_LENGTH)
+            setTitle(R.string.save_filter)
+            setPositiveButton(R.string.save) { _, _ ->
+                val text = input.text?.toString()?.trim()
+                if (text.isNullOrEmpty()) {
+                    Toast.makeText(context, R.string.invalid_value_message, Toast.LENGTH_SHORT).show()
+                    onSaveFilterClick("")
+                } else if (text in existingNames) {
+                    askForFilterOverwrite(filter, text)
+                } else {
+                    filter.saveCurrentFilter(text)
+                }
+            }
+            setNegativeButton(android.R.string.cancel, null)
+        }.show()
+    }
+
+    private fun onRenameFilterClick(preset: PersistableFilter) {
+        val filter = FilterCoordinator.require(this)
+        val existingNames = filter.savedFilters.value.availableItems.mapToSet { it.name }
+        buildAlertDialog(context ?: return) {
+            val input = setEditText(
+                inputType = EditorInfo.TYPE_CLASS_TEXT or EditorInfo.TYPE_TEXT_FLAG_CAP_SENTENCES,
+                singleLine = true,
+            )
+            input.filters += InputFilter.LengthFilter(MAX_TITLE_LENGTH)
+            input.setHint(R.string.enter_name)
+            input.setText(preset.name)
+            setTitle(R.string.rename)
+            setPositiveButton(R.string.save) { _, _ ->
+                val text = input.text?.toString()?.trim()
+                if (text.isNullOrEmpty() || text in existingNames) {
+                    Toast.makeText(context, R.string.invalid_value_message, Toast.LENGTH_SHORT).show()
+                } else {
+                    filter.renameSavedFilter(preset.id, text)
+                }
+            }
+            setNegativeButton(android.R.string.cancel, null)
+        }.show()
+    }
+
+    private fun askForFilterOverwrite(filter: FilterCoordinator, name: String) {
+        buildAlertDialog(context ?: return) {
+            setTitle(R.string.save_filter)
+            setMessage(getString(R.string.filter_overwrite_confirm, name))
+            setPositiveButton(R.string.overwrite) { _, _ ->
+                filter.saveCurrentFilter(name)
+            }
+            setNegativeButton(android.R.string.cancel) { _, _ ->
+                onSaveFilterClick(name)
+            }
+        }.show()
+    }
 }

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

@@ -43,6 +43,9 @@ import org.koitharu.kotatsu.parsers.model.Manga
 import java.time.Instant
 import java.util.concurrent.atomic.AtomicBoolean
 import javax.inject.Inject
+import org.koitharu.kotatsu.local.data.LocalStorageChanges
+import org.koitharu.kotatsu.local.domain.model.LocalManga
+import kotlinx.coroutines.flow.SharedFlow
 
 private const val PAGE_SIZE = 16
 
@@ -54,7 +57,8 @@ class HistoryListViewModel @Inject constructor(
 	private val markAsReadUseCase: MarkAsReadUseCase,
 	private val quickFilter: HistoryListQuickFilter,
 	mangaDataRepository: MangaDataRepository,
-) : MangaListViewModel(settings, mangaDataRepository), QuickFilterListener by quickFilter {
+	@LocalStorageChanges localStorageChanges: SharedFlow<LocalManga?>,
+) : MangaListViewModel(settings, mangaDataRepository, localStorageChanges), QuickFilterListener by quickFilter {
 
 	private val sortOrder: StateFlow<ListSortOrder> = settings.observeAsStateFlow(
 		scope = viewModelScope + Dispatchers.IO,

app/src/main/kotlin/org/koitharu/kotatsu/image/ui/CoverImageView.kt

@@ -2,14 +2,12 @@ package org.koitharu.kotatsu.image.ui
 
 import android.content.Context
 import android.graphics.drawable.LayerDrawable
-import android.os.Build
 import android.util.AttributeSet
 import android.view.Gravity
 import android.view.ViewGroup
 import android.view.ViewTreeObserver
 import android.view.ViewTreeObserver.OnPreDrawListener
 import androidx.annotation.AttrRes
-import androidx.annotation.RequiresApi
 import androidx.core.content.ContextCompat
 import androidx.core.content.withStyledAttributes
 import androidx.core.graphics.ColorUtils
@@ -83,9 +81,7 @@ class CoverImageView @JvmOverloads constructor(
 		if (fallbackDrawable == null) {
 			fallbackDrawable = context.getThemeColor(materialR.attr.colorSurfaceContainer).toDrawable()
 		}
-		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+		addImageRequestListener(ErrorForegroundListener())
-			addImageRequestListener(ErrorForegroundListener())
-		}
 	}
 
 	override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
@@ -169,7 +165,6 @@ class CoverImageView @JvmOverloads constructor(
 		}
 	}
 
-	@RequiresApi(Build.VERSION_CODES.M)
 	private inner class ErrorForegroundListener : ImageRequest.Listener {
 
 		override fun onSuccess(request: ImageRequest, result: SuccessResult) {
@@ -208,6 +203,7 @@ class CoverImageView @JvmOverloads constructor(
 			is HttpStatusException -> statusCode.toString()
 			is ContentUnavailableException,
 			is FileNotFoundException -> "404"
+
 			is TooManyRequestExceptions -> "429"
 			is ParseException -> "</>"
 			is UnsupportedSourceException -> "X"
@@ -269,7 +265,7 @@ class CoverImageView @JvmOverloads constructor(
 					width = Dimension(height.px * view.aspectRationWidth / view.aspectRationHeight)
 				}
 			}
-			return Size(checkNotNull(width), checkNotNull(height))
+			return Size(width, height)
 		}
 
 		private fun getWidth() = getDimension(

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

@@ -3,10 +3,12 @@ package org.koitharu.kotatsu.list.ui
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.plus
@@ -22,10 +24,13 @@ import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
 import org.koitharu.kotatsu.list.domain.ListFilterOption
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.local.data.LocalStorageChanges
+import org.koitharu.kotatsu.local.domain.model.LocalManga
 
 abstract class MangaListViewModel(
 	private val settings: AppSettings,
 	private val mangaDataRepository: MangaDataRepository,
+	@param:LocalStorageChanges private val localStorageChanges: SharedFlow<LocalManga?>,
 ) : BaseViewModel() {
 
 	abstract val content: StateFlow<List<ListModel>>
@@ -63,7 +68,11 @@ abstract class MangaListViewModel(
 
 	protected fun observeListModeWithTriggers(): Flow<ListMode> = combine(
 		listMode,
-		mangaDataRepository.observeOverridesTrigger(emitInitialState = true),
+		merge(
+			mangaDataRepository.observeOverridesTrigger(emitInitialState = true),
+			mangaDataRepository.observeFavoritesTrigger(emitInitialState = true),
+			localStorageChanges.onStart { emit(null) },
+		),
 		settings.observeChanges().filter { key ->
 			key == AppSettings.KEY_PROGRESS_INDICATORS
 				|| key == AppSettings.KEY_TRACKER_ENABLED

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

@@ -13,11 +13,11 @@ import androidx.annotation.WorkerThread
 import androidx.core.content.ContextCompat
 import androidx.core.net.toFile
 import dagger.Reusable
-import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.withContext
 import okhttp3.Cache
+import org.koitharu.kotatsu.core.LocalizedAppContext
 import org.koitharu.kotatsu.core.exceptions.NonFileUriException
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.ext.computeSize
@@ -39,8 +39,8 @@ private const val CACHE_SIZE_MAX: Long = 250 * 1024 * 1024 // 250MB
 
 @Reusable
 class LocalStorageManager @Inject constructor(
-	@ApplicationContext private val context: Context,
+    @LocalizedAppContext private val context: Context,
-	private val settings: AppSettings,
+    private val settings: AppSettings,
 ) {
 
 	val contentResolver: ContentResolver

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

@@ -27,7 +27,6 @@ import org.koitharu.kotatsu.parsers.util.json.getLongOrDefault
 import org.koitharu.kotatsu.parsers.util.json.getStringOrNull
 import org.koitharu.kotatsu.parsers.util.json.mapJSONToSet
 import org.koitharu.kotatsu.parsers.util.json.toStringSet
-import org.koitharu.kotatsu.parsers.util.nullIfEmpty
 import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import org.koitharu.kotatsu.parsers.util.toTitleCase
 import java.io.File

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

@@ -61,7 +61,9 @@ class LocalMangaParser(private val uri: Uri) {
 			val index = MangaIndex.read(fileSystem, rootPath / ENTRY_NAME_INDEX)
 			val mangaInfo = index?.getMangaInfo()
 			if (mangaInfo != null) {
-				val coverEntry: Path? = index.getCoverEntry()?.let { rootPath / it }
+				val coverEntry: Path? = index.getCoverEntry()?.let { rootPath / it }?.takeIf {
+					fileSystem.exists(it)
+				}
 				mangaInfo.copy(
 					source = LocalMangaSource,
 					url = rootFile.toUri().toString(),

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

@@ -45,7 +45,7 @@ class LocalListViewModel @Inject constructor(
 	mangaListMapper: MangaListMapper,
 	private val deleteLocalMangaUseCase: DeleteLocalMangaUseCase,
 	exploreRepository: ExploreRepository,
-	@LocalStorageChanges private val localStorageChanges: SharedFlow<LocalManga?>,
+	@param:LocalStorageChanges private val localStorageChanges: SharedFlow<LocalManga?>,
 	private val localStorageManager: LocalStorageManager,
 	sourcesRepository: MangaSourcesRepository,
 	mangaDataRepository: MangaDataRepository,
@@ -58,6 +58,7 @@ class LocalListViewModel @Inject constructor(
 	exploreRepository = exploreRepository,
 	sourcesRepository = sourcesRepository,
 	mangaDataRepository = mangaDataRepository,
+	localStorageChanges = localStorageChanges,
 ), SharedPreferences.OnSharedPreferenceChangeListener, QuickFilterListener {
 
 	val onMangaRemoved = MutableEventFlow<Unit>()

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

@@ -1,6 +1,8 @@
 package org.koitharu.kotatsu.main.ui
 
 import android.Manifest
+import android.app.BackgroundServiceStartNotAllowedException
+import android.app.ServiceStartNotAllowedException
 import android.content.Intent
 import android.content.pm.PackageManager.PERMISSION_GRANTED
 import android.os.Build
@@ -58,6 +60,7 @@ import org.koitharu.kotatsu.core.util.ext.consume
 import org.koitharu.kotatsu.core.util.ext.end
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
+import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import org.koitharu.kotatsu.core.util.ext.start
 import org.koitharu.kotatsu.databinding.ActivityMainBinding
 import org.koitharu.kotatsu.details.service.MangaPrefetchService
@@ -131,7 +134,7 @@ class MainActivity : BaseActivity<ActivityMainBinding>(), AppBarOwner, BottomNav
 		onBackPressedDispatcher.addCallback(exitCallback)
 		onBackPressedDispatcher.addCallback(navigationDelegate)
 
-		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU || !resources.getBoolean(R.bool.is_predictive_back_enabled)) {
 			val legacySearchCallback = SearchViewLegacyBackCallback(viewBinding.searchView)
 			viewBinding.searchView.addTransitionListener(legacySearchCallback)
 			onBackPressedDispatcher.addCallback(legacySearchCallback)
@@ -288,7 +291,7 @@ class MainActivity : BaseActivity<ActivityMainBinding>(), AppBarOwner, BottomNav
 		adjustFabVisibility(isResumeEnabled = isEnabled)
 	}
 
-	private fun onFirstStart() {
+	private fun onFirstStart() = try {
 		lifecycleScope.launch(Dispatchers.Main) { // not a default `Main.immediate` dispatcher
 			withContext(Dispatchers.Default) {
 				LocalStorageCleanupWorker.enqueue(applicationContext)
@@ -303,6 +306,8 @@ class MainActivity : BaseActivity<ActivityMainBinding>(), AppBarOwner, BottomNav
 				}
 			}
 		}
+	} catch (e: IllegalStateException) {
+		e.printStackTraceDebug()
 	}
 
 	private fun adjustAppbar(topFragment: Fragment) {

app/src/main/kotlin/org/koitharu/kotatsu/main/ui/welcome/WelcomeSheet.kt

@@ -51,6 +51,7 @@ class WelcomeSheet : BaseAdaptiveSheet<SheetWelcomeBinding>(), ChipsView.OnChipC
 		binding.chipsType.onChipClickListener = this
 		binding.chipBackup.setOnClickListener(this)
 		binding.chipSync.setOnClickListener(this)
+		binding.chipDirectories.setOnClickListener(this)
 
 		viewModel.locales.observe(viewLifecycleOwner, ::onLocalesChanged)
 		viewModel.types.observe(viewLifecycleOwner, ::onTypesChanged)
@@ -86,6 +87,10 @@ class WelcomeSheet : BaseAdaptiveSheet<SheetWelcomeBinding>(), ChipsView.OnChipC
 				val accountType = getString(R.string.account_type_sync)
 				am.addAccount(accountType, accountType, null, null, requireActivity(), null, null)
 			}
+
+            R.id.chip_directories -> {
+                router.openDirectoriesSettings()
+            }
 		}
 	}
 

app/src/main/kotlin/org/koitharu/kotatsu/picker/ui/manga/MangaPickerViewModel.kt

@@ -20,6 +20,9 @@ import org.koitharu.kotatsu.list.ui.model.ListHeader
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.LoadingState
 import javax.inject.Inject
+import kotlinx.coroutines.flow.SharedFlow
+import org.koitharu.kotatsu.local.data.LocalStorageChanges
+import org.koitharu.kotatsu.local.domain.model.LocalManga
 
 @HiltViewModel
 class MangaPickerViewModel @Inject constructor(
@@ -28,7 +31,8 @@ class MangaPickerViewModel @Inject constructor(
 	private val historyRepository: HistoryRepository,
 	private val favouritesRepository: FavouritesRepository,
 	private val mangaListMapper: MangaListMapper,
-) : MangaListViewModel(settings, mangaDataRepository) {
+	@LocalStorageChanges localStorageChanges: SharedFlow<LocalManga?>,
+) : MangaListViewModel(settings, mangaDataRepository, localStorageChanges) {
 
 	override val content: StateFlow<List<ListModel>>
 		get() = flow {

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

@@ -1,6 +1,7 @@
 package org.koitharu.kotatsu.reader.domain
 
 import android.util.LongSparseArray
+import androidx.annotation.CheckResult
 import dagger.hilt.android.scopes.ViewModelScoped
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -32,12 +33,12 @@ class ChaptersLoader @Inject constructor(
 		}
 	}
 
-	suspend fun loadPrevNextChapter(manga: MangaDetails, currentId: Long, isNext: Boolean) {
+	suspend fun loadPrevNextChapter(manga: MangaDetails, currentId: Long, isNext: Boolean): Boolean {
 		val chapters = manga.allChapters
 		val predicate: (MangaChapter) -> Boolean = { it.id == currentId }
 		val index = if (isNext) chapters.indexOfFirst(predicate) else chapters.indexOfLast(predicate)
-		if (index == -1) return
+		if (index == -1) return false
-		val newChapter = chapters.getOrNull(if (isNext) index + 1 else index - 1) ?: return
+		val newChapter = chapters.getOrNull(if (isNext) index + 1 else index - 1) ?: return false
 		val newPages = loadChapter(newChapter.id)
 		mutex.withLock {
 			if (chapterPages.chaptersSize > 1) {
@@ -56,13 +57,16 @@ class ChaptersLoader @Inject constructor(
 				chapterPages.addFirst(newChapter.id, newPages)
 			}
 		}
+		return true
 	}
 
-	suspend fun loadSingleChapter(chapterId: Long) {
+	@CheckResult
+	suspend fun loadSingleChapter(chapterId: Long): Boolean {
 		val pages = loadChapter(chapterId)
-		mutex.withLock {
+		return mutex.withLock {
 			chapterPages.clear()
 			chapterPages.addLast(chapterId, pages)
+			pages.isNotEmpty()
 		}
 	}
 

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

@@ -8,11 +8,9 @@ import android.graphics.Rect
 import androidx.annotation.ColorInt
 import androidx.core.graphics.alpha
 import androidx.core.graphics.blue
-import androidx.core.graphics.get
 import androidx.core.graphics.green
 import androidx.core.graphics.red
 import com.davemorrissey.labs.subscaleview.ImageSource
-import com.davemorrissey.labs.subscaleview.decoder.ImageRegionDecoder
 import com.davemorrissey.labs.subscaleview.decoder.SkiaPooledImageRegionDecoder
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
@@ -23,7 +21,6 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.core.util.SynchronizedSieveCache
-import org.koitharu.kotatsu.core.util.ext.use
 import kotlin.math.abs
 import kotlin.math.max
 import kotlin.math.min
@@ -49,16 +46,16 @@ class EdgeDetector(private val context: Context) {
 
 					val fullBitmap = decoder.decodeRegion(
 						Rect(0, 0, size.x, size.y),
-						sampleSize
+						sampleSize,
 					)
 
 					try {
 						val edges = coroutineScope {
 							listOf(
-							async { detectLeftRightEdge(fullBitmap, size, sampleSize, isLeft = true) },
+								async { detectLeftRightEdge(fullBitmap, size, sampleSize, isLeft = true) },
-							async { detectTopBottomEdge(fullBitmap, size, sampleSize, isTop = true) },
+								async { detectTopBottomEdge(fullBitmap, size, sampleSize, isTop = true) },
-							async { detectLeftRightEdge(fullBitmap, size, sampleSize, isLeft = false) },
+								async { detectLeftRightEdge(fullBitmap, size, sampleSize, isLeft = false) },
-							async { detectTopBottomEdge(fullBitmap, size, sampleSize, isTop = false) },
+								async { detectTopBottomEdge(fullBitmap, size, sampleSize, isTop = false) },
 							).awaitAll()
 						}
 						var hasEdges = false

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

@@ -49,7 +49,7 @@ class ReaderManager(
 	fun setDoubleReaderMode(isEnabled: Boolean) {
 		val mode = currentMode
 		val prevReader = currentReader?.javaClass
-		invalidateTypesMap(isEnabled && isLandscape())
+		invalidateTypesMap(isEnabled)
 		val newReader = modeMap[mode]
 		if (mode != null && newReader != prevReader) {
 			replace(mode)

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

@@ -10,7 +10,9 @@ import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
 import androidx.fragment.app.activityViewModels
+import androidx.transition.TransitionManager
 import com.google.android.material.button.MaterialButtonToggleGroup
+import com.google.android.material.slider.Slider
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
@@ -25,7 +27,9 @@ import org.koitharu.kotatsu.core.ui.sheet.BaseAdaptiveSheet
 import org.koitharu.kotatsu.core.util.ext.consume
 import org.koitharu.kotatsu.core.util.ext.findParentCallback
 import org.koitharu.kotatsu.core.util.ext.observe
+import org.koitharu.kotatsu.core.util.ext.setValueRounded
 import org.koitharu.kotatsu.core.util.ext.viewLifecycleScope
+import org.koitharu.kotatsu.core.util.progress.IntPercentLabelFormatter
 import org.koitharu.kotatsu.databinding.SheetReaderConfigBinding
 import org.koitharu.kotatsu.reader.domain.PageLoader
 import org.koitharu.kotatsu.reader.ui.ReaderViewModel
@@ -34,206 +38,244 @@ import javax.inject.Inject
 
 @AndroidEntryPoint
 class ReaderConfigSheet :
-	BaseAdaptiveSheet<SheetReaderConfigBinding>(),
+    BaseAdaptiveSheet<SheetReaderConfigBinding>(),
-	View.OnClickListener,
+    View.OnClickListener,
-	MaterialButtonToggleGroup.OnButtonCheckedListener,
+    MaterialButtonToggleGroup.OnButtonCheckedListener,
-	CompoundButton.OnCheckedChangeListener {
+    CompoundButton.OnCheckedChangeListener,
-
+    Slider.OnChangeListener {
-	private val viewModel by activityViewModels<ReaderViewModel>()
+
-
+    private val viewModel by activityViewModels<ReaderViewModel>()
-	@Inject
+
-	lateinit var orientationHelper: ScreenOrientationHelper
+    @Inject
-
+    lateinit var orientationHelper: ScreenOrientationHelper
-	@Inject
+
-	lateinit var mangaRepositoryFactory: MangaRepository.Factory
+    @Inject
-
+    lateinit var mangaRepositoryFactory: MangaRepository.Factory
-	@Inject
+
-	lateinit var pageLoader: PageLoader
+    @Inject
-
+    lateinit var pageLoader: PageLoader
-	private lateinit var mode: ReaderMode
+
-	private lateinit var imageServerDelegate: ImageServerDelegate
+    private lateinit var mode: ReaderMode
-
+    private lateinit var imageServerDelegate: ImageServerDelegate
-	@Inject
+
-	lateinit var settings: AppSettings
+    @Inject
-
+    lateinit var settings: AppSettings
-	override fun onCreate(savedInstanceState: Bundle?) {
+
-		super.onCreate(savedInstanceState)
+    override fun onCreate(savedInstanceState: Bundle?) {
-		mode = arguments?.getInt(AppRouter.KEY_READER_MODE)
+        super.onCreate(savedInstanceState)
-			?.let { ReaderMode.valueOf(it) }
+        mode = arguments?.getInt(AppRouter.KEY_READER_MODE)
-			?: ReaderMode.STANDARD
+            ?.let { ReaderMode.valueOf(it) }
-		imageServerDelegate = ImageServerDelegate(
+            ?: ReaderMode.STANDARD
-			mangaRepositoryFactory = mangaRepositoryFactory,
+        imageServerDelegate = ImageServerDelegate(
-			mangaSource = viewModel.getMangaOrNull()?.source,
+            mangaRepositoryFactory = mangaRepositoryFactory,
-		)
+            mangaSource = viewModel.getMangaOrNull()?.source,
-	}
+        )
-
+    }
-	override fun onCreateViewBinding(
+
-		inflater: LayoutInflater,
+    override fun onCreateViewBinding(
-		container: ViewGroup?,
+        inflater: LayoutInflater,
-	): SheetReaderConfigBinding {
+        container: ViewGroup?,
-		return SheetReaderConfigBinding.inflate(inflater, container, false)
+    ): SheetReaderConfigBinding {
-	}
+        return SheetReaderConfigBinding.inflate(inflater, container, false)
-
+    }
-	override fun onViewBindingCreated(
+
-		binding: SheetReaderConfigBinding,
+    override fun onViewBindingCreated(
-		savedInstanceState: Bundle?,
+        binding: SheetReaderConfigBinding,
-	) {
+        savedInstanceState: Bundle?,
-		super.onViewBindingCreated(binding, savedInstanceState)
+    ) {
-		observeScreenOrientation()
+        super.onViewBindingCreated(binding, savedInstanceState)
-		binding.buttonStandard.isChecked = mode == ReaderMode.STANDARD
+        observeScreenOrientation()
-		binding.buttonReversed.isChecked = mode == ReaderMode.REVERSED
+        binding.buttonStandard.isChecked = mode == ReaderMode.STANDARD
-		binding.buttonWebtoon.isChecked = mode == ReaderMode.WEBTOON
+        binding.buttonReversed.isChecked = mode == ReaderMode.REVERSED
-		binding.buttonVertical.isChecked = mode == ReaderMode.VERTICAL
+        binding.buttonWebtoon.isChecked = mode == ReaderMode.WEBTOON
-		binding.switchDoubleReader.isChecked = settings.isReaderDoubleOnLandscape
+        binding.buttonVertical.isChecked = mode == ReaderMode.VERTICAL
-		binding.switchDoubleReader.isEnabled = mode == ReaderMode.STANDARD || mode == ReaderMode.REVERSED
+        binding.switchDoubleReader.isChecked = settings.isReaderDoubleOnLandscape
-
+        binding.switchDoubleReader.isEnabled = mode == ReaderMode.STANDARD || mode == ReaderMode.REVERSED
-		binding.checkableGroup.addOnButtonCheckedListener(this)
+        binding.switchDoubleFoldable.isChecked = settings.isReaderDoubleOnFoldable
-		binding.buttonSavePage.setOnClickListener(this)
+        binding.switchDoubleFoldable.isEnabled = binding.switchDoubleReader.isEnabled
-		binding.buttonScreenRotate.setOnClickListener(this)
+        binding.sliderDoubleSensitivity.setValueRounded(settings.readerDoublePagesSensitivity * 100f)
-		binding.buttonSettings.setOnClickListener(this)
+        binding.sliderDoubleSensitivity.setLabelFormatter(IntPercentLabelFormatter(binding.root.context))
-		binding.buttonImageServer.setOnClickListener(this)
+        binding.adjustSensitivitySlider(withAnimation = false)
-		binding.buttonColorFilter.setOnClickListener(this)
+
-		binding.buttonScrollTimer.setOnClickListener(this)
+        binding.checkableGroup.addOnButtonCheckedListener(this)
-		binding.buttonBookmark.setOnClickListener(this)
+        binding.buttonSavePage.setOnClickListener(this)
-		binding.switchDoubleReader.setOnCheckedChangeListener(this)
+        binding.buttonScreenRotate.setOnClickListener(this)
-
+        binding.buttonSettings.setOnClickListener(this)
-		viewModel.isBookmarkAdded.observe(viewLifecycleOwner) {
+        binding.buttonImageServer.setOnClickListener(this)
-			binding.buttonBookmark.setText(if (it) R.string.bookmark_remove else R.string.bookmark_add)
+        binding.buttonColorFilter.setOnClickListener(this)
-			binding.buttonBookmark.setCompoundDrawablesRelativeWithIntrinsicBounds(
+        binding.buttonScrollTimer.setOnClickListener(this)
-				if (it) R.drawable.ic_bookmark_checked else R.drawable.ic_bookmark, 0, 0, 0,
+        binding.buttonBookmark.setOnClickListener(this)
-			)
+        binding.switchDoubleReader.setOnCheckedChangeListener(this)
-		}
+        binding.switchDoubleFoldable.setOnCheckedChangeListener(this)
-
+        binding.sliderDoubleSensitivity.addOnChangeListener(this)
-		viewLifecycleScope.launch {
+
-			val isAvailable = imageServerDelegate.isAvailable()
+        viewModel.isBookmarkAdded.observe(viewLifecycleOwner) {
-			if (isAvailable) {
+            binding.buttonBookmark.setText(if (it) R.string.bookmark_remove else R.string.bookmark_add)
-				bindImageServerTitle()
+            binding.buttonBookmark.setCompoundDrawablesRelativeWithIntrinsicBounds(
-			}
+                if (it) R.drawable.ic_bookmark_checked else R.drawable.ic_bookmark, 0, 0, 0,
-			binding.buttonImageServer.isVisible = isAvailable
+            )
-		}
+        }
-	}
+
-
+        viewLifecycleScope.launch {
-	override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+            val isAvailable = imageServerDelegate.isAvailable()
-		val typeMask = WindowInsetsCompat.Type.systemBars()
+            if (isAvailable) {
-		viewBinding?.scrollView?.updatePadding(
+                bindImageServerTitle()
-			bottom = insets.getInsets(typeMask).bottom,
+            }
-		)
+            binding.buttonImageServer.isVisible = isAvailable
-		return insets.consume(v, typeMask, bottom = true)
+        }
-	}
+    }
-
+
-	override fun onClick(v: View) {
+    override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
-		when (v.id) {
+        val typeMask = WindowInsetsCompat.Type.systemBars()
-			R.id.button_settings -> {
+        viewBinding?.scrollView?.updatePadding(
-				router.openReaderSettings()
+            bottom = insets.getInsets(typeMask).bottom,
-				dismissAllowingStateLoss()
+        )
-			}
+        return insets.consume(v, typeMask, bottom = true)
-
+    }
-			R.id.button_scroll_timer -> {
+
-				findParentCallback(Callback::class.java)?.onScrollTimerClick(false) ?: return
+    override fun onClick(v: View) {
-				dismissAllowingStateLoss()
+        when (v.id) {
-			}
+            R.id.button_settings -> {
-
+                router.openReaderSettings()
-			R.id.button_save_page -> {
+                dismissAllowingStateLoss()
-				findParentCallback(Callback::class.java)?.onSavePageClick() ?: return
+            }
-				dismissAllowingStateLoss()
+
-			}
+            R.id.button_scroll_timer -> {
-
+                findParentCallback(Callback::class.java)?.onScrollTimerClick(false) ?: return
-			R.id.button_screen_rotate -> {
+                dismissAllowingStateLoss()
-				orientationHelper.isLandscape = !orientationHelper.isLandscape
+            }
-			}
+
-
+            R.id.button_save_page -> {
-			R.id.button_bookmark -> {
+                findParentCallback(Callback::class.java)?.onSavePageClick() ?: return
-				viewModel.toggleBookmark()
+                dismissAllowingStateLoss()
-			}
+            }
-
+
-			R.id.button_color_filter -> {
+            R.id.button_screen_rotate -> {
-				val page = viewModel.getCurrentPage() ?: return
+                orientationHelper.isLandscape = !orientationHelper.isLandscape
-				val manga = viewModel.getMangaOrNull() ?: return
+            }
-				router.openColorFilterConfig(manga, page)
+
-			}
+            R.id.button_bookmark -> {
-
+                viewModel.toggleBookmark()
-			R.id.button_image_server -> viewLifecycleScope.launch {
+            }
-				if (imageServerDelegate.showDialog(v.context)) {
+
-					bindImageServerTitle()
+            R.id.button_color_filter -> {
-					pageLoader.invalidate(clearCache = true)
+                val page = viewModel.getCurrentPage() ?: return
-					viewModel.switchChapterBy(0)
+                val manga = viewModel.getMangaOrNull() ?: return
-				}
+                router.openColorFilterConfig(manga, page)
-			}
+            }
-		}
+
-	}
+            R.id.button_image_server -> viewLifecycleScope.launch {
-
+                if (imageServerDelegate.showDialog(v.context)) {
-	override fun onCheckedChanged(buttonView: CompoundButton, isChecked: Boolean) {
+                    bindImageServerTitle()
-		when (buttonView.id) {
+                    pageLoader.invalidate(clearCache = true)
-			R.id.switch_screen_lock_rotation -> {
+                    viewModel.switchChapterBy(0)
-				orientationHelper.isLocked = isChecked
+                }
-			}
+            }
-
+        }
-			R.id.switch_double_reader -> {
+    }
-				settings.isReaderDoubleOnLandscape = isChecked
+
-				findParentCallback(Callback::class.java)?.onDoubleModeChanged(isChecked)
+    override fun onCheckedChanged(buttonView: CompoundButton, isChecked: Boolean) {
-			}
+        when (buttonView.id) {
-		}
+            R.id.switch_screen_lock_rotation -> {
-	}
+                orientationHelper.isLocked = isChecked
-
+            }
-	override fun onButtonChecked(
+
-		group: MaterialButtonToggleGroup?,
+            R.id.switch_double_reader -> {
-		checkedId: Int,
+                settings.isReaderDoubleOnLandscape = isChecked
-		isChecked: Boolean,
+                viewBinding?.adjustSensitivitySlider(withAnimation = true)
-	) {
+                findParentCallback(Callback::class.java)?.onDoubleModeChanged(isChecked)
-		if (!isChecked) {
+            }
-			return
+
-		}
+            R.id.switch_double_foldable -> {
-		val newMode = when (checkedId) {
+                settings.isReaderDoubleOnFoldable = isChecked
-			R.id.button_standard -> ReaderMode.STANDARD
+                // Re-evaluate double-page considering foldable state and current manual toggle
-			R.id.button_webtoon -> ReaderMode.WEBTOON
+                findParentCallback(Callback::class.java)?.onDoubleModeChanged(settings.isReaderDoubleOnLandscape)
-			R.id.button_reversed -> ReaderMode.REVERSED
+            }
-			R.id.button_vertical -> ReaderMode.VERTICAL
+        }
-			else -> return
+    }
-		}
+
-		viewBinding?.switchDoubleReader?.isEnabled = newMode == ReaderMode.STANDARD || newMode == ReaderMode.REVERSED
+    override fun onValueChange(slider: Slider, value: Float, fromUser: Boolean) {
-		if (newMode == mode) {
+        settings.readerDoublePagesSensitivity = value / 100f
-			return
+    }
-		}
+
-		findParentCallback(Callback::class.java)?.onReaderModeChanged(newMode) ?: return
+    override fun onButtonChecked(
-		mode = newMode
+        group: MaterialButtonToggleGroup?,
-	}
+        checkedId: Int,
-
+        isChecked: Boolean,
-	private fun observeScreenOrientation() {
+    ) {
-		orientationHelper.observeAutoOrientation()
+        if (!isChecked) {
-			.onEach {
+            return
-				with(requireViewBinding()) {
+        }
-					buttonScreenRotate.isGone = it
+        val newMode = when (checkedId) {
-					switchScreenLockRotation.isVisible = it
+            R.id.button_standard -> ReaderMode.STANDARD
-					updateOrientationLockSwitch()
+            R.id.button_webtoon -> ReaderMode.WEBTOON
-				}
+            R.id.button_reversed -> ReaderMode.REVERSED
-			}.launchIn(viewLifecycleScope)
+            R.id.button_vertical -> ReaderMode.VERTICAL
-	}
+            else -> return
-
+        }
-	private fun updateOrientationLockSwitch() {
+        viewBinding?.run {
-		val switch = viewBinding?.switchScreenLockRotation ?: return
+            switchDoubleReader.isEnabled = newMode == ReaderMode.STANDARD || newMode == ReaderMode.REVERSED
-		switch.setOnCheckedChangeListener(null)
+            switchDoubleFoldable.isEnabled = switchDoubleReader.isEnabled
-		switch.isChecked = orientationHelper.isLocked
+            adjustSensitivitySlider(withAnimation = true)
-		switch.setOnCheckedChangeListener(this)
+        }
-	}
+        if (newMode == mode) {
-
+            return
-	private suspend fun bindImageServerTitle() {
+        }
-		viewBinding?.buttonImageServer?.text = getString(
+        findParentCallback(Callback::class.java)?.onReaderModeChanged(newMode) ?: return
-			R.string.inline_preference_pattern,
+        mode = newMode
-			getString(R.string.image_server),
+    }
-			imageServerDelegate.getValue() ?: getString(R.string.automatic),
+
-		)
+    private fun observeScreenOrientation() {
-	}
+        orientationHelper.observeAutoOrientation()
-
+            .onEach {
-	interface Callback {
+                with(requireViewBinding()) {
-
+                    buttonScreenRotate.isGone = it
-		fun onReaderModeChanged(mode: ReaderMode)
+                    switchScreenLockRotation.isVisible = it
-
+                    updateOrientationLockSwitch()
-		fun onDoubleModeChanged(isEnabled: Boolean)
+                }
-
+            }.launchIn(viewLifecycleScope)
-		fun onSavePageClick()
+    }
-
+
-		fun onScrollTimerClick(isLongClick: Boolean)
+    private fun updateOrientationLockSwitch() {
-
+        val switch = viewBinding?.switchScreenLockRotation ?: return
-		fun onBookmarkClick()
+        switch.setOnCheckedChangeListener(null)
-	}
+        switch.isChecked = orientationHelper.isLocked
+        switch.setOnCheckedChangeListener(this)
+    }
+
+    private suspend fun bindImageServerTitle() {
+        viewBinding?.buttonImageServer?.text = getString(
+            R.string.inline_preference_pattern,
+            getString(R.string.image_server),
+            imageServerDelegate.getValue() ?: getString(R.string.automatic),
+        )
+    }
+
+    private fun SheetReaderConfigBinding.adjustSensitivitySlider(withAnimation: Boolean) {
+        val isSubOptionsVisible = switchDoubleReader.isEnabled && switchDoubleReader.isChecked
+        val needTransition = withAnimation && (
+            (isSubOptionsVisible != sliderDoubleSensitivity.isVisible) ||
+                (isSubOptionsVisible != textDoubleSensitivity.isVisible) ||
+                (isSubOptionsVisible != switchDoubleFoldable.isVisible)
+            )
+        if (needTransition) {
+            TransitionManager.beginDelayedTransition(layoutMain)
+        }
+        sliderDoubleSensitivity.isVisible = isSubOptionsVisible
+        textDoubleSensitivity.isVisible = isSubOptionsVisible
+        switchDoubleFoldable.isVisible = isSubOptionsVisible
+    }
+
+    interface Callback {
+
+        fun onReaderModeChanged(mode: ReaderMode)
+
+        fun onDoubleModeChanged(isEnabled: Boolean)
+
+        fun onSavePageClick()
+
+        fun onScrollTimerClick(isLongClick: Boolean)
+
+        fun onBookmarkClick()
+    }
 }

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

@@ -25,11 +25,26 @@ abstract class BaseReaderFragment<B : ViewBinding> : BaseFragment<B>(), ZoomCont
 		readerAdapter = onCreateAdapter()
 
 		viewModel.content.observe(viewLifecycleOwner) {
-			if (it.state == null && it.pages.isNotEmpty() && readerAdapter?.hasItems != true) {
+			// Determine which state to use for restoring position:
-				onPagesChanged(it.pages, viewModel.getCurrentState())
+			// - content.state: explicitly set state (e.g., after mode switch or chapter change)
-			} else {
+			// - getCurrentState(): current reading position saved in SavedStateHandle
-				onPagesChanged(it.pages, it.state)
+			val currentState = viewModel.getCurrentState()
+			val pendingState = when {
+				// If content.state is null and we have pages, use getCurrentState
+				it.state == null
+					&& it.pages.isNotEmpty()
+					&& readerAdapter?.hasItems != true -> currentState
+
+				// use currentState only if it matches the current pages (to avoid the error message)
+				readerAdapter?.hasItems != true
+					&& it.state != currentState
+					&& currentState != null
+					&& it.pages.any { page -> page.chapterId == currentState.chapterId } -> currentState
+
+				// Otherwise, use content.state (normal flow, mode switch, chapter change)
+				else -> it.state
 			}
+			onPagesChanged(it.pages, pendingState)
 		}
 	}
 

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

@@ -11,11 +11,14 @@ import androidx.recyclerview.widget.OrientationHelper
 import androidx.recyclerview.widget.RecyclerView
 import androidx.recyclerview.widget.RecyclerView.SmoothScroller.ScrollVectorProvider
 import androidx.recyclerview.widget.SnapHelper
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import kotlin.math.abs
+import kotlin.math.absoluteValue
 import kotlin.math.max
 import kotlin.math.roundToInt
+import kotlin.math.sign
 
-class DoublePageSnapHelper : SnapHelper() {
+class DoublePageSnapHelper(private val settings: AppSettings) : SnapHelper() {
 
 	private lateinit var recyclerView: RecyclerView
 
@@ -248,28 +251,27 @@ class DoublePageSnapHelper : SnapHelper() {
 			equal to zero.
 		 */
 		fun getPositionsToMove(llm: LinearLayoutManager, scroll: Int, itemSize: Int): Int {
-			var positionsToMove: Int
+			val sensitivity = settings.readerDoublePagesSensitivity.coerceIn(0f, 1f) * 2.5
-			positionsToMove = roundUpToBlockSize(abs((scroll.toDouble()) / itemSize).roundToInt())
+			var positionsToMove = (scroll.toDouble() / (itemSize * (2.5 - sensitivity))).roundToInt()
-			if (positionsToMove < blockSize) {
+
-				// Must move at least one block
+			// Apply a maximum threshold
-				positionsToMove = blockSize
+			val maxPages = (4 * sensitivity).roundToInt().coerceAtLeast(1)
-			} else if (positionsToMove > maxPositionsToMove) {
+			if (positionsToMove.absoluteValue > maxPages) {
-				// Clamp number of positions to move, so we don't get wild flinging.
+				positionsToMove = maxPages * positionsToMove.sign
-				positionsToMove = maxPositionsToMove
-			}
-			if (scroll < 0) {
-				positionsToMove *= -1
 			}
-			if (isRTL) {
+
-				positionsToMove *= -1
+			// Apply a minimum threshold
+			if (positionsToMove == 0 && scroll.absoluteValue > itemSize * 0.2) {
+				positionsToMove = 1 * scroll.sign
 			}
-			return if (layoutDirectionHelper.isDirectionToBottom(scroll < 0)) {
+
-				// Scrolling toward the bottom of data.
+			val currentPosition = if (layoutDirectionHelper.isDirectionToBottom(scroll < 0)) {
-				roundDownToBlockSize(llm.findFirstVisibleItemPosition()) + positionsToMove
+				llm.findFirstVisibleItemPosition()
 			} else {
-				roundDownToBlockSize(llm.findLastVisibleItemPosition()) + positionsToMove
+				llm.findLastVisibleItemPosition()
 			}
-			// Scrolling toward the top of the data.
+			val targetPos = currentPosition + positionsToMove * 2
+			return roundDownToBlockSize(targetPos)
 		}
 
 		fun isDirectionToBottom(velocityNegative: Boolean): Boolean {