Update parsers

Currently translated at 100.0% (893 of 893 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
@@ -26,4 +27,4 @@
 .cxx
 /.idea/deviceManager.xml
 /.kotlin/
-/.idea/AndroidProjectSystem.xml
+/.idea/AndroidProjectSystem.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>
-        <option name="USE_TAB_CHARACTER" value="true" />
-      </value>
+      <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$" />
@@ -16,4 +16,4 @@
       </GradleProjectSettings>
     </option>
   </component>
-</project>
+</project>

README.md

@@ -8,7 +8,7 @@
 
 **[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)
+![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 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)
 
 ### Download
 
@@ -35,7 +35,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>
 
@@ -112,6 +112,6 @@ 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 = 1024
-		versionName = '9.1'
+		versionCode = 1032
+		versionName = '9.4'
 		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'
 		]
 	}

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/alternatives/ui/AutoFixService.kt

@@ -17,6 +17,7 @@ import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.runBlocking
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.alternatives.domain.AutoFixUseCase
+import org.koitharu.kotatsu.alternatives.domain.AutoFixUseCase.NoAlternativesException
 import org.koitharu.kotatsu.core.ErrorReporterReceiver
 import org.koitharu.kotatsu.core.model.getTitle
 import org.koitharu.kotatsu.core.model.isNsfw
