Fix settings title

Currently translated at 100.0% (323 of 323 strings)

Co-authored-by: lowak <lowak@pm.me>
Translate-URL: https://hosted.weblate.org/projects/kotatsu/strings/sv/
Translation: Kotatsu/Strings

.editorconfig

@@ -15,5 +15,6 @@ disabled_rules=no-wildcard-imports,no-unused-imports
 ij_continuation_indent_size = 4
 
 [{*.kt,*.kts}]
+ij_kotlin_allow_trailing_comma_on_call_site = true
 ij_kotlin_allow_trailing_comma = true
 ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL

.github/ISSUE_TEMPLATE/config.yml

@@ -2,4 +2,4 @@ blank_issues_enabled: false
 contact_links:
     - name: ⚠️ Source issue
       url: https://github.com/KotatsuApp/kotatsu-parsers/issues/new
-      about: Issues and requests for sources should be opened in the kotatsu-parsers repository instead
+      about: If you have troubles with a manga parser or want to propose new manga source, please open an issue in the kotatsu-parsers repository instead

.github/ISSUE_TEMPLATE/report_bug.yml

@@ -0,0 +1,64 @@
+name: 🐞 Bug report
+description: Report a bug in Kotatsu
+labels: [bug]
+body:
+
+    - type: textarea
+      id: summary
+      attributes:
+          label: Brief summary
+          description: Please describe, what went wrong
+      validations:
+          required: true
+
+    - type: textarea
+      id: reproduce-steps
+      attributes:
+          label: Steps to reproduce
+          description: Please provide a way to reproduce this issue. Screenshots or videos can be very helpful
+          placeholder: |
+              Example:
+                1. First step
+                2. Second step
+                3. Issue here
+      validations:
+          required: false
+
+
+    - type: input
+      id: kotatsu-version
+      attributes:
+          label: Kotatsu version
+          description: You can find your Kotatsu version in **Settings → About**.
+          placeholder: |
+              Example: "3.3"
+      validations:
+          required: true
+
+    - type: input
+      id: android-version
+      attributes:
+          label: Android version
+          description: You can find this somewhere in your Android settings.
+          placeholder: |
+              Example: "12.0"
+      validations:
+          required: true
+
+    - type: input
+      id: device
+      attributes:
+          label: Device
+          description: List your device and model.
+          placeholder: |
+              Example: "LG Nexus 5X"
+      validations:
+          required: false
+
+    - type: checkboxes
+      id: acknowledgements
+      attributes:
+          label: Acknowledgements
+          options:
+              - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open issue.
+                required: true

.github/ISSUE_TEMPLATE/report_issue.yml

