Update readme

Currently translated at 99.8% (895 of 896 strings)

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

README.md

@@ -1,24 +1,16 @@
+> [!IMPORTANT]
+> In light of recent challenges — including threating actions from Kakao Entertainment Corp and upcoming Google’s
+> [new sideloading policy](https://f-droid.org/ru/2025/10/28/sideloading.html) — we’ve made the difficult decision to shut down Kotatsu and end its support. We’re deeply grateful
+> to everyone who contributed and to the amazing community that grew around this project.
+
+---
+
 <div align="center">
 
-<a href="https://kotatsu.app">
+**[Kotatsu](https://github.com/KotatsuApp/Kotatsu) is a free and open-source manga reader for Android with built-in
-    <img src="./.github/assets/vtuber.png" alt="Kotatsu Logo" title="Kotatsu" width="600"/>
+online content sources.**
-</a>
 
-# [Kotatsu](https://kotatsu.app)
+![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)
-
-**[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 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
-
-<div align="left">
-
-* **Recommended:** Download and install APK from [GitHub Releases](https://github.com/KotatsuApp/Kotatsu/releases/latest). Application has a built-in self-updating feature.
-* Get it on [F-Droid](https://f-droid.org/packages/org.koitharu.kotatsu). The F-Droid build may be a bit outdated and some fixes might be missing.
-* Also [nightly builds](https://github.com/KotatsuApp/Kotatsu-nightly/releases) are available (Unstable, use at your own risk). Application has a built-in self-updating feature.
-
-</div>
 
 ### Main Features
 
@@ -86,7 +78,8 @@ please head over to the [Weblate project page](https://hosted.weblate.org/engage
 
 </br>
 
-**📌 Pull requests are welcome, if you want: See [CONTRIBUTING.md](https://github.com/KotatsuApp/Kotatsu/blob/devel/CONTRIBUTING.md) for the guidelines**
+**📌 Pull requests are welcome, if you want:
+See [CONTRIBUTING.md](https://github.com/KotatsuApp/Kotatsu/blob/devel/CONTRIBUTING.md) for the guidelines**
 
 ### Certificate fingerprints
 
@@ -104,7 +97,9 @@ please head over to the [Weblate project page](https://hosted.weblate.org/engage
 
 <div align="left">
 
-You may copy, distribute and modify the software as long as you track changes/dates in source files. Any modifications to or software including (via compiler) GPL-licensed code must also be made available under the GPL along with build & install instructions.
+You may copy, distribute and modify the software as long as you track changes/dates in source files. Any modifications
+to or software including (via compiler) GPL-licensed code must also be made available under the GPL along with build &
+install instructions.
 
 </div>
 
@@ -112,6 +107,9 @@ You may copy, distribute and modify the software as long as you track changes/da
 
 <div align="left">
 
-The developers of this application do not have any affiliation with the content available in the app 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.
+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

@@ -21,8 +21,8 @@ android {
 		applicationId 'org.koitharu.kotatsu'
 		minSdk = 23
 		targetSdk = 36
-		versionCode = 1031
+		versionCode = 1033
-		versionName = '9.3'
+		versionName = '9.4.1'
 		generatedDensities = []
 		testInstrumentationRunner 'org.koitharu.kotatsu.HiltTestRunner'
 		ksp {
@@ -155,6 +155,9 @@ dependencies {
 	implementation libs.androidx.work.runtime
 	implementation libs.guava
 
+    // Foldable/Window layout
+    implementation libs.androidx.window
+
 	implementation libs.androidx.room.runtime
 	implementation libs.androidx.room.ktx
 	ksp libs.androidx.room.compiler

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

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

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

@@ -17,6 +17,7 @@ enum class BackupSection(
 	SOURCES("sources"),
 	SCROBBLING("scrobbling"),
 	STATS("statistics"),
+	SAVED_FILTERS("saved_filters"),
 	;
 
 	companion object {

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

@@ -25,6 +25,7 @@ data class BackupSectionModel(
 			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/exceptions/EmptyMangaException.kt

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

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

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

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

@@ -138,6 +138,10 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getBoolean(KEY_READER_DOUBLE_PAGES, false)
 		set(value) = prefs.edit { putBoolean(KEY_READER_DOUBLE_PAGES, value) }
 
+	var isReaderDoubleOnFoldable: Boolean
+		get() = prefs.getBoolean(KEY_READER_DOUBLE_FOLDABLE, false)
+		set(value) = prefs.edit { putBoolean(KEY_READER_DOUBLE_FOLDABLE, value) }
+
 	@get:FloatRange(0.0, 1.0)
 	var readerDoublePagesSensitivity: Float
 		get() = prefs.getFloat(KEY_READER_DOUBLE_PAGES_SENSITIVITY, 0.5f)
@@ -546,11 +550,11 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isPeriodicalBackupEnabled: Boolean
 		get() = prefs.getBoolean(KEY_BACKUP_PERIODICAL_ENABLED, false)
 
-	val periodicalBackupFrequency: Long
+	val periodicalBackupFrequency: Float
-		get() = prefs.getString(KEY_BACKUP_PERIODICAL_FREQUENCY, null)?.toLongOrNull() ?: 7L
+		get() = prefs.getString(KEY_BACKUP_PERIODICAL_FREQUENCY, null)?.toFloatOrNull() ?: 7f
 
 	val periodicalBackupFrequencyMillis: Long
-		get() = TimeUnit.DAYS.toMillis(periodicalBackupFrequency)
+		get() = (TimeUnit.DAYS.toMillis(1) * periodicalBackupFrequency).toLong()
 
 	val periodicalBackupMaxCount: Int
 		get() = if (prefs.getBoolean(KEY_BACKUP_PERIODICAL_TRIM, true)) {
@@ -681,7 +685,8 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_REMOTE_SOURCES = "remote_sources"
 		const val KEY_LOCAL_STORAGE = "local_storage"
 		const val KEY_READER_DOUBLE_PAGES = "reader_double_pages"
-		const val KEY_READER_DOUBLE_PAGES_SENSITIVITY = "reader_double_pages_sensitivity"
+		const val KEY_READER_DOUBLE_PAGES_SENSITIVITY = "reader_double_pages_sensitivity_2"
+		const val KEY_READER_DOUBLE_FOLDABLE = "reader_double_foldable"
 		const val KEY_READER_ZOOM_BUTTONS = "reader_zoom_buttons"
 		const val KEY_READER_CONTROL_LTR = "reader_taps_ltr"
 		const val KEY_READER_NAVIGATION_INVERTED = "reader_navigation_inverted"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -100,7 +100,7 @@ class ChaptersPagesSheet : BaseAdaptiveSheet<SheetChaptersPagesBinding>(),
 
 	override fun onStateChanged(sheet: View, newState: Int) {
         val binding = viewBinding ?: return
-        binding.layoutTouchBlock.isTouchEventsAllowed = newState != STATE_COLLAPSED
+        binding.layoutTouchBlock.isTouchEventsAllowed = dialog != null || newState != STATE_COLLAPSED
         if (newState == STATE_DRAGGING || newState == STATE_SETTLING) {
             return
         }

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

@@ -53,7 +53,9 @@ class MangaSourcesRepository @Inject constructor(
 		get() = db.getSourcesDao()
 
 	val allMangaSources: Set<MangaParserSource> = Collections.unmodifiableSet(
-		EnumSet.allOf(MangaParserSource::class.java)
+		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/filter/data/SavedFiltersRepository.kt

@@ -57,10 +57,16 @@ class SavedFiltersRepository @Inject constructor(
             source = source,
             filter = filter,
         )
-        persist(source, persistableFilter)
+        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)
@@ -79,8 +85,8 @@ class SavedFiltersRepository @Inject constructor(
         }
     }
 
-    private fun persist(source: MangaSource, persistableFilter: PersistableFilter) {
+    private fun persist(persistableFilter: PersistableFilter) {
-        val prefs = getPrefs(source)
+        val prefs = getPrefs(persistableFilter.source)
         val json = Json.encodeToString(persistableFilter)
         prefs.edit(commit = true) {
             putString(key(persistableFilter.id), json)

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

@@ -2,16 +2,19 @@ package org.koitharu.kotatsu.filter.ui.sheet
 
 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
@@ -69,8 +72,7 @@ class FilterSheetFragment : BaseAdaptiveSheet<SheetFilterBinding>(),
     override fun onViewBindingCreated(binding: SheetFilterBinding, savedInstanceState: Bundle?) {
         super.onViewBindingCreated(binding, savedInstanceState)
         if (dialog == null) {
-            binding.layoutBody.updatePadding(top = binding.layoutBody.paddingBottom)
+            binding.adjustForEmbeddedLayout()
-            binding.scrollView.scrollIndicators = 0
         }
         val filter = FilterCoordinator.require(this)
         filter.sortOrder.observe(viewLifecycleOwner, this::onSortOrderChanged)
@@ -127,6 +129,18 @@ class FilterSheetFragment : BaseAdaptiveSheet<SheetFilterBinding>(),
         binding.buttonDone.setOnClickListener(this)
     }
 
+    private fun SheetFilterBinding.adjustForEmbeddedLayout() {
+        layoutBody.updatePadding(top = layoutBody.paddingBottom)
+        scrollView.scrollIndicators = 0
+        buttonDone.isVisible = false
+        this.root.layoutParams?.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 onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
         val typeMask = WindowInsetsCompat.Type.systemBars()
         viewBinding?.layoutBottom?.updateLayoutParams<ViewGroup.MarginLayoutParams> {

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

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

app/src/main/kotlin/org/koitharu/kotatsu/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/reader/ui/ReaderActivity.kt

@@ -3,6 +3,7 @@ package org.koitharu.kotatsu.reader.ui
 import android.app.assist.AssistContent
 import android.content.DialogInterface
 import android.content.Intent
+import android.content.res.Configuration
 import android.os.Bundle
 import android.view.Gravity
 import android.view.KeyEvent
@@ -24,6 +25,8 @@ import androidx.transition.Fade
 import androidx.transition.Slide
 import androidx.transition.TransitionManager
 import androidx.transition.TransitionSet
+import androidx.window.layout.FoldingFeature
+import androidx.window.layout.WindowInfoTracker
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
@@ -31,7 +34,9 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.R
@@ -70,483 +75,519 @@ import androidx.appcompat.R as appcompatR
 
 @AndroidEntryPoint
 class ReaderActivity :
-	BaseFullscreenActivity<ActivityReaderBinding>(),
+    BaseFullscreenActivity<ActivityReaderBinding>(),
-	TapGridDispatcher.OnGridTouchListener,
+    TapGridDispatcher.OnGridTouchListener,
-	ReaderConfigSheet.Callback,
+    ReaderConfigSheet.Callback,
-	ReaderControlDelegate.OnInteractionListener,
+    ReaderControlDelegate.OnInteractionListener,
-	ReaderNavigationCallback,
+    ReaderNavigationCallback,
-	IdlingDetector.Callback,
+    IdlingDetector.Callback,
-	ZoomControl.ZoomControlListener,
+    ZoomControl.ZoomControlListener,
-	View.OnClickListener,
+    View.OnClickListener,
-	ScrollTimerControlView.OnVisibilityChangeListener {
+    ScrollTimerControlView.OnVisibilityChangeListener {
 
-	@Inject
+    @Inject
-	lateinit var settings: AppSettings
+    lateinit var settings: AppSettings
 
-	@Inject
+    @Inject
-	lateinit var tapGridSettings: TapGridSettings
+    lateinit var tapGridSettings: TapGridSettings
 
-	@Inject
+    @Inject
-	lateinit var pageSaveHelperFactory: PageSaveHelper.Factory
+    lateinit var pageSaveHelperFactory: PageSaveHelper.Factory
 
-	@Inject
+    @Inject
-	lateinit var scrollTimerFactory: ScrollTimer.Factory
+    lateinit var scrollTimerFactory: ScrollTimer.Factory
 
-	@Inject
+    @Inject
-	lateinit var screenOrientationHelper: ScreenOrientationHelper
+    lateinit var screenOrientationHelper: ScreenOrientationHelper
 
-	private val idlingDetector = IdlingDetector(TimeUnit.SECONDS.toMillis(10), this)
+    private val idlingDetector = IdlingDetector(TimeUnit.SECONDS.toMillis(10), this)
 
-	private val viewModel: ReaderViewModel by viewModels()
+    private val viewModel: ReaderViewModel by viewModels()
 
-	override val readerMode: ReaderMode?
+    override val readerMode: ReaderMode?
-		get() = readerManager.currentMode
+        get() = readerManager.currentMode
 
-	private lateinit var scrollTimer: ScrollTimer
+    private lateinit var scrollTimer: ScrollTimer
-	private lateinit var pageSaveHelper: PageSaveHelper
+    private lateinit var pageSaveHelper: PageSaveHelper
-	private lateinit var touchHelper: TapGridDispatcher
+    private lateinit var touchHelper: TapGridDispatcher
-	private lateinit var controlDelegate: ReaderControlDelegate
+    private lateinit var controlDelegate: ReaderControlDelegate
-	private var gestureInsets: Insets = Insets.NONE
+    private var gestureInsets: Insets = Insets.NONE
-	private lateinit var readerManager: ReaderManager
+    private lateinit var readerManager: ReaderManager
-	private val hideUiRunnable = Runnable { setUiIsVisible(false) }
+    private val hideUiRunnable = Runnable { setUiIsVisible(false) }
 
-	override fun onCreate(savedInstanceState: Bundle?) {
+    // Tracks whether the foldable device is in an unfolded state (half-opened or flat)
-		super.onCreate(savedInstanceState)
+    private var isFoldUnfolded: Boolean = false
-		setContentView(ActivityReaderBinding.inflate(layoutInflater))
-		readerManager = ReaderManager(supportFragmentManager, viewBinding.container, settings)
-		setDisplayHomeAsUp(isEnabled = true, showUpAsClose = false)
-		touchHelper = TapGridDispatcher(viewBinding.root, this)
-		scrollTimer = scrollTimerFactory.create(resources, this, this)
-		pageSaveHelper = pageSaveHelperFactory.create(this)
-		controlDelegate = ReaderControlDelegate(resources, settings, tapGridSettings, this)
-		viewBinding.zoomControl.listener = this
-		viewBinding.actionsView.listener = this
-		viewBinding.buttonTimer?.setOnClickListener(this)
-		idlingDetector.bindToLifecycle(this)
-		screenOrientationHelper.applySettings()
-		viewModel.isBookmarkAdded.observe(this) { viewBinding.actionsView.isBookmarkAdded = it }
-		scrollTimer.isActive.observe(this) {
-			updateScrollTimerButton()
-			viewBinding.actionsView.setTimerActive(it)
-		}
-		viewBinding.timerControl.onVisibilityChangeListener = this
-		viewBinding.timerControl.attach(scrollTimer, this)
-		if (resources.getBoolean(R.bool.is_tablet)) {
-			viewBinding.timerControl.updateLayoutParams<CoordinatorLayout.LayoutParams> {
-				topMargin = marginEnd + getThemeDimensionPixelOffset(appcompatR.attr.actionBarSize)
-			}
-		}
 
-		viewModel.onLoadingError.observeEvent(
+    override fun onCreate(savedInstanceState: Bundle?) {
-			this,
+        super.onCreate(savedInstanceState)
-			DialogErrorObserver(
+        setContentView(ActivityReaderBinding.inflate(layoutInflater))
-				host = viewBinding.container,
+        readerManager = ReaderManager(supportFragmentManager, viewBinding.container, settings)
-				fragment = null,
+        setDisplayHomeAsUp(isEnabled = true, showUpAsClose = false)
-				resolver = exceptionResolver,
+        touchHelper = TapGridDispatcher(viewBinding.root, this)
-				onResolved = { isResolved ->
+        scrollTimer = scrollTimerFactory.create(resources, this, this)
-					if (isResolved) {
+        pageSaveHelper = pageSaveHelperFactory.create(this)
-						viewModel.reload()
+        controlDelegate = ReaderControlDelegate(resources, settings, tapGridSettings, this)
-					} else if (viewModel.content.value.pages.isEmpty()) {
+        viewBinding.zoomControl.listener = this
-						dispatchNavigateUp()
+        viewBinding.actionsView.listener = this
-					}
+        viewBinding.buttonTimer?.setOnClickListener(this)
-				},
+        idlingDetector.bindToLifecycle(this)
-			),
+        screenOrientationHelper.applySettings()
-		)
+        viewModel.isBookmarkAdded.observe(this) { viewBinding.actionsView.isBookmarkAdded = it }
-		viewModel.onError.observeEvent(
+        scrollTimer.isActive.observe(this) {
-			this,
+            updateScrollTimerButton()
-			SnackbarErrorObserver(
+            viewBinding.actionsView.setTimerActive(it)
-				host = viewBinding.container,
+        }
-				fragment = null,
+        viewBinding.timerControl.onVisibilityChangeListener = this
-				resolver = exceptionResolver,
+        viewBinding.timerControl.attach(scrollTimer, this)
-				onResolved = null,
+        if (resources.getBoolean(R.bool.is_tablet)) {
-			),
+            viewBinding.timerControl.updateLayoutParams<CoordinatorLayout.LayoutParams> {
-		)
+                topMargin = marginEnd + getThemeDimensionPixelOffset(appcompatR.attr.actionBarSize)
-		viewModel.readerMode.observe(this, Lifecycle.State.STARTED, this::onInitReader)
+            }
-		viewModel.onPageSaved.observeEvent(this, PagesSavedObserver(viewBinding.container))
+        }
-		viewModel.uiState.zipWithPrevious().observe(this, this::onUiStateChanged)
-		combine(
-			viewModel.isLoading,
-			viewModel.content.map { it.pages.isNotEmpty() }.distinctUntilChanged(),
-			::Pair,
-		).flowOn(Dispatchers.Default)
-			.observe(this, this::onLoadingStateChanged)
-		viewModel.isKeepScreenOnEnabled.observe(this, this::setKeepScreenOn)
-		viewModel.isInfoBarTransparent.observe(this) { viewBinding.infoBar.drawBackground = !it }
-		viewModel.isInfoBarEnabled.observe(this, ::onReaderBarChanged)
-		viewModel.isBookmarkAdded.observe(this, MenuInvalidator(this))
-		viewModel.onAskNsfwIncognito.observeEvent(this) { askForIncognitoMode() }
-		viewModel.onShowToast.observeEvent(this) { msgId ->
-			Snackbar.make(viewBinding.container, msgId, Snackbar.LENGTH_SHORT)
-				.setAnchorView(viewBinding.toolbarDocked)
-				.show()
-		}
-		viewModel.readerSettingsProducer.observe(this) {
-			viewBinding.infoBar.applyColorScheme(isBlackOnWhite = it.background.isLight(this))
-		}
-		viewModel.isZoomControlsEnabled.observe(this) {
-			viewBinding.zoomControl.isVisible = it
-		}
-		addMenuProvider(ReaderMenuProvider(viewModel))
-	}
 
-	override fun getParentActivityIntent(): Intent? {
+        viewModel.onLoadingError.observeEvent(
-		val manga = viewModel.getMangaOrNull() ?: return null
+            this,
-		return AppRouter.detailsIntent(this, manga)
+            DialogErrorObserver(
-	}
+                host = viewBinding.container,
+                fragment = null,
+                resolver = exceptionResolver,
+                onResolved = { isResolved ->
+                    if (isResolved) {
+                        viewModel.reload()
+                    } else if (viewModel.content.value.pages.isEmpty()) {
+                        dispatchNavigateUp()
+                    }
+                },
+            ),
+        )
+        viewModel.onError.observeEvent(
+            this,
+            SnackbarErrorObserver(
+                host = viewBinding.container,
+                fragment = null,
+                resolver = exceptionResolver,
+                onResolved = null,
+            ),
+        )
+        viewModel.readerMode.observe(this, Lifecycle.State.STARTED, this::onInitReader)
+        viewModel.onPageSaved.observeEvent(this, PagesSavedObserver(viewBinding.container))
+        viewModel.uiState.zipWithPrevious().observe(this, this::onUiStateChanged)
+        combine(
+            viewModel.isLoading,
+            viewModel.content.map { it.pages.isNotEmpty() }.distinctUntilChanged(),
+            ::Pair,
+        ).flowOn(Dispatchers.Default)
+            .observe(this, this::onLoadingStateChanged)
+        viewModel.isKeepScreenOnEnabled.observe(this, this::setKeepScreenOn)
+        viewModel.isInfoBarTransparent.observe(this) { viewBinding.infoBar.drawBackground = !it }
+        viewModel.isInfoBarEnabled.observe(this, ::onReaderBarChanged)
+        viewModel.isBookmarkAdded.observe(this, MenuInvalidator(this))
+        viewModel.onAskNsfwIncognito.observeEvent(this) { askForIncognitoMode() }
+        viewModel.onShowToast.observeEvent(this) { msgId ->
+            Snackbar.make(viewBinding.container, msgId, Snackbar.LENGTH_SHORT)
+                .setAnchorView(viewBinding.toolbarDocked)
+                .show()
+        }
+        viewModel.readerSettingsProducer.observe(this) {
+            viewBinding.infoBar.applyColorScheme(isBlackOnWhite = it.background.isLight(this))
+        }
+        viewModel.isZoomControlsEnabled.observe(this) {
+            viewBinding.zoomControl.isVisible = it
+        }
+        addMenuProvider(ReaderMenuProvider(viewModel))
 
-	override fun onUserInteraction() {
+        observeWindowLayout()
-		super.onUserInteraction()
-		if (!viewBinding.timerControl.isVisible) {
-			scrollTimer.onUserInteraction()
-		}
-		idlingDetector.onUserInteraction()
-	}
 
-	override fun onPause() {
+        // Apply initial double-mode considering foldable setting
-		super.onPause()
+        applyDoubleModeAuto()
-		viewModel.onPause()
+    }
-	}
 
-	override fun onStop() {
+    override fun getParentActivityIntent(): Intent? {
-		super.onStop()
+        val manga = viewModel.getMangaOrNull() ?: return null
-		viewModel.onStop()
+        return AppRouter.detailsIntent(this, manga)
-	}
+    }
 
-	override fun onProvideAssistContent(outContent: AssistContent) {
+    override fun onUserInteraction() {
-		super.onProvideAssistContent(outContent)
+        super.onUserInteraction()
-		viewModel.getMangaOrNull()?.publicUrl?.toUriOrNull()?.let { outContent.webUri = it }
+        if (!viewBinding.timerControl.isVisible) {
-	}
+            scrollTimer.onUserInteraction()
+        }
+        idlingDetector.onUserInteraction()
+    }
 
-	override fun isNsfwContent(): Flow<Boolean> = viewModel.isMangaNsfw
+    override fun onPause() {
+        super.onPause()
+        viewModel.onPause()
+    }
 
-	override fun onIdle() {
+    override fun onStop() {
-		viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
+        super.onStop()
-		viewModel.onIdle()
+        viewModel.onStop()
-	}
+    }
 
-	override fun onVisibilityChanged(v: View, visibility: Int) {
+    override fun onProvideAssistContent(outContent: AssistContent) {
-		updateScrollTimerButton()
+        super.onProvideAssistContent(outContent)
-	}
+        viewModel.getMangaOrNull()?.publicUrl?.toUriOrNull()?.let { outContent.webUri = it }
+    }
 
-	override fun onZoomIn() {
+    override fun isNsfwContent(): Flow<Boolean> = viewModel.isMangaNsfw
-		readerManager.currentReader?.onZoomIn()
-	}
 
-	override fun onZoomOut() {
+    override fun onIdle() {
-		readerManager.currentReader?.onZoomOut()
+        viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
-	}
+        viewModel.onIdle()
+    }
 
-	override fun onClick(v: View) {
+    override fun onVisibilityChanged(v: View, visibility: Int) {
-		when (v.id) {
+        updateScrollTimerButton()
-			R.id.button_timer -> onScrollTimerClick(isLongClick = false)
+    }
-		}
-	}
 
-	private fun onInitReader(mode: ReaderMode?) {
+    override fun onZoomIn() {
-		if (mode == null) {
+        readerManager.currentReader?.onZoomIn()
-			return
+    }
-		}
-		if (readerManager.currentMode != mode) {
-			readerManager.replace(mode)
-		}
-		if (viewBinding.appbarTop.isVisible) {
-			lifecycle.postDelayed(TimeUnit.SECONDS.toMillis(1), hideUiRunnable)
-		}
-		viewBinding.actionsView.setSliderReversed(mode == ReaderMode.REVERSED)
-		viewBinding.timerControl.onReaderModeChanged(mode)
-	}
 
-	private fun onLoadingStateChanged(value: Pair<Boolean, Boolean>) {
+    override fun onZoomOut() {
-		val (isLoading, hasPages) = value
+        readerManager.currentReader?.onZoomOut()
-		val showLoadingLayout = isLoading && !hasPages
+    }
-		if (viewBinding.layoutLoading.isVisible != showLoadingLayout) {
-			val transition = Fade().addTarget(viewBinding.layoutLoading)
-			TransitionManager.beginDelayedTransition(viewBinding.root, transition)
-			viewBinding.layoutLoading.isVisible = showLoadingLayout
-		}
-		if (isLoading && hasPages) {
-			viewBinding.toastView.show(R.string.loading_)
-		} else {
-			viewBinding.toastView.hide()
-		}
-		invalidateOptionsMenu()
-	}
 
-	override fun onGridTouch(area: TapGridArea): Boolean {
+    override fun onClick(v: View) {
-		return isReaderResumed() && controlDelegate.onGridTouch(area)
+        when (v.id) {
-	}
+            R.id.button_timer -> onScrollTimerClick(isLongClick = false)
+        }
+    }
 
-	override fun onGridLongTouch(area: TapGridArea) {
+    private fun onInitReader(mode: ReaderMode?) {
-		if (isReaderResumed()) {
+        if (mode == null) {
-			controlDelegate.onGridLongTouch(area)
+            return
-		}
+        }
-	}
+        if (readerManager.currentMode != mode) {
+            readerManager.replace(mode)
+        }
+        if (viewBinding.appbarTop.isVisible) {
+            lifecycle.postDelayed(TimeUnit.SECONDS.toMillis(1), hideUiRunnable)
+        }
+        viewBinding.actionsView.setSliderReversed(mode == ReaderMode.REVERSED)
+        viewBinding.timerControl.onReaderModeChanged(mode)
+    }
 
-	override fun onProcessTouch(rawX: Int, rawY: Int): Boolean {
+    private fun onLoadingStateChanged(value: Pair<Boolean, Boolean>) {
-		return if (
+        val (isLoading, hasPages) = value
-			rawX <= gestureInsets.left ||
+        val showLoadingLayout = isLoading && !hasPages
-			rawY <= gestureInsets.top ||
+        if (viewBinding.layoutLoading.isVisible != showLoadingLayout) {
-			rawX >= viewBinding.root.width - gestureInsets.right ||
+            val transition = Fade().addTarget(viewBinding.layoutLoading)
-			rawY >= viewBinding.root.height - gestureInsets.bottom ||
+            TransitionManager.beginDelayedTransition(viewBinding.root, transition)
-			viewBinding.appbarTop.hasGlobalPoint(rawX, rawY) ||
+            viewBinding.layoutLoading.isVisible = showLoadingLayout
-			viewBinding.toolbarDocked?.hasGlobalPoint(rawX, rawY) == true
+        }
-		) {
+        if (isLoading && hasPages) {
-			false
+            viewBinding.toastView.show(R.string.loading_)
-		} else {
+        } else {
-			val touchables = window.peekDecorView()?.touchables
+            viewBinding.toastView.hide()
-			touchables?.none { it.hasGlobalPoint(rawX, rawY) } != false
+        }
-		}
+        invalidateOptionsMenu()
-	}
+    }
 
-	override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+    override fun onGridTouch(area: TapGridArea): Boolean {
-		touchHelper.dispatchTouchEvent(ev)
+        return isReaderResumed() && controlDelegate.onGridTouch(area)
-		if (!viewBinding.timerControl.hasGlobalPoint(ev.rawX.toInt(), ev.rawY.toInt())) {
+    }
-			scrollTimer.onTouchEvent(ev)
-		}
-		return super.dispatchTouchEvent(ev)
-	}
 
-	override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
+    override fun onGridLongTouch(area: TapGridArea) {
-		return controlDelegate.onKeyDown(keyCode, event) || super.onKeyDown(keyCode, event)
+        if (isReaderResumed()) {
-	}
+            controlDelegate.onGridLongTouch(area)
+        }
+    }
 
-	override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
+    override fun onProcessTouch(rawX: Int, rawY: Int): Boolean {
-		return controlDelegate.onKeyUp(keyCode, event) || super.onKeyUp(keyCode, event)
+        return if (
-	}
+            rawX <= gestureInsets.left ||
+            rawY <= gestureInsets.top ||
+            rawX >= viewBinding.root.width - gestureInsets.right ||
+            rawY >= viewBinding.root.height - gestureInsets.bottom ||
+            viewBinding.appbarTop.hasGlobalPoint(rawX, rawY) ||
+            viewBinding.toolbarDocked?.hasGlobalPoint(rawX, rawY) == true
+        ) {
+            false
+        } else {
+            val touchables = window.peekDecorView()?.touchables
+            touchables?.none { it.hasGlobalPoint(rawX, rawY) } != false
+        }
+    }
 
-	override fun onChapterSelected(chapter: MangaChapter): Boolean {
+    override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
-		viewModel.switchChapter(chapter.id, 0)
+        touchHelper.dispatchTouchEvent(ev)
-		return true
+        if (!viewBinding.timerControl.hasGlobalPoint(ev.rawX.toInt(), ev.rawY.toInt())) {
-	}
+            scrollTimer.onTouchEvent(ev)
+        }
+        return super.dispatchTouchEvent(ev)
+    }
 
-	override fun onPageSelected(page: ReaderPage): Boolean {
+    override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
-		lifecycleScope.launch(Dispatchers.Default) {
+        return controlDelegate.onKeyDown(keyCode, event) || super.onKeyDown(keyCode, event)
-			val pages = viewModel.content.value.pages
+    }
-			val index = pages.indexOfFirst { it.chapterId == page.chapterId && it.id == page.id }
-			if (index != -1) {
-				withContext(Dispatchers.Main) {
-					readerManager.currentReader?.switchPageTo(index, true)
-				}
-			} else {
-				viewModel.switchChapter(page.chapterId, page.index)
-			}
-		}
-		return true
-	}
 
-	override fun onReaderModeChanged(mode: ReaderMode) {
+    override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
-		viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
+        return controlDelegate.onKeyUp(keyCode, event) || super.onKeyUp(keyCode, event)
-		viewModel.switchMode(mode)
+    }
-		viewBinding.timerControl.onReaderModeChanged(mode)
-	}
 
-	override fun onDoubleModeChanged(isEnabled: Boolean) {
+    override fun onChapterSelected(chapter: MangaChapter): Boolean {
-		readerManager.setDoubleReaderMode(isEnabled)
+        viewModel.switchChapter(chapter.id, 0)
-	}
+        return true
+    }
 
-	private fun setKeepScreenOn(isKeep: Boolean) {
+    override fun onPageSelected(page: ReaderPage): Boolean {
-		if (isKeep) {
+        lifecycleScope.launch(Dispatchers.Default) {
-			window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+            val pages = viewModel.content.value.pages
-		} else {
+            val index = pages.indexOfFirst { it.chapterId == page.chapterId && it.id == page.id }
-			window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+            if (index != -1) {
-		}
+                withContext(Dispatchers.Main) {
-	}
+                    readerManager.currentReader?.switchPageTo(index, true)
+                }
+            } else {
+                viewModel.switchChapter(page.chapterId, page.index)
+            }
+        }
+        return true
+    }
 
-	private fun setUiIsVisible(isUiVisible: Boolean) {
+    override fun onReaderModeChanged(mode: ReaderMode) {
-		if (viewBinding.appbarTop.isVisible != isUiVisible) {
+        viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
-			if (isAnimationsEnabled) {
+        viewModel.switchMode(mode)
-				val transition = TransitionSet()
+        viewBinding.timerControl.onReaderModeChanged(mode)
-					.setOrdering(TransitionSet.ORDERING_TOGETHER)
+    }
-					.addTransition(Slide(Gravity.TOP).addTarget(viewBinding.appbarTop))
-					.addTransition(Fade().addTarget(viewBinding.infoBar))
-				viewBinding.toolbarDocked?.let {
-					transition.addTransition(Slide(Gravity.BOTTOM).addTarget(it))
-				}
-				TransitionManager.beginDelayedTransition(viewBinding.root, transition)
-			}
-			val isFullscreen = settings.isReaderFullscreenEnabled
-			viewBinding.appbarTop.isVisible = isUiVisible
-			viewBinding.toolbarDocked?.isVisible = isUiVisible
-			viewBinding.infoBar.isGone = isUiVisible || (!viewModel.isInfoBarEnabled.value)
-			viewBinding.infoBar.isTimeVisible = isFullscreen
-			updateScrollTimerButton()
-			systemUiController.setSystemUiVisible(isUiVisible || !isFullscreen)
-			viewBinding.root.requestApplyInsets()
-		}
-	}
 
-	override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+    override fun onDoubleModeChanged(isEnabled: Boolean) {
-		gestureInsets = insets.getInsets(WindowInsetsCompat.Type.systemGestures())
+        // Combine manual toggle with foldable auto setting
-		val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+        applyDoubleModeAuto(isEnabled)
-		viewBinding.toolbar.updateLayoutParams<ViewGroup.MarginLayoutParams> {
+    }
-			topMargin = systemBars.top
-			rightMargin = systemBars.right
-			leftMargin = systemBars.left
-		}
-		if (viewBinding.toolbarDocked != null) {
-			viewBinding.actionsView.updateLayoutParams<ViewGroup.MarginLayoutParams> {
-				bottomMargin = systemBars.bottom
-				rightMargin = systemBars.right
-				leftMargin = systemBars.left
-			}
-		}
-		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(), innerInsets)
-			.build()
-	}
 
-	override fun switchPageBy(delta: Int) {
+    private fun applyDoubleModeAuto(manualEnabled: Boolean? = null) {
-		readerManager.currentReader?.switchPageBy(delta)
+        val isLandscape = resources.configuration.orientation == Configuration.ORIENTATION_LANDSCAPE
-	}
+        // Auto double-page on foldable when device is unfolded (half-opened or flat)
+        val autoFoldable = settings.isReaderDoubleOnFoldable && isFoldUnfolded
+        val manualLandscape = (manualEnabled ?: settings.isReaderDoubleOnLandscape) && isLandscape
+        val autoEnabled = autoFoldable || manualLandscape
+        readerManager.setDoubleReaderMode(autoEnabled)
+    }
 
-	override fun switchChapterBy(delta: Int) {
+    private fun setKeepScreenOn(isKeep: Boolean) {
-		viewModel.switchChapterBy(delta)
+        if (isKeep) {
-	}
+            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        } else {
+            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        }
+    }
 
-	override fun openMenu() {
+    private fun setUiIsVisible(isUiVisible: Boolean) {
-		viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
+        if (viewBinding.appbarTop.isVisible != isUiVisible) {
-		val currentMode = readerManager.currentMode ?: return
+            if (isAnimationsEnabled) {
-		router.showReaderConfigSheet(currentMode)
+                val transition = TransitionSet()
-	}
+                    .setOrdering(TransitionSet.ORDERING_TOGETHER)
+                    .addTransition(Slide(Gravity.TOP).addTarget(viewBinding.appbarTop))
+                    .addTransition(Fade().addTarget(viewBinding.infoBar))
+                viewBinding.toolbarDocked?.let {
+                    transition.addTransition(Slide(Gravity.BOTTOM).addTarget(it))
+                }
+                TransitionManager.beginDelayedTransition(viewBinding.root, transition)
+            }
+            val isFullscreen = settings.isReaderFullscreenEnabled
+            viewBinding.appbarTop.isVisible = isUiVisible
+            viewBinding.toolbarDocked?.isVisible = isUiVisible
+            viewBinding.infoBar.isGone = isUiVisible || (!viewModel.isInfoBarEnabled.value)
+            viewBinding.infoBar.isTimeVisible = isFullscreen
+            updateScrollTimerButton()
+            systemUiController.setSystemUiVisible(isUiVisible || !isFullscreen)
+            viewBinding.root.requestApplyInsets()
+        }
+    }
 
-	override fun scrollBy(delta: Int, smooth: Boolean): Boolean {
+    override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
-		return readerManager.currentReader?.scrollBy(delta, smooth) == true
+        gestureInsets = insets.getInsets(WindowInsetsCompat.Type.systemGestures())
-	}
+        val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+        viewBinding.toolbar.updateLayoutParams<ViewGroup.MarginLayoutParams> {
+            topMargin = systemBars.top
+            rightMargin = systemBars.right
+            leftMargin = systemBars.left
+        }
+        if (viewBinding.toolbarDocked != null) {
+            viewBinding.actionsView.updateLayoutParams<ViewGroup.MarginLayoutParams> {
+                bottomMargin = systemBars.bottom
+                rightMargin = systemBars.right
+                leftMargin = systemBars.left
+            }
+        }
+        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(), innerInsets)
+            .build()
+    }
 
-	override fun toggleUiVisibility() {
+    override fun switchPageBy(delta: Int) {
-		setUiIsVisible(!viewBinding.appbarTop.isVisible)
+        readerManager.currentReader?.switchPageBy(delta)
-	}
+    }
 
-	override fun isReaderResumed(): Boolean {
+    override fun switchChapterBy(delta: Int) {
-		val reader = readerManager.currentReader ?: return false
+        viewModel.switchChapterBy(delta)
-		return reader.isResumed && supportFragmentManager.fragments.lastOrNull() === reader
+    }
-	}
 
-	override fun onBookmarkClick() {
+    override fun openMenu() {
-		viewModel.toggleBookmark()
+        viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
-	}
+        val currentMode = readerManager.currentMode ?: return
+        router.showReaderConfigSheet(currentMode)
+    }
 
-	override fun onSavePageClick() {
+    override fun scrollBy(delta: Int, smooth: Boolean): Boolean {
-		viewModel.saveCurrentPage(pageSaveHelper)
+        return readerManager.currentReader?.scrollBy(delta, smooth) == true
-	}
+    }
 
-	override fun onScrollTimerClick(isLongClick: Boolean) {
+    override fun toggleUiVisibility() {
-		if (isLongClick) {
+        setUiIsVisible(!viewBinding.appbarTop.isVisible)
-			scrollTimer.setActive(!scrollTimer.isActive.value)
+    }
-		} else {
-			viewBinding.timerControl.showOrHide()
-		}
-	}
 
-	override fun toggleScreenOrientation() {
+    override fun isReaderResumed(): Boolean {
-		if (screenOrientationHelper.toggleScreenOrientation()) {
+        val reader = readerManager.currentReader ?: return false
-			Snackbar.make(
+        return reader.isResumed && supportFragmentManager.fragments.lastOrNull() === reader
-				viewBinding.container,
+    }
-				if (screenOrientationHelper.isLocked) {
-					R.string.screen_rotation_locked
-				} else {
-					R.string.screen_rotation_unlocked
-				},
-				Snackbar.LENGTH_SHORT,
-			).setAnchorView(viewBinding.toolbarDocked)
-				.show()
-		}
-	}
 
-	override fun switchPageTo(index: Int) {
+    override fun onBookmarkClick() {
-		val pages = viewModel.getCurrentChapterPages()
+        viewModel.toggleBookmark()
-		val page = pages?.getOrNull(index) ?: return
+    }
-		val chapterId = viewModel.getCurrentState()?.chapterId ?: return
-		onPageSelected(ReaderPage(page, index, chapterId))
-	}
 
-	private fun onReaderBarChanged(isBarEnabled: Boolean) {
+    override fun onSavePageClick() {
-		viewBinding.infoBar.isVisible = isBarEnabled && viewBinding.appbarTop.isGone
+        viewModel.saveCurrentPage(pageSaveHelper)
-	}
+    }
 
-	private fun onUiStateChanged(pair: Pair<ReaderUiState?, ReaderUiState?>) {
+    override fun onScrollTimerClick(isLongClick: Boolean) {
-		val (previous: ReaderUiState?, uiState: ReaderUiState?) = pair
+        if (isLongClick) {
-		title = uiState?.mangaName ?: getString(R.string.loading_)
+            scrollTimer.setActive(!scrollTimer.isActive.value)
-		viewBinding.infoBar.update(uiState)
+        } else {
-		if (uiState == null) {
+            viewBinding.timerControl.showOrHide()
-			supportActionBar?.subtitle = null
+        }
-			viewBinding.actionsView.setSliderValue(0, 1)
+    }
-			viewBinding.actionsView.isSliderEnabled = false
-			return
-		}
-		val chapterTitle = uiState.getChapterTitle(resources)
-		supportActionBar?.subtitle = when {
-			uiState.incognito -> getString(R.string.incognito_mode)
-			else -> chapterTitle
-		}
-		if (
-			settings.isReaderChapterToastEnabled &&
-			chapterTitle != previous?.getChapterTitle(resources) &&
-			chapterTitle.isNotEmpty()
-		) {
-			viewBinding.toastView.showTemporary(chapterTitle, TOAST_DURATION)
-		}
-		if (uiState.isSliderAvailable()) {
-			viewBinding.actionsView.setSliderValue(
-				value = uiState.currentPage,
-				max = uiState.totalPages - 1,
-			)
-		} else {
-			viewBinding.actionsView.setSliderValue(0, 1)
-		}
-		viewBinding.actionsView.isSliderEnabled = uiState.isSliderAvailable()
-		viewBinding.actionsView.isNextEnabled = uiState.hasNextChapter()
-		viewBinding.actionsView.isPrevEnabled = uiState.hasPreviousChapter()
-	}
 
-	private fun updateScrollTimerButton() {
+    override fun toggleScreenOrientation() {
-		val button = viewBinding.buttonTimer ?: return
+        if (screenOrientationHelper.toggleScreenOrientation()) {
-		val isButtonVisible = scrollTimer.isActive.value
+            Snackbar.make(
-			&& settings.isReaderAutoscrollFabVisible
+                viewBinding.container,
-			&& !viewBinding.appbarTop.isVisible
+                if (screenOrientationHelper.isLocked) {
-			&& !viewBinding.timerControl.isVisible
+                    R.string.screen_rotation_locked
-		if (button.isVisible != isButtonVisible) {
+                } else {
-			val transition = Fade().addTarget(button)
+                    R.string.screen_rotation_unlocked
-			TransitionManager.beginDelayedTransition(viewBinding.root, transition)
+                },
-			button.isVisible = isButtonVisible
+                Snackbar.LENGTH_SHORT,
-		}
+            ).setAnchorView(viewBinding.toolbarDocked)
-	}
+                .show()
+        }
+    }
 
-	private fun askForIncognitoMode() {
+    override fun switchPageTo(index: Int) {
-		buildAlertDialog(this, isCentered = true) {
+        val pages = viewModel.getCurrentChapterPages()
-			var dontAskAgain = false
+        val page = pages?.getOrNull(index) ?: return
-			val listener = DialogInterface.OnClickListener { _, which ->
+        val chapterId = viewModel.getCurrentState()?.chapterId ?: return
-				if (which == DialogInterface.BUTTON_NEUTRAL) {
+        onPageSelected(ReaderPage(page, index, chapterId))
-					finishAfterTransition()
+    }
-				} else {
-					viewModel.setIncognitoMode(which == DialogInterface.BUTTON_POSITIVE, dontAskAgain)
-				}
-			}
-			setCheckbox(R.string.dont_ask_again, dontAskAgain) { _, isChecked ->
-				dontAskAgain = isChecked
-			}
-			setIcon(R.drawable.ic_incognito)
-			setTitle(R.string.incognito_mode)
-			setMessage(R.string.incognito_mode_hint_nsfw)
-			setPositiveButton(R.string.incognito, listener)
-			setNegativeButton(R.string.disable, listener)
-			setNeutralButton(android.R.string.cancel, listener)
-			setOnCancelListener { finishAfterTransition() }
-			setCancelable(true)
-		}.show()
-	}
 
-	companion object {
+    private fun onReaderBarChanged(isBarEnabled: Boolean) {
+        viewBinding.infoBar.isVisible = isBarEnabled && viewBinding.appbarTop.isGone
+    }
 
-		private const val TOAST_DURATION = 2000L
+    private fun onUiStateChanged(pair: Pair<ReaderUiState?, ReaderUiState?>) {
-	}
+        val (previous: ReaderUiState?, uiState: ReaderUiState?) = pair
+        title = uiState?.mangaName ?: getString(R.string.loading_)
+        viewBinding.infoBar.update(uiState)
+        if (uiState == null) {
+            supportActionBar?.subtitle = null
+            viewBinding.actionsView.setSliderValue(0, 1)
+            viewBinding.actionsView.isSliderEnabled = false
+            return
+        }
+        val chapterTitle = uiState.getChapterTitle(resources)
+        supportActionBar?.subtitle = when {
+            uiState.incognito -> getString(R.string.incognito_mode)
+            else -> chapterTitle
+        }
+        if (
+            settings.isReaderChapterToastEnabled &&
+            chapterTitle != previous?.getChapterTitle(resources) &&
+            chapterTitle.isNotEmpty()
+        ) {
+            viewBinding.toastView.showTemporary(chapterTitle, TOAST_DURATION)
+        }
+        if (uiState.isSliderAvailable()) {
+            viewBinding.actionsView.setSliderValue(
+                value = uiState.currentPage,
+                max = uiState.totalPages - 1,
+            )
+        } else {
+            viewBinding.actionsView.setSliderValue(0, 1)
+        }
+        viewBinding.actionsView.isSliderEnabled = uiState.isSliderAvailable()
+        viewBinding.actionsView.isNextEnabled = uiState.hasNextChapter()
+        viewBinding.actionsView.isPrevEnabled = uiState.hasPreviousChapter()
+    }
+
+    private fun updateScrollTimerButton() {
+        val button = viewBinding.buttonTimer ?: return
+        val isButtonVisible = scrollTimer.isActive.value
+            && settings.isReaderAutoscrollFabVisible
+            && !viewBinding.appbarTop.isVisible
+            && !viewBinding.timerControl.isVisible
+        if (button.isVisible != isButtonVisible) {
+            val transition = Fade().addTarget(button)
+            TransitionManager.beginDelayedTransition(viewBinding.root, transition)
+            button.isVisible = isButtonVisible
+        }
+    }
+
+    // Observe foldable window layout to auto-enable double-page if configured
+    private fun observeWindowLayout() {
+        WindowInfoTracker.getOrCreate(this)
+            .windowLayoutInfo(this)
+            .onEach { info ->
+                val fold = info.displayFeatures.filterIsInstance<FoldingFeature>().firstOrNull()
+                val unfolded = when (fold?.state) {
+                    FoldingFeature.State.HALF_OPENED, FoldingFeature.State.FLAT -> true
+                    else -> false
+                }
+                if (unfolded != isFoldUnfolded) {
+                    isFoldUnfolded = unfolded
+                    applyDoubleModeAuto()
+                }
+            }
+            .launchIn(lifecycleScope)
+    }
+
+    private fun askForIncognitoMode() {
+        buildAlertDialog(this, isCentered = true) {
+            var dontAskAgain = false
+            val listener = DialogInterface.OnClickListener { _, which ->
+                if (which == DialogInterface.BUTTON_NEUTRAL) {
+                    finishAfterTransition()
+                } else {
+                    viewModel.setIncognitoMode(which == DialogInterface.BUTTON_POSITIVE, dontAskAgain)
+                }
+            }
+            setCheckbox(R.string.dont_ask_again, dontAskAgain) { _, isChecked ->
+                dontAskAgain = isChecked
+            }
+            setIcon(R.drawable.ic_incognito)
+            setTitle(R.string.incognito_mode)
+            setMessage(R.string.incognito_mode_hint_nsfw)
+            setPositiveButton(R.string.incognito, listener)
+            setNegativeButton(R.string.disable, listener)
+            setNeutralButton(android.R.string.cancel, listener)
+            setOnCancelListener { finishAfterTransition() }
+            setCancelable(true)
+        }.show()
+    }
+
+    companion object {
+
+        private const val TOAST_DURATION = 2000L
+    }
 }

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

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

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

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

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

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

app/src/main/kotlin/org/koitharu/kotatsu/search/ui/multi/SearchActivity.kt

@@ -94,7 +94,7 @@ class SearchActivity :
 		setDisplayHomeAsUp(isEnabled = true, showUpAsClose = false)
 		supportActionBar?.setSubtitle(R.string.search_results)
 
-		addMenuProvider(SearchKindMenuProvider(this, viewModel.query, viewModel.kind))
+		addMenuProvider(SearchMenuProvider(this, viewModel))
 
 		viewModel.list.observe(this, adapter)
 		viewModel.onError.observeEvent(this, SnackbarErrorObserver(viewBinding.recyclerView, null))

app/src/main/kotlin/org/koitharu/kotatsu/search/ui/multi/SearchMenuProvider.kt

@@ -9,10 +9,9 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.nav.router
 import org.koitharu.kotatsu.search.domain.SearchKind
 
-class SearchKindMenuProvider(
+class SearchMenuProvider(
 	private val activity: SearchActivity,
-	private val query: String,
+	private val viewModel: SearchViewModel,
-	private val kind: SearchKind
 ) : MenuProvider {
 
 	override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
@@ -22,7 +21,7 @@ class SearchKindMenuProvider(
 	override fun onPrepareMenu(menu: Menu) {
 		super.onPrepareMenu(menu)
 		menu.findItem(
-			when (kind) {
+			when (viewModel.kind) {
 				SearchKind.SIMPLE -> R.id.action_kind_simple
 				SearchKind.TITLE -> R.id.action_kind_title
 				SearchKind.AUTHOR -> R.id.action_kind_author
@@ -32,6 +31,20 @@ class SearchKindMenuProvider(
 	}
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+		when (menuItem.itemId) {
+			R.id.action_filter_pinned_only -> {
+				menuItem.isChecked = !menuItem.isChecked
+				viewModel.setPinnedOnly(menuItem.isChecked)
+				return true
+			}
+
+			R.id.action_filter_hide_empty -> {
+				menuItem.isChecked = !menuItem.isChecked
+				viewModel.setHideEmpty(menuItem.isChecked)
+				return true
+			}
+		}
+
 		val newKind = when (menuItem.itemId) {
 			R.id.action_kind_simple -> SearchKind.SIMPLE
 			R.id.action_kind_title -> SearchKind.TITLE
@@ -39,9 +52,9 @@ class SearchKindMenuProvider(
 			R.id.action_kind_tag -> SearchKind.TAG
 			else -> return false
 		}
-		if (newKind != kind) {
+		if (newKind != viewModel.kind) {
 			activity.router.openSearch(
-				query = query,
+				query = viewModel.query,
 				kind = newKind,
 			)
 			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {

app/src/main/kotlin/org/koitharu/kotatsu/search/ui/multi/SearchViewModel.kt

@@ -62,6 +62,8 @@ class SearchViewModel @Inject constructor(
 	val kind = savedStateHandle.get<SearchKind>(AppRouter.KEY_KIND) ?: SearchKind.SIMPLE
 
 	private var includeDisabledSources = MutableStateFlow(false)
+	private var pinnedOnly = MutableStateFlow(false)
+	private var hideEmpty = MutableStateFlow(false)
 	private val results = MutableStateFlow<List<SearchResultsListModel>>(emptyList())
 
 	private var searchJob: Job? = null
@@ -70,9 +72,15 @@ class SearchViewModel @Inject constructor(
 		results,
 		isLoading.dropWhile { !it },
 		includeDisabledSources,
-	) { list, loading, includeDisabled ->
+		hideEmpty,
+	) { list, loading, includeDisabled, hideEmptyVal ->
+		val filteredList = if (hideEmptyVal) {
+			list.filter { it.list.isNotEmpty() }
+		} else {
+			list
+		}
 		when {
-			list.isEmpty() -> listOf(
+			filteredList.isEmpty() -> listOf(
 				when {
 					loading -> LoadingState
 					else -> EmptyState(
@@ -84,9 +92,9 @@ class SearchViewModel @Inject constructor(
 				},
 			)
 
-			loading -> list + LoadingFooter()
+			loading -> filteredList + LoadingFooter()
-			includeDisabled -> list
+			includeDisabled -> filteredList
-			else -> list + ButtonFooter(R.string.search_disabled_sources)
+			else -> filteredList + ButtonFooter(R.string.search_disabled_sources)
 		}
 	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, listOf(LoadingState))
 
@@ -114,6 +122,17 @@ class SearchViewModel @Inject constructor(
 		doSearch()
 	}
 
+	fun setPinnedOnly(value: Boolean) {
+		if (pinnedOnly.value != value) {
+			pinnedOnly.value = value
+			retry()
+		}
+	}
+
+	fun setHideEmpty(value: Boolean) {
+		hideEmpty.value = value
+	}
+
 	fun continueSearch() {
 		if (includeDisabledSources.value) {
 			return
@@ -122,8 +141,12 @@ class SearchViewModel @Inject constructor(
 		searchJob = launchLoadingJob(Dispatchers.Default) {
 			includeDisabledSources.value = true
 			prevJob?.join()
-			val sources = sourcesRepository.getDisabledSources()
+			val sources = if (pinnedOnly.value) {
-				.sortedByDescending { it.priority() }
+				emptyList()
+			} else {
+				sourcesRepository.getDisabledSources()
+					.sortedByDescending { it.priority() }
+			}
 			val semaphore = Semaphore(MAX_PARALLELISM)
 			sources.map { source ->
 				launch {
@@ -142,7 +165,11 @@ class SearchViewModel @Inject constructor(
 			appendResult(searchHistory())
 			appendResult(searchFavorites())
 			appendResult(searchLocal())
-			val sources = sourcesRepository.getEnabledSources()
+			val sources = if (pinnedOnly.value) {
+				sourcesRepository.getPinnedSources().toList()
+			} else {
+				sourcesRepository.getEnabledSources()
+			}
 			val semaphore = Semaphore(MAX_PARALLELISM)
 			sources.map { source ->
 				launch {

app/src/main/kotlin/org/koitharu/kotatsu/search/ui/multi/adapter/SearchResultsAD.kt

@@ -37,7 +37,7 @@ fun searchResultsAD(
 	binding.recyclerView.addItemDecoration(selectionDecoration)
 	binding.recyclerView.adapter = adapter
 	val spacing = context.resources.getDimensionPixelOffset(R.dimen.grid_spacing_outer)
-	binding.recyclerView.addItemDecoration(SpacingItemDecoration(spacing))
+	binding.recyclerView.addItemDecoration(SpacingItemDecoration(spacing, withBottomPadding = true))
 	val eventListener = AdapterDelegateClickListenerAdapter(this, itemClickListener)
 	binding.buttonMore.setOnClickListener(eventListener)
 

app/src/main/kotlin/org/koitharu/kotatsu/search/ui/suggestion/adapter/SearchSuggestionsMangaListAD.kt

@@ -29,7 +29,7 @@ fun searchSuggestionMangaListAD(
 		left = recyclerView.paddingLeft - spacing,
 		right = recyclerView.paddingRight - spacing,
 	)
-	recyclerView.addItemDecoration(SpacingItemDecoration(spacing))
+	recyclerView.addItemDecoration(SpacingItemDecoration(spacing, withBottomPadding = true))
 	val scrollResetCallback = RecyclerViewScrollCallback(recyclerView, 0, 0)
 
 	bind {

app/src/main/kotlin/org/koitharu/kotatsu/settings/storage/directories/DirectoryConfigAD.kt

@@ -1,38 +1,66 @@
 package org.koitharu.kotatsu.settings.storage.directories
 
+import android.view.View
 import androidx.core.content.ContextCompat
-import androidx.core.view.isVisible
+import androidx.core.text.bold
+import androidx.core.text.buildSpannedString
+import androidx.core.text.color
+import androidx.core.view.isGone
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
-import org.koitharu.kotatsu.core.util.ext.drawableStart
+import org.koitharu.kotatsu.core.util.FileSize
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
 import org.koitharu.kotatsu.core.util.ext.setTooltipCompat
 import org.koitharu.kotatsu.core.util.ext.textAndVisible
-import org.koitharu.kotatsu.databinding.ItemStorageConfigBinding
+import org.koitharu.kotatsu.databinding.ItemStorageConfig2Binding
-import org.koitharu.kotatsu.settings.storage.DirectoryModel
 
 fun directoryConfigAD(
-	clickListener: OnListItemClickListener<DirectoryModel>,
+    clickListener: OnListItemClickListener<DirectoryConfigModel>,
-) = adapterDelegateViewBinding<DirectoryModel, DirectoryModel, ItemStorageConfigBinding>(
+) = adapterDelegateViewBinding<DirectoryConfigModel, DirectoryConfigModel, ItemStorageConfig2Binding>(
-	{ layoutInflater, parent -> ItemStorageConfigBinding.inflate(layoutInflater, parent, false) },
+    { layoutInflater, parent -> ItemStorageConfig2Binding.inflate(layoutInflater, parent, false) },
 ) {
 
-	binding.buttonRemove.setOnClickListener { v -> clickListener.onItemClick(item, v) }
+    binding.buttonRemove.setOnClickListener { v -> clickListener.onItemClick(item, v) }
-	binding.buttonRemove.setTooltipCompat(binding.buttonRemove.contentDescription)
+    binding.buttonRemove.setTooltipCompat(binding.buttonRemove.contentDescription)
 
-	bind {
+    bind {
-		binding.textViewTitle.text = item.title ?: getString(item.titleRes)
+        binding.textViewTitle.text = item.title
-		binding.textViewSubtitle.textAndVisible = item.file?.absolutePath
+        binding.textViewSubtitle.text = item.path.absolutePath
-		binding.buttonRemove.isVisible = item.isRemovable
+        binding.buttonRemove.isGone = item.isAppPrivate
-		binding.buttonRemove.isEnabled = !item.isChecked
+        binding.buttonRemove.isEnabled = !item.isDefault
-		binding.textViewTitle.drawableStart = if (!item.isAvailable) {
+        binding.spacer.visibility = if (item.isAppPrivate) {
-			ContextCompat.getDrawable(context, R.drawable.ic_alert_outline)?.apply {
+            View.INVISIBLE
-				setTint(ContextCompat.getColor(context, R.color.warning))
+        } else {
-			}
+            View.GONE
-		} else if (item.isChecked) {
+        }
-			ContextCompat.getDrawable(context, R.drawable.ic_download)
+        binding.textViewInfo.textAndVisible = buildSpannedString {
-		} else {
+            if (item.isDefault) {
-			null
+                bold {
-		}
+                    append(getString(R.string.download_default_directory))
-	}
+                }
+            }
+            if (!item.isAccessible) {
+                if (isNotEmpty()) appendLine()
+                color(
+                    context.getThemeColor(
+                        androidx.appcompat.R.attr.colorError,
+                        ContextCompat.getColor(context, R.color.common_red),
+                    ),
+                ) {
+                    append(getString(R.string.no_write_permission_to_file))
+                }
+            }
+            if (item.isAppPrivate) {
+                if (isNotEmpty()) appendLine()
+                append(getString(R.string.private_app_directory_warning))
+            }
+        }
+        binding.indicatorSize.max = FileSize.BYTES.convert(item.available, FileSize.KILOBYTES).toInt()
+        binding.indicatorSize.progress = FileSize.BYTES.convert(item.size, FileSize.KILOBYTES).toInt()
+        binding.textViewSize.text = context.getString(
+            R.string.available_pattern,
+            FileSize.BYTES.format(context, item.available),
+        )
+    }
 }

app/src/main/kotlin/org/koitharu/kotatsu/settings/storage/directories/DirectoryConfigDiffCallback.kt

@@ -0,0 +1,22 @@
+package org.koitharu.kotatsu.settings.storage.directories
+
+import androidx.recyclerview.widget.DiffUtil.ItemCallback
+
+class DirectoryConfigDiffCallback : ItemCallback<DirectoryConfigModel>() {
+
+	override fun areItemsTheSame(oldItem: DirectoryConfigModel, newItem: DirectoryConfigModel): Boolean {
+		return oldItem.path == newItem.path
+	}
+
+	override fun areContentsTheSame(oldItem: DirectoryConfigModel, newItem: DirectoryConfigModel): Boolean {
+		return oldItem == newItem
+	}
+
+	override fun getChangePayload(oldItem: DirectoryConfigModel, newItem: DirectoryConfigModel): Any? {
+		return if (oldItem.isDefault != newItem.isDefault) {
+			Unit
+		} else {
+			super.getChangePayload(oldItem, newItem)
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/settings/storage/directories/DirectoryConfigModel.kt

@@ -0,0 +1,19 @@
+package org.koitharu.kotatsu.settings.storage.directories
+
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import java.io.File
+
+data class DirectoryConfigModel(
+    val title: String,
+    val path: File,
+    val isDefault: Boolean,
+    val isAppPrivate: Boolean,
+    val isAccessible: Boolean,
+    val size: Long,
+    val available: Long,
+) : ListModel {
+
+    override fun areItemsTheSame(other: ListModel): Boolean {
+        return other is DirectoryConfigModel && path == other.path
+    }
+}

app/src/main/kotlin/org/koitharu/kotatsu/settings/storage/directories/MangaDirectoriesActivity.kt

@@ -20,18 +20,17 @@ import org.koitharu.kotatsu.core.exceptions.resolve.SnackbarErrorObserver
 import org.koitharu.kotatsu.core.os.OpenDocumentTreeHelper
 import org.koitharu.kotatsu.core.ui.BaseActivity
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.ui.list.decor.SpacingItemDecoration
 import org.koitharu.kotatsu.core.util.ext.consumeAllSystemBarsInsets
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
 import org.koitharu.kotatsu.core.util.ext.tryLaunch
 import org.koitharu.kotatsu.databinding.ActivityMangaDirectoriesBinding
-import org.koitharu.kotatsu.settings.storage.DirectoryDiffCallback
-import org.koitharu.kotatsu.settings.storage.DirectoryModel
 import org.koitharu.kotatsu.settings.storage.RequestStorageManagerPermissionContract
 
 @AndroidEntryPoint
 class MangaDirectoriesActivity : BaseActivity<ActivityMangaDirectoriesBinding>(),
-	OnListItemClickListener<DirectoryModel>, View.OnClickListener {
+	OnListItemClickListener<DirectoryConfigModel>, View.OnClickListener {
 
 	private val viewModel: MangaDirectoriesViewModel by viewModels()
 	private val pickFileTreeLauncher = OpenDocumentTreeHelper(
@@ -63,8 +62,10 @@ class MangaDirectoriesActivity : BaseActivity<ActivityMangaDirectoriesBinding>()
 		super.onCreate(savedInstanceState)
 		setContentView(ActivityMangaDirectoriesBinding.inflate(layoutInflater))
 		setDisplayHomeAsUp(isEnabled = true, showUpAsClose = false)
-		val adapter = AsyncListDifferDelegationAdapter(DirectoryDiffCallback(), directoryConfigAD(this))
+		val adapter = AsyncListDifferDelegationAdapter(DirectoryConfigDiffCallback(), directoryConfigAD(this))
-		viewBinding.recyclerView.adapter = adapter
+        val spacing = resources.getDimensionPixelOffset(R.dimen.list_spacing_large)
+        viewBinding.recyclerView.adapter = adapter
+        viewBinding.recyclerView.addItemDecoration(SpacingItemDecoration(spacing, withBottomPadding = false))
 		viewBinding.fabAdd.setOnClickListener(this)
 		viewModel.items.observe(this) { adapter.items = it }
 		viewModel.isLoading.observe(this) { viewBinding.progressBar.isVisible = it }
@@ -76,8 +77,8 @@ class MangaDirectoriesActivity : BaseActivity<ActivityMangaDirectoriesBinding>()
 		)
 	}
 
-	override fun onItemClick(item: DirectoryModel, view: View) {
+	override fun onItemClick(item: DirectoryConfigModel, view: View) {
-		viewModel.onRemoveClick(item.file ?: return)
+		viewModel.onRemoveClick(item.path)
 	}
 
 	override fun onClick(v: View?) {

app/src/main/kotlin/org/koitharu/kotatsu/settings/storage/directories/MangaDirectoriesViewModel.kt

@@ -1,6 +1,7 @@
 package org.koitharu.kotatsu.settings.storage.directories
 
 import android.net.Uri
+import android.os.StatFs
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -8,82 +9,87 @@ import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.MutableStateFlow
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.ui.BaseViewModel
+import org.koitharu.kotatsu.core.util.ext.computeSize
 import org.koitharu.kotatsu.core.util.ext.isReadable
 import org.koitharu.kotatsu.core.util.ext.isWriteable
 import org.koitharu.kotatsu.local.data.LocalStorageManager
-import org.koitharu.kotatsu.settings.storage.DirectoryModel
 import java.io.File
 import javax.inject.Inject
 
 @HiltViewModel
 class MangaDirectoriesViewModel @Inject constructor(
-	private val storageManager: LocalStorageManager,
+    private val storageManager: LocalStorageManager,
-	private val settings: AppSettings,
+    private val settings: AppSettings,
 ) : BaseViewModel() {
 
-	val items = MutableStateFlow(emptyList<DirectoryModel>())
+    val items = MutableStateFlow(emptyList<DirectoryConfigModel>())
-	private var loadingJob: Job? = null
+    private var loadingJob: Job? = null
 
-	init {
+    init {
-		loadList()
+        loadList()
-	}
+    }
 
-	fun updateList() {
+    fun updateList() {
-		loadList()
+        loadList()
-	}
+    }
 
-	fun onCustomDirectoryPicked(uri: Uri) {
+    fun onCustomDirectoryPicked(uri: Uri) {
-		launchLoadingJob(Dispatchers.Default) {
+        launchLoadingJob(Dispatchers.Default) {
-			loadingJob?.cancelAndJoin()
+            loadingJob?.cancelAndJoin()
-			storageManager.takePermissions(uri)
+            storageManager.takePermissions(uri)
-			val dir = storageManager.resolveUri(uri)
+            val dir = storageManager.resolveUri(uri)
-			if (!dir.canRead()) {
+            if (!dir.canRead()) {
-				throw AccessDeniedException(dir)
+                throw AccessDeniedException(dir)
-			}
+            }
-			if (dir !in storageManager.getApplicationStorageDirs()) {
+            if (dir !in storageManager.getApplicationStorageDirs()) {
-				settings.userSpecifiedMangaDirectories += dir
+                settings.userSpecifiedMangaDirectories += dir
-				loadList()
+                loadList()
-			}
+            }
-		}
+        }
-	}
+    }
 
-	fun onRemoveClick(directory: File) {
+    fun onRemoveClick(directory: File) {
-		settings.userSpecifiedMangaDirectories -= directory
+        settings.userSpecifiedMangaDirectories -= directory
-		if (settings.mangaStorageDir == directory) {
+        if (settings.mangaStorageDir == directory) {
-			settings.mangaStorageDir = null
+            settings.mangaStorageDir = null
-		}
+        }
-		loadList()
+        loadList()
-	}
+    }
 
-	private fun loadList() {
+    private fun loadList() {
-		val prevJob = loadingJob
+        val prevJob = loadingJob
-		loadingJob = launchJob(Dispatchers.Default) {
+        loadingJob = launchJob(Dispatchers.Default) {
-			prevJob?.cancelAndJoin()
+            prevJob?.cancelAndJoin()
-			val downloadDir = storageManager.getDefaultWriteableDir()
+            val downloadDir = storageManager.getDefaultWriteableDir()
-			val applicationDirs = storageManager.getApplicationStorageDirs()
+            val applicationDirs = storageManager.getApplicationStorageDirs()
-			val customDirs = settings.userSpecifiedMangaDirectories - applicationDirs
+            val customDirs = settings.userSpecifiedMangaDirectories - applicationDirs
-			items.value = buildList(applicationDirs.size + customDirs.size) {
+            items.value = buildList(applicationDirs.size + customDirs.size) {
-				applicationDirs.mapTo(this) { dir ->
+                applicationDirs.mapTo(this) { dir ->
-					DirectoryModel(
+                    dir.toDirectoryModel(
-						title = storageManager.getDirectoryDisplayName(dir, isFullPath = false),
+                        isDefault = dir == downloadDir,
-						titleRes = 0,
+                        isAppPrivate = true,
-						file = dir,
+                    )
-						isChecked = dir == downloadDir,
+                }
-						isAvailable = dir.isReadable() && dir.isWriteable(),
+                customDirs.mapTo(this) { dir ->
-						isRemovable = false,
+                    dir.toDirectoryModel(
-					)
+                        isDefault = dir == downloadDir,
-				}
+                        isAppPrivate = false,
-				customDirs.mapTo(this) { dir ->
+                    )
-					DirectoryModel(
+                }
-						title = storageManager.getDirectoryDisplayName(dir, isFullPath = false),
+            }
-						titleRes = 0,
+        }
-						file = dir,
+    }
-						isChecked = dir == downloadDir,
+
-						isAvailable = dir.isReadable() && dir.isWriteable(),
+    private suspend fun File.toDirectoryModel(
-						isRemovable = true,
+        isDefault: Boolean,
-					)
+        isAppPrivate: Boolean,
-				}
+    ) = DirectoryConfigModel(
-			}
+        title = storageManager.getDirectoryDisplayName(this, isFullPath = false),
-		}
+        path = this,
-	}
+        isDefault = isDefault,
+        isAccessible = isReadable() && isWriteable(),
+        isAppPrivate = isAppPrivate,
+        size = computeSize(),
+        available = StatFs(this.absolutePath).availableBytes,
+    )
 }

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

@@ -1,57 +1,60 @@
 <?xml version="1.0" encoding="utf-8"?>
 <androidx.coordinatorlayout.widget.CoordinatorLayout
-	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"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
-	android:layout_width="match_parent"
+    xmlns:tools="http://schemas.android.com/tools"
-	android:layout_height="match_parent">
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
 
-	<com.google.android.material.appbar.AppBarLayout
+    <com.google.android.material.appbar.AppBarLayout
-		android:id="@+id/appbar"
+        android:id="@+id/appbar"
-		android:layout_width="match_parent"
+        android:layout_width="match_parent"
-		android:layout_height="wrap_content"
+        android:layout_height="wrap_content"
-		android:fitsSystemWindows="true">
+        android:fitsSystemWindows="true">
 
-		<com.google.android.material.appbar.MaterialToolbar
+        <com.google.android.material.appbar.MaterialToolbar
-			android:id="@id/toolbar"
+            android:id="@id/toolbar"
-			android:layout_width="match_parent"
+            android:layout_width="match_parent"
-			android:layout_height="?attr/actionBarSize"
+            android:layout_height="?attr/actionBarSize"
-			app:layout_scrollFlags="noScroll">
+            app:layout_scrollFlags="noScroll">
 
-		</com.google.android.material.appbar.MaterialToolbar>
+        </com.google.android.material.appbar.MaterialToolbar>
 
-	</com.google.android.material.appbar.AppBarLayout>
+    </com.google.android.material.appbar.AppBarLayout>
 
-	<androidx.recyclerview.widget.RecyclerView
+    <androidx.recyclerview.widget.RecyclerView
-		android:id="@+id/recyclerView"
+        android:id="@+id/recyclerView"
-		android:layout_width="match_parent"
+        android:layout_width="match_parent"
-		android:layout_height="match_parent"
+        android:layout_height="match_parent"
-		android:clipToPadding="false"
+        android:clipToPadding="false"
-		android:orientation="vertical"
+        android:orientation="vertical"
-		android:scrollbars="vertical"
+        android:paddingBottom="@dimen/list_spacing_large"
-		app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
+        android:scrollbars="vertical"
-		app:layout_behavior="com.google.android.material.appbar.AppBarLayout$ScrollingViewBehavior" />
+        app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
+        app:layout_behavior="com.google.android.material.appbar.AppBarLayout$ScrollingViewBehavior"
+        tools:listitem="@layout/item_storage_config2" />
 
-	<com.google.android.material.progressindicator.LinearProgressIndicator
+    <com.google.android.material.progressindicator.LinearProgressIndicator
-		android:id="@+id/progressBar"
+        android:id="@+id/progressBar"
-		android:layout_width="match_parent"
+        android:layout_width="match_parent"
-		android:layout_height="wrap_content"
+        android:layout_height="wrap_content"
-		android:indeterminate="true"
+        android:indeterminate="true"
-		android:visibility="gone"
+        android:visibility="gone"
-		app:layout_anchor="@id/appbar"
+        app:layout_anchor="@id/appbar"
-		app:layout_anchorGravity="bottom" />
+        app:layout_anchorGravity="bottom" />
 
-	<com.google.android.material.floatingactionbutton.ExtendedFloatingActionButton
+    <com.google.android.material.floatingactionbutton.ExtendedFloatingActionButton
-		android:id="@+id/fab_add"
+        android:id="@+id/fab_add"
-		android:layout_width="wrap_content"
+        android:layout_width="wrap_content"
-		android:layout_height="wrap_content"
+        android:layout_height="wrap_content"
-		android:layout_margin="16dp"
+        android:layout_margin="16dp"
-		android:contentDescription="@string/pick_custom_directory"
+        android:contentDescription="@string/pick_custom_directory"
-		android:text="@string/add"
+        android:text="@string/add"
-		app:fabSize="normal"
+        app:fabSize="normal"
-		app:icon="@drawable/ic_add"
+        app:icon="@drawable/ic_add"
-		app:layout_anchor="@id/recyclerView"
+        app:layout_anchor="@id/recyclerView"
-		app:layout_anchorGravity="bottom|end"
+        app:layout_anchorGravity="bottom|end"
-		app:layout_behavior="org.koitharu.kotatsu.core.ui.util.ShrinkOnScrollBehavior"
+        app:layout_behavior="org.koitharu.kotatsu.core.ui.util.ShrinkOnScrollBehavior"
-		app:layout_dodgeInsetEdges="bottom" />
+        app:layout_dodgeInsetEdges="bottom" />
 
 </androidx.coordinatorlayout.widget.CoordinatorLayout>

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

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?>
+<com.google.android.material.card.MaterialCardView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    tools:layout_margin="@dimen/screen_padding">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:paddingBottom="@dimen/margin_small">
+
+        <TextView
+            android:id="@+id/textView_title"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginHorizontal="@dimen/screen_padding"
+            android:layout_marginTop="@dimen/screen_padding"
+            android:ellipsize="end"
+            android:singleLine="true"
+            android:textAppearance="?attr/textAppearanceTitleMedium"
+            tools:text="@tools:sample/lorem[3]" />
+
+        <TextView
+            android:id="@+id/textView_subtitle"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginHorizontal="@dimen/screen_padding"
+            android:layout_marginTop="@dimen/margin_small"
+            android:textAppearance="?attr/textAppearanceBodyMedium"
+            tools:text="@tools:sample/lorem[5]" />
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginHorizontal="@dimen/screen_padding"
+            android:layout_marginTop="@dimen/screen_padding"
+            android:baselineAligned="false"
+            android:gravity="center_vertical"
+            android:orientation="horizontal">
+
+            <TextView
+                android:id="@+id/textView_size"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_marginEnd="@dimen/margin_small"
+                android:layout_weight="1"
+                android:singleLine="true"
+                android:textAppearance="?attr/textAppearanceBodyMedium"
+                android:textColor="?android:textColorSecondary"
+                tools:text="250MB / 10GB" />
+
+            <com.google.android.material.progressindicator.LinearProgressIndicator
+                android:id="@+id/indicator_size"
+                android:layout_width="160dp"
+                android:layout_height="wrap_content"
+                app:trackCornerRadius="5dp"
+                app:trackThickness="10dp"
+                tools:progress="40" />
+
+        </LinearLayout>
+
+        <TextView
+            android:id="@+id/textView_info"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginHorizontal="@dimen/screen_padding"
+            android:layout_marginTop="@dimen/margin_small"
+            android:textAppearance="?attr/textAppearanceBodySmall"
+            android:textColor="?android:textColorSecondary"
+            tools:text="Content will be removed within application" />
+
+        <Button
+            android:id="@+id/button_remove"
+            style="?buttonBarButtonStyle"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="end"
+            android:layout_marginEnd="@dimen/margin_small"
+            android:text="@string/remove" />
+
+        <View
+            android:id="@+id/spacer"
+            android:layout_width="match_parent"
+            android:layout_height="@dimen/margin_small"
+            tools:visibility="gone" />
+
+    </LinearLayout>
+
+</com.google.android.material.card.MaterialCardView>

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

@@ -19,6 +19,7 @@
         android:layout_height="0dp"
         android:layout_weight="1"
         android:clipToPadding="false"
+        android:fillViewport="true"
         android:scrollIndicators="top|bottom"
         tools:ignore="UnusedAttribute">
 

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

@@ -1,216 +1,218 @@
 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout
-	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"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
-	xmlns:tools="http://schemas.android.com/tools"
+    xmlns:tools="http://schemas.android.com/tools"
-	android:layout_width="match_parent"
+    android:layout_width="match_parent"
-	android:layout_height="wrap_content"
+    android:layout_height="wrap_content"
-	android:orientation="vertical">
+    android:orientation="vertical">
 
-	<org.koitharu.kotatsu.core.ui.sheet.AdaptiveSheetHeaderBar
+    <org.koitharu.kotatsu.core.ui.sheet.AdaptiveSheetHeaderBar
-		android:id="@+id/headerBar"
+        android:id="@+id/headerBar"
-		android:layout_width="match_parent"
+        android:layout_width="match_parent"
-		android:layout_height="wrap_content"
+        android:layout_height="wrap_content"
-		app:title="@string/options" />
+        app:title="@string/options" />
 
-	<androidx.core.widget.NestedScrollView
+    <androidx.core.widget.NestedScrollView
-		android:id="@+id/scrollView"
+        android:id="@+id/scrollView"
-		android:layout_width="match_parent"
+        android:layout_width="match_parent"
-		android:layout_height="wrap_content"
+        android:layout_height="wrap_content"
-		android:clipToPadding="false"
+        android:clipToPadding="false"
-		android:scrollIndicators="top">
+        android:scrollIndicators="top">
 
-		<LinearLayout
+        <LinearLayout
-			android:layout_width="match_parent"
+            android:id="@+id/layout_main"
-			android:layout_height="wrap_content"
+            android:layout_width="match_parent"
-			android:orientation="vertical"
+            android:layout_height="wrap_content"
-			android:paddingBottom="@dimen/margin_normal">
+            android:orientation="vertical"
+            android:paddingBottom="@dimen/margin_normal">
 
-			<org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
+            <org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
-				android:id="@+id/button_save_page"
+                android:id="@+id/button_save_page"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:text="@string/save_page"
+                android:text="@string/save_page"
-				app:drawableStartCompat="@drawable/ic_save" />
+                app:drawableStartCompat="@drawable/ic_save" />
 
-			<org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
+            <org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
-				android:id="@+id/button_bookmark"
+                android:id="@+id/button_bookmark"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:text="@string/bookmark_add"
+                android:text="@string/bookmark_add"
-				app:drawableStartCompat="@drawable/ic_bookmark" />
+                app:drawableStartCompat="@drawable/ic_bookmark" />
 
-			<org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
+            <org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
-				android:id="@+id/button_image_server"
+                android:id="@+id/button_image_server"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:drawableEnd="@drawable/ic_expand_more_22px"
+                android:drawableEnd="@drawable/ic_expand_more_22px"
-				android:text="@string/image_server"
+                android:text="@string/image_server"
-				android:visibility="gone"
+                android:visibility="gone"
-				app:drawableStartCompat="@drawable/ic_images"
+                app:drawableStartCompat="@drawable/ic_images"
-				tools:visibility="visible" />
+                tools:visibility="visible" />
 
-			<TextView
+            <TextView
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:layout_marginHorizontal="@dimen/margin_normal"
+                android:layout_marginHorizontal="@dimen/margin_normal"
-				android:layout_marginTop="@dimen/margin_normal"
+                android:layout_marginTop="@dimen/margin_normal"
-				android:text="@string/read_mode"
+                android:text="@string/read_mode"
-				android:textAppearance="?textAppearanceTitleSmall" />
+                android:textAppearance="?textAppearanceTitleSmall" />
 
-			<com.google.android.material.button.MaterialButtonToggleGroup
+            <com.google.android.material.button.MaterialButtonToggleGroup
-				android:id="@+id/checkableGroup"
+                android:id="@+id/checkableGroup"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:layout_marginHorizontal="@dimen/margin_normal"
+                android:layout_marginHorizontal="@dimen/margin_normal"
-				android:layout_marginTop="@dimen/margin_small"
+                android:layout_marginTop="@dimen/margin_small"
-				android:baselineAligned="false"
+                android:baselineAligned="false"
-				android:orientation="horizontal"
+                android:orientation="horizontal"
-				app:selectionRequired="true"
+                app:selectionRequired="true"
-				app:singleSelection="true">
+                app:singleSelection="true">
 
-				<com.google.android.material.button.MaterialButton
+                <com.google.android.material.button.MaterialButton
-					android:id="@+id/button_standard"
+                    android:id="@+id/button_standard"
-					style="@style/Widget.Kotatsu.ToggleButton.Vertical"
+                    style="@style/Widget.Kotatsu.ToggleButton.Vertical"
-					android:layout_width="0dp"
+                    android:layout_width="0dp"
-					android:layout_height="wrap_content"
+                    android:layout_height="wrap_content"
-					android:layout_weight="1"
+                    android:layout_weight="1"
-					android:text="@string/standard"
+                    android:text="@string/standard"
-					app:icon="@drawable/ic_reader_ltr" />
+                    app:icon="@drawable/ic_reader_ltr" />
 
-				<com.google.android.material.button.MaterialButton
+                <com.google.android.material.button.MaterialButton
-					android:id="@+id/button_reversed"
+                    android:id="@+id/button_reversed"
-					style="@style/Widget.Kotatsu.ToggleButton.Vertical"
+                    style="@style/Widget.Kotatsu.ToggleButton.Vertical"
-					android:layout_width="0dp"
+                    android:layout_width="0dp"
-					android:layout_height="wrap_content"
+                    android:layout_height="wrap_content"
-					android:layout_weight="1"
+                    android:layout_weight="1"
-					android:text="@string/right_to_left"
+                    android:text="@string/right_to_left"
-					app:icon="@drawable/ic_reader_rtl" />
+                    app:icon="@drawable/ic_reader_rtl" />
 
-				<com.google.android.material.button.MaterialButton
+                <com.google.android.material.button.MaterialButton
-					android:id="@+id/button_vertical"
+                    android:id="@+id/button_vertical"
-					style="@style/Widget.Kotatsu.ToggleButton.Vertical"
+                    style="@style/Widget.Kotatsu.ToggleButton.Vertical"
-					android:layout_width="0dp"
+                    android:layout_width="0dp"
-					android:layout_height="wrap_content"
+                    android:layout_height="wrap_content"
-					android:layout_weight="1"
+                    android:layout_weight="1"
-					android:text="@string/vertical"
+                    android:text="@string/vertical"
-					app:icon="@drawable/ic_reader_vertical" />
+                    app:icon="@drawable/ic_reader_vertical" />
 
-				<com.google.android.material.button.MaterialButton
+                <com.google.android.material.button.MaterialButton
-					android:id="@+id/button_webtoon"
+                    android:id="@+id/button_webtoon"
-					style="@style/Widget.Kotatsu.ToggleButton.Vertical"
+                    style="@style/Widget.Kotatsu.ToggleButton.Vertical"
-					android:layout_width="0dp"
+                    android:layout_width="0dp"
-					android:layout_height="wrap_content"
+                    android:layout_height="wrap_content"
-					android:layout_weight="1"
+                    android:layout_weight="1"
-					android:text="@string/webtoon"
+                    android:text="@string/webtoon"
-					app:icon="@drawable/ic_script" />
+                    app:icon="@drawable/ic_script" />
 
-			</com.google.android.material.button.MaterialButtonToggleGroup>
+            </com.google.android.material.button.MaterialButtonToggleGroup>
 
-			<TextView
+            <TextView
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:layout_marginHorizontal="@dimen/margin_normal"
+                android:layout_marginHorizontal="@dimen/margin_normal"
-				android:layout_marginTop="@dimen/margin_small"
+                android:layout_marginTop="@dimen/margin_small"
-				android:text="@string/reader_mode_hint"
+                android:text="@string/reader_mode_hint"
-				android:textAppearance="?attr/textAppearanceBodySmall" />
+                android:textAppearance="?attr/textAppearanceBodySmall" />
 
-			<com.google.android.material.materialswitch.MaterialSwitch
+            <com.google.android.material.materialswitch.MaterialSwitch
-				android:id="@+id/switch_double_reader"
+                android:id="@+id/switch_double_reader"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:layout_marginTop="@dimen/margin_normal"
+                android:layout_marginTop="@dimen/margin_normal"
-				android:drawablePadding="?android:listPreferredItemPaddingStart"
+                android:drawablePadding="?android:listPreferredItemPaddingStart"
-				android:minHeight="?android:listPreferredItemHeightSmall"
+                android:minHeight="?android:listPreferredItemHeightSmall"
-				android:paddingStart="?android:listPreferredItemPaddingStart"
+                android:paddingStart="?android:listPreferredItemPaddingStart"
-				android:paddingEnd="?android:listPreferredItemPaddingEnd"
+                android:paddingEnd="?android:listPreferredItemPaddingEnd"
-				android:text="@string/use_two_pages_landscape"
+                android:text="@string/use_two_pages_landscape"
-				android:textAppearance="?textAppearanceListItem"
+                android:textAppearance="?textAppearanceListItem"
-				android:textColor="?colorOnSurfaceVariant"
+                android:textColor="?colorOnSurfaceVariant"
-				app:drawableStartCompat="@drawable/ic_split_horizontal" />
+                app:drawableStartCompat="@drawable/ic_split_horizontal" />
 
-			<TextView
+            <com.google.android.material.materialswitch.MaterialSwitch
-				android:id="@+id/text_sensitivity"
+                android:id="@+id/switch_double_foldable"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:layout_marginHorizontal="@dimen/margin_normal"
+                android:layout_marginTop="@dimen/margin_small"
-				android:layout_marginTop="@dimen/margin_small"
+                android:drawablePadding="?android:listPreferredItemPaddingStart"
-				android:text="@string/two_page_scroll_sensitivity"
+                android:minHeight="?android:listPreferredItemHeightSmall"
-				android:textAppearance="@style/TextAppearance.Kotatsu.GridTitle" />
+                android:paddingStart="?android:listPreferredItemPaddingStart"
+                android:paddingEnd="?android:listPreferredItemPaddingEnd"
+                android:text="@string/auto_double_foldable"
+                android:textAppearance="@style/TextAppearance.Kotatsu.GridTitle"
+                android:textColor="?colorOnSurfaceVariant"
+                android:visibility="gone"
+                tools:visibility="visible" />
 
-			<com.google.android.material.slider.Slider
+            <TextView
-				android:id="@+id/seekbar_sensitivity"
+                android:id="@+id/text_double_sensitivity"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:layout_marginHorizontal="@dimen/margin_small"
+                android:layout_marginHorizontal="@dimen/margin_normal"
-				android:layout_marginTop="@dimen/margin_small"
+                android:layout_marginTop="@dimen/margin_small"
-				android:valueFrom="0"
+                android:text="@string/two_page_scroll_sensitivity"
-				android:valueTo="100"
+                android:textAppearance="@style/TextAppearance.Kotatsu.GridTitle" />
-				app:labelBehavior="floating"
-				tools:value="50" />
 
-			<com.google.android.material.materialswitch.MaterialSwitch
+            <com.google.android.material.slider.Slider
-				android:id="@+id/switch_pull_gesture"
+                android:id="@+id/slider_double_sensitivity"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:layout_marginTop="@dimen/margin_small"
+                android:layout_marginHorizontal="@dimen/margin_small"
-				android:drawablePadding="?android:listPreferredItemPaddingStart"
+                android:layout_marginTop="@dimen/margin_small"
-				android:minHeight="?android:listPreferredItemHeightSmall"
+                android:valueFrom="0"
-				android:paddingStart="?android:listPreferredItemPaddingStart"
+                android:valueTo="100"
-				android:paddingEnd="?android:listPreferredItemPaddingEnd"
+                app:labelBehavior="floating"
-				android:text="@string/enable_pull_gesture_title"
+                tools:value="50" />
-				android:textAppearance="?textAppearanceListItem"
-				android:textColor="?colorOnSurfaceVariant"
-				app:drawableStartCompat="@drawable/ic_gesture_vertical" />
 
-			<org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
+            <org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
-				android:id="@+id/button_screen_rotate"
+                android:id="@+id/button_screen_rotate"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:text="@string/rotate_screen"
+                android:text="@string/rotate_screen"
-				android:visibility="gone"
+                android:visibility="gone"
-				app:drawableStartCompat="@drawable/ic_screen_rotation"
+                app:drawableStartCompat="@drawable/ic_screen_rotation"
-				tools:visibility="visible" />
+                tools:visibility="visible" />
 
-			<com.google.android.material.materialswitch.MaterialSwitch
+            <com.google.android.material.materialswitch.MaterialSwitch
-				android:id="@+id/switch_screen_lock_rotation"
+                android:id="@+id/switch_screen_lock_rotation"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:drawablePadding="?android:listPreferredItemPaddingStart"
+                android:drawablePadding="?android:listPreferredItemPaddingStart"
-				android:ellipsize="end"
+                android:ellipsize="end"
-				android:minHeight="?android:listPreferredItemHeightSmall"
+                android:minHeight="?android:listPreferredItemHeightSmall"
-				android:paddingStart="?android:listPreferredItemPaddingStart"
+                android:paddingStart="?android:listPreferredItemPaddingStart"
-				android:paddingEnd="?android:listPreferredItemPaddingEnd"
+                android:paddingEnd="?android:listPreferredItemPaddingEnd"
-				android:singleLine="true"
+                android:singleLine="true"
-				android:text="@string/lock_screen_rotation"
+                android:text="@string/lock_screen_rotation"
-				android:textAppearance="?textAppearanceListItem"
+                android:textAppearance="?textAppearanceListItem"
-				android:textColor="?colorOnSurfaceVariant"
+                android:textColor="?colorOnSurfaceVariant"
-				android:visibility="gone"
+                android:visibility="gone"
-				app:drawableStartCompat="@drawable/ic_screen_rotation_lock"
+                app:drawableStartCompat="@drawable/ic_screen_rotation_lock"
-				tools:visibility="visible" />
+                tools:visibility="visible" />
 
-			<org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
+            <org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
-				android:id="@+id/button_scroll_timer"
+                android:id="@+id/button_scroll_timer"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:text="@string/automatic_scroll"
+                android:text="@string/automatic_scroll"
-				app:drawableStartCompat="@drawable/ic_timer" />
+                app:drawableStartCompat="@drawable/ic_timer" />
 
-			<org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
+            <org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
-				android:id="@+id/button_color_filter"
+                android:id="@+id/button_color_filter"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:text="@string/color_correction"
+                android:text="@string/color_correction"
-				app:drawableStartCompat="@drawable/ic_appearance" />
+                app:drawableStartCompat="@drawable/ic_appearance" />
 
-			<org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
+            <org.koitharu.kotatsu.core.ui.widgets.ListItemTextView
-				android:id="@+id/button_settings"
+                android:id="@+id/button_settings"
-				android:layout_width="match_parent"
+                android:layout_width="match_parent"
-				android:layout_height="wrap_content"
+                android:layout_height="wrap_content"
-				android:text="@string/settings"
+                android:text="@string/settings"
-				app:drawableStartCompat="@drawable/ic_settings" />
+                app:drawableStartCompat="@drawable/ic_settings" />
 
-		</LinearLayout>
+        </LinearLayout>
 
-	</androidx.core.widget.NestedScrollView>
+    </androidx.core.widget.NestedScrollView>
 </LinearLayout>

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

@@ -64,6 +64,14 @@
 						android:text="@string/sync_auth"
 						app:chipIcon="@drawable/ic_sync" />
 
+					<com.google.android.material.chip.Chip
+						android:id="@+id/chip_directories"
+						style="@style/Widget.Kotatsu.Chip.Assist"
+						android:layout_width="wrap_content"
+						android:layout_height="wrap_content"
+						android:text="@string/local_manga_directories"
+						app:chipIcon="@drawable/ic_storage" />
+
 				</com.google.android.material.chip.ChipGroup>
 
 			</HorizontalScrollView>

app/src/main/res/menu/opt_search_kind.xml

@@ -33,6 +33,20 @@
 					android:title="@string/genre" />
 
 			</group>
+
+			<group android:id="@+id/group_search_filters">
+
+				<item
+					android:id="@+id/action_filter_pinned_only"
+					android:checkable="true"
+					android:title="@string/pinned_sources_only" />
+
+				<item
+					android:id="@+id/action_filter_hide_empty"
+					android:checkable="true"
+					android:title="@string/hide_empty_sources" />
+
+			</group>
 		</menu>
 
 	</item>

app/src/main/res/values-bn/strings.xml

@@ -179,4 +179,43 @@
     <string name="incognito_mode_hint">আপনার পড়ার অগ্রগতি সেভ হবে না</string>
     <string name="volume_">আওয়াজ%d</string>
     <string name="volume_unknown">অজানা ভলিউম</string>
+    <string name="suggested_queries">সাম্প্রতিক প্রশ্ন</string>
+    <string name="authors">লেখক</string>
+    <string name="blocked_by_server_message">আপনি সার্ভার দ্বারা অবরুদ্ধ করা হয়. একটি ভিন্ন নেটওয়ার্ক সংযোগ ব্যবহার করার চেষ্টা করুন (ভিপিএন, প্রক্সি, ইত্যাদি)</string>
+    <string name="disable">নিষ্ক্রিয় করুন</string>
+    <string name="sources_disabled">উৎস নিষ্ক্রিয়</string>
+    <string name="disable_connectivity_check">সংযোগ পরীক্ষা করতে অক্ষম করুন</string>
+    <string name="ignore_ssl_errors_summary">নেটওয়ার্ক সংস্থানগুলি অ্যাক্সেস করার সময় আপনি যদি কোনও SSL- সম্পর্কিত সমস্যার মুখোমুখি হন তবে আপনি SSL শংসাপত্র যাচাইকরণ অক্ষম করতে পারেন৷ এটি আপনার নিরাপত্তা প্রভাবিত করতে পারে। এই সেটিং পরিবর্তন করার পরে অ্যাপ্লিকেশন পুনরায় চালু করা প্রয়োজন।</string>
+    <string name="disable_connectivity_check_summary">আপনার সমস্যা থাকলে কানেক্টিভিটি চেক এড়িয়ে যান (যেমন, নেটওয়ার্ক সংযুক্ত থাকা সত্ত্বেও অফলাইন মোডে যাওয়া)</string>
+    <string name="disable_nsfw_notifications">NSFW বিজ্ঞপ্তি অক্ষম করুন</string>
+    <string name="disable_nsfw_notifications_summary">NSFW মাঙ্গা আপডেট সম্পর্কে বিজ্ঞপ্তি দেখাবেন না</string>
+    <string name="tracker_debug_info">নতুন অধ্যায় লগ জন্য পরীক্ষা করা হচ্ছে</string>
+    <string name="tracker_debug_info_summary">নতুন অধ্যায়গুলির জন্য পটভূমি পরীক্ষা সম্পর্কে তথ্য ডিবাগ করুন</string>
+    <string name="_new">নতুন</string>
+    <string name="all_languages">সব ভাষা</string>
+    <string name="screenshots_block_incognito">ছদ্মবেশী মোড হলে ব্লক করুন</string>
+    <string name="image_server">পছন্দের ইমেজ সার্ভার</string>
+    <string name="crop_pages">পৃষ্ঠাগুলি কাটা</string>
+    <string name="pin">পিন</string>
+    <string name="unpin">আনপিন করুন</string>
+    <string name="source_pinned">উৎস পিন করা হয়েছে</string>
+    <string name="source_unpinned">উৎস আনপিন করা হয়েছে</string>
+    <string name="sources_unpinned">উৎস আনপিন করা হয়েছে</string>
+    <string name="sources_pinned">উৎস পিন করা হয়েছে</string>
+    <string name="recent_sources">সাম্প্রতিক সূত্র</string>
+    <string name="percent_read">শতকরা কতটুকু করেছেন</string>
+    <string name="percent_left">শতকরা কতটুকু পড়তে বাকি আছে</string>
+    <string name="chapters_read">অধ্যায় পড়া</string>
+    <string name="chapters_left">অধ্যায় বাকি আছে</string>
+    <string name="external_source">বাহ্যিক/প্লাগইন</string>
+    <string name="plugin_incompatible">বেমানান প্লাগইন বা অভ্যন্তরীণ ত্রুটি. আপনি প্লাগইন এবং Kotatsu এর সর্বশেষ সংস্করণ ব্যবহার করছেন তা নিশ্চিত করুন৷</string>
+    <string name="plugin_incompatible_with_cause">প্লাগইন ত্রুটি: %s \n· নিশ্চিত করুন যে আপনি প্লাগইন এবং Kotatsu এর সর্বশেষ সংস্করণ ব্যবহার করছেন</string>
+    <string name="connection_ok">সংযোগ ঠিক আছে</string>
+    <string name="invalid_proxy_configuration">অবৈধ প্রক্সি কনফিগারেশন</string>
+    <string name="show_quick_filters">দ্রুত ফিল্টার দেখান</string>
+    <string name="show_quick_filters_summary">নির্দিষ্ট পরামিতি দ্বারা মাঙ্গা তালিকা ফিল্টার করার ক্ষমতা প্রদান করে</string>
+    <string name="sfw">SFW</string>
+    <string name="skip_all">সব এড়িয়ে যান</string>
+    <string name="stuck">আটকে গেছে</string>
+    <string name="source_broken_warning">এই মঙ্গা সূত্রটি\nভাঙ্গা হিসাবে চিহ্নিত। কিছু বৈশিষ্ট্য \nকাজ নাও হতে পারে</string>
 </resources>

app/src/main/res/values-cs/strings.xml

@@ -740,7 +740,7 @@
     <string name="all_sources_enabled">Všechny zdroje jsou povoleny</string>
     <string name="rating">Hodnocení</string>
     <string name="source">Zdroj</string>
-    <string name="incognito">Anonymní</string>
+    <string name="incognito">Inkognito</string>
     <string name="reader_info_bar_transparent">Průhledný informační proužek pro čtenáře</string>
     <string name="handle_links">Spravovat odkazy</string>
     <string name="handle_links_summary">Zpracování odkazů na manga z externích aplikací (např. webového prohlížeče). Může být také nutné povolit ji ručně v systémových nastaveních aplikace</string>
@@ -812,4 +812,75 @@
     <string name="creating_backup">Vytváření kopie</string>
     <string name="collapse_long_description">Sbalit dlouhý popis</string>
     <string name="changelog">Seznam změn</string>
+    <string name="saved_filters">Uložené filtry</string>
+    <string name="enter_name">Vložte jméno</string>
+    <string name="theme_name_expressive">Výrazný (Test)</string>
+    <string name="pull_to_prev_chapter">Uvolněte pro otevření předešlé kapitoly</string>
+    <string name="pull_to_next_chapter">Uvolněte pro otevření další kapitoly</string>
+    <string name="pull_top_no_prev">Žádná předešlá kapitola</string>
+    <string name="pull_bottom_no_next">Žádná další kapitola</string>
+    <string name="frequency_every_6_hours">Každých 6 hodin</string>
+    <string name="reader_navigation_inverted">Převrátit navigační prvky</string>
+    <string name="reader_navigation_inverted_summary">Vyměňit směr tlačítka hlasitosti a šipek na klávesnici (vlevo/nahoru/dolů/vpravo)</string>
+    <string name="two_page_scroll_sensitivity">Dvoustranná citlivost posouvání</string>
+    <string name="enable_pull_gesture_title">Povolit tahová gesta</string>
+    <string name="enable_pull_gesture_summary">Použijte tahová gesta pro přepínání kapitol v režimu webtoon</string>
+    <string name="reader_chapter_toast">Zobrazit změnu kapitoly pomocí pop-upu</string>
+    <string name="reader_chapter_toast_summary">Zobrazit pop-up s názvem kapitoly, když se změní</string>
+    <string name="badges_in_lists">Odznaky v seznamech</string>
+    <string name="link_to_manga_on_s">Odkaz na mangu na %s</string>
+    <string name="no_write_permission_to_file">Nemá oprávnění k ukládání souboru</string>
+    <string name="error_non_file_uri">Zvolená cesta nemůže být použita, protože neoznačuje soubor nebo adresář</string>
+    <string name="use_default_cover">Použít výchozí přebal</string>
+    <string name="pick_manga_page">Vyberte stranu mangy</string>
+    <string name="pick_custom_file">Vybrat vlastní přebal</string>
+    <string name="change_cover">Změnit přebal</string>
+    <string name="page_switch_timer">Strana se změní kažých ~%d sekund</string>
+    <string name="incognito_mode_hint_nsfw">Tato manga může obsahovat dospělá témata. Chcete použít režim inkognito?</string>
+    <string name="incognito_for_nsfw">Režim inkognito pro NSFW mangu</string>
+    <string name="additional_action_required">Dodatečná akce je nutná</string>
+    <string name="hide_from_main_screen">Skrýt z hlavní obrazovky</string>
+    <string name="changelog_summary">Historie změn pro nedávno vydané verze</string>
+    <string name="reader_multitask">Otevřít čtečku ve vlastním okně</string>
+    <string name="reader_multitask_summary">Umožňuje zároveň otevřít několik různých mang ve vlastních oknech</string>
+    <string name="theme_name_itsuka">Itsuka</string>
+    <string name="theme_name_totoro">Totoro</string>
+    <string name="book_effect">Nažloutlé pozadí (filtr modrého světla)</string>
+    <string name="local_storage_cleanup">Čištění místního úložišťe</string>
+    <string name="packup_creation_failed">Nepodařilo se vytvořit zálohu</string>
+    <string name="main_screen">Hlavní obrazovka</string>
+    <string name="main_screen_fab">Zobrazit plovoucí tlačítko Pokračovat</string>
+    <string name="main_screen_fab_summary">Umožňuje pokračovat ve čtení jedním kliknutím. Toto tlačítko se nezobrazí v režimu inkognito nebo když je historie prázdná</string>
+    <string name="error_corrupted_zip">Poškozený ZIP archiv (%s)</string>
+    <string name="discord_rpc">Discord Rich Presence</string>
+    <string name="discord_token">Discord Token</string>
+    <string name="discord_token_summary">Zadejte svůj Discord Token, abyste zapnuli Rich Presence</string>
+    <string name="discord_token_description">Zadejte svůj Discord Token nebo klikněte na %s, abyste ho získali pomocí prohlížeče</string>
+    <string name="discord_token_hint">Vložte svůj Discord Token zde</string>
+    <string name="discord_rpc_summary">Zobrazit stav čtení na Discordu</string>
+    <string name="obtain">Získat</string>
+    <string name="discord_rpc_description">Čte mangu na Kotatsu - aplikace pro čtení mangy</string>
+    <string name="reading_s">Čtení %s</string>
+    <string name="read_on_s">Číst na %s</string>
+    <string name="rpc_skip_nsfw_summary">Nepoužívat RPC pro mangu pro dospělé</string>
+    <string name="invalid_token">Neplatný token: %s</string>
+    <string name="show_floating_control_button">Zobrazit plovoucí ovládací tlačítko</string>
+    <string name="unavailable">Nedostupné</string>
+    <string name="manga_restricted_description">Tato manga není k dispozici od tohoto zdroje. Zkuste ji vyhledat v jiných zdrojích nebo otevřít v prohlížeči pro více informací</string>
+    <string name="no_chapters_in_manga">Tato manga neobsahuje žádné kapitoly</string>
+    <string name="chapters_load_failed">Načítání kapitol selhalo</string>
+    <string name="telegram_integration">Integrace Telegramu</string>
+    <string name="test_parser">Vyzkoušet zdroje mang</string>
+    <string name="rename">Přejmenovat</string>
+    <string name="save_filter">Uložit filtr</string>
+    <string name="overwrite">Nahradit</string>
+    <string name="filter_overwrite_confirm">Filtr pojmenován\"%s\" již existuje. Chcete ho nahradit?</string>
+    <string name="storage_and_network">Uložiště a síť</string>
+    <string name="create_or_restore_backup">Vytvořit nebo obnovit zálohu</string>
+    <string name="data_removal">Odstranění dat</string>
+    <string name="privacy">Soukromí</string>
+    <string name="source_broken_warning">Tento zdroj byl označen jako rozbitý. Některé funkce nemusí fungovat</string>
+    <string name="download_default_directory">Výchozí adresář pro stahování mangy</string>
+    <string name="private_app_directory_warning">Tento adresář a všechna data v něm budou smazána, pokud odinstalujete aplikaci</string>
+    <string name="available_pattern">%1$s dostupný</string>
 </resources>

app/src/main/res/values-fil/strings.xml

@@ -859,4 +859,8 @@
     <string name="pull_bottom_no_next">Walang susunod na kabanata</string>
     <string name="enable_pull_gesture_title">Paganahin ang paghila na gesture</string>
     <string name="enable_pull_gesture_summary">Gamitin ang paghila na gesture para makapagpalit ng kabanata sa webtoon</string>
+    <string name="saved_filters">Naka-save na mga filter</string>
+    <string name="enter_name">Ipasok ang pangalan</string>
+    <string name="reader_chapter_toast">Ipakita ang popup sa pagpalit ng kabanata</string>
+    <string name="reader_chapter_toast_summary">Magpakita ng pop-up na mensahe na may pamagat ng kabanata kapag binago ito</string>
 </resources>

app/src/main/res/values-hr/strings.xml

@@ -579,8 +579,8 @@
     <string name="reader_actions_summary">Konfigurirajte radnje za dodirna područja zaslona</string>
     <string name="switch_pages_volume_buttons_summary">Koristite tipke za glasnoću za prebacivanje stranica</string>
     <string name="tap_action">Radnja pri dodiru</string>
-    <string name="long_tap_action">Radnja dugog dodira</string>
+    <string name="long_tap_action">Radnja pri dugom dodiru</string>
-    <string name="use_two_pages_landscape">Koristi izgled dvije stranice u pejzažnoj orijentaciji (beta)</string>
+    <string name="use_two_pages_landscape">Koristi raspored dviju stranice u poleženom položaju (beta)</string>
     <string name="download_option_next_unread_n_chapters">Sljedeći nepročitani %s</string>
     <string name="download_option_all_unread">Sva nepročitana poglavlja</string>
     <string name="download_option_all_unread_b">Sva nepročitana poglavlja (%s)</string>
@@ -861,4 +861,24 @@
     <string name="test_parser">Testiraj izvor mange</string>
     <string name="discord_rpc">Discord Rich Presence</string>
     <string name="discord_token_summary">Unesi svoj Discord token za uključivanje Rich Presence podataka</string>
+    <string name="saved_filters">Spremljeni filtri</string>
+    <string name="enter_name">Upiši ime</string>
+    <string name="reader_chapter_toast_summary">Prikaži skočnu poruku s naslovom poglavlja kada je promijenjen</string>
+    <string name="rename">Preimenuj</string>
+    <string name="save_filter">Spremi filtar</string>
+    <string name="reader_chapter_toast">Prikaži skočnu poruku za promijenjeno poglavlje</string>
+    <string name="two_page_scroll_sensitivity">Osjetljivost pomicanja dviju stranica</string>
+    <string name="frequency_every_6_hours">Svakih 6 sati</string>
+    <string name="overwrite">Prepiši</string>
+    <string name="filter_overwrite_confirm">Filtar s imenom „%s” već postoji. Želiš li ga prepisati?</string>
+    <string name="storage_and_network">Spremište i mreža</string>
+    <string name="create_or_restore_backup">Stvori ili obnovi sigurnosnu kopiju</string>
+    <string name="data_removal">Uklanjanje podataka</string>
+    <string name="privacy">Privatnost</string>
+    <string name="source_broken_warning">Ovaj izvor mange označen je kao pokvaren. Neke funkcije možda neće raditi</string>
+    <string name="download_default_directory">Standardni direktorij za preuzimanje manga</string>
+    <string name="private_app_directory_warning">Ako deinstaliraš aplikaciju, ovaj će se direktorij izbrisati sa svim podacima</string>
+    <string name="available_pattern">%1$s dostupno</string>
+    <string name="pinned_sources_only">Samo prikvačeni izvori</string>
+    <string name="hide_empty_sources">Sakrij prazne izvore</string>
 </resources>

app/src/main/res/values-in/plurals.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
     <plurals name="items">
-        <item quantity="other">”%1$d butir</item>
+        <item quantity="other">%1$d item</item>
     </plurals>
     <plurals name="new_chapters">
         <item quantity="other">%1$d Sub-bab Baru</item>

app/src/main/res/values-in/strings.xml

@@ -865,4 +865,24 @@
     <string name="pull_bottom_no_next">Tidak ada bab berikutnya</string>
     <string name="enable_pull_gesture_title">Aktifkan gerakan tarik</string>
     <string name="enable_pull_gesture_summary">Gunakan gerakan tarik untuk pindah bab di webtoon</string>
+    <string name="two_page_scroll_sensitivity">Sensitivitas Gulir Dua Halaman</string>
+    <string name="saved_filters">Filter tersimpan</string>
+    <string name="enter_name">Masukkan nama</string>
+    <string name="reader_chapter_toast">Tampilkan popup perubahan bab</string>
+    <string name="reader_chapter_toast_summary">Tampilkan pesan pop-up dengan judul bab saat diubah</string>
+    <string name="rename">Ganti nama</string>
+    <string name="save_filter">Simpan filter</string>
+    <string name="overwrite">Timpa</string>
+    <string name="filter_overwrite_confirm">Filter bernama \"%s\" sudah ada. Ingin menimpanya?</string>
+    <string name="storage_and_network">Penyimpanan dan jaringan</string>
+    <string name="create_or_restore_backup">Buat atau pulihkan cadangan</string>
+    <string name="data_removal">Penghapusan data</string>
+    <string name="source_broken_warning">Sumber manga ini telah ditandai rusak. Beberapa fitur mungkin tidak berfungsi</string>
+    <string name="privacy">Pribadi</string>
+    <string name="frequency_every_6_hours">Setiap 6 jam</string>
+    <string name="download_default_directory">Direktori default untuk mengunduh manga</string>
+    <string name="private_app_directory_warning">Direktori ini beserta semua datanya akan dihapus jika Anda menghapus aplikasi</string>
+    <string name="available_pattern">%1$s tersedia</string>
+    <string name="pinned_sources_only">Hanya sumber yang disematkan</string>
+    <string name="hide_empty_sources">Sembunyikan sumber kosong</string>
 </resources>

app/src/main/res/values-it/strings.xml

@@ -866,4 +866,22 @@
     <string name="pull_bottom_no_next">Nessun capitolo successivo</string>
     <string name="enable_pull_gesture_title">Abilita gesto di scorrimento</string>
     <string name="enable_pull_gesture_summary">Abilita gesto di scorrimento per cambiare capitolo in webtoon</string>
+    <string name="two_page_scroll_sensitivity">Sensibilità di scorrimento a due pagine</string>
+    <string name="saved_filters">Filtri salvati</string>
+    <string name="enter_name">Inserisci nome</string>
+    <string name="reader_chapter_toast">Mostra popup di cambio capitolo</string>
+    <string name="reader_chapter_toast_summary">Mostra un messaggio pop-up con un titolo del capitolo quando è cambiato</string>
+    <string name="rename">Rinomina</string>
+    <string name="save_filter">Salva filtro</string>
+    <string name="overwrite">Sovrascrivi</string>
+    <string name="filter_overwrite_confirm">Un filtro di nome \"%s\" esiste già. Vuoi sovrascriverlo?</string>
+    <string name="storage_and_network">Memoria e rete</string>
+    <string name="create_or_restore_backup">Crea o ripristina un backup</string>
+    <string name="data_removal">Rimozione dei dati</string>
+    <string name="privacy">Privacy</string>
+    <string name="source_broken_warning">Questa fonte manga è stata contrassegnata come non funzionante. Alcune funzioni potrebbero non essere disponibili</string>
+    <string name="frequency_every_6_hours">Ogni 6 ore</string>
+    <string name="download_default_directory">Cartella predefinita per scaricare manga</string>
+    <string name="private_app_directory_warning">Questa cartella e tutti i suoi dati verranno eliminati se disinstalli l\'applicazione</string>
+    <string name="available_pattern">%1$s disponibile</string>
 </resources>

app/src/main/res/values-ja/strings.xml

@@ -93,7 +93,7 @@
     <string name="manga_shelf">本棚</string>
     <string name="recent_manga">最近</string>
     <string name="pages_animation">ページアニメーション</string>
-    <string name="manga_save_location">ダウンロード用のフォルダ</string>
+    <string name="manga_save_location">ダウンロードフォルダ</string>
     <string name="not_available">利用不可</string>
     <string name="cannot_find_available_storage">使用可能なストレージがありません</string>
     <string name="other_storage">その他のストレージ</string>
@@ -101,7 +101,7 @@
     <string name="all_favourites">全てのお気に入り</string>
     <string name="read_later">後で読む</string>
     <string name="updates">更新</string>
-    <string name="text_feed_holder">あなたが読んでいるものの新しいチャプターがここに示されています</string>
+    <string name="text_feed_holder">あなたが読んでいるものの新しい章がここに示されています</string>
     <string name="search_results">の検索結果</string>
     <string name="size_s">サイズ:%s</string>
     <string name="clear_updates_feed">更新フィードをクリア</string>
@@ -249,7 +249,7 @@
     <string name="send">送信</string>
     <string name="disable_all">すべて無効にする</string>
     <string name="appwidget_recent_description">最近読んだ漫画</string>
-    <string name="use_fingerprint">指紋がある場合は、指紋を使用する</string>
+    <string name="use_fingerprint">利用可能な場合、指紋認証を使用する</string>
     <string name="appwidget_shelf_description">お気に入りの漫画</string>
     <string name="report">報告</string>
     <string name="status_reading">読書</string>
@@ -316,7 +316,7 @@
     <string name="reader_control_ltr">人間工学に基づいたリーダーコントロール</string>
     <string name="history_shortcuts">最近のマンガのショートカットを表示</string>
     <string name="history_shortcuts_summary">アプリケーションアイコンを長押しして最近のマンガを利用できるようにする</string>
-    <string name="reader_control_ltr_summary">右端をタップするか、右キーを押すと、常に次のページに切り替わります</string>
+    <string name="reader_control_ltr_summary">ページ切り替え方向をリーダーモードに調整しないでください。例えば、右キーを押すと常に次のページに切り替わります。このオプションはハードウェア入力デバイスにのみ影響します。</string>
     <string name="color_correction">色補正</string>
     <string name="brightness">輝度</string>
     <string name="contrast">コントラスト</string>
@@ -565,7 +565,7 @@
     <string name="show_labels_in_navbar">ナビゲーションバーにラベルを表示する</string>
     <string name="pages_saving">ページを保存</string>
     <string name="remove_from_history">履歴から削除</string>
-    <string name="preferred_download_format">希望するダウンロード形式</string>
+    <string name="preferred_download_format">推奨ダウンロード形式</string>
     <string name="single_cbz_file">単一のCBZファイル</string>
     <string name="multiple_cbz_files">複数のCBZファイル</string>
     <string name="other_manga">他のマンガ</string>
@@ -671,4 +671,148 @@
     <string name="genre">ジャンル</string>
     <string name="download_added">ダウンロードに追加</string>
     <string name="chapter_selection_hint">チャプターリストの項目を長押しすると、ダウンロードするチャプターを選択できます。</string>
+    <string name="frequency_every_6_hours">6時間毎に</string>
+    <string name="available_pattern">%1$sが有効</string>
+    <string name="no_chapters_in_manga">この漫画には利用可能なチャプターが含まれていません</string>
+    <string name="chapters_load_failed">チャプターリストの読み込みに失敗</string>
+    <string name="telegram_integration">Telegramで連携</string>
+    <string name="test_parser">漫画のソースをテストする</string>
+    <string name="rename">リネーム</string>
+    <string name="save_filter">フィルターを保存</string>
+    <string name="overwrite">上書き</string>
+    <string name="filter_overwrite_confirm">「%s」という名前のフィルターが既に存在します。上書きしますか？</string>
+    <string name="storage_and_network">ストレージとネットワーク</string>
+    <string name="create_or_restore_backup">バックアップを作成または復元する</string>
+    <string name="data_removal">データ削除</string>
+    <string name="privacy">プライバシー</string>
+    <string name="source_broken_warning">この漫画ソースは破損しているとマークされています。一部の機能が動作しない可能性があります</string>
+    <string name="download_default_directory">漫画ダウンロードのデフォルトディレクトリ</string>
+    <string name="private_app_directory_warning">アプリケーションをアンインストールすると、このディレクトリとすべてのデータが削除されます</string>
+    <string name="author">著者</string>
+    <string name="rating">評価</string>
+    <string name="source">ソース</string>
+    <string name="translation">翻訳</string>
+    <string name="captcha_required_message">このソースを続行するにはキャプチャを解決する必要があります</string>
+    <string name="ask_every_time">いつでも聞いて</string>
+    <string name="screen_orientation">画面の向き</string>
+    <string name="portrait">肖像画</string>
+    <string name="landscape">風景</string>
+    <string name="by_name_reverse">名前を反転</string>
+    <string name="content_rating">コンテンツレーティング</string>
+    <string name="global_search">グローバルサーチ</string>
+    <string name="disable_captcha_notifications">Captcha通知を無効にする</string>
+    <string name="disable_captcha_notifications_summary">このソースのCaptchaに関する通知は届きませんが、これによりバックグラウンド操作（新章の確認、おすすめ情報の取得など）が中断される可能性があります</string>
+    <string name="chapter_volume_number">巻 %1$s 章 %2$s</string>
+    <string name="chapter_number">章%s</string>
+    <string name="unnamed_chapter">名前のない章</string>
+    <string name="search_disabled_sources">無効化されたソースを検索する</string>
+    <string name="error_details">エラーの詳細</string>
+    <string name="error_disclaimer_manga">ウェブブラウザで漫画を開いて、そのソースで利用可能かどうかを確認してください。</string>
+    <string name="error_disclaimer_app_outdated">お使いのKotatsuのバージョンが古くなっているようです。最新のバージョンをインストールして、利用可能なすべての修正プログラムを入手してください。</string>
+    <string name="error_disclaimer_report">開発者へバグ報告を提出できます。これにより問題の調査と修正に役立ちます。</string>
+    <string name="link_to_manga_on_s">%sの漫画へのリンク</string>
+    <string name="link_to_manga_in_app">Kotatsuの中の漫画へのリンク</string>
+    <string name="clear_browser_data">ブラウザのデータを消去する</string>
+    <string name="clear_browser_data_summary">キャッシュやクッキーなどのブラウザデータを消去してください。警告：マンガソースでの認証が無効になる可能性があります</string>
+    <string name="no_write_permission_to_file">ファイルへの書き込み権限がありません</string>
+    <string name="exclude_nsfw_from_suggestions_summary">成人向け漫画はおすすめに表示されません。このオプションは一部のソースでは正確に機能しない場合があります</string>
+    <string name="include_disabled_sources">無効化されたソースを含める</string>
+    <string name="suggestions_disabled_sources_summary">すべてのマンガソースからの提案を表示する（無効化されているものも含む）</string>
+    <string name="tags_warnings">危険なジャンルを強調する</string>
+    <string name="tags_warnings_summary">ほとんどのユーザーにとって不適切と思われるジャンルを強調表示する</string>
+    <string name="error_non_file_uri">選択されたパスはファイルまたはディレクトリを指していないため使用できません</string>
+    <string name="manga_override_hint">これらの変更は、アプリ内でのマンガの表示方法に影響を与えます</string>
+    <string name="use_default_cover">デフォルトの表紙を使用する</string>
+    <string name="pick_manga_page">漫画のページを選ぶ</string>
+    <string name="pick_custom_file">カスタムファイルを選択</string>
+    <string name="change_cover">カバーを変える</string>
+    <string name="page_switch_timer">ページは約%d秒ごとに切り替わります</string>
+    <string name="dont_ask_again">二度と聞くな</string>
+    <string name="incognito_mode_hint_nsfw">この漫画には成人向けの内容が含まれている可能性があります。シークレットモードを使用しますか？</string>
+    <string name="incognito_for_nsfw">成人向け漫画のシークレットモード</string>
+    <string name="additional_action_required">追加の操作が必要です</string>
+    <string name="hide_from_main_screen">メイン画面から非表示にする</string>
+    <string name="changelog">変更履歴</string>
+    <string name="changelog_summary">最近リリースされたバージョンの変更履歴</string>
+    <string name="collapse">折りたたむ</string>
+    <string name="expand">拡張する</string>
+    <string name="adblock">ブラウザで広告をブロックする</string>
+    <string name="adblock_summary">組み込みブラウザでの広告ブロック（ベータ版）</string>
+    <string name="collapse_long_description">長い説明を折りたたむ</string>
+    <string name="creating_backup">バックアップを作成する</string>
+    <string name="share_backup">バックアップを共有する</string>
+    <string name="reader_multitask">別のタスクでリーダーを開く</string>
+    <string name="reader_multitask_summary">複数の異なる漫画を開いたまま、複数のリーダーを同時に保持できます</string>
+    <string name="theme_name_itsuka">トピックス</string>
+    <string name="theme_name_totoro">トトロ</string>
+    <string name="book_effect">黄色がかった背景(青いフィルター)</string>
+    <string name="local_storage_cleanup">ローカルストレージのクリーンアップ</string>
+    <string name="packup_creation_failed">バックアップの作成に失敗しました</string>
+    <string name="main_screen">メイン画面</string>
+    <string name="main_screen_fab">フローティングの「続行」ボタンを表示</string>
+    <string name="main_screen_fab_summary">ワンクリックで読み続けられます。このボタンはシークレットモード時や履歴が空の時には表示されません</string>
+    <string name="error_corrupted_zip">破損したZIPアーカイブ(%s)</string>
+    <string name="discord_rpc">Discord リッチプレゼンス</string>
+    <string name="discord_token">Discordトークン</string>
+    <string name="discord_token_summary">リッチプレゼンスを有効にするには、Discordトークンを入力してください</string>
+    <string name="discord_token_description">Discord トークンを入力するか、%s をクリックしてブラウザーで取得します</string>
+    <string name="discord_token_hint">ここにDiscordトークンを貼り付けてください</string>
+    <string name="discord_rpc_summary">Discordで読み取りステータスを表示</string>
+    <string name="obtain">アクセス</string>
+    <string name="discord_rpc_description">Kotatsuで漫画を読む - 漫画リーダーアプリ</string>
+    <string name="reading_s">読書 %s</string>
+    <string name="read_on_s">%s で読む</string>
+    <string name="rpc_skip_nsfw_summary">成人向けコンテンツに RPC を使用しないでください</string>
+    <string name="invalid_token">無効なトークン: %s</string>
+    <string name="show_floating_control_button">「続行」ボタンをフローティングで表示</string>
+    <string name="unavailable">利用案内</string>
+    <string name="manga_restricted_description">このマンガは、このソースで読み込むことはできません。 他のソースで検索するか、ブラウザで開くと、より多くの情報が得られます</string>
+    <string name="saved_filters">保存フィルター</string>
+    <string name="chapters_grid_view">グリッドビュー</string>
+    <string name="enter_name">名前を入力してください</string>
+    <string name="nsfw_16">16歳以上</string>
+    <string name="theme_name_expressive">エクスプレス(テスト)</string>
+    <string name="pull_to_prev_chapter">前の章を開く</string>
+    <string name="pull_to_next_chapter">次の章を開く</string>
+    <string name="state_abandoned">ドロップ</string>
+    <string name="speed_value">x%.1f</string>
+    <string name="lock_screen_rotation">ロック スクリーンの回転</string>
+    <string name="manage_sources">ソースの管理</string>
+    <string name="manual">マニュアル</string>
+    <string name="available_d">利用可能: %1$d</string>
+    <string name="reader_optimize_summary">画面外ページの品質を下げ、メモリ使用量を削減する</string>
+    <string name="state">ステータス</string>
+    <string name="error_filter_states_genre_not_supported">両方のジャンルや状態のフィルタリングは、このソースではサポートされていません</string>
+    <string name="volume_unknown">未知のボリューム</string>
+    <string name="vertical">プロフィール</string>
+    <string name="last_read">最近の投稿</string>
+    <string name="reader_actions">リーダーの動作</string>
+    <string name="none">なし</string>
+    <string name="two_page_scroll_sensitivity">2ページスクロール感度</string>
+    <string name="ask_for_dest_dir_every_time">毎回、目的のディレクトリを指定してください</string>
+    <string name="default_page_save_dir">デフォルトページ保存ディレクトリ</string>
+    <string name="location">アクセス</string>
+    <string name="reading_stats">統計を読む</string>
+    <string name="all_time">すべての時間</string>
+    <string name="pages_read_s">ページの読み込み: %s</string>
+    <string name="migrate_confirmation">「%2$s」から「%3$s」を「%4$s」に置き換えられます</string>
+    <string name="chapters_deleted_pattern">%1$s を削除し、%2$s をクリア</string>
+    <string name="split_by_translations">翻訳によるスプリット</string>
+    <string name="order_oldest">最新記事</string>
+    <string name="long_ago_read">昔読んだ</string>
+    <string name="enable_source">ソースを有効にする</string>
+    <string name="last_used">最後の使用</string>
+    <string name="show_updated">更新情報</string>
+    <string name="more_frequently">より頻繁に</string>
+    <string name="recent_queries">最近の質問</string>
+    <string name="suggested_queries">提案されたクエリ</string>
+    <string name="sources_disabled">無効なソース</string>
+    <string name="disable_connectivity_check">接続チェックを無効にする</string>
+    <string name="tracker_debug_info">新しいチャプターログの確認</string>
+    <string name="tracker_debug_info_summary">新規チャプター向けバックグラウンドチェックに関するデバッグ情報</string>
+    <string name="_new">新しい</string>
+    <string name="image_server">優先画像サーバ</string>
+    <string name="pin">ピン</string>
+    <string name="unpin">ピンを外す</string>
+    <string name="source_pinned">ソース ピン留め</string>
 </resources>

app/src/main/res/values-nl/plurals.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <plurals name="new_chapters">
+        <item quantity="one">%1$d nieuwe hoofdstuk</item>
+        <item quantity="other">%1$d nieuwe hoofdstukken</item>
+    </plurals>
+    <plurals name="chapters">
+        <item quantity="one">%1$d hoofdstuk</item>
+        <item quantity="other">%1$d hoofdstukken</item>
+    </plurals>
+    <plurals name="minutes_ago">
+        <item quantity="one">%1$d minuut geleden</item>
+        <item quantity="other">%1$d minuten geleden</item>
+    </plurals>
+    <plurals name="hours_ago">
+        <item quantity="one">%1$d uur geleden</item>
+        <item quantity="other">%1$d uren geleden</item>
+    </plurals>
+    <plurals name="days_ago">
+        <item quantity="one">%1$d dag geleden</item>
+        <item quantity="other">%1$d dagen geleden</item>
+    </plurals>
+    <plurals name="months_ago">
+        <item quantity="one">%1$d maand geleden</item>
+        <item quantity="other">%1$d maanden geleden</item>
+    </plurals>
+    <plurals name="hours">
+        <item quantity="one">%1$d uur</item>
+        <item quantity="other">%1$d uren</item>
+    </plurals>
+    <plurals name="minutes">
+        <item quantity="one">%1$d minuut</item>
+        <item quantity="other">%1$d minuten</item>
+    </plurals>
+</resources>

app/src/main/res/values-nl/strings.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="chapters">Hoofdstukken</string>
+    <string name="new_chapters">Nieuwe hoofdstukken</string>
+    <string name="favourites">Favorieten</string>
+    <string name="history">Geschiedenis</string>
+    <string name="error_occurred">Er is een fout opgetreden</string>
+    <string name="network_error">Netwerk fout</string>
+    <string name="details">Details</string>
+    <string name="detailed_list">Gedetailleerde lijst</string>
+    <string name="grid">Rooster</string>
+    <string name="list_mode">Lijstmodus</string>
+    <string name="settings">Instellingen</string>
+    <string name="remote_sources">Mangabronnen</string>
+    <string name="loading_">Bezig met laden…</string>
+    <string name="computing_">Computeren…</string>
+    <string name="chapter_d_of_d">Hoofdstuk %1$d van %2$d</string>
+    <string name="close">Sluiten</string>
+    <string name="try_again">Probeer het opnieuw</string>
+    <string name="retry">Opnieuw proberen</string>
+    <string name="clear_history">Geschiedenis wissen</string>
+</resources>

app/src/main/res/values-pt-rBR/strings.xml

@@ -756,7 +756,7 @@
     <string name="telegram_chat_id">ID do bate-papo do telegram</string>
     <string name="open_telegram_bot">Abra o bot do Telegram</string>
     <string name="clear_database">Limpar banco de dados</string>
-    <string name="clear_database_summary">Excluir informações sobre mangás que não estão sendo utilizadas</string>
+    <string name="clear_database_summary">Excluir informações sobre mangás que não estão sendo utilizados</string>
     <string name="test_connection">Teste de conexão</string>
     <string name="backup_tg_echo">Mensagem de teste</string>
     <string name="translation">Tradução</string>
@@ -800,7 +800,7 @@
     <string name="tags_warnings">Destacar gêneros perigosos</string>
     <string name="tags_warnings_summary">Destacar gêneros que podem ser inapropriados para a maioria dos usuários</string>
     <string name="nsfw_16">+16</string>
-    <string name="exclude_nsfw_from_suggestions_summary">Mangás adultos não serão exibidas nas sugestões. Esta opção pode funcionar de forma imprecisa com algumas fontes</string>
+    <string name="exclude_nsfw_from_suggestions_summary">Mangás adultos não serão exibidos nas sugestões. Esta opção pode funcionar de forma imprecisa com algumas fontes</string>
     <string name="include_disabled_sources">Incluir fontes desabilitadas</string>
     <string name="suggestions_disabled_sources_summary">Mostrar sugestões de todas as fontes, incluindo as desabilitadas</string>
     <string name="manga_override_hint">Essas mudanças afetarão como a obra é exibida no aplicativo</string>
@@ -847,7 +847,7 @@
     <string name="invalid_token">Token inválido: %s</string>
     <string name="show_floating_control_button">Mostrar botão de controle flutuante</string>
     <string name="unavailable">Indisponível</string>
-    <string name="manga_restricted_description">Este mangá não está disponível para leitura nessa fonte. Tente pesquisar por ele em outras fontes ou abrir em um navegador para mais informação</string>
+    <string name="manga_restricted_description">Este mangá não está disponível para leitura nessa fonte. Tente pesquisar por ele em outras fontes ou abrir em um navegador para mais informações</string>
     <string name="no_chapters_in_manga">Este mangá não contém nenhum capítulo</string>
     <string name="chapters_load_failed">Falha ao carregar lista de capítulos</string>
     <string name="telegram_integration">Integração com Telegram</string>
@@ -856,4 +856,32 @@
     <string name="discord_rpc">Discord Rich Presence</string>
     <string name="discord_token_description">Insira seu Token do Discord ou clique em %s para obtê-lo usando o navegador</string>
     <string name="read_on_s">Leia em %s</string>
+    <string name="saved_filters">Filtros salvos</string>
+    <string name="pull_to_prev_chapter">Soltar para abrir o capítulo anterior</string>
+    <string name="pull_to_next_chapter">Soltar para abrir o próximo capítulo</string>
+    <string name="pull_top_no_prev">Capítulo anterior indisponível</string>
+    <string name="pull_bottom_no_next">Próximo capítulo indisponível</string>
+    <string name="two_page_scroll_sensitivity">Sensibilidade de Rolagem Dupla</string>
+    <string name="enable_pull_gesture_title">Ativar gesto de puxar</string>
+    <string name="enable_pull_gesture_summary">Puxe para trocar de capítulo em webtoons</string>
+    <string name="reader_chapter_toast">Exibir mensagem ao mudar de capítulo</string>
+    <string name="reader_chapter_toast_summary">Exibir título do capítulo ao mudar de capítulo</string>
+    <string name="rename">Renomear</string>
+    <string name="save_filter">Salvar filtro</string>
+    <string name="overwrite">Sobrescrever</string>
+    <string name="filter_overwrite_confirm">O filtro \"%s\" já existe. Deseja substituí-lo?</string>
+    <string name="storage_and_network">Armazenamento e rede</string>
+    <string name="create_or_restore_backup">Criar ou restaurar um backup</string>
+    <string name="privacy">Privacidade</string>
+    <string name="enter_name">Insira um nome</string>
+    <string name="test_parser">Testar fonte de mangás</string>
+    <string name="data_removal">Remoção de dados</string>
+    <string name="source_broken_warning">Esta fonte de mangá está quebrada. Algumas funções podem não funcionar</string>
+    <string name="frequency_every_6_hours">A cada 6 horas</string>
+    <string name="download_default_directory">Diretório padrão onde baixar os mangás</string>
+    <string name="private_app_directory_warning">Esse diretório e todo seu conteúdo será deletado se desinstalar a aplicação</string>
+    <string name="available_pattern">%1$s disponível</string>
+    <string name="hide_empty_sources">Esconder fontes vazias</string>
+    <string name="pinned_sources_only">Apenas fontes fixadas</string>
+    <string name="auto_double_foldable">Duas Páginas Automático em Tela Dobrável</string>
 </resources>

app/src/main/res/values-pt/strings.xml

@@ -858,4 +858,25 @@
     <string name="no_chapters_in_manga">Esse manga não contém capítulos</string>
     <string name="chapters_load_failed">Falha ao carregar lista de capítulos</string>
     <string name="telegram_integration">Integração Telegram</string>
+    <string name="saved_filters">Filtros salvos</string>
+    <string name="enter_name">Digite o nome</string>
+    <string name="pull_to_prev_chapter">Solte para abrir o capítulo anterior</string>
+    <string name="pull_to_next_chapter">Solte para abrir o próximo capítulo</string>
+    <string name="pull_top_no_prev">Nenhum capítulo anterior</string>
+    <string name="pull_bottom_no_next">Sem mais capítulos</string>
+    <string name="two_page_scroll_sensitivity">Sensibilidade de rolagem de página dupla</string>
+    <string name="enable_pull_gesture_title">Ativar gesto de puxar</string>
+    <string name="enable_pull_gesture_summary">Use o gesto de puxar para mudar de capítulo na webtoon</string>
+    <string name="reader_chapter_toast">Mostrar pop-up de mudança de capítulo</string>
+    <string name="reader_chapter_toast_summary">Mostrar uma mensagem pop-up com o título do capítulo quando ele for alterado</string>
+    <string name="test_parser">Teste fonte do mangá</string>
+    <string name="rename">Renomear</string>
+    <string name="save_filter">Salvar filtro</string>
+    <string name="overwrite">Sobrescrever</string>
+    <string name="filter_overwrite_confirm">Já existe um filtro chamado \"%s\". Você quer sobrescrevê-lo?</string>
+    <string name="storage_and_network">Armazenamento e internet</string>
+    <string name="create_or_restore_backup">Criar e restaurar backup</string>
+    <string name="data_removal">Remover dados</string>
+    <string name="privacy">Privacidade</string>
+    <string name="source_broken_warning">Esta fonte de mangá foi marcada como quebrada. Alguns recursos podem não funcionar</string>
 </resources>

app/src/main/res/values-ru/strings.xml

@@ -859,4 +859,27 @@
     <string name="no_chapters_in_manga">Эта манга не содержит глав</string>
     <string name="chapters_load_failed">Не удалось загрузить список глав</string>
     <string name="telegram_integration">Интеграция с Telegram</string>
+    <string name="pull_to_prev_chapter">Отпустите, чтобы открыть предыдущую главу</string>
+    <string name="pull_top_no_prev">Нет предыдущей главы</string>
+    <string name="pull_bottom_no_next">Нет следующей главы</string>
+    <string name="two_page_scroll_sensitivity">Чувствительность прокрутки двух страниц</string>
+    <string name="enable_pull_gesture_title">Включить жест перетягивания</string>
+    <string name="enable_pull_gesture_summary">Используйте жест перетаскивания для переключения глав в вебтуне</string>
+    <string name="test_parser">Проверка источников манги</string>
+    <string name="pull_to_next_chapter">Отпустите, чтобы открыть следующую главу</string>
+    <string name="reader_chapter_toast">Отображать сообщение о смене главы</string>
+    <string name="reader_chapter_toast_summary">Показывать всплывающее сообщение с названием главы при переходе между главами</string>
+    <string name="rename">Переименовать</string>
+    <string name="save_filter">Сохранить фильтр</string>
+    <string name="overwrite">Перезаписать</string>
+    <string name="filter_overwrite_confirm">Фильтр с именем \"%s\" уже существует. Перезаписать?</string>
+    <string name="storage_and_network">Хранилище и сеть</string>
+    <string name="create_or_restore_backup">Создать или восстановить резервную копию</string>
+    <string name="data_removal">Удаление данных</string>
+    <string name="privacy">Приватность</string>
+    <string name="source_broken_warning">Данный источник манги помечен как сломанный. Некоторые функции могут не работать</string>
+    <string name="download_default_directory">Каталог по умолчанию для загрузки манги</string>
+    <string name="private_app_directory_warning">Данный каталог вместе со всеми данными будет удалён при удалении приложения</string>
+    <string name="available_pattern">%1$s доступно</string>
+    <string name="enter_name">Введите имя</string>
 </resources>

app/src/main/res/values-tr/strings.xml

@@ -30,7 +30,7 @@
     <string name="download_complete">İndirildi</string>
     <string name="downloads">İndirmeler</string>
     <string name="by_name">Ad</string>
-    <string name="updated">Güncellendi</string>
+    <string name="updated">Güncellenenler</string>
     <string name="newest">En yeniler</string>
     <string name="by_rating">Puanlama</string>
     <string name="filter">Filtre</string>
@@ -207,7 +207,7 @@
     <string name="only_using_wifi">Yalnızca Wi-Fi\'de</string>
     <string name="preload_pages">Sayfaları önceden yükle</string>
     <string name="logged_in_as">%s olarak oturum açıldı</string>
-    <string name="nsfw">18+</string>
+    <string name="nsfw">+18</string>
     <string name="various_languages">Çeşitli diller</string>
     <string name="search_chapters">Bölüm bul</string>
     <string name="chapters_empty">Bu mangada bölüm yok</string>
@@ -503,7 +503,7 @@
     <string name="lock_screen_rotation">Ekran döndürmeyi kilitle</string>
     <string name="error_search_not_supported">Arama bu manga kaynağı tarafından desteklenmemektedir</string>
     <string name="manual">Manuel</string>
-    <string name="disable_nsfw_summary">Eğer mümkünse yetişkin içerik ve NSFW kaynaklarını arama listesinden kaldır</string>
+    <string name="disable_nsfw_summary">NSFW kaynakları devre dışı bırak ve yetişkinlere yönelik mangaları listeden gizle</string>
     <string name="available_d">Mevcut:%1$d</string>
     <string name="state">Durum</string>
     <string name="error_filter_states_genre_not_supported">Hem türlere hem de duruma göre filtreleme bu kaynak tarafından desteklenmiyor</string>
@@ -867,4 +867,24 @@
     <string name="enable_pull_gesture_title">Çekme hareketini etkinleştir</string>
     <string name="enable_pull_gesture_summary">Webtoon modunda bölüm değiştirmek için çekme hareketi kullan</string>
     <string name="two_page_scroll_sensitivity">İki Sayfa Kaydırma Hassaslığı</string>
+    <string name="saved_filters">Kaydedilen filtreler</string>
+    <string name="enter_name">Ad girin</string>
+    <string name="reader_chapter_toast">Bölüm değişikliği açılır penceresini göster</string>
+    <string name="reader_chapter_toast_summary">Değiştirildiğinde bölüm başlığını içeren bir açılır pencere mesajı göster</string>
+    <string name="rename">Yeniden adlandır</string>
+    <string name="save_filter">Filtreyi kaydet</string>
+    <string name="overwrite">Üzerine yaz</string>
+    <string name="filter_overwrite_confirm">\"%s\" adında bir filtre zaten var. Üzerine yazmak istiyor musunuz?</string>
+    <string name="storage_and_network">Depolama ve ağ</string>
+    <string name="create_or_restore_backup">Yedekleme oluştur veya geri yükle</string>
+    <string name="data_removal">Verilerin silinmesi</string>
+    <string name="privacy">Gizlilik</string>
+    <string name="source_broken_warning">Bu manga kaynağı bozuk olarak işaretlendi. Bazı özellikler çalışmayabilir</string>
+    <string name="download_default_directory">Mangaların indirileceği varsayılan dizin</string>
+    <string name="private_app_directory_warning">Uygulamayı kaldırırsanız, bu dizin ve içindeki tüm veriler silinecektir</string>
+    <string name="available_pattern">%1$s var</string>
+    <string name="frequency_every_6_hours">6 saatte bir</string>
+    <string name="pinned_sources_only">Yalnızca sabitlenen kaynaklar</string>
+    <string name="hide_empty_sources">Boş kaynakları gizle</string>
+    <string name="auto_double_foldable">Otomatik İki Sayfa Katlanabilir</string>
 </resources>

app/src/main/res/values-uk/strings.xml

@@ -832,9 +832,9 @@
     <string name="error_disclaimer_report">Ви можете надіслати звіт про помилку розробникам. Це допоможе нам виправити проблему.</string>
     <string name="error_disclaimer_app_outdated">Схоже, що ваша версія Kotatsu застаріла. Будь ласка, установіть останню версію, щоб отримати всі доступні виправлення.</string>
     <string name="error_disclaimer_manga">Спробуйте відкрити манґу в браузері, щоб переконатися, що вона доступна джерелом.</string>
-    <string name="handle_links_summary">Обробка посилань на мангу з зовнішніх програм (наприклад, веб-браузера). Можливо, вам також доведеться ввімкнути цю функцію вручну в системних налаштуваннях програми.</string>
+    <string name="handle_links_summary">Обробка посилань на мангу з зовнішніх програм (наприклад, веб-браузера). Можливо, вам також доведеться ввімкнути цю функцію вручну в системних налаштуваннях програми</string>
-    <string name="disable_captcha_notifications_summary">Ви не будете отримувати повідомлення про вирішення CAPTCHA для цього джерела, але це може призвести до порушення фонових операцій (перевірка нових розділів, отримання рекомендацій тощо).</string>
+    <string name="disable_captcha_notifications_summary">Ви не будете отримувати повідомлення про вирішення CAPTCHA для цього джерела, але це може призвести до порушення фонових операцій (перевірка нових розділів, отримання рекомендацій тощо)</string>
-    <string name="clear_browser_data_summary">Очистити дані браузера, такі як кеш і файли cookie. Попередження: авторизація в джерелах манги може стати недійсною.</string>
+    <string name="clear_browser_data_summary">Очистити дані браузера, такі як кеш і файли cookie. Попередження: авторизація в джерелах манги може стати недійсною</string>
     <string name="local_storage_cleanup">Очищення локального сховища</string>
     <string name="packup_creation_failed">Не вдалося створити резервну копію</string>
     <string name="main_screen">Головний екран</string>
@@ -867,4 +867,24 @@
     <string name="enable_pull_gesture_title">Увімкнути жест потягування</string>
     <string name="enable_pull_gesture_summary">Використовуйте жест потягування для перемикання розділів у вебтуні</string>
     <string name="two_page_scroll_sensitivity">Чутливість прокручування на дві сторінки</string>
+    <string name="saved_filters">Збережені фільтри</string>
+    <string name="enter_name">Введіть ім\'я</string>
+    <string name="reader_chapter_toast">Показати спливаюче вікно зміни розділу</string>
+    <string name="reader_chapter_toast_summary">Показувати спливаюче повідомлення з назвою розділу, коли її змінено</string>
+    <string name="rename">Перейменувати</string>
+    <string name="save_filter">Зберегти фільтр</string>
+    <string name="overwrite">Перезаписати</string>
+    <string name="filter_overwrite_confirm">Фільтр з назвою \"%s\" вже існує. Перезаписати його?</string>
+    <string name="storage_and_network">Зберігання та мережа</string>
+    <string name="create_or_restore_backup">Створення або відновлення резервної копії</string>
+    <string name="data_removal">Вилучення даних</string>
+    <string name="privacy">Конфіденційність</string>
+    <string name="source_broken_warning">Це джерело манги позначено як непрацююче. Деякі функції можуть не працювати</string>
+    <string name="frequency_every_6_hours">Кожні 6 годин</string>
+    <string name="download_default_directory">Каталог за замовчуванням для завантаження манги</string>
+    <string name="private_app_directory_warning">Цей каталог з усіма даними буде видалено, якщо ви видалите програму</string>
+    <string name="available_pattern">Доступно %1$s</string>
+    <string name="auto_double_foldable">Автоматичне двосторінкове розміщення на складному</string>
+    <string name="pinned_sources_only">Тільки закріплені джерела</string>
+    <string name="hide_empty_sources">Приховати порожні джерела</string>
 </resources>

app/src/main/res/values-vi/strings.xml

@@ -864,4 +864,22 @@
     <string name="pull_bottom_no_next">Không còn chương nào để xem tiếp</string>
     <string name="enable_pull_gesture_title">Bật cử chỉ kéo - thả</string>
     <string name="enable_pull_gesture_summary">Sử dụng cử chỉ tay kéo - thả để chuyển chương trong chế độ đọc Webtoon</string>
+    <string name="saved_filters">Lưu bộ lọc tìm kiếm</string>
+    <string name="enter_name">Hãy điền tên</string>
+    <string name="two_page_scroll_sensitivity">Độ nhạy khi cuộn hai trang</string>
+    <string name="reader_chapter_toast">Hiện thông báo chuyển chương</string>
+    <string name="reader_chapter_toast_summary">Hiển thị một bong bóng nổi nho nhỏ ở phía dưới màn hình cùng với tên của chương truyện khi bạn đọc sang một chương truyện mới</string>
+    <string name="rename">Đặt tên</string>
+    <string name="save_filter">Lưu bộ lọc</string>
+    <string name="overwrite">Đè lên</string>
+    <string name="filter_overwrite_confirm">Một bộ lộc có tên là \"%s\" đã tồn tại trước đó. Bạn có muốn ghi đè nó lên không?</string>
+    <string name="storage_and_network">Lưu trữ và mạng</string>
+    <string name="create_or_restore_backup">Tạo hoặc khôi phục từ một bản sao lưu</string>
+    <string name="data_removal">Xoá dữ liệu</string>
+    <string name="privacy">Quyền riêng tư</string>
+    <string name="source_broken_warning">Nguồn đọc này đã được gắn là \"Không còn sử dụng được\". Một vài tính năng có thể sẽ không hoạt động</string>
+    <string name="frequency_every_6_hours">6 tiếng một lần</string>
+    <string name="download_default_directory">Đường dẫn mặc định để tải truyện về thiết bị</string>
+    <string name="private_app_directory_warning">Đường dẫn này với tất cả dữ liệu của ứng dụng sẽ bị xóa nếu bạn gỡ ứng dụng Kotatsu</string>
+    <string name="available_pattern">Hiện có sẵn %1$s</string>
 </resources>

app/src/main/res/values-zh-rCN/strings.xml

@@ -866,4 +866,5 @@
     <string name="pull_bottom_no_next">到底了</string>
     <string name="enable_pull_gesture_title">启用推拉手势</string>
     <string name="enable_pull_gesture_summary">条漫模式下使用推拉手势切换章节</string>
+    <string name="auto_double_foldable">折叠设备自动双页</string>
 </resources>

app/src/main/res/values-zh-rTW/strings.xml

@@ -661,4 +661,5 @@
     <string name="download_new_chapters">下載新的漫畫章節</string>
     <string name="enable_all_sources">啟用所有漫畫來源</string>
     <string name="all_sources_enabled">所有漫畫來源已啟用</string>
+    <string name="auto_double_foldable">摺疊設備自動雙頁</string>
 </resources>

app/src/main/res/values/arrays.xml

@@ -75,6 +75,7 @@
 		<item>@string/advanced</item>
 	</string-array>
 	<string-array name="backup_frequency" translatable="false">
+		<item>@string/frequency_every_6_hours</item>
 		<item>@string/frequency_every_day</item>
 		<item>@string/frequency_every_2_days</item>
 		<item>@string/frequency_once_per_week</item>

app/src/main/res/values/constants.xml

@@ -56,6 +56,7 @@
 		<item>SOCKS</item>
 	</string-array>
 	<string-array name="values_backup_frequency" translatable="false">
+		<item>0.25</item>
 		<item>1</item>
 		<item>2</item>
 		<item>7</item>

app/src/main/res/values/strings.xml

@@ -210,6 +210,8 @@
     <string name="disabled">Disabled</string>
     <string name="reset_filter">Reset filter</string>
     <string name="enter_name">Enter name</string>
+    <string name="pinned_sources_only">Pinned sources only</string>
+    <string name="hide_empty_sources">Hide empty sources</string>
     <string name="onboard_text">Select languages which you want to read manga. You can change it later in settings.</string>
     <string name="never">Never</string>
     <string name="only_using_wifi">Only on Wi-Fi</string>
@@ -498,6 +500,7 @@
     <string name="online_variant">Online variant</string>
     <string name="periodic_backups">Periodic backups</string>
     <string name="backup_frequency">Backup creation frequency</string>
+    <string name="frequency_every_6_hours">Every 6 hours</string>
     <string name="frequency_every_day">Every day</string>
     <string name="frequency_every_2_days">Every 2 days</string>
     <string name="frequency_once_per_week">Once per week</string>
@@ -578,6 +581,7 @@
     <string name="none">None</string>
     <string name="config_reset_confirm">Reset settings to default values? This action cannot be undone.</string>
     <string name="use_two_pages_landscape">Use two pages layout on landscape orientation (beta)</string>
+    <string name="auto_double_foldable">Auto Two-Page On Foldable</string>
     <string name="two_page_scroll_sensitivity">Two-Page Scroll Sensitivity</string>
     <string name="default_webtoon_zoom_out">Default webtoon zoom out</string>
     <string name="fullscreen_mode">Fullscreen mode</string>
@@ -900,4 +904,7 @@
     <string name="data_removal">Data removal</string>
     <string name="privacy">Privacy</string>
     <string name="source_broken_warning">This manga source has been marked as broken. Some features may not work</string>
+    <string name="download_default_directory">Default directory for downloading manga</string>
+    <string name="private_app_directory_warning">This directory with all data will be deleted if you uninstall the application</string>
+    <string name="available_pattern">%1$s available</string>
 </resources>

app/src/main/res/xml/pref_reader.xml

@@ -87,6 +87,12 @@
 		android:title="@string/pages_animation"
 		app:useSimpleSummaryProvider="true" />
 
+    <SwitchPreferenceCompat
+        android:defaultValue="false"
+        android:key="webtoon_pull_gesture"
+        android:summary="@string/enable_pull_gesture_summary"
+        android:title="@string/enable_pull_gesture_title" />
+
 	<SwitchPreferenceCompat
 		android:defaultValue="false"
 		android:key="enhanced_colors"

gradle/libs.versions.toml

@@ -35,7 +35,7 @@ material = "1.14.0-alpha05"
 moshi = "1.15.2"
 okhttp = "5.2.1"
 okio = "3.16.1"
-parsers = "df1cab3f9d"
+parsers = "4d1e521aef"
 preference = "1.2.1"
 recyclerview = "1.4.0"
 room = "2.7.2"
@@ -49,6 +49,7 @@ viewpager2 = "1.1.0"
 webkit = "1.14.0"
 workRuntime = "2.10.5"
 workinspector = "1.2"
+window = "1.3.0"
 
 [libraries]
 acra-dialog = { module = "ch.acra:acra-dialog", version.ref = "acra" }
@@ -115,6 +116,7 @@ okhttp-tls = { module = "com.squareup.okhttp3:okhttp-tls", version.ref = "okhttp
 okio = { module = "com.squareup.okio:okio", version.ref = "okio" }
 ssiv = { module = "com.github.KotatsuApp:subsampling-scale-image-view", version.ref = "ssiv" }
 workinspector = { module = "com.github.Koitharu:WorkInspector", version.ref = "workinspector" }
+androidx-window = { module = "androidx.window:window", version.ref = "window" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "gradle" }