@@ -47,7 +48,7 @@ class AutoFixService : CoroutineIntentService() {
 
 	override fun onCreate() {
 		super.onCreate()
-		notificationManager = NotificationManagerCompat.from(applicationContext)
+		notificationManager = NotificationManagerCompat.from(this)
 	}
 
 	override suspend fun IntentJobContext.processIntent(intent: Intent) {
@@ -58,7 +59,7 @@ class AutoFixService : CoroutineIntentService() {
 				val result = runCatchingCancellable {
 					autoFixUseCase.invoke(mangaId)
 				}
-				if (applicationContext.checkNotificationPermission(CHANNEL_ID)) {
+				if (checkNotificationPermission(CHANNEL_ID)) {
 					val notification = buildNotification(startId, result)
 					notificationManager.notify(TAG, startId, notification)
 				}
@@ -67,7 +68,7 @@ class AutoFixService : CoroutineIntentService() {
 	}
 
 	override fun IntentJobContext.onError(error: Throwable) {
-		if (applicationContext.checkNotificationPermission(CHANNEL_ID)) {
+		if (checkNotificationPermission(CHANNEL_ID)) {
 			val notification = runBlocking { buildNotification(startId, Result.failure(error)) }
 			notificationManager.notify(TAG, startId, notification)
 		}
@@ -75,7 +76,7 @@ class AutoFixService : CoroutineIntentService() {
 
 	@SuppressLint("InlinedApi")
 	private fun startForeground(jobContext: IntentJobContext) {
-		val title = applicationContext.getString(R.string.fixing_manga)
+		val title = getString(R.string.fixing_manga)
 		val channel = NotificationChannelCompat.Builder(CHANNEL_ID, NotificationManagerCompat.IMPORTANCE_MIN)
 			.setName(title)
 			.setShowBadge(false)
@@ -85,7 +86,7 @@ class AutoFixService : CoroutineIntentService() {
 			.build()
 		notificationManager.createNotificationChannel(channel)
 
-		val notification = NotificationCompat.Builder(applicationContext, CHANNEL_ID)
+		val notification = NotificationCompat.Builder(this, CHANNEL_ID)
 			.setContentTitle(title)
 			.setPriority(NotificationCompat.PRIORITY_MIN)
 			.setDefaults(0)
@@ -97,7 +98,7 @@ class AutoFixService : CoroutineIntentService() {
 			.setCategory(NotificationCompat.CATEGORY_PROGRESS)
 			.addAction(
 				appcompatR.drawable.abc_ic_clear_material,
-				applicationContext.getString(android.R.string.cancel),
+				getString(android.R.string.cancel),
 				jobContext.getCancelIntent(),
 			)
 			.build()
@@ -110,7 +111,7 @@ class AutoFixService : CoroutineIntentService() {
 	}
 
 	private suspend fun buildNotification(startId: Int, result: Result<Pair<Manga, Manga?>>): Notification {
-		val notification = NotificationCompat.Builder(applicationContext, CHANNEL_ID)
+		val notification = NotificationCompat.Builder(this, CHANNEL_ID)
 			.setPriority(NotificationCompat.PRIORITY_DEFAULT)
 			.setDefaults(0)
 			.setSilent(true)
@@ -119,17 +120,17 @@ class AutoFixService : CoroutineIntentService() {
 			if (replacement != null) {
 				notification.setLargeIcon(
 					coil.execute(
-						ImageRequest.Builder(applicationContext)
+						ImageRequest.Builder(this)
 							.data(replacement.coverUrl)
 							.mangaSourceExtra(replacement.source)
 							.build(),
 					).toBitmapOrNull(),
 				)
 				notification.setSubText(replacement.title)
-				val intent = AppRouter.detailsIntent(applicationContext, replacement)
+				val intent = AppRouter.detailsIntent(this, replacement)
 				notification.setContentIntent(
 					PendingIntentCompat.getActivity(
-						applicationContext,
+						this,
 						replacement.id.toInt(),
 						intent,
 						PendingIntent.FLAG_UPDATE_CURRENT,
@@ -143,35 +144,35 @@ class AutoFixService : CoroutineIntentService() {
 					},
 				)
 				notification
-					.setContentTitle(applicationContext.getString(R.string.fixed))
+					.setContentTitle(getString(R.string.fixed))
 					.setContentText(
-						applicationContext.getString(
+						getString(
 							R.string.manga_replaced,
 							seed.title,
-							seed.source.getTitle(applicationContext),
+							seed.source.getTitle(this),
 							replacement.title,
-							replacement.source.getTitle(applicationContext),
+							replacement.source.getTitle(this),
 						),
 					)
 					.setSmallIcon(R.drawable.ic_stat_done)
 			} else {
 				notification
-					.setContentTitle(applicationContext.getString(R.string.fixing_manga))
-					.setContentText(applicationContext.getString(R.string.no_fix_required, seed.title))
+					.setContentTitle(getString(R.string.fixing_manga))
+					.setContentText(getString(R.string.no_fix_required, seed.title))
 					.setSmallIcon(android.R.drawable.stat_sys_warning)
 			}
 		}.onFailure { error ->
 			notification
-				.setContentTitle(applicationContext.getString(R.string.error_occurred))
+				.setContentTitle(getString(R.string.error_occurred))
 				.setContentText(
-					if (error is AutoFixUseCase.NoAlternativesException) {
-						applicationContext.getString(R.string.no_alternatives_found, error.seed.manga.title)
+					if (error is NoAlternativesException) {
+						getString(R.string.no_alternatives_found, error.seed.manga.title)
 					} else {
-						error.getDisplayMessage(applicationContext.resources)
+						error.getDisplayMessage(resources)
 					},
 				).setSmallIcon(android.R.drawable.stat_notify_error)
 			ErrorReporterReceiver.getNotificationAction(
-				context = applicationContext,
+				context = this,
 				e = error,
 				notificationId = startId,
 				notificationTag = TAG,

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 settings: AppSettings,
-	private val tapGridSettings: TapGridSettings,
+    private val database: MangaDatabase,
+    private val settings: AppSettings,
+    private val tapGridSettings: TapGridSettings,
+    private val mangaSourcesRepository: MangaSourcesRepository,
+    private val savedFiltersRepository: SavedFiltersRepository,
 ) {
 
-	private val json = Json {
-		allowSpecialFloatingPointValues = true
-		coerceInputValues = true
-		encodeDefaults = true
-		ignoreUnknownKeys = true
-		useAlternativeNames = false
-	}
+    private val json = Json {
+        allowSpecialFloatingPointValues = true
+        coerceInputValues = true
+        encodeDefaults = true
+        ignoreUnknownKeys = true
+        useAlternativeNames = false
+    }
 
-	suspend fun createBackup(
-		output: ZipOutputStream,
-		progress: FlowCollector<Progress>?,
-	) {
-		progress?.emit(Progress.INDETERMINATE)
-		var commonProgress = Progress(0, BackupSection.entries.size)
-		for (section in BackupSection.entries) {
-			when (section) {
-				BackupSection.INDEX -> output.writeJsonArray(
-					section = BackupSection.INDEX,
-					data = flowOf(BackupIndex()),
-					serializer = serializer(),
-				)
+    suspend fun createBackup(
+        output: ZipOutputStream,
+        progress: FlowCollector<Progress>?,
+    ) {
+        progress?.emit(Progress.INDETERMINATE)
+        var commonProgress = Progress(0, BackupSection.entries.size)
+        for (section in BackupSection.entries) {
+            when (section) {
+                BackupSection.INDEX -> output.writeJsonArray(
+                    section = BackupSection.INDEX,
+                    data = flowOf(BackupIndex()),
+                    serializer = serializer(),
+                )
 
-				BackupSection.HISTORY -> output.writeJsonArray(
-					section = BackupSection.HISTORY,
-					data = database.getHistoryDao().dump().map { HistoryBackup(it) },
-					serializer = serializer(),
-				)
+                BackupSection.HISTORY -> output.writeJsonArray(
+                    section = BackupSection.HISTORY,
+                    data = database.getHistoryDao().dump().map { HistoryBackup(it) },
+                    serializer = serializer(),
+                )
 
-				BackupSection.CATEGORIES -> output.writeJsonArray(
-					section = BackupSection.CATEGORIES,
-					data = database.getFavouriteCategoriesDao().findAll().asFlow().map { CategoryBackup(it) },
-					serializer = serializer(),
-				)
+                BackupSection.CATEGORIES -> output.writeJsonArray(
+                    section = BackupSection.CATEGORIES,
+                    data = database.getFavouriteCategoriesDao().findAll().asFlow().map { CategoryBackup(it) },
+                    serializer = serializer(),
+                )
 
-				BackupSection.FAVOURITES -> output.writeJsonArray(
-					section = BackupSection.FAVOURITES,
-					data = database.getFavouritesDao().dump().map { FavouriteBackup(it) },
-					serializer = serializer(),
-				)
+                BackupSection.FAVOURITES -> output.writeJsonArray(
+                    section = BackupSection.FAVOURITES,
+                    data = database.getFavouritesDao().dump().map { FavouriteBackup(it) },
+                    serializer = serializer(),
+                )
 
-				BackupSection.SETTINGS -> output.writeString(
-					section = BackupSection.SETTINGS,
-					data = dumpSettings(),
-				)
+                BackupSection.SETTINGS -> output.writeString(
+                    section = BackupSection.SETTINGS,
+                    data = dumpSettings(),
+                )
 
-				BackupSection.SETTINGS_READER_GRID -> output.writeString(
-					section = BackupSection.SETTINGS_READER_GRID,
-					data = dumpReaderGridSettings(),
-				)
+                BackupSection.SETTINGS_READER_GRID -> output.writeString(
+                    section = BackupSection.SETTINGS_READER_GRID,
+                    data = dumpReaderGridSettings(),
+                )
 
-				BackupSection.BOOKMARKS -> output.writeJsonArray(
-					section = BackupSection.BOOKMARKS,
-					data = database.getBookmarksDao().dump().map { BookmarkBackup(it.first, it.second) },
-					serializer = serializer(),
-				)
+                BackupSection.BOOKMARKS -> output.writeJsonArray(
+                    section = BackupSection.BOOKMARKS,
+                    data = database.getBookmarksDao().dump().map { BookmarkBackup(it.first, it.second) },
+                    serializer = serializer(),
+                )
 
-				BackupSection.SOURCES -> output.writeJsonArray(
-					section = BackupSection.SOURCES,
-					data = database.getSourcesDao().dumpEnabled().map { SourceBackup(it) },
-					serializer = serializer(),
-				)
-			}
-			progress?.emit(commonProgress)
-			commonProgress++
-		}
-		progress?.emit(commonProgress)
-	}
+                BackupSection.SOURCES -> output.writeJsonArray(
+                    section = BackupSection.SOURCES,
+                    data = database.getSourcesDao().dumpEnabled().map { SourceBackup(it) },
+                    serializer = serializer(),
+                )
 
-	suspend fun restoreBackup(
-		input: ZipInputStream,
-		sections: Set<BackupSection>,
-		progress: FlowCollector<Progress>?,
-	): CompositeResult {
-		progress?.emit(Progress.INDETERMINATE)
-		var commonProgress = Progress(0, sections.size)
-		var entry = input.nextEntry
-		var result = CompositeResult.EMPTY
-		while (entry != null) {
-			val section = BackupSection.of(entry)
-			if (section in sections) {
-				result = result + when (section) {
-					BackupSection.INDEX -> CompositeResult.EMPTY // useless in our case
-					BackupSection.HISTORY -> input.readJsonArray<HistoryBackup>(serializer()).restoreToDb {
-						upsertManga(it.manga)
-						getHistoryDao().upsert(it.toEntity())
-					}
+                BackupSection.SCROBBLING -> output.writeJsonArray(
+                    section = BackupSection.SCROBBLING,
+                    data = database.getScrobblingDao().dumpEnabled().map { ScrobblingBackup(it) },
+                    serializer = serializer(),
+                )
 
-					BackupSection.CATEGORIES -> input.readJsonArray<CategoryBackup>(serializer()).restoreToDb {
-						getFavouriteCategoriesDao().upsert(it.toEntity())
-					}
+                BackupSection.STATS -> output.writeJsonArray(
+                    section = BackupSection.STATS,
+                    data = database.getStatsDao().dumpEnabled().map { StatisticBackup(it) },
+                    serializer = serializer(),
+                )
 
-					BackupSection.FAVOURITES -> input.readJsonArray<FavouriteBackup>(serializer()).restoreToDb {
-						upsertManga(it.manga)
-						getFavouritesDao().upsert(it.toEntity())
-					}
+                BackupSection.SAVED_FILTERS -> {
+                    val sources = mangaSourcesRepository.getEnabledSources()
+                    val filters = sources.flatMap { source ->
+                        savedFiltersRepository.getAll(source)
+                    }
+                    output.writeJsonArray(
+                        section = BackupSection.SAVED_FILTERS,
+                        data = filters.asFlow(),
+                        serializer = serializer(),
+                    )
+                }
+            }
+            progress?.emit(commonProgress)
+            commonProgress++
+        }
+        progress?.emit(commonProgress)
+    }
 
-					BackupSection.SETTINGS -> input.readMap().let {
-						settings.upsertAll(it)
-						CompositeResult.success()
-					}
+    suspend fun restoreBackup(
+        input: ZipInputStream,
+        sections: Set<BackupSection>,
+        progress: FlowCollector<Progress>?,
+    ): CompositeResult {
+        progress?.emit(Progress.INDETERMINATE)
+        var commonProgress = Progress(0, sections.size)
+        var entry = input.nextEntry
+        var result = CompositeResult.EMPTY
+        while (entry != null) {
+            val section = BackupSection.of(entry)
+            if (section in sections) {
+                result += when (section) {
+                    BackupSection.INDEX -> CompositeResult.EMPTY // useless in our case
+                    BackupSection.HISTORY -> input.readJsonArray<HistoryBackup>(serializer()).restoreToDb {
+                        upsertManga(it.manga)
+                        getHistoryDao().upsert(it.toEntity())
+                    }
 
-					BackupSection.SETTINGS_READER_GRID -> input.readMap().let {
-						tapGridSettings.upsertAll(it)
-						CompositeResult.success()
-					}
+                    BackupSection.CATEGORIES -> input.readJsonArray<CategoryBackup>(serializer()).restoreToDb {
+                        getFavouriteCategoriesDao().upsert(it.toEntity())
+                    }
 
-					BackupSection.BOOKMARKS -> input.readJsonArray<BookmarkBackup>(serializer()).restoreToDb {
-						upsertManga(it.manga)
-						getBookmarksDao().upsert(it.bookmarks.map { b -> b.toEntity() })
-					}
+                    BackupSection.FAVOURITES -> input.readJsonArray<FavouriteBackup>(serializer()).restoreToDb {
+                        upsertManga(it.manga)
+                        getFavouritesDao().upsert(it.toEntity())
+                    }
 
-					BackupSection.SOURCES -> input.readJsonArray<SourceBackup>(serializer()).restoreToDb {
-						getSourcesDao().upsert(it.toEntity())
-					}
+                    BackupSection.SETTINGS -> input.readMap().let {
+                        settings.upsertAll(it)
+                        CompositeResult.success()
+                    }
 
-					null -> CompositeResult.EMPTY // skip unknown entries
-				}
-				progress?.emit(commonProgress)
-				commonProgress++
-			}
-			input.closeEntry()
-			entry = input.nextEntry
-		}
-		progress?.emit(commonProgress)
-		return result
-	}
+                    BackupSection.SETTINGS_READER_GRID -> input.readMap().let {
+                        tapGridSettings.upsertAll(it)
+                        CompositeResult.success()
+                    }
 
-	private suspend fun <T> ZipOutputStream.writeJsonArray(
-		section: BackupSection,
-		data: Flow<T>,
-		serializer: SerializationStrategy<T>,
-	) {
-		data.onStart {
-			putNextEntry(ZipEntry(section.entryName))
-			write("[")
-		}.onCompletion { error ->
-			if (error == null) {
-				write("]")
-			}
-			closeEntry()
-			flush()
-		}.collectIndexed { index, value ->
-			if (index > 0) {
-				write(",")
-			}
-			json.encodeToStream(serializer, value, this)
-		}
-	}
+                    BackupSection.BOOKMARKS -> input.readJsonArray<BookmarkBackup>(serializer()).restoreToDb {
+                        upsertManga(it.manga)
+                        getBookmarksDao().upsert(it.bookmarks.map { b -> b.toEntity() })
+                    }
 
-	private fun <T> InputStream.readJsonArray(
-		serializer: DeserializationStrategy<T>,
-	): Sequence<T> = json.decodeToSequence(this, serializer, DecodeSequenceMode.ARRAY_WRAPPED)
+                    BackupSection.SOURCES -> input.readJsonArray<SourceBackup>(serializer()).restoreToDb {
+                        getSourcesDao().upsert(it.toEntity())
+                    }
 
-	private fun InputStream.readMap(): Map<String, Any?> {
-		val jo = JSONArray(readString()).getJSONObject(0)
-		val map = ArrayMap<String, Any?>(jo.length())
-		val keys = jo.keys()
-		while (keys.hasNext()) {
-			val key = keys.next()
-			map[key] = jo.get(key)
-		}
-		return map
-	}
+                    BackupSection.SCROBBLING -> input.readJsonArray<ScrobblingBackup>(serializer()).restoreToDb {
+                        getScrobblingDao().upsert(it.toEntity())
+                    }
 
-	private fun ZipOutputStream.writeString(
-		section: BackupSection,
-		data: String,
-	) {
-		putNextEntry(ZipEntry(section.entryName))
-		try {
-			write("[")
-			write(data)
-			write("]")
-		} finally {
-			closeEntry()
-			flush()
-		}
-	}
+                    BackupSection.STATS -> input.readJsonArray<StatisticBackup>(serializer()).restoreToDb {
+                        getStatsDao().upsert(it.toEntity())
+                    }
 
-	private fun OutputStream.write(str: String) = write(str.toByteArray())
+                    BackupSection.SAVED_FILTERS -> input.readJsonArray<PersistableFilter>(serializer())
+                        .restoreWithoutTransaction {
+                            savedFiltersRepository.save(it)
+                        }
 
-	private fun InputStream.readString(): String = readBytes().decodeToString()
+                    null -> CompositeResult.EMPTY // skip unknown entries
+                }
+                progress?.emit(commonProgress)
+                commonProgress++
+            }
+            input.closeEntry()
+            entry = input.nextEntry
+        }
+        progress?.emit(commonProgress)
+        return result
+    }
 
-	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 suspend fun <T> ZipOutputStream.writeJsonArray(
+        section: BackupSection,
+        data: Flow<T>,
+        serializer: SerializationStrategy<T>,
+    ) {
+        data.onStart {
+            putNextEntry(ZipEntry(section.entryName))
+            write("[")
+        }.onCompletion { error ->
+            if (error == null) {
+                write("]")
+            }
+            closeEntry()
+            flush()
+        }.collectIndexed { index, value ->
+            if (index > 0) {
+                write(",")
+            }
+            json.encodeToStream(serializer, value, this)
+        }
+    }
 
-	private fun dumpReaderGridSettings(): String {
-		return JSONObject(tapGridSettings.getAllValues()).toString()
-	}
+    private fun <T> InputStream.readJsonArray(
+        serializer: DeserializationStrategy<T>,
+    ): Sequence<T> = json.decodeToSequence(this, serializer, DecodeSequenceMode.ARRAY_WRAPPED)
 
-	private suspend fun MangaDatabase.upsertManga(manga: MangaBackup) {
-		val tags = manga.tags.map { it.toEntity() }
-		getTagsDao().upsert(tags)
-		getMangaDao().upsert(manga.toEntity(), tags)
-	}
+    private fun InputStream.readMap(): Map<String, Any?> {
+        val jo = JSONArray(readString()).getJSONObject(0)
+        val map = ArrayMap<String, Any?>(jo.length())
+        val keys = jo.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            map[key] = jo.get(key)
+        }
+        return map
+    }
 
-	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 fun ZipOutputStream.writeString(
+        section: BackupSection,
+        data: String,
+    ) {
+        putNextEntry(ZipEntry(section.entryName))
+        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 =
-			createBackupFile(
-				this,
-				BackupRepository(
-					MangaDatabase(context = applicationContext),
-					AppSettings(applicationContext),
-					TapGridSettings(applicationContext),
+		val file = createBackupFile(
+			this,
+			BackupRepository(
+				database = MangaDatabase(context = applicationContext),
+				settings = AppSettings(applicationContext),
+				tapGridSettings = 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/ErrorReporterReceiver.kt

@@ -4,7 +4,6 @@ import android.app.PendingIntent
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import android.os.BadParcelableException
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.app.PendingIntentCompat
@@ -65,7 +64,7 @@ class ErrorReporterReceiver : BroadcastReceiver() {
 			e: Throwable,
 			notificationId: Int,
 			notificationTag: String?,
-		): PendingIntent? = try {
+		): PendingIntent? = runCatching {
 			val intent = Intent(context, ErrorReporterReceiver::class.java)
 			intent.setAction(ACTION_REPORT)
 			intent.setData("err://${e.hashCode()}".toUri())
@@ -73,9 +72,9 @@ class ErrorReporterReceiver : BroadcastReceiver() {
 			intent.putExtra(EXTRA_NOTIFICATION_ID, notificationId)
 			intent.putExtra(EXTRA_NOTIFICATION_TAG, notificationTag)
 			PendingIntentCompat.getBroadcast(context, 0, intent, 0, false)
-		} catch (e: BadParcelableException) {
+		}.onFailure { e ->
+			// probably cannot write exception as serializable
 			e.printStackTraceDebug()
-			null
-		}
+		}.getOrNull()
 	}
 }

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/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
@@ -54,6 +56,7 @@ import org.koitharu.kotatsu.core.util.ext.processLifecycleScope
 import org.koitharu.kotatsu.core.util.ext.toBitmapOrNull
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.network.CloudFlareHelper
+import org.koitharu.kotatsu.parsers.util.mapToArray
 import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import javax.inject.Inject
 import javax.inject.Provider
@@ -64,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) {
@@ -78,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
+				}
 			}
 		}
 	}
@@ -89,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) {
@@ -118,7 +134,7 @@ class CaptchaHandler @Inject constructor(
 				notify(exceptions)
 			}
 		}
-		true
+		false
 	}
 
 	@RequiresPermission(Manifest.permission.POST_NOTIFICATIONS)
@@ -152,6 +168,15 @@ class CaptchaHandler @Inject constructor(
 				.setOnlyAlertOnce(true)
 				.setSmallIcon(R.drawable.ic_bot)
 				.setGroup(GROUP_CAPTCHA)
+				.setContentIntent(
+					PendingIntentCompat.getActivities(
+						context, GROUP_NOTIFICATION_ID,
+						exceptions.mapToArray { e ->
+							AppRouter.cloudFlareResolveIntent(context, e)
+						},
+						0, false,
+					),
+				)
 				.setContentText(
 					context.getString(
 						R.string.captcha_required_summary, context.getString(R.string.app_name),
@@ -172,7 +197,6 @@ class CaptchaHandler @Inject constructor(
 
 	private suspend fun buildNotification(exception: CloudFlareProtectedException): Notification {
 		val intent = AppRouter.cloudFlareResolveIntent(context, exception)
-			.setData(exception.url.toUri())
 		val discardIntent = Intent(ACTION_DISCARD)
 			.putExtra(AppRouter.KEY_SOURCE, exception.source.name)
 			.setData("source://${exception.source.name}".toUri())
@@ -225,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)
@@ -251,11 +275,11 @@ class CaptchaHandler @Inject constructor(
 
 	companion object {
 
-		fun ImageRequest.Builder.ignoreCaptchaErrors() = apply {
-			extras[ignoreCaptchaKey] = true
+		fun ImageRequest.Builder.suppressCaptchaErrors() = apply {
+			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
@@ -263,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/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/nav/AppRouter.kt

@@ -798,7 +798,7 @@ class AppRouter private constructor(
 			else -> true
 		}
 
-		fun shortMangaUrl(mangaId: Long) = Uri.Builder()
+		fun shortMangaUrl(mangaId: Long): Uri = Uri.Builder()
 			.scheme("kotatsu")
 			.path("manga")
 			.appendQueryParameter("id", mangaId.toString())

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
-		continuation.resume(Unit)
+		resumeContinuation(view)
+	}
+
+	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

@@ -0,0 +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.parsers.model.MangaSource
+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,
+	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()
+			try {
+				if (!baseUrl.isNullOrEmpty()) {
+					suspendCoroutine { cont ->
+						webView.webViewClient = ContinuationResumeWebViewClient(cont)
+						webView.loadDataWithBaseURL(baseUrl, " ", "text/html", null, null)
+					}
+				}
+				suspendCoroutine { cont ->
+					webView.evaluateJavascript(script) { result ->
+						cont.resume(result?.takeUnless { it == "null" })
+					}
+				}
+			} finally {
+				webView.reset()
+			}
+		}
+	}
+
+	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()
+			}
+		}
+	}
+
+	private fun MangaSource.getUserAgent(): String? {
+		val repository = mangaRepositoryFactoryProvider.get().create(this) as? ParserMangaRepository
+		return repository?.getRequestHeaders()?.get(CommonHeaders.USER_AGENT)
+	}
+
+	@MainThread
+	private fun WebView.reset() {
+		stopLoading()
+		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) {
-				activeNetwork?.let { isOnline(it) } == true
-			} else {
-				@Suppress("DEPRECATION")
-				activeNetworkInfo?.isConnected == true
-			}
+			return activeNetwork?.let { isOnline(it) } == 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

@@ -3,15 +3,8 @@ package org.koitharu.kotatsu.core.parser
 import android.annotation.SuppressLint
 import android.content.Context
 import android.util.Base64
-import android.webkit.WebView
-import androidx.annotation.MainThread
 import androidx.core.os.LocaleListCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
@@ -22,11 +15,8 @@ import org.koitharu.kotatsu.core.exceptions.InteractiveActionRequiredException
 import org.koitharu.kotatsu.core.image.BitmapDecoderCompat
 import org.koitharu.kotatsu.core.network.MangaHttpClient
 import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
-import org.koitharu.kotatsu.core.network.webview.ContinuationResumeWebViewClient
+import org.koitharu.kotatsu.core.network.webview.WebViewExecutor
 import org.koitharu.kotatsu.core.prefs.SourceSettings
-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.core.util.ext.toList
 import org.koitharu.kotatsu.core.util.ext.toMimeType
 import org.koitharu.kotatsu.core.util.ext.use
@@ -37,25 +27,19 @@ import org.koitharu.kotatsu.parsers.config.MangaSourceConfig
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.network.UserAgents
 import org.koitharu.kotatsu.parsers.util.map
-import java.lang.ref.WeakReference
 import java.util.Locale
 import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 import javax.inject.Singleton
-import kotlin.coroutines.EmptyCoroutineContext
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 
 @Singleton
 class MangaLoaderContextImpl @Inject constructor(
 	@MangaHttpClient override val httpClient: OkHttpClient,
 	override val cookieJar: MutableCookieJar,
 	@ApplicationContext private val androidContext: Context,
+	private val webViewExecutor: WebViewExecutor,
 ) : MangaLoaderContext() {
 
-	private var webViewCached: WeakReference<WebView>? = null
-	private val webViewUserAgent by lazy { obtainWebViewUserAgent() }
-	private val jsMutex = Mutex()
 	private val jsTimeout = TimeUnit.SECONDS.toMillis(4)
 
 	@Deprecated("Provide a base url")
@@ -63,25 +47,10 @@ class MangaLoaderContextImpl @Inject constructor(
 	override suspend fun evaluateJs(script: String): String? = evaluateJs("", script)
 
 	override suspend fun evaluateJs(baseUrl: String, script: String): String? = withTimeout(jsTimeout) {
-		jsMutex.withLock {
-			withContext(Dispatchers.Main.immediate) {
-				val webView = obtainWebView()
-				if (baseUrl.isNotEmpty()) {
-					suspendCoroutine { cont ->
-						webView.webViewClient = ContinuationResumeWebViewClient(cont)
-						webView.loadDataWithBaseURL(baseUrl, " ", "text/html", null, null)
-					}
-				}
-				suspendCoroutine { cont ->
-					webView.evaluateJavascript(script) { result ->
-						cont.resume(result?.takeUnless { it == "null" })
-					}
-				}
-			}
-		}
+		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)
@@ -118,28 +87,4 @@ class MangaLoaderContextImpl @Inject constructor(
 	}
 
 	override fun createBitmap(width: Int, height: Int): Bitmap = BitmapWrapper.create(width, height)
-
-	@MainThread
-	private fun obtainWebView(): WebView = webViewCached?.get() ?: WebView(androidContext).also {
-		it.configureForParser(null)
-		webViewCached = WeakReference(it)
-	}
-
-	private fun obtainWebViewUserAgent(): String {
-		val mainDispatcher = Dispatchers.Main.immediate
-		return if (!mainDispatcher.isDispatchNeeded(EmptyCoroutineContext)) {
-			obtainWebViewUserAgentImpl()
-		} else {
-			runBlocking(mainDispatcher) {
-				obtainWebViewUserAgentImpl()
-			}
-		}
-	}
-
-	@MainThread
-	private fun obtainWebViewUserAgentImpl() = runCatching {
-		obtainWebView().settings.userAgentString.sanitizeHeaderValue()
-	}.onFailure { e ->
-		e.printStackTraceDebug()
-	}.getOrDefault(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/external/ExternalPluginContentSource.kt

@@ -53,6 +53,9 @@ class ExternalPluginContentSource(
 		filter.states.forEach { uri.appendQueryParameter("state", it.name) }
 		filter.locale?.let { uri.appendQueryParameter("locale", it.language) }
 		filter.contentRating.forEach { uri.appendQueryParameter("content_rating", it.name) }
+		if (!filter.author.isNullOrEmpty()) {
+			uri.appendQueryParameter("author", filter.author)
+		}
 		if (!filter.query.isNullOrEmpty()) {
 			uri.appendQueryParameter("query", filter.query)
 		}
@@ -196,6 +199,7 @@ class ExternalPluginContentSource(
 							isYearSupported = cursor.getBooleanOrDefault(COLUMN_YEAR, false),
 							isYearRangeSupported = cursor.getBooleanOrDefault(COLUMN_YEAR_RANGE, false),
 							isOriginalLocaleSupported = cursor.getBooleanOrDefault(COLUMN_ORIGINAL_LOCALE, false),
+							isAuthorSearchSupported = cursor.getBooleanOrDefault(COLUMN_AUTHOR, false),
 						),
 					)
 				} else {

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,11 @@ 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) }
 
+	@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 +409,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 +496,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 +546,11 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isPeriodicalBackupEnabled: Boolean
 		get() = prefs.getBoolean(KEY_BACKUP_PERIODICAL_ENABLED, false)
 
-	val periodicalBackupFrequency: Long
-		get() = prefs.getString(KEY_BACKUP_PERIODICAL_FREQUENCY, null)?.toLongOrNull() ?: 7L
+	val periodicalBackupFrequency: Float
+		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 +681,7 @@ 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"
 		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 +750,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 +762,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/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,
-	isCentered: Boolean = false,
-	block: MaterialAlertDialogBuilder.() -> Unit,
+    @UiContext context: Context,
+    isCentered: Boolean = false,
+    block: MaterialAlertDialogBuilder.() -> Unit,
 ): AlertDialog = MaterialAlertDialogBuilder(
-	context,
-	if (isCentered) materialR.style.ThemeOverlay_Material3_MaterialAlertDialog_Centered else 0,
+    context,
+    if (isCentered) materialR.style.ThemeOverlay_Material3_MaterialAlertDialog_Centered else 0,
 ).apply(block).create()
 
 fun <B : AlertDialog.Builder> B.setCheckbox(
-	@StringRes textResId: Int,
-	isChecked: Boolean,
-	onCheckedChangeListener: OnCheckedChangeListener
+    @StringRes textResId: Int,
+    isChecked: Boolean,
+    onCheckedChangeListener: OnCheckedChangeListener
 ) = apply {
-	val binding = DialogCheckboxBinding.inflate(LayoutInflater.from(context))
-	binding.checkbox.setText(textResId)
-	binding.checkbox.isChecked = isChecked
-	binding.checkbox.setOnCheckedChangeListener(onCheckedChangeListener)
-	setView(binding.root)
+    val binding = DialogCheckboxBinding.inflate(LayoutInflater.from(context))
+    binding.checkbox.setText(textResId)
+    binding.checkbox.isChecked = isChecked
+    binding.checkbox.setOnCheckedChangeListener(onCheckedChangeListener)
+    setView(binding.root)
 }
 
 fun <B : AlertDialog.Builder, T> B.setRecyclerViewList(
-	list: List<T>,
-	delegate: AdapterDelegate<List<T>>,
+    list: List<T>,
+    delegate: AdapterDelegate<List<T>>,
 ) = apply {
-	val delegatesManager = AdapterDelegatesManager<List<T>>()
-	delegatesManager.addDelegate(delegate)
-	setRecyclerViewList(ListDelegationAdapter(delegatesManager).also { it.items = list })
+    val delegatesManager = AdapterDelegatesManager<List<T>>()
+    delegatesManager.addDelegate(delegate)
+    setRecyclerViewList(ListDelegationAdapter(delegatesManager).also { it.items = list })
 }
 
 fun <B : AlertDialog.Builder, T> B.setRecyclerViewList(
-	list: List<T>,
-	vararg delegates: AdapterDelegate<List<T>>,
+    list: List<T>,
+    vararg delegates: AdapterDelegate<List<T>>,
 ) = apply {
-	val delegatesManager = AdapterDelegatesManager<List<T>>()
-	delegates.forEach { delegatesManager.addDelegate(it) }
-	setRecyclerViewList(ListDelegationAdapter(delegatesManager).also { it.items = list })
+    val delegatesManager = AdapterDelegatesManager<List<T>>()
+    delegates.forEach { delegatesManager.addDelegate(it) }
+    setRecyclerViewList(ListDelegationAdapter(delegatesManager).also { it.items = list })
 }
 
 fun <B : AlertDialog.Builder> B.setRecyclerViewList(adapter: RecyclerView.Adapter<*>) = apply {
-	val recyclerView = RecyclerView(context)
-	recyclerView.layoutManager = LinearLayoutManager(context)
-	recyclerView.updatePadding(
-		top = context.resources.getDimensionPixelOffset(R.dimen.list_spacing),
-	)
-	recyclerView.clipToPadding = false
-	recyclerView.adapter = adapter
-	setView(recyclerView)
+    val recyclerView = RecyclerView(context)
+    recyclerView.layoutManager = LinearLayoutManager(context)
+    recyclerView.updatePadding(
+        top = context.resources.getDimensionPixelOffset(R.dimen.list_spacing),
+    )
+    recyclerView.clipToPadding = false
+    recyclerView.adapter = adapter
+    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/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) {
-				ColorUtils.compositeColors(
-					ContextCompat.getColor(ctx, materialR.color.m3_appbar_overlay_color),
-					ctx.getThemeColor(materialR.attr.colorSurface),
-				)
-			} else {
-				ContextCompat.getColor(ctx, R.color.kotatsu_surface)
-			}
+			val actionModeColor = ColorUtils.compositeColors(
+				ContextCompat.getColor(ctx, materialR.color.m3_appbar_overlay_color),
+				ctx.getThemeColor(materialR.attr.colorSurface),
+			)
 			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/MultiMutex.kt

@@ -31,8 +31,8 @@ open class MultiMutex<T : Any> {
 		contract {
 			callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 		}
+		lock(element)
 		return try {
-			lock(element)
 			block()
 		} finally {
 			unlock(element)

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/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
@@ -183,6 +176,8 @@ fun View.setTooltipCompat(tooltip: CharSequence?) {
 	}
 }
 
+fun View.setTooltipCompat(@StringRes tooltipResId: Int) = setTooltipCompat(context.getString(tooltipResId))
+
 val Toolbar.menuView: ActionMenuView?
 	get() {
 		menu // to call ensureMenu()

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) {
-			return
-		}
-		val binding = viewBinding ?: return
+        val binding = viewBinding ?: return
+        binding.layoutTouchBlock.isTouchEventsAllowed = newState != STATE_COLLAPSED
+        if (newState == STATE_DRAGGING || newState == STATE_SETTLING) {
+            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(
-							recyclerView,
-							R.string.chapters_will_removed_background,
-							Snackbar.LENGTH_LONG,
-						).show()
+						try {
+							Snackbar.make(
+								recyclerView,
+								R.string.chapters_will_removed_background,
+								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 {
-			if (!BuildConfig.DEBUG) {
-				remove(MangaParserSource.DUMMY)
-			}
-		},
+		EnumSet.noneOf<MangaParserSource>(MangaParserSource::class.java).also {
+            MangaParserSource.entries.filterNotTo(it, MangaParserSource::isBroken)
+        }
 	)
 
 	suspend fun getEnabledSources(): List<MangaSource> {

app/src/main/kotlin/org/koitharu/kotatsu/explore/domain/ExploreRepository.kt

@@ -35,7 +35,7 @@ class ExploreRepository @Inject constructor(
 			val details = runCatchingCancellable {
 				mangaRepositoryFactory.create(manga.source).getDetails(manga)
 			}.getOrNull() ?: continue
-			if ((settings.isSuggestionsExcludeNsfw && details.isNsfw) || details in tagsBlacklist) {
+			if ((settings.isSuggestionsExcludeNsfw && details.isNsfw()) || details in tagsBlacklist) {
 				continue
 			}
 			return details
@@ -55,7 +55,7 @@ class ExploreRepository @Inject constructor(
 			val details = runCatchingCancellable {
 				mangaRepositoryFactory.create(manga.source).getDetails(manga)
 			}.getOrNull() ?: continue
-			if ((skipNsfw && details.isNsfw) || details in tagsBlacklist) {
+			if ((skipNsfw && details.isNsfw()) || details in tagsBlacklist) {
 				continue
 			}
 			return details
@@ -80,7 +80,7 @@ class ExploreRepository @Inject constructor(
 			filter = MangaListFilter(tags = setOfNotNull(tag)),
 		).asArrayList()
 		if (settings.isSuggestionsExcludeNsfw) {
-			list.removeAll { it.isNsfw }
+			list.removeAll { it.isNsfw() }
 		}
 		if (blacklist.isNotEmpty()) {
 			list.removeAll { manga -> manga in blacklist }

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/categories/adapter/CategoryAD.kt

@@ -11,6 +11,7 @@ import androidx.core.view.isVisible
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.util.ext.getQuantityStringSafe
+import org.koitharu.kotatsu.core.util.ext.setTooltipCompat
 import org.koitharu.kotatsu.databinding.ItemCategoriesAllBinding
 import org.koitharu.kotatsu.databinding.ItemCategoryBinding
 import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesListListener
@@ -91,6 +92,13 @@ fun allCategoriesAD(
 				R.drawable.ic_eye_off
 			},
 		)
+		binding.imageViewVisible.setTooltipCompat(
+			if (item.isVisible) {
+				R.string.hide
+			} else {
+				R.string.show
+			},
+		)
 		binding.coversView.setCoversAsync(item.covers)
 	}
 }

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,
-	mangaRepositoryFactory: MangaRepository.Factory,
-	private val searchRepository: MangaSearchRepository,
-	lifecycle: ViewModelLifecycle,
+    savedStateHandle: SavedStateHandle,
+    mangaRepositoryFactory: MangaRepository.Factory,
+    private val searchRepository: MangaSearchRepository,
+    private val savedFiltersRepository: SavedFiltersRepository,
+    lifecycle: ViewModelLifecycle,
 ) {
 
-	private val coroutineScope = lifecycle.lifecycleScope + Dispatchers.Default
-	private val repository = mangaRepositoryFactory.create(MangaSource(savedStateHandle[RemoteListFragment.ARG_SOURCE]))
-	private val sourceLocale = (repository.source as? MangaParserSource)?.locale
+    private val coroutineScope = lifecycle.lifecycleScope + Dispatchers.Default
+    private val repository = mangaRepositoryFactory.create(MangaSource(savedStateHandle[RemoteListFragment.ARG_SOURCE]))
+    private val sourceLocale = (repository.source as? MangaParserSource)?.locale
 
-	private val currentListFilter = MutableStateFlow(MangaListFilter.EMPTY)
-	private val currentSortOrder = MutableStateFlow(repository.defaultSortOrder)
+    private val currentListFilter = MutableStateFlow(MangaListFilter.EMPTY)
+    private val currentSortOrder = MutableStateFlow(repository.defaultSortOrder)
 
-	private val availableSortOrders = repository.sortOrders
-	private val filterOptions = suspendLazy { repository.getFilterOptions() }
-	val capabilities = repository.filterCapabilities
+    private val availableSortOrders = repository.sortOrders
+    private val filterOptions = suspendLazy { repository.getFilterOptions() }
 
-	val mangaSource: MangaSource
-		get() = repository.source
+    val capabilities = repository.filterCapabilities
 
-	val isFilterApplied: Boolean
-		get() = currentListFilter.value.isNotEmpty()
+    val mangaSource: MangaSource
+        get() = repository.source
 
-	val query: StateFlow<String?> = currentListFilter.map { it.query }
-		.stateIn(coroutineScope, SharingStarted.Eagerly, null)
+    val isFilterApplied: Boolean
+        get() = currentListFilter.value.isNotEmpty()
 
-	val sortOrder: StateFlow<FilterProperty<SortOrder>> = currentSortOrder.map { selected ->
-		FilterProperty(
-			availableItems = availableSortOrders.sortedByOrdinal(),
-			selectedItem = selected,
-		)
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val query: StateFlow<String?> = currentListFilter.map { it.query }
+        .stateIn(coroutineScope, SharingStarted.Eagerly, null)
 
-	val tags: StateFlow<FilterProperty<MangaTag>> = combine(
-		getTopTags(TAGS_LIMIT),
-		currentListFilter.distinctUntilChangedBy { it.tags },
-	) { available, selected ->
-		available.fold(
-			onSuccess = {
-				FilterProperty(
-					availableItems = it.addFirstDistinct(selected.tags),
-					selectedItems = selected.tags,
-				)
-			},
-			onFailure = {
-				FilterProperty.error(it)
-			},
-		)
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val sortOrder: StateFlow<FilterProperty<SortOrder>> = currentSortOrder.map { selected ->
+        FilterProperty(
+            availableItems = availableSortOrders.sortedByOrdinal(),
+            selectedItem = selected,
+        )
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
 
-	val tagsExcluded: StateFlow<FilterProperty<MangaTag>> = if (capabilities.isTagsExclusionSupported) {
-		combine(
-			getBottomTags(TAGS_LIMIT),
-			currentListFilter.distinctUntilChangedBy { it.tagsExclude },
-		) { available, selected ->
-			available.fold(
-				onSuccess = {
-					FilterProperty(
-						availableItems = it.addFirstDistinct(selected.tagsExclude),
-						selectedItems = selected.tagsExclude,
-					)
-				},
-				onFailure = {
-					FilterProperty.error(it)
-				},
-			)
-		}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-	} else {
-		MutableStateFlow(FilterProperty.EMPTY)
-	}
+    val tags: StateFlow<FilterProperty<MangaTag>> = combine(
+        getTopTags(TAGS_LIMIT),
+        currentListFilter.distinctUntilChangedBy { it.tags },
+    ) { available, selected ->
+        available.fold(
+            onSuccess = {
+                FilterProperty(
+                    availableItems = it.addFirstDistinct(selected.tags),
+                    selectedItems = selected.tags,
+                )
+            },
+            onFailure = {
+                FilterProperty.error(it)
+            },
+        )
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
 
-	val states: StateFlow<FilterProperty<MangaState>> = combine(
-		filterOptions.asFlow(),
-		currentListFilter.distinctUntilChangedBy { it.states },
-	) { available, selected ->
-		available.fold(
-			onSuccess = {
-				FilterProperty(
-					availableItems = it.availableStates.sortedByOrdinal(),
-					selectedItems = selected.states,
-				)
-			},
-			onFailure = {
-				FilterProperty.error(it)
-			},
-		)
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val tagsExcluded: StateFlow<FilterProperty<MangaTag>> = if (capabilities.isTagsExclusionSupported) {
+        combine(
+            getBottomTags(TAGS_LIMIT),
+            currentListFilter.distinctUntilChangedBy { it.tagsExclude },
+        ) { available, selected ->
+            available.fold(
+                onSuccess = {
+                    FilterProperty(
+                        availableItems = it.addFirstDistinct(selected.tagsExclude),
+                        selectedItems = selected.tagsExclude,
+                    )
+                },
+                onFailure = {
+                    FilterProperty.error(it)
+                },
+            )
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    } else {
+        MutableStateFlow(FilterProperty.EMPTY)
+    }
 
-	val contentRating: StateFlow<FilterProperty<ContentRating>> = combine(
-		filterOptions.asFlow(),
-		currentListFilter.distinctUntilChangedBy { it.contentRating },
-	) { available, selected ->
-		available.fold(
-			onSuccess = {
-				FilterProperty(
-					availableItems = it.availableContentRating.sortedByOrdinal(),
-					selectedItems = selected.contentRating,
-				)
-			},
-			onFailure = {
-				FilterProperty.error(it)
-			},
-		)
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val authors: StateFlow<FilterProperty<String>> = if (capabilities.isAuthorSearchSupported) {
+        combine(
+            flow { emit(searchRepository.getAuthors(repository.source, TAGS_LIMIT)) },
+            currentListFilter.distinctUntilChangedBy { it.author },
+        ) { available, selected ->
+            FilterProperty(
+                availableItems = available,
+                selectedItems = setOfNotNull(selected.author),
+            )
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    } else {
+        MutableStateFlow(FilterProperty.EMPTY)
+    }
 
-	val contentTypes: StateFlow<FilterProperty<ContentType>> = combine(
-		filterOptions.asFlow(),
-		currentListFilter.distinctUntilChangedBy { it.types },
-	) { available, selected ->
-		available.fold(
-			onSuccess = {
-				FilterProperty(
-					availableItems = it.availableContentTypes.sortedByOrdinal(),
-					selectedItems = selected.types,
-				)
-			},
-			onFailure = {
-				FilterProperty.error(it)
-			},
-		)
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val states: StateFlow<FilterProperty<MangaState>> = combine(
+        filterOptions.asFlow(),
+        currentListFilter.distinctUntilChangedBy { it.states },
+    ) { available, selected ->
+        available.fold(
+            onSuccess = {
+                FilterProperty(
+                    availableItems = it.availableStates.sortedByOrdinal(),
+                    selectedItems = selected.states,
+                )
+            },
+            onFailure = {
+                FilterProperty.error(it)
+            },
+        )
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
 
-	val demographics: StateFlow<FilterProperty<Demographic>> = combine(
-		filterOptions.asFlow(),
-		currentListFilter.distinctUntilChangedBy { it.demographics },
-	) { available, selected ->
-		available.fold(
-			onSuccess = {
-				FilterProperty(
-					availableItems = it.availableDemographics.sortedByOrdinal(),
-					selectedItems = selected.demographics,
-				)
-			},
-			onFailure = {
-				FilterProperty.error(it)
-			},
-		)
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val contentRating: StateFlow<FilterProperty<ContentRating>> = combine(
+        filterOptions.asFlow(),
+        currentListFilter.distinctUntilChangedBy { it.contentRating },
+    ) { available, selected ->
+        available.fold(
+            onSuccess = {
+                FilterProperty(
+                    availableItems = it.availableContentRating.sortedByOrdinal(),
+                    selectedItems = selected.contentRating,
+                )
+            },
+            onFailure = {
+                FilterProperty.error(it)
+            },
+        )
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
 
-	val locale: StateFlow<FilterProperty<Locale?>> = combine(
-		filterOptions.asFlow(),
-		currentListFilter.distinctUntilChangedBy { it.locale },
-	) { available, selected ->
-		available.fold(
-			onSuccess = {
-				FilterProperty(
-					availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
-					selectedItems = setOfNotNull(selected.locale),
-				)
-			},
-			onFailure = {
-				FilterProperty.error(it)
-			},
-		)
-	}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    val contentTypes: StateFlow<FilterProperty<ContentType>> = combine(
+        filterOptions.asFlow(),
+        currentListFilter.distinctUntilChangedBy { it.types },
+    ) { available, selected ->
+        available.fold(
+            onSuccess = {
+                FilterProperty(
+                    availableItems = it.availableContentTypes.sortedByOrdinal(),
+                    selectedItems = selected.types,
+                )
+            },
+            onFailure = {
+                FilterProperty.error(it)
+            },
+        )
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
 
-	val originalLocale: StateFlow<FilterProperty<Locale?>> = if (capabilities.isOriginalLocaleSupported) {
-		combine(
-			filterOptions.asFlow(),
-			currentListFilter.distinctUntilChangedBy { it.originalLocale },
-		) { available, selected ->
-			available.fold(
-				onSuccess = {
-					FilterProperty(
-						availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
-						selectedItems = setOfNotNull(selected.originalLocale),
-					)
-				},
-				onFailure = {
-					FilterProperty.error(it)
-				},
-			)
-		}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-	} else {
-		MutableStateFlow(FilterProperty.EMPTY)
-	}
+    val demographics: StateFlow<FilterProperty<Demographic>> = combine(
+        filterOptions.asFlow(),
+        currentListFilter.distinctUntilChangedBy { it.demographics },
+    ) { available, selected ->
+        available.fold(
+            onSuccess = {
+                FilterProperty(
+                    availableItems = it.availableDemographics.sortedByOrdinal(),
+                    selectedItems = selected.demographics,
+                )
+            },
+            onFailure = {
+                FilterProperty.error(it)
+            },
+        )
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
 
-	val year: StateFlow<FilterProperty<Int>> = if (capabilities.isYearSupported) {
-		currentListFilter.distinctUntilChangedBy { it.year }.map { selected ->
-			FilterProperty(
-				availableItems = listOf(YEAR_MIN, MAX_YEAR),
-				selectedItems = setOf(selected.year),
-			)
-		}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-	} else {
-		MutableStateFlow(FilterProperty.EMPTY)
-	}
+    val locale: StateFlow<FilterProperty<Locale?>> = combine(
+        filterOptions.asFlow(),
+        currentListFilter.distinctUntilChangedBy { it.locale },
+    ) { available, selected ->
+        available.fold(
+            onSuccess = {
+                FilterProperty(
+                    availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
+                    selectedItems = setOfNotNull(selected.locale),
+                )
+            },
+            onFailure = {
+                FilterProperty.error(it)
+            },
+        )
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
 
-	val yearRange: StateFlow<FilterProperty<Int>> = if (capabilities.isYearRangeSupported) {
-		currentListFilter.distinctUntilChanged { old, new ->
-			old.yearTo == new.yearTo && old.yearFrom == new.yearFrom
-		}.map { selected ->
-			FilterProperty(
-				availableItems = listOf(YEAR_MIN, MAX_YEAR),
-				selectedItems = setOf(selected.yearFrom.ifZero { YEAR_MIN }, selected.yearTo.ifZero { MAX_YEAR }),
-			)
-		}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
-	} else {
-		MutableStateFlow(FilterProperty.EMPTY)
-	}
+    val originalLocale: StateFlow<FilterProperty<Locale?>> = if (capabilities.isOriginalLocaleSupported) {
+        combine(
+            filterOptions.asFlow(),
+            currentListFilter.distinctUntilChangedBy { it.originalLocale },
+        ) { available, selected ->
+            available.fold(
+                onSuccess = {
+                    FilterProperty(
+                        availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
+                        selectedItems = setOfNotNull(selected.originalLocale),
+                    )
+                },
+                onFailure = {
+                    FilterProperty.error(it)
+                },
+            )
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    } else {
+        MutableStateFlow(FilterProperty.EMPTY)
+    }
 
-	fun reset() {
-		currentListFilter.value = MangaListFilter.EMPTY
-	}
+    val year: StateFlow<FilterProperty<Int>> = if (capabilities.isYearSupported) {
+        currentListFilter.distinctUntilChangedBy { it.year }.map { selected ->
+            FilterProperty(
+                availableItems = listOf(YEAR_MIN, MAX_YEAR),
+                selectedItems = setOf(selected.year),
+            )
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    } else {
+        MutableStateFlow(FilterProperty.EMPTY)
+    }
 
-	fun snapshot() = Snapshot(
-		sortOrder = currentSortOrder.value,
-		listFilter = currentListFilter.value,
-	)
+    val yearRange: StateFlow<FilterProperty<Int>> = if (capabilities.isYearRangeSupported) {
+        currentListFilter.distinctUntilChanged { old, new ->
+            old.yearTo == new.yearTo && old.yearFrom == new.yearFrom
+        }.map { selected ->
+            FilterProperty(
+                availableItems = listOf(YEAR_MIN, MAX_YEAR),
+                selectedItems = setOf(selected.yearFrom.ifZero { YEAR_MIN }, selected.yearTo.ifZero { MAX_YEAR }),
+            )
+        }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
+    } else {
+        MutableStateFlow(FilterProperty.EMPTY)
+    }
 
-	fun observe(): Flow<Snapshot> = combine(currentSortOrder, currentListFilter, ::Snapshot)
+    val savedFilters: StateFlow<FilterProperty<PersistableFilter>> = combine(
+        savedFiltersRepository.observeAll(repository.source),
+        currentListFilter,
+    ) { available, applied ->
+        FilterProperty(
+            availableItems = available,
+            selectedItems = setOfNotNull(available.find { it.filter == applied }),
+        )
+    }.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.EMPTY)
 
-	fun setSortOrder(newSortOrder: SortOrder) {
-		currentSortOrder.value = newSortOrder
-		repository.defaultSortOrder = newSortOrder
-	}
+    fun reset() {
+        currentListFilter.value = MangaListFilter.EMPTY
+    }
 
-	fun set(value: MangaListFilter) {
-		currentListFilter.value = value
-	}
+    fun snapshot() = Snapshot(
+        sortOrder = currentSortOrder.value,
+        listFilter = currentListFilter.value,
+    )
 
-	fun setAdjusted(value: MangaListFilter) {
-		var newFilter = value
-		if (!newFilter.author.isNullOrEmpty() && !capabilities.isAuthorSearchSupported) {
-			newFilter = newFilter.copy(
-				query = newFilter.author,
-				author = null,
-			)
-		}
-		if (!capabilities.isSearchSupported && !newFilter.query.isNullOrEmpty()) {
-			newFilter = newFilter.copy(
-				query = null,
-			)
-		}
-		if (!newFilter.query.isNullOrEmpty() && !newFilter.hasNonSearchOptions() && !capabilities.isSearchWithFiltersSupported) {
-			newFilter = MangaListFilter(query = newFilter.query)
-		}
-		set(newFilter)
-	}
+    fun observe(): Flow<Snapshot> = combine(currentSortOrder, currentListFilter, ::Snapshot)
 
-	fun setQuery(value: String?) {
-		val newQuery = value?.trim()?.nullIfEmpty()
-		currentListFilter.update { oldValue ->
-			if (capabilities.isSearchWithFiltersSupported || newQuery == null) {
-				oldValue.copy(query = newQuery)
-			} else {
-				MangaListFilter(query = newQuery)
-			}
-		}
-	}
+    fun setSortOrder(newSortOrder: SortOrder) {
+        currentSortOrder.value = newSortOrder
+        repository.defaultSortOrder = newSortOrder
+    }
 
-	fun setLocale(value: Locale?) {
-		currentListFilter.update { oldValue ->
-			oldValue.copy(
-				locale = value,
-				query = oldValue.takeQueryIfSupported(),
-			)
-		}
-	}
+    fun set(value: MangaListFilter) {
+        currentListFilter.value = value
+    }
 
-	fun setAuthor(value: String?) {
-		currentListFilter.update { oldValue ->
-			oldValue.copy(
-				author = value,
-				query = oldValue.takeQueryIfSupported(),
-			)
-		}
-	}
+    fun setAdjusted(value: MangaListFilter) {
+        var newFilter = value
+        if (!newFilter.author.isNullOrEmpty() && !capabilities.isAuthorSearchSupported) {
+            newFilter = newFilter.copy(
+                query = newFilter.author,
+                author = null,
+            )
+        }
+        if (!newFilter.query.isNullOrEmpty() && !newFilter.hasNonSearchOptions() && !capabilities.isSearchWithFiltersSupported) {
+            newFilter = MangaListFilter(query = newFilter.query)
+        }
+        set(newFilter)
+    }
 
-	fun setOriginalLocale(value: Locale?) {
-		currentListFilter.update { oldValue ->
-			oldValue.copy(
-				originalLocale = value,
-				query = oldValue.takeQueryIfSupported(),
-			)
-		}
-	}
+    fun saveCurrentFilter(name: String) = coroutineScope.launch {
+        savedFiltersRepository.save(repository.source, name, currentListFilter.value)
+    }
 
-	fun setYear(value: Int) {
-		currentListFilter.update { oldValue ->
-			oldValue.copy(
-				year = value,
-				query = oldValue.takeQueryIfSupported(),
-			)
-		}
-	}
+    fun renameSavedFilter(id: Int, newName: String) = coroutineScope.launch {
+        savedFiltersRepository.rename(repository.source, id, newName)
+    }
 
-	fun setYearRange(valueFrom: Int, valueTo: Int) {
-		currentListFilter.update { oldValue ->
-			oldValue.copy(
-				yearFrom = valueFrom,
-				yearTo = valueTo,
-				query = oldValue.takeQueryIfSupported(),
-			)
-		}
-	}
+    fun deleteSavedFilter(id: Int) = coroutineScope.launch {
+        savedFiltersRepository.delete(repository.source, id)
+    }
 
-	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 setQuery(value: String?) {
+        val newQuery = value?.trim()?.nullIfEmpty()
+        currentListFilter.update { oldValue ->
+            if (capabilities.isSearchWithFiltersSupported || newQuery == null) {
+                oldValue.copy(query = newQuery)
+            } else {
+                MangaListFilter(query = newQuery)
+            }
+        }
+    }
 
-	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 setLocale(value: Locale?) {
+        currentListFilter.update { oldValue ->
+            oldValue.copy(
+                locale = 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 setAuthor(value: String?) {
+        currentListFilter.update { oldValue ->
+            oldValue.copy(
+                author = value,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	fun toggleContentType(value: ContentType, isSelected: Boolean) {
-		currentListFilter.update { oldValue ->
-			oldValue.copy(
-				types = if (isSelected) oldValue.types + value else oldValue.types - value,
-				query = oldValue.takeQueryIfSupported(),
-			)
-		}
-	}
+    fun setOriginalLocale(value: Locale?) {
+        currentListFilter.update { oldValue ->
+            oldValue.copy(
+                originalLocale = value,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	fun toggleTag(value: MangaTag, isSelected: Boolean) {
-		currentListFilter.update { oldValue ->
-			val newTags = if (capabilities.isMultipleTagsSupported) {
-				if (isSelected) oldValue.tags + value else oldValue.tags - value
-			} else {
-				if (isSelected) setOf(value) else emptySet()
-			}
-			oldValue.copy(
-				tags = newTags,
-				tagsExclude = oldValue.tagsExclude - newTags,
-				query = oldValue.takeQueryIfSupported(),
-			)
-		}
-	}
+    fun setYear(value: Int) {
+        currentListFilter.update { oldValue ->
+            oldValue.copy(
+                year = value,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	fun toggleTagExclude(value: MangaTag, isSelected: Boolean) {
-		currentListFilter.update { oldValue ->
-			val newTagsExclude = if (capabilities.isMultipleTagsSupported) {
-				if (isSelected) oldValue.tagsExclude + value else oldValue.tagsExclude - value
-			} else {
-				if (isSelected) setOf(value) else emptySet()
-			}
-			oldValue.copy(
-				tags = oldValue.tags - newTagsExclude,
-				tagsExclude = newTagsExclude,
-				query = oldValue.takeQueryIfSupported(),
-			)
-		}
-	}
+    fun setYearRange(valueFrom: Int, valueTo: Int) {
+        currentListFilter.update { oldValue ->
+            oldValue.copy(
+                yearFrom = valueFrom,
+                yearTo = valueTo,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	fun getAllTags(): Flow<Result<List<MangaTag>>> = filterOptions.asFlow().map {
-		it.map { x -> x.availableTags.sortedWithSafe(TagTitleComparator(sourceLocale)) }
-	}
+    fun toggleState(value: MangaState, isSelected: Boolean) {
+        currentListFilter.update { oldValue ->
+            oldValue.copy(
+                states = if (isSelected) oldValue.states + value else oldValue.states - value,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	private fun MangaListFilter.takeQueryIfSupported() = when {
-		capabilities.isSearchWithFiltersSupported -> query
-		query.isNullOrEmpty() -> query
-		hasNonSearchOptions() -> null
-		else -> query
-	}
+    fun toggleContentRating(value: ContentRating, isSelected: Boolean) {
+        currentListFilter.update { oldValue ->
+            oldValue.copy(
+                contentRating = if (isSelected) oldValue.contentRating + value else oldValue.contentRating - value,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	private fun getTopTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
-		flow { emit(searchRepository.getTopTags(repository.source, limit)) },
-		filterOptions.asFlow(),
-	) { suggested, options ->
-		val all = options.getOrNull()?.availableTags.orEmpty()
-		val result = ArrayList<MangaTag>(limit)
-		result.addAll(suggested.take(limit))
-		if (result.size < limit) {
-			result.addAll(all.shuffled().take(limit - result.size))
-		}
-		if (result.isNotEmpty()) {
-			Result.success(result)
-		} else {
-			options.map { result }
-		}
-	}.catch {
-		emit(Result.failure(it))
-	}
+    fun toggleDemographic(value: Demographic, isSelected: Boolean) {
+        currentListFilter.update { oldValue ->
+            oldValue.copy(
+                demographics = if (isSelected) oldValue.demographics + value else oldValue.demographics - value,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	private fun getBottomTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
-		flow { emit(searchRepository.getRareTags(repository.source, limit)) },
-		filterOptions.asFlow(),
-	) { suggested, options ->
-		val all = options.getOrNull()?.availableTags.orEmpty()
-		val result = ArrayList<MangaTag>(limit)
-		result.addAll(suggested.take(limit))
-		if (result.size < limit) {
-			result.addAll(all.shuffled().take(limit - result.size))
-		}
-		if (result.isNotEmpty()) {
-			Result.success(result)
-		} else {
-			options.map { result }
-		}
-	}.catch {
-		emit(Result.failure(it))
-	}
+    fun toggleContentType(value: ContentType, isSelected: Boolean) {
+        currentListFilter.update { oldValue ->
+            oldValue.copy(
+                types = if (isSelected) oldValue.types + value else oldValue.types - value,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	private fun <T> List<T>.addFirstDistinct(other: Collection<T>): List<T> {
-		val result = ArrayDeque<T>(this.size + other.size)
-		result.addAll(this)
-		for (item in other) {
-			if (item !in result) {
-				result.addFirst(item)
-			}
-		}
-		return result
-	}
+    fun toggleTag(value: MangaTag, isSelected: Boolean) {
+        currentListFilter.update { oldValue ->
+            val newTags = if (capabilities.isMultipleTagsSupported) {
+                if (isSelected) oldValue.tags + value else oldValue.tags - value
+            } else {
+                if (isSelected) setOf(value) else emptySet()
+            }
+            oldValue.copy(
+                tags = newTags,
+                tagsExclude = oldValue.tagsExclude - newTags,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	private fun <T> List<T>.addFirstDistinct(item: T): List<T> {
-		val result = ArrayDeque<T>(this.size + 1)
-		result.addAll(this)
-		if (item !in result) {
-			result.addFirst(item)
-		}
-		return result
-	}
+    fun toggleTagExclude(value: MangaTag, isSelected: Boolean) {
+        currentListFilter.update { oldValue ->
+            val newTagsExclude = if (capabilities.isMultipleTagsSupported) {
+                if (isSelected) oldValue.tagsExclude + value else oldValue.tagsExclude - value
+            } else {
+                if (isSelected) setOf(value) else emptySet()
+            }
+            oldValue.copy(
+                tags = oldValue.tags - newTagsExclude,
+                tagsExclude = newTagsExclude,
+                query = oldValue.takeQueryIfSupported(),
+            )
+        }
+    }
 
-	data class Snapshot(
-		val sortOrder: SortOrder,
-		val listFilter: MangaListFilter,
-	)
+    fun getAllTags(): Flow<Result<List<MangaTag>>> = filterOptions.asFlow().map {
+        it.map { x -> x.availableTags.sortedWithSafe(TagTitleComparator(sourceLocale)) }
+    }
 
-	interface Owner {
+    private fun MangaListFilter.takeQueryIfSupported() = when {
+        capabilities.isSearchWithFiltersSupported -> query
+        query.isNullOrEmpty() -> query
+        hasNonSearchOptions() -> null
+        else -> query
+    }
 
-		val filterCoordinator: FilterCoordinator
-	}
+    private fun getTopTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
+        flow { emit(searchRepository.getTopTags(repository.source, limit)) },
+        filterOptions.asFlow(),
+    ) { suggested, options ->
+        val all = options.getOrNull()?.availableTags.orEmpty()
+        val result = ArrayList<MangaTag>(limit)
+        result.addAll(suggested.take(limit))
+        if (result.size < limit) {
+            result.addAll(all.shuffled().take(limit - result.size))
+        }
+        if (result.isNotEmpty()) {
+            Result.success(result)
+        } else {
+            options.map { result }
+        }
+    }.catch {
+        emit(Result.failure(it))
+    }
 
-	companion object {
+    private fun getBottomTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
+        flow { emit(searchRepository.getRareTags(repository.source, limit)) },
+        filterOptions.asFlow(),
+    ) { suggested, options ->
+        val all = options.getOrNull()?.availableTags.orEmpty()
+        val result = ArrayList<MangaTag>(limit)
+        result.addAll(suggested.take(limit))
+        if (result.size < limit) {
+            result.addAll(all.shuffled().take(limit - result.size))
+        }
+        if (result.isNotEmpty()) {
+            Result.success(result)
+        } else {
+            options.map { result }
+        }
+    }.catch {
+        emit(Result.failure(it))
+    }
 
-		private const val TAGS_LIMIT = 12
-		private val MAX_YEAR = Calendar.getInstance()[Calendar.YEAR] + 1
+    private fun <T> List<T>.addFirstDistinct(other: Collection<T>): List<T> {
+        val result = ArrayDeque<T>(this.size + other.size)
+        result.addAll(this)
+        for (item in other) {
+            if (item !in result) {
+                result.addFirst(item)
+            }
+        }
+        return result
+    }
 
-		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
-		}
+    private fun <T> List<T>.addFirstDistinct(item: T): List<T> {
+        val result = ArrayDeque<T>(this.size + 1)
+        result.addAll(this)
+        if (item !in result) {
+            result.addFirst(item)
+        }
+        return result
+    }
 
-		fun require(fragment: Fragment): FilterCoordinator {
-			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
-	lateinit var filterHeaderProducer: FilterHeaderProducer
+    @Inject
+    lateinit var filterHeaderProducer: FilterHeaderProducer
 
-	private val filter: FilterCoordinator
-		get() = (requireActivity() as FilterCoordinator.Owner).filterCoordinator
+    private val filter: FilterCoordinator
+        get() = (requireActivity() as FilterCoordinator.Owner).filterCoordinator
 
-	override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): FragmentFilterHeaderBinding {
-		return FragmentFilterHeaderBinding.inflate(inflater, container, false)
-	}
+    override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): FragmentFilterHeaderBinding {
+        return FragmentFilterHeaderBinding.inflate(inflater, container, false)
+    }
 
-	override fun onViewBindingCreated(binding: FragmentFilterHeaderBinding, savedInstanceState: Bundle?) {
-		super.onViewBindingCreated(binding, savedInstanceState)
-		binding.chipsTags.onChipClickListener = this
-		binding.chipsTags.onChipCloseClickListener = this
-		filterHeaderProducer.observeHeader(filter)
-			.flowOn(Dispatchers.Default)
-			.observe(viewLifecycleOwner, ::onDataChanged)
-	}
+    override fun onViewBindingCreated(binding: FragmentFilterHeaderBinding, savedInstanceState: Bundle?) {
+        super.onViewBindingCreated(binding, savedInstanceState)
+        binding.chipsTags.onChipClickListener = this
+        binding.chipsTags.onChipCloseClickListener = this
+        filterHeaderProducer.observeHeader(filter)
+            .flowOn(Dispatchers.Default)
+            .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?) {
-		when (data) {
-			is MangaTag -> filter.toggleTag(data, !chip.isChecked)
-			is String -> Unit
-			null -> router.showTagsCatalogSheet(excludeMode = false)
-		}
-	}
+    override fun onChipClick(chip: Chip, data: Any?) {
+        when (data) {
+            is MangaTag -> filter.toggleTag(data, !chip.isChecked)
+            is PersistableFilter -> if (chip.isChecked) {
+                filter.reset()
+            } else {
+                filter.setAdjusted(data.filter)
+            }
 
-	override fun onChipCloseClick(chip: Chip, data: Any?) {
-		when (data) {
-			is String -> if (data == filter.snapshot().listFilter.author) {
-				filter.setAuthor(null)
-			} else {
-				filter.setQuery(null)
-			}
+            is String -> Unit
+            null -> router.showTagsCatalogSheet(excludeMode = false)
+        }
+    }
 
-			is ContentRating -> filter.toggleContentRating(data, false)
-			is Demographic -> filter.toggleDemographic(data, false)
-			is ContentType -> filter.toggleContentType(data, false)
-			is MangaState -> filter.toggleState(data, false)
-			is Locale -> filter.setLocale(null)
-			is Int -> filter.setYear(YEAR_UNKNOWN)
-			is IntRange -> filter.setYearRange(YEAR_UNKNOWN, YEAR_UNKNOWN)
-		}
-	}
+    override fun onChipCloseClick(chip: Chip, data: Any?) {
+        when (data) {
+            is String -> if (data == filter.snapshot().listFilter.author) {
+                filter.setAuthor(null)
+            } else {
+                filter.setQuery(null)
+            }
 
-	private fun onDataChanged(header: FilterHeaderModel) {
-		val binding = viewBinding ?: return
-		val chips = header.chips
-		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)
-		}
-	}
+            is ContentRating -> filter.toggleContentRating(data, false)
+            is Demographic -> filter.toggleDemographic(data, false)
+            is ContentType -> filter.toggleContentType(data, false)
+            is MangaState -> filter.toggleState(data, false)
+            is Locale -> filter.setLocale(null)
+            is Int -> filter.setYear(YEAR_UNKNOWN)
+            is IntRange -> filter.setYearRange(YEAR_UNKNOWN, YEAR_UNKNOWN)
+        }
+    }
+
+    private fun onDataChanged(header: FilterHeaderModel) {
+        val binding = viewBinding ?: return
+        val chips = header.chips
+        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> {
-		return combine(filterCoordinator.tags, filterCoordinator.observe()) { tags, snapshot ->
-			val chipList = createChipsList(
-				source = filterCoordinator.mangaSource,
-				capabilities = filterCoordinator.capabilities,
-				tagsProperty = tags,
-				snapshot = snapshot.listFilter,
-				limit = 12,
-			)
-			FilterHeaderModel(
-				chips = chipList,
-				sortOrder = snapshot.sortOrder,
-				isFilterApplied = !snapshot.listFilter.isEmpty(),
-			)
-		}
-	}
+    fun observeHeader(filterCoordinator: FilterCoordinator): Flow<FilterHeaderModel> {
+        return combine(
+            filterCoordinator.savedFilters,
+            filterCoordinator.tags,
+            filterCoordinator.observe(),
+        ) { saved, tags, snapshot ->
+            val chipList = createChipsList(
+                source = filterCoordinator.mangaSource,
+                capabilities = filterCoordinator.capabilities,
+                savedFilters = saved,
+                tagsProperty = tags,
+                snapshot = snapshot.listFilter,
+                limit = 12,
+            )
+            FilterHeaderModel(
+                chips = chipList,
+                sortOrder = snapshot.sortOrder,
+                isFilterApplied = !snapshot.listFilter.isEmpty(),
+            )
+        }
+    }
 
-	private suspend fun createChipsList(
-		source: MangaSource,
-		capabilities: MangaListFilterCapabilities,
-		tagsProperty: FilterProperty<MangaTag>,
-		snapshot: MangaListFilter,
-		limit: Int,
-	): List<ChipsView.ChipModel> {
-		val result = ArrayDeque<ChipsView.ChipModel>(limit + 3)
-		if (snapshot.query.isNullOrEmpty() || capabilities.isSearchWithFiltersSupported) {
-			val selectedTags = tagsProperty.selectedItems.toMutableSet()
-			var tags = if (selectedTags.isEmpty()) {
-				searchRepository.getTagsSuggestion("", limit, source)
-			} else {
-				searchRepository.getTagsSuggestion(selectedTags).take(limit)
-			}
-			if (tags.size < limit) {
-				tags = tags + tagsProperty.availableItems.take(limit - tags.size)
-			}
-			if (tags.isEmpty() && selectedTags.isEmpty()) {
-				return emptyList()
-			}
-			for (tag in tags) {
-				val model = ChipsView.ChipModel(
-					title = tag.title,
-					isChecked = selectedTags.remove(tag),
-					data = tag,
-				)
-				if (model.isChecked) {
-					result.addFirst(model)
-				} else {
-					result.addLast(model)
-				}
-			}
-			for (tag in selectedTags) {
-				val model = ChipsView.ChipModel(
-					title = tag.title,
-					isChecked = true,
-					data = tag,
-				)
-				result.addFirst(model)
-			}
-		}
-		snapshot.locale?.let {
-			result.addFirst(
-				ChipsView.ChipModel(
-					title = it.getDisplayName(it).toTitleCase(it),
-					icon = R.drawable.ic_language,
-					isCloseable = true,
-					data = it,
-				),
-			)
-		}
-		snapshot.types.forEach {
-			result.addFirst(
-				ChipsView.ChipModel(
-					titleResId = it.titleResId,
-					isCloseable = true,
-					data = it,
-				),
-			)
-		}
-		snapshot.demographics.forEach {
-			result.addFirst(
-				ChipsView.ChipModel(
-					titleResId = it.titleResId,
-					isCloseable = true,
-					data = it,
-				),
-			)
-		}
-		snapshot.contentRating.forEach {
-			result.addFirst(
-				ChipsView.ChipModel(
-					titleResId = it.titleResId,
-					isCloseable = true,
-					data = it,
-				),
-			)
-		}
-		snapshot.states.forEach {
-			result.addFirst(
-				ChipsView.ChipModel(
-					titleResId = it.titleResId,
-					isCloseable = true,
-					data = it,
-				),
-			)
-		}
-		if (!snapshot.query.isNullOrEmpty()) {
-			result.addFirst(
-				ChipsView.ChipModel(
-					title = snapshot.query,
-					icon = appcompatR.drawable.abc_ic_search_api_material,
-					isCloseable = true,
-					data = snapshot.query,
-				),
-			)
-		}
-		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 suspend fun createChipsList(
+        source: MangaSource,
+        capabilities: MangaListFilterCapabilities,
+        savedFilters: FilterProperty<PersistableFilter>,
+        tagsProperty: FilterProperty<MangaTag>,
+        snapshot: MangaListFilter,
+        limit: Int,
+    ): List<ChipsView.ChipModel> {
+        val result = ArrayDeque<ChipsView.ChipModel>(savedFilters.availableItems.size + limit + 3)
+        if (snapshot.query.isNullOrEmpty() || capabilities.isSearchWithFiltersSupported) {
+            val selectedTags = tagsProperty.selectedItems.toMutableSet()
+            var tags = if (selectedTags.isEmpty()) {
+                searchRepository.getTagsSuggestion("", limit, source)
+            } else {
+                searchRepository.getTagsSuggestion(selectedTags).take(limit)
+            }
+            if (tags.size < limit) {
+                tags = tags + tagsProperty.availableItems.take(limit - tags.size)
+            }
+            if (tags.isEmpty() && selectedTags.isEmpty()) {
+                return emptyList()
+            }
+            for (saved in savedFilters.availableItems) {
+                val model = ChipsView.ChipModel(
+                    title = saved.name,
+                    isChecked = saved in savedFilters.selectedItems,
+                    data = saved,
+                )
+                if (model.isChecked) {
+                    selectedTags.removeAll(saved.filter.tags)
+                    result.addFirst(model)
+                } else {
+                    result.addLast(model)
+                }
+            }
+            for (tag in tags) {
+                val model = ChipsView.ChipModel(
+                    title = tag.title,
+                    isChecked = selectedTags.remove(tag),
+                    data = tag,
+                )
+                if (model.isChecked) {
+                    result.addFirst(model)
+                } else {
+                    result.addLast(model)
+                }
+            }
+            for (tag in selectedTags) {
+                val model = ChipsView.ChipModel(
+                    title = tag.title,
+                    isChecked = true,
+                    data = tag,
+                )
+                result.addFirst(model)
+            }
+        }
+        snapshot.locale?.let {
+            result.addFirst(
+                ChipsView.ChipModel(
+                    title = it.getDisplayName(it).toTitleCase(it),
+                    icon = R.drawable.ic_language,
+                    isCloseable = true,
+                    data = it,
+                ),
+            )
+        }
+        snapshot.types.forEach {
+            result.addFirst(
+                ChipsView.ChipModel(
+                    titleResId = it.titleResId,
+                    isCloseable = true,
+                    data = it,
+                ),
+            )
+        }
+        snapshot.demographics.forEach {
+            result.addFirst(
+                ChipsView.ChipModel(
+                    titleResId = it.titleResId,
+                    isCloseable = true,
+                    data = it,
+                ),
+            )
+        }
+        snapshot.contentRating.forEach {
+            result.addFirst(
+                ChipsView.ChipModel(
+                    titleResId = it.titleResId,
+                    isCloseable = true,
+                    data = it,
+                ),
+            )
+        }
+        snapshot.states.forEach {
+            result.addFirst(
+                ChipsView.ChipModel(
+                    titleResId = it.titleResId,
+                    isCloseable = true,
+                    data = it,
+                ),
+            )
+        }
+        if (!snapshot.query.isNullOrEmpty()) {
+            result.addFirst(
+                ChipsView.ChipModel(
+                    title = snapshot.query,
+                    icon = appcompatR.drawable.abc_ic_search_api_material,
+                    isCloseable = true,
+                    data = snapshot.query,
+                ),
+            )
+        }
+        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(
-		titleResId = R.string.genres,
-		icon = R.drawable.ic_drawer_menu_open,
-	)
+    private fun moreTagsChip() = ChipsView.ChipModel(
+        titleResId = R.string.genres,
+        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,501 @@ 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,
-	ChipsView.OnChipClickListener {
+    AdapterView.OnItemSelectedListener,
+    View.OnClickListener,
+    ChipsView.OnChipClickListener,
+    ChipsView.OnChipLongClickListener,
+    ChipsView.OnChipCloseClickListener {
 
-	override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): SheetFilterBinding {
-		return SheetFilterBinding.inflate(inflater, container, false)
-	}
+    override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): SheetFilterBinding {
+        return SheetFilterBinding.inflate(inflater, container, false)
+    }
 
-	override fun onViewBindingCreated(binding: SheetFilterBinding, savedInstanceState: Bundle?) {
-		super.onViewBindingCreated(binding, savedInstanceState)
-		if (dialog == null) {
-			binding.layoutBody.updatePadding(top = binding.layoutBody.paddingBottom)
-			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-				binding.scrollView.scrollIndicators = 0
-			}
-		}
-		val filter = FilterCoordinator.require(this)
-		filter.sortOrder.observe(viewLifecycleOwner, this::onSortOrderChanged)
-		filter.locale.observe(viewLifecycleOwner, this::onLocaleChanged)
-		filter.originalLocale.observe(viewLifecycleOwner, this::onOriginalLocaleChanged)
-		filter.tags.observe(viewLifecycleOwner, this::onTagsChanged)
-		filter.tagsExcluded.observe(viewLifecycleOwner, this::onTagsExcludedChanged)
-		filter.states.observe(viewLifecycleOwner, this::onStateChanged)
-		filter.contentTypes.observe(viewLifecycleOwner, this::onContentTypesChanged)
-		filter.contentRating.observe(viewLifecycleOwner, this::onContentRatingChanged)
-		filter.demographics.observe(viewLifecycleOwner, this::onDemographicsChanged)
-		filter.year.observe(viewLifecycleOwner, this::onYearChanged)
-		filter.yearRange.observe(viewLifecycleOwner, this::onYearRangeChanged)
+    override fun onViewBindingCreated(binding: SheetFilterBinding, savedInstanceState: Bundle?) {
+        super.onViewBindingCreated(binding, savedInstanceState)
+        if (dialog == null) {
+            binding.adjustForEmbeddedLayout()
+        }
+        val filter = FilterCoordinator.require(this)
+        filter.sortOrder.observe(viewLifecycleOwner, this::onSortOrderChanged)
+        filter.locale.observe(viewLifecycleOwner, this::onLocaleChanged)
+        filter.originalLocale.observe(viewLifecycleOwner, this::onOriginalLocaleChanged)
+        filter.tags.observe(viewLifecycleOwner, this::onTagsChanged)
+        filter.tagsExcluded.observe(viewLifecycleOwner, this::onTagsExcludedChanged)
+        filter.authors.observe(viewLifecycleOwner, this::onAuthorsChanged)
+        filter.states.observe(viewLifecycleOwner, this::onStateChanged)
+        filter.contentTypes.observe(viewLifecycleOwner, this::onContentTypesChanged)
+        filter.contentRating.observe(viewLifecycleOwner, this::onContentRatingChanged)
+        filter.demographics.observe(viewLifecycleOwner, this::onDemographicsChanged)
+        filter.year.observe(viewLifecycleOwner, this::onYearChanged)
+        filter.yearRange.observe(viewLifecycleOwner, this::onYearRangeChanged)
+        filter.savedFilters.observe(viewLifecycleOwner, ::onSavedPresetsChanged)
 
-		binding.layoutGenres.setTitle(
-			if (filter.capabilities.isMultipleTagsSupported) {
-				R.string.genres
-			} else {
-				R.string.genre
-			},
-		)
-		binding.spinnerLocale.onItemSelectedListener = this
-		binding.spinnerOriginalLocale.onItemSelectedListener = this
-		binding.spinnerOrder.onItemSelectedListener = this
-		binding.chipsState.onChipClickListener = this
-		binding.chipsTypes.onChipClickListener = this
-		binding.chipsContentRating.onChipClickListener = this
-		binding.chipsDemographics.onChipClickListener = this
-		binding.chipsGenres.onChipClickListener = this
-		binding.chipsGenresExclude.onChipClickListener = this
-		binding.sliderYear.addOnChangeListener(this::onSliderValueChange)
-		binding.sliderYearsRange.addOnChangeListener(this::onRangeSliderValueChange)
-		binding.layoutGenres.setOnMoreButtonClickListener {
-			router.showTagsCatalogSheet(excludeMode = false)
-		}
-		binding.layoutGenresExclude.setOnMoreButtonClickListener {
-			router.showTagsCatalogSheet(excludeMode = true)
-		}
-	}
+        binding.layoutGenres.setTitle(
+            if (filter.capabilities.isMultipleTagsSupported) {
+                R.string.genres
+            } else {
+                R.string.genre
+            },
+        )
+        binding.spinnerLocale.onItemSelectedListener = this
+        binding.spinnerOriginalLocale.onItemSelectedListener = this
+        binding.spinnerOrder.onItemSelectedListener = this
+        binding.chipsSavedFilters.onChipClickListener = this
+        binding.chipsState.onChipClickListener = this
+        binding.chipsTypes.onChipClickListener = this
+        binding.chipsContentRating.onChipClickListener = this
+        binding.chipsDemographics.onChipClickListener = this
+        binding.chipsGenres.onChipClickListener = this
+        binding.chipsGenresExclude.onChipClickListener = this
+        binding.chipsAuthor.onChipClickListener = this
+        binding.chipsSavedFilters.onChipLongClickListener = this
+        binding.chipsSavedFilters.onChipCloseClickListener = this
+        binding.sliderYear.addOnChangeListener(this::onSliderValueChange)
+        binding.sliderYearsRange.addOnChangeListener(this::onRangeSliderValueChange)
+        binding.layoutGenres.setOnMoreButtonClickListener {
+            router.showTagsCatalogSheet(excludeMode = false)
+        }
+        binding.layoutGenresExclude.setOnMoreButtonClickListener {
+            router.showTagsCatalogSheet(excludeMode = true)
+        }
+        combine(
+            filter.observe().map { it.listFilter.isNotEmpty() }.distinctUntilChanged(),
+            filter.savedFilters.map { it.selectedItems.isEmpty() }.distinctUntilChanged(),
+            Boolean::and,
+        ).flowOn(Dispatchers.Default)
+            .observe(viewLifecycleOwner) {
+                binding.buttonSave.isEnabled = it
+            }
+        binding.buttonSave.setOnClickListener(this)
+        binding.buttonDone.setOnClickListener(this)
+    }
 
-	override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
-		val typeMask = WindowInsetsCompat.Type.systemBars()
-		viewBinding?.scrollView?.updatePadding(
-			bottom = insets.getInsets(typeMask).bottom,
-		)
-		return insets.consume(v, typeMask, bottom = true)
-	}
+    private fun SheetFilterBinding.adjustForEmbeddedLayout() {
+        layoutBody.updatePadding(top = layoutBody.paddingBottom)
+        scrollView.scrollIndicators = 0
+        buttonDone.isVisible = false
+        this.root.updateLayoutParams {
+            height = ViewGroup.LayoutParams.MATCH_PARENT
+        }
+        buttonSave.updateLayoutParams<LinearLayout.LayoutParams> {
+            weight = 0f
+            width = LinearLayout.LayoutParams.WRAP_CONTENT
+            gravity = Gravity.END or Gravity.CENTER_VERTICAL
+        }
+    }
 
-	override fun onItemSelected(parent: AdapterView<*>, view: View?, position: Int, id: Long) {
-		val filter = FilterCoordinator.require(this)
-		when (parent.id) {
-			R.id.spinner_order -> filter.setSortOrder(filter.sortOrder.value.availableItems[position])
-			R.id.spinner_locale -> filter.setLocale(filter.locale.value.availableItems[position])
-			R.id.spinner_original_locale -> filter.setOriginalLocale(filter.originalLocale.value.availableItems[position])
-		}
-	}
+    override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+        val typeMask = WindowInsetsCompat.Type.systemBars()
+        viewBinding?.layoutBottom?.updateLayoutParams<ViewGroup.MarginLayoutParams> {
+            bottomMargin = insets.getInsets(typeMask).bottom
+        }
+        return insets.consume(v, typeMask, bottom = true)
+    }
 
-	override fun onNothingSelected(parent: AdapterView<*>?) = Unit
+    override fun onClick(v: View) {
+        when (v.id) {
+            R.id.button_done -> dismiss()
+            R.id.button_save -> onSaveFilterClick("")
+        }
+    }
 
-	private fun onSliderValueChange(slider: Slider, value: Float, fromUser: Boolean) {
-		if (!fromUser) {
-			return
-		}
-		val intValue = value.toInt()
-		val filter = FilterCoordinator.require(this)
-		when (slider.id) {
-			R.id.slider_year -> filter.setYear(
-				if (intValue <= slider.valueFrom.toIntUp()) {
-					YEAR_UNKNOWN
-				} else {
-					intValue
-				},
-			)
-		}
-	}
+    override fun onItemSelected(parent: AdapterView<*>, view: View?, position: Int, id: Long) {
+        val filter = FilterCoordinator.require(this)
+        when (parent.id) {
+            R.id.spinner_order -> filter.setSortOrder(filter.sortOrder.value.availableItems[position])
+            R.id.spinner_locale -> filter.setLocale(filter.locale.value.availableItems[position])
+            R.id.spinner_original_locale -> filter.setOriginalLocale(filter.originalLocale.value.availableItems[position])
+        }
+    }
 
-	private fun onRangeSliderValueChange(slider: RangeSlider, value: Float, fromUser: Boolean) {
-		if (!fromUser) {
-			return
-		}
-		val filter = FilterCoordinator.require(this)
-		when (slider.id) {
-			R.id.slider_yearsRange -> filter.setYearRange(
-				valueFrom = slider.values.firstOrNull()?.let {
-					if (it <= slider.valueFrom) YEAR_UNKNOWN else it.toInt()
-				} ?: YEAR_UNKNOWN,
-				valueTo = slider.values.lastOrNull()?.let {
-					if (it >= slider.valueTo) YEAR_UNKNOWN else it.toInt()
-				} ?: YEAR_UNKNOWN,
-			)
-		}
-	}
+    override fun onNothingSelected(parent: AdapterView<*>?) = Unit
 
-	override fun onChipClick(chip: Chip, data: Any?) {
-		val filter = FilterCoordinator.require(this)
-		when (data) {
-			is MangaState -> filter.toggleState(data, !chip.isChecked)
-			is MangaTag -> if (chip.parentView?.id == R.id.chips_genresExclude) {
-				filter.toggleTagExclude(data, !chip.isChecked)
-			} else {
-				filter.toggleTag(data, !chip.isChecked)
-			}
+    private fun onSliderValueChange(slider: Slider, value: Float, fromUser: Boolean) {
+        if (!fromUser) {
+            return
+        }
+        val intValue = value.toInt()
+        val filter = FilterCoordinator.require(this)
+        when (slider.id) {
+            R.id.slider_year -> filter.setYear(
+                if (intValue <= slider.valueFrom.toIntUp()) {
+                    YEAR_UNKNOWN
+                } else {
+                    intValue
+                },
+            )
+        }
+    }
 
-			is ContentType -> filter.toggleContentType(data, !chip.isChecked)
-			is ContentRating -> filter.toggleContentRating(data, !chip.isChecked)
-			is Demographic -> filter.toggleDemographic(data, !chip.isChecked)
-			null -> router.showTagsCatalogSheet(excludeMode = chip.parentView?.id == R.id.chips_genresExclude)
-		}
-	}
+    private fun onRangeSliderValueChange(slider: RangeSlider, value: Float, fromUser: Boolean) {
+        if (!fromUser) {
+            return
+        }
+        val filter = FilterCoordinator.require(this)
+        when (slider.id) {
+            R.id.slider_yearsRange -> filter.setYearRange(
+                valueFrom = slider.values.firstOrNull()?.let {
+                    if (it <= slider.valueFrom) YEAR_UNKNOWN else it.toInt()
+                } ?: YEAR_UNKNOWN,
+                valueTo = slider.values.lastOrNull()?.let {
+                    if (it >= slider.valueTo) YEAR_UNKNOWN else it.toInt()
+                } ?: YEAR_UNKNOWN,
+            )
+        }
+    }
 
-	private fun onSortOrderChanged(value: FilterProperty<SortOrder>) {
-		val b = viewBinding ?: return
-		b.layoutOrder.isGone = value.isEmpty()
-		if (value.isEmpty()) {
-			return
-		}
-		val selected = value.selectedItems.single()
-		b.spinnerOrder.adapter = ArrayAdapter(
-			b.spinnerOrder.context,
-			android.R.layout.simple_spinner_dropdown_item,
-			android.R.id.text1,
-			value.availableItems.map { b.spinnerOrder.context.getString(it.titleRes) },
-		)
-		val selectedIndex = value.availableItems.indexOf(selected)
-		if (selectedIndex >= 0) {
-			b.spinnerOrder.setSelection(selectedIndex, false)
-		}
-	}
+    override fun onChipClick(chip: Chip, data: Any?) {
+        val filter = FilterCoordinator.require(this)
+        when (data) {
+            is MangaState -> filter.toggleState(data, !chip.isChecked)
+            is MangaTag -> if (chip.parentView?.id == R.id.chips_genresExclude) {
+                filter.toggleTagExclude(data, !chip.isChecked)
+            } else {
+                filter.toggleTag(data, !chip.isChecked)
+            }
 
-	private fun onLocaleChanged(value: FilterProperty<Locale?>) {
-		val b = viewBinding ?: return
-		b.layoutLocale.isGone = value.isEmpty()
-		if (value.isEmpty()) {
-			return
-		}
-		val selected = value.selectedItems.singleOrNull()
-		b.spinnerLocale.adapter = ArrayAdapter(
-			b.spinnerLocale.context,
-			android.R.layout.simple_spinner_dropdown_item,
-			android.R.id.text1,
-			value.availableItems.map { it.getDisplayName(b.spinnerLocale.context) },
-		)
-		val selectedIndex = value.availableItems.indexOf(selected)
-		if (selectedIndex >= 0) {
-			b.spinnerLocale.setSelection(selectedIndex, false)
-		}
-	}
+            is ContentType -> filter.toggleContentType(data, !chip.isChecked)
+            is ContentRating -> filter.toggleContentRating(data, !chip.isChecked)
+            is Demographic -> filter.toggleDemographic(data, !chip.isChecked)
+            is PersistableFilter -> filter.setAdjusted(data.filter)
+            is String -> if (chip.isChecked) {
+                filter.setAuthor(null)
+            } 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()) {
-			return
-		}
-		val selected = value.selectedItems.singleOrNull()
-		b.spinnerOriginalLocale.adapter = ArrayAdapter(
-			b.spinnerOriginalLocale.context,
-			android.R.layout.simple_spinner_dropdown_item,
-			android.R.id.text1,
-			value.availableItems.map { it.getDisplayName(b.spinnerOriginalLocale.context) },
-		)
-		val selectedIndex = value.availableItems.indexOf(selected)
-		if (selectedIndex >= 0) {
-			b.spinnerOriginalLocale.setSelection(selectedIndex, false)
-		}
-	}
+    override fun onChipLongClick(chip: Chip, data: Any?): Boolean {
+        return when (data) {
+            is PersistableFilter -> {
+                showSavedFilterMenu(chip, data)
+                true
+            }
 
-	private fun onTagsChanged(value: FilterProperty<MangaTag>) {
-		val b = viewBinding ?: return
-		b.layoutGenres.isGone = value.isEmptyAndSuccess()
-		b.layoutGenres.setError(value.error?.getDisplayMessage(resources))
-		if (value.isEmpty()) {
-			return
-		}
-		val chips = value.availableItems.map { tag ->
-			ChipsView.ChipModel(
-				title = tag.title,
-				isChecked = tag in value.selectedItems,
-				data = tag,
-			)
-		}
-		b.chipsGenres.setChips(chips)
-	}
+            else -> false
+        }
+    }
 
-	private fun onTagsExcludedChanged(value: FilterProperty<MangaTag>) {
-		val b = viewBinding ?: return
-		b.layoutGenresExclude.isGone = value.isEmpty()
-		if (value.isEmpty()) {
-			return
-		}
-		val chips = value.availableItems.map { tag ->
-			ChipsView.ChipModel(
-				title = tag.title,
-				isChecked = tag in value.selectedItems,
-				data = tag,
-			)
-		}
-		b.chipsGenresExclude.setChips(chips)
-	}
+    override fun onChipCloseClick(chip: Chip, data: Any?) {
+        when (data) {
+            is PersistableFilter -> {
+                showSavedFilterMenu(chip, data)
+            }
+        }
+    }
 
-	private fun onStateChanged(value: FilterProperty<MangaState>) {
-		val b = viewBinding ?: return
-		b.layoutState.isGone = value.isEmpty()
-		if (value.isEmpty()) {
-			return
-		}
-		val chips = value.availableItems.map { state ->
-			ChipsView.ChipModel(
-				title = getString(state.titleResId),
-				isChecked = state in value.selectedItems,
-				data = state,
-			)
-		}
-		b.chipsState.setChips(chips)
-	}
+    private fun onSortOrderChanged(value: FilterProperty<SortOrder>) {
+        val b = viewBinding ?: return
+        b.layoutOrder.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val selected = value.selectedItems.single()
+        b.spinnerOrder.adapter = ArrayAdapter(
+            b.spinnerOrder.context,
+            android.R.layout.simple_spinner_dropdown_item,
+            android.R.id.text1,
+            value.availableItems.map { b.spinnerOrder.context.getString(it.titleRes) },
+        )
+        val selectedIndex = value.availableItems.indexOf(selected)
+        if (selectedIndex >= 0) {
+            b.spinnerOrder.setSelection(selectedIndex, false)
+        }
+    }
 
-	private fun onContentTypesChanged(value: FilterProperty<ContentType>) {
-		val b = viewBinding ?: return
-		b.layoutTypes.isGone = value.isEmpty()
-		if (value.isEmpty()) {
-			return
-		}
-		val chips = value.availableItems.map { type ->
-			ChipsView.ChipModel(
-				title = getString(type.titleResId),
-				isChecked = type in value.selectedItems,
-				data = type,
-			)
-		}
-		b.chipsTypes.setChips(chips)
-	}
+    private fun onLocaleChanged(value: FilterProperty<Locale?>) {
+        val b = viewBinding ?: return
+        b.layoutLocale.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val selected = value.selectedItems.singleOrNull()
+        b.spinnerLocale.adapter = ArrayAdapter(
+            b.spinnerLocale.context,
+            android.R.layout.simple_spinner_dropdown_item,
+            android.R.id.text1,
+            value.availableItems.map { it.getDisplayName(b.spinnerLocale.context) },
+        )
+        val selectedIndex = value.availableItems.indexOf(selected)
+        if (selectedIndex >= 0) {
+            b.spinnerLocale.setSelection(selectedIndex, false)
+        }
+    }
 
-	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 onOriginalLocaleChanged(value: FilterProperty<Locale?>) {
+        val b = viewBinding ?: return
+        b.layoutOriginalLocale.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val selected = value.selectedItems.singleOrNull()
+        b.spinnerOriginalLocale.adapter = ArrayAdapter(
+            b.spinnerOriginalLocale.context,
+            android.R.layout.simple_spinner_dropdown_item,
+            android.R.id.text1,
+            value.availableItems.map { it.getDisplayName(b.spinnerOriginalLocale.context) },
+        )
+        val selectedIndex = value.availableItems.indexOf(selected)
+        if (selectedIndex >= 0) {
+            b.spinnerOriginalLocale.setSelection(selectedIndex, false)
+        }
+    }
 
-	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 onTagsChanged(value: FilterProperty<MangaTag>) {
+        val b = viewBinding ?: return
+        b.layoutGenres.isGone = value.isEmptyAndSuccess()
+        b.layoutGenres.setError(value.error?.getDisplayMessage(resources))
+        if (value.isEmpty()) {
+            return
+        }
+        val chips = value.availableItems.map { tag ->
+            ChipsView.ChipModel(
+                title = tag.title,
+                isChecked = tag in value.selectedItems,
+                data = tag,
+            )
+        }
+        b.chipsGenres.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 onTagsExcludedChanged(value: FilterProperty<MangaTag>) {
+        val b = viewBinding ?: return
+        b.layoutGenresExclude.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val chips = value.availableItems.map { tag ->
+            ChipsView.ChipModel(
+                title = tag.title,
+                isChecked = tag in value.selectedItems,
+                data = tag,
+            )
+        }
+        b.chipsGenresExclude.setChips(chips)
+    }
 
-	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 onAuthorsChanged(value: FilterProperty<String>) {
+        val b = viewBinding ?: return
+        b.layoutAuthor.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val chips = value.availableItems.map { author ->
+            ChipsView.ChipModel(
+                title = author,
+                isChecked = author in value.selectedItems,
+                data = author,
+            )
+        }
+        b.chipsAuthor.setChips(chips)
+    }
+
+    private fun onStateChanged(value: FilterProperty<MangaState>) {
+        val b = viewBinding ?: return
+        b.layoutState.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val chips = value.availableItems.map { state ->
+            ChipsView.ChipModel(
+                title = getString(state.titleResId),
+                isChecked = state in value.selectedItems,
+                data = state,
+            )
+        }
+        b.chipsState.setChips(chips)
+    }
+
+    private fun onContentTypesChanged(value: FilterProperty<ContentType>) {
+        val b = viewBinding ?: return
+        b.layoutTypes.isGone = value.isEmpty()
+        if (value.isEmpty()) {
+            return
+        }
+        val chips = value.availableItems.map { type ->
+            ChipsView.ChipModel(
+                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,13 +3,16 @@ 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
+import org.koitharu.kotatsu.core.model.isNsfw
 import org.koitharu.kotatsu.core.parser.MangaDataRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.ListMode
@@ -21,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>>
@@ -45,7 +51,7 @@ abstract class MangaListViewModel(
 	abstract fun onRetry()
 
 	protected fun List<Manga>.skipNsfwIfNeeded() = if (settings.isNsfwContentDisabled) {
-		filterNot { it.isNsfw }
+		filterNot { it.isNsfw() }
 	} else {
 		this
 	}
@@ -62,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/LocalMangaRepository.kt

@@ -12,6 +12,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.runInterruptible
 import org.koitharu.kotatsu.core.model.LocalMangaSource
 import org.koitharu.kotatsu.core.model.isLocal
+import org.koitharu.kotatsu.core.model.isNsfw
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.AlphanumComparator
@@ -94,7 +95,7 @@ class LocalMangaRepository @Inject constructor(
 		}
 		val list = getRawList()
 		if (settings.isNsfwContentDisabled) {
-			list.removeAll { it.manga.isNsfw }
+			list.removeAll { it.manga.isNsfw() }
 		}
 		if (filter != null) {
 			val query = filter.query
@@ -109,7 +110,7 @@ class LocalMangaRepository @Inject constructor(
 			}
 			filter.contentRating.singleOrNull()?.let { contentRating ->
 				val isNsfw = contentRating == ContentRating.ADULT
-				list.retainAll { it.manga.isNsfw == isNsfw }
+				list.retainAll { it.manga.isNsfw() == isNsfw }
 			}
 			if (!query.isNullOrEmpty() && order == SortOrder.RELEVANCE) {
 				list.sortBy { it.manga.title.levenshteinDistance(query) }

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,
-	private val settings: AppSettings,
+    @LocalizedAppContext private val context: Context,
+    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/MainNavigationDelegate.kt

@@ -1,15 +1,18 @@
 package org.koitharu.kotatsu.main.ui
 
 import android.os.Bundle
+import android.view.Gravity
 import android.view.Menu
 import android.view.MenuItem
 import android.view.View
+import android.widget.FrameLayout
 import androidx.activity.OnBackPressedCallback
 import androidx.annotation.IdRes
 import androidx.core.view.isEmpty
 import androidx.core.view.isVisible
 import androidx.core.view.iterator
 import androidx.core.view.size
+import androidx.core.view.updateLayoutParams
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentManager
 import androidx.lifecycle.LifecycleOwner
@@ -66,6 +69,9 @@ class MainNavigationDelegate(
 		navBar.setOnItemSelectedListener(this)
 		navBar.setOnItemReselectedListener(this)
 		navRailHeader?.run {
+			root.updateLayoutParams<FrameLayout.LayoutParams> {
+				gravity = Gravity.TOP or Gravity.CENTER
+			}
 			val horizontalPadding = (navBar as NavigationRailView).itemActiveIndicatorMarginHorizontal
 			root.setPadding(horizontalPadding, 0, horizontalPadding, 0)
 			buttonExpand.setOnClickListener(this@MainNavigationDelegate)
@@ -295,6 +301,9 @@ class MainNavigationDelegate(
 		if (value) {
 			navBar.expand()
 			navRailHeader?.run {
+				root.updateLayoutParams<FrameLayout.LayoutParams> {
+					gravity = Gravity.TOP or Gravity.START
+				}
 				railFab.extend()
 				buttonExpand.setImageResource(R.drawable.ic_drawer_menu_open)
 				buttonExpand.setContentDescriptionAndTooltip(R.string.collapse)
@@ -304,6 +313,9 @@ class MainNavigationDelegate(
 		} else {
 			navBar.collapse()
 			navRailHeader?.run {
+				root.updateLayoutParams<FrameLayout.LayoutParams> {
+					gravity = Gravity.TOP or Gravity.CENTER
+				}
 				railFab.shrink()
 				buttonExpand.setImageResource(R.drawable.ic_drawer_menu)
 				buttonExpand.setContentDescriptionAndTooltip(R.string.expand)

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
-		val newChapter = chapters.getOrNull(if (isNext) index + 1 else index - 1) ?: return
+		if (index == -1) return false
+		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
@@ -46,19 +43,19 @@ class EdgeDetector(private val context: Context) {
 					}
 					val scaleFactor = calculateScaleFactor(size)
 					val sampleSize = (1f / scaleFactor).toInt().coerceAtLeast(1)
-					
+
 					val fullBitmap = decoder.decodeRegion(
-						Rect(0, 0, size.x, size.y), 
-						sampleSize
+						Rect(0, 0, size.x, size.y),
+						sampleSize,
 					)
-					
+
 					try {
 						val edges = coroutineScope {
 							listOf(
-							async { detectLeftRightEdge(fullBitmap, size, sampleSize, isLeft = true) },
-							async { detectTopBottomEdge(fullBitmap, size, sampleSize, isTop = true) },
-							async { detectLeftRightEdge(fullBitmap, size, sampleSize, isLeft = false) },
-							async { detectTopBottomEdge(fullBitmap, size, sampleSize, isTop = false) },
+								async { detectLeftRightEdge(fullBitmap, size, sampleSize, isLeft = true) },
+								async { detectTopBottomEdge(fullBitmap, size, sampleSize, isTop = true) },
+								async { detectLeftRightEdge(fullBitmap, size, sampleSize, isLeft = false) },
+								async { detectTopBottomEdge(fullBitmap, size, sampleSize, isTop = false) },
 							).awaitAll()
 						}
 						var hasEdges = false
@@ -91,10 +88,10 @@ class EdgeDetector(private val context: Context) {
 		val rectCount = size.x / BLOCK_SIZE
 		val maxRect = rectCount / 3
 		val blockPixels = IntArray(BLOCK_SIZE * BLOCK_SIZE)
-		
+
 		val bitmapWidth = bitmap.width
 		val bitmapHeight = bitmap.height
-		
+
 		for (i in 0 until rectCount) {
 			if (i > maxRect) {
 				return -1
@@ -103,16 +100,16 @@ class EdgeDetector(private val context: Context) {
 			for (j in 0 until size.y / BLOCK_SIZE) {
 				val regionX = if (isLeft) i * BLOCK_SIZE else size.x - (i + 1) * BLOCK_SIZE
 				val regionY = j * BLOCK_SIZE
-				
+
 				// Convert to bitmap coordinates
 				val bitmapX = regionX / sampleSize
 				val bitmapY = regionY / sampleSize
 				val blockWidth = min(BLOCK_SIZE / sampleSize, bitmapWidth - bitmapX)
 				val blockHeight = min(BLOCK_SIZE / sampleSize, bitmapHeight - bitmapY)
-				
+
 				if (blockWidth > 0 && blockHeight > 0) {
 					bitmap.getPixels(blockPixels, 0, blockWidth, bitmapX, bitmapY, blockWidth, blockHeight)
-					
+
 					for (ii in 0 until minOf(blockWidth, dd / sampleSize)) {
 						for (jj in 0 until blockHeight) {
 							val bi = if (isLeft) ii else blockWidth - ii - 1
@@ -141,10 +138,10 @@ class EdgeDetector(private val context: Context) {
 		val rectCount = size.y / BLOCK_SIZE
 		val maxRect = rectCount / 3
 		val blockPixels = IntArray(BLOCK_SIZE * BLOCK_SIZE)
-		
+
 		val bitmapWidth = bitmap.width
 		val bitmapHeight = bitmap.height
-		
+
 		for (j in 0 until rectCount) {
 			if (j > maxRect) {
 				return -1
@@ -153,16 +150,16 @@ class EdgeDetector(private val context: Context) {
 			for (i in 0 until size.x / BLOCK_SIZE) {
 				val regionX = i * BLOCK_SIZE
 				val regionY = if (isTop) j * BLOCK_SIZE else size.y - (j + 1) * BLOCK_SIZE
-				
+
 				// Convert to bitmap coordinates
 				val bitmapX = regionX / sampleSize
 				val bitmapY = regionY / sampleSize
 				val blockWidth = min(BLOCK_SIZE / sampleSize, bitmapWidth - bitmapX)
 				val blockHeight = min(BLOCK_SIZE / sampleSize, bitmapHeight - bitmapY)
-				
+
 				if (blockWidth > 0 && blockHeight > 0) {
 					bitmap.getPixels(blockPixels, 0, blockWidth, bitmapX, bitmapY, blockWidth, blockHeight)
-					
+
 					for (jj in 0 until minOf(blockHeight, dd / sampleSize)) {
 						for (ii in 0 until blockWidth) {
 							val bj = if (isTop) jj else blockHeight - jj - 1
@@ -218,4 +215,4 @@ class EdgeDetector(private val context: Context) {
 
 		private fun region(x: Int, y: Int) = Rect(x, y, x + BLOCK_SIZE, y + BLOCK_SIZE)
 	}
-}
+}

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

@@ -3,7 +3,6 @@ package org.koitharu.kotatsu.reader.ui
 import android.app.assist.AssistContent
 import android.content.DialogInterface
 import android.content.Intent
-import android.os.Build
 import android.os.Bundle
 import android.view.Gravity
 import android.view.KeyEvent
@@ -215,9 +214,7 @@ class ReaderActivity :
 
 	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.isMangaNsfw
@@ -374,6 +371,7 @@ class ReaderActivity :
 			viewBinding.infoBar.isTimeVisible = isFullscreen
 			updateScrollTimerButton()
 			systemUiController.setSystemUiVisible(isUiVisible || !isFullscreen)
+			viewBinding.root.requestApplyInsets()
 		}
 	}
 
@@ -395,8 +393,14 @@ class ReaderActivity :
 		viewBinding.infoBar.updatePadding(
 			top = systemBars.top,
 		)
+		val innerInsets = Insets.of(
+			systemBars.left,
+			if (viewBinding.appbarTop.isVisible) viewBinding.appbarTop.height else systemBars.top,
+			systemBars.right,
+			viewBinding.toolbarDocked?.takeIf { it.isVisible }?.height ?: systemBars.bottom,
+		)
 		return WindowInsetsCompat.Builder(insets)
-			.setInsets(WindowInsetsCompat.Type.systemBars(), Insets.NONE)
+			.setInsets(WindowInsetsCompat.Type.systemBars(), innerInsets)
 			.build()
 	}
 
@@ -484,7 +488,11 @@ class ReaderActivity :
 			uiState.incognito -> getString(R.string.incognito_mode)
 			else -> chapterTitle
 		}
-		if (chapterTitle != previous?.getChapterTitle(resources) && chapterTitle.isNotEmpty()) {
+		if (
+			settings.isReaderChapterToastEnabled &&
+			chapterTitle != previous?.getChapterTitle(resources) &&
+			chapterTitle.isNotEmpty()
+		) {
 			viewBinding.toastView.showTemporary(chapterTitle, TOAST_DURATION)
 		}
 		if (uiState.isSliderAvailable()) {

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

@@ -157,6 +157,12 @@ class ReaderViewModel @Inject constructor(
 		valueProducer = { isWebtoonGapsEnabled },
 	)
 
+	val isWebtoonPullGestureEnabled = settings.observeAsStateFlow(
+		scope = viewModelScope + Dispatchers.Default,
+		key = AppSettings.KEY_WEBTOON_PULL_GESTURE,
+		valueProducer = { isWebtoonPullGestureEnabled },
+	)
+
 	val defaultWebtoonZoomOut = observeIsWebtoonZoomEnabled().flatMapLatest {
 		if (it) {
 			observeWebtoonZoomOut()
@@ -345,11 +351,14 @@ class ReaderViewModel @Inject constructor(
 				return@launchJob
 			}
 			ensureActive()
-			if (upperPos >= pages.lastIndex - BOUNDS_PAGE_OFFSET) {
-				loadPrevNextChapter(pages.last().chapterId, isNext = true)
-			}
-			if (lowerPos <= BOUNDS_PAGE_OFFSET) {
-				loadPrevNextChapter(pages.first().chapterId, isNext = false)
+			val autoLoadAllowed = readerMode.value != ReaderMode.WEBTOON || !isWebtoonPullGestureEnabled.value
+			if (autoLoadAllowed) {
+				if (upperPos >= pages.lastIndex - BOUNDS_PAGE_OFFSET) {
+					loadPrevNextChapter(pages.last().chapterId, isNext = true)
+				}
+				if (lowerPos <= BOUNDS_PAGE_OFFSET) {
+					loadPrevNextChapter(pages.first().chapterId, isNext = false)
+				}
 			}
 			if (pageLoader.isPrefetchApplicable()) {
 				pageLoader.prefetch(pages.trySublist(upperPos + 1, upperPos + PREFETCH_LIMIT))

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
@@ -37,7 +41,8 @@ class ReaderConfigSheet :
 	BaseAdaptiveSheet<SheetReaderConfigBinding>(),
 	View.OnClickListener,
 	MaterialButtonToggleGroup.OnButtonCheckedListener,
-	CompoundButton.OnCheckedChangeListener {
+	CompoundButton.OnCheckedChangeListener,
+	Slider.OnChangeListener {
 
 	private val viewModel by activityViewModels<ReaderViewModel>()
 
@@ -86,6 +91,9 @@ class ReaderConfigSheet :
 		binding.buttonVertical.isChecked = mode == ReaderMode.VERTICAL
 		binding.switchDoubleReader.isChecked = settings.isReaderDoubleOnLandscape
 		binding.switchDoubleReader.isEnabled = mode == ReaderMode.STANDARD || mode == ReaderMode.REVERSED
+		binding.sliderDoubleSensitivity.setValueRounded(settings.readerDoublePagesSensitivity * 100f)
+		binding.sliderDoubleSensitivity.setLabelFormatter(IntPercentLabelFormatter(binding.root.context))
+        binding.adjustSensitivitySlider(withAnimation = false)
 
 		binding.checkableGroup.addOnButtonCheckedListener(this)
 		binding.buttonSavePage.setOnClickListener(this)
@@ -96,6 +104,7 @@ class ReaderConfigSheet :
 		binding.buttonScrollTimer.setOnClickListener(this)
 		binding.buttonBookmark.setOnClickListener(this)
 		binding.switchDoubleReader.setOnCheckedChangeListener(this)
+		binding.sliderDoubleSensitivity.addOnChangeListener(this)
 
 		viewModel.isBookmarkAdded.observe(viewLifecycleOwner) {
 			binding.buttonBookmark.setText(if (it) R.string.bookmark_remove else R.string.bookmark_add)
@@ -170,11 +179,16 @@ class ReaderConfigSheet :
 
 			R.id.switch_double_reader -> {
 				settings.isReaderDoubleOnLandscape = isChecked
+				viewBinding?.adjustSensitivitySlider(withAnimation = true)
 				findParentCallback(Callback::class.java)?.onDoubleModeChanged(isChecked)
 			}
 		}
 	}
 
+	override fun onValueChange(slider: Slider, value: Float, fromUser: Boolean) {
+		settings.readerDoublePagesSensitivity = value / 100f
+	}
+
 	override fun onButtonChecked(
 		group: MaterialButtonToggleGroup?,
 		checkedId: Int,
@@ -190,7 +204,10 @@ class ReaderConfigSheet :
 			R.id.button_vertical -> ReaderMode.VERTICAL
 			else -> return
 		}
-		viewBinding?.switchDoubleReader?.isEnabled = newMode == ReaderMode.STANDARD || newMode == ReaderMode.REVERSED
+		viewBinding?.run {
+            switchDoubleReader.isEnabled = newMode == ReaderMode.STANDARD || newMode == ReaderMode.REVERSED
+            adjustSensitivitySlider(withAnimation = true)
+        }
 		if (newMode == mode) {
 			return
 		}
@@ -224,6 +241,15 @@ class ReaderConfigSheet :
 		)
 	}
 
+    private fun SheetReaderConfigBinding.adjustSensitivitySlider(withAnimation: Boolean) {
+        val isSliderVisible = switchDoubleReader.isEnabled && switchDoubleReader.isChecked
+        if (isSliderVisible != sliderDoubleSensitivity.isVisible && withAnimation) {
+            TransitionManager.beginDelayedTransition(layoutMain)
+        }
+        sliderDoubleSensitivity.isVisible = isSliderVisible
+        textDoubleSensitivity.isVisible = isSliderVisible
+    }
+
 	interface Callback {
 
 		fun onReaderModeChanged(mode: ReaderMode)

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
-			positionsToMove = roundUpToBlockSize(abs((scroll.toDouble()) / itemSize).roundToInt())
-			if (positionsToMove < blockSize) {
-				// Must move at least one block
-				positionsToMove = blockSize
-			} else if (positionsToMove > maxPositionsToMove) {
-				// Clamp number of positions to move, so we don't get wild flinging.
-				positionsToMove = maxPositionsToMove
+			val sensitivity = settings.readerDoublePagesSensitivity.coerceIn(0f, 1f) * 2.5
+			var positionsToMove = (scroll.toDouble() / (itemSize * (2.5 - sensitivity))).roundToInt()
+
+			// Apply a maximum threshold
+			val maxPages = (4 * sensitivity).roundToInt().coerceAtLeast(1)
+			if (positionsToMove.absoluteValue > maxPages) {
+				positionsToMove = maxPages * positionsToMove.sign
 			}
-			if (scroll < 0) {
-				positionsToMove *= -1
+
+			// Apply a minimum threshold
+			if (positionsToMove == 0 && scroll.absoluteValue > itemSize * 0.2) {
+				positionsToMove = 1 * scroll.sign
 			}
-			if (isRTL) {
-				positionsToMove *= -1
-			}
-			return if (layoutDirectionHelper.isDirectionToBottom(scroll < 0)) {
-				// Scrolling toward the bottom of data.
-				roundDownToBlockSize(llm.findFirstVisibleItemPosition()) + positionsToMove
+
+			val currentPosition = if (layoutDirectionHelper.isDirectionToBottom(scroll < 0)) {
+				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 {

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

@@ -13,6 +13,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.yield
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.os.NetworkState
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.ui.list.lifecycle.RecyclerViewLifecycleDispatcher
 import org.koitharu.kotatsu.core.util.ext.firstVisibleItemPosition
 import org.koitharu.kotatsu.databinding.FragmentReaderDoubleBinding
@@ -33,6 +34,9 @@ open class DoubleReaderFragment : BaseReaderFragment<FragmentReaderDoubleBinding
 	@Inject
 	lateinit var pageLoader: PageLoader
 
+	@Inject
+	lateinit var settings: AppSettings
+
 	private var recyclerLifecycleDispatcher: RecyclerViewLifecycleDispatcher? = null
 
 	override fun onCreateViewBinding(
@@ -51,7 +55,7 @@ open class DoubleReaderFragment : BaseReaderFragment<FragmentReaderDoubleBinding
 				addOnScrollListener(it)
 			}
 			addOnScrollListener(PageScrollListener())
-			DoublePageSnapHelper().attachToRecyclerView(this)
+			DoublePageSnapHelper(settings).attachToRecyclerView(this)
 		}
 	}
 

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

@@ -40,7 +40,7 @@ class WebtoonImageView @JvmOverloads constructor(
 	fun scrollTo(y: Int) {
 		val maxScroll = getScrollRange()
 		if (maxScroll == 0) {
-			resetScaleAndCenter()
+			scrollToInternal(0)
 			return
 		}
 		scrollToInternal(y.coerceIn(0, maxScroll))
@@ -86,9 +86,9 @@ class WebtoonImageView @JvmOverloads constructor(
 				desiredWidth = sWidth
 				desiredHeight = sHeight
 			} else if (resizeHeight) {
-				desiredHeight = (sHeight.toDouble() / sWidth.toDouble() * desiredWidth).roundToInt()
+				desiredHeight = (sHeight.toDouble() / sWidth.toDouble() * desiredWidth).toInt()
 			} else if (resizeWidth) {
-				desiredWidth = (sWidth.toDouble() / sHeight.toDouble() * desiredHeight).roundToInt()
+				desiredWidth = (sWidth.toDouble() / sHeight.toDouble() * desiredHeight).toInt()
 			}
 		}
 		desiredWidth = desiredWidth.coerceAtLeast(suggestedMinimumWidth)