@@ -1,91 +0,0 @@
-name: 🐞 Issue report
-description: Report an issue in Kotatsu
-labels: [bug]
-body:
-
-    - type: textarea
-      id: reproduce-steps
-      attributes:
-          label: Steps to reproduce
-          description: Provide an example of the issue.
-          placeholder: |
-              Example:
-                1. First step
-                2. Second step
-                3. Issue here
-      validations:
-          required: true
-
-    - type: textarea
-      id: expected-behavior
-      attributes:
-          label: Expected behavior
-          description: Explain what you should expect to happen.
-          placeholder: |
-              Example:
-                "This should happen..."
-      validations:
-          required: true
-
-    - type: textarea
-      id: actual-behavior
-      attributes:
-          label: Actual behavior
-          description: Explain what actually happens.
-          placeholder: |
-              Example:
-                "This happened instead..."
-      validations:
-          required: true
-
-    - type: input
-      id: kotatsu-version
-      attributes:
-          label: Kotatsu version
-          description: You can find your Kotatsu version in **Settings → About**.
-          placeholder: |
-              Example: "3.3"
-      validations:
-          required: true
-
-    - type: input
-      id: android-version
-      attributes:
-          label: Android version
-          description: You can find this somewhere in your Android settings.
-          placeholder: |
-              Example: "Android 12"
-      validations:
-          required: true
-
-    - type: input
-      id: device
-      attributes:
-          label: Device
-          description: List your device and model.
-          placeholder: |
-              Example: "LG Nexus 5X"
-      validations:
-          required: true
-
-    - type: textarea
-      id: other-details
-      attributes:
-          label: Other details
-          placeholder: |
-              Additional details and attachments.
-
-    - type: checkboxes
-      id: acknowledgements
-      attributes:
-          label: Acknowledgements
-          description: Read this carefully, we will close and ignore your issue if you skimmed through this.
-          options:
-              - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open issue.
-                required: true
-              - label: I have written a short but informative title.
-                required: true
-              - label: If this is an issue with a source, I should be opening an issue in the [parsers repository](https://github.com/KotatsuApp/kotatsu-parsers/issues/new).
-                required: true
-              - label: I will fill out all of the requested information in this form.
-                required: true

.github/ISSUE_TEMPLATE/request_feature.yml

@@ -1,5 +1,5 @@
 name: ⭐ Feature request
-description: Suggest a feature to improve Kotatsu
+description: Suggest a new idea how to improve Kotatsu
 labels: [feature request]
 body:
 
@@ -14,23 +14,6 @@ body:
       validations:
           required: true
 
-    - type: textarea
-      id: other-details
-      attributes:
-          label: Other details
-          placeholder: |
-              Additional details and attachments.
-
-    - type: input
-      id: kotatsu-version
-      attributes:
-          label: Kotatsu version
-          description: You can find your Kotatsu version in **Settings → About**.
-          placeholder: |
-              Example: "3.3"
-      validations:
-          required: true
-
     - type: checkboxes
       id: acknowledgements
       attributes:
@@ -38,10 +21,4 @@ body:
           description: Read this carefully, we will close and ignore your issue if you skimmed through this.
           options:
               - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open issue.
-                required: true
-              - label: I have written a short but informative title.
-                required: true
-              - label: If this is an issue with a source, I should be opening an issue in the [parsers repository](https://github.com/KotatsuApp/kotatsu-parsers/issues/new).
-                required: true
-              - label: I will fill out all of the requested information in this form.
                 required: true

README.md

@@ -10,9 +10,9 @@ Kotatsu is a free and open source manga reader for Android.
 alt="Get it on F-Droid"
 height="80">](https://f-droid.org/packages/org.koitharu.kotatsu)
 
-Download APK from GitHub Releases:
+Download APK directly from GitHub:
 
-- [Latest release](https://github.com/KotatsuApp/Kotatsu/releases/latest)
+- **[Latest release](https://github.com/KotatsuApp/Kotatsu/releases/latest)**
 
 ### Main Features
 
@@ -24,8 +24,8 @@ Download APK from GitHub Releases:
 * Tablet-optimized material design UI
 * Standard and Webtoon-optimized reader
 * Notifications about new chapters with updates feed
-* Available in multiple languages
+* Shikimori integration (manga tracking)
-* Password protect access to the app
+* Password/fingerprint protect access to the app
 
 ### Screenshots
 
@@ -38,23 +38,20 @@ Download APK from GitHub Releases:
 
 ### Localization
 
-<a href="https://hosted.weblate.org/engage/kotatsu/">
+[<img src="https://hosted.weblate.org/widgets/kotatsu/-/287x66-white.png" alt="Translation status">](https://hosted.weblate.org/engage/kotatsu/)
-<img src="https://hosted.weblate.org/widgets/kotatsu/-/287x66-white.png" alt="Translation status" />
-</a>
 
 Kotatsu is localized in a number of different languages, if you would like to help improve these or add new languages,
-please head over to the Weblate <a href="https://hosted.weblate.org/engage/kotatsu/">project page</a>
+please head over to the [Weblate project page](https://hosted.weblate.org/engage/kotatsu/)
 
 ### License
 
 [![GNU GPLv3 Image](https://www.gnu.org/graphics/gplv3-127x51.png)](http://www.gnu.org/licenses/gpl-3.0.en.html)
 
-Kotatsu is Free Software: You can use, study share and improve it at your
+You may copy, distribute and modify the software as long as you track changes/dates in source files. Any modifications
-will. Specifically you can redistribute and/or modify it under the terms of the
+to or software including (via compiler) GPL-licensed code must also be made available under the GPL along with build &
-[GNU General Public License](https://www.gnu.org/licenses/gpl.html) as
+install instructions.
-published by the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
 
-### Disclaimer
+### DMCA disclaimer
 
-The developers of this application does not have any affiliation with the content providers available.
+The developers of this application does not have any affiliation with the content available in the app.
+It is collecting from the sources freely available through any web browser.

app/build.gradle

@@ -14,8 +14,8 @@ android {
 		applicationId 'org.koitharu.kotatsu'
 		minSdkVersion 21
 		targetSdkVersion 32
-		versionCode 412
+		versionCode 421
-		versionName '3.4'
+		versionName '3.4.9'
 		generatedDensities = []
 		testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
@@ -64,8 +64,11 @@ android {
 		disable 'MissingTranslation', 'PrivateResource', 'NotifyDataSetChanged'
 	}
 	testOptions {
-		unitTests.includeAndroidResources = true
+		unitTests.includeAndroidResources true
-		unitTests.returnDefaultValues = false
+		unitTests.returnDefaultValues false
+		kotlinOptions {
+			freeCompilerArgs += ['-opt-in=org.koitharu.kotatsu.parsers.InternalParsersApi']
+		}
 	}
 }
 afterEvaluate {
@@ -76,20 +79,19 @@ afterEvaluate {
 	}
 }
 dependencies {
-	implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
+	implementation('com.github.KotatsuApp:kotatsu-parsers:8709c3dd0c') {
-	implementation('com.github.nv95:kotatsu-parsers:da3b0ae0cf') {
 		exclude group: 'org.json', module: 'json'
 	}
 
-	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.3'
+	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
 
 	implementation 'androidx.core:core-ktx:1.8.0'
-	implementation 'androidx.activity:activity-ktx:1.5.0'
+	implementation 'androidx.activity:activity-ktx:1.5.1'
-	implementation 'androidx.fragment:fragment-ktx:1.5.0'
+	implementation 'androidx.fragment:fragment-ktx:1.5.1'
-	implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.0'
+	implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1'
-	implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.5.0'
+	implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.5.1'
-	implementation 'androidx.lifecycle:lifecycle-service:2.5.0'
+	implementation 'androidx.lifecycle:lifecycle-service:2.5.1'
-	implementation 'androidx.lifecycle:lifecycle-process:2.5.0'
+	implementation 'androidx.lifecycle:lifecycle-process:2.5.1'
 	implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
 	implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
 	implementation 'androidx.recyclerview:recyclerview:1.2.1'
@@ -97,13 +99,13 @@ dependencies {
 	implementation 'androidx.preference:preference-ktx:1.2.0'
 	implementation 'androidx.work:work-runtime-ktx:2.7.1'
 	implementation 'androidx.biometric:biometric-ktx:1.2.0-alpha04'
-	implementation 'com.google.android.material:material:1.7.0-alpha02'
+	implementation 'com.google.android.material:material:1.7.0-alpha03'
 	//noinspection LifecycleAnnotationProcessorWithJava8
-	kapt 'androidx.lifecycle:lifecycle-compiler:2.5.0'
+	kapt 'androidx.lifecycle:lifecycle-compiler:2.5.1'
 
-	implementation 'androidx.room:room-runtime:2.4.2'
+	implementation 'androidx.room:room-runtime:2.4.3'
-	implementation 'androidx.room:room-ktx:2.4.2'
+	implementation 'androidx.room:room-ktx:2.4.3'
-	kapt 'androidx.room:room-compiler:2.4.2'
+	kapt 'androidx.room:room-compiler:2.4.3'
 
 	implementation 'com.squareup.okhttp3:okhttp:4.10.0'
 	implementation 'com.squareup.okhttp3:okhttp-dnsoverhttps:4.9.3'
@@ -117,24 +119,24 @@ dependencies {
 	implementation 'com.davemorrissey.labs:subsampling-scale-image-view-androidx:3.10.0'
 	implementation 'com.github.solkin:disk-lru-cache:1.4'
 
-	implementation 'ch.acra:acra-mail:5.9.3'
+	implementation 'ch.acra:acra-mail:5.9.5'
-	implementation 'ch.acra:acra-dialog:5.9.3'
+	implementation 'ch.acra:acra-dialog:5.9.5'
 
-	debugImplementation 'org.jsoup:jsoup:1.15.1'
 	debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.9.1'
 
 	testImplementation 'junit:junit:4.13.2'
-	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.3'
+	testImplementation 'org.json:json:20220320'
+	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
 
 	androidTestImplementation 'androidx.test:runner:1.4.0'
 	androidTestImplementation 'androidx.test:rules:1.4.0'
 	androidTestImplementation 'androidx.test:core-ktx:1.4.0'
 	androidTestImplementation 'androidx.test.ext:junit-ktx:1.1.3'
 
-	androidTestImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.3'
+	androidTestImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
 	androidTestImplementation 'io.insert-koin:koin-test:3.2.0'
 	androidTestImplementation 'io.insert-koin:koin-test-junit4:3.2.0'
 
-	androidTestImplementation 'androidx.room:room-testing:2.4.2'
+	androidTestImplementation 'androidx.room:room-testing:2.4.3'
 	androidTestImplementation 'com.squareup.moshi:moshi-kotlin:1.13.0'
 }

app/src/androidTest/assets/categories/simple.json

@@ -0,0 +1,8 @@
+{
+	"id": 4,
+	"title": "Read later",
+	"sortKey": 1,
+	"order": "NEWEST",
+	"createdAt": 1335906000000,
+	"isTrackingEnabled": true
+}

app/src/androidTest/assets/manga/header.json

@@ -0,0 +1,35 @@
+{
+	"id": -2096681732556647985,
+	"title": "Странствия Эманон",
+	"url": "/stranstviia_emanon",
+	"publicUrl": "https://readmanga.io/stranstviia_emanon",
+	"rating": 0.9400894,
+	"isNsfw": true,
+	"coverUrl": "https://staticrm.rmr.rocks/uploads/pics/01/12/559_p.jpg",
+	"tags": [
+		{
+			"title": "Сверхъестественное",
+			"key": "supernatural",
+			"source": "READMANGA_RU"
+		},
+		{
+			"title": "Сэйнэн",
+			"key": "seinen",
+			"source": "READMANGA_RU"
+		},
+		{
+			"title": "Повседневность",
+			"key": "slice_of_life",
+			"source": "READMANGA_RU"
+		},
+		{
+			"title": "Приключения",
+			"key": "adventure",
+			"source": "READMANGA_RU"
+		}
+	],
+	"state": "FINISHED",
+	"largeCoverUrl": "https://staticrm.rmr.rocks/uploads/pics/01/12/559_o.jpg",
+	"description": null,
+	"source": "READMANGA_RU"
+}

app/src/androidTest/java/org/koitharu/kotatsu/Instrumentation.kt

@@ -0,0 +1,9 @@
+package org.koitharu.kotatsu
+
+import android.app.Instrumentation
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+suspend fun Instrumentation.awaitForIdle() = suspendCoroutine<Unit> { cont ->
+	waitForIdle { cont.resume(Unit) }
+}

app/src/androidTest/java/org/koitharu/kotatsu/SampleData.kt

@@ -0,0 +1,54 @@
+package org.koitharu.kotatsu
+
+import androidx.test.platform.app.InstrumentationRegistry
+import com.squareup.moshi.*
+import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
+import okio.buffer
+import okio.source
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.parsers.model.Manga
+import java.util.*
+import kotlin.reflect.KClass
+
+object SampleData {
+
+	private val moshi = Moshi.Builder()
+		.add(DateAdapter())
+		.add(KotlinJsonAdapterFactory())
+		.build()
+
+	val manga: Manga = loadAsset("manga/header.json", Manga::class)
+
+	val mangaDetails: Manga = loadAsset("manga/full.json", Manga::class)
+
+	val tag = mangaDetails.tags.elementAt(2)
+
+	val chapter = checkNotNull(mangaDetails.chapters)[2]
+
+	val favouriteCategory: FavouriteCategory = loadAsset("categories/simple.json", FavouriteCategory::class)
+
+	fun <T : Any> loadAsset(name: String, cls: KClass<T>): T {
+		val assets = InstrumentationRegistry.getInstrumentation().context.assets
+		return assets.open(name).use {
+			moshi.adapter(cls.java).fromJson(it.source().buffer())
+		} ?: throw RuntimeException("Cannot read asset from json \"$name\"")
+	}
+
+	private class DateAdapter : JsonAdapter<Date>() {
+
+		@FromJson
+		override fun fromJson(reader: JsonReader): Date? {
+			val ms = reader.nextLong()
+			return if (ms == 0L) {
+				null
+			} else {
+				Date(ms)
+			}
+		}
+
+		@ToJson
+		override fun toJson(writer: JsonWriter, value: Date?) {
+			writer.value(value?.time ?: 0L)
+		}
+	}
+}

app/src/androidTest/java/org/koitharu/kotatsu/core/db/MangaDatabaseTest.kt

@@ -3,11 +3,10 @@ package org.koitharu.kotatsu.core.db
 import androidx.room.testing.MigrationTestHelper
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
-import java.io.IOException
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.koitharu.kotatsu.core.db.migrations.*
+import kotlin.test.assertEquals
 
 @RunWith(AndroidJUnit4::class)
 class MangaDatabaseTest {
@@ -18,38 +17,41 @@ class MangaDatabaseTest {
 		MangaDatabase::class.java,
 	)
 
+	private val migrations = databaseMigrations
+
 	@Test
-	@Throws(IOException::class)
+	fun versions() {
-	fun migrateAll() {
+		assertEquals(1, migrations.first().startVersion)
-		helper.createDatabase(TEST_DB, 1).apply {
+		repeat(migrations.size) { i ->
-			// TODO execSQL("")
+			assertEquals(i + 1, migrations[i].startVersion)
-			close()
+			assertEquals(i + 2, migrations[i].endVersion)
 		}
+		assertEquals(DATABASE_VERSION, migrations.last().endVersion)
+	}
+
+	@Test
+	fun migrateAll() {
+		helper.createDatabase(TEST_DB, 1).close()
 		for (migration in migrations) {
 			helper.runMigrationsAndValidate(
 				TEST_DB,
 				migration.endVersion,
 				true,
 				migration
-			)
+			).close()
+		}
+	}
+
+	@Test
+	fun prePopulate() {
+		val resources = InstrumentationRegistry.getInstrumentation().targetContext.resources
+		helper.createDatabase(TEST_DB, DATABASE_VERSION).use {
+			DatabasePrePopulateCallback(resources).onCreate(it)
 		}
 	}
 
 	private companion object {
 
 		const val TEST_DB = "test-db"
-
-		val migrations = arrayOf(
-			Migration1To2(),
-			Migration2To3(),
-			Migration3To4(),
-			Migration4To5(),
-			Migration5To6(),
-			Migration6To7(),
-			Migration7To8(),
-			Migration8To9(),
-			Migration9To10(),
-			Migration10To11(),
-		)
 	}
-}
+}

app/src/androidTest/java/org/koitharu/kotatsu/core/os/ShortcutsUpdaterTest.kt

@@ -0,0 +1,65 @@
+package org.koitharu.kotatsu.core.os
+
+import android.content.pm.ShortcutInfo
+import android.content.pm.ShortcutManager
+import android.os.Build
+import androidx.core.content.getSystemService
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import kotlinx.coroutines.test.runTest
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.koin.test.KoinTest
+import org.koin.test.inject
+import org.koitharu.kotatsu.SampleData
+import org.koitharu.kotatsu.awaitForIdle
+import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.history.domain.HistoryRepository
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+@RunWith(AndroidJUnit4::class)
+class ShortcutsUpdaterTest : KoinTest {
+
+	private val historyRepository by inject<HistoryRepository>()
+	private val shortcutsUpdater by inject<ShortcutsUpdater>()
+	private val database by inject<MangaDatabase>()
+
+	@Before
+	fun setUp() {
+		database.clearAllTables()
+	}
+
+	@Test
+	fun testUpdateShortcuts() = runTest {
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N_MR1) {
+			return@runTest
+		}
+		awaitUpdate()
+		assertTrue(getShortcuts().isEmpty())
+		historyRepository.addOrUpdate(
+			manga = SampleData.manga,
+			chapterId = SampleData.chapter.id,
+			page = 4,
+			scroll = 2,
+			percent = 0.3f
+		)
+		awaitUpdate()
+
+		val shortcuts = getShortcuts()
+		assertEquals(1, shortcuts.size)
+	}
+
+	private fun getShortcuts(): List<ShortcutInfo> {
+		val context = InstrumentationRegistry.getInstrumentation().targetContext
+		val manager = checkNotNull(context.getSystemService<ShortcutManager>())
+		return manager.dynamicShortcuts.filterNot { it.id == "com.squareup.leakcanary.dynamic_shortcut" }
+	}
+
+	private suspend fun awaitUpdate() {
+		val instrumentation = InstrumentationRegistry.getInstrumentation()
+		instrumentation.awaitForIdle()
+		shortcutsUpdater.await()
+	}
+}

app/src/androidTest/java/org/koitharu/kotatsu/settings/backup/AppBackupAgentTest.kt

@@ -0,0 +1,67 @@
+package org.koitharu.kotatsu.settings.backup
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlinx.coroutines.test.runTest
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.koin.test.KoinTest
+import org.koin.test.get
+import org.koin.test.inject
+import org.koitharu.kotatsu.SampleData
+import org.koitharu.kotatsu.core.backup.BackupRepository
+import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.db.entity.toMangaTags
+import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
+import org.koitharu.kotatsu.history.domain.HistoryRepository
+import kotlin.test.*
+
+@RunWith(AndroidJUnit4::class)
+class AppBackupAgentTest : KoinTest {
+
+	private val historyRepository by inject<HistoryRepository>()
+	private val favouritesRepository by inject<FavouritesRepository>()
+	private val backupRepository by inject<BackupRepository>()
+	private val database by inject<MangaDatabase>()
+
+	@Before
+	fun setUp() {
+		database.clearAllTables()
+	}
+
+	@Test
+	fun testBackupRestore() = runTest {
+		val category = favouritesRepository.createCategory(
+			title = SampleData.favouriteCategory.title,
+			sortOrder = SampleData.favouriteCategory.order,
+			isTrackerEnabled = SampleData.favouriteCategory.isTrackingEnabled,
+		)
+		favouritesRepository.addToCategory(categoryId = category.id, mangas = listOf(SampleData.manga))
+		historyRepository.addOrUpdate(
+			manga = SampleData.mangaDetails,
+			chapterId = SampleData.mangaDetails.chapters!![2].id,
+			page = 3,
+			scroll = 40,
+			percent = 0.2f,
+		)
+		val history = checkNotNull(historyRepository.getOne(SampleData.manga))
+
+		val agent = AppBackupAgent()
+		val backup = agent.createBackupFile(get(), backupRepository)
+
+		database.clearAllTables()
+		assertTrue(favouritesRepository.getAllManga().isEmpty())
+		assertNull(historyRepository.getLastOrNull())
+
+		backup.inputStream().use {
+			agent.restoreBackupFile(it.fd, backup.length(), backupRepository)
+		}
+
+		assertEquals(category, favouritesRepository.getCategory(category.id))
+		assertEquals(history, historyRepository.getOne(SampleData.manga))
+		assertContentEquals(listOf(SampleData.manga), favouritesRepository.getManga(category.id))
+
+		val allTags = database.tagsDao.findTags(SampleData.tag.source.name).toMangaTags()
+		assertContains(allTags, SampleData.tag)
+	}
+}

app/src/androidTest/java/org/koitharu/kotatsu/tracker/domain/TrackerTest.kt

@@ -1,29 +1,21 @@
 package org.koitharu.kotatsu.tracker.domain
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import com.squareup.moshi.Moshi
-import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
 import kotlinx.coroutines.test.runTest
-import okio.buffer
-import okio.source
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.koin.test.KoinTest
 import org.koin.test.inject
+import org.koitharu.kotatsu.SampleData
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
-import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.parsers.model.Manga
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 @RunWith(AndroidJUnit4::class)
 class TrackerTest : KoinTest {
 
-	private val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
-	private val mangaAdapter = moshi.adapter(Manga::class.java)
-	private val historyRegistry by inject<HistoryRepository>()
 	private val repository by inject<TrackingRepository>()
 	private val dataRepository by inject<MangaDataRepository>()
 	private val tracker by inject<Tracker>()
@@ -166,22 +158,25 @@ class TrackerTest : KoinTest {
 		}
 		assertEquals(3, repository.getNewChaptersCount(mangaFirst.id))
 
-		val chapter = requireNotNull(mangaFull.chapters).run { get(lastIndex - 1) }
+		var chapter = requireNotNull(mangaFull.chapters).run { get(lastIndex - 1) }
 		repository.syncWithHistory(mangaFull, chapter.id)
 
 		assertEquals(1, repository.getNewChaptersCount(mangaFirst.id))
+
+		chapter = requireNotNull(mangaFull.chapters).run { get(lastIndex) }
+		repository.syncWithHistory(mangaFull, chapter.id)
+
+		assertEquals(0, repository.getNewChaptersCount(mangaFirst.id))
+
 		tracker.checkUpdates(mangaFull, commit = true).apply {
 			assertTrue(isValid)
 			assert(newChapters.isEmpty())
 		}
-		assertEquals(1, repository.getNewChaptersCount(mangaFirst.id))
+		assertEquals(0, repository.getNewChaptersCount(mangaFirst.id))
 	}
 
 	private suspend fun loadManga(name: String): Manga {
-		val assets = InstrumentationRegistry.getInstrumentation().context.assets
+		val manga = SampleData.loadAsset("manga/$name", Manga::class)
-		val manga = assets.open("manga/$name").use {
-			mangaAdapter.fromJson(it.source().buffer())
-		} ?: throw RuntimeException("Cannot read manga from json \"$name\"")
 		dataRepository.storeManga(manga)
 		return manga
 	}

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

@@ -5,16 +5,18 @@ import android.content.Context
 import android.os.StrictMode
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.fragment.app.strictmode.FragmentStrictMode
+import androidx.room.InvalidationTracker
 import org.acra.ReportField
 import org.acra.config.dialog
 import org.acra.config.mailSender
 import org.acra.data.StringFormat
 import org.acra.ktx.initAcra
 import org.koin.android.ext.android.get
+import org.koin.android.ext.android.getKoin
 import org.koin.android.ext.koin.androidContext
 import org.koin.core.context.startKoin
-import org.koitharu.kotatsu.base.ui.util.ActivityRecreationHandle
 import org.koitharu.kotatsu.bookmarks.bookmarksModule
+import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.db.databaseModule
 import org.koitharu.kotatsu.core.github.githubModule
 import org.koitharu.kotatsu.core.network.networkModule
@@ -27,7 +29,6 @@ import org.koitharu.kotatsu.local.data.PagesCache
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.local.localModule
 import org.koitharu.kotatsu.main.mainModule
-import org.koitharu.kotatsu.main.ui.protect.AppProtectHelper
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.reader.readerModule
 import org.koitharu.kotatsu.remotelist.remoteListModule
@@ -36,7 +37,6 @@ import org.koitharu.kotatsu.search.searchModule
 import org.koitharu.kotatsu.settings.settingsModule
 import org.koitharu.kotatsu.suggestions.suggestionsModule
 import org.koitharu.kotatsu.tracker.trackerModule
-import org.koitharu.kotatsu.widget.WidgetUpdater
 import org.koitharu.kotatsu.widget.appWidgetModule
 
 class KotatsuApp : Application() {
@@ -48,11 +48,8 @@ class KotatsuApp : Application() {
 		}
 		initKoin()
 		AppCompatDelegate.setDefaultNightMode(get<AppSettings>().theme)
-		registerActivityLifecycleCallbacks(get<AppProtectHelper>())
+		setupActivityLifecycleCallbacks()
-		registerActivityLifecycleCallbacks(get<ActivityRecreationHandle>())
+		setupDatabaseObservers()
-		val widgetUpdater = WidgetUpdater(applicationContext)
-		widgetUpdater.subscribeToFavourites(get())
-		widgetUpdater.subscribeToHistory(get())
 	}
 
 	private fun initKoin() {
@@ -76,7 +73,7 @@ class KotatsuApp : Application() {
 				appWidgetModule,
 				suggestionsModule,
 				shikimoriModule,
-				bookmarksModule,
+				bookmarksModule
 			)
 		}
 	}
@@ -94,8 +91,7 @@ class KotatsuApp : Application() {
 				ReportField.PHONE_MODEL,
 				ReportField.CRASH_CONFIGURATION,
 				ReportField.STACK_TRACE,
-				ReportField.CUSTOM_DATA,
+				ReportField.SHARED_PREFERENCES
-				ReportField.SHARED_PREFERENCES,
 			)
 			dialog {
 				text = getString(R.string.crash_text)
@@ -112,6 +108,22 @@ class KotatsuApp : Application() {
 		}
 	}
 
+	private fun setupDatabaseObservers() {
+		val observers = getKoin().getAll<InvalidationTracker.Observer>()
+		val database = get<MangaDatabase>()
+		val tracker = database.invalidationTracker
+		observers.forEach {
+			tracker.addObserver(it)
+		}
+	}
+
+	private fun setupActivityLifecycleCallbacks() {
+		val callbacks = getKoin().getAll<ActivityLifecycleCallbacks>()
+		callbacks.forEach {
+			registerActivityLifecycleCallbacks(it)
+		}
+	}
+
 	private fun enableStrictMode() {
 		StrictMode.setThreadPolicy(
 			StrictMode.ThreadPolicy.Builder()

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

@@ -10,6 +10,7 @@ import android.widget.Checkable
 import androidx.annotation.AttrRes
 import androidx.appcompat.widget.AppCompatImageView
 import androidx.core.os.ParcelCompat
+import androidx.customview.view.AbsSavedState
 
 class CheckableImageView @JvmOverloads constructor(
 	context: Context,
@@ -73,7 +74,7 @@ class CheckableImageView @JvmOverloads constructor(
 		fun onCheckedChanged(view: CheckableImageView, isChecked: Boolean)
 	}
 
-	private class SavedState : BaseSavedState {
+	private class SavedState : AbsSavedState {
 
 		val isChecked: Boolean
 
@@ -81,7 +82,7 @@ class CheckableImageView @JvmOverloads constructor(
 			isChecked = checked
 		}
 
-		constructor(source: Parcel) : super(source) {
+		constructor(source: Parcel, classLoader: ClassLoader?) : super(source, classLoader) {
 			isChecked = ParcelCompat.readBoolean(source)
 		}
 
@@ -91,9 +92,10 @@ class CheckableImageView @JvmOverloads constructor(
 		}
 
 		companion object {
+			@Suppress("unused")
 			@JvmField
 			val CREATOR: Creator<SavedState> = object : Creator<SavedState> {
-				override fun createFromParcel(`in`: Parcel) = SavedState(`in`)
+				override fun createFromParcel(`in`: Parcel) = SavedState(`in`, SavedState::class.java.classLoader)
 
 				override fun newArray(size: Int): Array<SavedState?> = arrayOfNulls(size)
 			}

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

@@ -0,0 +1,29 @@
+package org.koitharu.kotatsu.base.ui.widgets
+
+import android.content.Context
+import android.text.Selection
+import android.text.Spannable
+import android.util.AttributeSet
+import android.view.MotionEvent
+import androidx.annotation.AttrRes
+import com.google.android.material.textview.MaterialTextView
+
+class SelectableTextView @JvmOverloads constructor(
+	context: Context,
+	attrs: AttributeSet? = null,
+	@AttrRes defStyleAttr: Int = android.R.attr.textViewStyle,
+) : MaterialTextView(context, attrs, defStyleAttr) {
+
+	override fun dispatchTouchEvent(event: MotionEvent?): Boolean {
+		fixSelectionRange()
+		return super.dispatchTouchEvent(event)
+	}
+
+	// https://stackoverflow.com/questions/22810147/error-when-selecting-text-from-textview-java-lang-indexoutofboundsexception-se
+	private fun fixSelectionRange() {
+		if (selectionStart < 0 || selectionEnd < 0) {
+			val spannableText = text as? Spannable ?: return
+			Selection.setSelection(spannableText, text.length)
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/bookmarks/data/BookmarkEntity.kt

@@ -17,7 +17,7 @@ import org.koitharu.kotatsu.core.db.entity.MangaEntity
 		),
 	]
 )
-class BookmarkEntity(
+data class BookmarkEntity(
 	@ColumnInfo(name = "manga_id", index = true) val mangaId: Long,
 	@ColumnInfo(name = "page_id", index = true) val pageId: Long,
 	@ColumnInfo(name = "chapter_id") val chapterId: Long,

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

@@ -2,15 +2,13 @@ package org.koitharu.kotatsu.bookmarks.ui
 
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
-import coil.request.Disposable
-import coil.size.Scale
-import coil.util.CoilUtils
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.list.AdapterDelegateClickListenerAdapter
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.databinding.ItemBookmarkBinding
+import org.koitharu.kotatsu.utils.ext.disposeImageRequest
 import org.koitharu.kotatsu.utils.ext.enqueueWith
 import org.koitharu.kotatsu.utils.ext.newImageRequest
 import org.koitharu.kotatsu.utils.ext.referer
@@ -23,29 +21,24 @@ fun bookmarkListAD(
 	{ inflater, parent -> ItemBookmarkBinding.inflate(inflater, parent, false) }
 ) {
 
-	var imageRequest: Disposable? = null
 	val listener = AdapterDelegateClickListenerAdapter(this, clickListener)
 
 	binding.root.setOnClickListener(listener)
 	binding.root.setOnLongClickListener(listener)
 
 	bind {
-		imageRequest?.dispose()
+		binding.imageViewThumb.newImageRequest(item.imageUrl)?.run {
-		imageRequest = binding.imageViewThumb.newImageRequest(item.imageUrl)
+			referer(item.manga.publicUrl)
-			.referer(item.manga.publicUrl)
+			placeholder(R.drawable.ic_placeholder)
-			.placeholder(R.drawable.ic_placeholder)
+			fallback(R.drawable.ic_placeholder)
-			.fallback(R.drawable.ic_placeholder)
+			error(R.drawable.ic_placeholder)
-			.error(R.drawable.ic_placeholder)
+			allowRgb565(true)
-			.allowRgb565(true)
+			lifecycle(lifecycleOwner)
-			.scale(Scale.FILL)
+			enqueueWith(coil)
-			.lifecycle(lifecycleOwner)
+		}
-			.enqueueWith(coil)
 	}
 
 	onViewRecycled {
-		imageRequest?.dispose()
+		binding.imageViewThumb.disposeImageRequest()
-		imageRequest = null
-		CoilUtils.dispose(binding.imageViewThumb)
-		binding.imageViewThumb.setImageDrawable(null)
 	}
 }

app/src/main/java/org/koitharu/kotatsu/browser/BrowserClient.kt

@@ -2,10 +2,9 @@ package org.koitharu.kotatsu.browser
 
 import android.graphics.Bitmap
 import android.webkit.WebView
-import org.koin.core.component.KoinComponent
+import android.webkit.WebViewClient
-import org.koitharu.kotatsu.core.network.WebViewClientCompat
 
-class BrowserClient(private val callback: BrowserCallback) : WebViewClientCompat(), KoinComponent {
+class BrowserClient(private val callback: BrowserCallback) : WebViewClient() {
 
 	override fun onPageFinished(webView: WebView, url: String) {
 		super.onPageFinished(webView, url)

app/src/main/java/org/koitharu/kotatsu/browser/ProgressChromeClient.kt

@@ -2,13 +2,14 @@ package org.koitharu.kotatsu.browser
 
 import android.webkit.WebChromeClient
 import android.webkit.WebView
+import android.widget.ProgressBar
 import androidx.core.view.isVisible
-import com.google.android.material.progressindicator.BaseProgressIndicator
+import org.koitharu.kotatsu.utils.ext.setProgressCompat
 
 private const val PROGRESS_MAX = 100
 
 class ProgressChromeClient(
-	private val progressIndicator: BaseProgressIndicator<*>,
+	private val progressIndicator: ProgressBar,
 ) : WebChromeClient() {
 
 	init {
@@ -24,7 +25,7 @@ class ProgressChromeClient(
 			progressIndicator.isIndeterminate = false
 			progressIndicator.setProgressCompat(newProgress.coerceAtMost(PROGRESS_MAX), true)
 		} else {
-			progressIndicator.setIndeterminate(true)
+			progressIndicator.isIndeterminate = true
 		}
 	}
 }

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

@@ -2,19 +2,19 @@ package org.koitharu.kotatsu.browser.cloudflare
 
 import android.graphics.Bitmap
 import android.webkit.WebView
+import android.webkit.WebViewClient
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import org.koitharu.kotatsu.core.network.AndroidCookieJar
-import org.koitharu.kotatsu.core.network.WebViewClientCompat
 
 private const val CF_CLEARANCE = "cf_clearance"
 
 class CloudFlareClient(
 	private val cookieJar: AndroidCookieJar,
 	private val callback: CloudFlareCallback,
-	private val targetUrl: String
+	private val targetUrl: String,
-) : WebViewClientCompat() {
+) : WebViewClient() {
 
-	private val oldClearance = getCookieValue(CF_CLEARANCE)
+	private val oldClearance = getClearance()
 
 	override fun onPageStarted(view: WebView, url: String?, favicon: Bitmap?) {
 		super.onPageStarted(view, url, favicon)
@@ -32,14 +32,14 @@ class CloudFlareClient(
 	}
 
 	private fun checkClearance() {
-		val clearance = getCookieValue(CF_CLEARANCE)
+		val clearance = getClearance()
 		if (clearance != null && clearance != oldClearance) {
 			callback.onCheckPassed()
 		}
 	}
 
-	private fun getCookieValue(name: String): String? {
+	private fun getClearance(): String? {
 		return cookieJar.loadForRequest(targetUrl.toHttpUrl())
-			.find { it.name == name }?.value
+			.find { it.name == CF_CLEARANCE }?.value
 	}
 }

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

@@ -1,14 +1,12 @@
 package org.koitharu.kotatsu.core.backup
 
+import androidx.room.withTransaction
 import org.json.JSONArray
 import org.json.JSONObject
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.parsers.util.json.JSONIterator
-import org.koitharu.kotatsu.core.db.entity.TagEntity
+import org.koitharu.kotatsu.parsers.util.json.mapJSON
-import org.koitharu.kotatsu.favourites.data.FavouriteCategoryEntity
-import org.koitharu.kotatsu.favourites.data.FavouriteEntity
-import org.koitharu.kotatsu.history.data.HistoryEntity
 
 private const val PAGE_SIZE = 10
 
@@ -24,11 +22,11 @@ class BackupRepository(private val db: MangaDatabase) {
 			}
 			offset += history.size
 			for (item in history) {
-				val manga = item.manga.toJson()
+				val manga = JsonSerializer(item.manga).toJson()
 				val tags = JSONArray()
-				item.tags.forEach { tags.put(it.toJson()) }
+				item.tags.forEach { tags.put(JsonSerializer(it).toJson()) }
 				manga.put("tags", tags)
-				val json = item.history.toJson()
+				val json = JsonSerializer(item.history).toJson()
 				json.put("manga", manga)
 				entry.data.put(json)
 			}
@@ -40,7 +38,7 @@ class BackupRepository(private val db: MangaDatabase) {
 		val entry = BackupEntry(BackupEntry.CATEGORIES, JSONArray())
 		val categories = db.favouriteCategoriesDao.findAll()
 		for (item in categories) {
-			entry.data.put(item.toJson())
+			entry.data.put(JsonSerializer(item).toJson())
 		}
 		return entry
 	}
@@ -55,11 +53,11 @@ class BackupRepository(private val db: MangaDatabase) {
 			}
 			offset += favourites.size
 			for (item in favourites) {
-				val manga = item.manga.toJson()
+				val manga = JsonSerializer(item.manga).toJson()
 				val tags = JSONArray()
-				item.tags.forEach { tags.put(it.toJson()) }
+				item.tags.forEach { tags.put(JsonSerializer(it).toJson()) }
 				manga.put("tags", tags)
-				val json = item.favourite.toJson()
+				val json = JsonSerializer(item.favourite).toJson()
 				json.put("manga", manga)
 				entry.data.put(json)
 			}
@@ -77,60 +75,54 @@ class BackupRepository(private val db: MangaDatabase) {
 		return entry
 	}
 
-	private fun MangaEntity.toJson(): JSONObject {
+	suspend fun restoreHistory(entry: BackupEntry): CompositeResult {
-		val jo = JSONObject()
+		val result = CompositeResult()
-		jo.put("id", id)
+		for (item in entry.data.JSONIterator()) {
-		jo.put("title", title)
+			val mangaJson = item.getJSONObject("manga")
-		jo.put("alt_title", altTitle)
+			val manga = JsonDeserializer(mangaJson).toMangaEntity()
-		jo.put("url", url)
+			val tags = mangaJson.getJSONArray("tags").mapJSON {
-		jo.put("public_url", publicUrl)
+				JsonDeserializer(it).toTagEntity()
-		jo.put("rating", rating)
+			}
-		jo.put("nsfw", isNsfw)
+			val history = JsonDeserializer(item).toHistoryEntity()
-		jo.put("cover_url", coverUrl)
+			result += runCatching {
-		jo.put("large_cover_url", largeCoverUrl)
+				db.withTransaction {
-		jo.put("state", state)
+					db.tagsDao.upsert(tags)
-		jo.put("author", author)
+					db.mangaDao.upsert(manga, tags)
-		jo.put("source", source)
+					db.historyDao.upsert(history)
-		return jo
+				}
+			}
+		}
+		return result
 	}
 
-	private fun TagEntity.toJson(): JSONObject {
+	suspend fun restoreCategories(entry: BackupEntry): CompositeResult {
-		val jo = JSONObject()
+		val result = CompositeResult()
-		jo.put("id", id)
+		for (item in entry.data.JSONIterator()) {
-		jo.put("title", title)
+			val category = JsonDeserializer(item).toFavouriteCategoryEntity()
-		jo.put("key", key)
+			result += runCatching {
-		jo.put("source", source)
+				db.favouriteCategoriesDao.upsert(category)
-		return jo
+			}
+		}
+		return result
 	}
 
-	private fun HistoryEntity.toJson(): JSONObject {
+	suspend fun restoreFavourites(entry: BackupEntry): CompositeResult {
-		val jo = JSONObject()
+		val result = CompositeResult()
-		jo.put("manga_id", mangaId)
+		for (item in entry.data.JSONIterator()) {
-		jo.put("created_at", createdAt)
+			val mangaJson = item.getJSONObject("manga")
-		jo.put("updated_at", updatedAt)
+			val manga = JsonDeserializer(mangaJson).toMangaEntity()
-		jo.put("chapter_id", chapterId)
+			val tags = mangaJson.getJSONArray("tags").mapJSON {
-		jo.put("page", page)
+				JsonDeserializer(it).toTagEntity()
-		jo.put("scroll", scroll)
+			}
-		jo.put("percent", percent)
+			val favourite = JsonDeserializer(item).toFavouriteEntity()
-		return jo
+			result += runCatching {
-	}
+				db.withTransaction {
-
+					db.tagsDao.upsert(tags)
-	private fun FavouriteCategoryEntity.toJson(): JSONObject {
+					db.mangaDao.upsert(manga, tags)
-		val jo = JSONObject()
+					db.favouritesDao.upsert(favourite)
-		jo.put("category_id", categoryId)
+				}
-		jo.put("created_at", createdAt)
+			}
-		jo.put("sort_key", sortKey)
+		}
-		jo.put("title", title)
+		return result
-		jo.put("order", order)
-		jo.put("track", track)
-		return jo
-	}
-
-	private fun FavouriteEntity.toJson(): JSONObject {
-		val jo = JSONObject()
-		jo.put("manga_id", mangaId)
-		jo.put("category_id", categoryId)
-		jo.put("created_at", createdAt)
-		return jo
 	}
 }

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

@@ -0,0 +1,62 @@
+package org.koitharu.kotatsu.core.backup
+
+import org.json.JSONObject
+import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.core.db.entity.TagEntity
+import org.koitharu.kotatsu.favourites.data.FavouriteCategoryEntity
+import org.koitharu.kotatsu.favourites.data.FavouriteEntity
+import org.koitharu.kotatsu.history.data.HistoryEntity
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.parsers.util.json.getBooleanOrDefault
+import org.koitharu.kotatsu.parsers.util.json.getFloatOrDefault
+import org.koitharu.kotatsu.parsers.util.json.getStringOrNull
+
+class JsonDeserializer(private val json: JSONObject) {
+
+	fun toFavouriteEntity() = FavouriteEntity(
+		mangaId = json.getLong("manga_id"),
+		categoryId = json.getLong("category_id"),
+		createdAt = json.getLong("created_at"),
+	)
+
+	fun toMangaEntity() = MangaEntity(
+		id = json.getLong("id"),
+		title = json.getString("title"),
+		altTitle = json.getStringOrNull("alt_title"),
+		url = json.getString("url"),
+		publicUrl = json.getStringOrNull("public_url").orEmpty(),
+		rating = json.getDouble("rating").toFloat(),
+		isNsfw = json.getBooleanOrDefault("nsfw", false),
+		coverUrl = json.getString("cover_url"),
+		largeCoverUrl = json.getStringOrNull("large_cover_url"),
+		state = json.getStringOrNull("state"),
+		author = json.getStringOrNull("author"),
+		source = json.getString("source")
+	)
+
+	fun toTagEntity() = TagEntity(
+		id = json.getLong("id"),
+		title = json.getString("title"),
+		key = json.getString("key"),
+		source = json.getString("source")
+	)
+
+	fun toHistoryEntity() = HistoryEntity(
+		mangaId = json.getLong("manga_id"),
+		createdAt = json.getLong("created_at"),
+		updatedAt = json.getLong("updated_at"),
+		chapterId = json.getLong("chapter_id"),
+		page = json.getInt("page"),
+		scroll = json.getDouble("scroll").toFloat(),
+		percent = json.getFloatOrDefault("percent", -1f),
+	)
+
+	fun toFavouriteCategoryEntity() = FavouriteCategoryEntity(
+		categoryId = json.getInt("category_id"),
+		createdAt = json.getLong("created_at"),
+		sortKey = json.getInt("sort_key"),
+		title = json.getString("title"),
+		order = json.getStringOrNull("order") ?: SortOrder.NEWEST.name,
+		track = json.getBooleanOrDefault("track", true),
+	)
+}

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

@@ -0,0 +1,70 @@
+package org.koitharu.kotatsu.core.backup
+
+import org.json.JSONObject
+import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.core.db.entity.TagEntity
+import org.koitharu.kotatsu.favourites.data.FavouriteCategoryEntity
+import org.koitharu.kotatsu.favourites.data.FavouriteEntity
+import org.koitharu.kotatsu.history.data.HistoryEntity
+
+class JsonSerializer private constructor(private val json: JSONObject) {
+
+	constructor(e: FavouriteEntity) : this(
+		JSONObject().apply {
+			put("manga_id", e.mangaId)
+			put("category_id", e.categoryId)
+			put("created_at", e.createdAt)
+		}
+	)
+
+	constructor(e: FavouriteCategoryEntity) : this(
+		JSONObject().apply {
+			put("category_id", e.categoryId)
+			put("created_at", e.createdAt)
+			put("sort_key", e.sortKey)
+			put("title", e.title)
+			put("order", e.order)
+			put("track", e.track)
+		}
+	)
+
+	constructor(e: HistoryEntity) : this(
+		JSONObject().apply {
+			put("manga_id", e.mangaId)
+			put("created_at", e.createdAt)
+			put("updated_at", e.updatedAt)
+			put("chapter_id", e.chapterId)
+			put("page", e.page)
+			put("scroll", e.scroll)
+			put("percent", e.percent)
+		}
+	)
+
+	constructor(e: TagEntity) : this(
+		JSONObject().apply {
+			put("id", e.id)
+			put("title", e.title)
+			put("key", e.key)
+			put("source", e.source)
+		}
+	)
+
+	constructor(e: MangaEntity) : this(
+		JSONObject().apply {
+			put("id", e.id)
+			put("title", e.title)
+			put("alt_title", e.altTitle)
+			put("url", e.url)
+			put("public_url", e.publicUrl)
+			put("rating", e.rating)
+			put("nsfw", e.isNsfw)
+			put("cover_url", e.coverUrl)
+			put("large_cover_url", e.largeCoverUrl)
+			put("state", e.state)
+			put("author", e.author)
+			put("source", e.source)
+		}
+	)
+
+	fun toJson(): JSONObject = json
+}

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

@@ -1,113 +0,0 @@
-package org.koitharu.kotatsu.core.backup
-
-import androidx.room.withTransaction
-import org.json.JSONObject
-import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.MangaEntity
-import org.koitharu.kotatsu.core.db.entity.TagEntity
-import org.koitharu.kotatsu.favourites.data.FavouriteCategoryEntity
-import org.koitharu.kotatsu.favourites.data.FavouriteEntity
-import org.koitharu.kotatsu.history.data.HistoryEntity
-import org.koitharu.kotatsu.parsers.model.SortOrder
-import org.koitharu.kotatsu.parsers.util.json.*
-
-class RestoreRepository(private val db: MangaDatabase) {
-
-	suspend fun upsertHistory(entry: BackupEntry): CompositeResult {
-		val result = CompositeResult()
-		for (item in entry.data.JSONIterator()) {
-			val mangaJson = item.getJSONObject("manga")
-			val manga = parseManga(mangaJson)
-			val tags = mangaJson.getJSONArray("tags").mapJSON {
-				parseTag(it)
-			}
-			val history = parseHistory(item)
-			result += runCatching {
-				db.withTransaction {
-					db.tagsDao.upsert(tags)
-					db.mangaDao.upsert(manga, tags)
-					db.historyDao.upsert(history)
-				}
-			}
-		}
-		return result
-	}
-
-	suspend fun upsertCategories(entry: BackupEntry): CompositeResult {
-		val result = CompositeResult()
-		for (item in entry.data.JSONIterator()) {
-			val category = parseCategory(item)
-			result += runCatching {
-				db.favouriteCategoriesDao.upsert(category)
-			}
-		}
-		return result
-	}
-
-	suspend fun upsertFavourites(entry: BackupEntry): CompositeResult {
-		val result = CompositeResult()
-		for (item in entry.data.JSONIterator()) {
-			val mangaJson = item.getJSONObject("manga")
-			val manga = parseManga(mangaJson)
-			val tags = mangaJson.getJSONArray("tags").mapJSON {
-				parseTag(it)
-			}
-			val favourite = parseFavourite(item)
-			result += runCatching {
-				db.withTransaction {
-					db.tagsDao.upsert(tags)
-					db.mangaDao.upsert(manga, tags)
-					db.favouritesDao.upsert(favourite)
-				}
-			}
-		}
-		return result
-	}
-
-	private fun parseManga(json: JSONObject) = MangaEntity(
-		id = json.getLong("id"),
-		title = json.getString("title"),
-		altTitle = json.getStringOrNull("alt_title"),
-		url = json.getString("url"),
-		publicUrl = json.getStringOrNull("public_url").orEmpty(),
-		rating = json.getDouble("rating").toFloat(),
-		isNsfw = json.getBooleanOrDefault("nsfw", false),
-		coverUrl = json.getString("cover_url"),
-		largeCoverUrl = json.getStringOrNull("large_cover_url"),
-		state = json.getStringOrNull("state"),
-		author = json.getStringOrNull("author"),
-		source = json.getString("source")
-	)
-
-	private fun parseTag(json: JSONObject) = TagEntity(
-		id = json.getLong("id"),
-		title = json.getString("title"),
-		key = json.getString("key"),
-		source = json.getString("source")
-	)
-
-	private fun parseHistory(json: JSONObject) = HistoryEntity(
-		mangaId = json.getLong("manga_id"),
-		createdAt = json.getLong("created_at"),
-		updatedAt = json.getLong("updated_at"),
-		chapterId = json.getLong("chapter_id"),
-		page = json.getInt("page"),
-		scroll = json.getDouble("scroll").toFloat(),
-		percent = json.getFloatOrDefault("percent", -1f),
-	)
-
-	private fun parseCategory(json: JSONObject) = FavouriteCategoryEntity(
-		categoryId = json.getInt("category_id"),
-		createdAt = json.getLong("created_at"),
-		sortKey = json.getInt("sort_key"),
-		title = json.getString("title"),
-		order = json.getStringOrNull("order") ?: SortOrder.NEWEST.name,
-		track = json.getBooleanOrDefault("track", true),
-	)
-
-	private fun parseFavourite(json: JSONObject) = FavouriteEntity(
-		mangaId = json.getLong("manga_id"),
-		categoryId = json.getLong("category_id"),
-		createdAt = json.getLong("created_at")
-	)
-}

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

@@ -4,6 +4,7 @@ import android.content.Context
 import androidx.room.Database
 import androidx.room.Room
 import androidx.room.RoomDatabase
+import androidx.room.migration.Migration
 import org.koitharu.kotatsu.bookmarks.data.BookmarkEntity
 import org.koitharu.kotatsu.bookmarks.data.BookmarksDao
 import org.koitharu.kotatsu.core.db.dao.MangaDao
@@ -29,6 +30,8 @@ import org.koitharu.kotatsu.tracker.data.TrackEntity
 import org.koitharu.kotatsu.tracker.data.TrackLogEntity
 import org.koitharu.kotatsu.tracker.data.TracksDao
 
+const val DATABASE_VERSION = 12
+
 @Database(
 	entities = [
 		MangaEntity::class, TagEntity::class, HistoryEntity::class, MangaTagsEntity::class,
@@ -36,7 +39,7 @@ import org.koitharu.kotatsu.tracker.data.TracksDao
 		TrackEntity::class, TrackLogEntity::class, SuggestionEntity::class, BookmarkEntity::class,
 		ScrobblingEntity::class,
 	],
-	version = 12,
+	version = DATABASE_VERSION,
 )
 abstract class MangaDatabase : RoomDatabase() {
 
@@ -63,22 +66,23 @@ abstract class MangaDatabase : RoomDatabase() {
 	abstract val scrobblingDao: ScrobblingDao
 }
 
-fun MangaDatabase(context: Context): MangaDatabase = Room.databaseBuilder(
+val databaseMigrations: Array<Migration>
-	context,
+	get() = arrayOf(
-	MangaDatabase::class.java,
+		Migration1To2(),
-	"kotatsu-db"
+		Migration2To3(),
-).addMigrations(
+		Migration3To4(),
-	Migration1To2(),
+		Migration4To5(),
-	Migration2To3(),
+		Migration5To6(),
-	Migration3To4(),
+		Migration6To7(),
-	Migration4To5(),
+		Migration7To8(),
-	Migration5To6(),
+		Migration8To9(),
-	Migration6To7(),
+		Migration9To10(),
-	Migration7To8(),
+		Migration10To11(),
-	Migration8To9(),
+		Migration11To12(),
-	Migration9To10(),
+	)
-	Migration10To11(),
+
-	Migration11To12(),
+fun MangaDatabase(context: Context): MangaDatabase = Room
-).addCallback(
+	.databaseBuilder(context, MangaDatabase::class.java, "kotatsu-db")
-	DatabasePrePopulateCallback(context.resources)
+	.addMigrations(*databaseMigrations)
-).build()
+	.addCallback(DatabasePrePopulateCallback(context.resources))
+	.build()

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

@@ -0,0 +1,9 @@
+package org.koitharu.kotatsu.core.db
+
+
+const val TABLE_FAVOURITES = "favourites"
+const val TABLE_MANGA = "manga"
+const val TABLE_TAGS = "tags"
+const val TABLE_FAVOURITE_CATEGORIES = "favourite_categories"
+const val TABLE_HISTORY = "history"
+const val TABLE_MANGA_TAGS = "manga_tags"

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

@@ -3,9 +3,10 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
+import org.koitharu.kotatsu.core.db.TABLE_MANGA
 
-@Entity(tableName = "manga")
+@Entity(tableName = TABLE_MANGA)
-class MangaEntity(
+data class MangaEntity(
 	@PrimaryKey(autoGenerate = false)
 	@ColumnInfo(name = "manga_id") val id: Long,
 	@ColumnInfo(name = "title") val title: String,
@@ -18,5 +19,5 @@ class MangaEntity(
 	@ColumnInfo(name = "large_cover_url") val largeCoverUrl: String?,
 	@ColumnInfo(name = "state") val state: String?,
 	@ColumnInfo(name = "author") val author: String?,
-	@ColumnInfo(name = "source") val source: String
+	@ColumnInfo(name = "source") val source: String,
 )

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

@@ -3,9 +3,11 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.ForeignKey
+import org.koitharu.kotatsu.core.db.TABLE_MANGA_TAGS
 
 @Entity(
-	tableName = "manga_tags", primaryKeys = ["manga_id", "tag_id"],
+	tableName = TABLE_MANGA_TAGS,
+	primaryKeys = ["manga_id", "tag_id"],
 	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
@@ -23,5 +25,5 @@ import androidx.room.ForeignKey
 )
 class MangaTagsEntity(
 	@ColumnInfo(name = "manga_id", index = true) val mangaId: Long,
-	@ColumnInfo(name = "tag_id", index = true) val tagId: Long
+	@ColumnInfo(name = "tag_id", index = true) val tagId: Long,
 )

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

@@ -3,12 +3,13 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
+import org.koitharu.kotatsu.core.db.TABLE_TAGS
 
-@Entity(tableName = "tags")
+@Entity(tableName = TABLE_TAGS)
-class TagEntity(
+data class TagEntity(
 	@PrimaryKey(autoGenerate = false)
 	@ColumnInfo(name = "tag_id") val id: Long,
 	@ColumnInfo(name = "title") val title: String,
 	@ColumnInfo(name = "key") val key: String,
-	@ColumnInfo(name = "source") val source: String
+	@ColumnInfo(name = "source") val source: String,
 )

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

@@ -0,0 +1,3 @@
+package org.koitharu.kotatsu.core.exceptions
+
+class CaughtException(cause: Throwable, override val message: String?) : RuntimeException(cause)

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

@@ -1,3 +0,0 @@
-package org.koitharu.kotatsu.core.exceptions
-
-class MangaNotFoundException(s: String? = null) : RuntimeException(s)

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

@@ -8,9 +8,11 @@ import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
 import kotlinx.coroutines.suspendCancellableCoroutine
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.browser.BrowserActivity
 import org.koitharu.kotatsu.browser.cloudflare.CloudFlareDialog
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
 import org.koitharu.kotatsu.parsers.exception.AuthRequiredException
+import org.koitharu.kotatsu.parsers.exception.NotFoundException
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.settings.sources.auth.SourceAuthActivity
 import org.koitharu.kotatsu.utils.TaggedActivityResult
@@ -43,6 +45,10 @@ class ExceptionResolver private constructor(
 	suspend fun resolve(e: Throwable): Boolean = when (e) {
 		is CloudFlareProtectedException -> resolveCF(e.url)
 		is AuthRequiredException -> resolveAuthException(e.source)
+		is NotFoundException -> {
+			openInBrowser(e.url)
+			false
+		}
 		else -> false
 	}
 
@@ -69,6 +75,11 @@ class ExceptionResolver private constructor(
 		sourceAuthContract.launch(source)
 	}
 
+	private fun openInBrowser(url: String) {
+		val context = activity ?: fragment?.activity ?: return
+		context.startActivity(BrowserActivity.newIntent(context, url, null))
+	}
+
 	private fun getFragmentManager() = checkNotNull(fragment?.childFragmentManager ?: activity?.supportFragmentManager)
 
 	companion object {
@@ -77,6 +88,7 @@ class ExceptionResolver private constructor(
 		fun getResolveStringId(e: Throwable) = when (e) {
 			is CloudFlareProtectedException -> R.string.captcha_solve
 			is AuthRequiredException -> R.string.sign_in
+			is NotFoundException -> if (e.url.isNotEmpty()) R.string.open_in_browser else 0
 			else -> 0
 		}
 

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

@@ -10,7 +10,7 @@ class GithubRepository(private val okHttp: OkHttpClient) {
 	suspend fun getLatestVersion(): AppVersion {
 		val request = Request.Builder()
 			.get()
-			.url("https://api.github.com/repos/nv95/Kotatsu/releases/latest")
+			.url("https://api.github.com/repos/KotatsuApp/Kotatsu/releases/latest")
 		val json = okHttp.newCall(request.build()).await().parseJson()
 		val asset = json.getJSONArray("assets").getJSONObject(0)
 		return AppVersion(

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

@@ -1,6 +1,34 @@
 package org.koitharu.kotatsu.core.model
 
+import androidx.core.os.LocaleListCompat
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.util.mapToSet
+import org.koitharu.kotatsu.parsers.util.toTitleCase
+import org.koitharu.kotatsu.utils.ext.iterator
 
-fun Collection<Manga>.ids() = mapToSet { it.id }
+fun Collection<Manga>.ids() = mapToSet { it.id }
+
+fun Manga.getPreferredBranch(history: MangaHistory?): String? {
+	val ch = chapters
+	if (ch.isNullOrEmpty()) {
+		return null
+	}
+	if (history != null) {
+		val currentChapter = ch.find { it.id == history.chapterId }
+		if (currentChapter != null) {
+			return currentChapter.branch
+		}
+	}
+	val groups = ch.groupBy { it.branch }
+	for (locale in LocaleListCompat.getAdjustedDefault()) {
+		var language = locale.getDisplayLanguage(locale).toTitleCase(locale)
+		if (groups.containsKey(language)) {
+			return language
+		}
+		language = locale.getDisplayName(locale).toTitleCase(locale)
+		if (groups.containsKey(language)) {
+			return language
+		}
+	}
+	return groups.maxByOrNull { it.value.size }?.key
+}

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

@@ -1,10 +1,18 @@
 package org.koitharu.kotatsu.core.model
 
+import java.util.*
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.util.toTitleCase
-import java.util.*
 
 fun MangaSource.getLocaleTitle(): String? {
 	val lc = Locale(locale ?: return null)
 	return lc.getDisplayLanguage(lc).toTitleCase(lc)
+}
+
+@Suppress("FunctionName")
+fun MangaSource(name: String): MangaSource? {
+	MangaSource.values().forEach {
+		if (it.name == name) return it
+	}
+	return null
 }

app/src/main/java/org/koitharu/kotatsu/core/network/CloudFlareInterceptor.kt

@@ -17,7 +17,7 @@ class CloudFlareInterceptor : Interceptor {
 		if (response.code == HTTP_FORBIDDEN || response.code == HTTP_UNAVAILABLE) {
 			if (response.header(HEADER_SERVER)?.startsWith(SERVER_CLOUDFLARE) == true) {
 				response.closeQuietly()
-				throw CloudFlareProtectedException(chain.request().url.toString())
+				throw CloudFlareProtectedException(response.request.url.toString())
 			}
 		}
 		return response

app/src/main/java/org/koitharu/kotatsu/core/network/DoHManager.kt

@@ -21,7 +21,12 @@ class DoHManager(
 	private var cachedProvider: DoHProvider? = null
 
 	override fun lookup(hostname: String): List<InetAddress> {
-		return getDelegate().lookup(hostname)
+		return try {
+			getDelegate().lookup(hostname)
+		} catch (e: UnknownHostException) {
+			// fallback
+			Dns.SYSTEM.lookup(hostname)
+		}
 	}
 
 	@Synchronized
@@ -40,6 +45,7 @@ class DoHManager(
 		DoHProvider.NONE -> Dns.SYSTEM
 		DoHProvider.GOOGLE -> DnsOverHttps.Builder().client(bootstrapClient)
 			.url("https://dns.google/dns-query".toHttpUrl())
+			.resolvePrivateAddresses(true)
 			.bootstrapDnsHosts(
 				listOfNotNull(
 					tryGetByIp("8.8.4.4"),
@@ -50,6 +56,7 @@ class DoHManager(
 			).build()
 		DoHProvider.CLOUDFLARE -> DnsOverHttps.Builder().client(bootstrapClient)
 			.url("https://cloudflare-dns.com/dns-query".toHttpUrl())
+			.resolvePrivateAddresses(true)
 			.bootstrapDnsHosts(
 				listOfNotNull(
 					tryGetByIp("162.159.36.1"),
@@ -65,6 +72,7 @@ class DoHManager(
 			).build()
 		DoHProvider.ADGUARD -> DnsOverHttps.Builder().client(bootstrapClient)
 			.url("https://dns-unfiltered.adguard.com/dns-query".toHttpUrl())
+			.resolvePrivateAddresses(true)
 			.bootstrapDnsHosts(
 				listOfNotNull(
 					tryGetByIp("94.140.14.140"),
@@ -81,4 +89,4 @@ class DoHManager(
 		e.printStackTraceDebug()
 		null
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/core/network/WebViewClientCompat.kt

@@ -1,86 +0,0 @@
-package org.koitharu.kotatsu.core.network
-
-import android.annotation.TargetApi
-import android.os.Build
-import android.webkit.*
-
-@Suppress("OverridingDeprecatedMember")
-abstract class WebViewClientCompat : WebViewClient() {
-
-	open fun shouldOverrideUrlCompat(view: WebView, url: String): Boolean {
-		return false
-	}
-
-	open fun shouldInterceptRequestCompat(view: WebView, url: String): WebResourceResponse? {
-		return null
-	}
-
-	open fun onReceivedErrorCompat(
-		view: WebView,
-		errorCode: Int,
-		description: String?,
-		failingUrl: String,
-		isMainFrame: Boolean
-	) {
-	}
-
-	@TargetApi(Build.VERSION_CODES.N)
-	final override fun shouldOverrideUrlLoading(
-		view: WebView,
-		request: WebResourceRequest
-	): Boolean = shouldOverrideUrlCompat(view, request.url.toString())
-
-	final override fun shouldOverrideUrlLoading(view: WebView, url: String): Boolean {
-		return shouldOverrideUrlCompat(view, url)
-	}
-
-	final override fun shouldInterceptRequest(
-		view: WebView,
-		request: WebResourceRequest
-	): WebResourceResponse? = shouldInterceptRequestCompat(view, request.url.toString())
-
-	final override fun shouldInterceptRequest(
-		view: WebView,
-		url: String
-	): WebResourceResponse? = shouldInterceptRequestCompat(view, url)
-
-	@TargetApi(Build.VERSION_CODES.M)
-	final override fun onReceivedError(
-		view: WebView,
-		request: WebResourceRequest,
-		error: WebResourceError
-	) {
-		onReceivedErrorCompat(
-			view,
-			error.errorCode,
-			error.description?.toString(),
-			request.url.toString(),
-			request.isForMainFrame
-		)
-	}
-
-	final override fun onReceivedError(
-		view: WebView,
-		errorCode: Int,
-		description: String?,
-		failingUrl: String
-	) {
-		onReceivedErrorCompat(view, errorCode, description, failingUrl, failingUrl == view.url)
-	}
-
-	@TargetApi(Build.VERSION_CODES.M)
-	final override fun onReceivedHttpError(
-		view: WebView,
-		request: WebResourceRequest,
-		error: WebResourceResponse
-	) {
-		onReceivedErrorCompat(
-			view,
-			error.statusCode,
-			error.reasonPhrase,
-			request.url
-				.toString(),
-			request.isForMainFrame
-		)
-	}
-}

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

@@ -6,38 +6,42 @@ import android.content.pm.ShortcutManager
 import android.media.ThumbnailUtils
 import android.os.Build
 import android.util.Size
+import androidx.annotation.VisibleForTesting
 import androidx.core.content.pm.ShortcutInfoCompat
 import androidx.core.content.pm.ShortcutManagerCompat
 import androidx.core.graphics.drawable.IconCompat
+import androidx.room.InvalidationTracker
 import coil.ImageLoader
 import coil.request.ImageRequest
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
+import org.koitharu.kotatsu.core.db.TABLE_HISTORY
 import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.reader.ui.ReaderActivity
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.processLifecycleScope
 import org.koitharu.kotatsu.utils.ext.requireBitmap
 
-class ShortcutsRepository(
+class ShortcutsUpdater(
 	private val context: Context,
 	private val coil: ImageLoader,
 	private val historyRepository: HistoryRepository,
 	private val mangaRepository: MangaDataRepository,
-) {
+) : InvalidationTracker.Observer(TABLE_HISTORY) {
 
-	private val iconSize by lazy {
+	private val iconSize by lazy { getIconSize(context) }
-		getIconSize(context)
+	private var shortcutsUpdateJob: Job? = null
-	}
 
-	suspend fun updateShortcuts() {
+	override fun onInvalidated(tables: MutableSet<String>) {
-		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N_MR1) return
+		val prevJob = shortcutsUpdateJob
-		val manager = context.getSystemService(Context.SHORTCUT_SERVICE) as ShortcutManager
+		shortcutsUpdateJob = processLifecycleScope.launch(Dispatchers.Default) {
-		val shortcuts = historyRepository.getList(0, manager.maxShortcutCountPerActivity)
+			prevJob?.join()
-			.filter { x -> x.title.isNotEmpty() }
+			updateShortcutsImpl()
-			.map { buildShortcutInfo(it).build().toShortcutInfo() }
+		}
-		manager.dynamicShortcuts = shortcuts
 	}
 
 	suspend fun requestPinShortcut(manga: Manga): Boolean {
@@ -48,17 +52,30 @@ class ShortcutsRepository(
 		)
 	}
 
+	@VisibleForTesting
+	suspend fun await(): Boolean {
+		return shortcutsUpdateJob?.join() != null
+	}
+
+	private suspend fun updateShortcutsImpl() = runCatching {
+		val manager = context.getSystemService(Context.SHORTCUT_SERVICE) as ShortcutManager
+		val shortcuts = historyRepository.getList(0, manager.maxShortcutCountPerActivity)
+			.filter { x -> x.title.isNotEmpty() }
+			.map { buildShortcutInfo(it).build().toShortcutInfo() }
+		manager.dynamicShortcuts = shortcuts
+	}.onFailure {
+		it.printStackTraceDebug()
+	}
+
 	private suspend fun buildShortcutInfo(manga: Manga): ShortcutInfoCompat.Builder {
 		val icon = runCatching {
-			withContext(Dispatchers.IO) {
+			val bmp = coil.execute(
-				val bmp = coil.execute(
+				ImageRequest.Builder(context)
-					ImageRequest.Builder(context)
+					.data(manga.coverUrl)
-						.data(manga.coverUrl)
+					.size(iconSize.width, iconSize.height)
-						.size(iconSize.width, iconSize.height)
+					.build()
-						.build()
+			).requireBitmap()
-				).requireBitmap()
+			ThumbnailUtils.extractThumbnail(bmp, iconSize.width, iconSize.height, 0)
-				ThumbnailUtils.extractThumbnail(bmp, iconSize.width, iconSize.height, 0)
-			}
 		}.fold(
 			onSuccess = { IconCompat.createWithAdaptiveBitmap(it) },
 			onFailure = { IconCompat.createWithResource(context, R.drawable.ic_shortcut_default) }

app/src/main/java/org/koitharu/kotatsu/core/parser/FaviconMapper.kt

@@ -5,7 +5,7 @@ import coil.map.Mapper
 import coil.request.Options
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
-import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.core.model.MangaSource
 
 class FaviconMapper : Mapper<Uri, HttpUrl> {
 
@@ -13,7 +13,7 @@ class FaviconMapper : Mapper<Uri, HttpUrl> {
 		if (data.scheme != "favicon") {
 			return null
 		}
-		val mangaSource = MangaSource.valueOf(data.schemeSpecificPart)
+		val mangaSource = MangaSource(data.schemeSpecificPart) ?: return null
 		val repo = MangaRepository(mangaSource) as RemoteMangaRepository
 		return repo.getFaviconUrl().toHttpUrl()
 	}

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

@@ -135,6 +135,26 @@ class ChaptersFragment :
 				mode.finish()
 				true
 			}
+			R.id.action_select_range -> {
+				val controller = selectionController ?: return false
+				val items = chaptersAdapter?.items ?: return false
+				val ids = HashSet(controller.peekCheckedIds())
+				val buffer = HashSet<Long>()
+				var isAdding = false
+				for (x in items) {
+					if (x.chapter.id in ids) {
+						isAdding = true
+						if (buffer.isNotEmpty()) {
+							ids.addAll(buffer)
+							buffer.clear()
+						}
+					} else if (isAdding) {
+						buffer.add(x.chapter.id)
+					}
+				}
+				controller.addAll(ids)
+				true
+			}
 			R.id.action_select_all -> {
 				val ids = chaptersAdapter?.items?.map { it.chapter.id } ?: return false
 				selectionController?.addAll(ids)
@@ -158,14 +178,24 @@ class ChaptersFragment :
 
 	override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
 		val selectedIds = selectionController?.peekCheckedIds() ?: return false
-		val items = chaptersAdapter?.items?.filter { x -> x.chapter.id in selectedIds }.orEmpty()
+		val allItems = chaptersAdapter?.items.orEmpty()
-		menu.findItem(R.id.action_save).isVisible = items.none { x ->
+		val items = allItems.withIndex().filter { (_, x) -> x.chapter.id in selectedIds }
+		menu.findItem(R.id.action_save).isVisible = items.none { (_, x) ->
 			x.chapter.source == MangaSource.LOCAL
 		}
-		menu.findItem(R.id.action_delete).isVisible = items.all { x ->
+		menu.findItem(R.id.action_delete).isVisible = items.all { (_, x) ->
 			x.chapter.source == MangaSource.LOCAL
 		}
+		menu.findItem(R.id.action_select_all).isVisible = items.size < allItems.size
 		mode.title = items.size.toString()
+		var hasGap = false
+		for (i in 0 until items.size - 1) {
+			if (items[i].index + 1 != items[i + 1].index) {
+				hasGap = true
+				break
+			}
+		}
+		menu.findItem(R.id.action_select_range).isVisible = hasGap
 		return true
 	}
 

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

@@ -25,7 +25,6 @@ import com.google.android.material.snackbar.Snackbar
 import com.google.android.material.tabs.TabLayout
 import com.google.android.material.tabs.TabLayoutMediator
 import kotlinx.coroutines.launch
-import org.acra.ktx.sendWithAcra
 import org.koin.android.ext.android.get
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import org.koin.core.parameter.parametersOf
@@ -35,11 +34,10 @@ import org.koitharu.kotatsu.base.ui.BaseActivity
 import org.koitharu.kotatsu.browser.BrowserActivity
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
-import org.koitharu.kotatsu.core.os.ShortcutsRepository
+import org.koitharu.kotatsu.core.os.ShortcutsUpdater
 import org.koitharu.kotatsu.databinding.ActivityDetailsBinding
 import org.koitharu.kotatsu.details.ui.adapter.BranchesAdapter
 import org.koitharu.kotatsu.download.ui.service.DownloadService
-import org.koitharu.kotatsu.parsers.exception.ParseException
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.util.mapNotNullToSet
@@ -48,6 +46,8 @@ import org.koitharu.kotatsu.reader.ui.ReaderState
 import org.koitharu.kotatsu.scrobbling.ui.selector.ScrobblingSelectorBottomSheet
 import org.koitharu.kotatsu.search.ui.multi.MultiSearchActivity
 import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.isReportable
+import org.koitharu.kotatsu.utils.ext.report
 
 class DetailsActivity :
 	BaseActivity<ActivityDetailsBinding>(),
@@ -103,8 +103,9 @@ class DetailsActivity :
 
 	private fun onMangaRemoved(manga: Manga) {
 		Toast.makeText(
-			this, getString(R.string._s_deleted_from_local_storage, manga.title),
+			this,
-			Toast.LENGTH_SHORT
+			getString(R.string._s_deleted_from_local_storage, manga.title),
+			Toast.LENGTH_SHORT,
 		).show()
 		finishAfterTransition()
 	}
@@ -118,7 +119,7 @@ class DetailsActivity :
 				Toast.makeText(this, e.getDisplayMessage(resources), Toast.LENGTH_LONG).show()
 				finishAfterTransition()
 			}
-			e is ParseException || e is IllegalArgumentException || e is IllegalStateException -> {
+			e.isReportable() -> {
 				binding.snackbar.show(
 					messageText = e.getDisplayMessage(resources),
 					actionId = R.string.report,
@@ -128,9 +129,9 @@ class DetailsActivity :
 						Snackbar.LENGTH_LONG
 					},
 					onActionClick = {
-						e.sendWithAcra()
+						e.report("DetailsActivity::onError")
 						dismiss()
-					}
+					},
 				)
 			}
 			else -> {
@@ -141,14 +142,14 @@ class DetailsActivity :
 
 	override fun onWindowInsetsChanged(insets: Insets) {
 		binding.snackbar.updatePadding(
-			bottom = insets.bottom
+			bottom = insets.bottom,
 		)
 		binding.toolbar.updateLayoutParams<ViewGroup.MarginLayoutParams> {
 			topMargin = insets.top
 		}
 		binding.root.updatePadding(
 			left = insets.left,
-			right = insets.right
+			right = insets.right,
 		)
 	}
 
@@ -158,6 +159,7 @@ class DetailsActivity :
 			tab.removeBadge()
 		} else {
 			val badge = tab.orCreateBadge
+			badge.maxCharacterCount = 3
 			badge.number = newChapters
 			badge.isVisible = true
 		}
@@ -224,7 +226,7 @@ class DetailsActivity :
 		R.id.action_shortcut -> {
 			viewModel.manga.value?.let {
 				lifecycleScope.launch {
-					if (!get<ShortcutsRepository>().requestPinShortcut(it)) {
+					if (!get<ShortcutsUpdater>().requestPinShortcut(it)) {
 						binding.snackbar.show(getString(R.string.operation_not_supported))
 					}
 				}
@@ -274,8 +276,8 @@ class DetailsActivity :
 					ReaderActivity.newIntent(
 						context = this@DetailsActivity,
 						manga = remoteManga,
-						state = ReaderState(chapterId, 0, 0)
+						state = ReaderState(chapterId, 0, 0),
-					)
+					),
 				)
 			}
 			setNeutralButton(R.string.download) { _, _ ->
@@ -349,8 +351,8 @@ class DetailsActivity :
 			dialogBuilder.setMessage(
 				getString(
 					R.string.large_manga_save_confirm,
-					resources.getQuantityString(R.plurals.chapters, chaptersCount, chaptersCount)
+					resources.getQuantityString(R.plurals.chapters, chaptersCount, chaptersCount),
-				)
+				),
 			).setPositiveButton(R.string.save) { _, _ ->
 				DownloadService.start(this, manga)
 			}

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

@@ -2,7 +2,6 @@ package org.koitharu.kotatsu.details.ui
 
 import android.app.ActivityOptions
 import android.os.Bundle
-import android.text.Spanned
 import android.text.method.LinkMovementMethod
 import android.view.*
 import androidx.appcompat.widget.PopupMenu
@@ -10,18 +9,15 @@ import androidx.core.content.ContextCompat
 import androidx.core.graphics.Insets
 import androidx.core.net.toFile
 import androidx.core.net.toUri
-import androidx.core.text.parseAsHtml
 import androidx.core.view.MenuProvider
 import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
 import coil.ImageLoader
 import coil.request.ImageRequest
-import coil.size.Scale
 import coil.util.CoilUtils
 import com.google.android.material.chip.Chip
 import kotlinx.coroutines.launch
-import org.koin.android.ext.android.get
 import org.koin.android.ext.android.inject
 import org.koin.androidx.viewmodel.ext.android.sharedViewModel
 import org.koitharu.kotatsu.R
@@ -33,6 +29,7 @@ import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.bookmarks.ui.BookmarksAdapter
 import org.koitharu.kotatsu.core.model.MangaHistory
 import org.koitharu.kotatsu.databinding.FragmentDetailsBinding
+import org.koitharu.kotatsu.details.ui.model.ChapterListItem
 import org.koitharu.kotatsu.details.ui.scrobbling.ScrobblingInfoBottomSheet
 import org.koitharu.kotatsu.favourites.ui.categories.select.FavouriteCategoriesBottomSheet
 import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
@@ -49,6 +46,7 @@ import org.koitharu.kotatsu.search.ui.SearchActivity
 import org.koitharu.kotatsu.utils.FileSize
 import org.koitharu.kotatsu.utils.ShareHelper
 import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.image.CoverSizeResolver
 
 class DetailsFragment :
 	BaseFragment<FragmentDetailsBinding>(),
@@ -82,6 +80,7 @@ class DetailsFragment :
 		viewModel.bookmarks.observe(viewLifecycleOwner, ::onBookmarksChanged)
 		viewModel.scrobblingInfo.observe(viewLifecycleOwner, ::onScrobblingInfoChanged)
 		viewModel.description.observe(viewLifecycleOwner, ::onDescriptionChanged)
+		viewModel.chapters.observe(viewLifecycleOwner, ::onChaptersChanged)
 		addMenuProvider(DetailsMenuProvider())
 	}
 
@@ -126,18 +125,6 @@ class DetailsFragment :
 				else -> textViewState.isVisible = false
 			}
 
-			// Info containers
-			val chapters = manga.chapters
-			if (chapters.isNullOrEmpty()) {
-				infoLayout.textViewChapters.isVisible = false
-			} else {
-				infoLayout.textViewChapters.isVisible = true
-				infoLayout.textViewChapters.text = resources.getQuantityString(
-					R.plurals.chapters,
-					chapters.size,
-					chapters.size,
-				)
-			}
 			if (manga.hasRating) {
 				infoLayout.textViewRating.text = String.format("%.1f", manga.rating * 5)
 				infoLayout.ratingContainer.isVisible = true
@@ -164,14 +151,27 @@ class DetailsFragment :
 
 			infoLayout.textViewNsfw.isVisible = manga.isNsfw
 
-			// Buttons
-			buttonRead.isEnabled = !manga.chapters.isNullOrEmpty()
-
 			// Chips
 			bindTags(manga)
 		}
 	}
 
+	private fun onChaptersChanged(chapters: List<ChapterListItem>?) {
+		val infoLayout = binding.infoLayout
+		if (chapters.isNullOrEmpty()) {
+			infoLayout.textViewChapters.isVisible = false
+		} else {
+			infoLayout.textViewChapters.isVisible = true
+			infoLayout.textViewChapters.text = resources.getQuantityString(
+				R.plurals.chapters,
+				chapters.size,
+				chapters.size,
+			)
+		}
+		// Buttons
+		binding.buttonRead.isEnabled = !chapters.isNullOrEmpty()
+	}
+
 	private fun onDescriptionChanged(description: CharSequence?) {
 		if (description.isNullOrBlank()) {
 			binding.textViewDescription.setText(R.string.no_description)
@@ -231,14 +231,13 @@ class DetailsFragment :
 				CoilUtils.dispose(imageViewCover)
 				return
 			}
-			imageViewCover.newImageRequest(scrobbling.coverUrl)
+			imageViewCover.newImageRequest(scrobbling.coverUrl)?.run {
-				.crossfade(true)
+				placeholder(R.drawable.ic_placeholder)
-				.placeholder(R.drawable.ic_placeholder)
+				fallback(R.drawable.ic_placeholder)
-				.fallback(R.drawable.ic_placeholder)
+				error(R.drawable.ic_placeholder)
-				.error(R.drawable.ic_placeholder)
+				lifecycle(viewLifecycleOwner)
-				.scale(Scale.FILL)
+				enqueueWith(coil)
-				.lifecycle(viewLifecycleOwner)
+			}
-				.enqueueWith(coil)
 			textViewTitle.text = scrobbling.title
 			textViewTitle.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, scrobbling.scrobbler.iconResId, 0)
 			ratingBar.rating = scrobbling.rating * ratingBar.numStars
@@ -267,7 +266,7 @@ class DetailsFragment :
 							context = context ?: return,
 							manga = manga,
 							branch = viewModel.selectedBranchValue,
-						)
+						),
 					)
 				}
 			}
@@ -277,14 +276,14 @@ class DetailsFragment :
 						context = v.context,
 						source = manga.source,
 						query = manga.author ?: return,
-					)
+					),
 				)
 			}
 			R.id.imageView_cover -> {
 				val options = ActivityOptions.makeScaleUpAnimation(v, 0, 0, v.width, v.height)
 				startActivity(
 					ImageActivity.newIntent(v.context, manga.largeCoverUrl.ifNullOrEmpty { manga.coverUrl }),
-					options.toBundle()
+					options.toBundle(),
 				)
 			}
 		}
@@ -310,8 +309,8 @@ class DetailsFragment :
 										c.chapter.branch == branch
 									}?.let { c ->
 										ReaderState(c.chapter.id, 0, 0)
-									}
+									},
-								)
+								),
 							)
 							true
 						}
@@ -344,7 +343,7 @@ class DetailsFragment :
 					icon = 0,
 					data = tag,
 				)
-			}
+			},
 		)
 	}
 
@@ -356,13 +355,22 @@ class DetailsFragment :
 		}
 		val request = ImageRequest.Builder(context ?: return)
 			.target(binding.imageViewCover)
+			.size(CoverSizeResolver(binding.imageViewCover))
 			.data(imageUrl)
 			.crossfade(true)
 			.referer(manga.publicUrl)
 			.lifecycle(viewLifecycleOwner)
-		lastResult?.drawable?.let {
+			.placeholderMemoryCacheKey(manga.coverUrl)
-			request.fallback(it)
+		val previousDrawable = lastResult?.drawable
-		} ?: request.fallback(R.drawable.ic_placeholder)
+		if (previousDrawable != null) {
+			request.fallback(previousDrawable)
+				.placeholder(previousDrawable)
+				.error(previousDrawable)
+		} else {
+			request.fallback(R.drawable.ic_placeholder)
+				.placeholder(R.drawable.ic_placeholder)
+				.error(R.drawable.ic_placeholder)
+		}
 		request.enqueueWith(coil)
 	}
 

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

@@ -1,11 +1,16 @@
 package org.koitharu.kotatsu.details.ui
 
 import android.text.Html
+import android.text.SpannableString
+import android.text.Spanned
+import android.text.style.ForegroundColorSpan
+import androidx.core.text.getSpans
 import androidx.core.text.parseAsHtml
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.asFlow
 import androidx.lifecycle.asLiveData
 import androidx.lifecycle.viewModelScope
+import java.io.IOException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.*
@@ -33,7 +38,6 @@ import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
-import java.io.IOException
 
 class DetailsViewModel(
 	intent: MangaIntent,
@@ -91,8 +95,8 @@ class DetailsViewModel(
 			if (description.isNullOrEmpty()) {
 				emit(null)
 			} else {
-				emit(description.parseAsHtml())
+				emit(description.parseAsHtml().filterSpans())
-				emit(description.parseAsHtml(imageGetter = imageGetter))
+				emit(description.parseAsHtml(imageGetter = imageGetter).filterSpans())
 			}
 		}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default, null)
 
@@ -110,7 +114,7 @@ class DetailsViewModel(
 
 	val selectedBranchIndex = combine(
 		branches.asFlow(),
-		delegate.selectedBranch
+		delegate.selectedBranch,
 	) { branches, selected ->
 		branches.indexOf(selected)
 	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
@@ -225,7 +229,7 @@ class DetailsViewModel(
 	fun unregisterScrobbling() {
 		launchJob(Dispatchers.Default) {
 			scrobbler.unregisterScrobbling(
-				mangaId = delegate.mangaId
+				mangaId = delegate.mangaId,
 			)
 		}
 	}
@@ -242,4 +246,13 @@ class DetailsViewModel(
 			it.chapter.name.contains(query, ignoreCase = true)
 		}
 	}
+
+	private fun Spanned.filterSpans(): CharSequence {
+		val spannable = SpannableString.valueOf(this)
+		val spans = spannable.getSpans<ForegroundColorSpan>()
+		for (span in spans) {
+			spannable.removeSpan(span)
+		}
+		return spannable.trim()
+	}
 }

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

@@ -1,28 +1,22 @@
 package org.koitharu.kotatsu.details.ui
 
-import androidx.core.os.LocaleListCompat
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
-import org.acra.ACRA
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
 import org.koitharu.kotatsu.base.domain.MangaIntent
-import org.koitharu.kotatsu.core.exceptions.MangaNotFoundException
 import org.koitharu.kotatsu.core.model.MangaHistory
+import org.koitharu.kotatsu.core.model.getPreferredBranch
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem
 import org.koitharu.kotatsu.details.ui.model.toListItem
 import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
-import org.koitharu.kotatsu.parsers.exception.ParseException
+import org.koitharu.kotatsu.parsers.exception.NotFoundException
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.util.mapToSet
-import org.koitharu.kotatsu.parsers.util.toTitleCase
-import org.koitharu.kotatsu.utils.ext.iterator
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
-import org.koitharu.kotatsu.utils.ext.setCurrentManga
 
 class MangaDetailsDelegate(
 	private val intent: MangaIntent,
@@ -43,19 +37,12 @@ class MangaDetailsDelegate(
 	val mangaId = intent.manga?.id ?: intent.mangaId
 
 	suspend fun doLoad() {
-		var manga = mangaDataRepository.resolveIntent(intent)
+		var manga = mangaDataRepository.resolveIntent(intent) ?: throw NotFoundException("Cannot find manga", "")
-			?: throw MangaNotFoundException("Cannot find manga")
-		ACRA.setCurrentManga(manga)
 		mangaData.value = manga
 		manga = MangaRepository(manga.source).getDetails(manga)
 		// find default branch
 		val hist = historyRepository.getOne(manga)
-		selectedBranch.value = if (hist != null) {
+		selectedBranch.value = manga.getPreferredBranch(hist)
-			val currentChapter = manga.chapters?.find { it.id == hist.chapterId }
-			if (currentChapter != null) currentChapter.branch else predictBranch(manga.chapters)
-		} else {
-			predictBranch(manga.chapters)
-		}
 		mangaData.value = manga
 		relatedManga.value = runCatching {
 			if (manga.source == MangaSource.LOCAL) {
@@ -96,7 +83,7 @@ class MangaDetailsDelegate(
 		val dateFormat = settings.getDateFormat()
 		val currentIndex = chapters.indexOfFirst { it.id == currentId }
 		val firstNewIndex = chapters.size - newCount
-		val downloadedIds = downloadedChapters?.mapToSet { it.id }
+		val downloadedIds = downloadedChapters?.mapTo(HashSet(downloadedChapters.size)) { it.id }
 		for (i in chapters.indices) {
 			val chapter = chapters[i]
 			if (chapter.branch != branch) {
@@ -111,6 +98,9 @@ class MangaDetailsDelegate(
 				dateFormat = dateFormat,
 			)
 		}
+		if (result.size < chapters.size / 2) {
+			result.trimToSize()
+		}
 		return result
 	}
 
@@ -166,24 +156,9 @@ class MangaDetailsDelegate(
 			}
 			result.sortBy { it.chapter.number }
 		}
+		if (result.size < sourceChapters.size / 2) {
+			result.trimToSize()
+		}
 		return result
 	}
-
-	private fun predictBranch(chapters: List<MangaChapter>?): String? {
-		if (chapters.isNullOrEmpty()) {
-			return null
-		}
-		val groups = chapters.groupBy { it.branch }
-		for (locale in LocaleListCompat.getAdjustedDefault()) {
-			var language = locale.getDisplayLanguage(locale).toTitleCase(locale)
-			if (groups.containsKey(language)) {
-				return language
-			}
-			language = locale.getDisplayName(locale).toTitleCase(locale)
-			if (groups.containsKey(language)) {
-				return language
-			}
-		}
-		return groups.maxByOrNull { it.value.size }?.key
-	}
 }

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

@@ -1,13 +1,24 @@
 package org.koitharu.kotatsu.details.ui.model
 
+import java.text.DateFormat
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 
 class ChapterListItem(
 	val chapter: MangaChapter,
 	val flags: Int,
-	val uploadDate: String?,
+	private val uploadDateMs: Long,
+	private val dateFormat: DateFormat,
 ) {
 
+	var uploadDate: String? = null
+		private set
+		get() {
+			if (field != null) return field
+			if (uploadDateMs == 0L) return null
+			field = dateFormat.format(uploadDateMs)
+			return field
+		}
+
 	val status: Int
 		get() = flags and MASK_STATUS
 
@@ -32,7 +43,8 @@ class ChapterListItem(
 
 		if (chapter != other.chapter) return false
 		if (flags != other.flags) return false
-		if (uploadDate != other.uploadDate) return false
+		if (uploadDateMs != other.uploadDateMs) return false
+		if (dateFormat != other.dateFormat) return false
 
 		return true
 	}
@@ -40,7 +52,8 @@ class ChapterListItem(
 	override fun hashCode(): Int {
 		var result = chapter.hashCode()
 		result = 31 * result + flags
-		result = 31 * result + (uploadDate?.hashCode() ?: 0)
+		result = 31 * result + uploadDateMs.hashCode()
+		result = 31 * result + dateFormat.hashCode()
 		return result
 	}
 
@@ -53,4 +66,4 @@ class ChapterListItem(
 		const val FLAG_DOWNLOADED = 32
 		const val MASK_STATUS = FLAG_UNREAD or FLAG_CURRENT
 	}
-}
+}

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

@@ -1,12 +1,12 @@
 package org.koitharu.kotatsu.details.ui.model
 
+import java.text.DateFormat
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_CURRENT
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_DOWNLOADED
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_MISSING
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_NEW
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_UNREAD
 import org.koitharu.kotatsu.parsers.model.MangaChapter
-import java.text.DateFormat
 
 fun MangaChapter.toListItem(
 	isCurrent: Boolean,
@@ -25,6 +25,7 @@ fun MangaChapter.toListItem(
 	return ChapterListItem(
 		chapter = this,
 		flags = flags,
-		uploadDate = if (uploadDate != 0L) dateFormat.format(uploadDate) else null
+		uploadDateMs = uploadDate,
+		dateFormat = dateFormat,
 	)
 }

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

@@ -1,11 +1,11 @@
 package org.koitharu.kotatsu.download.domain
 
 import android.content.Context
-import android.net.ConnectivityManager
 import android.webkit.MimeTypeMap
 import coil.ImageLoader
 import coil.request.ImageRequest
 import coil.size.Scale
+import java.io.File
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.sync.Semaphore
@@ -16,6 +16,7 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.network.CommonHeaders
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.download.ui.service.PausingHandle
 import org.koitharu.kotatsu.local.data.PagesCache
 import org.koitharu.kotatsu.local.domain.CbzMangaOutput
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
@@ -25,11 +26,9 @@ import org.koitharu.kotatsu.parsers.util.await
 import org.koitharu.kotatsu.utils.ext.deleteAwait
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.referer
-import org.koitharu.kotatsu.utils.ext.waitForNetwork
+import org.koitharu.kotatsu.utils.progress.PausingProgressJob
-import org.koitharu.kotatsu.utils.progress.ProgressJob
-import java.io.File
 
-private const val MAX_DOWNLOAD_ATTEMPTS = 3
+private const val MAX_FAILSAFE_ATTEMPTS = 2
 private const val DOWNLOAD_ERROR_DELAY = 500L
 private const val SLOWDOWN_DELAY = 200L
 
@@ -43,9 +42,6 @@ class DownloadManager(
 	private val settings: AppSettings,
 ) {
 
-	private val connectivityManager = context.getSystemService(
-		Context.CONNECTIVITY_SERVICE
-	) as ConnectivityManager
 	private val coverWidth = context.resources.getDimensionPixelSize(
 		androidx.core.R.dimen.compat_notification_large_icon_max_width
 	)
@@ -58,21 +54,24 @@ class DownloadManager(
 		manga: Manga,
 		chaptersIds: LongArray?,
 		startId: Int,
-	): ProgressJob<DownloadState> {
+	): PausingProgressJob<DownloadState> {
 		val stateFlow = MutableStateFlow<DownloadState>(
 			DownloadState.Queued(startId = startId, manga = manga, cover = null)
 		)
-		val job = downloadMangaImpl(manga, chaptersIds?.takeUnless { it.isEmpty() }, stateFlow, startId)
+		val pausingHandle = PausingHandle()
-		return ProgressJob(job, stateFlow)
+		val job = downloadMangaImpl(manga, chaptersIds?.takeUnless { it.isEmpty() }, stateFlow, pausingHandle, startId)
+		return PausingProgressJob(job, stateFlow, pausingHandle)
 	}
 
 	private fun downloadMangaImpl(
 		manga: Manga,
 		chaptersIds: LongArray?,
 		outState: MutableStateFlow<DownloadState>,
+		pausingHandle: PausingHandle,
 		startId: Int,
 	): Job = coroutineScope.launch(Dispatchers.Default + errorStateHandler(outState)) {
-		@Suppress("NAME_SHADOWING") var manga = manga
+		@Suppress("NAME_SHADOWING")
+		var manga = manga
 		val chaptersIdsSet = chaptersIds?.toMutableSet()
 		val cover = loadCover(manga)
 		outState.value = DownloadState.Queued(startId, manga, cover)
@@ -108,38 +107,28 @@ class DownloadManager(
 				"${chaptersIdsSet?.size} of ${chaptersIds?.size} requested chapters not found in manga"
 			}
 			for ((chapterIndex, chapter) in chapters.withIndex()) {
-				val pages = repo.getPages(chapter)
+				val pages = runFailsafe(outState, pausingHandle) {
+					repo.getPages(chapter)
+				}
 				for ((pageIndex, page) in pages.withIndex()) {
-					var retryCounter = 0
+					runFailsafe(outState, pausingHandle) {
-					failsafe@ while (true) {
+						val url = repo.getPageUrl(page)
-						try {
+						val file = cache[url] ?: downloadFile(url, page.referer, destination, tempFileName)
-							val url = repo.getPageUrl(page)
+						output.addPage(
-							val file = cache[url] ?: downloadFile(url, page.referer, destination, tempFileName)
+							chapter = chapter,
-							output.addPage(
+							file = file,
-								chapter = chapter,
+							pageNumber = pageIndex,
-								file = file,
+							ext = MimeTypeMap.getFileExtensionFromUrl(url)
-								pageNumber = pageIndex,
+						)
-								ext = MimeTypeMap.getFileExtensionFromUrl(url),
-							)
-							break@failsafe
-						} catch (e: IOException) {
-							if (retryCounter < MAX_DOWNLOAD_ATTEMPTS) {
-								outState.value = DownloadState.WaitingForNetwork(startId, data, cover)
-								delay(DOWNLOAD_ERROR_DELAY)
-								connectivityManager.waitForNetwork()
-								retryCounter++
-							} else {
-								throw e
-							}
-						}
 					}
-
 					outState.value = DownloadState.Progress(
-						startId, data, cover,
+						startId = startId,
+						manga = data,
+						cover = cover,
 						totalChapters = chapters.size,
 						currentChapter = chapterIndex,
 						totalPages = pages.size,
-						currentPage = pageIndex,
+						currentPage = pageIndex
 					)
 
 					if (settings.isDownloadsSlowdownEnabled) {
@@ -157,15 +146,40 @@ class DownloadManager(
 			throw e
 		} catch (e: Throwable) {
 			e.printStackTraceDebug()
-			outState.value = DownloadState.Error(startId, manga, cover, e)
+			outState.value = DownloadState.Error(startId, manga, cover, e, false)
 		} finally {
 			withContext(NonCancellable) {
 				output?.cleanup()
 				File(destination, tempFileName).deleteAwait()
+				coroutineContext[WakeLockNode]?.release()
+				semaphore.release()
+				localMangaRepository.unlockManga(manga.id)
+			}
+		}
+	}
+
+	private suspend fun <R> runFailsafe(
+		outState: MutableStateFlow<DownloadState>,
+		pausingHandle: PausingHandle,
+		block: suspend () -> R,
+	): R {
+		var countDown = MAX_FAILSAFE_ATTEMPTS
+		failsafe@ while (true) {
+			try {
+				return block()
+			} catch (e: IOException) {
+				if (countDown <= 0) {
+					val state = outState.value
+					outState.value = DownloadState.Error(state.startId, state.manga, state.cover, e, true)
+					countDown = MAX_FAILSAFE_ATTEMPTS
+					pausingHandle.pause()
+					pausingHandle.awaitResumed()
+					outState.value = state
+				} else {
+					countDown--
+					delay(DOWNLOAD_ERROR_DELAY)
+				}
 			}
-			coroutineContext[WakeLockNode]?.release()
-			semaphore.release()
-			localMangaRepository.unlockManga(manga.id)
 		}
 	}
 
@@ -195,6 +209,7 @@ class DownloadManager(
 				manga = prevValue.manga,
 				cover = prevValue.cover,
 				error = throwable,
+				canRetry = false
 			)
 		}
 
@@ -225,7 +240,7 @@ class DownloadManager(
 			okHttp = okHttp,
 			cache = cache,
 			localMangaRepository = localMangaRepository,
-			settings = settings,
+			settings = settings
 		)
 	}
 }

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

@@ -108,6 +108,7 @@ sealed interface DownloadState {
 		}
 	}
 
+	@Deprecated("TODO: remove")
 	class WaitingForNetwork(
 		override val startId: Int,
 		override val manga: Manga,
@@ -170,6 +171,7 @@ sealed interface DownloadState {
 		override val manga: Manga,
 		override val cover: Drawable?,
 		val error: Throwable,
+		val canRetry: Boolean,
 	) : DownloadState {
 
 		override fun equals(other: Any?): Boolean {
@@ -182,6 +184,7 @@ sealed interface DownloadState {
 			if (manga != other.manga) return false
 			if (cover != other.cover) return false
 			if (error != other.error) return false
+			if (canRetry != other.canRetry) return false
 
 			return true
 		}
@@ -191,6 +194,7 @@ sealed interface DownloadState {
 			result = 31 * result + manga.hashCode()
 			result = 31 * result + (cover?.hashCode() ?: 0)
 			result = 31 * result + error.hashCode()
+			result = 31 * result + canRetry.hashCode()
 			return result
 		}
 	}

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

@@ -27,13 +27,14 @@ fun downloadItemAD(
 	bind {
 		job?.cancel()
 		job = item.progressAsFlow().onFirst { state ->
-			binding.imageViewCover.newImageRequest(state.manga.coverUrl)
+			binding.imageViewCover.newImageRequest(state.manga.coverUrl)?.run {
-				.referer(state.manga.publicUrl)
+				referer(state.manga.publicUrl)
-				.placeholder(state.cover)
+				placeholder(state.cover)
-				.fallback(R.drawable.ic_placeholder)
+				fallback(R.drawable.ic_placeholder)
-				.error(R.drawable.ic_placeholder)
+				error(R.drawable.ic_placeholder)
-				.allowRgb565(true)
+				allowRgb565(true)
-				.enqueueWith(coil)
+				enqueueWith(coil)
+			}
 		}.onEach { state ->
 			binding.textViewTitle.text = state.manga.title
 			when (state) {

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

@@ -29,16 +29,26 @@ class DownloadNotification(private val context: Context, startId: Int) {
 		context.getString(android.R.string.cancel),
 		PendingIntent.getBroadcast(
 			context,
-			startId,
+			startId * 2,
 			DownloadService.getCancelIntent(startId),
 			PendingIntent.FLAG_CANCEL_CURRENT or PendingIntentCompat.FLAG_IMMUTABLE
 		)
 	)
+	private val retryAction = NotificationCompat.Action(
+		R.drawable.ic_restart_black,
+		context.getString(R.string.try_again),
+		PendingIntent.getBroadcast(
+			context,
+			startId * 2 + 1,
+			DownloadService.getResumeIntent(startId),
+			PendingIntent.FLAG_CANCEL_CURRENT or PendingIntentCompat.FLAG_IMMUTABLE
+		)
+	)
 	private val listIntent = PendingIntent.getActivity(
 		context,
 		REQUEST_LIST,
 		DownloadsActivity.newIntent(context),
-		PendingIntentCompat.FLAG_IMMUTABLE,
+		PendingIntentCompat.FLAG_IMMUTABLE
 	)
 
 	init {
@@ -89,10 +99,14 @@ class DownloadNotification(private val context: Context, startId: Int) {
 				builder.setSmallIcon(android.R.drawable.stat_notify_error)
 				builder.setSubText(context.getString(R.string.error))
 				builder.setContentText(message)
-				builder.setAutoCancel(true)
+				builder.setAutoCancel(!state.canRetry)
-				builder.setOngoing(false)
+				builder.setOngoing(state.canRetry)
 				builder.setCategory(NotificationCompat.CATEGORY_ERROR)
 				builder.setStyle(NotificationCompat.BigTextStyle().bigText(message))
+				if (state.canRetry) {
+					builder.addAction(cancelAction)
+					builder.addAction(retryAction)
+				}
 			}
 			is DownloadState.PostProcessing -> {
 				builder.setProgress(1, 0, true)

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

@@ -11,6 +11,7 @@ import android.widget.Toast
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
@@ -28,16 +29,16 @@ import org.koitharu.kotatsu.download.domain.WakeLockNode
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.utils.ext.connectivityManager
 import org.koitharu.kotatsu.utils.ext.throttle
+import org.koitharu.kotatsu.utils.progress.PausingProgressJob
 import org.koitharu.kotatsu.utils.progress.ProgressJob
 import org.koitharu.kotatsu.utils.progress.TimeLeftEstimator
-import java.util.concurrent.TimeUnit
 
 class DownloadService : BaseService() {
 
 	private lateinit var downloadManager: DownloadManager
 	private lateinit var notificationSwitcher: ForegroundNotificationSwitcher
 
-	private val jobs = LinkedHashMap<Int, ProgressJob<DownloadState>>()
+	private val jobs = LinkedHashMap<Int, PausingProgressJob<DownloadState>>()
 	private val jobCount = MutableStateFlow(0)
 	private val controlReceiver = ControlReceiver()
 	private var binder: DownloadBinder? = null
@@ -49,10 +50,13 @@ class DownloadService : BaseService() {
 		val wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager)
 			.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "kotatsu:downloading")
 		downloadManager = get<DownloadManager.Factory>().create(
-			coroutineScope = lifecycleScope + WakeLockNode(wakeLock, TimeUnit.HOURS.toMillis(1)),
+			coroutineScope = lifecycleScope + WakeLockNode(wakeLock, TimeUnit.HOURS.toMillis(1))
 		)
 		DownloadNotification.createChannel(this)
-		registerReceiver(controlReceiver, IntentFilter(ACTION_DOWNLOAD_CANCEL))
+		val intentFilter = IntentFilter()
+		intentFilter.addAction(ACTION_DOWNLOAD_CANCEL)
+		intentFilter.addAction(ACTION_DOWNLOAD_RESUME)
+		registerReceiver(controlReceiver, intentFilter)
 	}
 
 	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
@@ -90,7 +94,7 @@ class DownloadService : BaseService() {
 		startId: Int,
 		manga: Manga,
 		chaptersIds: LongArray?,
-	): ProgressJob<DownloadState> {
+	): PausingProgressJob<DownloadState> {
 		val job = downloadManager.downloadManga(manga, chaptersIds, startId)
 		listenJob(job)
 		return job
@@ -144,7 +148,7 @@ class DownloadService : BaseService() {
 	}
 
 	private val DownloadState.isTerminal: Boolean
-		get() = this is DownloadState.Done || this is DownloadState.Error || this is DownloadState.Cancelled
+		get() = this is DownloadState.Done || this is DownloadState.Cancelled || (this is DownloadState.Error && !canRetry)
 
 	inner class ControlReceiver : BroadcastReceiver() {
 
@@ -155,6 +159,10 @@ class DownloadService : BaseService() {
 					jobs.remove(cancelId)?.cancel()
 					jobCount.value = jobs.size
 				}
+				ACTION_DOWNLOAD_RESUME -> {
+					val cancelId = intent.getIntExtra(EXTRA_CANCEL_ID, 0)
+					jobs[cancelId]?.resume()
+				}
 			}
 		}
 	}
@@ -173,6 +181,7 @@ class DownloadService : BaseService() {
 		const val ACTION_DOWNLOAD_COMPLETE = "${BuildConfig.APPLICATION_ID}.action.ACTION_DOWNLOAD_COMPLETE"
 
 		private const val ACTION_DOWNLOAD_CANCEL = "${BuildConfig.APPLICATION_ID}.action.ACTION_DOWNLOAD_CANCEL"
+		private const val ACTION_DOWNLOAD_RESUME = "${BuildConfig.APPLICATION_ID}.action.ACTION_DOWNLOAD_RESUME"
 
 		private const val EXTRA_MANGA = "manga"
 		private const val EXTRA_CHAPTERS_IDS = "chapters_ids"
@@ -219,6 +228,9 @@ class DownloadService : BaseService() {
 		fun getCancelIntent(startId: Int) = Intent(ACTION_DOWNLOAD_CANCEL)
 			.putExtra(EXTRA_CANCEL_ID, startId)
 
+		fun getResumeIntent(startId: Int) = Intent(ACTION_DOWNLOAD_RESUME)
+			.putExtra(EXTRA_CANCEL_ID, startId)
+
 		fun getDownloadedManga(intent: Intent?): Manga? {
 			if (intent?.action == ACTION_DOWNLOAD_COMPLETE) {
 				return intent.getParcelableExtra<ParcelableManga>(EXTRA_MANGA)?.manga

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

@@ -0,0 +1,30 @@
+package org.koitharu.kotatsu.download.ui.service
+
+import androidx.annotation.AnyThread
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.first
+
+class PausingHandle {
+
+	private val paused = MutableStateFlow(false)
+
+	@get:AnyThread
+	val isPaused: Boolean
+		get() = paused.value
+
+	@AnyThread
+	suspend fun awaitResumed() {
+		paused.filter { !it }.first()
+	}
+
+	@AnyThread
+	fun pause() {
+		paused.value = true
+	}
+
+	@AnyThread
+	fun resume() {
+		paused.value = false
+	}
+}

app/src/main/java/org/koitharu/kotatsu/favourites/data/FavouriteCategoryEntity.kt

@@ -3,9 +3,10 @@ package org.koitharu.kotatsu.favourites.data
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
+import org.koitharu.kotatsu.core.db.TABLE_FAVOURITE_CATEGORIES
 
-@Entity(tableName = "favourite_categories")
+@Entity(tableName = TABLE_FAVOURITE_CATEGORIES)
-class FavouriteCategoryEntity(
+data class FavouriteCategoryEntity(
 	@PrimaryKey(autoGenerate = true)
 	@ColumnInfo(name = "category_id") val categoryId: Int,
 	@ColumnInfo(name = "created_at") val createdAt: Long,

app/src/main/java/org/koitharu/kotatsu/favourites/data/FavouriteEntity.kt

@@ -3,10 +3,13 @@ package org.koitharu.kotatsu.favourites.data
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.ForeignKey
+import org.koitharu.kotatsu.core.db.TABLE_FAVOURITES
 import org.koitharu.kotatsu.core.db.entity.MangaEntity
 
 @Entity(
-	tableName = "favourites", primaryKeys = ["manga_id", "category_id"], foreignKeys = [
+	tableName = TABLE_FAVOURITES,
+	primaryKeys = ["manga_id", "category_id"],
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],
@@ -21,8 +24,8 @@ import org.koitharu.kotatsu.core.db.entity.MangaEntity
 		)
 	]
 )
-class FavouriteEntity(
+data class FavouriteEntity(
 	@ColumnInfo(name = "manga_id", index = true) val mangaId: Long,
 	@ColumnInfo(name = "category_id", index = true) val categoryId: Long,
-	@ColumnInfo(name = "created_at") val createdAt: Long
+	@ColumnInfo(name = "created_at") val createdAt: Long,
 )

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

@@ -148,7 +148,12 @@ class FavouritesContainerFragment :
 		menu.setOnMenuItemClickListener {
 			when (it.itemId) {
 				R.id.action_remove -> editDelegate.deleteCategory(category)
-				R.id.action_edit -> startActivity(FavouritesCategoryEditActivity.newIntent(tabView.context, category.id))
+				R.id.action_edit -> startActivity(
+					FavouritesCategoryEditActivity.newIntent(
+						tabView.context,
+						category.id
+					)
+				)
 				else -> return@setOnMenuItemClickListener false
 			}
 			true
@@ -172,7 +177,7 @@ class FavouritesContainerFragment :
 	private fun showStub() {
 		val stub = stubBinding ?: ItemEmptyStateBinding.bind(binding.stubEmptyState.inflate())
 		stub.root.isVisible = true
-		stub.icon.setImageResource(R.drawable.ic_heart_outline)
+		stub.icon.setImageResource(R.drawable.ic_empty_favourites)
 		stub.textPrimary.setText(R.string.text_empty_holder_primary)
 		stub.textSecondary.setText(R.string.empty_favourite_categories)
 		stub.buttonRetry.setText(R.string.add)

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

@@ -3,10 +3,13 @@ package org.koitharu.kotatsu.favourites.ui.categories.edit
 import android.content.Context
 import android.content.Intent
 import android.os.Bundle
+import android.text.Editable
+import android.text.TextWatcher
 import android.view.View
 import android.view.ViewGroup
 import android.widget.AdapterView
 import android.widget.ArrayAdapter
+import android.widget.Filter
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.core.view.updateLayoutParams
@@ -23,7 +26,7 @@ import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.utils.ext.getDisplayMessage
 
 class FavouritesCategoryEditActivity : BaseActivity<ActivityCategoryEditBinding>(), AdapterView.OnItemClickListener,
-	View.OnClickListener {
+	View.OnClickListener, TextWatcher {
 
 	private val viewModel by viewModel<FavouritesCategoryEditViewModel> {
 		parametersOf(intent.getLongExtra(EXTRA_ID, NO_ID))
@@ -39,6 +42,8 @@ class FavouritesCategoryEditActivity : BaseActivity<ActivityCategoryEditBinding>
 		}
 		initSortSpinner()
 		binding.buttonDone.setOnClickListener(this)
+		binding.editName.addTextChangedListener(this)
+		afterTextChanged(binding.editName.text)
 
 		viewModel.onSaved.observe(this) { finishAfterTransition() }
 		viewModel.category.observe(this, ::onCategoryChanged)
@@ -65,13 +70,21 @@ class FavouritesCategoryEditActivity : BaseActivity<ActivityCategoryEditBinding>
 	override fun onClick(v: View) {
 		when (v.id) {
 			R.id.button_done -> viewModel.save(
-				title = binding.editName.text?.toString().orEmpty(),
+				title = binding.editName.text?.toString()?.trim().orEmpty(),
 				sortOrder = getSelectedSortOrder(),
 				isTrackerEnabled = binding.switchTracker.isChecked,
 			)
 		}
 	}
 
+	override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit
+
+	override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = Unit
+
+	override fun afterTextChanged(s: Editable?) {
+		binding.buttonDone.isEnabled = !s.isNullOrBlank()
+	}
+
 	override fun onWindowInsetsChanged(insets: Insets) {
 		binding.scrollView.updatePadding(
 			left = insets.left,
@@ -115,7 +128,7 @@ class FavouritesCategoryEditActivity : BaseActivity<ActivityCategoryEditBinding>
 
 	private fun initSortSpinner() {
 		val entries = CategoriesActivity.SORT_ORDERS.map { getString(it.titleRes) }
-		val adapter = ArrayAdapter(this, android.R.layout.simple_spinner_dropdown_item, entries)
+		val adapter = SortAdapter(this, entries)
 		binding.editSort.setAdapter(adapter)
 		binding.editSort.onItemClickListener = this
 	}
@@ -127,6 +140,19 @@ class FavouritesCategoryEditActivity : BaseActivity<ActivityCategoryEditBinding>
 		return CategoriesActivity.SORT_ORDERS.getOrNull(index) ?: SortOrder.NEWEST
 	}
 
+	private class SortAdapter(
+		context: Context,
+		entries: List<String>,
+	) : ArrayAdapter<String>(context, android.R.layout.simple_spinner_dropdown_item, entries) {
+
+		override fun getFilter(): Filter = EmptyFilter
+
+		private object EmptyFilter : Filter() {
+			override fun performFiltering(constraint: CharSequence?) = FilterResults()
+			override fun publishResults(constraint: CharSequence?, results: FilterResults?) = Unit
+		}
+	}
+
 	companion object {
 
 		private const val EXTRA_ID = "id"

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

@@ -42,6 +42,7 @@ class FavouritesCategoryEditViewModel(
 		isTrackerEnabled: Boolean,
 	) {
 		launchLoadingJob {
+			check(title.isNotEmpty())
 			if (categoryId == NO_ID) {
 				repository.createCategory(title, sortOrder, isTrackerEnabled)
 			} else {

app/src/main/java/org/koitharu/kotatsu/favourites/ui/categories/select/FavouriteCategoriesBottomSheet.kt

@@ -2,9 +2,11 @@ package org.koitharu.kotatsu.favourites.ui.categories.select
 
 import android.os.Bundle
 import android.view.LayoutInflater
+import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
 import android.widget.Toast
+import androidx.appcompat.widget.Toolbar
 import androidx.fragment.app.FragmentManager
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import org.koin.core.parameter.parametersOf
@@ -26,7 +28,8 @@ class FavouriteCategoriesBottomSheet :
 	BaseBottomSheet<DialogFavoriteCategoriesBinding>(),
 	OnListItemClickListener<MangaCategoryItem>,
 	CategoriesEditDelegate.CategoriesEditCallback,
-	View.OnClickListener {
+	View.OnClickListener,
+	Toolbar.OnMenuItemClickListener {
 
 	private val viewModel by viewModel<MangaCategoriesViewModel> {
 		parametersOf(requireNotNull(arguments?.getParcelableArrayList<ParcelableManga>(KEY_MANGA_LIST)).map { it.manga })
@@ -44,7 +47,7 @@ class FavouriteCategoriesBottomSheet :
 		adapter = MangaCategoriesAdapter(this)
 		binding.recyclerViewCategories.adapter = adapter
 		binding.buttonDone.setOnClickListener(this)
-		binding.itemCreate.setOnClickListener(this)
+		binding.toolbar.setOnMenuItemClickListener(this)
 
 		viewModel.content.observe(viewLifecycleOwner, this::onContentChanged)
 		viewModel.onError.observe(viewLifecycleOwner, ::onError)
@@ -57,11 +60,18 @@ class FavouriteCategoriesBottomSheet :
 
 	override fun onClick(v: View) {
 		when (v.id) {
-			R.id.item_create -> startActivity(FavouritesCategoryEditActivity.newIntent(requireContext()))
 			R.id.button_done -> dismiss()
 		}
 	}
 
+	override fun onMenuItemClick(item: MenuItem): Boolean {
+		when (item.itemId) {
+			R.id.action_create -> startActivity(FavouritesCategoryEditActivity.newIntent(requireContext()))
+			else -> return false
+		}
+		return true
+	}
+
 	override fun onItemClick(item: MangaCategoryItem, view: View) {
 		viewModel.setChecked(item.id, !item.isChecked)
 	}

app/src/main/java/org/koitharu/kotatsu/history/HistoryModule.kt

@@ -10,5 +10,5 @@ val historyModule
 
 		single { HistoryRepository(get(), get(), get(), getAll()) }
 
-		viewModel { HistoryListViewModel(get(), get(), get(), get()) }
+		viewModel { HistoryListViewModel(get(), get(), get()) }
 	}

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

@@ -46,7 +46,7 @@ abstract class HistoryDao {
 	abstract fun observeCount(): Flow<Int>
 
 	@Query("SELECT percent FROM history WHERE manga_id = :id")
-	abstract fun findProgress(id: Long): Float?
+	abstract suspend fun findProgress(id: Long): Float?
 
 	@Query("DELETE FROM history")
 	abstract suspend fun clear()

app/src/main/java/org/koitharu/kotatsu/history/data/HistoryEntity.kt

@@ -4,10 +4,11 @@ import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
+import org.koitharu.kotatsu.core.db.TABLE_HISTORY
 import org.koitharu.kotatsu.core.db.entity.MangaEntity
 
 @Entity(
-	tableName = "history",
+	tableName = TABLE_HISTORY,
 	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
@@ -17,7 +18,7 @@ import org.koitharu.kotatsu.core.db.entity.MangaEntity
 		)
 	]
 )
-class HistoryEntity(
+data class HistoryEntity(
 	@PrimaryKey(autoGenerate = false)
 	@ColumnInfo(name = "manga_id") val mangaId: Long,
 	@ColumnInfo(name = "created_at") val createdAt: Long,

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

@@ -9,8 +9,6 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onStart
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.ReversibleHandle
-import org.koitharu.kotatsu.base.domain.plus
-import org.koitharu.kotatsu.core.os.ShortcutsRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.ListMode
 import org.koitharu.kotatsu.core.prefs.observeAsFlow
@@ -31,7 +29,6 @@ import java.util.concurrent.TimeUnit
 class HistoryListViewModel(
 	private val repository: HistoryRepository,
 	private val settings: AppSettings,
-	private val shortcutsRepository: ShortcutsRepository,
 	private val trackingRepository: TrackingRepository,
 ) : MangaListViewModel(settings) {
 
@@ -72,7 +69,6 @@ class HistoryListViewModel(
 	fun clearHistory() {
 		launchLoadingJob {
 			repository.clear()
-			shortcutsRepository.updateShortcuts()
 		}
 	}
 
@@ -81,10 +77,7 @@ class HistoryListViewModel(
 			return
 		}
 		launchJob(Dispatchers.Default) {
-			val handle = repository.deleteReversible(ids) + ReversibleHandle {
+			val handle = repository.deleteReversible(ids)
-				shortcutsRepository.updateShortcuts()
-			}
-			shortcutsRepository.updateShortcuts()
 			onItemsRemoved.postCall(handle)
 		}
 	}

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

@@ -68,7 +68,7 @@ abstract class MangaListFragment :
 
 	override fun onInflateView(
 		inflater: LayoutInflater,
-		container: ViewGroup?
+		container: ViewGroup?,
 	) = FragmentListBinding.inflate(inflater, container, false)
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
@@ -76,13 +76,13 @@ abstract class MangaListFragment :
 		listAdapter = MangaListAdapter(
 			coil = get(),
 			lifecycleOwner = viewLifecycleOwner,
-			listener = this,
+			listener = this
 		)
 		selectionController = ListSelectionController(
 			activity = requireActivity(),
 			decoration = MangaSelectionDecoration(view.context),
 			registryOwner = this,
-			callback = this,
+			callback = this
 		)
 		paginationListener = PaginationScrollListener(4, this)
 		with(binding.recyclerView) {
@@ -97,7 +97,7 @@ abstract class MangaListFragment :
 			setOnRefreshListener(this@MangaListFragment)
 			isEnabled = isSwipeRefreshEnabled
 		}
-		addMenuProvider(MangaListMenuProvider(childFragmentManager))
+		addMenuProvider(MangaListMenuProvider(this))
 
 		viewModel.listMode.observe(viewLifecycleOwner, ::onListModeChanged)
 		viewModel.gridScale.observe(viewLifecycleOwner, ::onGridScaleChanged)
@@ -171,21 +171,21 @@ abstract class MangaListFragment :
 		val headerHeight = (activity as? AppBarOwner)?.appBar?.measureHeight() ?: insets.top
 		binding.root.updatePadding(
 			left = insets.left,
-			right = insets.right,
+			right = insets.right
 		)
 		if (activity is MainActivity) {
 			binding.recyclerView.updatePadding(
 				top = headerHeight,
-				bottom = insets.bottom,
+				bottom = insets.bottom
 			)
 			binding.swipeRefreshLayout.setProgressViewOffset(
 				true,
 				headerHeight + resources.resolveDp(-72),
-				headerHeight + resources.resolveDp(10),
+				headerHeight + resources.resolveDp(10)
 			)
 		} else {
 			binding.recyclerView.updatePadding(
-				bottom = insets.bottom,
+				bottom = insets.bottom
 			)
 		}
 	}

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

@@ -4,11 +4,11 @@ import android.view.Menu
 import android.view.MenuInflater
 import android.view.MenuItem
 import androidx.core.view.MenuProvider
-import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.Fragment
 import org.koitharu.kotatsu.R
 
 class MangaListMenuProvider(
-	private val fragmentManager: FragmentManager,
+	private val fragment: Fragment,
 ) : MenuProvider {
 
 	override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
@@ -17,7 +17,7 @@ class MangaListMenuProvider(
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean = when (menuItem.itemId) {
 		R.id.action_list_mode -> {
-			ListModeSelectDialog.show(fragmentManager)
+			ListModeSelectDialog.show(fragment.childFragmentManager)
 			true
 		}
 		else -> false

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

@@ -3,9 +3,6 @@ package org.koitharu.kotatsu.list.ui.adapter
 import androidx.core.view.updateLayoutParams
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
-import coil.request.Disposable
-import coil.size.Scale
-import coil.util.CoilUtils
 import com.google.android.material.badge.BadgeDrawable
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
@@ -16,9 +13,11 @@ import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.MangaGridModel
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.search.ui.multi.adapter.ItemSizeResolver
+import org.koitharu.kotatsu.utils.ext.disposeImageRequest
 import org.koitharu.kotatsu.utils.ext.enqueueWith
 import org.koitharu.kotatsu.utils.ext.newImageRequest
 import org.koitharu.kotatsu.utils.ext.referer
+import org.koitharu.kotatsu.utils.image.CoverSizeResolver
 
 fun mangaGridItemAD(
 	coil: ImageLoader,
@@ -26,10 +25,8 @@ fun mangaGridItemAD(
 	clickListener: OnListItemClickListener<Manga>,
 	sizeResolver: ItemSizeResolver?,
 ) = adapterDelegateViewBinding<MangaGridModel, ListModel, ItemMangaGridBinding>(
-	{ inflater, parent -> ItemMangaGridBinding.inflate(inflater, parent, false) }
+	{ inflater, parent -> ItemMangaGridBinding.inflate(inflater, parent, false) },
 ) {
-
-	var imageRequest: Disposable? = null
 	var badge: BadgeDrawable? = null
 
 	itemView.setOnClickListener {
@@ -47,16 +44,16 @@ fun mangaGridItemAD(
 	bind { payloads ->
 		binding.textViewTitle.text = item.title
 		binding.progressView.setPercent(item.progress, MangaListAdapter.PAYLOAD_PROGRESS in payloads)
-		imageRequest?.dispose()
+		binding.imageViewCover.newImageRequest(item.coverUrl)?.run {
-		imageRequest = binding.imageViewCover.newImageRequest(item.coverUrl)
+			referer(item.manga.publicUrl)
-			.referer(item.manga.publicUrl)
+			size(CoverSizeResolver(binding.imageViewCover))
-			.placeholder(R.drawable.ic_placeholder)
+			placeholder(R.drawable.ic_placeholder)
-			.fallback(R.drawable.ic_placeholder)
+			fallback(R.drawable.ic_placeholder)
-			.error(R.drawable.ic_placeholder)
+			error(R.drawable.ic_placeholder)
-			.allowRgb565(true)
+			allowRgb565(true)
-			.scale(Scale.FILL)
+			lifecycle(lifecycleOwner)
-			.lifecycle(lifecycleOwner)
+			enqueueWith(coil)
-			.enqueueWith(coil)
+		}
 		badge = itemView.bindBadge(badge, item.counter)
 	}
 
@@ -64,9 +61,6 @@ fun mangaGridItemAD(
 		itemView.clearBadge(badge)
 		binding.progressView.percent = PROGRESS_NONE
 		badge = null
-		imageRequest?.dispose()
+		binding.imageViewCover.disposeImageRequest()
-		imageRequest = null
-		CoilUtils.dispose(binding.imageViewCover)
-		binding.imageViewCover.setImageDrawable(null)
 	}
 }

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

@@ -2,9 +2,6 @@ package org.koitharu.kotatsu.list.ui.adapter
 
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
-import coil.request.Disposable
-import coil.size.Scale
-import coil.util.CoilUtils
 import com.google.android.material.badge.BadgeDrawable
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
@@ -14,20 +11,16 @@ import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.MangaListDetailedModel
 import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.utils.ext.enqueueWith
+import org.koitharu.kotatsu.utils.ext.*
-import org.koitharu.kotatsu.utils.ext.newImageRequest
+import org.koitharu.kotatsu.utils.image.CoverSizeResolver
-import org.koitharu.kotatsu.utils.ext.referer
-import org.koitharu.kotatsu.utils.ext.textAndVisible
 
 fun mangaListDetailedItemAD(
 	coil: ImageLoader,
 	lifecycleOwner: LifecycleOwner,
 	clickListener: OnListItemClickListener<Manga>,
 ) = adapterDelegateViewBinding<MangaListDetailedModel, ListModel, ItemMangaListDetailsBinding>(
-	{ inflater, parent -> ItemMangaListDetailsBinding.inflate(inflater, parent, false) }
+	{ inflater, parent -> ItemMangaListDetailsBinding.inflate(inflater, parent, false) },
 ) {
-
-	var imageRequest: Disposable? = null
 	var badge: BadgeDrawable? = null
 
 	itemView.setOnClickListener {
@@ -38,19 +31,19 @@ fun mangaListDetailedItemAD(
 	}
 
 	bind { payloads ->
-		imageRequest?.dispose()
 		binding.textViewTitle.text = item.title
 		binding.textViewSubtitle.textAndVisible = item.subtitle
 		binding.progressView.setPercent(item.progress, MangaListAdapter.PAYLOAD_PROGRESS in payloads)
-		imageRequest = binding.imageViewCover.newImageRequest(item.coverUrl)
+		binding.imageViewCover.newImageRequest(item.coverUrl)?.run {
-			.referer(item.manga.publicUrl)
+			referer(item.manga.publicUrl)
-			.placeholder(R.drawable.ic_placeholder)
+			size(CoverSizeResolver(binding.imageViewCover))
-			.fallback(R.drawable.ic_placeholder)
+			placeholder(R.drawable.ic_placeholder)
-			.error(R.drawable.ic_placeholder)
+			fallback(R.drawable.ic_placeholder)
-			.scale(Scale.FILL)
+			error(R.drawable.ic_placeholder)
-			.allowRgb565(true)
+			allowRgb565(true)
-			.lifecycle(lifecycleOwner)
+			lifecycle(lifecycleOwner)
-			.enqueueWith(coil)
+			enqueueWith(coil)
+		}
 		binding.textViewRating.textAndVisible = item.rating
 		binding.textViewTags.text = item.tags
 		itemView.bindBadge(badge, item.counter)
@@ -60,9 +53,6 @@ fun mangaListDetailedItemAD(
 		itemView.clearBadge(badge)
 		binding.progressView.percent = PROGRESS_NONE
 		badge = null
-		imageRequest?.dispose()
+		binding.imageViewCover.disposeImageRequest()
-		imageRequest = null
-		CoilUtils.dispose(binding.imageViewCover)
-		binding.imageViewCover.setImageDrawable(null)
 	}
 }

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

@@ -2,9 +2,6 @@ package org.koitharu.kotatsu.list.ui.adapter
 
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
-import coil.request.Disposable
-import coil.size.Scale
-import coil.util.CoilUtils
 import com.google.android.material.badge.BadgeDrawable
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
@@ -13,20 +10,15 @@ import org.koitharu.kotatsu.databinding.ItemMangaListBinding
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.MangaListModel
 import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.utils.ext.enqueueWith
+import org.koitharu.kotatsu.utils.ext.*
-import org.koitharu.kotatsu.utils.ext.newImageRequest
-import org.koitharu.kotatsu.utils.ext.referer
-import org.koitharu.kotatsu.utils.ext.textAndVisible
 
 fun mangaListItemAD(
 	coil: ImageLoader,
 	lifecycleOwner: LifecycleOwner,
 	clickListener: OnListItemClickListener<Manga>,
 ) = adapterDelegateViewBinding<MangaListModel, ListModel, ItemMangaListBinding>(
-	{ inflater, parent -> ItemMangaListBinding.inflate(inflater, parent, false) }
+	{ inflater, parent -> ItemMangaListBinding.inflate(inflater, parent, false) },
 ) {
-
-	var imageRequest: Disposable? = null
 	var badge: BadgeDrawable? = null
 
 	itemView.setOnClickListener {
@@ -37,27 +29,23 @@ fun mangaListItemAD(
 	}
 
 	bind {
-		imageRequest?.dispose()
 		binding.textViewTitle.text = item.title
 		binding.textViewSubtitle.textAndVisible = item.subtitle
-		imageRequest = binding.imageViewCover.newImageRequest(item.coverUrl)
+		binding.imageViewCover.newImageRequest(item.coverUrl)?.run {
-			.referer(item.manga.publicUrl)
+			referer(item.manga.publicUrl)
-			.placeholder(R.drawable.ic_placeholder)
+			placeholder(R.drawable.ic_placeholder)
-			.fallback(R.drawable.ic_placeholder)
+			fallback(R.drawable.ic_placeholder)
-			.error(R.drawable.ic_placeholder)
+			error(R.drawable.ic_placeholder)
-			.scale(Scale.FILL)
+			allowRgb565(true)
-			.allowRgb565(true)
+			lifecycle(lifecycleOwner)
-			.lifecycle(lifecycleOwner)
+			enqueueWith(coil)
-			.enqueueWith(coil)
+		}
 		itemView.bindBadge(badge, item.counter)
 	}
 
 	onViewRecycled {
 		itemView.clearBadge(badge)
 		badge = null
-		imageRequest?.dispose()
+		binding.imageViewCover.disposeImageRequest()
-		imageRequest = null
-		CoilUtils.dispose(binding.imageViewCover)
-		binding.imageViewCover.setImageDrawable(null)
 	}
 }

app/src/main/java/org/koitharu/kotatsu/local/LocalModule.kt

@@ -16,5 +16,5 @@ val localModule
 
 		factory { DownloadManager.Factory(androidContext(), get(), get(), get(), get(), get()) }
 
-		viewModel { LocalListViewModel(get(), get(), get(), get()) }
+		viewModel { LocalListViewModel(get(), get(), get()) }
 	}

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

@@ -11,7 +11,6 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.os.ShortcutsRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.download.ui.service.DownloadService
 import org.koitharu.kotatsu.history.domain.HistoryRepository
@@ -29,7 +28,6 @@ class LocalListViewModel(
 	private val repository: LocalMangaRepository,
 	private val historyRepository: HistoryRepository,
 	settings: AppSettings,
-	private val shortcutsRepository: ShortcutsRepository,
 ) : MangaListViewModel(settings) {
 
 	val onMangaRemoved = SingleLiveEvent<Unit>()
@@ -107,7 +105,6 @@ class LocalListViewModel(
 					}
 				}
 			}
-			shortcutsRepository.updateShortcuts()
 			onMangaRemoved.call(Unit)
 		}
 	}

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

@@ -1,19 +1,29 @@
 package org.koitharu.kotatsu.main
 
+import android.app.Application
+import android.os.Build
+import androidx.room.InvalidationTracker
 import org.koin.android.ext.koin.androidContext
 import org.koin.androidx.viewmodel.dsl.viewModel
+import org.koin.dsl.bind
 import org.koin.dsl.module
 import org.koitharu.kotatsu.base.ui.util.ActivityRecreationHandle
-import org.koitharu.kotatsu.core.os.ShortcutsRepository
+import org.koitharu.kotatsu.core.os.ShortcutsUpdater
 import org.koitharu.kotatsu.main.ui.MainViewModel
 import org.koitharu.kotatsu.main.ui.protect.AppProtectHelper
 import org.koitharu.kotatsu.main.ui.protect.ProtectViewModel
 
 val mainModule
 	get() = module {
-		single { AppProtectHelper(get()) }
+		single { AppProtectHelper(get()) } bind Application.ActivityLifecycleCallbacks::class
-		single { ActivityRecreationHandle() }
+		single { ActivityRecreationHandle() } bind Application.ActivityLifecycleCallbacks::class
-		factory { ShortcutsRepository(androidContext(), get(), get(), get()) }
+
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
+			single { ShortcutsUpdater(androidContext(), get(), get(), get()) } bind InvalidationTracker.Observer::class
+		} else {
+			factory { ShortcutsUpdater(androidContext(), get(), get(), get()) }
+		}
+
 		viewModel { MainViewModel(get(), get()) }
 		viewModel { ProtectViewModel(get(), get()) }
 	}

app/src/main/java/org/koitharu/kotatsu/reader/ReaderModule.kt

@@ -14,7 +14,7 @@ val readerModule
 		factory { MangaDataRepository(get()) }
 		single { PagesCache(get()) }
 
-		factory { PageSaveHelper(get(), androidContext()) }
+		factory { PageSaveHelper(androidContext()) }
 
 		viewModel { params ->
 			ReaderViewModel(
@@ -23,10 +23,9 @@ val readerModule
 				preselectedBranch = params[2],
 				dataRepository = get(),
 				historyRepository = get(),
-				shortcutsRepository = get(),
 				settings = get(),
 				pageSaveHelper = get(),
-				bookmarksRepository = get(),
+				bookmarksRepository = get()
 			)
 		}
 	}

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

@@ -4,6 +4,10 @@ import android.content.Context
 import android.net.Uri
 import android.webkit.MimeTypeMap
 import androidx.activity.result.ActivityResultLauncher
+import androidx.core.net.toUri
+import java.io.File
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.resume
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.suspendCancellableCoroutine
@@ -11,19 +15,14 @@ import kotlinx.coroutines.withContext
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okio.IOException
 import org.koitharu.kotatsu.base.domain.MangaUtils
-import org.koitharu.kotatsu.local.data.PagesCache
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.parsers.util.toFileNameSafe
 import org.koitharu.kotatsu.reader.domain.PageLoader
-import java.io.File
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.resume
 
 private const val MAX_FILENAME_LENGTH = 10
 private const val EXTENSION_FALLBACK = "png"
 
 class PageSaveHelper(
-	private val cache: PagesCache,
 	context: Context,
 ) {
 
@@ -61,7 +60,11 @@ class PageSaveHelper(
 	} != null
 
 	private suspend fun getProposedFileName(url: String, file: File): String {
-		var name = url.toHttpUrl().pathSegments.last()
+		var name = if (url.startsWith("cbz://")) {
+			requireNotNull(url.toUri().fragment)
+		} else {
+			url.toHttpUrl().pathSegments.last()
+		}
 		var extension = name.substringAfterLast('.', "")
 		name = name.substringBeforeLast('.')
 		if (extension.length !in 2..4) {

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

@@ -24,7 +24,6 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import org.acra.ktx.sendWithAcra
 import org.koin.android.ext.android.get
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import org.koin.core.parameter.parametersOf
@@ -47,10 +46,7 @@ import org.koitharu.kotatsu.settings.SettingsActivity
 import org.koitharu.kotatsu.utils.GridTouchHelper
 import org.koitharu.kotatsu.utils.ScreenOrientationHelper
 import org.koitharu.kotatsu.utils.ShareHelper
-import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.*
-import org.koitharu.kotatsu.utils.ext.hasGlobalPoint
-import org.koitharu.kotatsu.utils.ext.observeWithPrevious
-import org.koitharu.kotatsu.utils.ext.postDelayed
 import java.util.concurrent.TimeUnit
 
 class ReaderActivity :
@@ -170,10 +166,9 @@ class ReaderActivity :
 				}
 			}
 			R.id.action_save_page -> {
-				viewModel.getCurrentPage()?.also { page ->
+				viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
-					viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
+				val page = viewModel.getCurrentPage() ?: return false
-					viewModel.saveCurrentPage(page, savePageRequest)
+				viewModel.saveCurrentPage(page, savePageRequest)
-				} ?: return false
 			}
 			R.id.action_bookmark -> {
 				if (viewModel.isBookmarkAdded.value == true) {
@@ -350,14 +345,14 @@ class ReaderActivity :
 		menuItem.setIcon(if (isAdded) R.drawable.ic_bookmark_added else R.drawable.ic_bookmark)
 	}
 
-	private fun onUiStateChanged(uiState: ReaderUiState, previous: ReaderUiState?) {
+	private fun onUiStateChanged(uiState: ReaderUiState?, previous: ReaderUiState?) {
-		title = uiState.chapterName ?: uiState.mangaName ?: getString(R.string.loading_)
+		title = uiState?.chapterName ?: uiState?.mangaName ?: getString(R.string.loading_)
-		supportActionBar?.subtitle = if (uiState.chapterNumber in 1..uiState.chaptersTotal) {
+		supportActionBar?.subtitle = if (uiState != null && uiState.chapterNumber in 1..uiState.chaptersTotal) {
 			getString(R.string.chapter_d_of_d, uiState.chapterNumber, uiState.chaptersTotal)
 		} else {
 			null
 		}
-		if (previous?.chapterName != null && uiState.chapterName != previous.chapterName) {
+		if (uiState != null && previous?.chapterName != null && uiState.chapterName != previous.chapterName) {
 			if (!uiState.chapterName.isNullOrEmpty()) {
 				binding.toastView.showTemporary(uiState.chapterName, TOAST_DURATION)
 			}
@@ -374,7 +369,7 @@ class ReaderActivity :
 				if (ExceptionResolver.canResolve(exception)) {
 					tryResolve(exception)
 				} else {
-					exception.sendWithAcra()
+					exception.report("ReaderActivity::onError")
 				}
 			} else {
 				onCancel(dialog)

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

@@ -8,7 +8,6 @@ import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
-import org.acra.ACRA
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
 import org.koitharu.kotatsu.base.domain.MangaIntent
@@ -16,12 +15,11 @@ import org.koitharu.kotatsu.base.domain.MangaUtils
 import org.koitharu.kotatsu.base.ui.BaseViewModel
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.bookmarks.domain.BookmarksRepository
-import org.koitharu.kotatsu.core.exceptions.MangaNotFoundException
-import org.koitharu.kotatsu.core.os.ShortcutsRepository
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.*
 import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
+import org.koitharu.kotatsu.parsers.exception.NotFoundException
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.parsers.model.MangaPage
@@ -33,7 +31,6 @@ import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.processLifecycleScope
-import org.koitharu.kotatsu.utils.ext.setCurrentManga
 import java.util.*
 
 private const val BOUNDS_PAGE_OFFSET = 2
@@ -46,7 +43,6 @@ class ReaderViewModel(
 	private val preselectedBranch: String?,
 	private val dataRepository: MangaDataRepository,
 	private val historyRepository: HistoryRepository,
-	private val shortcutsRepository: ShortcutsRepository,
 	private val bookmarksRepository: BookmarksRepository,
 	private val settings: AppSettings,
 	private val pageSaveHelper: PageSaveHelper,
@@ -75,7 +71,7 @@ class ReaderViewModel(
 			chapterNumber = chapter?.number ?: 0,
 			chaptersTotal = chapters.size()
 		)
-	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
+	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default, null)
 
 	val content = MutableLiveData(ReaderContent(emptyList(), null))
 	val manga: Manga?
@@ -93,7 +89,7 @@ class ReaderViewModel(
 	) { manga, policy ->
 		policy == ScreenshotsPolicy.BLOCK_ALL ||
 			(policy == ScreenshotsPolicy.BLOCK_NSFW && manga != null && manga.isNsfw)
-	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
+	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default, false)
 
 	val onZoomChanged = SingleLiveEvent<Unit>()
 
@@ -105,7 +101,7 @@ class ReaderViewModel(
 			bookmarksRepository.observeBookmark(manga, state.chapterId, state.page)
 				.map { it != null }
 		}
-	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
+	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default, false)
 
 	init {
 		loadImpl()
@@ -263,8 +259,7 @@ class ReaderViewModel(
 
 	private fun loadImpl() {
 		loadingJob = launchLoadingJob(Dispatchers.Default) {
-			var manga = dataRepository.resolveIntent(intent) ?: throw MangaNotFoundException("Cannot find manga")
+			var manga = dataRepository.resolveIntent(intent) ?: throw NotFoundException("Cannot find manga", "")
-			ACRA.setCurrentManga(manga)
 			mangaData.value = manga
 			val repo = MangaRepository(manga.source)
 			manga = repo.getDetails(manga)
@@ -289,7 +284,6 @@ class ReaderViewModel(
 			currentState.value?.let {
 				val percent = computePercent(it.chapterId, it.page)
 				historyRepository.addOrUpdate(manga, it.chapterId, it.page, it.scroll, percent)
-				shortcutsRepository.updateShortcuts()
 			}
 
 			content.postValue(ReaderContent(pages, currentState.value))

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

@@ -7,6 +7,8 @@ import android.view.View
 import androidx.core.view.isVisible
 import com.davemorrissey.labs.subscaleview.ImageSource
 import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.asExecutor
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.model.ZoomMode
@@ -26,6 +28,8 @@ open class PageHolder(
 	View.OnClickListener {
 
 	init {
+		binding.ssiv.setExecutor(Dispatchers.Default.asExecutor())
+		binding.ssiv.setEagerLoadingEnabled(!isLowRamDevice(context))
 		binding.ssiv.setOnImageEventListener(delegate)
 		@Suppress("LeakingThis")
 		bindingInfo.buttonRetry.setOnClickListener(this)

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

@@ -3,13 +3,16 @@ package org.koitharu.kotatsu.reader.ui.pager.webtoon
 import android.content.Context
 import android.util.AttributeSet
 import android.widget.FrameLayout
+import androidx.annotation.AttrRes
 import org.koitharu.kotatsu.R
 
 class WebtoonFrameLayout @JvmOverloads constructor(
-	context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
+	context: Context,
+	attrs: AttributeSet? = null,
+	@AttrRes defStyleAttr: Int = 0,
 ) : FrameLayout(context, attrs, defStyleAttr) {
 
-	private val target by lazy {
+	private val target by lazy(LazyThreadSafetyMode.NONE) {
 		findViewById<WebtoonImageView>(R.id.ssiv)
 	}
 

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

@@ -13,14 +13,14 @@ import org.koitharu.kotatsu.databinding.ItemPageWebtoonBinding
 import org.koitharu.kotatsu.reader.domain.PageLoader
 import org.koitharu.kotatsu.reader.ui.pager.BasePageHolder
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
+import org.koitharu.kotatsu.utils.GoneOnInvisibleListener
 import org.koitharu.kotatsu.utils.ext.*
 
-
 class WebtoonHolder(
 	binding: ItemPageWebtoonBinding,
 	loader: PageLoader,
 	settings: AppSettings,
-	exceptionResolver: ExceptionResolver
+	exceptionResolver: ExceptionResolver,
 ) : BasePageHolder<ItemPageWebtoonBinding>(binding, loader, settings, exceptionResolver),
 	View.OnClickListener {
 
@@ -29,6 +29,7 @@ class WebtoonHolder(
 	init {
 		binding.ssiv.setOnImageEventListener(delegate)
 		bindingInfo.buttonRetry.setOnClickListener(this)
+		GoneOnInvisibleListener(bindingInfo.progressBar).attach()
 	}
 
 	override fun onBind(data: ReaderPage) {
@@ -61,9 +62,9 @@ class WebtoonHolder(
 
 	override fun onImageShowing(zoom: ZoomMode) {
 		with(binding.ssiv) {
-			maxScale = 2f * width / sWidth.toFloat()
 			setMinimumScaleType(SubsamplingScaleImageView.SCALE_TYPE_CUSTOM)
 			minScale = width / sWidth.toFloat()
+			maxScale = minScale
 			scrollTo(
 				when {
 					scrollToRestore != 0 -> scrollToRestore

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

@@ -1,11 +1,15 @@
 package org.koitharu.kotatsu.reader.ui.pager.webtoon
 
-import android.app.Activity
 import android.content.Context
 import android.graphics.PointF
 import android.util.AttributeSet
+import androidx.recyclerview.widget.RecyclerView
 import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.asExecutor
 import org.koitharu.kotatsu.parsers.util.toIntUp
+import org.koitharu.kotatsu.utils.ext.isLowRamDevice
+import org.koitharu.kotatsu.utils.ext.parents
 
 private const val SCROLL_UNKNOWN = -1
 
@@ -15,15 +19,15 @@ class WebtoonImageView @JvmOverloads constructor(
 ) : SubsamplingScaleImageView(context, attr) {
 
 	private val ct = PointF()
-	private val displayHeight = if (context is Activity) {
-		context.window.decorView.height
-	} else {
-		context.resources.displayMetrics.heightPixels
-	}
 
 	private var scrollPos = 0
 	private var scrollRange = SCROLL_UNKNOWN
 
+	init {
+		setExecutor(Dispatchers.Default.asExecutor())
+		setEagerLoadingEnabled(!isLowRamDevice(context))
+	}
+
 	fun scrollBy(delta: Int) {
 		val maxScroll = getScrollRange()
 		if (maxScroll == 0) {
@@ -36,6 +40,7 @@ class WebtoonImageView @JvmOverloads constructor(
 	fun scrollTo(y: Int) {
 		val maxScroll = getScrollRange()
 		if (maxScroll == 0) {
+			resetScaleAndCenter()
 			return
 		}
 		scrollToInternal(y.coerceIn(0, maxScroll))
@@ -58,8 +63,11 @@ class WebtoonImageView @JvmOverloads constructor(
 
 	override fun getSuggestedMinimumHeight(): Int {
 		var desiredHeight = super.getSuggestedMinimumHeight()
-		if (sHeight == 0 && desiredHeight < displayHeight) {
+		if (sHeight == 0) {
-			desiredHeight = displayHeight
+			val parentHeight = parentHeight()
+			if (desiredHeight < parentHeight) {
+				desiredHeight = parentHeight
+			}
 		}
 		return desiredHeight
 	}
@@ -84,7 +92,7 @@ class WebtoonImageView @JvmOverloads constructor(
 			}
 		}
 		width = width.coerceAtLeast(suggestedMinimumWidth)
-		height = height.coerceIn(suggestedMinimumHeight, displayHeight)
+		height = height.coerceIn(suggestedMinimumHeight, parentHeight())
 		setMeasuredDimension(width, height)
 	}
 
@@ -101,4 +109,8 @@ class WebtoonImageView @JvmOverloads constructor(
 		val totalHeight = (sHeight * minScale).toIntUp()
 		scrollRange = (totalHeight - height).coerceAtLeast(0)
 	}
+
+	private fun parentHeight(): Int {
+		return parents.firstNotNullOfOrNull { it as? RecyclerView }?.height ?: 0
+	}
 }

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

@@ -0,0 +1,42 @@
+package org.koitharu.kotatsu.reader.ui.pager.webtoon
+
+import android.content.Context
+import android.util.AttributeSet
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import kotlin.math.sign
+
+@Suppress("unused")
+class WebtoonLayoutManager : LinearLayoutManager {
+
+	private var scrollDirection: Int = 0
+
+	constructor(context: Context) : super(context)
+	constructor(
+		context: Context,
+		orientation: Int,
+		reverseLayout: Boolean,
+	) : super(context, orientation, reverseLayout)
+
+	constructor(
+		context: Context,
+		attrs: AttributeSet?,
+		defStyleAttr: Int,
+		defStyleRes: Int,
+	) : super(context, attrs, defStyleAttr, defStyleRes)
+
+	override fun scrollVerticallyBy(dy: Int, recycler: RecyclerView.Recycler?, state: RecyclerView.State): Int {
+		scrollDirection = dy.sign
+		return super.scrollVerticallyBy(dy, recycler, state)
+	}
+
+	override fun calculateExtraLayoutSpace(state: RecyclerView.State, extraLayoutSpace: IntArray) {
+		if (state.hasTargetScrollPosition()) {
+			super.calculateExtraLayoutSpace(state, extraLayoutSpace)
+			return
+		}
+		val pageSize = height
+		extraLayoutSpace[0] = if (scrollDirection < 0) pageSize else 0
+		extraLayoutSpace[1] = if (scrollDirection < 0) 0 else pageSize
+	}
+}

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

@@ -12,7 +12,6 @@ import org.koitharu.kotatsu.reader.ui.ReaderState
 import org.koitharu.kotatsu.reader.ui.pager.BaseReader
 import org.koitharu.kotatsu.reader.ui.pager.BaseReaderAdapter
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
-import org.koitharu.kotatsu.utils.ext.doOnCurrentItemChanged
 import org.koitharu.kotatsu.utils.ext.findCenterViewPosition
 import org.koitharu.kotatsu.utils.ext.firstVisibleItemPosition
 import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
@@ -24,7 +23,7 @@ class WebtoonReaderFragment : BaseReader<FragmentReaderWebtoonBinding>() {
 
 	override fun onInflateView(
 		inflater: LayoutInflater,
-		container: ViewGroup?
+		container: ViewGroup?,
 	) = FragmentReaderWebtoonBinding.inflate(inflater, container, false)
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
@@ -33,7 +32,7 @@ class WebtoonReaderFragment : BaseReader<FragmentReaderWebtoonBinding>() {
 		with(binding.recyclerView) {
 			setHasFixedSize(true)
 			adapter = webtoonAdapter
-			doOnCurrentItemChanged(::notifyPageChanged)
+			addOnPageScrollListener(PageScrollListener())
 		}
 	}
 
@@ -93,4 +92,12 @@ class WebtoonReaderFragment : BaseReader<FragmentReaderWebtoonBinding>() {
 	override fun switchPageTo(position: Int, smooth: Boolean) {
 		binding.recyclerView.firstVisibleItemPosition = position
 	}
+
+	private inner class PageScrollListener : WebtoonRecyclerView.OnPageScrollListener() {
+
+		override fun onPageChanged(recyclerView: WebtoonRecyclerView, index: Int) {
+			super.onPageChanged(recyclerView, index)
+			notifyPageChanged(index)
+		}
+	}
 }

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

@@ -2,25 +2,27 @@ package org.koitharu.kotatsu.reader.ui.pager.webtoon
 
 import android.content.Context
 import android.util.AttributeSet
-import androidx.core.view.ViewCompat
+import androidx.core.view.ViewCompat.TYPE_TOUCH
 import androidx.recyclerview.widget.RecyclerView
+import org.koitharu.kotatsu.utils.ext.findCenterViewPosition
+import java.util.*
 
 class WebtoonRecyclerView @JvmOverloads constructor(
 	context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
 ) : RecyclerView(context, attrs, defStyleAttr) {
 
-	override fun startNestedScroll(axes: Int) = startNestedScroll(axes, ViewCompat.TYPE_TOUCH)
+	private var onPageScrollListeners: MutableList<OnPageScrollListener>? = null
 
-	override fun startNestedScroll(axes: Int, type: Int): Boolean {
+	override fun startNestedScroll(axes: Int) = startNestedScroll(axes, TYPE_TOUCH)
-		return true
+
-	}
+	override fun startNestedScroll(axes: Int, type: Int): Boolean = true
 
 	override fun dispatchNestedPreScroll(
 		dx: Int,
 		dy: Int,
 		consumed: IntArray?,
 		offsetInWindow: IntArray?
-	) = dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, ViewCompat.TYPE_TOUCH)
+	) = dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, TYPE_TOUCH)
 
 	override fun dispatchNestedPreScroll(
 		dx: Int,
@@ -34,6 +36,7 @@ class WebtoonRecyclerView @JvmOverloads constructor(
 			consumed[0] = 0
 			consumed[1] = consumedY
 		}
+		notifyScrollChanged(dy)
 		return consumedY != 0 || dy == 0
 	}
 
@@ -75,4 +78,39 @@ class WebtoonRecyclerView @JvmOverloads constructor(
 		}
 		return 0
 	}
+
+	fun addOnPageScrollListener(listener: OnPageScrollListener) {
+		val list = onPageScrollListeners ?: LinkedList<OnPageScrollListener>().also { onPageScrollListeners = it }
+		list.add(listener)
+	}
+
+	fun removeOnPageScrollListener(listener: OnPageScrollListener) {
+		onPageScrollListeners?.remove(listener)
+	}
+
+	private fun notifyScrollChanged(dy: Int) {
+		val listeners = onPageScrollListeners
+		if (listeners.isNullOrEmpty()) {
+			return
+		}
+		val centerPosition = findCenterViewPosition()
+		listeners.forEach { it.dispatchScroll(this, dy, centerPosition) }
+	}
+
+	abstract class OnPageScrollListener {
+
+		private var lastPosition = NO_POSITION
+
+		fun dispatchScroll(recyclerView: WebtoonRecyclerView, dy: Int, centerPosition: Int) {
+			onScroll(recyclerView, dy)
+			if (centerPosition != NO_POSITION && centerPosition != lastPosition) {
+				lastPosition = centerPosition
+				onPageChanged(recyclerView, centerPosition)
+			}
+		}
+
+		open fun onScroll(recyclerView: WebtoonRecyclerView, dy: Int) = Unit
+
+		open fun onPageChanged(recyclerView: WebtoonRecyclerView, index: Int) = Unit
+	}
 }

app/src/main/java/org/koitharu/kotatsu/reader/ui/thumbnails/adapter/PageThumbnailAD.kt

@@ -3,6 +3,7 @@ package org.koitharu.kotatsu.reader.ui.thumbnails.adapter
 import android.graphics.drawable.Drawable
 import coil.ImageLoader
 import coil.request.ImageRequest
+import coil.size.Scale
 import coil.size.Size
 import com.google.android.material.R as materialR
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
@@ -24,7 +25,6 @@ fun pageThumbnailAD(
 ) = adapterDelegateViewBinding<PageThumbnail, PageThumbnail, ItemPageThumbBinding>(
 	{ inflater, parent -> ItemPageThumbBinding.inflate(inflater, parent, false) }
 ) {
-
 	var job: Job? = null
 	val gridWidth = itemView.context.resources.getDimensionPixelSize(R.dimen.preferred_grid_width)
 	val thumbSize = Size(
@@ -39,6 +39,7 @@ fun pageThumbnailAD(
 					.data(url)
 					.referer(item.page.referer)
 					.size(thumbSize)
+					.scale(Scale.FILL)
 					.allowRgb565(true)
 					.build()
 			).drawable

app/src/main/java/org/koitharu/kotatsu/scrobbling/ui/selector/adapter/ShikimoriMangaAD.kt

@@ -2,15 +2,13 @@ package org.koitharu.kotatsu.scrobbling.ui.selector.adapter
 
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
-import coil.request.Disposable
-import coil.size.Scale
-import coil.util.CoilUtils
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.databinding.ItemMangaListBinding
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblerManga
+import org.koitharu.kotatsu.utils.ext.disposeImageRequest
 import org.koitharu.kotatsu.utils.ext.enqueueWith
 import org.koitharu.kotatsu.utils.ext.newImageRequest
 import org.koitharu.kotatsu.utils.ext.textAndVisible
@@ -23,30 +21,24 @@ fun shikimoriMangaAD(
 	{ inflater, parent -> ItemMangaListBinding.inflate(inflater, parent, false) }
 ) {
 
-	var imageRequest: Disposable? = null
-
 	itemView.setOnClickListener {
 		clickListener.onItemClick(item, it)
 	}
 
 	bind {
-		imageRequest?.dispose()
 		binding.textViewTitle.text = item.name
 		binding.textViewSubtitle.textAndVisible = item.altName
-		imageRequest = binding.imageViewCover.newImageRequest(item.cover)
+		binding.imageViewCover.newImageRequest(item.cover)?.run {
-			.placeholder(R.drawable.ic_placeholder)
+			placeholder(R.drawable.ic_placeholder)
-			.fallback(R.drawable.ic_placeholder)
+			fallback(R.drawable.ic_placeholder)
-			.error(R.drawable.ic_placeholder)
+			error(R.drawable.ic_placeholder)
-			.scale(Scale.FILL)
+			allowRgb565(true)
-			.allowRgb565(true)
+			lifecycle(lifecycleOwner)
-			.lifecycle(lifecycleOwner)
+			enqueueWith(coil)
-			.enqueueWith(coil)
+		}
 	}
 
 	onViewRecycled {
-		imageRequest?.dispose()
+		binding.imageViewCover.disposeImageRequest()
-		imageRequest = null
-		CoilUtils.dispose(binding.imageViewCover)
-		binding.imageViewCover.setImageDrawable(null)
 	}
 }

app/src/main/java/org/koitharu/kotatsu/search/ui/multi/MultiSearchViewModel.kt

@@ -89,26 +89,25 @@ class MultiSearchViewModel(
 		}
 	}
 
-	private suspend fun searchImpl(q: String) {
+	private suspend fun searchImpl(q: String) = coroutineScope {
 		val sources = settings.getMangaSources(includeHidden = false)
 		val dispatcher = Dispatchers.Default.limitedParallelism(MAX_PARALLELISM)
-		val deferredList = coroutineScope {
+		val deferredList = sources.map { source ->
-			sources.map { source ->
+			async(dispatcher) {
-				async(dispatcher) {
+				runCatching {
-					runCatching {
+					val list = MangaRepository(source).getList(offset = 0, query = q)
-						val list = MangaRepository(source).getList(offset = 0, query = q)
+						.toUi(ListMode.GRID)
-							.toUi(ListMode.GRID)
+					if (list.isNotEmpty()) {
-						if (list.isNotEmpty()) {
+						MultiSearchListModel(source, list.size > MIN_HAS_MORE_ITEMS, list)
-							MultiSearchListModel(source, list.size > MIN_HAS_MORE_ITEMS, list)
+					} else {
-						} else {
+						null
-							null
-						}
-					}.onFailure {
-						it.printStackTraceDebug()
 					}
+				}.onFailure {
+					it.printStackTraceDebug()
 				}
 			}
 		}
+
 		val errors = ArrayList<Throwable>()
 		for (deferred in deferredList) {
 			deferred.await()
@@ -120,13 +119,12 @@ class MultiSearchViewModel(
 					errors.add(it)
 				}
 		}
-		if (listData.value.isNotEmpty()) {
+		if (listData.value.isEmpty()) {
-			return
+			when (errors.size) {
-		}
+				0 -> Unit
-		when (errors.size) {
+				1 -> throw errors[0]
-			0 -> Unit
+				else -> throw CompositeException(errors)
-			1 -> throw errors[0]
+			}
-			else -> throw CompositeException(errors)
 		}
 	}
 }

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

@@ -5,7 +5,6 @@ import androidx.lifecycle.LifecycleOwner
 import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.RecyclerView
 import coil.ImageLoader
-import coil.request.Disposable
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegate
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
@@ -16,6 +15,7 @@ import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.search.ui.suggestion.SearchSuggestionListener
 import org.koitharu.kotatsu.search.ui.suggestion.model.SearchSuggestionItem
 import org.koitharu.kotatsu.utils.RecyclerViewScrollCallback
+import org.koitharu.kotatsu.utils.ext.disposeImageRequest
 import org.koitharu.kotatsu.utils.ext.enqueueWith
 import org.koitharu.kotatsu.utils.ext.newImageRequest
 
@@ -52,27 +52,24 @@ private fun searchSuggestionMangaGridAD(
 	{ layoutInflater, parent -> ItemSearchSuggestionMangaGridBinding.inflate(layoutInflater, parent, false) }
 ) {
 
-	var imageRequest: Disposable? = null
-
 	itemView.setOnClickListener {
 		listener.onMangaClick(item)
 	}
 
 	bind {
-		imageRequest?.dispose()
+		binding.imageViewCover.newImageRequest(item.coverUrl)?.run {
-		imageRequest = binding.imageViewCover.newImageRequest(item.coverUrl)
+			placeholder(R.drawable.ic_placeholder)
-			.placeholder(R.drawable.ic_placeholder)
+			fallback(R.drawable.ic_placeholder)
-			.fallback(R.drawable.ic_placeholder)
+			error(R.drawable.ic_placeholder)
-			.error(R.drawable.ic_placeholder)
+			allowRgb565(true)
-			.allowRgb565(true)
+			lifecycle(lifecycleOwner)
-			.lifecycle(lifecycleOwner)
+			enqueueWith(coil)
-			.enqueueWith(coil)
+		}
 		binding.textViewTitle.text = item.title
 	}
 
 	onViewRecycled {
-		imageRequest?.dispose()
+		binding.imageViewCover.disposeImageRequest()
-		binding.imageViewCover.setImageDrawable(null)
 	}
 }
 

app/src/main/java/org/koitharu/kotatsu/settings/AppUpdateChecker.kt

@@ -4,9 +4,9 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
-import android.net.Uri
 import androidx.activity.ComponentActivity
 import androidx.annotation.MainThread
+import androidx.core.net.toUri
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
@@ -23,9 +23,6 @@ import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import java.io.ByteArrayInputStream
 import java.io.InputStream
 import java.security.MessageDigest
-import java.security.NoSuchAlgorithmException
-import java.security.cert.CertificateEncodingException
-import java.security.cert.CertificateException
 import java.security.cert.CertificateFactory
 import java.security.cert.X509Certificate
 import java.util.concurrent.TimeUnit
@@ -74,7 +71,8 @@ class AppUpdateChecker(private val activity: ComponentActivity) {
 			.setTitle(R.string.app_update_available)
 			.setMessage(message)
 			.setPositiveButton(R.string.download) { _, _ ->
-				activity.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(version.apkUrl)))
+				val intent = Intent(Intent.ACTION_VIEW, version.apkUrl.toUri())
+				activity.startActivity(Intent.createChooser(intent, activity.getString(R.string.open_in_browser)))
 			}
 			.setNegativeButton(R.string.close, null)
 			.setCancelable(false)
@@ -88,42 +86,23 @@ class AppUpdateChecker(private val activity: ComponentActivity) {
 		private val PERIOD = TimeUnit.HOURS.toMillis(6)
 
 		fun isUpdateSupported(context: Context): Boolean {
-			return getCertificateSHA1Fingerprint(context) == CERT_SHA1
+			return BuildConfig.DEBUG || getCertificateSHA1Fingerprint(context) == CERT_SHA1
 		}
 
 		@Suppress("DEPRECATION")
 		@SuppressLint("PackageManagerGetSignatures")
-		private fun getCertificateSHA1Fingerprint(context: Context): String? {
+		private fun getCertificateSHA1Fingerprint(context: Context): String? = runCatching {
-			val packageInfo = try {
+			val packageInfo = context.packageManager.getPackageInfo(context.packageName, PackageManager.GET_SIGNATURES)
-				context.packageManager.getPackageInfo(
+			val signatures = requireNotNull(packageInfo?.signatures)
-					context.packageName,
+			val cert: ByteArray = signatures.first().toByteArray()
-					PackageManager.GET_SIGNATURES
-				)
-			} catch (e: PackageManager.NameNotFoundException) {
-				e.printStackTraceDebug()
-				return null
-			}
-			val signatures = packageInfo?.signatures
-			val cert: ByteArray = signatures?.firstOrNull()?.toByteArray() ?: return null
 			val input: InputStream = ByteArrayInputStream(cert)
-			val c = try {
+			val cf = CertificateFactory.getInstance("X509")
-				val cf = CertificateFactory.getInstance("X509")
+			val c = cf.generateCertificate(input) as X509Certificate
-				cf.generateCertificate(input) as X509Certificate
+			val md: MessageDigest = MessageDigest.getInstance("SHA1")
-			} catch (e: CertificateException) {
+			val publicKey: ByteArray = md.digest(c.encoded)
-				e.printStackTraceDebug()
+			return publicKey.byte2HexFormatted()
-				return null
+		}.onFailure { error ->
-			}
+			error.printStackTraceDebug()
-			return try {
+		}.getOrNull()
-				val md: MessageDigest = MessageDigest.getInstance("SHA1")
-				val publicKey: ByteArray = md.digest(c.encoded)
-				publicKey.byte2HexFormatted()
-			} catch (e: NoSuchAlgorithmException) {
-				e.printStackTraceDebug()
-				null
-			} catch (e: CertificateEncodingException) {
-				e.printStackTraceDebug()
-				null
-			}
-		}
 	}
 }

app/src/main/java/org/koitharu/kotatsu/settings/DomainValidator.kt

@@ -0,0 +1,20 @@
+package org.koitharu.kotatsu.settings
+
+import okhttp3.internal.toCanonicalHost
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.utils.EditTextValidator
+
+class DomainValidator : EditTextValidator() {
+
+	override fun validate(text: String): ValidationResult {
+		if (text.isBlank()) {
+			return ValidationResult.Success
+		}
+		val host = text.trim().toCanonicalHost()
+		return if (host == null) {
+			ValidationResult.Failed(context.getString(R.string.invalid_domain_message))
+		} else {
+			ValidationResult.Success
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/settings/SettingsHeadersFragment.kt

@@ -33,7 +33,7 @@ class SettingsHeadersFragment : PreferenceHeaderFragmentCompat(), SlidingPaneLay
 
 	fun setTitle(title: CharSequence?) {
 		currentTitle = title
-		if (slidingPaneLayout.isOpen) {
+		if (slidingPaneLayout.width != 0 && slidingPaneLayout.isOpen) {
 			activity?.title = title
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/settings/SettingsModule.kt

@@ -1,12 +1,14 @@
 package org.koitharu.kotatsu.settings
 
 import android.net.Uri
+import android.os.Build
+import androidx.room.InvalidationTracker
 import org.koin.android.ext.koin.androidContext
 import org.koin.androidx.viewmodel.dsl.viewModel
 import org.koin.dsl.module
 import org.koitharu.kotatsu.core.backup.BackupRepository
-import org.koitharu.kotatsu.core.backup.RestoreRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.settings.backup.BackupObserver
 import org.koitharu.kotatsu.settings.backup.BackupViewModel
 import org.koitharu.kotatsu.settings.backup.RestoreViewModel
 import org.koitharu.kotatsu.settings.newsources.NewSourcesViewModel
@@ -17,8 +19,11 @@ import org.koitharu.kotatsu.settings.sources.SourcesSettingsViewModel
 val settingsModule
 	get() = module {
 
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+			single<InvalidationTracker.Observer> { BackupObserver(androidContext()) }
+		}
+
 		factory { BackupRepository(get()) }
-		factory { RestoreRepository(get()) }
 		single(createdAtStart = true) { AppSettings(androidContext()) }
 
 		viewModel { BackupViewModel(get(), androidContext()) }

app/src/main/java/org/koitharu/kotatsu/settings/SourceSettingsExt.kt

@@ -28,6 +28,7 @@ fun PreferenceFragmentCompat.addPreferencesFromRepository(repository: RemoteMang
 						EditTextBindListener(
 							inputType = EditorInfo.TYPE_CLASS_TEXT or EditorInfo.TYPE_TEXT_VARIATION_URI,
 							hint = key.defaultValue,
+							validator = DomainValidator(),
 						)
 					)
 					setTitle(R.string.domain)

app/src/main/java/org/koitharu/kotatsu/settings/SourceSettingsFragment.kt

@@ -5,6 +5,7 @@ import android.view.View
 import androidx.preference.Preference
 import com.google.android.material.snackbar.Snackbar
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.R
@@ -74,11 +75,15 @@ class SourceSettingsFragment : BasePreferenceFragment(0) {
 			when {
 				error is AuthRequiredException -> Unit
 				ExceptionResolver.canResolve(error) -> {
-					Snackbar.make(listView, error.getDisplayMessage(resources), Snackbar.LENGTH_INDEFINITE)
+					ensureActive()
-						.setAction(ExceptionResolver.getResolveStringId(error)) { resolveError(error) }
+					Snackbar.make(
+						listView ?: return@onFailure,
+						error.getDisplayMessage(preference.context.resources),
+						Snackbar.LENGTH_INDEFINITE,
+					).setAction(ExceptionResolver.getResolveStringId(error)) { resolveError(error) }
 						.show()
 				}
-				else -> preference.summary = error.getDisplayMessage(resources)
+				else -> preference.summary = error.getDisplayMessage(preference.context.resources)
 			}
 			error.printStackTraceDebug()
 		}

app/src/main/java/org/koitharu/kotatsu/settings/backup/AppBackupAgent.kt

@@ -4,9 +4,14 @@ import android.app.backup.BackupAgent
 import android.app.backup.BackupDataInput
 import android.app.backup.BackupDataOutput
 import android.app.backup.FullBackupDataOutput
+import android.content.Context
 import android.os.ParcelFileDescriptor
+import androidx.annotation.VisibleForTesting
 import kotlinx.coroutines.runBlocking
-import org.koitharu.kotatsu.core.backup.*
+import org.koitharu.kotatsu.core.backup.BackupEntry
+import org.koitharu.kotatsu.core.backup.BackupRepository
+import org.koitharu.kotatsu.core.backup.BackupZipInput
+import org.koitharu.kotatsu.core.backup.BackupZipOutput
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import java.io.*
 
@@ -26,7 +31,7 @@ class AppBackupAgent : BackupAgent() {
 
 	override fun onFullBackup(data: FullBackupDataOutput) {
 		super.onFullBackup(data)
-		val file = createBackupFile()
+		val file = createBackupFile(this, BackupRepository(MangaDatabase(applicationContext)))
 		try {
 			fullBackupFile(file, data)
 		} finally {
@@ -43,16 +48,16 @@ class AppBackupAgent : BackupAgent() {
 		mtime: Long
 	) {
 		if (destination?.name?.endsWith(".bk.zip") == true) {
-			restoreBackupFile(data.fileDescriptor, size)
+			restoreBackupFile(data.fileDescriptor, size, BackupRepository(MangaDatabase(applicationContext)))
 			destination.delete()
 		} else {
 			super.onRestoreFile(data, size, destination, type, mode, mtime)
 		}
 	}
 
-	private fun createBackupFile() = runBlocking {
+	@VisibleForTesting
-		val repository = BackupRepository(MangaDatabase(applicationContext))
+	fun createBackupFile(context: Context, repository: BackupRepository) = runBlocking {
-		BackupZipOutput(this@AppBackupAgent).use { backup ->
+		BackupZipOutput(context).use { backup ->
 			backup.put(repository.createIndex())
 			backup.put(repository.dumpHistory())
 			backup.put(repository.dumpCategories())
@@ -62,8 +67,8 @@ class AppBackupAgent : BackupAgent() {
 		}
 	}
 
-	private fun restoreBackupFile(fd: FileDescriptor, size: Long) {
+	@VisibleForTesting
-		val repository = RestoreRepository(MangaDatabase(applicationContext))
+	fun restoreBackupFile(fd: FileDescriptor, size: Long, repository: BackupRepository) {
 		val tempFile = File.createTempFile("backup_", ".tmp")
 		FileInputStream(fd).use { input ->
 			tempFile.outputStream().use { output ->
@@ -73,9 +78,9 @@ class AppBackupAgent : BackupAgent() {
 		val backup = BackupZipInput(tempFile)
 		try {
 			runBlocking {
-				repository.upsertHistory(backup.getEntry(BackupEntry.HISTORY))
+				repository.restoreHistory(backup.getEntry(BackupEntry.HISTORY))
-				repository.upsertCategories(backup.getEntry(BackupEntry.CATEGORIES))
+				repository.restoreCategories(backup.getEntry(BackupEntry.CATEGORIES))
-				repository.upsertFavourites(backup.getEntry(BackupEntry.FAVOURITES))
+				repository.restoreFavourites(backup.getEntry(BackupEntry.FAVOURITES))
 			}
 		} finally {
 			backup.close()

app/src/main/java/org/koitharu/kotatsu/settings/backup/BackupObserver.kt

@@ -0,0 +1,22 @@
+package org.koitharu.kotatsu.settings.backup
+
+import android.app.backup.BackupManager
+import android.content.Context
+import android.os.Build
+import androidx.annotation.RequiresApi
+import androidx.room.InvalidationTracker
+import org.koitharu.kotatsu.core.db.TABLE_FAVOURITES
+import org.koitharu.kotatsu.core.db.TABLE_FAVOURITE_CATEGORIES
+import org.koitharu.kotatsu.core.db.TABLE_HISTORY
+
+@RequiresApi(Build.VERSION_CODES.M)
+class BackupObserver(
+	context: Context,
+) : InvalidationTracker.Observer(arrayOf(TABLE_HISTORY, TABLE_FAVOURITES, TABLE_FAVOURITE_CATEGORIES)) {
+
+	private val backupManager = BackupManager(context)
+
+	override fun onInvalidated(tables: MutableSet<String>) {
+		backupManager.dataChanged()
+	}
+}

app/src/main/java/org/koitharu/kotatsu/settings/backup/RestoreViewModel.kt

@@ -7,9 +7,9 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import org.koitharu.kotatsu.base.ui.BaseViewModel
 import org.koitharu.kotatsu.core.backup.BackupEntry
+import org.koitharu.kotatsu.core.backup.BackupRepository
 import org.koitharu.kotatsu.core.backup.BackupZipInput
 import org.koitharu.kotatsu.core.backup.CompositeResult
-import org.koitharu.kotatsu.core.backup.RestoreRepository
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.progress.Progress
 import java.io.File
@@ -17,7 +17,7 @@ import java.io.FileNotFoundException
 
 class RestoreViewModel(
 	uri: Uri?,
-	private val repository: RestoreRepository,
+	private val repository: BackupRepository,
 	context: Context
 ) : BaseViewModel() {
 
@@ -44,13 +44,13 @@ class RestoreViewModel(
 				val result = CompositeResult()
 
 				progress.value = Progress(0, 3)
-				result += repository.upsertHistory(backup.getEntry(BackupEntry.HISTORY))
+				result += repository.restoreHistory(backup.getEntry(BackupEntry.HISTORY))
 
 				progress.value = Progress(1, 3)
-				result += repository.upsertCategories(backup.getEntry(BackupEntry.CATEGORIES))
+				result += repository.restoreCategories(backup.getEntry(BackupEntry.CATEGORIES))
 
 				progress.value = Progress(2, 3)
-				result += repository.upsertFavourites(backup.getEntry(BackupEntry.FAVOURITES))
+				result += repository.restoreFavourites(backup.getEntry(BackupEntry.FAVOURITES))
 
 				progress.value = Progress(3, 3)
 				onRestoreDone.call(result)

app/src/main/java/org/koitharu/kotatsu/settings/newsources/NewSourcesViewModel.kt

@@ -33,15 +33,22 @@ class NewSourcesViewModel(
 
 	private fun buildList() {
 		val locales = LocaleListCompat.getDefault().mapToSet { it.language }
-		val hidden = settings.hiddenSources
+		val pendingHidden = HashSet<String>()
 		sources.value = initialList.map {
 			val locale = it.locale
+			val isEnabledByLocale = locale == null || locale in locales
+			if (!isEnabledByLocale) {
+				pendingHidden += it.name
+			}
 			SourceConfigItem.SourceItem(
 				source = it,
 				summary = it.getLocaleTitle(),
-				isEnabled = it.name !in hidden && (locale == null || locale in locales),
+				isEnabled = isEnabledByLocale,
-				isDraggable = false,
+				isDraggable = false
 			)
 		}
+		if (pendingHidden.isNotEmpty()) {
+			settings.hiddenSources += pendingHidden
+		}
 	}
 }

app/src/main/java/org/koitharu/kotatsu/settings/onboard/OnboardViewModel.kt

@@ -3,15 +3,16 @@ package org.koitharu.kotatsu.settings.onboard
 import androidx.collection.ArraySet
 import androidx.core.os.LocaleListCompat
 import androidx.lifecycle.MutableLiveData
+import java.util.*
 import org.koitharu.kotatsu.base.ui.BaseViewModel
+import org.koitharu.kotatsu.core.model.MangaSource
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.util.mapNotNullToSet
 import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.parsers.util.toTitleCase
 import org.koitharu.kotatsu.settings.onboard.model.SourceLocale
 import org.koitharu.kotatsu.utils.ext.map
 import org.koitharu.kotatsu.utils.ext.mapToSet
-import java.util.*
 
 class OnboardViewModel(
 	private val settings: AppSettings,
@@ -27,7 +28,7 @@ class OnboardViewModel(
 
 	init {
 		if (settings.isSourcesSelected) {
-			selectedLocales.removeAll(settings.hiddenSources.mapToSet { x -> MangaSource.valueOf(x).locale })
+			selectedLocales.removeAll(settings.hiddenSources.mapNotNullToSet { x -> MangaSource(x)?.locale })
 		} else {
 			val deviceLocales = LocaleListCompat.getDefault().mapToSet { x ->
 				x.language
@@ -66,7 +67,7 @@ class OnboardViewModel(
 			SourceLocale(
 				key = key,
 				title = locale?.getDisplayLanguage(locale)?.toTitleCase(locale),
-				isChecked = key in selectedLocales
+				isChecked = key in selectedLocales,
 			)
 		}.sortedWith(SourceLocaleComparator())
 	}