Added translation using Weblate (Lithuanian)

Added translation using Weblate (Lithuanian)

Co-authored-by: Andrius <sndriuss@gmail.com>

.idea/gradle.xml

@@ -4,9 +4,8 @@
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
-        <option name="testRunner" value="GRADLE" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="jbr-17" />
+        <option name="gradleJvm" value="#GRADLE_LOCAL_JAVA_HOME" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />

LICENSE

@@ -619,56 +619,3 @@ Program, unless a warranty or assumption of liability accompanies a
 copy of the Program in return for a fee.
 
                      END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

app/build.gradle

@@ -16,8 +16,8 @@ android {
 		applicationId 'org.koitharu.kotatsu'
 		minSdk = 21
 		targetSdk = 34
-		versionCode = 622
-		versionName = '6.7'
+		versionCode = 636
+		versionName = '7.0-b2'
 		generatedDensities = []
 		testInstrumentationRunner 'org.koitharu.kotatsu.HiltTestRunner'
 		ksp {
@@ -82,19 +82,19 @@ afterEvaluate {
 }
 dependencies {
 	//noinspection GradleDependency
-	implementation('com.github.KotatsuApp:kotatsu-parsers:014ea5ef49') {
+	implementation('com.github.KotatsuApp:kotatsu-parsers:a245574dee') {
 		exclude group: 'org.json', module: 'json'
 	}
 
 	coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.4'
-	implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.9.22'
-	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+	implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.9.23'
+	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.0'
 
 	implementation 'androidx.appcompat:appcompat:1.6.1'
-	implementation 'androidx.core:core-ktx:1.12.0'
-	implementation 'androidx.activity:activity-ktx:1.8.2'
+	implementation 'androidx.core:core-ktx:1.13.0'
+	implementation 'androidx.activity:activity-ktx:1.9.0'
 	implementation 'androidx.fragment:fragment-ktx:1.6.2'
-	implementation 'androidx.collection:collection:1.4.0'
+	implementation 'androidx.collection:collection-ktx:1.4.0'
 	implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0'
 	implementation 'androidx.lifecycle:lifecycle-service:2.7.0'
 	implementation 'androidx.lifecycle:lifecycle-process:2.7.0'
@@ -104,8 +104,9 @@ dependencies {
 	implementation 'androidx.viewpager2:viewpager2:1.1.0-beta02'
 	implementation 'androidx.preference:preference-ktx:1.2.1'
 	implementation 'androidx.biometric:biometric-ktx:1.2.0-alpha05'
-	implementation 'com.google.android.material:material:1.12.0-alpha03'
+	implementation 'com.google.android.material:material:1.12.0-rc01'
 	implementation 'androidx.lifecycle:lifecycle-common-java8:2.7.0'
+	implementation 'androidx.webkit:webkit:1.10.0'
 
 	implementation 'androidx.work:work-runtime:2.9.0'
 	//noinspection GradleDependency
@@ -121,18 +122,18 @@ dependencies {
 
 	implementation 'com.squareup.okhttp3:okhttp:4.12.0'
 	implementation 'com.squareup.okhttp3:okhttp-dnsoverhttps:4.12.0'
-	implementation 'com.squareup.okio:okio:3.8.0'
+	implementation 'com.squareup.okio:okio:3.9.0'
 
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl:4.3.2'
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl-viewbinding:4.3.2'
 
-	implementation 'com.google.dagger:hilt-android:2.50'
-	kapt 'com.google.dagger:hilt-compiler:2.50'
-	implementation 'androidx.hilt:hilt-work:1.1.0'
-	kapt 'androidx.hilt:hilt-compiler:1.1.0'
+	implementation 'com.google.dagger:hilt-android:2.51.1'
+	kapt 'com.google.dagger:hilt-compiler:2.51.1'
+	implementation 'androidx.hilt:hilt-work:1.2.0'
+	kapt 'androidx.hilt:hilt-compiler:1.2.0'
 
-	implementation 'io.coil-kt:coil-base:2.5.0'
-	implementation 'io.coil-kt:coil-svg:2.5.0'
+	implementation 'io.coil-kt:coil-base:2.6.0'
+	implementation 'io.coil-kt:coil-svg:2.6.0'
 	implementation 'com.github.KotatsuApp:subsampling-scale-image-view:02e6d6cfe9'
 	implementation 'com.github.solkin:disk-lru-cache:1.4'
 	implementation 'io.noties.markwon:core:4.6.2'
@@ -144,22 +145,22 @@ dependencies {
 
 	implementation 'org.conscrypt:conscrypt-android:2.5.2'
 
-	debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.13'
+	debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.14'
 
 	testImplementation 'junit:junit:4.13.2'
-	testImplementation 'org.json:json:20240205'
-	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3'
+	testImplementation 'org.json:json:20240303'
+	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.0'
 
 	androidTestImplementation 'androidx.test:runner:1.5.2'
 	androidTestImplementation 'androidx.test:rules:1.5.0'
 	androidTestImplementation 'androidx.test:core-ktx:1.5.0'
 	androidTestImplementation 'androidx.test.ext:junit-ktx:1.1.5'
 
-	androidTestImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3'
+	androidTestImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.0'
 
 	androidTestImplementation 'androidx.room:room-testing:2.6.1'
 	androidTestImplementation 'com.squareup.moshi:moshi-kotlin:1.15.1'
 
-	androidTestImplementation 'com.google.dagger:hilt-android-testing:2.50'
-	kaptAndroidTest 'com.google.dagger:hilt-android-compiler:2.50'
+	androidTestImplementation 'com.google.dagger:hilt-android-testing:2.51.1'
+	kaptAndroidTest 'com.google.dagger:hilt-android-compiler:2.51.1'
 }

app/src/androidTest/kotlin/org/koitharu/kotatsu/core/os/AppShortcutManagerTest.kt

@@ -57,6 +57,7 @@ class AppShortcutManagerTest {
 			page = 4,
 			scroll = 2,
 			percent = 0.3f,
+			force = false,
 		)
 		awaitUpdate()
 

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

@@ -7,7 +7,9 @@ import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
-import org.junit.Assert.*
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
@@ -61,6 +63,7 @@ class AppBackupAgentTest {
 			page = 3,
 			scroll = 40,
 			percent = 0.2f,
+			force = false,
 		)
 		val history = checkNotNull(historyRepository.getOne(SampleData.manga))
 

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

@@ -174,12 +174,12 @@ class TrackerTest {
 		assertEquals(3, repository.getNewChaptersCount(mangaFirst.id))
 
 		var chapter = requireNotNull(mangaFull.chapters).run { get(lastIndex - 1) }
-		repository.syncWithHistory(mangaFull, chapter.id)
+		tracker.syncWithHistory(mangaFull, chapter.id)
 
 		assertEquals(1, repository.getNewChaptersCount(mangaFirst.id))
 
 		chapter = requireNotNull(mangaFull.chapters).run { get(lastIndex) }
-		repository.syncWithHistory(mangaFull, chapter.id)
+		tracker.syncWithHistory(mangaFull, chapter.id)
 
 		assertEquals(0, repository.getNewChaptersCount(mangaFirst.id))
 

app/src/debug/AndroidManifest.xml

@@ -0,0 +1,12 @@
+<manifest
+	xmlns:android="http://schemas.android.com/apk/res/android">
+
+	<application>
+
+		<activity
+			android:name=".tracker.ui.debug.TrackerDebugActivity"
+			android:label="@string/check_for_new_chapters" />
+
+	</application>
+
+</manifest>

app/src/debug/kotlin/org/koitharu/kotatsu/tracker/ui/debug/TrackDebugAD.kt

@@ -0,0 +1,72 @@
+package org.koitharu.kotatsu.tracker.ui.debug
+
+import android.graphics.Color
+import android.text.format.DateUtils
+import androidx.core.content.ContextCompat
+import androidx.core.text.bold
+import androidx.core.text.buildSpannedString
+import androidx.core.text.color
+import androidx.lifecycle.LifecycleOwner
+import coil.ImageLoader
+import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.util.ext.defaultPlaceholders
+import org.koitharu.kotatsu.core.util.ext.drawableStart
+import org.koitharu.kotatsu.core.util.ext.enqueueWith
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import org.koitharu.kotatsu.core.util.ext.newImageRequest
+import org.koitharu.kotatsu.core.util.ext.source
+import org.koitharu.kotatsu.databinding.ItemTrackDebugBinding
+import org.koitharu.kotatsu.tracker.data.TrackEntity
+import com.google.android.material.R as materialR
+
+fun trackDebugAD(
+	lifecycleOwner: LifecycleOwner,
+	coil: ImageLoader,
+	clickListener: OnListItemClickListener<TrackDebugItem>,
+) = adapterDelegateViewBinding<TrackDebugItem, TrackDebugItem, ItemTrackDebugBinding>(
+	{ layoutInflater, parent -> ItemTrackDebugBinding.inflate(layoutInflater, parent, false) },
+) {
+	val indicatorNew = ContextCompat.getDrawable(context, R.drawable.ic_new)
+
+	itemView.setOnClickListener { v ->
+		clickListener.onItemClick(item, v)
+	}
+
+	bind {
+		binding.imageViewCover.newImageRequest(lifecycleOwner, item.manga.coverUrl)?.run {
+			defaultPlaceholders(context)
+			allowRgb565(true)
+			source(item.manga.source)
+			enqueueWith(coil)
+		}
+		binding.textViewTitle.text = item.manga.title
+		binding.textViewSummary.text = buildSpannedString {
+			item.lastCheckTime?.let {
+				append(
+					DateUtils.getRelativeDateTimeString(
+						context,
+						it.toEpochMilli(),
+						DateUtils.MINUTE_IN_MILLIS,
+						DateUtils.WEEK_IN_MILLIS,
+						0,
+					),
+				)
+			}
+			if (item.lastResult == TrackEntity.RESULT_FAILED) {
+				append(" - ")
+				bold {
+					color(context.getThemeColor(materialR.attr.colorError, Color.RED)) {
+						append(getString(R.string.error))
+					}
+				}
+			}
+		}
+		binding.textViewTitle.drawableStart = if (item.newChapters > 0) {
+			indicatorNew
+		} else {
+			null
+		}
+	}
+}

app/src/debug/kotlin/org/koitharu/kotatsu/tracker/ui/debug/TrackDebugItem.kt

@@ -0,0 +1,19 @@
+package org.koitharu.kotatsu.tracker.ui.debug
+
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.Manga
+import java.time.Instant
+
+data class TrackDebugItem(
+	val manga: Manga,
+	val lastChapterId: Long,
+	val newChapters: Int,
+	val lastCheckTime: Instant?,
+	val lastChapterDate: Instant?,
+	val lastResult: Int,
+) : ListModel {
+
+	override fun areItemsTheSame(other: ListModel): Boolean {
+		return other is TrackDebugItem && other.manga.id == manga.id
+	}
+}

app/src/debug/kotlin/org/koitharu/kotatsu/tracker/ui/debug/TrackerDebugActivity.kt

@@ -0,0 +1,57 @@
+package org.koitharu.kotatsu.tracker.ui.debug
+
+import android.os.Bundle
+import android.view.View
+import androidx.activity.viewModels
+import androidx.core.graphics.Insets
+import androidx.core.view.updatePadding
+import coil.ImageLoader
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.core.ui.BaseActivity
+import org.koitharu.kotatsu.core.ui.BaseListAdapter
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.util.ext.observe
+import org.koitharu.kotatsu.databinding.ActivityTrackerDebugBinding
+import org.koitharu.kotatsu.details.ui.DetailsActivity
+import org.koitharu.kotatsu.list.ui.adapter.ListItemType
+import org.koitharu.kotatsu.list.ui.adapter.TypedListSpacingDecoration
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class TrackerDebugActivity : BaseActivity<ActivityTrackerDebugBinding>(), OnListItemClickListener<TrackDebugItem> {
+
+	@Inject
+	lateinit var coil: ImageLoader
+
+	private val viewModel by viewModels<TrackerDebugViewModel>()
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		setContentView(ActivityTrackerDebugBinding.inflate(layoutInflater))
+		supportActionBar?.setDisplayHomeAsUpEnabled(true)
+		val tracksAdapter = BaseListAdapter<TrackDebugItem>()
+			.addDelegate(ListItemType.FEED, trackDebugAD(this, coil, this))
+		with(viewBinding.recyclerView) {
+			adapter = tracksAdapter
+			addItemDecoration(TypedListSpacingDecoration(context, false))
+		}
+		viewModel.content.observe(this, tracksAdapter)
+	}
+
+	override fun onWindowInsetsChanged(insets: Insets) {
+		val rv = viewBinding.recyclerView
+		rv.updatePadding(
+			left = insets.left + rv.paddingTop,
+			right = insets.right + rv.paddingTop,
+			bottom = insets.bottom,
+		)
+		viewBinding.toolbar.updatePadding(
+			left = insets.left,
+			right = insets.right,
+		)
+	}
+
+	override fun onItemClick(item: TrackDebugItem, view: View) {
+		startActivity(DetailsActivity.newIntent(this, item.manga))
+	}
+}

app/src/debug/kotlin/org/koitharu/kotatsu/tracker/ui/debug/TrackerDebugViewModel.kt

@@ -0,0 +1,36 @@
+package org.koitharu.kotatsu.tracker.ui.debug
+
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.plus
+import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.db.entity.toManga
+import org.koitharu.kotatsu.core.ui.BaseViewModel
+import org.koitharu.kotatsu.core.util.ext.toInstantOrNull
+import org.koitharu.kotatsu.tracker.data.TrackWithManga
+import javax.inject.Inject
+
+@HiltViewModel
+class TrackerDebugViewModel @Inject constructor(
+	private val db: MangaDatabase
+) : BaseViewModel() {
+
+	val content = db.getTracksDao().observeAll()
+		.map { it.toUiList() }
+		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, emptyList())
+
+	private fun List<TrackWithManga>.toUiList(): List<TrackDebugItem> = map {
+		TrackDebugItem(
+			manga = it.manga.toManga(emptySet()),
+			lastChapterId = it.track.lastChapterId,
+			newChapters = it.track.newChapters,
+			lastCheckTime = it.track.lastCheckTime.toInstantOrNull(),
+			lastChapterDate = it.track.lastChapterDate.toInstantOrNull(),
+			lastResult = it.track.lastResult,
+		)
+	}
+}

app/src/debug/res/layout/activity_tracker_debug.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	xmlns:app="http://schemas.android.com/apk/res-auto"
+	xmlns:tools="http://schemas.android.com/tools"
+	android:layout_width="match_parent"
+	android:layout_height="match_parent">
+
+	<com.google.android.material.appbar.AppBarLayout
+		android:id="@+id/appbar"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:fitsSystemWindows="true">
+
+		<com.google.android.material.appbar.CollapsingToolbarLayout
+			android:id="@+id/collapsingToolbarLayout"
+			android:layout_width="match_parent"
+			android:layout_height="?attr/collapsingToolbarLayoutMediumSize"
+			app:layout_scrollFlags="scroll|exitUntilCollapsed|snap"
+			app:toolbarId="@id/toolbar">
+
+			<com.google.android.material.appbar.MaterialToolbar
+				android:id="@id/toolbar"
+				android:layout_width="match_parent"
+				android:layout_height="?attr/actionBarSize"
+				app:layout_collapseMode="pin" />
+
+		</com.google.android.material.appbar.CollapsingToolbarLayout>
+
+	</com.google.android.material.appbar.AppBarLayout>
+
+	<androidx.recyclerview.widget.RecyclerView
+		android:id="@+id/recyclerView"
+		android:layout_width="match_parent"
+		android:layout_height="match_parent"
+		android:clipToPadding="false"
+		android:orientation="vertical"
+		android:padding="@dimen/list_spacing_normal"
+		android:scrollbars="vertical"
+		app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
+		app:layout_behavior="com.google.android.material.appbar.AppBarLayout$ScrollingViewBehavior"
+		tools:listitem="@layout/item_track_debug" />
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>

app/src/debug/res/layout/item_track_debug.xml

@@ -4,7 +4,7 @@
 	xmlns:app="http://schemas.android.com/apk/res-auto"
 	xmlns:tools="http://schemas.android.com/tools"
 	android:layout_width="match_parent"
-	android:layout_height="wrap_content"
+	android:layout_height="72dp"
 	android:background="@drawable/list_selector"
 	android:clipChildren="false">
 
@@ -14,7 +14,9 @@
 		android:layout_height="40dp"
 		android:layout_marginStart="8dp"
 		android:layout_marginTop="16dp"
+		android:layout_marginBottom="16dp"
 		android:scaleType="centerCrop"
+		app:layout_constraintBottom_toBottomOf="parent"
 		app:layout_constraintStart_toStartOf="parent"
 		app:layout_constraintTop_toTopOf="parent"
 		app:shapeAppearanceOverlay="@style/ShapeAppearanceOverlay.Kotatsu.Cover.Small"
@@ -26,42 +28,29 @@
 		android:layout_height="wrap_content"
 		android:layout_marginStart="16dp"
 		android:layout_marginEnd="8dp"
+		android:drawablePadding="8dp"
 		android:ellipsize="end"
 		android:maxLines="1"
-		android:textAppearance="?attr/textAppearanceBodyLarge"
-		app:layout_constraintBottom_toTopOf="@+id/textView_subtitle"
-		app:layout_constraintEnd_toStartOf="@id/button_more"
+		android:textAppearance="?attr/textAppearanceTitleSmall"
+		app:layout_constraintBottom_toTopOf="@+id/textView_summary"
+		app:layout_constraintEnd_toEndOf="parent"
 		app:layout_constraintStart_toEndOf="@+id/imageView_cover"
 		app:layout_constraintTop_toTopOf="@+id/imageView_cover"
 		tools:text="@tools:sample/lorem" />
 
 	<TextView
-		android:id="@+id/textView_subtitle"
+		android:id="@+id/textView_summary"
 		android:layout_width="0dp"
 		android:layout_height="wrap_content"
 		android:layout_marginStart="16dp"
 		android:layout_marginEnd="8dp"
 		android:ellipsize="end"
 		android:maxLines="1"
-		android:textAppearance="?attr/textAppearanceBodyMedium"
+		android:textAppearance="?attr/textAppearanceBodySmall"
 		app:layout_constraintBottom_toBottomOf="@+id/imageView_cover"
-		app:layout_constraintEnd_toStartOf="@id/button_more"
+		app:layout_constraintEnd_toEndOf="parent"
 		app:layout_constraintStart_toEndOf="@+id/imageView_cover"
 		app:layout_constraintTop_toBottomOf="@+id/textView_title"
 		tools:text="@tools:sample/lorem/random" />
 
-	<Button
-		android:id="@+id/button_more"
-		style="@style/Widget.Kotatsu.ExploreButton"
-		android:layout_width="wrap_content"
-		android:layout_height="wrap_content"
-		android:layout_margin="8dp"
-		android:gravity="center"
-		android:minWidth="120dp"
-		android:text="@string/more"
-		app:layout_constraintBottom_toBottomOf="parent"
-		app:layout_constraintEnd_toEndOf="parent"
-		app:layout_constraintTop_toTopOf="parent" />
-
 </androidx.constraintlayout.widget.ConstraintLayout>
-

app/src/debug/res/menu/opt_settings.xml

@@ -8,4 +8,9 @@
 		android:title="@string/leak_canary_display_activity_label"
 		app:showAsAction="never" />
 
-</menu>
+	<item
+		android:id="@id/action_tracker"
+		android:title="@string/check_for_new_chapters"
+		app:showAsAction="never" />
+
+</menu>

app/src/main/AndroidManifest.xml

@@ -239,6 +239,12 @@
 				<data android:scheme="kotatsu+kitsu" />
 			</intent-filter>
 		</activity>
+		<activity
+			android:name="org.koitharu.kotatsu.stats.ui.StatsActivity"
+			android:label="@string/reading_stats" />
+		<activity
+			android:name="org.koitharu.kotatsu.alternatives.ui.AlternativesActivity"
+			android:label="@string/alternatives" />
 
 		<service
 			android:name="androidx.work.impl.foreground.SystemForegroundService"
@@ -247,6 +253,9 @@
 		<service
 			android:name="org.koitharu.kotatsu.local.ui.LocalChaptersRemoveService"
 			android:foregroundServiceType="dataSync" />
+		<service
+			android:name="org.koitharu.kotatsu.local.ui.ImportService"
+			android:foregroundServiceType="dataSync" />
 		<service
 			android:name="org.koitharu.kotatsu.widget.shelf.ShelfWidgetService"
 			android:permission="android.permission.BIND_REMOTEVIEWS" />

app/src/main/kotlin/org/koitharu/kotatsu/alternatives/domain/AlternativesUseCase.kt

@@ -0,0 +1,85 @@
+package org.koitharu.kotatsu.alternatives.domain
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.core.util.ext.almostEquals
+import org.koitharu.kotatsu.explore.data.MangaSourcesRepository
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaListFilter
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
+import javax.inject.Inject
+
+private const val MAX_PARALLELISM = 4
+private const val MATCH_THRESHOLD = 0.2f
+
+class AlternativesUseCase @Inject constructor(
+	private val sourcesRepository: MangaSourcesRepository,
+	private val mangaRepositoryFactory: MangaRepository.Factory,
+) {
+
+	suspend operator fun invoke(manga: Manga): Flow<Manga> {
+		val sources = getSources(manga.source)
+		if (sources.isEmpty()) {
+			return emptyFlow()
+		}
+		val semaphore = Semaphore(MAX_PARALLELISM)
+		return channelFlow {
+			for (source in sources) {
+				val repository = mangaRepositoryFactory.create(source)
+				if (!repository.isSearchSupported) {
+					continue
+				}
+				launch {
+					val list = runCatchingCancellable {
+						semaphore.withPermit {
+							repository.getList(offset = 0, filter = MangaListFilter.Search(manga.title))
+						}
+					}.getOrDefault(emptyList())
+					for (item in list) {
+						if (item.matches(manga)) {
+							send(item)
+						}
+					}
+				}
+			}
+		}.map {
+			runCatchingCancellable {
+				mangaRepositoryFactory.create(it.source).getDetails(it)
+			}.getOrDefault(it)
+		}
+	}
+
+	private suspend fun getSources(ref: MangaSource): List<MangaSource> {
+		val result = ArrayList<MangaSource>(MangaSource.entries.size - 2)
+		result.addAll(sourcesRepository.getEnabledSources())
+		result.sortByDescending { it.priority(ref) }
+		result.addAll(sourcesRepository.getDisabledSources().sortedByDescending { it.priority(ref) })
+		return result
+	}
+
+	private fun Manga.matches(ref: Manga): Boolean {
+		return matchesTitles(title, ref.title) ||
+			matchesTitles(title, ref.altTitle) ||
+			matchesTitles(altTitle, ref.title) ||
+			matchesTitles(altTitle, ref.altTitle)
+
+	}
+
+	private fun matchesTitles(a: String?, b: String?): Boolean {
+		return !a.isNullOrEmpty() && !b.isNullOrEmpty() && a.almostEquals(b, MATCH_THRESHOLD)
+	}
+
+	private fun MangaSource.priority(ref: MangaSource): Int {
+		var res = 0
+		if (locale == ref.locale) res += 2
+		if (contentType == ref.contentType) res++
+		return res
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/alternatives/domain/MigrateUseCase.kt

@@ -0,0 +1,129 @@
+package org.koitharu.kotatsu.alternatives.domain
+
+import androidx.room.withTransaction
+import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.model.getPreferredBranch
+import org.koitharu.kotatsu.core.parser.MangaDataRepository
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.details.domain.ProgressUpdateUseCase
+import org.koitharu.kotatsu.history.data.HistoryEntity
+import org.koitharu.kotatsu.history.data.PROGRESS_NONE
+import org.koitharu.kotatsu.history.data.toMangaHistory
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
+import javax.inject.Inject
+
+class MigrateUseCase @Inject constructor(
+	private val mangaRepositoryFactory: MangaRepository.Factory,
+	private val mangaDataRepository: MangaDataRepository,
+	private val database: MangaDatabase,
+	private val progressUpdateUseCase: ProgressUpdateUseCase,
+) {
+
+	suspend operator fun invoke(oldManga: Manga, newManga: Manga) {
+		val oldDetails = if (oldManga.chapters.isNullOrEmpty()) {
+			runCatchingCancellable {
+				mangaRepositoryFactory.create(oldManga.source).getDetails(oldManga)
+			}.getOrDefault(oldManga)
+		} else {
+			oldManga
+		}
+		val newDetails = if (newManga.chapters.isNullOrEmpty()) {
+			mangaRepositoryFactory.create(newManga.source).getDetails(newManga)
+		} else {
+			newManga
+		}
+		mangaDataRepository.storeManga(newDetails)
+		database.withTransaction {
+			// replace favorites
+			val favoritesDao = database.getFavouritesDao()
+			val oldFavourites = favoritesDao.findAllRaw(oldDetails.id)
+			if (oldFavourites.isNotEmpty()) {
+				favoritesDao.delete(oldManga.id)
+				for (f in oldFavourites) {
+					val e = f.copy(
+						mangaId = newManga.id,
+					)
+					favoritesDao.upsert(e)
+				}
+			}
+			// replace history
+			val historyDao = database.getHistoryDao()
+			val oldHistory = historyDao.find(oldDetails.id)
+			if (oldHistory != null) {
+				val newHistory = makeNewHistory(oldDetails, newDetails, oldHistory)
+				historyDao.delete(oldDetails.id)
+				historyDao.upsert(newHistory)
+			}
+		}
+		progressUpdateUseCase(newManga)
+	}
+
+	private fun makeNewHistory(
+		oldManga: Manga,
+		newManga: Manga,
+		history: HistoryEntity,
+	): HistoryEntity {
+		if (oldManga.chapters.isNullOrEmpty()) { // probably broken manga/source
+			val branch = newManga.getPreferredBranch(null)
+			val chapters = checkNotNull(newManga.getChapters(branch))
+			val currentChapter = if (history.percent in 0f..1f) {
+				chapters[(chapters.lastIndex * history.percent).toInt()]
+			} else {
+				chapters.first()
+			}
+			return HistoryEntity(
+				mangaId = newManga.id,
+				createdAt = history.createdAt,
+				updatedAt = System.currentTimeMillis(),
+				chapterId = currentChapter.id,
+				page = history.page,
+				scroll = history.scroll,
+				percent = history.percent,
+				deletedAt = 0,
+				chaptersCount = chapters.size,
+			)
+		}
+		val branch = oldManga.getPreferredBranch(history.toMangaHistory())
+		val oldChapters = checkNotNull(oldManga.getChapters(branch))
+		var index = oldChapters.indexOfFirst { it.id == history.chapterId }
+		if (index < 0) {
+			index = if (history.percent in 0f..1f) {
+				(oldChapters.lastIndex * history.percent).toInt()
+			} else {
+				0
+			}
+		}
+		val newChapters = checkNotNull(newManga.chapters).groupBy { it.branch }
+		val newBranch = if (newChapters.containsKey(branch)) {
+			branch
+		} else {
+			newManga.getPreferredBranch(null)
+		}
+		val newChapterId = checkNotNull(newChapters[newBranch]).let {
+			val oldChapter = oldChapters[index]
+			it.findByNumber(oldChapter.volume, oldChapter.number) ?: it.getOrNull(index) ?: it.last()
+		}.id
+
+		return HistoryEntity(
+			mangaId = newManga.id,
+			createdAt = history.createdAt,
+			updatedAt = System.currentTimeMillis(),
+			chapterId = newChapterId,
+			page = history.page,
+			scroll = history.scroll,
+			percent = PROGRESS_NONE,
+			deletedAt = 0,
+			chaptersCount = checkNotNull(newChapters[newBranch]).size,
+		)
+	}
+
+	private fun List<MangaChapter>.findByNumber(volume: Int, number: Float): MangaChapter? {
+		return if (number <= 0f) {
+			null
+		} else {
+			firstOrNull { it.volume == volume && it.number == number }
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/alternatives/ui/AlternativeAD.kt

@@ -0,0 +1,91 @@
+package org.koitharu.kotatsu.alternatives.ui
+
+import android.text.style.ForegroundColorSpan
+import androidx.core.content.ContextCompat
+import androidx.core.text.buildSpannedString
+import androidx.core.text.inSpans
+import androidx.lifecycle.LifecycleOwner
+import coil.ImageLoader
+import coil.request.ImageRequest
+import coil.transform.CircleCropTransformation
+import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.parser.favicon.faviconUri
+import org.koitharu.kotatsu.core.ui.image.ChipIconTarget
+import org.koitharu.kotatsu.core.ui.image.CoverSizeResolver
+import org.koitharu.kotatsu.core.ui.image.TrimTransformation
+import org.koitharu.kotatsu.core.ui.list.AdapterDelegateClickListenerAdapter
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.util.ext.defaultPlaceholders
+import org.koitharu.kotatsu.core.util.ext.enqueueWith
+import org.koitharu.kotatsu.core.util.ext.newImageRequest
+import org.koitharu.kotatsu.core.util.ext.source
+import org.koitharu.kotatsu.databinding.ItemMangaAlternativeBinding
+import org.koitharu.kotatsu.list.ui.ListModelDiffCallback
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import kotlin.math.sign
+import com.google.android.material.R as materialR
+
+fun alternativeAD(
+	coil: ImageLoader,
+	lifecycleOwner: LifecycleOwner,
+	listener: OnListItemClickListener<MangaAlternativeModel>,
+) = adapterDelegateViewBinding<MangaAlternativeModel, ListModel, ItemMangaAlternativeBinding>(
+	{ inflater, parent -> ItemMangaAlternativeBinding.inflate(inflater, parent, false) },
+) {
+
+	val colorGreen = ContextCompat.getColor(context, R.color.common_green)
+	val colorRed = ContextCompat.getColor(context, R.color.common_red)
+	val clickListener = AdapterDelegateClickListenerAdapter(this, listener)
+	itemView.setOnClickListener(clickListener)
+	binding.buttonMigrate.setOnClickListener(clickListener)
+	binding.chipSource.setOnClickListener(clickListener)
+
+	bind { payloads ->
+		binding.textViewTitle.text = item.manga.title
+		binding.textViewSubtitle.text = buildSpannedString {
+			if (item.chaptersCount > 0) {
+				append(context.resources.getQuantityString(R.plurals.chapters, item.chaptersCount, item.chaptersCount))
+			} else {
+				append(context.getString(R.string.no_chapters))
+			}
+			when (item.chaptersDiff.sign) {
+				-1 -> inSpans(ForegroundColorSpan(colorRed)) {
+					append("  ▼ ")
+					append(item.chaptersDiff.toString())
+				}
+
+				1 -> inSpans(ForegroundColorSpan(colorGreen)) {
+					append("  ▲ +")
+					append(item.chaptersDiff.toString())
+				}
+			}
+		}
+		binding.progressView.setPercent(item.progress, ListModelDiffCallback.PAYLOAD_PROGRESS_CHANGED in payloads)
+		binding.chipSource.also { chip ->
+			chip.text = item.manga.source.title
+			ImageRequest.Builder(context)
+				.data(item.manga.source.faviconUri())
+				.lifecycle(lifecycleOwner)
+				.crossfade(false)
+				.size(context.resources.getDimensionPixelSize(materialR.dimen.m3_chip_icon_size))
+				.target(ChipIconTarget(chip))
+				.placeholder(R.drawable.ic_web)
+				.fallback(R.drawable.ic_web)
+				.error(R.drawable.ic_web)
+				.source(item.manga.source)
+				.transformations(CircleCropTransformation())
+				.allowRgb565(true)
+				.enqueueWith(coil)
+		}
+		binding.imageViewCover.newImageRequest(lifecycleOwner, item.manga.coverUrl)?.run {
+			size(CoverSizeResolver(binding.imageViewCover))
+			defaultPlaceholders(context)
+			transformations(TrimTransformation())
+			allowRgb565(true)
+			tag(item.manga)
+			source(item.manga.source)
+			enqueueWith(coil)
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/alternatives/ui/AlternativesActivity.kt

@@ -0,0 +1,114 @@
+package org.koitharu.kotatsu.alternatives.ui
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.view.View
+import android.widget.Toast
+import androidx.activity.viewModels
+import androidx.core.graphics.Insets
+import androidx.core.view.updatePadding
+import coil.ImageLoader
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.exceptions.resolve.SnackbarErrorObserver
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.parser.MangaIntent
+import org.koitharu.kotatsu.core.ui.BaseActivity
+import org.koitharu.kotatsu.core.ui.BaseListAdapter
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.util.ext.DIALOG_THEME_CENTERED
+import org.koitharu.kotatsu.core.util.ext.observe
+import org.koitharu.kotatsu.core.util.ext.observeEvent
+import org.koitharu.kotatsu.databinding.ActivityAlternativesBinding
+import org.koitharu.kotatsu.details.ui.DetailsActivity
+import org.koitharu.kotatsu.list.ui.adapter.ListItemType
+import org.koitharu.kotatsu.list.ui.adapter.TypedListSpacingDecoration
+import org.koitharu.kotatsu.list.ui.adapter.emptyStateListAD
+import org.koitharu.kotatsu.list.ui.adapter.loadingFooterAD
+import org.koitharu.kotatsu.list.ui.adapter.loadingStateAD
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.search.ui.SearchActivity
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class AlternativesActivity : BaseActivity<ActivityAlternativesBinding>(),
+	OnListItemClickListener<MangaAlternativeModel> {
+
+	@Inject
+	lateinit var coil: ImageLoader
+
+	private val viewModel by viewModels<AlternativesViewModel>()
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		setContentView(ActivityAlternativesBinding.inflate(layoutInflater))
+		supportActionBar?.run {
+			setDisplayHomeAsUpEnabled(true)
+			subtitle = viewModel.manga.title
+		}
+		val listAdapter = BaseListAdapter<ListModel>()
+			.addDelegate(ListItemType.MANGA_LIST_DETAILED, alternativeAD(coil, this, this))
+			.addDelegate(ListItemType.STATE_EMPTY, emptyStateListAD(coil, this, null))
+			.addDelegate(ListItemType.FOOTER_LOADING, loadingFooterAD())
+			.addDelegate(ListItemType.STATE_LOADING, loadingStateAD())
+		with(viewBinding.recyclerView) {
+			setHasFixedSize(true)
+			addItemDecoration(TypedListSpacingDecoration(context, addHorizontalPadding = false))
+			adapter = listAdapter
+		}
+
+		viewModel.onError.observeEvent(this, SnackbarErrorObserver(viewBinding.recyclerView, null))
+		viewModel.content.observe(this, listAdapter)
+		viewModel.onMigrated.observeEvent(this) {
+			Toast.makeText(this, R.string.migration_completed, Toast.LENGTH_SHORT).show()
+			startActivity(DetailsActivity.newIntent(this, it))
+			finishAfterTransition()
+		}
+	}
+
+	override fun onWindowInsetsChanged(insets: Insets) {
+		viewBinding.root.updatePadding(
+			left = insets.left,
+			right = insets.right,
+		)
+		viewBinding.recyclerView.updatePadding(
+			bottom = insets.bottom + viewBinding.recyclerView.paddingTop,
+		)
+	}
+
+	override fun onItemClick(item: MangaAlternativeModel, view: View) {
+		when (view.id) {
+			R.id.chip_source -> startActivity(SearchActivity.newIntent(this, item.manga.source, viewModel.manga.title))
+			R.id.button_migrate -> confirmMigration(item.manga)
+			else -> startActivity(DetailsActivity.newIntent(this, item.manga))
+		}
+	}
+
+	private fun confirmMigration(target: Manga) {
+		MaterialAlertDialogBuilder(this, DIALOG_THEME_CENTERED)
+			.setIcon(R.drawable.ic_replace)
+			.setTitle(R.string.manga_migration)
+			.setMessage(
+				getString(
+					R.string.migrate_confirmation,
+					viewModel.manga.title,
+					viewModel.manga.source.title,
+					target.title,
+					target.source.title,
+				),
+			)
+			.setNegativeButton(android.R.string.cancel, null)
+			.setPositiveButton(R.string.migrate) { _, _ ->
+				viewModel.migrate(target)
+			}.show()
+	}
+
+	companion object {
+
+		fun newIntent(context: Context, manga: Manga) = Intent(context, AlternativesActivity::class.java)
+			.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga))
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/alternatives/ui/AlternativesViewModel.kt

@@ -0,0 +1,98 @@
+package org.koitharu.kotatsu.alternatives.ui
+
+import androidx.lifecycle.SavedStateHandle
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEmpty
+import kotlinx.coroutines.flow.runningFold
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.alternatives.domain.AlternativesUseCase
+import org.koitharu.kotatsu.alternatives.domain.MigrateUseCase
+import org.koitharu.kotatsu.core.model.chaptersCount
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.parser.MangaIntent
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.core.ui.BaseViewModel
+import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
+import org.koitharu.kotatsu.core.util.ext.call
+import org.koitharu.kotatsu.core.util.ext.require
+import org.koitharu.kotatsu.list.domain.ListExtraProvider
+import org.koitharu.kotatsu.list.ui.model.EmptyState
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.list.ui.model.LoadingFooter
+import org.koitharu.kotatsu.list.ui.model.LoadingState
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
+import javax.inject.Inject
+
+@HiltViewModel
+class AlternativesViewModel @Inject constructor(
+	savedStateHandle: SavedStateHandle,
+	private val mangaRepositoryFactory: MangaRepository.Factory,
+	private val alternativesUseCase: AlternativesUseCase,
+	private val migrateUseCase: MigrateUseCase,
+	private val extraProvider: ListExtraProvider,
+) : BaseViewModel() {
+
+	val manga = savedStateHandle.require<ParcelableManga>(MangaIntent.KEY_MANGA).manga
+
+	val onMigrated = MutableEventFlow<Manga>()
+	val content = MutableStateFlow<List<ListModel>>(listOf(LoadingState))
+	private var migrationJob: Job? = null
+
+	init {
+		launchJob(Dispatchers.Default) {
+			val ref = runCatchingCancellable {
+				mangaRepositoryFactory.create(manga.source).getDetails(manga)
+			}.getOrDefault(manga)
+			val refCount = ref.chaptersCount()
+			alternativesUseCase(ref)
+				.map {
+					MangaAlternativeModel(
+						manga = it,
+						progress = extraProvider.getProgress(it.id),
+						referenceChapters = refCount,
+					)
+				}.runningFold<MangaAlternativeModel, List<ListModel>>(listOf(LoadingState)) { acc, item ->
+					acc.filterIsInstance<MangaAlternativeModel>() + item + LoadingFooter()
+				}.onEmpty {
+					emit(
+						listOf(
+							EmptyState(
+								icon = R.drawable.ic_empty_common,
+								textPrimary = R.string.nothing_found,
+								textSecondary = R.string.text_search_holder_secondary,
+								actionStringRes = 0,
+							),
+						),
+					)
+				}.collect {
+					content.value = it
+				}
+			content.value = content.value.filterNot { it is LoadingFooter }
+		}
+	}
+
+	fun migrate(target: Manga) {
+		if (migrationJob?.isActive == true) {
+			return
+		}
+		migrationJob = launchLoadingJob(Dispatchers.Default) {
+			migrateUseCase(manga, target)
+			onMigrated.call(target)
+		}
+	}
+
+	private suspend fun mapList(list: List<Manga>, refCount: Int): List<MangaAlternativeModel> {
+		return list.map {
+			MangaAlternativeModel(
+				manga = it,
+				progress = extraProvider.getProgress(it.id),
+				referenceChapters = refCount,
+			)
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/alternatives/ui/MangaAlternativeModel.kt

@@ -0,0 +1,21 @@
+package org.koitharu.kotatsu.alternatives.ui
+
+import org.koitharu.kotatsu.core.model.chaptersCount
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.Manga
+
+data class MangaAlternativeModel(
+	val manga: Manga,
+	val progress: Float,
+	private val referenceChapters: Int,
+) : ListModel {
+
+	val chaptersCount = manga.chaptersCount()
+
+	val chaptersDiff: Int
+		get() = if (referenceChapters == 0 || chaptersCount == 0) 0 else chaptersCount - referenceChapters
+
+	override fun areItemsTheSame(other: ListModel): Boolean {
+		return other is MangaAlternativeModel && other.manga.id == manga.id
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/bookmarks/ui/BookmarksFragment.kt

@@ -25,11 +25,12 @@ import org.koitharu.kotatsu.core.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.ui.list.fastscroll.FastScroller
 import org.koitharu.kotatsu.core.ui.util.ReversibleActionObserver
+import org.koitharu.kotatsu.core.util.ext.findAppCompatDelegate
 import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.core.util.ext.observeEvent
 import org.koitharu.kotatsu.databinding.FragmentListSimpleBinding
 import org.koitharu.kotatsu.details.ui.DetailsActivity
-import org.koitharu.kotatsu.list.ui.MangaListSpanResolver
+import org.koitharu.kotatsu.list.ui.GridSpanResolver
 import org.koitharu.kotatsu.list.ui.adapter.ListHeaderClickListener
 import org.koitharu.kotatsu.list.ui.adapter.ListItemType
 import org.koitharu.kotatsu.list.ui.adapter.ListStateHolderListener
@@ -71,7 +72,7 @@ class BookmarksFragment :
 	) {
 		super.onViewBindingCreated(binding, savedInstanceState)
 		selectionController = ListSelectionController(
-			activity = requireActivity(),
+			appCompatDelegate = checkNotNull(findAppCompatDelegate()),
 			decoration = BookmarksSelectionDecoration(binding.root.context),
 			registryOwner = this,
 			callback = this,
@@ -85,7 +86,7 @@ class BookmarksFragment :
 		val spanSizeLookup = SpanSizeLookup()
 		with(binding.recyclerView) {
 			setHasFixedSize(true)
-			val spanResolver = MangaListSpanResolver(resources)
+			val spanResolver = GridSpanResolver(resources)
 			addItemDecoration(TypedListSpacingDecoration(context, false))
 			adapter = bookmarksAdapter
 			addOnLayoutChangeListener(spanResolver)
@@ -100,7 +101,7 @@ class BookmarksFragment :
 		}
 		viewModel.onError.observeEvent(
 			viewLifecycleOwner,
-			SnackbarErrorObserver(binding.recyclerView, this)
+			SnackbarErrorObserver(binding.recyclerView, this),
 		)
 		viewModel.onActionDone.observeEvent(viewLifecycleOwner, ReversibleActionObserver(binding.recyclerView))
 	}
@@ -206,10 +207,11 @@ class BookmarksFragment :
 	companion object {
 
 		@Deprecated(
-			"", ReplaceWith(
+			"",
+			ReplaceWith(
 				"BookmarksFragment()",
-				"org.koitharu.kotatsu.bookmarks.ui.BookmarksFragment"
-			)
+				"org.koitharu.kotatsu.bookmarks.ui.BookmarksFragment",
+			),
 		)
 		fun newInstance() = BookmarksFragment()
 	}

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

@@ -3,12 +3,12 @@ package org.koitharu.kotatsu.bookmarks.ui.adapter
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
-import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.core.ui.image.CoverSizeResolver
 import org.koitharu.kotatsu.core.ui.list.AdapterDelegateClickListenerAdapter
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.util.ext.decodeRegion
+import org.koitharu.kotatsu.core.util.ext.defaultPlaceholders
 import org.koitharu.kotatsu.core.util.ext.enqueueWith
 import org.koitharu.kotatsu.core.util.ext.newImageRequest
 import org.koitharu.kotatsu.core.util.ext.source
@@ -29,9 +29,7 @@ fun bookmarkListAD(
 	bind {
 		binding.imageViewThumb.newImageRequest(lifecycleOwner, item.imageLoadData)?.run {
 			size(CoverSizeResolver(binding.imageViewThumb))
-			placeholder(R.drawable.ic_placeholder)
-			fallback(R.drawable.ic_placeholder)
-			error(R.drawable.ic_error_placeholder)
+			defaultPlaceholders(context)
 			allowRgb565(true)
 			tag(item)
 			decodeRegion(item.scroll)

app/src/main/kotlin/org/koitharu/kotatsu/bookmarks/ui/sheet/BookmarkLargeAD.kt

@@ -3,12 +3,12 @@ package org.koitharu.kotatsu.bookmarks.ui.sheet
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
-import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.core.ui.image.CoverSizeResolver
 import org.koitharu.kotatsu.core.ui.list.AdapterDelegateClickListenerAdapter
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.util.ext.decodeRegion
+import org.koitharu.kotatsu.core.util.ext.defaultPlaceholders
 import org.koitharu.kotatsu.core.util.ext.enqueueWith
 import org.koitharu.kotatsu.core.util.ext.newImageRequest
 import org.koitharu.kotatsu.core.util.ext.source
@@ -30,9 +30,7 @@ fun bookmarkLargeAD(
 	bind {
 		binding.imageViewThumb.newImageRequest(lifecycleOwner, item.imageLoadData)?.run {
 			size(CoverSizeResolver(binding.imageViewThumb))
-			placeholder(R.drawable.ic_placeholder)
-			fallback(R.drawable.ic_placeholder)
-			error(R.drawable.ic_error_placeholder)
+			defaultPlaceholders(context)
 			allowRgb565(true)
 			tag(item)
 			decodeRegion(item.scroll)

app/src/main/kotlin/org/koitharu/kotatsu/bookmarks/ui/sheet/BookmarksSheet.kt

@@ -1,169 +0,0 @@
-package org.koitharu.kotatsu.bookmarks.ui.sheet
-
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.fragment.app.FragmentManager
-import androidx.fragment.app.viewModels
-import androidx.recyclerview.widget.GridLayoutManager
-import coil.ImageLoader
-import dagger.hilt.android.AndroidEntryPoint
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.bookmarks.domain.Bookmark
-import org.koitharu.kotatsu.core.exceptions.resolve.SnackbarErrorObserver
-import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
-import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
-import org.koitharu.kotatsu.core.ui.sheet.AdaptiveSheetBehavior
-import org.koitharu.kotatsu.core.ui.sheet.AdaptiveSheetCallback
-import org.koitharu.kotatsu.core.ui.sheet.BaseAdaptiveSheet
-import org.koitharu.kotatsu.core.util.RecyclerViewScrollCallback
-import org.koitharu.kotatsu.core.util.ext.observe
-import org.koitharu.kotatsu.core.util.ext.observeEvent
-import org.koitharu.kotatsu.core.util.ext.plus
-import org.koitharu.kotatsu.core.util.ext.showDistinct
-import org.koitharu.kotatsu.core.util.ext.withArgs
-import org.koitharu.kotatsu.databinding.SheetPagesBinding
-import org.koitharu.kotatsu.list.ui.MangaListSpanResolver
-import org.koitharu.kotatsu.list.ui.adapter.ListItemType
-import org.koitharu.kotatsu.list.ui.adapter.TypedListSpacingDecoration
-import org.koitharu.kotatsu.list.ui.model.ListModel
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.reader.ui.ReaderActivity.IntentBuilder
-import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
-import org.koitharu.kotatsu.reader.ui.thumbnails.OnPageSelectListener
-import org.koitharu.kotatsu.reader.ui.thumbnails.PageThumbnail
-import javax.inject.Inject
-import kotlin.math.roundToInt
-
-@AndroidEntryPoint
-class BookmarksSheet :
-	BaseAdaptiveSheet<SheetPagesBinding>(),
-	AdaptiveSheetCallback,
-	OnListItemClickListener<Bookmark> {
-
-	private val viewModel by viewModels<BookmarksSheetViewModel>()
-
-	@Inject
-	lateinit var coil: ImageLoader
-
-	@Inject
-	lateinit var settings: AppSettings
-
-	private var bookmarksAdapter: BookmarksAdapter? = null
-	private var spanResolver: MangaListSpanResolver? = null
-
-	private val spanSizeLookup = SpanSizeLookup()
-	private val listCommitCallback = Runnable {
-		spanSizeLookup.invalidateCache()
-	}
-
-	override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): SheetPagesBinding {
-		return SheetPagesBinding.inflate(inflater, container, false)
-	}
-
-	override fun onViewBindingCreated(binding: SheetPagesBinding, savedInstanceState: Bundle?) {
-		super.onViewBindingCreated(binding, savedInstanceState)
-		addSheetCallback(this)
-		spanResolver = MangaListSpanResolver(binding.root.resources)
-		bookmarksAdapter = BookmarksAdapter(
-			coil = coil,
-			lifecycleOwner = viewLifecycleOwner,
-			clickListener = this@BookmarksSheet,
-			headerClickListener = null,
-		)
-		viewBinding?.headerBar?.setTitle(R.string.bookmarks)
-		with(binding.recyclerView) {
-			addItemDecoration(TypedListSpacingDecoration(context, false))
-			adapter = bookmarksAdapter
-			addOnLayoutChangeListener(spanResolver)
-			spanResolver?.setGridSize(settings.gridSize / 100f, this)
-			(layoutManager as GridLayoutManager).spanSizeLookup = spanSizeLookup
-		}
-		viewModel.content.observe(viewLifecycleOwner, ::onThumbnailsChanged)
-		viewModel.onError.observeEvent(viewLifecycleOwner, SnackbarErrorObserver(binding.recyclerView, this))
-	}
-
-	override fun onDestroyView() {
-		spanResolver = null
-		bookmarksAdapter = null
-		spanSizeLookup.invalidateCache()
-		super.onDestroyView()
-	}
-
-	override fun onItemClick(item: Bookmark, view: View) {
-		val listener = (parentFragment as? OnPageSelectListener) ?: (activity as? OnPageSelectListener)
-		if (listener != null) {
-			listener.onPageSelected(ReaderPage(item.toMangaPage(), item.page, item.chapterId))
-		} else {
-			val intent = IntentBuilder(view.context)
-				.manga(viewModel.manga)
-				.bookmark(item)
-				.incognito(true)
-				.build()
-			startActivity(intent)
-		}
-		dismiss()
-	}
-
-	override fun onStateChanged(sheet: View, newState: Int) {
-		viewBinding?.recyclerView?.isFastScrollerEnabled = newState == AdaptiveSheetBehavior.STATE_EXPANDED
-	}
-
-	private fun onThumbnailsChanged(list: List<ListModel>) {
-		val adapter = bookmarksAdapter ?: return
-		if (adapter.itemCount == 0) {
-			var position = list.indexOfFirst { it is PageThumbnail && it.isCurrent }
-			if (position > 0) {
-				val spanCount = spanResolver?.spanCount ?: 0
-				val offset = if (position > spanCount + 1) {
-					(resources.getDimensionPixelSize(R.dimen.manga_list_details_item_height) * 0.6).roundToInt()
-				} else {
-					position = 0
-					0
-				}
-				val scrollCallback = RecyclerViewScrollCallback(requireViewBinding().recyclerView, position, offset)
-				adapter.setItems(list, listCommitCallback + scrollCallback)
-			} else {
-				adapter.setItems(list, listCommitCallback)
-			}
-		} else {
-			adapter.setItems(list, listCommitCallback)
-		}
-	}
-
-	private inner class SpanSizeLookup : GridLayoutManager.SpanSizeLookup() {
-
-		init {
-			isSpanIndexCacheEnabled = true
-			isSpanGroupIndexCacheEnabled = true
-		}
-
-		override fun getSpanSize(position: Int): Int {
-			val total = (viewBinding?.recyclerView?.layoutManager as? GridLayoutManager)?.spanCount ?: return 1
-			return when (bookmarksAdapter?.getItemViewType(position)) {
-				ListItemType.PAGE_THUMB.ordinal -> 1
-				else -> total
-			}
-		}
-
-		fun invalidateCache() {
-			invalidateSpanGroupIndexCache()
-			invalidateSpanIndexCache()
-		}
-	}
-
-	companion object {
-
-		const val ARG_MANGA = "manga"
-
-		private const val TAG = "BookmarksSheet"
-
-		fun show(fm: FragmentManager, manga: Manga) {
-			BookmarksSheet().withArgs(1) {
-				putParcelable(ARG_MANGA, ParcelableManga(manga))
-			}.showDistinct(fm, TAG)
-		}
-	}
-}

app/src/main/kotlin/org/koitharu/kotatsu/bookmarks/ui/sheet/BookmarksSheetViewModel.kt

@@ -1,55 +0,0 @@
-package org.koitharu.kotatsu.bookmarks.ui.sheet
-
-import androidx.lifecycle.SavedStateHandle
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.plus
-import org.koitharu.kotatsu.bookmarks.domain.Bookmark
-import org.koitharu.kotatsu.bookmarks.domain.BookmarksRepository
-import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
-import org.koitharu.kotatsu.core.parser.MangaRepository
-import org.koitharu.kotatsu.core.ui.BaseViewModel
-import org.koitharu.kotatsu.core.util.ext.require
-import org.koitharu.kotatsu.list.ui.model.ListHeader
-import org.koitharu.kotatsu.list.ui.model.ListModel
-import org.koitharu.kotatsu.list.ui.model.LoadingFooter
-import org.koitharu.kotatsu.parsers.util.SuspendLazy
-import javax.inject.Inject
-
-@HiltViewModel
-class BookmarksSheetViewModel @Inject constructor(
-	savedStateHandle: SavedStateHandle,
-	mangaRepositoryFactory: MangaRepository.Factory,
-	bookmarksRepository: BookmarksRepository,
-) : BaseViewModel() {
-
-	val manga = savedStateHandle.require<ParcelableManga>(BookmarksSheet.ARG_MANGA).manga
-	private val chaptersLazy = SuspendLazy {
-		requireNotNull(manga.chapters ?: mangaRepositoryFactory.create(manga.source).getDetails(manga).chapters)
-	}
-
-	val content: StateFlow<List<ListModel>> = bookmarksRepository.observeBookmarks(manga)
-		.map { mapList(it) }
-		.withErrorHandling()
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Lazily, listOf(LoadingFooter()))
-
-	private suspend fun mapList(bookmarks: List<Bookmark>): List<ListModel> {
-		val chapters = chaptersLazy.get()
-		val bookmarksMap = bookmarks.groupBy { it.chapterId }
-		val result = ArrayList<ListModel>(bookmarks.size + bookmarksMap.size)
-		for (chapter in chapters) {
-			val b = bookmarksMap[chapter.id]
-			if (b.isNullOrEmpty()) {
-				continue
-			}
-			result += ListHeader(chapter.name)
-			result.addAll(b)
-		}
-		return result
-	}
-}

app/src/main/kotlin/org/koitharu/kotatsu/browser/BrowserActivity.kt

@@ -1,6 +1,5 @@
 package org.koitharu.kotatsu.browser
 
-import android.annotation.SuppressLint
 import android.content.ActivityNotFoundException
 import android.content.Context
 import android.content.Intent
@@ -12,31 +11,42 @@ import android.webkit.CookieManager
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
+import dagger.hilt.android.AndroidEntryPoint
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.network.CommonHeaders
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.core.ui.BaseActivity
-import org.koitharu.kotatsu.core.util.ext.catchingWebViewUnavailability
+import org.koitharu.kotatsu.core.util.ext.configureForParser
+import org.koitharu.kotatsu.core.util.ext.getSerializableExtraCompat
+import org.koitharu.kotatsu.core.util.ext.toUriOrNull
 import org.koitharu.kotatsu.databinding.ActivityBrowserBinding
-import org.koitharu.kotatsu.parsers.network.UserAgents
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import javax.inject.Inject
 import com.google.android.material.R as materialR
 
-@SuppressLint("SetJavaScriptEnabled")
+@AndroidEntryPoint
 class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback {
 
 	private lateinit var onBackPressedCallback: WebViewBackPressedCallback
 
+	@Inject
+	lateinit var mangaRepositoryFactory: MangaRepository.Factory
+
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
-		if (!catchingWebViewUnavailability { setContentView(ActivityBrowserBinding.inflate(layoutInflater)) }) {
+		if (!setContentViewWebViewSafe { ActivityBrowserBinding.inflate(layoutInflater) }) {
 			return
 		}
 		supportActionBar?.run {
 			setDisplayHomeAsUpEnabled(true)
 			setHomeAsUpIndicator(materialR.drawable.abc_ic_clear_material)
 		}
-		with(viewBinding.webView.settings) {
-			javaScriptEnabled = true
-			userAgentString = UserAgents.CHROME_MOBILE
+		val userAgent = intent?.getSerializableExtraCompat<MangaSource>(EXTRA_SOURCE)?.let { source ->
+			val repository = mangaRepositoryFactory.create(source) as? RemoteMangaRepository
+			repository?.headers?.get(CommonHeaders.USER_AGENT)
 		}
+		viewBinding.webView.configureForParser(userAgent)
 		CookieManager.getInstance().setAcceptThirdPartyCookies(viewBinding.webView, true)
 		viewBinding.webView.webViewClient = BrowserClient(this)
 		viewBinding.webView.webChromeClient = ProgressChromeClient(viewBinding.progressBar)
@@ -57,16 +67,6 @@ class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback
 		}
 	}
 
-	override fun onSaveInstanceState(outState: Bundle) {
-		super.onSaveInstanceState(outState)
-		viewBinding.webView.saveState(outState)
-	}
-
-	override fun onRestoreInstanceState(savedInstanceState: Bundle) {
-		super.onRestoreInstanceState(savedInstanceState)
-		viewBinding.webView.restoreState(savedInstanceState)
-	}
-
 	override fun onCreateOptionsMenu(menu: Menu): Boolean {
 		super.onCreateOptionsMenu(menu)
 		menuInflater.inflate(R.menu.opt_browser, menu)
@@ -81,11 +81,14 @@ class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback
 		}
 
 		R.id.action_browser -> {
-			val intent = Intent(Intent.ACTION_VIEW)
-			intent.data = Uri.parse(viewBinding.webView.url)
-			try {
-				startActivity(Intent.createChooser(intent, item.title))
-			} catch (_: ActivityNotFoundException) {
+			val url = viewBinding.webView.url?.toUriOrNull()
+			if (url != null) {
+				val intent = Intent(Intent.ACTION_VIEW)
+				intent.data = url
+				try {
+					startActivity(Intent.createChooser(intent, item.title))
+				} catch (_: ActivityNotFoundException) {
+				}
 			}
 			true
 		}
@@ -136,11 +139,13 @@ class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback
 	companion object {
 
 		private const val EXTRA_TITLE = "title"
+		private const val EXTRA_SOURCE = "source"
 
-		fun newIntent(context: Context, url: String, title: String?): Intent {
+		fun newIntent(context: Context, url: String, source: MangaSource?, title: String?): Intent {
 			return Intent(context, BrowserActivity::class.java)
 				.setData(Uri.parse(url))
 				.putExtra(EXTRA_TITLE, title)
+				.putExtra(EXTRA_SOURCE, source)
 		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/browser/cloudflare/CaptchaNotifier.kt

@@ -20,7 +20,7 @@ class CaptchaNotifier(
 ) : EventListener {
 
 	fun notify(exception: CloudFlareProtectedException) {
-		if (!context.checkNotificationPermission()) {
+		if (!context.checkNotificationPermission(CHANNEL_ID)) {
 			return
 		}
 		val manager = NotificationManagerCompat.from(context)
@@ -40,6 +40,7 @@ class CaptchaNotifier(
 			.setPriority(NotificationCompat.PRIORITY_DEFAULT)
 			.setDefaults(NotificationCompat.DEFAULT_SOUND)
 			.setSmallIcon(android.R.drawable.stat_notify_error)
+			.setGroup(GROUP_CAPTCHA)
 			.setAutoCancel(true)
 			.setVisibility(
 				if (exception.source?.contentType == ContentType.HENTAI) {
@@ -82,5 +83,6 @@ class CaptchaNotifier(
 		private const val PARAM_IGNORE_CAPTCHA = "ignore_captcha"
 		private const val CHANNEL_ID = "captcha"
 		private const val TAG = CHANNEL_ID
+		private const val GROUP_CAPTCHA = "org.koitharu.kotatsu.CAPTCHA"
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/browser/cloudflare/CloudFlareActivity.kt

@@ -27,9 +27,8 @@ import org.koitharu.kotatsu.core.network.CommonHeaders
 import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
 import org.koitharu.kotatsu.core.ui.BaseActivity
 import org.koitharu.kotatsu.core.util.TaggedActivityResult
-import org.koitharu.kotatsu.core.util.ext.catchingWebViewUnavailability
+import org.koitharu.kotatsu.core.util.ext.configureForParser
 import org.koitharu.kotatsu.databinding.ActivityBrowserBinding
-import org.koitharu.kotatsu.parsers.network.UserAgents
 import javax.inject.Inject
 import com.google.android.material.R as materialR
 
@@ -41,17 +40,12 @@ class CloudFlareActivity : BaseActivity<ActivityBrowserBinding>(), CloudFlareCal
 	@Inject
 	lateinit var cookieJar: MutableCookieJar
 
+	private lateinit var cfClient: CloudFlareClient
 	private var onBackPressedCallback: WebViewBackPressedCallback? = null
 
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
-		if (!catchingWebViewUnavailability {
-				setContentView(
-					ActivityBrowserBinding.inflate(
-						layoutInflater,
-					),
-				)
-			}) {
+		if (!setContentViewWebViewSafe { ActivityBrowserBinding.inflate(layoutInflater) }) {
 			return
 		}
 		supportActionBar?.run {
@@ -59,13 +53,9 @@ class CloudFlareActivity : BaseActivity<ActivityBrowserBinding>(), CloudFlareCal
 			setHomeAsUpIndicator(materialR.drawable.abc_ic_clear_material)
 		}
 		val url = intent?.dataString.orEmpty()
-		with(viewBinding.webView.settings) {
-			javaScriptEnabled = true
-			domStorageEnabled = true
-			databaseEnabled = true
-			userAgentString = intent?.getStringExtra(ARG_UA) ?: UserAgents.CHROME_MOBILE
-		}
-		viewBinding.webView.webViewClient = CloudFlareClient(cookieJar, this, url)
+		cfClient = CloudFlareClient(cookieJar, this, url)
+		viewBinding.webView.configureForParser(intent?.getStringExtra(ARG_UA))
+		viewBinding.webView.webViewClient = cfClient
 		onBackPressedCallback = WebViewBackPressedCallback(viewBinding.webView).also {
 			onBackPressedDispatcher.addCallback(it)
 		}
@@ -91,16 +81,6 @@ class CloudFlareActivity : BaseActivity<ActivityBrowserBinding>(), CloudFlareCal
 		super.onDestroy()
 	}
 
-	override fun onSaveInstanceState(outState: Bundle) {
-		super.onSaveInstanceState(outState)
-		viewBinding.webView.saveState(outState)
-	}
-
-	override fun onRestoreInstanceState(savedInstanceState: Bundle) {
-		super.onRestoreInstanceState(savedInstanceState)
-		viewBinding.webView.restoreState(savedInstanceState)
-	}
-
 	override fun onCreateOptionsMenu(menu: Menu?): Boolean {
 		menuInflater.inflate(R.menu.opt_captcha, menu)
 		return super.onCreateOptionsMenu(menu)
@@ -125,15 +105,7 @@ class CloudFlareActivity : BaseActivity<ActivityBrowserBinding>(), CloudFlareCal
 		}
 
 		R.id.action_retry -> {
-			lifecycleScope.launch {
-				viewBinding.webView.stopLoading()
-				yield()
-				val targetUrl = intent?.dataString?.toHttpUrlOrNull()
-				if (targetUrl != null) {
-					clearCfCookies(targetUrl)
-					viewBinding.webView.loadUrl(targetUrl.toString())
-				}
-			}
+			restartCheck()
 			true
 		}
 
@@ -159,6 +131,10 @@ class CloudFlareActivity : BaseActivity<ActivityBrowserBinding>(), CloudFlareCal
 		viewBinding.progressBar.isInvisible = true
 	}
 
+	override fun onLoopDetected() {
+		restartCheck()
+	}
+
 	override fun onCheckPassed() {
 		pendingResult = RESULT_OK
 		finishAfterTransition()
@@ -178,10 +154,23 @@ class CloudFlareActivity : BaseActivity<ActivityBrowserBinding>(), CloudFlareCal
 			subtitle?.toString()?.toHttpUrlOrNull()?.topPrivateDomain() ?: subtitle
 	}
 
+	private fun restartCheck() {
+		lifecycleScope.launch {
+			viewBinding.webView.stopLoading()
+			yield()
+			cfClient.reset()
+			val targetUrl = intent?.dataString?.toHttpUrlOrNull()
+			if (targetUrl != null) {
+				clearCfCookies(targetUrl)
+				viewBinding.webView.loadUrl(targetUrl.toString())
+			}
+		}
+	}
+
 	private suspend fun clearCfCookies(url: HttpUrl) = runInterruptible(Dispatchers.Default) {
 		cookieJar.removeCookies(url) { cookie ->
 			val name = cookie.name
-			name.startsWith("cf_") || name.startsWith("_cf") || name.startsWith("__cf")
+			name.startsWith("cf_") || name.startsWith("_cf") || name.startsWith("__cf") || name == "csrftoken"
 		}
 	}
 

app/src/main/kotlin/org/koitharu/kotatsu/browser/cloudflare/CloudFlareCallback.kt

@@ -11,4 +11,6 @@ interface CloudFlareCallback : BrowserCallback {
 	fun onPageLoaded()
 
 	fun onCheckPassed()
+
+	fun onLoopDetected()
 }

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

@@ -7,6 +7,7 @@ import org.koitharu.kotatsu.browser.BrowserClient
 import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
 
 private const val CF_CLEARANCE = "cf_clearance"
+private const val LOOP_COUNTER = 3
 
 class CloudFlareClient(
 	private val cookieJar: MutableCookieJar,
@@ -15,6 +16,7 @@ class CloudFlareClient(
 ) : BrowserClient(callback) {
 
 	private val oldClearance = getClearance()
+	private var counter = 0
 
 	override fun onPageStarted(view: WebView?, url: String?, favicon: Bitmap?) {
 		super.onPageStarted(view, url, favicon)
@@ -31,10 +33,20 @@ class CloudFlareClient(
 		callback.onPageLoaded()
 	}
 
+	fun reset() {
+		counter = 0
+	}
+
 	private fun checkClearance() {
 		val clearance = getClearance()
 		if (clearance != null && clearance != oldClearance) {
 			callback.onCheckPassed()
+		} else {
+			counter++
+			if (counter >= LOOP_COUNTER) {
+				reset()
+				callback.onLoopDetected()
+			}
 		}
 	}
 

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

@@ -40,9 +40,9 @@ import org.koitharu.kotatsu.core.parser.favicon.FaviconFetcher
 import org.koitharu.kotatsu.core.ui.image.CoilImageGetter
 import org.koitharu.kotatsu.core.ui.util.ActivityRecreationHandle
 import org.koitharu.kotatsu.core.util.AcraScreenLogger
-import org.koitharu.kotatsu.core.util.IncognitoModeIndicator
 import org.koitharu.kotatsu.core.util.ext.connectivityManager
 import org.koitharu.kotatsu.core.util.ext.isLowRamDevice
+import org.koitharu.kotatsu.details.ui.pager.pages.MangaPageFetcher
 import org.koitharu.kotatsu.local.data.CacheDir
 import org.koitharu.kotatsu.local.data.CbzFetcher
 import org.koitharu.kotatsu.local.data.LocalStorageChanges
@@ -50,7 +50,6 @@ import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.main.domain.CoverRestoreInterceptor
 import org.koitharu.kotatsu.main.ui.protect.AppProtectHelper
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
-import org.koitharu.kotatsu.reader.ui.thumbnails.MangaPageFetcher
 import org.koitharu.kotatsu.search.ui.MangaSuggestionsProvider
 import org.koitharu.kotatsu.settings.backup.BackupObserver
 import org.koitharu.kotatsu.sync.domain.SyncController
@@ -147,12 +146,10 @@ interface AppModule {
 		fun provideActivityLifecycleCallbacks(
 			appProtectHelper: AppProtectHelper,
 			activityRecreationHandle: ActivityRecreationHandle,
-			incognitoModeIndicator: IncognitoModeIndicator,
 			acraScreenLogger: AcraScreenLogger,
 		): Set<@JvmSuppressWildcards Application.ActivityLifecycleCallbacks> = arraySetOf(
 			appProtectHelper,
 			activityRecreationHandle,
-			incognitoModeIndicator,
 			acraScreenLogger,
 		)
 

app/src/main/kotlin/org/koitharu/kotatsu/core/backup/BackupZipInput.kt

@@ -6,12 +6,14 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.runInterruptible
 import okio.Closeable
 import org.json.JSONArray
+import org.koitharu.kotatsu.core.exceptions.BadBackupFormatException
 import org.koitharu.kotatsu.core.util.ext.processLifecycleScope
 import java.io.File
 import java.util.EnumSet
+import java.util.zip.ZipException
 import java.util.zip.ZipFile
 
-class BackupZipInput(val file: File) : Closeable {
+class BackupZipInput private constructor(val file: File) : Closeable {
 
 	private val zipFile = ZipFile(file)
 
@@ -41,4 +43,17 @@ class BackupZipInput(val file: File) : Closeable {
 			}
 		}
 	}
+
+	companion object {
+
+		fun from(file: File): BackupZipInput = try {
+			val res = BackupZipInput(file)
+			if (res.zipFile.getEntry("index") == null) {
+				throw BadBackupFormatException(null)
+			}
+			res
+		} catch (e: ZipException) {
+			throw BadBackupFormatException(e)
+		}
+	}
 }

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

@@ -54,6 +54,7 @@ class JsonDeserializer(private val json: JSONObject) {
 		page = json.getInt("page"),
 		scroll = json.getDouble("scroll").toFloat(),
 		percent = json.getFloatOrDefault("percent", -1f),
+		chaptersCount = json.getIntOrDefault("chapters", -1),
 		deletedAt = 0L,
 	)
 

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

@@ -41,6 +41,7 @@ class JsonSerializer private constructor(private val json: JSONObject) {
 			put("page", e.page)
 			put("scroll", e.scroll)
 			put("percent", e.percent)
+			put("chapters", e.chaptersCount)
 		},
 	)
 

app/src/main/kotlin/org/koitharu/kotatsu/core/cache/ContentCache.kt

@@ -20,6 +20,8 @@ interface ContentCache {
 
 	fun putRelatedManga(source: MangaSource, url: String, related: SafeDeferred<List<Manga>>)
 
+	fun clear(source: MangaSource)
+
 	data class Key(
 		val source: MangaSource,
 		val url: String,

app/src/main/kotlin/org/koitharu/kotatsu/core/cache/ExpiringLruCache.kt

@@ -7,10 +7,12 @@ class ExpiringLruCache<T>(
 	val maxSize: Int,
 	private val lifetime: Long,
 	private val timeUnit: TimeUnit,
-) {
+) : Iterable<ContentCache.Key> {
 
 	private val cache = LruCache<ContentCache.Key, ExpiringValue<T>>(maxSize)
 
+	override fun iterator(): Iterator<ContentCache.Key> = cache.snapshot().keys.iterator()
+
 	operator fun get(key: ContentCache.Key): T? {
 		val value = cache[key] ?: return null
 		if (value.isExpired) {
@@ -30,4 +32,8 @@ class ExpiringLruCache<T>(
 	fun trimToSize(size: Int) {
 		cache.trimToSize(size)
 	}
+
+	fun remove(key: ContentCache.Key) {
+		cache.remove(key)
+	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/cache/MemoryContentCache.kt

@@ -44,6 +44,12 @@ class MemoryContentCache(application: Application) : ContentCache, ComponentCall
 		relatedMangaCache[ContentCache.Key(source, url)] = related
 	}
 
+	override fun clear(source: MangaSource) {
+		clearCache(detailsCache, source)
+		clearCache(pagesCache, source)
+		clearCache(relatedMangaCache, source)
+	}
+
 	override fun onConfigurationChanged(newConfig: Configuration) = Unit
 
 	override fun onLowMemory() = Unit
@@ -67,4 +73,12 @@ class MemoryContentCache(application: Application) : ContentCache, ComponentCall
 			else -> cache.trimToSize(cache.maxSize / 2)
 		}
 	}
+
+	private fun clearCache(cache: ExpiringLruCache<*>, source: MangaSource) {
+		cache.forEach { key ->
+			if (key.source == source) {
+				cache.remove(key)
+			}
+		}
+	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/cache/StubContentCache.kt

@@ -19,4 +19,6 @@ class StubContentCache : ContentCache {
 	override suspend fun getRelatedManga(source: MangaSource, url: String): List<Manga>? = null
 
 	override fun putRelatedManga(source: MangaSource, url: String, related: SafeDeferred<List<Manga>>) = Unit
+
+	override fun clear(source: MangaSource) = Unit
 }

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

@@ -30,6 +30,8 @@ import org.koitharu.kotatsu.core.db.migrations.Migration14To15
 import org.koitharu.kotatsu.core.db.migrations.Migration15To16
 import org.koitharu.kotatsu.core.db.migrations.Migration16To17
 import org.koitharu.kotatsu.core.db.migrations.Migration17To18
+import org.koitharu.kotatsu.core.db.migrations.Migration18To19
+import org.koitharu.kotatsu.core.db.migrations.Migration19To20
 import org.koitharu.kotatsu.core.db.migrations.Migration1To2
 import org.koitharu.kotatsu.core.db.migrations.Migration2To3
 import org.koitharu.kotatsu.core.db.migrations.Migration3To4
@@ -48,20 +50,22 @@ import org.koitharu.kotatsu.history.data.HistoryDao
 import org.koitharu.kotatsu.history.data.HistoryEntity
 import org.koitharu.kotatsu.scrobbling.common.data.ScrobblingDao
 import org.koitharu.kotatsu.scrobbling.common.data.ScrobblingEntity
+import org.koitharu.kotatsu.stats.data.StatsDao
+import org.koitharu.kotatsu.stats.data.StatsEntity
 import org.koitharu.kotatsu.suggestions.data.SuggestionDao
 import org.koitharu.kotatsu.suggestions.data.SuggestionEntity
 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 = 18
+const val DATABASE_VERSION = 20
 
 @Database(
 	entities = [
 		MangaEntity::class, TagEntity::class, HistoryEntity::class, MangaTagsEntity::class,
 		FavouriteCategoryEntity::class, FavouriteEntity::class, MangaPrefsEntity::class,
 		TrackEntity::class, TrackLogEntity::class, SuggestionEntity::class, BookmarkEntity::class,
-		ScrobblingEntity::class, MangaSourceEntity::class,
+		ScrobblingEntity::class, MangaSourceEntity::class, StatsEntity::class,
 	],
 	version = DATABASE_VERSION,
 )
@@ -90,6 +94,8 @@ abstract class MangaDatabase : RoomDatabase() {
 	abstract fun getScrobblingDao(): ScrobblingDao
 
 	abstract fun getSourcesDao(): MangaSourcesDao
+
+	abstract fun getStatsDao(): StatsDao
 }
 
 fun getDatabaseMigrations(context: Context): Array<Migration> = arrayOf(
@@ -110,6 +116,8 @@ fun getDatabaseMigrations(context: Context): Array<Migration> = arrayOf(
 	Migration15To16(),
 	Migration16To17(context),
 	Migration17To18(),
+	Migration18To19(),
+	Migration19To20(),
 )
 
 fun MangaDatabase(context: Context): MangaDatabase = Room

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

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

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

@@ -29,6 +29,9 @@ abstract class MangaSourcesDao {
 	@Query("SELECT * FROM sources ORDER BY sort_key")
 	abstract fun observeAll(): Flow<List<MangaSourceEntity>>
 
+	@Query("SELECT enabled FROM sources WHERE source = :source")
+	abstract fun observeIsEnabled(source: String): Flow<Boolean>
+
 	@Query("SELECT IFNULL(MAX(sort_key),0) FROM sources")
 	abstract suspend fun getMaxSortKey(): Int
 

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

@@ -1,6 +1,10 @@
 package org.koitharu.kotatsu.core.db.dao
 
-import androidx.room.*
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import androidx.room.Transaction
 import kotlinx.coroutines.flow.Flow
 import org.koitharu.kotatsu.tracker.data.TrackLogEntity
 import org.koitharu.kotatsu.tracker.data.TrackLogWithManga
@@ -12,9 +16,15 @@ interface TrackLogsDao {
 	@Query("SELECT * FROM track_logs ORDER BY created_at DESC LIMIT :limit OFFSET 0")
 	fun observeAll(limit: Int): Flow<List<TrackLogWithManga>>
 
+	@Query("SELECT COUNT(*) FROM track_logs WHERE unread = 1")
+	fun observeUnreadCount(): Flow<Int>
+
 	@Query("DELETE FROM track_logs")
 	suspend fun clear()
 
+	@Query("UPDATE track_logs SET unread = 0 WHERE id = :id")
+	suspend fun markAsRead(id: Long)
+
 	@Insert(onConflict = OnConflictStrategy.REPLACE)
 	suspend fun insert(entity: TrackLogEntity): Long
 
@@ -24,6 +34,9 @@ interface TrackLogsDao {
 	@Query("DELETE FROM track_logs WHERE manga_id NOT IN (SELECT manga_id FROM tracks)")
 	suspend fun gc()
 
+	@Query("DELETE FROM track_logs WHERE id IN (SELECT id FROM track_logs ORDER BY created_at DESC LIMIT 0 OFFSET :size)")
+	suspend fun trim(size: Int)
+
 	@Query("SELECT COUNT(*) FROM track_logs")
 	suspend fun count(): Int
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/db/migrations/Migration18To19.kt

@@ -0,0 +1,12 @@
+package org.koitharu.kotatsu.core.db.migrations
+
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+
+class Migration18To19 : Migration(18, 19) {
+
+	override fun migrate(db: SupportSQLiteDatabase) {
+		db.execSQL("ALTER TABLE history ADD COLUMN `chapters` INTEGER NOT NULL DEFAULT -1")
+		db.execSQL("CREATE TABLE IF NOT EXISTS `stats` (`manga_id` INTEGER NOT NULL, `started_at` INTEGER NOT NULL, `duration` INTEGER NOT NULL, `pages` INTEGER NOT NULL, PRIMARY KEY(`manga_id`, `started_at`), FOREIGN KEY(`manga_id`) REFERENCES `history`(`manga_id`) ON UPDATE NO ACTION ON DELETE CASCADE )")
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/core/db/migrations/Migration19To20.kt

@@ -0,0 +1,18 @@
+package org.koitharu.kotatsu.core.db.migrations
+
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+
+class Migration19To20 : Migration(19, 20) {
+
+	override fun migrate(db: SupportSQLiteDatabase) {
+		db.execSQL("CREATE TABLE tracks_bk (manga_id INTEGER NOT NULL, chapters_total INTEGER NOT NULL, last_chapter_id INTEGER NOT NULL, chapters_new INTEGER NOT NULL, last_check INTEGER NOT NULL, last_notified_id INTEGER NOT NULL, PRIMARY KEY(manga_id))")
+		db.execSQL("INSERT INTO tracks_bk SELECT manga_id, chapters_total, last_chapter_id, chapters_new, last_check, last_notified_id FROM tracks")
+		db.execSQL("DROP TABLE tracks")
+		db.execSQL("CREATE TABLE tracks (`manga_id` INTEGER NOT NULL, `last_chapter_id` INTEGER NOT NULL, `chapters_new` INTEGER NOT NULL, `last_check_time` INTEGER NOT NULL, `last_chapter_date` INTEGER NOT NULL, `last_result` INTEGER NOT NULL, PRIMARY KEY(`manga_id`), FOREIGN KEY(`manga_id`) REFERENCES `manga`(`manga_id`) ON UPDATE NO ACTION ON DELETE CASCADE )")
+		db.execSQL("INSERT INTO tracks SELECT manga_id, last_chapter_id, chapters_new, last_check AS last_check_time, 0 AS last_chapter_date, 0 AS last_result FROM tracks_bk")
+		db.execSQL("DROP TABLE tracks_bk")
+
+		db.execSQL("ALTER TABLE track_logs ADD COLUMN `unread` INTEGER NOT NULL DEFAULT 0")
+	}
+}

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

@@ -0,0 +1,5 @@
+package org.koitharu.kotatsu.core.exceptions
+
+import java.io.IOException
+
+class BadBackupFormatException(cause: Throwable?) : IOException(cause)

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

@@ -0,0 +1,10 @@
+package org.koitharu.kotatsu.core.exceptions
+
+import okhttp3.Headers
+import okio.IOException
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+class CloudFlareBlockedException(
+	val url: String,
+	val source: MangaSource?,
+) : IOException("Blocked by CloudFlare")

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

@@ -0,0 +1,7 @@
+package org.koitharu.kotatsu.core.exceptions
+
+import okio.IOException
+
+class NoDataReceivedException(
+	private val url: String,
+) : IOException("No data has been received from $url")

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

@@ -0,0 +1,8 @@
+package org.koitharu.kotatsu.core.exceptions
+
+import org.koitharu.kotatsu.parsers.model.Manga
+
+class UnsupportedSourceException(
+	message: String?,
+	val manga: Manga?,
+) : IllegalArgumentException(message)

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

@@ -21,7 +21,7 @@ abstract class ErrorObserver(
 	private val onResolved: Consumer<Boolean>?,
 ) : FlowCollector<Throwable> {
 
-	protected val activity = host.context.findActivity()
+	protected open val activity = host.context.findActivity()
 
 	private val lifecycleScope: LifecycleCoroutineScope
 		get() = checkNotNull(fragment?.viewLifecycleScope ?: (activity as? LifecycleOwner)?.lifecycle?.coroutineScope)
@@ -36,7 +36,7 @@ abstract class ErrorObserver(
 	private fun isAlive(): Boolean {
 		return when {
 			fragment != null -> fragment.view != null
-			activity != null -> !activity.isDestroyed
+			activity != null -> activity?.isDestroyed == false
 			else -> true
 		}
 	}

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

@@ -8,13 +8,16 @@ import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
 import okhttp3.Headers
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.alternatives.ui.AlternativesActivity
 import org.koitharu.kotatsu.browser.BrowserActivity
 import org.koitharu.kotatsu.browser.cloudflare.CloudFlareActivity
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
+import org.koitharu.kotatsu.core.exceptions.UnsupportedSourceException
 import org.koitharu.kotatsu.core.ui.dialog.ErrorDetailsDialog
 import org.koitharu.kotatsu.core.util.TaggedActivityResult
 import org.koitharu.kotatsu.parsers.exception.AuthRequiredException
 import org.koitharu.kotatsu.parsers.exception.NotFoundException
+import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.settings.sources.auth.SourceAuthActivity
 import kotlin.coroutines.Continuation
@@ -59,6 +62,11 @@ class ExceptionResolver : ActivityResultCallback<TaggedActivityResult> {
 			false
 		}
 
+		is UnsupportedSourceException -> {
+			e.manga?.let { openAlternatives(it) }
+			false
+		}
+
 		else -> false
 	}
 
@@ -74,7 +82,12 @@ class ExceptionResolver : ActivityResultCallback<TaggedActivityResult> {
 
 	private fun openInBrowser(url: String) {
 		val context = activity ?: fragment?.activity ?: return
-		context.startActivity(BrowserActivity.newIntent(context, url, null))
+		context.startActivity(BrowserActivity.newIntent(context, url, null, null))
+	}
+
+	private fun openAlternatives(manga: Manga) {
+		val context = activity ?: fragment?.activity ?: return
+		context.startActivity(AlternativesActivity.newIntent(context, manga))
 	}
 
 	private fun getFragmentManager() = checkNotNull(fragment?.childFragmentManager ?: activity?.supportFragmentManager)
@@ -86,6 +99,7 @@ class ExceptionResolver : ActivityResultCallback<TaggedActivityResult> {
 			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
+			is UnsupportedSourceException -> if (e.manga != null) R.string.alternatives else 0
 			else -> 0
 		}
 

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

@@ -131,3 +131,19 @@ fun MangaChapter.formatNumber(): String? {
 	}
 	return chaptersNumberFormat.format(number.toDouble())
 }
+
+fun Manga.chaptersCount(): Int {
+	if (chapters.isNullOrEmpty()) {
+		return 0
+	}
+	val counters = MutableObjectIntMap<String?>()
+	var max = 0
+	chapters?.forEach { x ->
+		val c = counters.getOrDefault(x.branch, 0) + 1
+		counters[x.branch] = c
+		if (max < c) {
+			max = c
+		}
+	}
+	return max
+}

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

@@ -4,6 +4,7 @@ import okhttp3.Interceptor
 import okhttp3.Response
 import okhttp3.internal.closeQuietly
 import org.jsoup.Jsoup
+import org.koitharu.kotatsu.core.exceptions.CloudFlareBlockedException
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import java.net.HttpURLConnection.HTTP_FORBIDDEN
@@ -17,14 +18,23 @@ class CloudFlareInterceptor : Interceptor {
 			val content = response.body?.let { response.peekBody(Long.MAX_VALUE) }?.byteStream()?.use {
 				Jsoup.parse(it, Charsets.UTF_8.name(), response.request.url.toString())
 			} ?: return response
-			if (content.getElementById("challenge-error-title") != null) {
+			val hasCaptcha = content.getElementById("challenge-error-title") != null
+			val isBlocked = content.selectFirst("h2[data-translate=\"blocked_why_headline\"]") != null
+			if (hasCaptcha || isBlocked) {
 				val request = response.request
 				response.closeQuietly()
-				throw CloudFlareProtectedException(
-					url = request.url.toString(),
-					source = request.tag(MangaSource::class.java),
-					headers = request.headers,
-				)
+				if (isBlocked) {
+					throw CloudFlareBlockedException(
+						url = request.url.toString(),
+						source = request.tag(MangaSource::class.java),
+					)
+				} else {
+					throw CloudFlareProtectedException(
+						url = request.url.toString(),
+						source = request.tag(MangaSource::class.java),
+						headers = request.headers,
+					)
+				}
 			}
 		}
 		return response

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

@@ -7,11 +7,11 @@ import okhttp3.Interceptor
 import okhttp3.Request
 import okhttp3.Response
 import org.koitharu.kotatsu.BuildConfig
+import org.koitharu.kotatsu.core.parser.MangaLoaderContextImpl
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.network.UserAgents
 import org.koitharu.kotatsu.parsers.util.mergeWith
 import java.net.IDN
 import javax.inject.Inject
@@ -20,6 +20,7 @@ import javax.inject.Singleton
 @Singleton
 class CommonHeadersInterceptor @Inject constructor(
 	private val mangaRepositoryFactoryLazy: Lazy<MangaRepository.Factory>,
+	private val mangaLoaderContextLazy: Lazy<MangaLoaderContextImpl>,
 ) : Interceptor {
 
 	override fun intercept(chain: Interceptor.Chain): Response {
@@ -38,7 +39,7 @@ class CommonHeadersInterceptor @Inject constructor(
 			headersBuilder.mergeWith(it, replaceExisting = false)
 		}
 		if (headersBuilder[CommonHeaders.USER_AGENT] == null) {
-			headersBuilder[CommonHeaders.USER_AGENT] = UserAgents.CHROME_MOBILE
+			headersBuilder[CommonHeaders.USER_AGENT] = mangaLoaderContextLazy.get().getDefaultUserAgent()
 		}
 		if (headersBuilder[CommonHeaders.REFERER] == null && repository != null) {
 			val idn = IDN.toASCII(repository.domain)

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

@@ -1,5 +1,6 @@
 package org.koitharu.kotatsu.core.parser
 
+import org.koitharu.kotatsu.core.exceptions.UnsupportedSourceException
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaParser
 import org.koitharu.kotatsu.parsers.config.ConfigKey
@@ -18,24 +19,20 @@ import java.util.EnumSet
 class DummyParser(context: MangaLoaderContext) : MangaParser(context, MangaSource.DUMMY) {
 
 	override val configKeyDomain: ConfigKey.Domain
-		get() = ConfigKey.Domain("")
+		get() = ConfigKey.Domain("localhost")
 
 	override val availableSortOrders: Set<SortOrder>
 		get() = EnumSet.allOf(SortOrder::class.java)
 
-	override suspend fun getDetails(manga: Manga): Manga {
-		TODO("Not yet implemented")
-	}
+	override suspend fun getDetails(manga: Manga): Manga = stub(manga)
 
-	override suspend fun getList(offset: Int, filter: MangaListFilter?): List<Manga> {
-		TODO("Not yet implemented")
-	}
+	override suspend fun getList(offset: Int, filter: MangaListFilter?): List<Manga> = stub(null)
 
-	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
-		TODO("Not yet implemented")
-	}
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> = stub(null)
 
-	override suspend fun getAvailableTags(): Set<MangaTag> {
-		TODO("Not yet implemented")
+	override suspend fun getAvailableTags(): Set<MangaTag> = stub(null)
+
+	private fun stub(manga: Manga?): Nothing {
+		throw UnsupportedSourceException("Usage of Dummy parser", manga)
 	}
 }

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

@@ -4,18 +4,25 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.util.Base64
 import android.webkit.WebView
+import androidx.annotation.MainThread
 import androidx.core.os.LocaleListCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import org.koitharu.kotatsu.core.network.MangaHttpClient
 import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
 import org.koitharu.kotatsu.core.prefs.SourceSettings
+import org.koitharu.kotatsu.core.util.ext.configureForParser
+import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
+import org.koitharu.kotatsu.core.util.ext.sanitizeHeaderValue
 import org.koitharu.kotatsu.core.util.ext.toList
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.config.MangaSourceConfig
 import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.network.UserAgents
+import org.koitharu.kotatsu.parsers.util.SuspendLazy
 import java.lang.ref.WeakReference
 import java.util.Locale
 import javax.inject.Inject
@@ -32,12 +39,15 @@ class MangaLoaderContextImpl @Inject constructor(
 
 	private var webViewCached: WeakReference<WebView>? = null
 
+	private val userAgentLazy = SuspendLazy {
+		withContext(Dispatchers.Main) {
+			obtainWebView().settings.userAgentString
+		}.sanitizeHeaderValue()
+	}
+
 	@SuppressLint("SetJavaScriptEnabled")
 	override suspend fun evaluateJs(script: String): String? = withContext(Dispatchers.Main) {
-		val webView = webViewCached?.get() ?: WebView(androidContext).also {
-			it.settings.javaScriptEnabled = true
-			webViewCached = WeakReference(it)
-		}
+		val webView = obtainWebView()
 		suspendCoroutine { cont ->
 			webView.evaluateJavascript(script) { result ->
 				cont.resume(result?.takeUnless { it == "null" })
@@ -45,6 +55,14 @@ class MangaLoaderContextImpl @Inject constructor(
 		}
 	}
 
+	override fun getDefaultUserAgent(): String = runCatching {
+		runBlocking {
+			userAgentLazy.get()
+		}
+	}.onFailure { e ->
+		e.printStackTraceDebug()
+	}.getOrDefault(UserAgents.FIREFOX_MOBILE)
+
 	override fun getConfig(source: MangaSource): MangaSourceConfig {
 		return SourceSettings(androidContext, source)
 	}
@@ -60,4 +78,12 @@ class MangaLoaderContextImpl @Inject constructor(
 	override fun getPreferredLocales(): List<Locale> {
 		return LocaleListCompat.getAdjustedDefault().toList()
 	}
+
+	@MainThread
+	private fun obtainWebView(): WebView {
+		return webViewCached?.get() ?: WebView(androidContext).also {
+			it.configureForParser(null)
+			webViewCached = WeakReference(it)
+		}
+	}
 }

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

@@ -171,7 +171,11 @@ class RemoteMangaRepository(
 		return getConfig().isSlowdownEnabled
 	}
 
-	private fun getConfig() = parser.config as SourceSettings
+	fun invalidateCache() {
+		cache.clear(source)
+	}
+
+	fun getConfig() = parser.config as SourceSettings
 
 	private suspend fun <T> asyncSafe(block: suspend CoroutineScope.() -> T): SafeDeferred<T> {
 		var dispatcher = currentCoroutineContext()[CoroutineDispatcher.Key]
@@ -227,6 +231,5 @@ class RemoteMangaRepository(
 		}
 	}
 
-	private fun Result<*>.isValidResult() = exceptionOrNull() !is ParseException
-		&& (getOrNull() as? Collection<*>)?.isEmpty() != true
+	private fun Result<*>.isValidResult() = isSuccess && (getOrNull() as? Collection<*>)?.isEmpty() != true
 }

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

@@ -11,6 +11,7 @@ import androidx.appcompat.app.AppCompatDelegate
 import androidx.collection.ArraySet
 import androidx.core.content.edit
 import androidx.core.os.LocaleListCompat
+import androidx.documentfile.provider.DocumentFile
 import androidx.preference.PreferenceManager
 import dagger.hilt.android.qualifiers.ApplicationContext
 import org.json.JSONArray
@@ -31,6 +32,7 @@ import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.reader.domain.ReaderColorFilter
 import java.io.File
 import java.net.Proxy
+import java.util.EnumSet
 import java.util.Locale
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -70,10 +72,20 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 			}
 		}
 
+	val isNavLabelsVisible: Boolean
+		get() = prefs.getBoolean(KEY_NAV_LABELS, true)
+
+	val isNavBarPinned: Boolean
+		get() = prefs.getBoolean(KEY_NAV_PINNED, false)
+
 	var gridSize: Int
 		get() = prefs.getInt(KEY_GRID_SIZE, 100)
 		set(value) = prefs.edit { putInt(KEY_GRID_SIZE, value) }
 
+	var gridSizePages: Int
+		get() = prefs.getInt(KEY_GRID_SIZE_PAGES, 100)
+		set(value) = prefs.edit { putInt(KEY_GRID_SIZE_PAGES, value) }
+
 	var historyListMode: ListMode
 		get() = prefs.getEnumValue(KEY_LIST_MODE_HISTORY, listMode)
 		set(value) = prefs.edit { putEnumValue(KEY_LIST_MODE_HISTORY, value) }
@@ -111,6 +123,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isReaderZoomButtonsEnabled: Boolean
 		get() = prefs.getBoolean(KEY_READER_ZOOM_BUTTONS, false)
 
+	val isReaderControlAlwaysLTR: Boolean
+		get() = prefs.getBoolean(KEY_READER_CONTROL_LTR, false)
+
 	val isReaderFullscreenEnabled: Boolean
 		get() = prefs.getBoolean(KEY_READER_FULLSCREEN, true)
 
@@ -131,6 +146,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isTrackerWifiOnly: Boolean
 		get() = prefs.getBoolean(KEY_TRACKER_WIFI_ONLY, false)
 
+	val trackerFrequencyFactor: Float
+		get() = prefs.getString(KEY_TRACKER_FREQUENCY, null)?.toFloatOrNull() ?: 1f
+
 	val isTrackerNotificationsEnabled: Boolean
 		get() = prefs.getBoolean(KEY_TRACKER_NOTIFICATIONS, true)
 
@@ -161,6 +179,14 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getBoolean(KEY_HISTORY_GROUPING, true)
 		set(value) = prefs.edit { putBoolean(KEY_HISTORY_GROUPING, value) }
 
+	var isUpdatedGroupingEnabled: Boolean
+		get() = prefs.getBoolean(KEY_UPDATED_GROUPING, true)
+		set(value) = prefs.edit { putBoolean(KEY_UPDATED_GROUPING, value) }
+
+	var isFeedHeaderVisible: Boolean
+		get() = prefs.getBoolean(KEY_FEED_HEADER, true)
+		set(value) = prefs.edit { putBoolean(KEY_FEED_HEADER, value) }
+
 	val isReadingIndicatorsEnabled: Boolean
 		get() = prefs.getBoolean(KEY_READING_INDICATORS, true)
 
@@ -171,10 +197,14 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getBoolean(KEY_INCOGNITO_MODE, false)
 		set(value) = prefs.edit { putBoolean(KEY_INCOGNITO_MODE, value) }
 
-	var chaptersReverse: Boolean
+	var isChaptersReverse: Boolean
 		get() = prefs.getBoolean(KEY_REVERSE_CHAPTERS, false)
 		set(value) = prefs.edit { putBoolean(KEY_REVERSE_CHAPTERS, value) }
 
+	var isChaptersGridView: Boolean
+		get() = prefs.getBoolean(KEY_GRID_VIEW_CHAPTERS, false)
+		set(value) = prefs.edit { putBoolean(KEY_GRID_VIEW_CHAPTERS, value) }
+
 	val zoomMode: ZoomMode
 		get() = prefs.getEnumValue(KEY_ZOOM_MODE, ZoomMode.FIT_CENTER)
 
@@ -184,11 +214,20 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	var appPassword: String?
 		get() = prefs.getString(KEY_APP_PASSWORD, null)
 		set(value) = prefs.edit {
-			if (value != null) putString(KEY_APP_PASSWORD, value) else remove(
-				KEY_APP_PASSWORD,
-			)
+			if (value != null) putString(KEY_APP_PASSWORD, value) else remove(KEY_APP_PASSWORD)
 		}
 
+	var isAppPasswordNumeric: Boolean
+		get() = prefs.getBoolean(KEY_APP_PASSWORD_NUMERIC, false)
+		set(value) = prefs.edit { putBoolean(KEY_APP_PASSWORD_NUMERIC, value) }
+
+	val searchSuggestionTypes: Set<SearchSuggestionType>
+		get() = prefs.getStringSet(KEY_SEARCH_SUGGESTION_TYPES, null)?.let { stringSet ->
+			stringSet.mapNotNullTo(EnumSet.noneOf(SearchSuggestionType::class.java)) { x ->
+				enumValueOf<SearchSuggestionType>(x)
+			}
+		} ?: EnumSet.allOf(SearchSuggestionType::class.java)
+
 	val isLoggingEnabled: Boolean
 		get() = prefs.getBoolean(KEY_LOGGING_ENABLED, false)
 
@@ -208,8 +247,24 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isUnstableUpdatesAllowed: Boolean
 		get() = prefs.getBoolean(KEY_UPDATES_UNSTABLE, false)
 
+	val isPagesTabEnabled: Boolean
+		get() = prefs.getBoolean(KEY_PAGES_TAB, true)
+
 	val defaultDetailsTab: Int
-		get() = prefs.getString(KEY_DETAILS_TAB, null)?.toIntOrNull()?.coerceIn(0, 1) ?: 0
+		get() = if (isPagesTabEnabled) {
+			val raw = prefs.getString(KEY_DETAILS_TAB, null)?.toIntOrNull() ?: 0
+			if (raw == -1) {
+				lastDetailsTab
+			} else {
+				raw
+			}.coerceIn(0, 2)
+		} else {
+			0
+		}
+
+	var lastDetailsTab: Int
+		get() = prefs.getInt(KEY_DETAILS_LAST_TAB, 0)
+		set(value) = prefs.edit { putInt(KEY_DETAILS_LAST_TAB, value) }
 
 	val isContentPrefetchEnabled: Boolean
 		get() {
@@ -270,6 +325,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isDownloadsWiFiOnly: Boolean
 		get() = prefs.getBoolean(KEY_DOWNLOADS_WIFI, false)
 
+	val preferredDownloadFormat: DownloadFormat
+		get() = prefs.getEnumValue(KEY_DOWNLOADS_FORMAT, DownloadFormat.AUTOMATIC)
+
 	var isSuggestionsEnabled: Boolean
 		get() = prefs.getBoolean(KEY_SUGGESTIONS, false)
 		set(value) = prefs.edit { putBoolean(KEY_SUGGESTIONS, value) }
@@ -361,9 +419,13 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isRelatedMangaEnabled: Boolean
 		get() = prefs.getBoolean(KEY_RELATED_MANGA, true)
 
-	val isWebtoonZoomEnable: Boolean
+	val isWebtoonZoomEnabled: Boolean
 		get() = prefs.getBoolean(KEY_WEBTOON_ZOOM, true)
 
+	var isWebtoonGapsEnabled: Boolean
+		get() = prefs.getBoolean(KEY_WEBTOON_GAPS, false)
+		set(value) = prefs.edit { putBoolean(KEY_WEBTOON_GAPS, value) }
+
 	@get:FloatRange(from = 0.0, to = 0.5)
 	val defaultWebtoonZoomOut: Float
 		get() = prefs.getInt(KEY_WEBTOON_ZOOM_OUT, 0).coerceIn(0, 50) / 100f
@@ -406,6 +468,15 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isReadingTimeEstimationEnabled: Boolean
 		get() = prefs.getBoolean(KEY_READING_TIME, true)
 
+	val isPagesSavingAskEnabled: Boolean
+		get() = prefs.getBoolean(KEY_PAGES_SAVE_ASK, true)
+
+	val isStatsEnabled: Boolean
+		get() = prefs.getBoolean(KEY_STATS_ENABLED, false)
+
+	val isAutoLocalChaptersCleanupEnabled: Boolean
+		get() = prefs.getBoolean(KEY_CHAPTERS_CLEAR_AUTO, false)
+
 	fun isTipEnabled(tip: String): Boolean {
 		return prefs.getStringSet(KEY_TIPS_CLOSED, emptySet())?.contains(tip) != true
 	}
@@ -418,6 +489,15 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		prefs.edit { putStringSet(KEY_TIPS_CLOSED, closedTips + tip) }
 	}
 
+	fun getPagesSaveDir(context: Context): DocumentFile? =
+		prefs.getString(KEY_PAGES_SAVE_DIR, null)?.toUriOrNull()?.let {
+			DocumentFile.fromTreeUri(context, it)?.takeIf { it.canWrite() }
+		}
+
+	fun setPagesSaveDir(uri: Uri?) {
+		prefs.edit { putString(KEY_PAGES_SAVE_DIR, uri?.toString()) }
+	}
+
 	fun subscribe(listener: SharedPreferences.OnSharedPreferenceChangeListener) {
 		prefs.registerOnSharedPreferenceChangeListener(listener)
 	}
@@ -480,18 +560,23 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_PAGES_CACHE_CLEAR = "pages_cache_clear"
 		const val KEY_HTTP_CACHE_CLEAR = "http_cache_clear"
 		const val KEY_COOKIES_CLEAR = "cookies_clear"
+		const val KEY_CHAPTERS_CLEAR = "chapters_clear"
+		const val KEY_CHAPTERS_CLEAR_AUTO = "chapters_clear_auto"
 		const val KEY_THUMBS_CACHE_CLEAR = "thumbs_cache_clear"
 		const val KEY_SEARCH_HISTORY_CLEAR = "search_history_clear"
 		const val KEY_UPDATES_FEED_CLEAR = "updates_feed_clear"
 		const val KEY_GRID_SIZE = "grid_size"
+		const val KEY_GRID_SIZE_PAGES = "grid_size_pages"
 		const val KEY_REMOTE_SOURCES = "remote_sources"
 		const val KEY_LOCAL_STORAGE = "local_storage"
 		const val KEY_READER_DOUBLE_PAGES = "reader_double_pages"
 		const val KEY_READER_ZOOM_BUTTONS = "reader_zoom_buttons"
+		const val KEY_READER_CONTROL_LTR = "reader_taps_ltr"
 		const val KEY_READER_FULLSCREEN = "reader_fullscreen"
 		const val KEY_READER_VOLUME_BUTTONS = "reader_volume_buttons"
 		const val KEY_TRACKER_ENABLED = "tracker_enabled"
 		const val KEY_TRACKER_WIFI_ONLY = "tracker_wifi"
+		const val KEY_TRACKER_FREQUENCY = "tracker_freq"
 		const val KEY_TRACK_SOURCES = "track_sources"
 		const val KEY_TRACK_CATEGORIES = "track_categories"
 		const val KEY_TRACK_WARNING = "track_warning"
@@ -505,6 +590,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_READER_MODE = "reader_mode"
 		const val KEY_READER_MODE_DETECT = "reader_mode_detect"
 		const val KEY_APP_PASSWORD = "app_password"
+		const val KEY_APP_PASSWORD_NUMERIC = "app_password_num"
 		const val KEY_PROTECT_APP = "protect_app"
 		const val KEY_PROTECT_APP_BIOMETRIC = "protect_app_bio"
 		const val KEY_APP_VERSION = "app_version"
@@ -516,8 +602,10 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_BACKUP_PERIODICAL_OUTPUT = "backup_periodic_output"
 		const val KEY_BACKUP_PERIODICAL_LAST = "backup_periodic_last"
 		const val KEY_HISTORY_GROUPING = "history_grouping"
+		const val KEY_UPDATED_GROUPING = "updated_grouping"
 		const val KEY_READING_INDICATORS = "reading_indicators"
 		const val KEY_REVERSE_CHAPTERS = "reverse_chapters"
+		const val KEY_GRID_VIEW_CHAPTERS = "grid_view_chapters"
 		const val KEY_HISTORY_EXCLUDE_NSFW = "history_exclude_nsfw"
 		const val KEY_PAGES_NUMBERS = "pages_numbers"
 		const val KEY_SCREENSHOTS_POLICY = "screenshots_policy"
@@ -532,6 +620,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_MAL = "mal"
 		const val KEY_KITSU = "kitsu"
 		const val KEY_DOWNLOADS_WIFI = "downloads_wifi"
+		const val KEY_DOWNLOADS_FORMAT = "downloads_format"
 		const val KEY_ALL_FAVOURITES_VISIBLE = "all_favourites_visible"
 		const val KEY_DOH = "doh"
 		const val KEY_EXIT_CONFIRM = "exit_confirm"
@@ -548,6 +637,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_LOCAL_LIST_ORDER = "local_order"
 		const val KEY_HISTORY_ORDER = "history_order"
 		const val KEY_FAVORITES_ORDER = "fav_order"
+		const val KEY_WEBTOON_GAPS = "webtoon_gaps"
 		const val KEY_WEBTOON_ZOOM = "webtoon_zoom"
 		const val KEY_WEBTOON_ZOOM_OUT = "webtoon_zoom_out"
 		const val KEY_PREFETCH_CONTENT = "prefetch_content"
@@ -573,6 +663,8 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_DISABLE_NSFW = "no_nsfw"
 		const val KEY_RELATED_MANGA = "related_manga"
 		const val KEY_NAV_MAIN = "nav_main"
+		const val KEY_NAV_LABELS = "nav_labels"
+		const val KEY_NAV_PINNED = "nav_pinned"
 		const val KEY_32BIT_COLOR = "enhanced_colors"
 		const val KEY_SOURCES_ORDER = "sources_sort_order"
 		const val KEY_SOURCES_CATALOG = "sources_catalog"
@@ -581,11 +673,16 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_CF_INVERTED = "cf_inverted"
 		const val KEY_CF_GRAYSCALE = "cf_grayscale"
 		const val KEY_IGNORE_DOZE = "ignore_dose"
+		const val KEY_PAGES_TAB = "pages_tab"
 		const val KEY_DETAILS_TAB = "details_tab"
+		const val KEY_DETAILS_LAST_TAB = "details_last_tab"
 		const val KEY_READING_TIME = "reading_time"
-
-		// About
+		const val KEY_PAGES_SAVE_DIR = "pages_dir"
+		const val KEY_PAGES_SAVE_ASK = "pages_dir_ask"
+		const val KEY_STATS_ENABLED = "stats_on"
 		const val KEY_APP_UPDATE = "app_update"
 		const val KEY_APP_TRANSLATION = "about_app_translation"
+		const val KEY_FEED_HEADER = "feed_header"
+		const val KEY_SEARCH_SUGGESTION_TYPES = "search_suggest_types"
 	}
 }

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

@@ -0,0 +1,8 @@
+package org.koitharu.kotatsu.core.prefs
+
+enum class DownloadFormat {
+
+	AUTOMATIC,
+	SINGLE_CBZ,
+	MULTIPLE_CBZ,
+}

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

@@ -17,12 +17,13 @@ enum class NavItem(
 	EXPLORE(R.id.nav_explore, R.string.explore, R.drawable.ic_explore_selector),
 	SUGGESTIONS(R.id.nav_suggestions, R.string.suggestions, R.drawable.ic_suggestion_selector),
 	FEED(R.id.nav_feed, R.string.feed, R.drawable.ic_feed_selector),
+	UPDATED(R.id.nav_updated, R.string.updated, R.drawable.ic_updated_selector),
 	BOOKMARKS(R.id.nav_bookmarks, R.string.bookmarks, R.drawable.ic_bookmark_selector),
 	;
 
 	fun isAvailable(settings: AppSettings): Boolean = when (this) {
 		SUGGESTIONS -> settings.isSuggestionsEnabled
-		FEED -> settings.isTrackerEnabled
+		UPDATED, FEED -> settings.isTrackerEnabled
 		else -> true
 	}
 }

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

@@ -0,0 +1,16 @@
+package org.koitharu.kotatsu.core.prefs
+
+import androidx.annotation.StringRes
+import org.koitharu.kotatsu.R
+
+enum class SearchSuggestionType(
+	@StringRes val titleResId: Int,
+) {
+
+	GENRES(R.string.genres),
+	QUERIES_RECENT(R.string.recent_queries),
+	QUERIES_SUGGEST(R.string.suggested_queries),
+	MANGA(R.string.content_type_manga),
+	SOURCES(R.string.remote_sources),
+	AUTHORS(R.string.authors),
+}

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

@@ -1,18 +1,18 @@
 package org.koitharu.kotatsu.core.prefs
 
 import android.content.Context
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener
 import androidx.core.content.edit
+import okhttp3.internal.isSensitiveHeader
 import org.koitharu.kotatsu.core.util.ext.getEnumValue
 import org.koitharu.kotatsu.core.util.ext.ifNullOrEmpty
 import org.koitharu.kotatsu.core.util.ext.putEnumValue
+import org.koitharu.kotatsu.core.util.ext.sanitizeHeaderValue
 import org.koitharu.kotatsu.parsers.config.ConfigKey
 import org.koitharu.kotatsu.parsers.config.MangaSourceConfig
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.model.SortOrder
 
-private const val KEY_SORT_ORDER = "sort_order"
-private const val KEY_SLOWDOWN = "slowdown"
-
 class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig {
 
 	private val prefs = context.getSharedPreferences(source.name, Context.MODE_PRIVATE)
@@ -27,9 +27,13 @@ class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig
 	@Suppress("UNCHECKED_CAST")
 	override fun <T> get(key: ConfigKey<T>): T {
 		return when (key) {
-			is ConfigKey.UserAgent -> prefs.getString(key.key, key.defaultValue).ifNullOrEmpty { key.defaultValue }
+			is ConfigKey.UserAgent -> prefs.getString(key.key, key.defaultValue)
+				.ifNullOrEmpty { key.defaultValue }
+				.sanitizeHeaderValue()
+
 			is ConfigKey.Domain -> prefs.getString(key.key, key.defaultValue).ifNullOrEmpty { key.defaultValue }
 			is ConfigKey.ShowSuspiciousContent -> prefs.getBoolean(key.key, key.defaultValue)
+			is ConfigKey.SplitByTranslations -> prefs.getBoolean(key.key, key.defaultValue)
 		} as T
 	}
 
@@ -37,7 +41,22 @@ class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig
 		when (key) {
 			is ConfigKey.Domain -> putString(key.key, value as String?)
 			is ConfigKey.ShowSuspiciousContent -> putBoolean(key.key, value as Boolean)
-			is ConfigKey.UserAgent -> putString(key.key, value as String?)
+			is ConfigKey.UserAgent -> putString(key.key, (value as String?)?.sanitizeHeaderValue())
+			is ConfigKey.SplitByTranslations -> putBoolean(key.key, value as Boolean)
 		}
 	}
+
+	fun subscribe(listener: OnSharedPreferenceChangeListener) {
+		prefs.registerOnSharedPreferenceChangeListener(listener)
+	}
+
+	fun unsubscribe(listener: OnSharedPreferenceChangeListener) {
+		prefs.unregisterOnSharedPreferenceChangeListener(listener)
+	}
+
+	companion object {
+
+		const val KEY_SORT_ORDER = "sort_order"
+		const val KEY_SLOWDOWN = "slowdown"
+	}
 }

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

@@ -8,6 +8,7 @@ import android.os.Bundle
 import android.view.KeyEvent
 import android.view.View
 import android.view.ViewGroup
+import android.widget.Toast
 import androidx.annotation.CallSuper
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.view.ActionMode
@@ -29,6 +30,7 @@ import org.koitharu.kotatsu.core.ui.util.ActionModeDelegate
 import org.koitharu.kotatsu.core.ui.util.BaseActivityEntryPoint
 import org.koitharu.kotatsu.core.ui.util.WindowInsetsDelegate
 import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import org.koitharu.kotatsu.core.util.ext.isWebViewUnavailable
 
 @Suppress("LeakingThis")
 abstract class BaseActivity<B : ViewBinding> :
@@ -58,11 +60,11 @@ abstract class BaseActivity<B : ViewBinding> :
 		if (isAmoledTheme) {
 			setTheme(R.style.ThemeOverlay_Kotatsu_Amoled)
 		}
+		putDataToExtras(intent)
 		super.onCreate(savedInstanceState)
 		WindowCompat.setDecorFitsSystemWindows(window, false)
 		insetsDelegate.handleImeInsets = true
 		insetsDelegate.addInsetsListener(this)
-		putDataToExtras(intent)
 	}
 
 	override fun onPostCreate(savedInstanceState: Bundle?) {
@@ -70,7 +72,7 @@ abstract class BaseActivity<B : ViewBinding> :
 		onBackPressedDispatcher.addCallback(actionModeDelegate)
 	}
 
-	override fun onNewIntent(intent: Intent?) {
+	override fun onNewIntent(intent: Intent) {
 		putDataToExtras(intent)
 		super.onNewIntent(intent)
 	}
@@ -125,11 +127,13 @@ abstract class BaseActivity<B : ViewBinding> :
 		val actionModeColor = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 			ColorUtils.compositeColors(
 				ContextCompat.getColor(this, com.google.android.material.R.color.m3_appbar_overlay_color),
-				getThemeColor(R.attr.m3ColorBackground),
+				getThemeColor(com.google.android.material.R.attr.colorSurface),
 			)
 		} else {
-			ContextCompat.getColor(this, R.color.kotatsu_m3_background)
+			ContextCompat.getColor(this, R.color.kotatsu_background)
 		}
+		defaultStatusBarColor = window.statusBarColor
+		window.statusBarColor = actionModeColor
 		val insets = ViewCompat.getRootWindowInsets(viewBinding.root)
 			?.getInsets(WindowInsetsCompat.Type.systemBars()) ?: return
 		findViewById<ActionBarContextView?>(androidx.appcompat.R.id.action_mode_bar).apply {
@@ -138,8 +142,6 @@ abstract class BaseActivity<B : ViewBinding> :
 				topMargin = insets.top
 			}
 		}
-		defaultStatusBarColor = window.statusBarColor
-		window.statusBarColor = actionModeColor
 	}
 
 	@CallSuper
@@ -164,6 +166,21 @@ abstract class BaseActivity<B : ViewBinding> :
 		intent?.putExtra(EXTRA_DATA, intent.data)
 	}
 
+	protected fun setContentViewWebViewSafe(viewBindingProducer: () -> B): Boolean {
+		return try {
+			setContentView(viewBindingProducer())
+			true
+		} catch (e: Exception) {
+			if (e.isWebViewUnavailable()) {
+				Toast.makeText(this, R.string.web_view_unavailable, Toast.LENGTH_LONG).show()
+				finishAfterTransition()
+				false
+			} else {
+				throw e
+			}
+		}
+	}
+
 	companion object {
 
 		const val EXTRA_DATA = "data"

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

@@ -6,7 +6,12 @@ import com.hannesdorfmann.adapterdelegates4.AdapterDelegate
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.asExecutor
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.channels.trySendBlocking
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.onStart
 import org.koitharu.kotatsu.core.util.ContinuationResumeRunnable
 import org.koitharu.kotatsu.list.ui.ListModelDiffCallback
 import org.koitharu.kotatsu.list.ui.adapter.ListItemType
@@ -29,8 +34,9 @@ open class BaseListAdapter<T : ListModel> : AsyncListDifferDelegationAdapter<T>(
 		return this
 	}
 
-	fun addListListener(listListener: ListListener<T>) {
+	fun addListListener(listListener: ListListener<T>): BaseListAdapter<T> {
 		differ.addListListener(listListener)
+		return this
 	}
 
 	fun removeListListener(listListener: ListListener<T>) {
@@ -47,4 +53,14 @@ open class BaseListAdapter<T : ListModel> : AsyncListDifferDelegationAdapter<T>(
 		}
 		return null
 	}
+
+	fun observeItems(): Flow<List<T>> = callbackFlow {
+		val listListener = ListListener<T> { _, list ->
+			trySendBlocking(list)
+		}
+		addListListener(listListener)
+		awaitClose { removeListListener(listListener) }
+	}.onStart {
+		emit(items)
+	}
 }

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

@@ -68,6 +68,13 @@ abstract class BaseViewModel : ViewModel() {
 		errorEvent.call(error)
 	}
 
+	protected inline suspend fun <T> withLoading(block: () -> T): T = try {
+		loadingCounter.increment()
+		block()
+	} finally {
+		loadingCounter.decrement()
+	}
+
 	protected fun MutableStateFlow<Int>.increment() = update { it + 1 }
 
 	protected fun MutableStateFlow<Int>.decrement() = update { it - 1 }

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

@@ -1,6 +1,8 @@
 package org.koitharu.kotatsu.core.ui
 
 import android.content.Intent
+import androidx.annotation.AnyThread
+import androidx.annotation.WorkerThread
 import androidx.lifecycle.lifecycleScope
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineExceptionHandler
@@ -39,8 +41,10 @@ abstract class CoroutineIntentService : BaseService() {
 		}
 	}
 
+	@WorkerThread
 	protected abstract suspend fun processIntent(startId: Int, intent: Intent)
 
+	@AnyThread
 	protected abstract fun onError(startId: Int, error: Throwable)
 
 	private fun errorHandler(startId: Int) = CoroutineExceptionHandler { _, throwable ->

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

@@ -68,6 +68,14 @@ class RecyclerViewAlertDialog private constructor(
 			return this
 		}
 
+		fun setNeutralButton(
+			@StringRes textId: Int,
+			listener: DialogInterface.OnClickListener,
+		): Builder<T> {
+			delegate.setNeutralButton(textId, listener)
+			return this
+		}
+
 		fun setCancelable(isCancelable: Boolean): Builder<T> {
 			delegate.setCancelable(isCancelable)
 			return this

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

@@ -0,0 +1,82 @@
+package org.koitharu.kotatsu.core.ui.image
+
+import android.animation.TimeAnimator
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.ColorFilter
+import android.graphics.PixelFormat
+import android.graphics.drawable.Animatable
+import android.graphics.drawable.Drawable
+import android.view.animation.AccelerateDecelerateInterpolator
+import androidx.core.graphics.ColorUtils
+import androidx.interpolator.view.animation.FastOutSlowInInterpolator
+import com.google.android.material.animation.ArgbEvaluatorCompat
+import org.koitharu.kotatsu.core.util.ext.animatorDurationScale
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import kotlin.math.abs
+import com.google.android.material.R as materialR
+
+class AnimatedPlaceholderDrawable(context: Context) : Drawable(), Animatable, TimeAnimator.TimeListener {
+
+	private val colorLow = context.getThemeColor(materialR.attr.colorBackgroundFloating)
+	private val colorHigh = context.getThemeColor(materialR.attr.colorSurfaceContainer)
+	private var currentColor: Int = colorLow
+	private var alpha: Int = 255
+	private val interpolator = FastOutSlowInInterpolator()
+	private val period = 2000 * context.animatorDurationScale
+	private val timeAnimator = TimeAnimator()
+
+	init {
+		timeAnimator.setTimeListener(this)
+		updateColor()
+	}
+
+	override fun draw(canvas: Canvas) {
+		if (!isRunning) {
+			updateColor()
+			start()
+		}
+		canvas.drawColor(currentColor)
+	}
+
+	override fun setAlpha(alpha: Int) {
+		this.alpha = alpha
+	}
+
+	override fun setColorFilter(colorFilter: ColorFilter?) {
+		throw UnsupportedOperationException("ColorFilter is not supported by PlaceholderDrawable")
+	}
+
+	@Deprecated("Deprecated in Java")
+	override fun getOpacity(): Int = PixelFormat.OPAQUE
+
+	override fun getAlpha(): Int = alpha
+
+	override fun onTimeUpdate(animation: TimeAnimator?, totalTime: Long, deltaTime: Long) {
+		if (callback != null) {
+			updateColor()
+			invalidateSelf()
+		}
+	}
+
+	override fun start() {
+		timeAnimator.start()
+	}
+
+	override fun stop() {
+		timeAnimator.cancel()
+	}
+
+	override fun isRunning(): Boolean = timeAnimator.isStarted
+
+	private fun updateColor() {
+		val ph = period / 2
+		val fraction = abs((System.currentTimeMillis() % period) - ph) / ph.toFloat()
+		var color = ArgbEvaluatorCompat.getInstance()
+			.evaluate(interpolator.getInterpolation(fraction), colorLow, colorHigh)
+		if (alpha != 255) {
+			color = ColorUtils.setAlphaComponent(color, alpha)
+		}
+		currentColor = color
+	}
+}

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

@@ -0,0 +1,162 @@
+package org.koitharu.kotatsu.core.ui.image
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.Outline
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.PixelFormat
+import android.graphics.Rect
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.LayerDrawable
+import android.os.Build
+import androidx.annotation.ReturnThis
+import org.koitharu.kotatsu.core.util.ext.getThemeColorStateList
+import org.koitharu.kotatsu.core.util.ext.resolveDp
+import org.koitharu.kotatsu.parsers.util.toIntUp
+import com.google.android.material.R as materialR
+
+class CardDrawable(
+	context: Context,
+	private var corners: Int,
+) : Drawable() {
+
+	private val cornerSize = context.resources.resolveDp(12f)
+	private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+	private val cornersF = FloatArray(8)
+	private val boundsF = RectF()
+	private val color: ColorStateList
+	private val path = Path()
+	private var alpha = 255
+	private var state: IntArray? = null
+	private var horizontalInset: Int = 0
+
+	init {
+		paint.style = Paint.Style.FILL
+		color = context.getThemeColorStateList(materialR.attr.colorSurfaceContainerHighest)
+			?: ColorStateList.valueOf(Color.TRANSPARENT)
+		setCorners(corners)
+		updateColor()
+	}
+
+	override fun draw(canvas: Canvas) {
+		canvas.drawPath(path, paint)
+	}
+
+	override fun setAlpha(alpha: Int) {
+		this.alpha = alpha
+		updateColor()
+	}
+
+	override fun setColorFilter(colorFilter: ColorFilter?) {
+		paint.colorFilter = colorFilter
+	}
+
+	override fun getColorFilter(): ColorFilter? = paint.colorFilter
+
+	override fun getOutline(outline: Outline) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+			outline.setPath(path)
+		} else if (path.isConvex) {
+			outline.setConvexPath(path)
+		}
+		outline.alpha = 1f
+	}
+
+	override fun getPadding(padding: Rect): Boolean {
+		padding.set(
+			horizontalInset,
+			0,
+			horizontalInset,
+			0,
+		)
+		if (corners or TOP != 0) {
+			padding.top += cornerSize.toIntUp()
+		}
+		if (corners or BOTTOM != 0) {
+			padding.bottom += cornerSize.toIntUp()
+		}
+		return horizontalInset != 0
+	}
+
+	override fun onStateChange(state: IntArray): Boolean {
+		this.state = state
+		if (color.isStateful) {
+			updateColor()
+			return true
+		} else {
+			return false
+		}
+	}
+
+	@Deprecated("Deprecated in Java")
+	override fun getOpacity(): Int = PixelFormat.TRANSPARENT
+
+	override fun onBoundsChange(bounds: Rect) {
+		super.onBoundsChange(bounds)
+		boundsF.set(bounds)
+		boundsF.inset(horizontalInset.toFloat(), 0f)
+		path.reset()
+		path.addRoundRect(boundsF, cornersF, Path.Direction.CW)
+		path.close()
+	}
+
+	@ReturnThis
+	fun setCorners(corners: Int): CardDrawable {
+		this.corners = corners
+		val topLeft = if (corners and TOP_LEFT == TOP_LEFT) cornerSize else 0f
+		val topRight = if (corners and TOP_RIGHT == TOP_RIGHT) cornerSize else 0f
+		val bottomRight = if (corners and BOTTOM_RIGHT == BOTTOM_RIGHT) cornerSize else 0f
+		val bottomLeft = if (corners and BOTTOM_LEFT == BOTTOM_LEFT) cornerSize else 0f
+		cornersF[0] = topLeft
+		cornersF[1] = topLeft
+		cornersF[2] = topRight
+		cornersF[3] = topRight
+		cornersF[4] = bottomRight
+		cornersF[5] = bottomRight
+		cornersF[6] = bottomLeft
+		cornersF[7] = bottomLeft
+		invalidateSelf()
+		return this
+	}
+
+	fun setHorizontalInset(inset: Int) {
+		horizontalInset = inset
+		invalidateSelf()
+	}
+
+	private fun updateColor() {
+		paint.color = color.getColorForState(state, color.defaultColor)
+		paint.alpha = alpha
+	}
+
+	companion object {
+
+		const val TOP_LEFT = 1
+		const val TOP_RIGHT = 2
+		const val BOTTOM_LEFT = 4
+		const val BOTTOM_RIGHT = 8
+
+		const val LEFT = TOP_LEFT or BOTTOM_LEFT
+		const val TOP = TOP_LEFT or TOP_RIGHT
+		const val RIGHT = TOP_RIGHT or BOTTOM_RIGHT
+		const val BOTTOM = BOTTOM_LEFT or BOTTOM_RIGHT
+
+		const val NONE = 0
+		const val ALL = TOP_LEFT or TOP_RIGHT or BOTTOM_RIGHT or BOTTOM_LEFT
+
+		fun from(d: Drawable?): CardDrawable? = when (d) {
+			null -> null
+			is CardDrawable -> d
+			is LayerDrawable -> (0 until d.numberOfLayers).firstNotNullOfOrNull { i ->
+				from(d.getDrawable(i))
+			}
+
+			else -> null
+		}
+	}
+}

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

@@ -0,0 +1,14 @@
+package org.koitharu.kotatsu.core.ui.image
+
+import android.graphics.drawable.Drawable
+import coil.target.GenericViewTarget
+import com.google.android.material.chip.Chip
+
+class ChipIconTarget(override val view: Chip) : GenericViewTarget<Chip>() {
+
+	override var drawable: Drawable?
+		get() = view.chipIcon
+		set(value) {
+			view.chipIcon = value
+		}
+}

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

@@ -12,11 +12,10 @@ import android.graphics.RectF
 import android.graphics.drawable.Drawable
 import androidx.annotation.StyleRes
 import androidx.core.content.withStyledAttributes
-import androidx.core.graphics.ColorUtils
 import androidx.core.graphics.withClip
 import com.google.android.material.color.MaterialColors
 import org.koitharu.kotatsu.R
-import kotlin.math.absoluteValue
+import org.koitharu.kotatsu.core.util.KotatsuColors
 
 class FaviconDrawable(
 	context: Context,
@@ -44,7 +43,7 @@ class FaviconDrawable(
 		}
 		paint.textAlign = Paint.Align.CENTER
 		paint.isFakeBoldText = true
-		colorForeground = MaterialColors.harmonize(colorOfString(name), colorBackground)
+		colorForeground = MaterialColors.harmonize(KotatsuColors.random(name), colorBackground)
 	}
 
 	override fun draw(canvas: Canvas) {
@@ -104,9 +103,4 @@ class FaviconDrawable(
 		paint.getTextBounds(text, 0, text.length, tempRect)
 		return testTextSize * width / tempRect.width()
 	}
-
-	private fun colorOfString(str: String): Int {
-		val hue = (str.hashCode() % 360).absoluteValue.toFloat()
-		return ColorUtils.HSLToColor(floatArrayOf(hue, 0.5f, 0.5f))
-	}
 }

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

@@ -29,7 +29,7 @@ class FitHeightGridLayoutManager : GridLayoutManager {
 		if (orientation == RecyclerView.VERTICAL && child.layoutParams.height == LayoutParams.MATCH_PARENT) {
 			val parentBottom = height - paddingBottom
 			val offset = parentBottom - bottom
-			super.layoutDecoratedWithMargins(child, left, top + offset, right, bottom + offset)
+			super.layoutDecoratedWithMargins(child, left, top, right, bottom + offset)
 		} else {
 			super.layoutDecoratedWithMargins(child, left, top, right, bottom)
 		}

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

@@ -29,7 +29,7 @@ class FitHeightLinearLayoutManager : LinearLayoutManager {
 		if (orientation == RecyclerView.VERTICAL && child.layoutParams.height == LayoutParams.MATCH_PARENT) {
 			val parentBottom = height - paddingBottom
 			val offset = parentBottom - bottom
-			super.layoutDecoratedWithMargins(child, left, top + offset, right, bottom + offset)
+			super.layoutDecoratedWithMargins(child, left, top, right, bottom + offset)
 		} else {
 			super.layoutDecoratedWithMargins(child, left, top, right, bottom)
 		}

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

@@ -1,10 +1,10 @@
 package org.koitharu.kotatsu.core.ui.list
 
-import android.app.Activity
+import android.app.Notification.Action
 import android.os.Bundle
 import android.view.Menu
 import android.view.MenuItem
-import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.app.AppCompatDelegate
 import androidx.appcompat.view.ActionMode
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
@@ -20,7 +20,7 @@ private const val KEY_SELECTION = "selection"
 private const val PROVIDER_NAME = "selection_decoration"
 
 class ListSelectionController(
-	private val activity: Activity,
+	private val appCompatDelegate: AppCompatDelegate,
 	private val decoration: AbstractSelectionItemDecoration,
 	private val registryOwner: SavedStateRegistryOwner,
 	private val callback: Callback2,
@@ -81,8 +81,7 @@ class ListSelectionController(
 	}
 
 	fun onItemLongClick(id: Long): Boolean {
-		startActionMode()
-		return actionMode?.also {
+		return startActionMode()?.also {
 			decoration.setItemIsChecked(id, true)
 			notifySelectionChanged()
 		} != null
@@ -106,9 +105,9 @@ class ListSelectionController(
 		actionMode = null
 	}
 
-	private fun startActionMode() {
-		if (actionMode == null) {
-			actionMode = (activity as? AppCompatActivity)?.startSupportActionMode(this)
+	private fun startActionMode(): ActionMode? {
+		return actionMode ?: appCompatDelegate.startSupportActionMode(this).also {
+			actionMode = it
 		}
 	}
 

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

@@ -91,7 +91,7 @@ abstract class AbstractSelectionItemDecoration : RecyclerView.ItemDecoration() {
 		canvas.restoreToCount(checkpoint)
 	}
 
-	protected open fun getItemId(parent: RecyclerView, child: View) = parent.getChildItemId(child)
+	abstract fun getItemId(parent: RecyclerView, child: View): Long
 
 	protected open fun onDrawBackground(
 		canvas: Canvas,

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

@@ -2,7 +2,10 @@ package org.koitharu.kotatsu.core.ui.sheet
 
 import android.app.Dialog
 import android.view.View
+import android.view.ViewParent
 import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.view.ancestors
+import androidx.fragment.app.DialogFragment
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.bottomsheet.BottomSheetBehavior.BottomSheetCallback
 import com.google.android.material.bottomsheet.BottomSheetDialog
@@ -109,7 +112,16 @@ sealed class AdaptiveSheetBehavior {
 		const val STATE_DRAGGING = SideSheetBehavior.STATE_DRAGGING
 		const val STATE_HIDDEN = SideSheetBehavior.STATE_HIDDEN
 
-		fun from(dialog: Dialog?): AdaptiveSheetBehavior? = when (dialog) {
+		fun from(fragment: DialogFragment): AdaptiveSheetBehavior? {
+			from(fragment.dialog)?.let { return it }
+			val rootView = fragment.view ?: return null
+			for (parent in rootView.ancestors) {
+				from(parent)?.let { return it }
+			}
+			return null
+		}
+
+		private fun from(dialog: Dialog?): AdaptiveSheetBehavior? = when (dialog) {
 			is BottomSheetDialog -> Bottom(dialog.behavior)
 			is SideSheetDialog -> Side(dialog.behavior)
 			else -> null
@@ -121,5 +133,10 @@ sealed class AdaptiveSheetBehavior {
 				is SideSheetBehavior<*> -> Side(behavior)
 				else -> null
 			}
+
+		private fun from(parent: ViewParent): AdaptiveSheetBehavior? {
+			val lp = ((parent as? View)?.layoutParams as? CoordinatorLayout.LayoutParams) ?: return null
+			return from(lp)
+		}
 	}
 }

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

@@ -1,25 +1,46 @@
 package org.koitharu.kotatsu.core.ui.sheet
 
 import android.app.Dialog
+import android.content.Context
+import android.graphics.Color
+import android.os.Build
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewGroup.LayoutParams
+import androidx.activity.ComponentDialog
 import androidx.activity.OnBackPressedDispatcher
+import androidx.annotation.CallSuper
+import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.app.AppCompatDialog
 import androidx.appcompat.app.AppCompatDialogFragment
+import androidx.appcompat.view.ActionMode
+import androidx.appcompat.widget.ActionBarContextView
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.ColorUtils
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updateLayoutParams
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleObserver
+import androidx.lifecycle.LifecycleOwner
 import androidx.viewbinding.ViewBinding
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.bottomsheet.BottomSheetDialog
 import com.google.android.material.sidesheet.SideSheetDialog
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.BaseActivity
+import org.koitharu.kotatsu.core.ui.util.ActionModeDelegate
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
 import com.google.android.material.R as materialR
 
 abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 
 	private var waitingForDismissAllowingStateLoss = false
 	private var isFitToContentsDisabled = false
+	private var defaultStatusBarColor = Color.TRANSPARENT
 
 	var viewBinding: B? = null
 		private set
@@ -29,13 +50,20 @@ abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 		get() = requireViewBinding()
 
 	protected val behavior: AdaptiveSheetBehavior?
-		get() = AdaptiveSheetBehavior.from(dialog)
+		get() = AdaptiveSheetBehavior.from(this)
+
+	var actionModeDelegate: ActionModeDelegate? = null
+		private set
 
 	val isExpanded: Boolean
 		get() = behavior?.state == AdaptiveSheetBehavior.STATE_EXPANDED
 
 	val onBackPressedDispatcher: OnBackPressedDispatcher
-		get() = requireComponentDialog().onBackPressedDispatcher
+		get() = (dialog as? ComponentDialog)?.onBackPressedDispatcher ?: requireActivity().onBackPressedDispatcher
+
+	var isLocked = false
+		private set
+	private var lockCounter = 0
 
 	final override fun onCreateView(
 		inflater: LayoutInflater,
@@ -50,38 +78,91 @@ abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 	final override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
 		val binding = requireViewBinding()
+		if (actionModeDelegate == null) {
+			actionModeDelegate = (activity as? BaseActivity<*>)?.actionModeDelegate
+		}
 		onViewBindingCreated(binding, savedInstanceState)
 	}
 
 	override fun onDestroyView() {
 		viewBinding = null
+		actionModeDelegate = null
 		super.onDestroyView()
 	}
 
 	override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
 		val context = requireContext()
-		return if (context.resources.getBoolean(R.bool.is_tablet)) {
-			SideSheetDialog(context, theme)
+		val dialog = if (context.resources.getBoolean(R.bool.is_tablet)) {
+			SideSheetDialogImpl(context, theme)
 		} else {
-			BottomSheetDialog(context, theme)
+			BottomSheetDialogImpl(context, theme)
+		}
+		actionModeDelegate = ActionModeDelegate().also {
+			dialog.onBackPressedDispatcher.addCallback(it)
+		}
+		return dialog
+	}
+
+	@CallSuper
+	protected open fun dispatchSupportActionModeStarted(mode: ActionMode) {
+		actionModeDelegate?.onSupportActionModeStarted(mode)
+		val ctx = requireContext()
+		val actionModeColor = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+			ColorUtils.compositeColors(
+				ContextCompat.getColor(ctx, com.google.android.material.R.color.m3_appbar_overlay_color),
+				ctx.getThemeColor(com.google.android.material.R.attr.colorSurface),
+			)
+		} else {
+			ContextCompat.getColor(ctx, R.color.kotatsu_surface)
+		}
+		dialog?.window?.let {
+			defaultStatusBarColor = it.statusBarColor
+			it.statusBarColor = actionModeColor
+		}
+		val insets = ViewCompat.getRootWindowInsets(requireView())
+			?.getInsets(WindowInsetsCompat.Type.systemBars()) ?: return
+		dialog?.window?.decorView?.findViewById<ActionBarContextView?>(androidx.appcompat.R.id.action_mode_bar)?.apply {
+			setBackgroundColor(actionModeColor)
+			updateLayoutParams<ViewGroup.MarginLayoutParams> {
+				topMargin = insets.top
+			}
 		}
 	}
 
-	fun addSheetCallback(callback: AdaptiveSheetCallback) {
-		val b = behavior ?: return
+	@CallSuper
+	protected open fun dispatchSupportActionModeFinished(mode: ActionMode) {
+		actionModeDelegate?.onSupportActionModeFinished(mode)
+		dialog?.window?.statusBarColor = defaultStatusBarColor
+	}
+
+	fun addSheetCallback(callback: AdaptiveSheetCallback, lifecycleOwner: LifecycleOwner): Boolean {
+		val b = behavior ?: return false
 		b.addCallback(callback)
 		val rootView = dialog?.findViewById<View>(materialR.id.design_bottom_sheet)
 			?: dialog?.findViewById(materialR.id.coordinator)
+			?: view
 		if (rootView != null) {
 			callback.onStateChanged(rootView, b.state)
 		}
+		lifecycleOwner.lifecycle.addObserver(CallbackRemoveObserver(b, callback))
+		return true
 	}
 
 	protected abstract fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): B
 
 	protected open fun onViewBindingCreated(binding: B, savedInstanceState: Bundle?) = Unit
 
+	fun startSupportActionMode(callback: ActionMode.Callback): ActionMode? {
+		val delegate =
+			(dialog as? AppCompatDialog)?.delegate ?: (activity as? AppCompatActivity)?.delegate ?: return null
+		return delegate.startSupportActionMode(callback)
+	}
+
 	protected fun setExpanded(isExpanded: Boolean, isLocked: Boolean) {
+		this.isLocked = isLocked
+		if (!isLocked) {
+			lockCounter = 0
+		}
 		val b = behavior ?: return
 		if (isExpanded) {
 			b.state = BottomSheetBehavior.STATE_EXPANDED
@@ -109,6 +190,20 @@ abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 		}
 	}
 
+	@CallSuper
+	open fun expandAndLock() {
+		lockCounter++
+		setExpanded(isExpanded = true, isLocked = true)
+	}
+
+	@CallSuper
+	open fun unlock() {
+		lockCounter--
+		if (lockCounter <= 0) {
+			setExpanded(isExpanded, false)
+		}
+	}
+
 	fun requireViewBinding(): B = checkNotNull(viewBinding) {
 		"Fragment $this did not return a ViewBinding from onCreateView() or this was called before onCreateView()."
 	}
@@ -171,4 +266,50 @@ abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment() {
 
 		override fun onSlide(sheet: View, slideOffset: Float) {}
 	}
+
+	private inner class SideSheetDialogImpl(context: Context, theme: Int) : SideSheetDialog(context, theme) {
+
+		override fun onSupportActionModeStarted(mode: ActionMode?) {
+			super.onSupportActionModeStarted(mode)
+			if (mode != null) {
+				dispatchSupportActionModeStarted(mode)
+			}
+		}
+
+		override fun onSupportActionModeFinished(mode: ActionMode?) {
+			super.onSupportActionModeFinished(mode)
+			if (mode != null) {
+				dispatchSupportActionModeFinished(mode)
+			}
+		}
+	}
+
+	private inner class BottomSheetDialogImpl(context: Context, theme: Int) : BottomSheetDialog(context, theme) {
+
+		override fun onSupportActionModeStarted(mode: ActionMode?) {
+			super.onSupportActionModeStarted(mode)
+			if (mode != null) {
+				dispatchSupportActionModeStarted(mode)
+			}
+		}
+
+		override fun onSupportActionModeFinished(mode: ActionMode?) {
+			super.onSupportActionModeFinished(mode)
+			if (mode != null) {
+				dispatchSupportActionModeFinished(mode)
+			}
+		}
+	}
+
+	private class CallbackRemoveObserver(
+		private val behavior: AdaptiveSheetBehavior,
+		private val callback: AdaptiveSheetCallback,
+	) : DefaultLifecycleObserver {
+
+		override fun onDestroy(owner: LifecycleOwner) {
+			super.onDestroy(owner)
+			owner.lifecycle.removeObserver(this)
+			behavior.removeCallback(callback)
+		}
+	}
 }

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

@@ -0,0 +1,31 @@
+package org.koitharu.kotatsu.core.ui.util
+
+import android.view.View
+import androidx.activity.OnBackPressedCallback
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+import com.google.android.material.bottomsheet.BottomSheetBehavior.STATE_COLLAPSED
+import com.google.android.material.bottomsheet.BottomSheetBehavior.STATE_EXPANDED
+import com.google.android.material.bottomsheet.BottomSheetBehavior.STATE_HALF_EXPANDED
+import org.koitharu.kotatsu.core.util.ext.doOnExpansionsChanged
+
+class BottomSheetClollapseCallback(
+	private val behavior: BottomSheetBehavior<*>,
+) : OnBackPressedCallback(behavior.state == STATE_EXPANDED) {
+
+	init {
+		behavior.addBottomSheetCallback(
+			object : BottomSheetBehavior.BottomSheetCallback() {
+
+				override fun onStateChanged(view: View, state: Int) {
+					isEnabled = state == STATE_EXPANDED || state == STATE_HALF_EXPANDED
+				}
+
+				override fun onSlide(p0: View, p1: Float) = Unit
+			},
+		)
+	}
+
+	override fun handleOnBackPressed() {
+		behavior.state = STATE_COLLAPSED
+	}
+}

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

@@ -7,12 +7,16 @@ import org.koitharu.kotatsu.R
 
 class ReversibleActionObserver(
 	private val snackbarHost: View,
+	private val snackbarAnchor: View? = null,
 ) : FlowCollector<ReversibleAction> {
 
 	override suspend fun emit(value: ReversibleAction) {
 		val handle = value.handle
 		val length = if (handle == null) Snackbar.LENGTH_SHORT else Snackbar.LENGTH_LONG
 		val snackbar = Snackbar.make(snackbarHost, value.stringResId, length)
+		if (snackbarAnchor?.isShown == true) {
+			snackbar.anchorView = snackbarAnchor
+		}
 		if (handle != null) {
 			snackbar.setAction(R.string.undo) { handle.reverseAsync() }
 		}

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

@@ -10,8 +10,8 @@ import com.google.android.material.imageview.ShapeableImageView
 import org.koitharu.kotatsu.R
 import kotlin.math.roundToInt
 
-private const val ASPECT_RATIO_HEIGHT = 18f
-private const val ASPECT_RATIO_WIDTH = 13f
+private const val ASPECT_RATIO_HEIGHT = 3f
+private const val ASPECT_RATIO_WIDTH = 2f
 
 class CoverImageView @JvmOverloads constructor(
 	context: Context,

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

@@ -0,0 +1,144 @@
+package org.koitharu.kotatsu.core.ui.widgets
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.util.AttributeSet
+import android.view.View
+import androidx.core.content.withStyledAttributes
+import androidx.recyclerview.widget.RecyclerView
+import androidx.recyclerview.widget.RecyclerView.AdapterDataObserver
+import androidx.viewpager2.widget.ViewPager2
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import org.koitharu.kotatsu.core.util.ext.measureDimension
+import org.koitharu.kotatsu.core.util.ext.resolveDp
+import org.koitharu.kotatsu.parsers.util.toIntUp
+import com.google.android.material.R as materialR
+
+class DotsIndicator @JvmOverloads constructor(
+	context: Context,
+	attrs: AttributeSet? = null,
+	defStyleAttr: Int = R.attr.dotIndicatorStyle,
+) : View(context, attrs, defStyleAttr) {
+
+	private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+	private var indicatorSize = context.resources.resolveDp(12f)
+	private var dotSpacing = 0f
+	private var smallDotScale = 0.33f
+	private var smallDotAlpha = 0.6f
+	private var positionOffset: Float = 0f
+	private var position: Int = 0
+	private val inset = context.resources.resolveDp(1f)
+
+	var max: Int = 6
+		set(value) {
+			if (field != value) {
+				field = value
+				requestLayout()
+				invalidate()
+			}
+		}
+	var progress: Int
+		get() = position
+		set(value) {
+			if (position != value) {
+				position = value
+				invalidate()
+			}
+		}
+
+	init {
+		paint.style = Paint.Style.FILL
+		context.withStyledAttributes(attrs, R.styleable.DotsIndicator, defStyleAttr) {
+			paint.color = getColor(
+				R.styleable.DotsIndicator_dotColor,
+				context.getThemeColor(materialR.attr.colorOnBackground, Color.DKGRAY),
+			)
+			indicatorSize = getDimension(R.styleable.DotsIndicator_dotSize, indicatorSize)
+			dotSpacing = getDimension(R.styleable.DotsIndicator_dotSpacing, dotSpacing)
+			smallDotScale = getFloat(R.styleable.DotsIndicator_dotScale, smallDotScale).coerceIn(0f, 1f)
+			smallDotAlpha = getFloat(R.styleable.DotsIndicator_dotAlpha, smallDotAlpha).coerceIn(0f, 1f)
+			max = getInt(R.styleable.DotsIndicator_android_max, max)
+			position = getInt(R.styleable.DotsIndicator_android_progress, position)
+		}
+	}
+
+	override fun onDraw(canvas: Canvas) {
+		super.onDraw(canvas)
+		val dotSize = getDotSize()
+		val y = paddingTop + (height - paddingTop - paddingBottom) / 2f
+		var x = paddingLeft + dotSize / 2f
+		val radius = dotSize / 2f - inset
+		val spacing = (width - paddingLeft - paddingRight) / max.toFloat() - dotSize
+		x += spacing / 2f
+		for (i in 0 until max) {
+			val scale = when (i) {
+				position -> (1f - smallDotScale) * (1f - positionOffset) + smallDotScale
+				position + 1 -> (1f - smallDotScale) * positionOffset + smallDotScale
+				else -> smallDotScale
+			}
+			paint.alpha = (255 * when (i) {
+				position -> (1f - smallDotAlpha) * (1f - positionOffset) + smallDotAlpha
+				position + 1 -> (1f - smallDotAlpha) * positionOffset + smallDotAlpha
+				else -> smallDotAlpha
+			}).toInt()
+			canvas.drawCircle(x, y, radius * scale, paint)
+			x += spacing + dotSize
+		}
+	}
+
+	override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+		val dotSize = getDotSize()
+		val desiredHeight = (dotSize + paddingTop + paddingBottom).toIntUp()
+		val desiredWidth = ((dotSize + dotSpacing) * max).toIntUp() + paddingLeft + paddingRight
+		setMeasuredDimension(
+			measureDimension(desiredWidth, widthMeasureSpec),
+			measureDimension(desiredHeight, heightMeasureSpec),
+		)
+	}
+
+	fun bindToViewPager(pager: ViewPager2) {
+		pager.registerOnPageChangeCallback(ViewPagerCallback())
+		pager.adapter?.let {
+			it.registerAdapterDataObserver(AdapterObserver(it))
+		}
+	}
+
+	private fun getDotSize() = if (indicatorSize <= 0) {
+		(height - paddingTop - paddingBottom).toFloat()
+	} else {
+		indicatorSize
+	}
+
+	private inner class ViewPagerCallback : ViewPager2.OnPageChangeCallback() {
+
+		override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
+			super.onPageScrolled(position, positionOffset, positionOffsetPixels)
+			this@DotsIndicator.position = position
+			this@DotsIndicator.positionOffset = positionOffset
+			invalidate()
+		}
+	}
+
+	private inner class AdapterObserver(
+		private val adapter: RecyclerView.Adapter<*>,
+	) : AdapterDataObserver() {
+
+		override fun onChanged() {
+			super.onChanged()
+			max = adapter.itemCount
+		}
+
+		override fun onItemRangeInserted(positionStart: Int, itemCount: Int) {
+			super.onItemRangeInserted(positionStart, itemCount)
+			max = adapter.itemCount
+		}
+
+		override fun onItemRangeRemoved(positionStart: Int, itemCount: Int) {
+			super.onItemRangeRemoved(positionStart, itemCount)
+			max = adapter.itemCount
+		}
+	}
+}

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

@@ -25,6 +25,15 @@ class HideBottomNavigationOnScrollBehavior @JvmOverloads constructor(
 
 	private var dyRatio = 1F
 
+	var isPinned: Boolean = false
+		set(value) {
+			field = value
+			if (value) {
+				offsetAnimator?.cancel()
+				offsetAnimator = null
+			}
+		}
+
 	override fun layoutDependsOn(parent: CoordinatorLayout, child: BottomNavigationView, dependency: View): Boolean {
 		return dependency is AppBarLayout
 	}
@@ -51,7 +60,7 @@ class HideBottomNavigationOnScrollBehavior @JvmOverloads constructor(
 		axes: Int,
 		type: Int,
 	): Boolean {
-		if (axes != ViewCompat.SCROLL_AXIS_VERTICAL) {
+		if (isPinned || axes != ViewCompat.SCROLL_AXIS_VERTICAL) {
 			return false
 		}
 		lastStartedType = type
@@ -69,7 +78,9 @@ class HideBottomNavigationOnScrollBehavior @JvmOverloads constructor(
 		type: Int,
 	) {
 		super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed, type)
-		child.translationY = (child.translationY + (dy * dyRatio)).coerceIn(0F, child.height.toFloat())
+		if (!isPinned) {
+			child.translationY = (child.translationY + (dy * dyRatio)).coerceIn(0F, child.height.toFloat())
+		}
 	}
 
 	override fun onStopNestedScroll(
@@ -78,7 +89,7 @@ class HideBottomNavigationOnScrollBehavior @JvmOverloads constructor(
 		target: View,
 		type: Int,
 	) {
-		if (lastStartedType == ViewCompat.TYPE_TOUCH || type == ViewCompat.TYPE_NON_TOUCH) {
+		if (!isPinned && (lastStartedType == ViewCompat.TYPE_TOUCH || type == ViewCompat.TYPE_NON_TOUCH)) {
 			animateBottomNavigationVisibility(child, child.translationY < child.height / 2)
 		}
 	}

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

@@ -1,397 +0,0 @@
-package org.koitharu.kotatsu.core.ui.widgets
-
-import android.animation.ValueAnimator
-import android.content.Context
-import android.graphics.Canvas
-import android.graphics.Color
-import android.graphics.CornerPathEffect
-import android.graphics.Paint
-import android.graphics.Rect
-import android.graphics.RectF
-import android.graphics.Typeface
-import android.os.Build
-import android.os.Parcelable
-import android.text.Layout
-import android.text.StaticLayout
-import android.text.TextDirectionHeuristic
-import android.text.TextDirectionHeuristics
-import android.text.TextPaint
-import android.util.AttributeSet
-import android.view.View
-import androidx.annotation.RequiresApi
-import androidx.interpolator.view.animation.FastOutSlowInInterpolator
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.util.ext.draw
-import org.koitharu.kotatsu.core.util.ext.getAnimationDuration
-import org.koitharu.kotatsu.core.util.ext.resolveDp
-import org.koitharu.kotatsu.core.util.ext.resolveSp
-
-class PieChart @JvmOverloads constructor(
-	context: Context,
-	attrs: AttributeSet? = null,
-	defStyleAttr: Int = 0
-) : View(context, attrs, defStyleAttr), PieChartInterface {
-
-	private var marginTextFirst: Float = context.resources.resolveDp(DEFAULT_MARGIN_TEXT_1)
-	private var marginTextSecond: Float = context.resources.resolveDp(DEFAULT_MARGIN_TEXT_2)
-	private var marginTextThird: Float = context.resources.resolveDp(DEFAULT_MARGIN_TEXT_3)
-	private var marginSmallCircle: Float = context.resources.resolveDp(DEFAULT_MARGIN_SMALL_CIRCLE)
-	private val marginText: Float = marginTextFirst + marginTextSecond
-	private val circleRect = RectF()
-	private var circleStrokeWidth: Float = context.resources.resolveDp(6f)
-	private var circleRadius: Float = 0f
-	private var circlePadding: Float = context.resources.resolveDp(8f)
-	private var circlePaintRoundSize: Boolean = true
-	private var circleSectionSpace: Float = 3f
-	private var circleCenterX: Float = 0f
-	private var circleCenterY: Float = 0f
-	private var numberTextPaint: TextPaint = TextPaint()
-	private var descriptionTextPain: TextPaint = TextPaint()
-	private var amountTextPaint: TextPaint = TextPaint()
-	private var textStartX: Float = 0f
-	private var textStartY: Float = 0f
-	private var textHeight: Int = 0
-	private var textCircleRadius: Float = context.resources.resolveDp(4f)
-	private var textAmountStr: String = ""
-	private var textAmountY: Float = 0f
-	private var textAmountXNumber: Float = 0f
-	private var textAmountXDescription: Float = 0f
-	private var textAmountYDescription: Float = 0f
-	private var totalAmount: Int = 0
-	private var pieChartColors: List<String> = listOf()
-	private var percentageCircleList: List<PieChartModel> = listOf()
-	private var textRowList: MutableList<StaticLayout> = mutableListOf()
-	private var dataList: List<Pair<Int, String>> = listOf()
-	private var animationSweepAngle: Int = 0
-
-	init {
-		var textAmountSize: Float = context.resources.resolveSp(22f)
-		var textNumberSize: Float = context.resources.resolveSp(20f)
-		var textDescriptionSize: Float = context.resources.resolveSp(14f)
-		var textAmountColor: Int = Color.WHITE
-		var textNumberColor: Int = Color.WHITE
-		var textDescriptionColor: Int = Color.GRAY
-
-		if (attrs != null) {
-			val typeArray = context.obtainStyledAttributes(attrs, R.styleable.PieChart)
-
-			val colorResId = typeArray.getResourceId(R.styleable.PieChart_pieChartColors, 0)
-			pieChartColors = typeArray.resources.getStringArray(colorResId).toList()
-
-			marginTextFirst = typeArray.getDimension(R.styleable.PieChart_pieChartMarginTextFirst, marginTextFirst)
-			marginTextSecond = typeArray.getDimension(R.styleable.PieChart_pieChartMarginTextSecond, marginTextSecond)
-			marginTextThird = typeArray.getDimension(R.styleable.PieChart_pieChartMarginTextThird, marginTextThird)
-			marginSmallCircle =
-				typeArray.getDimension(R.styleable.PieChart_pieChartMarginSmallCircle, marginSmallCircle)
-
-			circleStrokeWidth =
-				typeArray.getDimension(R.styleable.PieChart_pieChartCircleStrokeWidth, circleStrokeWidth)
-			circlePadding = typeArray.getDimension(R.styleable.PieChart_pieChartCirclePadding, circlePadding)
-			circlePaintRoundSize =
-				typeArray.getBoolean(R.styleable.PieChart_pieChartCirclePaintRoundSize, circlePaintRoundSize)
-			circleSectionSpace = typeArray.getFloat(R.styleable.PieChart_pieChartCircleSectionSpace, circleSectionSpace)
-
-			textCircleRadius = typeArray.getDimension(R.styleable.PieChart_pieChartTextCircleRadius, textCircleRadius)
-			textAmountSize = typeArray.getDimension(R.styleable.PieChart_pieChartTextAmountSize, textAmountSize)
-			textNumberSize = typeArray.getDimension(R.styleable.PieChart_pieChartTextNumberSize, textNumberSize)
-			textDescriptionSize =
-				typeArray.getDimension(R.styleable.PieChart_pieChartTextDescriptionSize, textDescriptionSize)
-			textAmountColor = typeArray.getColor(R.styleable.PieChart_pieChartTextAmountColor, textAmountColor)
-			textNumberColor = typeArray.getColor(R.styleable.PieChart_pieChartTextNumberColor, textNumberColor)
-			textDescriptionColor =
-				typeArray.getColor(R.styleable.PieChart_pieChartTextDescriptionColor, textDescriptionColor)
-			textAmountStr = typeArray.getString(R.styleable.PieChart_pieChartTextAmount) ?: ""
-
-			typeArray.recycle()
-		}
-
-		circlePadding += circleStrokeWidth
-
-		// Инициализация кистей View
-		initPaints(amountTextPaint, textAmountSize, textAmountColor)
-		initPaints(numberTextPaint, textNumberSize, textNumberColor)
-		initPaints(descriptionTextPain, textDescriptionSize, textDescriptionColor, true)
-	}
-
-	@RequiresApi(Build.VERSION_CODES.M)
-	override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-		textRowList.clear()
-
-		val initSizeWidth = resolveDefaultSize(widthMeasureSpec, DEFAULT_VIEW_SIZE_WIDTH)
-
-		val textTextWidth = (initSizeWidth * TEXT_WIDTH_PERCENT)
-		val initSizeHeight = calculateViewHeight(heightMeasureSpec, textTextWidth.toInt())
-
-		textStartX = initSizeWidth - textTextWidth.toFloat()
-		textStartY = initSizeHeight.toFloat() / 2 - textHeight / 2
-
-		calculateCircleRadius(initSizeWidth, initSizeHeight)
-
-		setMeasuredDimension(initSizeWidth, initSizeHeight)
-	}
-
-	override fun onDraw(canvas: Canvas) {
-		super.onDraw(canvas)
-
-		drawCircle(canvas)
-		drawText(canvas)
-	}
-
-	override fun onRestoreInstanceState(state: Parcelable?) {
-		val pieChartState = state as? PieChartState
-		super.onRestoreInstanceState(pieChartState?.superState ?: state)
-
-		dataList = pieChartState?.dataList ?: listOf()
-	}
-
-	override fun onSaveInstanceState(): Parcelable {
-		val superState = super.onSaveInstanceState()
-		return PieChartState(superState, dataList)
-	}
-
-	override fun setDataChart(list: List<Pair<Int, String>>) {
-		dataList = list
-		calculatePercentageOfData()
-	}
-
-	override fun startAnimation() {
-		val animator = ValueAnimator.ofInt(0, 360).apply {
-			duration = context.getAnimationDuration(android.R.integer.config_longAnimTime)
-			interpolator = FastOutSlowInInterpolator()
-			addUpdateListener { valueAnimator ->
-				animationSweepAngle = valueAnimator.animatedValue as Int
-				invalidate()
-			}
-		}
-		animator.start()
-	}
-
-	private fun drawCircle(canvas: Canvas) {
-		for (percent in percentageCircleList) {
-			if (animationSweepAngle > percent.percentToStartAt + percent.percentOfCircle) {
-				canvas.drawArc(circleRect, percent.percentToStartAt, percent.percentOfCircle, false, percent.paint)
-			} else if (animationSweepAngle > percent.percentToStartAt) {
-				canvas.drawArc(
-					circleRect,
-					percent.percentToStartAt,
-					animationSweepAngle - percent.percentToStartAt,
-					false,
-					percent.paint,
-				)
-			}
-		}
-	}
-
-	private fun drawText(canvas: Canvas) {
-		var textBuffY = textStartY
-		textRowList.forEachIndexed { index, staticLayout ->
-			if (index % 2 == 0) {
-				staticLayout.draw(canvas, textStartX + marginSmallCircle + textCircleRadius, textBuffY)
-				canvas.drawCircle(
-					textStartX + marginSmallCircle / 2,
-					textBuffY + staticLayout.height / 2 + textCircleRadius / 2,
-					textCircleRadius,
-					Paint().apply { color = Color.parseColor(pieChartColors[(index / 2) % pieChartColors.size]) },
-				)
-				textBuffY += staticLayout.height + marginTextFirst
-			} else {
-				staticLayout.draw(canvas, textStartX, textBuffY)
-				textBuffY += staticLayout.height + marginTextSecond
-			}
-		}
-
-		canvas.drawText(totalAmount.toString(), textAmountXNumber, textAmountY, amountTextPaint)
-		canvas.drawText(textAmountStr, textAmountXDescription, textAmountYDescription, descriptionTextPain)
-	}
-
-	private fun initPaints(textPaint: TextPaint, textSize: Float, textColor: Int, isDescription: Boolean = false) {
-		textPaint.color = textColor
-		textPaint.textSize = textSize
-		textPaint.isAntiAlias = true
-
-		if (!isDescription) textPaint.typeface = Typeface.create(Typeface.DEFAULT, Typeface.BOLD)
-	}
-
-	private fun resolveDefaultSize(spec: Int, defValue: Int): Int {
-		return when (MeasureSpec.getMode(spec)) {
-			MeasureSpec.UNSPECIFIED -> resources.resolveDp(defValue)
-			else -> MeasureSpec.getSize(spec)
-		}
-	}
-
-	@RequiresApi(Build.VERSION_CODES.M)
-	private fun calculateViewHeight(heightMeasureSpec: Int, textWidth: Int): Int {
-		val initSizeHeight = resolveDefaultSize(heightMeasureSpec, DEFAULT_VIEW_SIZE_HEIGHT)
-		textHeight = (dataList.size * marginText + getTextViewHeight(textWidth)).toInt()
-
-		val textHeightWithPadding = textHeight + paddingTop + paddingBottom
-		return if (textHeightWithPadding > initSizeHeight) textHeightWithPadding else initSizeHeight
-	}
-
-	private fun calculateCircleRadius(width: Int, height: Int) {
-		val circleViewWidth = (width * CIRCLE_WIDTH_PERCENT)
-		circleRadius = if (circleViewWidth > height) {
-			(height.toFloat() - circlePadding) / 2
-		} else {
-			circleViewWidth.toFloat() / 2
-		}
-
-		with(circleRect) {
-			left = circlePadding
-			top = height / 2 - circleRadius
-			right = circleRadius * 2 + circlePadding
-			bottom = height / 2 + circleRadius
-		}
-
-		circleCenterX = (circleRadius * 2 + circlePadding + circlePadding) / 2
-		circleCenterY = (height / 2 + circleRadius + (height / 2 - circleRadius)) / 2
-
-		textAmountY = circleCenterY
-
-		val sizeTextAmountNumber = getWidthOfAmountText(
-			totalAmount.toString(),
-			amountTextPaint,
-		)
-
-		textAmountXNumber = circleCenterX - sizeTextAmountNumber.width() / 2
-		textAmountXDescription = circleCenterX - getWidthOfAmountText(textAmountStr, descriptionTextPain).width() / 2
-		textAmountYDescription = circleCenterY + sizeTextAmountNumber.height() + marginTextThird
-	}
-
-	@RequiresApi(Build.VERSION_CODES.M)
-	private fun getTextViewHeight(maxWidth: Int): Int {
-		var textHeight = 0
-		dataList.forEach {
-			val textLayoutNumber = getMultilineText(
-				text = it.first.toString(),
-				textPaint = numberTextPaint,
-				width = maxWidth,
-			)
-			val textLayoutDescription = getMultilineText(
-				text = it.second,
-				textPaint = descriptionTextPain,
-				width = maxWidth,
-			)
-			textRowList.apply {
-				add(textLayoutNumber)
-				add(textLayoutDescription)
-			}
-			textHeight += textLayoutNumber.height + textLayoutDescription.height
-		}
-
-		return textHeight
-	}
-
-	private fun calculatePercentageOfData() {
-		totalAmount = dataList.fold(0) { res, value -> res + value.first }
-
-		var startAt = circleSectionSpace
-		percentageCircleList = dataList.mapIndexed { index, pair ->
-			var percent = pair.first * 100 / totalAmount.toFloat() - circleSectionSpace
-			percent = if (percent < 0f) 0f else percent
-
-			val resultModel = PieChartModel(
-				percentOfCircle = percent,
-				percentToStartAt = startAt,
-				colorOfLine = Color.parseColor(pieChartColors[index % pieChartColors.size]),
-				stroke = circleStrokeWidth,
-				paintRound = circlePaintRoundSize,
-			)
-			if (percent != 0f) startAt += percent + circleSectionSpace
-			resultModel
-		}
-	}
-
-	private fun getWidthOfAmountText(text: String, textPaint: TextPaint): Rect {
-		val bounds = Rect()
-		textPaint.getTextBounds(text, 0, text.length, bounds)
-		return bounds
-	}
-
-	@RequiresApi(Build.VERSION_CODES.M)
-	private fun getMultilineText(
-		text: CharSequence,
-		textPaint: TextPaint,
-		width: Int,
-		start: Int = 0,
-		end: Int = text.length,
-		alignment: Layout.Alignment = Layout.Alignment.ALIGN_NORMAL,
-		textDir: TextDirectionHeuristic = TextDirectionHeuristics.LTR,
-		spacingMult: Float = 1f,
-		spacingAdd: Float = 0f
-	): StaticLayout {
-
-		return StaticLayout.Builder
-			.obtain(text, start, end, textPaint, width)
-			.setAlignment(alignment)
-			.setTextDirection(textDir)
-			.setLineSpacing(spacingAdd, spacingMult)
-			.build()
-	}
-
-	companion object {
-		private const val DEFAULT_MARGIN_TEXT_1 = 2f
-		private const val DEFAULT_MARGIN_TEXT_2 = 10f
-		private const val DEFAULT_MARGIN_TEXT_3 = 2f
-		private const val DEFAULT_MARGIN_SMALL_CIRCLE = 12f
-
-		private const val TEXT_WIDTH_PERCENT = 0.40
-		private const val CIRCLE_WIDTH_PERCENT = 0.50
-
-		const val DEFAULT_VIEW_SIZE_HEIGHT = 150
-		const val DEFAULT_VIEW_SIZE_WIDTH = 250
-	}
-}
-
-interface PieChartInterface {
-
-	fun setDataChart(list: List<Pair<Int, String>>)
-
-	fun startAnimation()
-}
-
-data class PieChartModel(
-	var percentOfCircle: Float = 0f,
-	var percentToStartAt: Float = 0f,
-	var colorOfLine: Int = 0,
-	var stroke: Float = 0f,
-	var paint: Paint = Paint(),
-	var paintRound: Boolean = true
-) {
-
-	init {
-		if (percentOfCircle < 0 || percentOfCircle > 100) {
-			percentOfCircle = 100f
-		}
-
-		percentOfCircle = 360 * percentOfCircle / 100
-
-		if (percentToStartAt < 0 || percentToStartAt > 100) {
-			percentToStartAt = 0f
-		}
-
-		percentToStartAt = 360 * percentToStartAt / 100
-
-		if (colorOfLine == 0) {
-			colorOfLine = Color.parseColor("#000000")
-		}
-
-		paint = Paint()
-		paint.color = colorOfLine
-		paint.isAntiAlias = true
-		paint.style = Paint.Style.STROKE
-		paint.strokeWidth = stroke
-		paint.isDither = true
-
-		if (paintRound) {
-			paint.strokeJoin = Paint.Join.ROUND
-			paint.strokeCap = Paint.Cap.ROUND
-			paint.pathEffect = CornerPathEffect(8f)
-		}
-	}
-}
-
-class PieChartState(
-	superSavedState: Parcelable?,
-	val dataList: List<Pair<Int, String>>
-) : View.BaseSavedState(superSavedState), Parcelable

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

@@ -0,0 +1,159 @@
+package org.koitharu.kotatsu.core.ui.widgets
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Outline
+import android.graphics.Paint
+import android.util.AttributeSet
+import android.view.Gravity
+import android.view.View
+import android.view.ViewOutlineProvider
+import android.view.animation.AccelerateDecelerateInterpolator
+import android.widget.TextView
+import androidx.annotation.StringRes
+import androidx.appcompat.widget.LinearLayoutCompat
+import androidx.core.content.withStyledAttributes
+import androidx.core.view.children
+import androidx.core.widget.TextViewCompat
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.util.ext.getAnimationDuration
+import org.koitharu.kotatsu.core.util.ext.getThemeColorStateList
+import org.koitharu.kotatsu.core.util.ext.resolveDp
+import org.koitharu.kotatsu.core.util.ext.setTextAndVisible
+import org.koitharu.kotatsu.core.util.ext.textAndVisible
+import com.google.android.material.R as materialR
+
+class ProgressButton @JvmOverloads constructor(
+	context: Context,
+	attrs: AttributeSet? = null,
+	defStyleAttr: Int = 0,
+) : LinearLayoutCompat(context, attrs, defStyleAttr), ValueAnimator.AnimatorUpdateListener {
+
+	private val textViewTitle = TextView(context)
+	private val textViewSubtitle = TextView(context)
+	private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+
+	private var progress = 0f
+	private var colorBase: ColorStateList = ColorStateList.valueOf(Color.TRANSPARENT)
+	private var colorProgress: ColorStateList = ColorStateList.valueOf(Color.TRANSPARENT)
+	private var progressAnimator: ValueAnimator? = null
+
+	var title: CharSequence?
+		get() = textViewTitle.textAndVisible
+		set(value) {
+			textViewTitle.textAndVisible = value
+		}
+
+	var subtitle: CharSequence?
+		get() = textViewSubtitle.textAndVisible
+		set(value) {
+			textViewSubtitle.textAndVisible = value
+		}
+
+	init {
+		orientation = VERTICAL
+		outlineProvider = OutlineProvider()
+		clipToOutline = true
+
+		context.withStyledAttributes(attrs, R.styleable.ProgressButton, defStyleAttr) {
+			val textAppearanceFallback = androidx.appcompat.R.style.TextAppearance_AppCompat
+			TextViewCompat.setTextAppearance(
+				textViewTitle,
+				getResourceId(R.styleable.ProgressButton_titleTextAppearance, textAppearanceFallback),
+			)
+			TextViewCompat.setTextAppearance(
+				textViewSubtitle,
+				getResourceId(R.styleable.ProgressButton_subtitleTextAppearance, textAppearanceFallback),
+			)
+			textViewTitle.text = getText(R.styleable.ProgressButton_title)
+			textViewSubtitle.text = getText(R.styleable.ProgressButton_subtitle)
+			colorBase = getColorStateList(R.styleable.ProgressButton_baseColor)
+				?: context.getThemeColorStateList(materialR.attr.colorPrimaryContainer) ?: colorBase
+			colorProgress = getColorStateList(R.styleable.ProgressButton_progressColor)
+				?: context.getThemeColorStateList(materialR.attr.colorPrimary) ?: colorProgress
+			getColorStateList(R.styleable.ProgressButton_android_textColor)?.let { colorText ->
+				textViewTitle.setTextColor(colorText)
+				textViewSubtitle.setTextColor(colorText)
+			}
+			progress = getInt(R.styleable.ProgressButton_android_progress, 0).toFloat() /
+				getInt(R.styleable.ProgressButton_android_max, 100).toFloat()
+		}
+
+		addView(textViewTitle, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT))
+		addView(
+			textViewSubtitle,
+			LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).also { lp ->
+				lp.topMargin = context.resources.resolveDp(2)
+			},
+		)
+
+		paint.style = Paint.Style.FILL
+		applyGravity()
+		setWillNotDraw(false)
+	}
+
+	override fun onDraw(canvas: Canvas) {
+		super.onDraw(canvas)
+		canvas.drawColor(colorBase.getColorForState(drawableState, colorBase.defaultColor))
+		paint.color = colorProgress.getColorForState(drawableState, colorProgress.defaultColor)
+		paint.alpha = 84 // 255 * 0.33F
+		canvas.drawRect(0f, 0f, width * progress, height.toFloat(), paint)
+	}
+
+	override fun setGravity(gravity: Int) {
+		super.setGravity(gravity)
+		if (childCount != 0) {
+			applyGravity()
+		}
+	}
+
+	override fun setEnabled(enabled: Boolean) {
+		super.setEnabled(enabled)
+		children.forEach { it.isEnabled = enabled }
+	}
+
+	override fun onAnimationUpdate(animation: ValueAnimator) {
+		progress = animation.animatedValue as Float
+		invalidate()
+	}
+
+	fun setTitle(@StringRes titleResId: Int) {
+		textViewTitle.setTextAndVisible(titleResId)
+	}
+
+	fun setSubtitle(@StringRes titleResId: Int) {
+		textViewSubtitle.setTextAndVisible(titleResId)
+	}
+
+	fun setProgress(value: Float, animate: Boolean) {
+		progressAnimator?.cancel()
+		if (animate) {
+			progressAnimator = ValueAnimator.ofFloat(progress, value).apply {
+				duration = context.getAnimationDuration(android.R.integer.config_shortAnimTime)
+				interpolator = AccelerateDecelerateInterpolator()
+				addUpdateListener(this@ProgressButton)
+				start()
+			}
+		} else {
+			progressAnimator = null
+			progress = value
+			invalidate()
+		}
+	}
+
+	private fun applyGravity() {
+		val value = (gravity and Gravity.HORIZONTAL_GRAVITY_MASK) or Gravity.CENTER_VERTICAL
+		textViewTitle.gravity = value
+		textViewSubtitle.gravity = value
+	}
+
+	private class OutlineProvider : ViewOutlineProvider() {
+
+		override fun getOutline(view: View, outline: Outline) {
+			outline.setRoundRect(0, 0, view.width, view.height, view.height / 2f)
+		}
+	}
+}

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

@@ -38,6 +38,15 @@ class SlidingBottomNavigationView @JvmOverloads constructor(
 	private var currentState = STATE_UP
 	private var behavior = HideBottomNavigationOnScrollBehavior()
 
+	var isPinned: Boolean
+		get() = behavior.isPinned
+		set(value) {
+			behavior.isPinned = value
+			if (value) {
+				translationX = 0f
+			}
+		}
+
 	override fun getBehavior(): CoordinatorLayout.Behavior<*> {
 		return behavior
 	}

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

@@ -12,6 +12,7 @@ import androidx.annotation.DrawableRes
 import androidx.annotation.StringRes
 import androidx.core.content.ContextCompat
 import androidx.core.content.withStyledAttributes
+import androidx.core.view.isVisible
 import androidx.core.view.setPadding
 import com.google.android.material.shape.MaterialShapeDrawable
 import com.google.android.material.shape.ShapeAppearanceModel
@@ -75,7 +76,7 @@ class TipView @JvmOverloads constructor(
 			val shapeAppearanceModel = ShapeAppearanceModel.builder(context, attrs, defStyleAttr, 0).build()
 			background = MaterialShapeDrawable(shapeAppearanceModel).also {
 				it.fillColor = getColorStateList(R.styleable.TipView_cardBackgroundColor)
-					?: context.getThemeColorStateList(R.attr.m3ColorExploreButton)
+					?: context.getThemeColorStateList(com.google.android.material.R.attr.colorSurfaceContainerHigh)
 				it.strokeWidth = getDimension(R.styleable.TipView_strokeWidth, 0f)
 				it.strokeColor = getColorStateList(R.styleable.TipView_strokeColor)
 				it.elevation = getDimension(R.styleable.TipView_elevation, 0f)
@@ -103,16 +104,22 @@ class TipView @JvmOverloads constructor(
 
 	fun setPrimaryButtonText(@StringRes resId: Int) {
 		binding.buttonPrimary.setTextAndVisible(resId)
+		updateButtonsLayout()
 	}
 
 	fun setSecondaryButtonText(@StringRes resId: Int) {
 		binding.buttonSecondary.setTextAndVisible(resId)
+		updateButtonsLayout()
 	}
 
 	fun setIcon(@DrawableRes resId: Int) {
 		icon = ContextCompat.getDrawable(context, resId)
 	}
 
+	private fun updateButtonsLayout() {
+		binding.layoutButtons.isVisible = binding.buttonPrimary.isVisible || binding.buttonSecondary.isVisible
+	}
+
 	interface OnButtonClickListener {
 
 		fun onPrimaryButtonClick(tipView: TipView)

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

@@ -0,0 +1,16 @@
+package org.koitharu.kotatsu.core.util
+
+import kotlinx.coroutines.CoroutineExceptionHandler
+import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
+import org.koitharu.kotatsu.core.util.ext.report
+import kotlin.coroutines.AbstractCoroutineContextElement
+import kotlin.coroutines.CoroutineContext
+
+class AcraCoroutineErrorHandler : AbstractCoroutineContextElement(CoroutineExceptionHandler),
+	CoroutineExceptionHandler {
+
+	override fun handleException(context: CoroutineContext, exception: Throwable) {
+		exception.printStackTraceDebug()
+		exception.report()
+	}
+}

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

@@ -1,58 +0,0 @@
-package org.koitharu.kotatsu.core.util
-
-import androidx.collection.ArrayMap
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlin.coroutines.coroutineContext
-
-@Deprecated("", replaceWith = ReplaceWith("CompositeMutex2"))
-class CompositeMutex<T : Any> : Set<T> {
-
-	private val state = ArrayMap<T, MutableStateFlow<Boolean>>()
-	private val mutex = Mutex()
-
-	override val size: Int
-		get() = state.size
-
-	override fun contains(element: T): Boolean {
-		return state.containsKey(element)
-	}
-
-	override fun containsAll(elements: Collection<T>): Boolean {
-		return elements.all { x -> state.containsKey(x) }
-	}
-
-	override fun isEmpty(): Boolean {
-		return state.isEmpty()
-	}
-
-	override fun iterator(): Iterator<T> {
-		return state.keys.iterator()
-	}
-
-	suspend fun lock(element: T) {
-		while (coroutineContext.isActive) {
-			waitForRemoval(element)
-			mutex.withLock {
-				if (state[element] == null) {
-					state[element] = MutableStateFlow(false)
-					return
-				}
-			}
-		}
-	}
-
-	fun unlock(element: T) {
-		checkNotNull(state.remove(element)) {
-			"CompositeMutex is not locked for $element"
-		}.value = true
-	}
-
-	private suspend fun waitForRemoval(element: T) {
-		val flow = state[element] ?: return
-		flow.first { it }
-	}
-}

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

@@ -1,12 +0,0 @@
-package org.koitharu.kotatsu.core.util
-
-class CompositeRunnable(
-	private val children: List<Runnable>,
-) : Runnable, Collection<Runnable> by children {
-
-	override fun run() {
-		for (child in children) {
-			child.run()
-		}
-	}
-}

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

@@ -9,8 +9,8 @@ class Event<T>(
 
 	suspend fun consume(collector: FlowCollector<T>) {
 		if (!isConsumed) {
-			collector.emit(data)
 			isConsumed = true
+			collector.emit(data)
 		}
 	}
 

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

@@ -1,46 +0,0 @@
-package org.koitharu.kotatsu.core.util
-
-import android.app.Activity
-import android.os.Bundle
-import androidx.appcompat.app.AppCompatActivity
-import androidx.core.content.ContextCompat
-import androidx.lifecycle.flowWithLifecycle
-import androidx.lifecycle.lifecycleScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.observeAsFlow
-import org.koitharu.kotatsu.core.ui.DefaultActivityLifecycleCallbacks
-import org.koitharu.kotatsu.core.util.ext.getThemeColor
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class IncognitoModeIndicator @Inject constructor(
-	private val settings: AppSettings,
-) : DefaultActivityLifecycleCallbacks {
-
-	override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
-		if (activity !is AppCompatActivity) {
-			return
-		}
-		settings.observeAsFlow(
-			key = AppSettings.KEY_INCOGNITO_MODE,
-			valueProducer = { isIncognitoModeEnabled },
-		).flowOn(Dispatchers.IO)
-			.flowWithLifecycle(activity.lifecycle)
-			.onEach { updateStatusBar(activity, it) }
-			.launchIn(activity.lifecycleScope)
-	}
-
-	private fun updateStatusBar(activity: AppCompatActivity, isIncognitoModeEnabled: Boolean) {
-		activity.window.statusBarColor = if (isIncognitoModeEnabled) {
-			ContextCompat.getColor(activity, R.color.status_bar_incognito)
-		} else {
-			activity.getThemeColor(android.R.attr.statusBarColor)
-		}
-	}
-}

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

@@ -0,0 +1,55 @@
+package org.koitharu.kotatsu.core.util
+
+import android.content.Context
+import androidx.annotation.AttrRes
+import androidx.annotation.ColorInt
+import androidx.core.graphics.ColorUtils
+import com.google.android.material.R
+import com.google.android.material.color.MaterialColors
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import org.koitharu.kotatsu.parsers.model.Manga
+import kotlin.math.absoluteValue
+
+object KotatsuColors {
+
+	@ColorInt
+	fun segmentColor(context: Context, @AttrRes resId: Int): Int {
+		val colorHex = String.format("%06x", context.getThemeColor(resId))
+		val hue = getHue(colorHex)
+		val color = ColorUtils.HSLToColor(floatArrayOf(hue, 0.5f, 0.5f))
+		val backgroundColor = context.getThemeColor(R.attr.colorSurfaceContainerHigh)
+		return MaterialColors.harmonize(color, backgroundColor)
+	}
+
+	@ColorInt
+	fun random(seed: Any): Int {
+		val hue = (seed.hashCode() % 360).absoluteValue.toFloat()
+		return ColorUtils.HSLToColor(floatArrayOf(hue, 0.5f, 0.5f))
+	}
+
+	@ColorInt
+	fun ofManga(context: Context, manga: Manga?): Int {
+		val color = if (manga != null) {
+			val hue = (manga.id.absoluteValue % 360).toFloat()
+			ColorUtils.HSLToColor(floatArrayOf(hue, 0.5f, 0.5f))
+		} else {
+			context.getThemeColor(R.attr.colorOutline)
+		}
+		val backgroundColor = context.getThemeColor(R.attr.colorSurfaceContainerHigh)
+		return MaterialColors.harmonize(color, backgroundColor)
+	}
+
+	private fun getHue(hex: String): Float {
+		val r = (hex.substring(0, 2).toInt(16)).toFloat()
+		val g = (hex.substring(2, 4).toInt(16)).toFloat()
+		val b = (hex.substring(4, 6).toInt(16)).toFloat()
+
+		var hue = 0F
+		if ((r >= g) && (g >= b)) {
+			hue = 60 * (g - b) / (r - b)
+		} else if ((g > r) && (r >= b)) {
+			hue = 60 * (2 - (r - b) / (g - b))
+		}
+		return hue
+	}
+}

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

@@ -3,7 +3,7 @@ package org.koitharu.kotatsu.core.util
 import androidx.collection.ArrayMap
 import kotlinx.coroutines.sync.Mutex
 
-class CompositeMutex2<T : Any> : Set<T> {
+class MultiMutex<T : Any> : Set<T> {
 
 	private val delegates = ArrayMap<T, Mutex>()
 

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

@@ -14,7 +14,7 @@ import android.content.ContextWrapper
 import android.content.OperationApplicationException
 import android.content.SharedPreferences
 import android.content.SyncResult
-import android.content.pm.PackageManager
+import android.content.pm.PackageManager.PERMISSION_GRANTED
 import android.content.pm.ResolveInfo
 import android.database.SQLException
 import android.graphics.Bitmap
@@ -27,14 +27,19 @@ import android.provider.Settings
 import android.view.View
 import android.view.ViewPropertyAnimator
 import android.view.Window
-import android.widget.Toast
+import android.webkit.WebView
 import androidx.activity.result.ActivityResultLauncher
 import androidx.annotation.IntegerRes
 import androidx.annotation.WorkerThread
+import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.appcompat.app.AppCompatDialog
 import androidx.core.app.ActivityOptionsCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.ContextCompat
 import androidx.core.os.LocaleListCompat
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.Fragment
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.coroutineScope
 import androidx.work.CoroutineWorker
@@ -60,6 +65,7 @@ import org.xmlpull.v1.XmlPullParser
 import org.xmlpull.v1.XmlPullParserException
 import java.io.File
 import kotlin.math.roundToLong
+import com.google.android.material.R as materialR
 
 val Context.activityManager: ActivityManager?
 	get() = getSystemService(ACTIVITY_SERVICE) as? ActivityManager
@@ -136,7 +142,7 @@ fun Window.setNavigationBarTransparentCompat(context: Context, elevation: Float,
 	} else {
 		// Set navbar scrim 70% of navigationBarColor
 		ElevationOverlayProvider(context).compositeOverlayIfNeeded(
-			context.getThemeColor(R.attr.m3ColorBottomMenuBackground, alphaFactor),
+			context.getThemeColor(materialR.attr.colorSurfaceContainer, alphaFactor),
 			elevation,
 		)
 	}
@@ -216,25 +222,26 @@ fun Context.findActivity(): Activity? = when (this) {
 	else -> null
 }
 
-inline fun Activity.catchingWebViewUnavailability(block: () -> Unit): Boolean {
-	return try {
-		block()
-		true
-	} catch (e: Exception) {
-		if (e.isWebViewUnavailable()) {
-			Toast.makeText(this, R.string.web_view_unavailable, Toast.LENGTH_LONG).show()
-			finishAfterTransition()
-			false
-		} else {
-			throw e
-		}
+fun Fragment.findAppCompatDelegate(): AppCompatDelegate? {
+	((this as? DialogFragment)?.dialog as? AppCompatDialog)?.run {
+		return delegate
 	}
+	return parentFragment?.findAppCompatDelegate() ?: (activity as? AppCompatActivity)?.delegate
 }
 
-fun Context.checkNotificationPermission(): Boolean = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-	ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
-} else {
-	NotificationManagerCompat.from(this).areNotificationsEnabled()
+fun Context.checkNotificationPermission(channelId: String?): Boolean {
+	val hasPermission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+		ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) == PERMISSION_GRANTED
+	} else {
+		NotificationManagerCompat.from(this).areNotificationsEnabled()
+	}
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && hasPermission && channelId != null) {
+		val channel = NotificationManagerCompat.from(this).getNotificationChannel(channelId)
+		if (channel != null && channel.importance == NotificationManagerCompat.IMPORTANCE_NONE) {
+			return false
+		}
+	}
+	return hasPermission
 }
 
 @WorkerThread
@@ -251,3 +258,13 @@ fun Context.ensureRamAtLeast(requiredSize: Long) {
 		throw IllegalStateException("Not enough free memory")
 	}
 }
+
+fun WebView.configureForParser(userAgentOverride: String?) = with(settings) {
+	javaScriptEnabled = true
+	domStorageEnabled = true
+	mediaPlaybackRequiresUserGesture = false
+	databaseEnabled = true
+	if (userAgentOverride != null) {
+		userAgentString = userAgentOverride
+	}
+}

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

@@ -24,11 +24,15 @@ inline fun <reified T : Parcelable> Intent.getParcelableExtraCompat(key: String)
 }
 
 inline fun <reified T : Serializable> Intent.getSerializableExtraCompat(key: String): T? {
-	return getSerializableExtra(key) as T?
+	return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+		getSerializableExtra(key, T::class.java)
+	} else {
+		getSerializableExtra(key) as T?
+	}
 }
 
 inline fun <reified T : Serializable> Bundle.getSerializableCompat(key: String): T? {
-	return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+	return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
 		getSerializable(key, T::class.java)
 	} else {
 		getSerializable(key) as T?

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

@@ -1,7 +1,9 @@
 package org.koitharu.kotatsu.core.util.ext
 
 import android.content.Context
+import android.graphics.drawable.ColorDrawable
 import android.widget.ImageView
+import androidx.core.graphics.ColorUtils
 import androidx.core.graphics.drawable.toBitmap
 import androidx.lifecycle.LifecycleOwner
 import coil.ImageLoader
@@ -12,9 +14,11 @@ import coil.request.SuccessResult
 import coil.util.CoilUtils
 import com.google.android.material.progressindicator.BaseProgressIndicator
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.image.AnimatedPlaceholderDrawable
 import org.koitharu.kotatsu.core.ui.image.RegionBitmapDecoder
 import org.koitharu.kotatsu.core.util.progress.ImageRequestIndicatorListener
 import org.koitharu.kotatsu.parsers.model.MangaSource
+import com.google.android.material.R as materialR
 
 fun ImageView.newImageRequest(lifecycleOwner: LifecycleOwner, data: Any?): ImageRequest.Builder? {
 	val current = CoilUtils.result(this)
@@ -25,7 +29,7 @@ fun ImageView.newImageRequest(lifecycleOwner: LifecycleOwner, data: Any?): Image
 	}
 	// disposeImageRequest()
 	return ImageRequest.Builder(context)
-		.data(data?.takeUnless { it == "" })
+		.data(data?.takeUnless { it == "" || it == 0 })
 		.lifecycle(lifecycleOwner)
 		.crossfade(context)
 		.target(this)
@@ -85,6 +89,17 @@ fun ImageRequest.Builder.source(source: MangaSource?): ImageRequest.Builder {
 	return tag(MangaSource::class.java, source)
 }
 
+fun ImageRequest.Builder.defaultPlaceholders(context: Context): ImageRequest.Builder {
+	val errorColor = ColorUtils.blendARGB(
+		context.getThemeColor(materialR.attr.colorErrorContainer),
+		context.getThemeColor(materialR.attr.colorBackgroundFloating),
+		0.25f,
+	)
+	return placeholder(AnimatedPlaceholderDrawable(context))
+		.fallback(ColorDrawable(context.getThemeColor(materialR.attr.colorSurfaceContainer)))
+		.error(ColorDrawable(errorColor))
+}
+
 fun ImageRequest.Builder.addListener(listener: ImageRequest.Listener): ImageRequest.Builder {
 	val existing = build().listener
 	return listener(

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

@@ -68,3 +68,5 @@ fun <T> Iterable<T>.sortedWithSafe(comparator: Comparator<in T>): List<T> = try
 		toList()
 	}
 }
+
+fun Collection<*>?.sizeOrZero() = if (this == null) 0 else size

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

@@ -1,7 +1,6 @@
 package org.koitharu.kotatsu.core.util.ext
 
 import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleCoroutineScope
 import androidx.lifecycle.LifecycleDestroyedException
 import androidx.lifecycle.LifecycleEventObserver
 import androidx.lifecycle.LifecycleObserver
@@ -10,17 +9,20 @@ import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.lifecycle.lifecycleScope
 import dagger.hilt.android.lifecycle.RetainedLifecycle
 import kotlinx.coroutines.CancellableContinuation
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.plus
 import kotlinx.coroutines.suspendCancellableCoroutine
+import org.koitharu.kotatsu.core.util.AcraCoroutineErrorHandler
 import org.koitharu.kotatsu.core.util.RetainedLifecycleCoroutineScope
 import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 
-val processLifecycleScope: LifecycleCoroutineScope
-	inline get() = ProcessLifecycleOwner.get().lifecycleScope
+val processLifecycleScope: CoroutineScope
+	get() = ProcessLifecycleOwner.get().lifecycleScope + AcraCoroutineErrorHandler()
 
 val RetainedLifecycle.lifecycleScope: RetainedLifecycleCoroutineScope
 	inline get() = RetainedLifecycleCoroutineScope(this)

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

@@ -18,6 +18,7 @@ fun calculateTimeAgo(instant: Instant, showMonths: Boolean = false): DateTimeAgo
 			if (instant.until(Instant.now(), ChronoUnit.MINUTES) < 3) DateTimeAgo.JustNow
 			else DateTimeAgo.Today
 		}
+
 		diffDays == 1L -> DateTimeAgo.Yesterday
 		diffDays < 6 -> DateTimeAgo.DaysAgo(diffDays.toInt())
 		else -> {
@@ -30,3 +31,5 @@ fun calculateTimeAgo(instant: Instant, showMonths: Boolean = false): DateTimeAgo
 		}
 	}
 }
+
+fun Long.toInstantOrNull() = if (this == 0L) null else Instant.ofEpochMilli(this)

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

@@ -10,7 +10,6 @@ import android.provider.OpenableColumns
 import androidx.core.database.getStringOrNull
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
-import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.fs.FileSequence
 import java.io.File
@@ -19,6 +18,7 @@ import java.nio.file.attribute.BasicFileAttributes
 import java.util.zip.ZipEntry
 import java.util.zip.ZipFile
 import kotlin.io.path.ExperimentalPathApi
+import kotlin.io.path.PathWalkOption
 import kotlin.io.path.readAttributes
 import kotlin.io.path.walk
 
@@ -52,7 +52,7 @@ fun File.getStorageName(context: Context): String = runCatching {
 
 fun Uri.toFileOrNull() = if (scheme == URI_SCHEME_FILE) path?.let(::File) else null
 
-suspend fun File.deleteAwait() = withContext(Dispatchers.IO) {
+suspend fun File.deleteAwait() = runInterruptible(Dispatchers.IO) {
 	delete() || deleteRecursively()
 }
 
@@ -72,7 +72,7 @@ fun ContentResolver.resolveName(uri: Uri): String? {
 }
 
 suspend fun File.computeSize(): Long = runInterruptible(Dispatchers.IO) {
-	walkCompat().sumOf { it.length() }
+	walkCompat(includeDirectories = false).sumOf { it.length() }
 }
 
 fun File.children() = FileSequence(this)
@@ -87,10 +87,16 @@ val File.creationTime
 	}
 
 @OptIn(ExperimentalPathApi::class)
-fun File.walkCompat() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+fun File.walkCompat(includeDirectories: Boolean): Sequence<File> = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
 	// Use lazy loading on Android 8.0 and later
-	toPath().walk().map { it.toFile() }
+	val walk = if (includeDirectories) {
+		toPath().walk(PathWalkOption.INCLUDE_DIRECTORIES)
+	} else {
+		toPath().walk()
+	}
+	walk.map { it.toFile() }
 } else {
 	// Directories are excluded by default in Path.walk(), so do it here as well
-	walk().filter { it.isFile }
+	val walk = walk()
+	if (includeDirectories) walk else walk.filter { it.isFile }
 }