Update parsers

Currently translated at 100.0% (626 of 626 strings)

Co-authored-by: maryush <maryush@gmail.com>
Translate-URL: https://hosted.weblate.org/projects/kotatsu/strings/pl/
Translation: Kotatsu/Strings

.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 = 627
-		versionName = '6.7.5'
+		versionCode = 630
+		versionName = '6.8'
 		generatedDensities = []
 		testInstrumentationRunner 'org.koitharu.kotatsu.HiltTestRunner'
 		ksp {
@@ -82,19 +82,19 @@ afterEvaluate {
 }
 dependencies {
 	//noinspection GradleDependency
-	implementation('com.github.KotatsuApp:kotatsu-parsers:b7613606c0') {
+	implementation('com.github.KotatsuApp:kotatsu-parsers:639895f511') {
 		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.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.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'
@@ -106,6 +106,7 @@ dependencies {
 	implementation 'androidx.biometric:biometric-ktx:1.2.0-alpha05'
 	implementation 'com.google.android.material:material:1.12.0-alpha03'
 	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,7 +122,7 @@ 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'
@@ -147,7 +148,7 @@ dependencies {
 	debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.13'
 
 	testImplementation 'junit:junit:4.13.2'
-	testImplementation 'org.json:json:20240205'
+	testImplementation 'org.json:json:20240303'
 	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.0'
 
 	androidTestImplementation 'androidx.test:runner:1.5.2'

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"

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,136 @@
+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.DetailsLoadUseCase
+import org.koitharu.kotatsu.details.domain.ProgressUpdateUseCase
+import org.koitharu.kotatsu.favourites.data.FavouriteEntity
+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,
+	private val useCase: DetailsLoadUseCase
+) {
+
+	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 oldFavourite = favoritesDao.find(oldDetails.id)
+			if (oldFavourite != null) {
+				favoritesDao.delete(oldManga.id)
+				for (f in oldFavourite.categories) {
+					val e = FavouriteEntity(
+						mangaId = newManga.id,
+						categoryId = f.categoryId.toLong(),
+						sortKey = f.sortKey,
+						createdAt = f.createdAt,
+						deletedAt = 0,
+					)
+					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,92 @@
+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.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))
+			placeholder(R.drawable.ic_placeholder)
+			fallback(R.drawable.ic_placeholder)
+			error(R.drawable.ic_error_placeholder)
+			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/browser/BrowserActivity.kt

@@ -14,9 +14,9 @@ import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.BaseActivity
+import org.koitharu.kotatsu.core.util.ext.configureForParser
 import org.koitharu.kotatsu.core.util.ext.toUriOrNull
 import org.koitharu.kotatsu.databinding.ActivityBrowserBinding
-import org.koitharu.kotatsu.parsers.network.UserAgents
 import com.google.android.material.R as materialR
 
 @SuppressLint("SetJavaScriptEnabled")
@@ -33,10 +33,7 @@ class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback
 			setDisplayHomeAsUpEnabled(true)
 			setHomeAsUpIndicator(materialR.drawable.abc_ic_clear_material)
 		}
-		with(viewBinding.webView.settings) {
-			javaScriptEnabled = true
-			userAgentString = UserAgents.CHROME_MOBILE
-		}
+		viewBinding.webView.configureForParser(null)
 		CookieManager.getInstance().setAcceptThirdPartyCookies(viewBinding.webView, true)
 		viewBinding.webView.webViewClient = BrowserClient(this)
 		viewBinding.webView.webChromeClient = ProgressChromeClient(viewBinding.progressBar)

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

@@ -27,8 +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.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
 
@@ -40,6 +40,7 @@ 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?) {
@@ -52,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)
 		}
@@ -118,15 +115,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
 		}
 
@@ -152,6 +141,10 @@ class CloudFlareActivity : BaseActivity<ActivityBrowserBinding>(), CloudFlareCal
 		viewBinding.progressBar.isInvisible = true
 	}
 
+	override fun onLoopDetected() {
+		restartCheck()
+	}
+
 	override fun onCheckPassed() {
 		pendingResult = RESULT_OK
 		finishAfterTransition()
@@ -171,10 +164,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/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,7 @@ 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.Migration1To2
 import org.koitharu.kotatsu.core.db.migrations.Migration2To3
 import org.koitharu.kotatsu.core.db.migrations.Migration3To4
@@ -48,20 +49,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 = 19
 
 @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 +93,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 +115,7 @@ fun getDatabaseMigrations(context: Context): Array<Migration> = arrayOf(
 	Migration15To16(),
 	Migration16To17(context),
 	Migration17To18(),
+	Migration18To19(),
 )
 
 fun MangaDatabase(context: Context): MangaDatabase = Room

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/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/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
 	}
 
@@ -77,6 +85,11 @@ class ExceptionResolver : ActivityResultCallback<TaggedActivityResult> {
 		context.startActivity(BrowserActivity.newIntent(context, url, 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)
 
 	companion object {
@@ -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/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,24 @@ 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.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 +38,15 @@ class MangaLoaderContextImpl @Inject constructor(
 
 	private var webViewCached: WeakReference<WebView>? = null
 
+	private val userAgentLazy = SuspendLazy {
+		withContext(Dispatchers.Main) {
+			obtainWebView().settings.userAgentString
+		}
+	}
+
 	@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 +54,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 +77,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]

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

@@ -27,7 +27,6 @@ import org.koitharu.kotatsu.explore.data.SourcesSortOrder
 import org.koitharu.kotatsu.list.domain.ListSortOrder
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.util.find
-import org.koitharu.kotatsu.parsers.util.isNumeric
 import org.koitharu.kotatsu.parsers.util.mapNotNullToSet
 import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.reader.domain.ReaderColorFilter
@@ -179,10 +178,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)
 
@@ -422,6 +425,12 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	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
 	}
@@ -505,6 +514,8 @@ 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"
@@ -545,6 +556,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_HISTORY_GROUPING = "history_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"
@@ -614,8 +626,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_READING_TIME = "reading_time"
 		const val KEY_PAGES_SAVE_DIR = "pages_dir"
 		const val KEY_PAGES_SAVE_ASK = "pages_dir_ask"
-
-		// About
+		const val KEY_STATS_ENABLED = "stats_on"
 		const val KEY_APP_UPDATE = "app_update"
 		const val KEY_APP_TRANSLATION = "about_app_translation"
 	}

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

@@ -1,6 +1,7 @@
 package org.koitharu.kotatsu.core.prefs
 
 import android.content.Context
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener
 import androidx.core.content.edit
 import org.koitharu.kotatsu.core.util.ext.getEnumValue
 import org.koitharu.kotatsu.core.util.ext.ifNullOrEmpty
@@ -10,9 +11,6 @@ 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)
@@ -30,6 +28,7 @@ class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig
 			is ConfigKey.UserAgent -> prefs.getString(key.key, key.defaultValue).ifNullOrEmpty { key.defaultValue }
 			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
 	}
 
@@ -38,6 +37,21 @@ class SourceSettings(context: Context, source: MangaSource) : MangaSourceConfig
 			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.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/BaseListAdapter.kt

@@ -29,8 +29,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>) {

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/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,12 +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 org.koitharu.kotatsu.core.util.Colors
-import kotlin.math.absoluteValue
+import org.koitharu.kotatsu.core.util.KotatsuColors
 
 class FaviconDrawable(
 	context: Context,
@@ -45,7 +43,7 @@ class FaviconDrawable(
 		}
 		paint.textAlign = Paint.Align.CENTER
 		paint.isFakeBoldText = true
-		colorForeground = MaterialColors.harmonize(Colors.random(name), colorBackground)
+		colorForeground = MaterialColors.harmonize(KotatsuColors.random(name), colorBackground)
 	}
 
 	override fun draw(canvas: Canvas) {

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

@@ -110,7 +110,7 @@ class ChipsView @JvmOverloads constructor(
 		chip.isChipIconVisible = false
 		chip.isCloseIconVisible = onChipCloseClickListener != null
 		chip.setOnCloseIconClickListener(chipOnCloseListener)
-		chip.setEnsureMinTouchTargetSize(false)
+		chip.setEnsureMinTouchTargetSize(false) // TODO remove
 		chip.setOnClickListener(chipOnClickListener)
 		addView(chip)
 		return chip

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/util/KotatsuColors.kt

@@ -7,9 +7,10 @@ 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 Colors {
+object KotatsuColors {
 
 	@ColorInt
 	fun segmentColor(context: Context, @AttrRes resId: Int): Int {
@@ -20,11 +21,24 @@ object Colors {
 		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.colorSurface)
+		}
+		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()

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

@@ -27,6 +27,7 @@ import android.provider.Settings
 import android.view.View
 import android.view.ViewPropertyAnimator
 import android.view.Window
+import android.webkit.WebView
 import androidx.activity.result.ActivityResultLauncher
 import androidx.annotation.IntegerRes
 import androidx.annotation.WorkerThread
@@ -235,3 +236,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/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
@@ -53,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()
 }
 

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

@@ -17,6 +17,7 @@ import org.koitharu.kotatsu.core.exceptions.EmptyHistoryException
 import org.koitharu.kotatsu.core.exceptions.SyncApiException
 import org.koitharu.kotatsu.core.exceptions.TooManyRequestExceptions
 import org.koitharu.kotatsu.core.exceptions.UnsupportedFileException
+import org.koitharu.kotatsu.core.exceptions.UnsupportedSourceException
 import org.koitharu.kotatsu.core.exceptions.WrongPasswordException
 import org.koitharu.kotatsu.parsers.ErrorMessages.FILTER_BOTH_LOCALE_GENRES_NOT_SUPPORTED
 import org.koitharu.kotatsu.parsers.ErrorMessages.FILTER_BOTH_STATES_GENRES_NOT_SUPPORTED
@@ -56,6 +57,7 @@ fun Throwable.getDisplayMessage(resources: Resources): String = when (this) {
 
 	is WrongPasswordException -> resources.getString(R.string.wrong_password)
 	is NotFoundException -> resources.getString(R.string.not_found_404)
+	is UnsupportedSourceException -> resources.getString(R.string.unsupported_source)
 
 	is HttpException -> getHttpDisplayMessage(response.code, resources)
 	is HttpStatusException -> getHttpDisplayMessage(statusCode, resources)
@@ -98,6 +100,10 @@ fun Throwable.isReportable(): Boolean {
 	return this is Error || this.javaClass in reportableExceptions
 }
 
+fun Throwable.isNetworkError(): Boolean {
+	return this is UnknownHostException || this is SocketTimeoutException
+}
+
 fun Throwable.report() {
 	val exception = CaughtException(this, "${javaClass.simpleName}($message)")
 	exception.sendWithAcra()

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

@@ -17,6 +17,7 @@ import androidx.recyclerview.widget.RecyclerView.ViewHolder
 import androidx.swiperefreshlayout.widget.CircularProgressDrawable
 import androidx.viewpager2.widget.ViewPager2
 import com.google.android.material.button.MaterialButton
+import com.google.android.material.chip.Chip
 import com.google.android.material.progressindicator.BaseProgressIndicator
 import com.google.android.material.slider.Slider
 import com.google.android.material.tabs.TabLayout
@@ -169,3 +170,11 @@ fun MaterialButton.setProgressIcon() {
 	icon = progressDrawable
 	progressDrawable.start()
 }
+
+fun Chip.setProgressIcon() {
+	val progressDrawable = CircularProgressDrawable(context)
+	progressDrawable.strokeWidth = resources.resolveDp(2f)
+	progressDrawable.setColorSchemeColors(currentTextColor)
+	chipIcon = progressDrawable
+	progressDrawable.start()
+}

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

@@ -10,6 +10,7 @@ data class ReadingTime(
 ) {
 
 	fun format(resources: Resources): String = when {
+		hours == 0 && minutes == 0 -> resources.getString(R.string.less_than_minute)
 		hours == 0 -> resources.getQuantityString(R.plurals.minutes, minutes, minutes)
 		minutes == 0 -> resources.getQuantityString(R.plurals.hours, hours, hours)
 		else -> resources.getString(

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

@@ -5,25 +5,27 @@ import org.koitharu.kotatsu.core.model.findById
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.details.data.MangaDetails
 import org.koitharu.kotatsu.details.data.ReadingTime
+import org.koitharu.kotatsu.stats.data.StatsRepository
+import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 import kotlin.math.roundToInt
 
 class ReadingTimeUseCase @Inject constructor(
 	private val settings: AppSettings,
+	private val statsRepository: StatsRepository,
 ) {
 
-	fun invoke(manga: MangaDetails?, branch: String?, history: MangaHistory?): ReadingTime? {
+	suspend fun invoke(manga: MangaDetails?, branch: String?, history: MangaHistory?): ReadingTime? {
 		if (!settings.isReadingTimeEstimationEnabled) {
 			return null
 		}
-		// FIXME MAXIMUM HARDCODE!!! To do calculation with user's page read speed and his favourites/history mangas average pages in chapter
 		val chapters = manga?.chapters?.get(branch)
 		if (chapters.isNullOrEmpty()) {
 			return null
 		}
 		val isOnHistoryBranch = history != null && chapters.findById(history.chapterId) != null
 		// Impossible task, I guess. Good luck on this.
-		var averageTimeSec: Int = 20 * 10 * chapters.size // 20 pages, 10 seconds per page
+		var averageTimeSec: Int = 20 /* pages */ * getSecondsPerPage(manga.id) * chapters.size
 		if (isOnHistoryBranch) {
 			averageTimeSec = (averageTimeSec * (1f - checkNotNull(history).percent)).roundToInt()
 		}
@@ -36,4 +38,16 @@ class ReadingTimeUseCase @Inject constructor(
 			isContinue = isOnHistoryBranch,
 		)
 	}
+
+	private suspend fun getSecondsPerPage(mangaId: Long): Int {
+		var time = if (settings.isStatsEnabled) {
+			TimeUnit.MILLISECONDS.toSeconds(statsRepository.getTimePerPage(mangaId)).toInt()
+		} else {
+			0
+		}
+		if (time == 0) {
+			time = 10 // default
+		}
+		return time
+	}
 }

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

@@ -16,6 +16,7 @@ fun MangaDetails.mapChapters(
 	newCount: Int,
 	branch: String?,
 	bookmarks: List<Bookmark>,
+	isGrid: Boolean,
 ): List<ChapterListItem> {
 	val remoteChapters = chapters[branch].orEmpty()
 	val localChapters = local?.manga?.getChapters(branch).orEmpty()
@@ -47,6 +48,7 @@ fun MangaDetails.mapChapters(
 			isNew = isUnread && result.size >= newFrom,
 			isDownloaded = local != null,
 			isBookmarked = chapter.id in bookmarked,
+			isGrid = isGrid,
 		)
 	}
 	if (!localMap.isNullOrEmpty()) {
@@ -60,6 +62,7 @@ fun MangaDetails.mapChapters(
 				isNew = false,
 				isDownloaded = !isLocal,
 				isBookmarked = chapter.id in bookmarked,
+				isGrid = isGrid,
 			)
 		}
 	}

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

@@ -28,8 +28,9 @@ class ChaptersMenuProvider(
 	}
 
 	override fun onPrepareMenu(menu: Menu) {
-		menu.findItem(R.id.action_reversed)?.isChecked = viewModel.isChaptersReversed.value == true
 		menu.findItem(R.id.action_search)?.isVisible = viewModel.isChaptersEmpty.value == false
+		menu.findItem(R.id.action_reversed)?.isChecked = viewModel.isChaptersReversed.value == true
+		menu.findItem(R.id.action_grid_view)?.isChecked = viewModel.isChaptersInGridView.value == true
 	}
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean = when (menuItem.itemId) {
@@ -37,6 +38,10 @@ class ChaptersMenuProvider(
 			viewModel.setChaptersReversed(!menuItem.isChecked)
 			true
 		}
+		R.id.action_grid_view-> {
+			viewModel.setChaptersInGridView(!menuItem.isChecked)
+			true
+		}
 
 		else -> false
 	}

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

@@ -36,7 +36,6 @@ import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.flow.FlowCollector
 import kotlinx.coroutines.flow.filterNotNull
 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.os.AppShortcutManager
 import org.koitharu.kotatsu.core.parser.MangaIntent
@@ -125,20 +124,11 @@ class DetailsActivity :
 		viewModel.manga.filterNotNull().observe(this, ::onMangaUpdated)
 		viewModel.onMangaRemoved.observeEvent(this, ::onMangaRemoved)
 		viewModel.newChaptersCount.observe(this, ::onNewChaptersChanged)
-		viewModel.onError.observeEvent(
+		viewModel.onError.observeEvent(this, DetailsErrorObserver(this, viewModel, exceptionResolver))
+		viewModel.onActionDone.observeEvent(
 			this,
-			SnackbarErrorObserver(
-				host = viewBinding.containerDetails,
-				fragment = null,
-				resolver = exceptionResolver,
-				onResolved = { isResolved ->
-					if (isResolved) {
-						viewModel.reload()
-					}
-				},
-			),
+			ReversibleActionObserver(viewBinding.containerDetails, viewBinding.layoutBottom),
 		)
-		viewModel.onActionDone.observeEvent(this, ReversibleActionObserver(viewBinding.containerDetails, viewBinding.layoutBottom))
 		viewModel.onShowTip.observeEvent(this) { showTip() }
 		viewModel.historyInfo.observe(this, ::onHistoryChanged)
 		viewModel.selectedBranch.observe(this) {
@@ -150,6 +140,7 @@ class DetailsActivity :
 		viewModel.isChaptersEmpty.observe(this, chaptersMenuInvalidator)
 		val menuInvalidator = MenuInvalidator(this)
 		viewModel.favouriteCategories.observe(this, menuInvalidator)
+		viewModel.isStatsAvailable.observe(this, menuInvalidator)
 		viewModel.remoteManga.observe(this, menuInvalidator)
 		viewModel.branches.observe(this) {
 			viewBinding.buttonDropdown.isVisible = it.size > 1

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

@@ -0,0 +1,56 @@
+package org.koitharu.kotatsu.details.ui
+
+import com.google.android.material.snackbar.Snackbar
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.exceptions.UnsupportedSourceException
+import org.koitharu.kotatsu.core.exceptions.resolve.ErrorObserver
+import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
+import org.koitharu.kotatsu.core.ui.dialog.ErrorDetailsDialog
+import org.koitharu.kotatsu.core.util.ext.getDisplayMessage
+import org.koitharu.kotatsu.core.util.ext.isNetworkError
+import org.koitharu.kotatsu.parsers.exception.NotFoundException
+import org.koitharu.kotatsu.parsers.exception.ParseException
+
+class DetailsErrorObserver(
+	override val activity: DetailsActivity,
+	private val viewModel: DetailsViewModel,
+	resolver: ExceptionResolver?,
+) : ErrorObserver(
+	activity.viewBinding.containerDetails, null, resolver,
+	{ isResolved ->
+		if (isResolved) {
+			viewModel.reload()
+		}
+	},
+) {
+
+	override suspend fun emit(value: Throwable) {
+		val snackbar = Snackbar.make(host, value.getDisplayMessage(host.context.resources), Snackbar.LENGTH_SHORT)
+		if (value is NotFoundException || value is UnsupportedSourceException) {
+			snackbar.duration = Snackbar.LENGTH_INDEFINITE
+		}
+		when {
+			canResolve(value) -> {
+				snackbar.setAction(ExceptionResolver.getResolveStringId(value)) {
+					resolve(value)
+				}
+			}
+
+			value is ParseException -> {
+				val fm = fragmentManager
+				if (fm != null) {
+					snackbar.setAction(R.string.details) {
+						ErrorDetailsDialog.show(fm, value, value.url)
+					}
+				}
+			}
+
+			value.isNetworkError() -> {
+				snackbar.setAction(R.string.try_again) {
+					viewModel.reload()
+				}
+			}
+		}
+		snackbar.show()
+	}
+}

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

@@ -14,6 +14,7 @@ import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.snackbar.Snackbar
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.alternatives.ui.AlternativesActivity
 import org.koitharu.kotatsu.browser.BrowserActivity
 import org.koitharu.kotatsu.core.os.AppShortcutManager
 import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
@@ -23,6 +24,7 @@ import org.koitharu.kotatsu.favourites.ui.categories.select.FavoriteSheet
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.scrobbling.common.ui.selector.ScrobblingSelectorSheet
 import org.koitharu.kotatsu.search.ui.multi.MultiSearchActivity
+import org.koitharu.kotatsu.stats.ui.sheet.MangaStatsSheet
 
 class DetailsMenuProvider(
 	private val activity: FragmentActivity,
@@ -40,9 +42,11 @@ class DetailsMenuProvider(
 		menu.findItem(R.id.action_save).isVisible = manga?.source != null && manga.source != MangaSource.LOCAL
 		menu.findItem(R.id.action_delete).isVisible = manga?.source == MangaSource.LOCAL
 		menu.findItem(R.id.action_browser).isVisible = manga?.source != MangaSource.LOCAL
+		menu.findItem(R.id.action_alternatives).isVisible = manga?.source != MangaSource.LOCAL
 		menu.findItem(R.id.action_shortcut).isVisible = ShortcutManagerCompat.isRequestPinShortcutSupported(activity)
 		menu.findItem(R.id.action_scrobbling).isVisible = viewModel.isScrobblingAvailable
 		menu.findItem(R.id.action_online).isVisible = viewModel.remoteManga.value != null
+		menu.findItem(R.id.action_stats).isVisible = viewModel.isStatsAvailable.value
 		menu.findItem(R.id.action_favourite).setIcon(
 			if (viewModel.favouriteCategories.value) R.drawable.ic_heart else R.drawable.ic_heart_outline,
 		)
@@ -101,6 +105,18 @@ class DetailsMenuProvider(
 				}
 			}
 
+			R.id.action_alternatives -> {
+				viewModel.manga.value?.let {
+					activity.startActivity(AlternativesActivity.newIntent(activity, it))
+				}
+			}
+
+			R.id.action_stats -> {
+				viewModel.manga.value?.let {
+					MangaStatsSheet.show(activity.supportFragmentManager, it)
+				}
+			}
+
 			R.id.action_scrobbling -> {
 				viewModel.manga.value?.let {
 					ScrobblingSelectorSheet.show(activity.supportFragmentManager, it, null)

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

@@ -18,6 +18,7 @@ import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.mapLatest
+import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.plus
@@ -35,6 +36,7 @@ import org.koitharu.kotatsu.core.ui.BaseViewModel
 import org.koitharu.kotatsu.core.ui.util.ReversibleAction
 import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
 import org.koitharu.kotatsu.core.util.ext.call
+import org.koitharu.kotatsu.core.util.ext.combine
 import org.koitharu.kotatsu.core.util.ext.computeSize
 import org.koitharu.kotatsu.core.util.ext.onEachWhile
 import org.koitharu.kotatsu.core.util.ext.requireValue
@@ -61,6 +63,7 @@ import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import org.koitharu.kotatsu.scrobbling.common.domain.Scrobbler
 import org.koitharu.kotatsu.scrobbling.common.domain.model.ScrobblingInfo
 import org.koitharu.kotatsu.scrobbling.common.domain.model.ScrobblingStatus
+import org.koitharu.kotatsu.stats.data.StatsRepository
 import javax.inject.Inject
 
 @HiltViewModel
@@ -79,6 +82,7 @@ class DetailsViewModel @Inject constructor(
 	private val detailsLoadUseCase: DetailsLoadUseCase,
 	private val progressUpdateUseCase: ProgressUpdateUseCase,
 	private val readingTimeUseCase: ReadingTimeUseCase,
+	private val statsRepository: StatsRepository,
 ) : BaseViewModel() {
 
 	private val intent = MangaIntent(savedStateHandle)
@@ -100,6 +104,9 @@ class DetailsViewModel @Inject constructor(
 	val favouriteCategories = interactor.observeIsFavourite(mangaId)
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, false)
 
+	val isStatsAvailable = statsRepository.observeHasStats(mangaId)
+		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, false)
+
 	val remoteManga = MutableStateFlow<Manga?>(null)
 
 	val newChaptersCount = details.flatMapLatest { d ->
@@ -116,7 +123,13 @@ class DetailsViewModel @Inject constructor(
 	val isChaptersReversed = settings.observeAsStateFlow(
 		scope = viewModelScope + Dispatchers.Default,
 		key = AppSettings.KEY_REVERSE_CHAPTERS,
-		valueProducer = { chaptersReverse },
+		valueProducer = { isChaptersReverse },
+	)
+
+	val isChaptersInGridView = settings.observeAsStateFlow(
+		scope = viewModelScope + Dispatchers.Default,
+		key = AppSettings.KEY_GRID_VIEW_CHAPTERS,
+		valueProducer = { isChaptersGridView },
 	)
 
 	val historyInfo: StateFlow<HistoryInfo> = combine(
@@ -139,6 +152,7 @@ class DetailsViewModel @Inject constructor(
 	val localSize = details
 		.map { it?.local }
 		.distinctUntilChanged()
+		.combine(localStorageChanges.onStart { emit(null) }) { x, _ -> x }
 		.map { local ->
 			if (local != null) {
 				runCatchingCancellable {
@@ -200,12 +214,14 @@ class DetailsViewModel @Inject constructor(
 			selectedBranch,
 			newChaptersCount,
 			bookmarks,
-		) { manga, history, branch, news, bookmarks ->
+			isChaptersInGridView,
+		) { manga, history, branch, news, bookmarks, grid ->
 			manga?.mapChapters(
 				history,
 				news,
 				branch,
 				bookmarks,
+				grid,
 			).orEmpty()
 		},
 		isChaptersReversed,
@@ -275,7 +291,11 @@ class DetailsViewModel @Inject constructor(
 	}
 
 	fun setChaptersReversed(newValue: Boolean) {
-		settings.chaptersReverse = newValue
+		settings.isChaptersReverse = newValue
+	}
+
+	fun setChaptersInGridView(newValue: Boolean) {
+		settings.isChaptersGridView = newValue
 	}
 
 	fun setSelectedBranch(branch: String?) {

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

@@ -0,0 +1,52 @@
+package org.koitharu.kotatsu.details.ui.adapter
+
+import android.graphics.Typeface
+import androidx.core.view.isVisible
+import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
+import org.koitharu.kotatsu.core.model.formatNumber
+import org.koitharu.kotatsu.core.ui.list.AdapterDelegateClickListenerAdapter
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.util.ext.getThemeColorStateList
+import org.koitharu.kotatsu.databinding.ItemChapterGridBinding
+import org.koitharu.kotatsu.details.ui.model.ChapterListItem
+import org.koitharu.kotatsu.list.ui.model.ListModel
+
+fun chapterGridItemAD(
+	clickListener: OnListItemClickListener<ChapterListItem>,
+) = adapterDelegateViewBinding<ChapterListItem, ListModel, ItemChapterGridBinding>(
+	viewBinding = { inflater, parent -> ItemChapterGridBinding.inflate(inflater, parent, false) },
+	on = { item, _, _ -> item is ChapterListItem && item.isGrid },
+) {
+
+	val eventListener = AdapterDelegateClickListenerAdapter(this, clickListener)
+	itemView.setOnClickListener(eventListener)
+	itemView.setOnLongClickListener(eventListener)
+
+	bind { payloads ->
+		if (payloads.isEmpty()) {
+			binding.textViewTitle.text = item.chapter.formatNumber() ?: "?"
+		}
+		binding.imageViewNew.isVisible = item.isNew
+		binding.imageViewCurrent.isVisible = item.isCurrent
+		binding.imageViewBookmarked.isVisible = item.isBookmarked
+		binding.imageViewDownloaded.isVisible = item.isDownloaded
+
+		when {
+			item.isCurrent -> {
+				binding.textViewTitle.setTextColor(context.getThemeColorStateList(android.R.attr.textColorPrimary))
+				binding.textViewTitle.typeface = Typeface.DEFAULT_BOLD
+			}
+
+			item.isUnread -> {
+				binding.textViewTitle.setTextColor(context.getThemeColorStateList(android.R.attr.textColorPrimary))
+				binding.textViewTitle.typeface = Typeface.DEFAULT
+			}
+
+			else -> {
+				binding.textViewTitle.setTextColor(context.getThemeColorStateList(android.R.attr.textColorHint))
+				binding.textViewTitle.typeface = Typeface.DEFAULT
+			}
+		}
+	}
+}
+

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

@@ -18,7 +18,8 @@ import com.google.android.material.R as MR
 fun chapterListItemAD(
 	clickListener: OnListItemClickListener<ChapterListItem>,
 ) = adapterDelegateViewBinding<ChapterListItem, ListModel, ItemChapterBinding>(
-	{ inflater, parent -> ItemChapterBinding.inflate(inflater, parent, false) },
+	viewBinding = { inflater, parent -> ItemChapterBinding.inflate(inflater, parent, false) },
+	on = { item, _, _ -> item is ChapterListItem && !item.isGrid }
 ) {
 
 	val eventListener = AdapterDelegateClickListenerAdapter(this, clickListener)

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

@@ -10,12 +10,13 @@ import org.koitharu.kotatsu.list.ui.adapter.listHeaderAD
 import org.koitharu.kotatsu.list.ui.model.ListModel
 
 class ChaptersAdapter(
-	onItemClickListener: OnListItemClickListener<ChapterListItem>,
+	private val onItemClickListener: OnListItemClickListener<ChapterListItem>,
 ) : BaseListAdapter<ListModel>(), FastScroller.SectionIndexer {
 
 	init {
-		addDelegate(ListItemType.CHAPTER, chapterListItemAD(onItemClickListener))
 		addDelegate(ListItemType.HEADER, listHeaderAD(null))
+		addDelegate(ListItemType.CHAPTER_LIST, chapterListItemAD(onItemClickListener))
+		addDelegate(ListItemType.CHAPTER_GRID, chapterGridItemAD(onItemClickListener))
 	}
 
 	override fun getSectionText(context: Context, position: Int): CharSequence? {

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

@@ -6,8 +6,11 @@ import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.RectF
 import android.view.View
+import androidx.cardview.widget.CardView
+import androidx.core.content.ContextCompat
 import androidx.core.graphics.ColorUtils
 import androidx.recyclerview.widget.RecyclerView
+import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.list.decor.AbstractSelectionItemDecoration
 import org.koitharu.kotatsu.core.util.ext.getItem
 import org.koitharu.kotatsu.core.util.ext.getThemeColor
@@ -18,6 +21,14 @@ class ChaptersSelectionDecoration(context: Context) : AbstractSelectionItemDecor
 
 	private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
 	private val radius = context.resources.getDimension(materialR.dimen.abc_control_corner_material)
+	private val checkIcon = ContextCompat.getDrawable(context, materialR.drawable.ic_mtrl_checked_circle)
+	private val iconOffset = context.resources.getDimensionPixelOffset(R.dimen.chapter_check_offset)
+	private val iconSize = context.resources.getDimensionPixelOffset(R.dimen.chapter_check_size)
+	private val strokeColor = context.getThemeColor(materialR.attr.colorPrimary, Color.RED)
+	private val fillColor = ColorUtils.setAlphaComponent(
+		ColorUtils.blendARGB(strokeColor, context.getThemeColor(materialR.attr.colorSurface), 0.8f),
+		0x74,
+	)
 
 	init {
 		paint.color = ColorUtils.setAlphaComponent(
@@ -25,6 +36,12 @@ class ChaptersSelectionDecoration(context: Context) : AbstractSelectionItemDecor
 			98,
 		)
 		paint.style = Paint.Style.FILL
+		hasBackground = false
+		hasForeground = true
+		isIncludeDecorAndMargins = false
+
+		paint.strokeWidth = context.resources.getDimension(R.dimen.selection_stroke_width)
+		checkIcon?.setTint(strokeColor)
 	}
 
 	override fun getItemId(parent: RecyclerView, child: View): Long {
@@ -40,6 +57,37 @@ class ChaptersSelectionDecoration(context: Context) : AbstractSelectionItemDecor
 		bounds: RectF,
 		state: RecyclerView.State,
 	) {
+		if (child is CardView) {
+			return
+		}
 		canvas.drawRoundRect(bounds, radius, radius, paint)
 	}
+
+	override fun onDrawForeground(
+		canvas: Canvas,
+		parent: RecyclerView,
+		child: View,
+		bounds: RectF,
+		state: RecyclerView.State
+	) {
+		if (child !is CardView) {
+			return
+		}
+		val radius = child.radius
+		paint.color = fillColor
+		paint.style = Paint.Style.FILL
+		canvas.drawRoundRect(bounds, radius, radius, paint)
+		paint.color = strokeColor
+		paint.style = Paint.Style.STROKE
+		canvas.drawRoundRect(bounds, radius, radius, paint)
+		checkIcon?.run {
+			setBounds(
+				(bounds.right - iconSize - iconOffset).toInt(),
+				(bounds.top + iconOffset).toInt(),
+				(bounds.right - iconOffset).toInt(),
+				(bounds.top + iconOffset + iconSize).toInt(),
+			)
+			draw(canvas)
+		}
+	}
 }

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

@@ -48,6 +48,9 @@ data class ChapterListItem(
 	val isNew: Boolean
 		get() = hasFlag(FLAG_NEW)
 
+	val isGrid: Boolean
+		get() = hasFlag(FLAG_GRID)
+
 	private fun buildDescription(): String {
 		val joiner = StringJoiner(" • ")
 		chapter.formatNumber()?.let {
@@ -90,5 +93,6 @@ data class ChapterListItem(
 		const val FLAG_NEW = 8
 		const val FLAG_BOOKMARKED = 16
 		const val FLAG_DOWNLOADED = 32
+		const val FLAG_GRID = 64
 	}
 }

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

@@ -3,6 +3,7 @@ package org.koitharu.kotatsu.details.ui.model
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_BOOKMARKED
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_CURRENT
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_DOWNLOADED
+import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_GRID
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_NEW
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem.Companion.FLAG_UNREAD
 import org.koitharu.kotatsu.parsers.model.MangaChapter
@@ -13,6 +14,7 @@ fun MangaChapter.toListItem(
 	isNew: Boolean,
 	isDownloaded: Boolean,
 	isBookmarked: Boolean,
+	isGrid: Boolean,
 ): ChapterListItem {
 	var flags = 0
 	if (isCurrent) flags = flags or FLAG_CURRENT
@@ -20,6 +22,7 @@ fun MangaChapter.toListItem(
 	if (isNew) flags = flags or FLAG_NEW
 	if (isBookmarked) flags = flags or FLAG_BOOKMARKED
 	if (isDownloaded) flags = flags or FLAG_DOWNLOADED
+	if (isGrid) flags = flags or FLAG_GRID
 	return ChapterListItem(
 		chapter = this,
 		flags = flags,

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

@@ -0,0 +1,63 @@
+package org.koitharu.kotatsu.details.ui.pager.chapters
+
+import android.view.View
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.list.ui.adapter.ListItemType
+import kotlin.math.roundToInt
+
+class ChapterGridSpanHelper private constructor() : View.OnLayoutChangeListener {
+
+	override fun onLayoutChange(
+		v: View?,
+		left: Int,
+		top: Int,
+		right: Int,
+		bottom: Int,
+		oldLeft: Int,
+		oldTop: Int,
+		oldRight: Int,
+		oldBottom: Int
+	) {
+		val rv = v as? RecyclerView ?: return
+		if (rv.width > 0) {
+			apply(rv)
+		}
+	}
+
+	private fun apply(rv: RecyclerView) {
+		(rv.layoutManager as? GridLayoutManager)?.spanCount = getSpanCount(rv)
+	}
+
+	class SpanSizeLookup(
+		private val recyclerView: RecyclerView
+	) : GridLayoutManager.SpanSizeLookup() {
+
+		override fun getSpanSize(position: Int): Int {
+			return when (recyclerView.adapter?.getItemViewType(position)) {
+				ListItemType.CHAPTER_LIST.ordinal, // for smooth transition
+				ListItemType.HEADER.ordinal -> getTotalSpans()
+
+				else -> 1
+			}
+		}
+
+		private fun getTotalSpans() = (recyclerView.layoutManager as? GridLayoutManager)?.spanCount ?: 1
+	}
+
+	companion object {
+
+		fun attach(view: RecyclerView) {
+			val helper = ChapterGridSpanHelper()
+			view.addOnLayoutChangeListener(helper)
+			helper.apply(view)
+		}
+
+		fun getSpanCount(view: RecyclerView): Int {
+			val cellWidth = view.resources.getDimension(R.dimen.chapter_grid_width)
+			val estimatedCount = (view.width / cellWidth).roundToInt()
+			return estimatedCount.coerceAtLeast(2)
+		}
+	}
+}

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

@@ -11,6 +11,8 @@ import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.fragment.app.activityViewModels
 import androidx.lifecycle.Lifecycle
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
 import com.google.android.material.snackbar.Snackbar
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.flowOn
@@ -62,12 +64,22 @@ class ChaptersFragment :
 			registryOwner = this,
 			callback = this,
 		)
+		viewModel.isChaptersInGridView.observe(viewLifecycleOwner) { chaptersInGridView ->
+			binding.recyclerViewChapters.layoutManager = if (chaptersInGridView) {
+				GridLayoutManager(context, ChapterGridSpanHelper.getSpanCount(binding.recyclerViewChapters)).apply {
+					spanSizeLookup = ChapterGridSpanHelper.SpanSizeLookup(binding.recyclerViewChapters)
+				}
+			} else {
+				LinearLayoutManager(context)
+			}
+		}
 		with(binding.recyclerViewChapters) {
 			addItemDecoration(TypedListSpacingDecoration(context, true))
 			checkNotNull(selectionController).attachToRecyclerView(this)
 			setHasFixedSize(true)
 			isNestedScrollingEnabled = false
 			adapter = chaptersAdapter
+			ChapterGridSpanHelper.attach(this)
 		}
 		viewModel.isLoading.observe(viewLifecycleOwner, this::onLoadingStateChanged)
 		viewModel.chapters

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

@@ -59,7 +59,7 @@ fun downloadItemAD(
 		}
 	}
 	val chaptersAdapter = BaseListAdapter<DownloadChapter>()
-		.addDelegate(ListItemType.CHAPTER, downloadChapterAD())
+		.addDelegate(ListItemType.CHAPTER_LIST, downloadChapterAD())
 
 	binding.recyclerViewChapters.addItemDecoration(DividerItemDecoration(context, RecyclerView.VERTICAL))
 	binding.recyclerViewChapters.adapter = chaptersAdapter

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

@@ -52,6 +52,10 @@ class MangaSourcesRepository @Inject constructor(
 		return dao.findAllDisabled().toSources(settings.isNsfwContentDisabled, null)
 	}
 
+	fun observeIsEnabled(source: MangaSource): Flow<Boolean> {
+		return dao.observeIsEnabled(source.name)
+	}
+
 	fun observeEnabledSourcesCount(): Flow<Int> {
 		return combine(
 			observeIsNsfwDisabled(),

app/src/main/kotlin/org/koitharu/kotatsu/favourites/data/FavouritesDao.kt

@@ -190,11 +190,14 @@ abstract class FavouritesDao {
 	private fun getOrderBy(sortOrder: ListSortOrder) = when (sortOrder) {
 		ListSortOrder.RATING -> "manga.rating DESC"
 		ListSortOrder.NEWEST -> "favourites.created_at DESC"
+		ListSortOrder.OLDEST -> "favourites.created_at ASC"
 		ListSortOrder.ALPHABETIC -> "manga.title ASC"
 		ListSortOrder.ALPHABETIC_REVERSE -> "manga.title DESC"
 		ListSortOrder.NEW_CHAPTERS -> "IFNULL((SELECT chapters_new FROM tracks WHERE tracks.manga_id = manga.manga_id), 0) DESC"
 		ListSortOrder.PROGRESS -> "IFNULL((SELECT percent FROM history WHERE history.manga_id = manga.manga_id), 0) DESC"
+		ListSortOrder.UNREAD -> "IFNULL((SELECT percent FROM history WHERE history.manga_id = manga.manga_id), 0) ASC"
 		ListSortOrder.LAST_READ -> "IFNULL((SELECT updated_at FROM history WHERE history.manga_id = manga.manga_id), 0) DESC"
+		ListSortOrder.LONG_AGO_READ -> "IFNULL((SELECT updated_at FROM history WHERE history.manga_id = manga.manga_id), 0) ASC"
 
 		else -> throw IllegalArgumentException("Sort order $sortOrder is not supported")
 	}

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/categories/FavouriteCategoriesActivity.kt

@@ -178,6 +178,7 @@ class FavouriteCategoriesActivity :
 		}
 	}
 
+	@Deprecated("")
 	companion object {
 
 		fun newIntent(context: Context) = Intent(context, FavouriteCategoriesActivity::class.java)

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

@@ -36,8 +36,11 @@ abstract class HistoryDao {
 	fun observeAll(order: ListSortOrder): Flow<List<HistoryWithManga>> {
 		val orderBy = when (order) {
 			ListSortOrder.LAST_READ -> "history.updated_at DESC"
+			ListSortOrder.LONG_AGO_READ -> "history.updated_at ASC"
 			ListSortOrder.NEWEST -> "history.created_at DESC"
+			ListSortOrder.OLDEST -> "history.created_at ASC"
 			ListSortOrder.PROGRESS -> "history.percent DESC"
+			ListSortOrder.UNREAD -> "history.percent ASC"
 			ListSortOrder.ALPHABETIC -> "manga.title"
 			ListSortOrder.ALPHABETIC_REVERSE -> "manga.title DESC"
 			ListSortOrder.NEW_CHAPTERS -> "IFNULL((SELECT chapters_new FROM tracks WHERE tracks.manga_id = manga.manga_id), 0) DESC"

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

@@ -15,8 +15,8 @@ import org.koitharu.kotatsu.core.db.entity.MangaEntity
 			parentColumns = ["manga_id"],
 			childColumns = ["manga_id"],
 			onDelete = ForeignKey.CASCADE,
-		)
-	]
+		),
+	],
 )
 data class HistoryEntity(
 	@PrimaryKey(autoGenerate = false)
@@ -28,4 +28,5 @@ data class HistoryEntity(
 	@ColumnInfo(name = "scroll") val scroll: Float,
 	@ColumnInfo(name = "percent") val percent: Float,
 	@ColumnInfo(name = "deleted_at") val deletedAt: Long,
+	@ColumnInfo(name = "chapters") val chaptersCount: Int,
 )

app/src/main/kotlin/org/koitharu/kotatsu/history/data/HistoryRepository.kt

@@ -94,6 +94,7 @@ class HistoryRepository @Inject constructor(
 		if (!force && shouldSkip(manga)) {
 			return
 		}
+		assert(manga.chapters != null)
 		db.withTransaction {
 			mangaRepository.storeManga(manga)
 			db.getHistoryDao().upsert(
@@ -105,6 +106,7 @@ class HistoryRepository @Inject constructor(
 					page = page,
 					scroll = scroll.toFloat(), // we migrate to int, but decide to not update database
 					percent = percent,
+					chaptersCount = manga.chapters?.size ?: -1,
 					deletedAt = 0L,
 				),
 			)

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

@@ -11,7 +11,9 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.os.NetworkManageIntent
 import org.koitharu.kotatsu.core.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.ui.list.RecyclerScrollKeeper
+import org.koitharu.kotatsu.core.ui.util.MenuInvalidator
 import org.koitharu.kotatsu.core.util.ext.addMenuProvider
+import org.koitharu.kotatsu.core.util.ext.observe
 import org.koitharu.kotatsu.databinding.FragmentListBinding
 import org.koitharu.kotatsu.list.ui.MangaListFragment
 import org.koitharu.kotatsu.list.ui.size.DynamicItemSizeResolver
@@ -27,6 +29,7 @@ class HistoryListFragment : MangaListFragment() {
 		super.onViewBindingCreated(binding, savedInstanceState)
 		RecyclerScrollKeeper(binding.recyclerView).attach()
 		addMenuProvider(HistoryListMenuProvider(binding.root.context, viewModel))
+		viewModel.isStatsEnabled.observe(viewLifecycleOwner, MenuInvalidator(requireActivity()))
 	}
 
 	override fun onScrolledToEnd() = Unit

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

@@ -1,6 +1,7 @@
 package org.koitharu.kotatsu.history.ui
 
 import android.content.Context
+import android.content.Intent
 import android.view.Menu
 import android.view.MenuInflater
 import android.view.MenuItem
@@ -9,6 +10,7 @@ import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.dialog.RememberSelectionDialogListener
 import org.koitharu.kotatsu.core.util.ext.DIALOG_THEME_CENTERED
+import org.koitharu.kotatsu.stats.ui.StatsActivity
 import java.time.Instant
 import java.time.LocalDate
 import java.time.ZoneId
@@ -24,6 +26,11 @@ class HistoryListMenuProvider(
 		menuInflater.inflate(R.menu.opt_history, menu)
 	}
 
+	override fun onPrepareMenu(menu: Menu) {
+		super.onPrepareMenu(menu)
+		menu.findItem(R.id.action_stats)?.isVisible = viewModel.isStatsEnabled.value
+	}
+
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
 		return when (menuItem.itemId) {
 			R.id.action_clear_history -> {
@@ -31,6 +38,11 @@ class HistoryListMenuProvider(
 				true
 			}
 
+			R.id.action_stats -> {
+				context.startActivity(Intent(context, StatsActivity::class.java))
+				true
+			}
+
 			else -> false
 		}
 	}

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

@@ -71,6 +71,12 @@ class HistoryListViewModel @Inject constructor(
 		g && s.isGroupingSupported()
 	}
 
+	val isStatsEnabled = settings.observeAsStateFlow(
+		scope = viewModelScope + Dispatchers.Default,
+		key = AppSettings.KEY_STATS_ENABLED,
+		valueProducer = { isStatsEnabled },
+	)
+
 	override val content = combine(
 		sortOrder.flatMapLatest { repository.observeAllWithHistory(it) },
 		isGroupingEnabled,
@@ -172,8 +178,13 @@ class HistoryListViewModel @Inject constructor(
 	}
 
 	private fun MangaHistory.header(order: ListSortOrder): ListHeader? = when (order) {
-		ListSortOrder.LAST_READ -> ListHeader(calculateTimeAgo(updatedAt))
+		ListSortOrder.LAST_READ,
+		ListSortOrder.LONG_AGO_READ -> ListHeader(calculateTimeAgo(updatedAt))
+
+		ListSortOrder.OLDEST,
 		ListSortOrder.NEWEST -> ListHeader(calculateTimeAgo(createdAt))
+
+		ListSortOrder.UNREAD,
 		ListSortOrder.PROGRESS -> ListHeader(
 			when (percent) {
 				1f -> R.string.status_completed

app/src/main/kotlin/org/koitharu/kotatsu/list/domain/ListSortOrder.kt

@@ -10,21 +10,45 @@ enum class ListSortOrder(
 ) {
 
 	NEWEST(R.string.order_added),
+	OLDEST(R.string.order_oldest),
 	PROGRESS(R.string.progress),
+	UNREAD(R.string.unread),
 	ALPHABETIC(R.string.by_name),
 	ALPHABETIC_REVERSE(R.string.by_name_reverse),
 	RATING(R.string.by_rating),
 	RELEVANCE(R.string.by_relevance),
 	NEW_CHAPTERS(R.string.new_chapters),
 	LAST_READ(R.string.last_read),
+	LONG_AGO_READ(R.string.long_ago_read),
 	;
 
 	fun isGroupingSupported() = this == LAST_READ || this == NEWEST || this == PROGRESS
 
 	companion object {
 
-		val HISTORY: Set<ListSortOrder> = EnumSet.of(LAST_READ, NEWEST, PROGRESS, ALPHABETIC, ALPHABETIC_REVERSE, NEW_CHAPTERS)
-		val FAVORITES: Set<ListSortOrder> = EnumSet.of(ALPHABETIC, ALPHABETIC_REVERSE, NEWEST, RATING, NEW_CHAPTERS, PROGRESS, LAST_READ)
+		val HISTORY: Set<ListSortOrder> = EnumSet.of(
+			LAST_READ,
+			LONG_AGO_READ,
+			NEWEST,
+			OLDEST,
+			PROGRESS,
+			UNREAD,
+			ALPHABETIC,
+			ALPHABETIC_REVERSE,
+			NEW_CHAPTERS,
+		)
+		val FAVORITES: Set<ListSortOrder> = EnumSet.of(
+			ALPHABETIC,
+			ALPHABETIC_REVERSE,
+			NEWEST,
+			OLDEST,
+			RATING,
+			NEW_CHAPTERS,
+			PROGRESS,
+			UNREAD,
+			LAST_READ,
+			LONG_AGO_READ,
+		)
 		val SUGGESTIONS: Set<ListSortOrder> = EnumSet.of(RELEVANCE)
 
 		operator fun invoke(value: String, fallback: ListSortOrder) = entries.find(value) ?: fallback

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

@@ -20,6 +20,5 @@ fun errorFooterAD(
 
 	bind {
 		binding.textViewTitle.text = item.exception.getDisplayMessage(context.resources)
-		binding.imageViewIcon.setImageResource(item.icon)
 	}
 }

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

@@ -29,5 +29,6 @@ enum class ListItemType {
 	CATEGORY_LARGE,
 	MANGA_SCROBBLING,
 	NAV_ITEM,
-	CHAPTER,
+	CHAPTER_LIST,
+	CHAPTER_GRID,
 }

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

@@ -62,10 +62,12 @@ class TypedListSpacingDecoration(
 			ListItemType.MANGA_NESTED_GROUP,
 			ListItemType.CATEGORY_LARGE,
 			ListItemType.NAV_ITEM,
-			ListItemType.CHAPTER,
+			ListItemType.CHAPTER_LIST,
 			null,
 			-> outRect.set(0)
 
+			ListItemType.CHAPTER_GRID -> outRect.set(spacingSmall)
+
 			ListItemType.TIP -> outRect.set(0) // TODO
 		}
 		if (addHorizontalPadding && !itemType.isEdgeToEdge()) {
@@ -83,5 +85,6 @@ class TypedListSpacingDecoration(
 	private fun ListItemType?.isEdgeToEdge() = this == ListItemType.MANGA_NESTED_GROUP
 		|| this == ListItemType.FILTER_SORT
 		|| this == ListItemType.FILTER_TAG
-		|| this == ListItemType.CHAPTER
+		|| this == ListItemType.CHAPTER_LIST
+		|| this == ListItemType.CHAPTER_GRID
 }

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

@@ -4,7 +4,6 @@ import androidx.annotation.DrawableRes
 
 data class ErrorFooter(
 	val exception: Throwable,
-	@DrawableRes val icon: Int
 ) : ListModel {
 
 	override fun areItemsTheSame(other: ListModel): Boolean {

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

@@ -83,5 +83,4 @@ fun Throwable.toErrorState(canRetry: Boolean = true) = ErrorState(
 
 fun Throwable.toErrorFooter() = ErrorFooter(
 	exception = this,
-	icon = R.drawable.ic_alert_outline,
 )

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

@@ -106,7 +106,7 @@ class MangaIndex(source: String?) {
 	}
 
 	fun removeChapter(id: Long): Boolean {
-		return json.getJSONObject("chapters").remove(id.toString()) != null
+		return json.has("chapters") && json.getJSONObject("chapters").remove(id.toString()) != null
 	}
 
 	fun getChapterFileName(chapterId: Long): String? {

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

@@ -1,5 +1,7 @@
 package org.koitharu.kotatsu.local.data.output
 
+import androidx.core.net.toFile
+import androidx.core.net.toUri
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.sync.Mutex
@@ -9,6 +11,7 @@ import org.koitharu.kotatsu.core.util.ext.deleteAwait
 import org.koitharu.kotatsu.core.util.ext.takeIfReadable
 import org.koitharu.kotatsu.core.zip.ZipOutput
 import org.koitharu.kotatsu.local.data.MangaIndex
+import org.koitharu.kotatsu.local.data.input.LocalMangaDirInput
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.parsers.util.toFileNameSafe
@@ -46,22 +49,23 @@ class LocalMangaDirOutput(
 		flushIndex()
 	}
 
-	override suspend fun addPage(chapter: IndexedValue<MangaChapter>, file: File, pageNumber: Int, ext: String) = mutex.withLock {
-		val output = chaptersOutput.getOrPut(chapter.value) {
-			ZipOutput(File(rootFile, chapterFileName(chapter) + SUFFIX_TMP))
-		}
-		val name = buildString {
-			append(FILENAME_PATTERN.format(chapter.value.branch.hashCode(), chapter.index + 1, pageNumber))
-			if (ext.isNotEmpty() && ext.length <= 4) {
-				append('.')
-				append(ext)
+	override suspend fun addPage(chapter: IndexedValue<MangaChapter>, file: File, pageNumber: Int, ext: String) =
+		mutex.withLock {
+			val output = chaptersOutput.getOrPut(chapter.value) {
+				ZipOutput(File(rootFile, chapterFileName(chapter) + SUFFIX_TMP))
 			}
+			val name = buildString {
+				append(FILENAME_PATTERN.format(chapter.value.branch.hashCode(), chapter.index + 1, pageNumber))
+				if (ext.isNotEmpty() && ext.length <= 4) {
+					append('.')
+					append(ext)
+				}
+			}
+			runInterruptible(Dispatchers.IO) {
+				output.put(name, file)
+			}
+			index.addChapter(chapter, chapterFileName(chapter))
 		}
-		runInterruptible(Dispatchers.IO) {
-			output.put(name, file)
-		}
-		index.addChapter(chapter, chapterFileName(chapter))
-	}
 
 	override suspend fun flushChapter(chapter: MangaChapter): Boolean = mutex.withLock {
 		val output = chaptersOutput.remove(chapter) ?: return@withLock false
@@ -90,13 +94,24 @@ class LocalMangaDirOutput(
 		}
 	}
 
-	suspend fun deleteChapter(chapterId: Long) = mutex.withLock {
-		val chapter = checkNotNull(index.getMangaInfo()?.chapters?.withIndex()) {
+	suspend fun deleteChapters(ids: Set<Long>) = mutex.withLock {
+		val chapters = checkNotNull((index.getMangaInfo() ?: LocalMangaDirInput(rootFile).getManga().manga).chapters) {
 			"No chapters found"
-		}.find { x -> x.value.id == chapterId } ?: error("Chapter not found")
-		val chapterDir = File(rootFile, chapterFileName(chapter))
-		chapterDir.deleteAwait()
-		index.removeChapter(chapterId)
+		}.withIndex()
+		val victimsIds = ids.toMutableSet()
+		for (chapter in chapters) {
+			if (!victimsIds.remove(chapter.value.id)) {
+				continue
+			}
+			val chapterFile = index.getChapterFileName(chapter.value.id)?.let {
+				File(rootFile, it)
+			} ?: chapter.value.url.toUri().toFile()
+			chapterFile.deleteAwait()
+			index.removeChapter(chapter.value.id)
+		}
+		check(victimsIds.isEmpty()) {
+			"${victimsIds.size} of ${ids.size} chapters was not removed: not found"
+		}
 	}
 
 	fun setIndex(newIndex: MangaIndex) {

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

@@ -25,9 +25,7 @@ class LocalMangaUtil(
 				}
 
 				is LocalMangaDirOutput -> {
-					for (id in ids) {
-						output.deleteChapter(id)
-					}
+					output.deleteChapters(ids)
 					output.finish()
 				}
 			}

app/src/main/kotlin/org/koitharu/kotatsu/local/domain/DeleteReadChaptersUseCase.kt

@@ -0,0 +1,96 @@
+package org.koitharu.kotatsu.local.domain
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.buffer
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.flow.fold
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import org.koitharu.kotatsu.core.model.findById
+import org.koitharu.kotatsu.core.model.ids
+import org.koitharu.kotatsu.core.model.isLocal
+import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
+import org.koitharu.kotatsu.history.data.HistoryRepository
+import org.koitharu.kotatsu.local.data.LocalMangaRepository
+import org.koitharu.kotatsu.local.data.LocalStorageChanges
+import org.koitharu.kotatsu.local.domain.model.LocalManga
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
+import javax.inject.Inject
+
+class DeleteReadChaptersUseCase @Inject constructor(
+	private val localMangaRepository: LocalMangaRepository,
+	private val historyRepository: HistoryRepository,
+	@LocalStorageChanges private val localStorageChanges: MutableSharedFlow<LocalManga?>,
+) {
+
+	suspend operator fun invoke(manga: Manga): Int {
+		val localManga = if (manga.isLocal) {
+			LocalManga(manga)
+		} else {
+			checkNotNull(localMangaRepository.findSavedManga(manga)) { "Cannot find local manga" }
+		}
+		val task = getDeletionTask(localManga) ?: return 0
+		localMangaRepository.deleteChapters(task.manga.manga, task.chaptersIds)
+		emitUpdate(localManga)
+		return task.chaptersIds.size
+	}
+
+	suspend operator fun invoke(): Int {
+		val list = localMangaRepository.getList(0, null)
+		if (list.isEmpty()) {
+			return 0
+		}
+		return channelFlow {
+			for (manga in list) {
+				launch(Dispatchers.Default) {
+					val task = runCatchingCancellable {
+						getDeletionTask(LocalManga(manga))
+					}.onFailure {
+						it.printStackTraceDebug()
+					}.getOrNull()
+					if (task != null) {
+						send(task)
+					}
+				}
+			}
+		}.buffer().map {
+			runCatchingCancellable {
+				localMangaRepository.deleteChapters(it.manga.manga, it.chaptersIds)
+				emitUpdate(it.manga)
+				it.chaptersIds.size
+			}.onFailure {
+				it.printStackTraceDebug()
+			}.getOrDefault(0)
+		}.fold(0) { acc, x -> acc + x }
+	}
+
+	private suspend fun getDeletionTask(manga: LocalManga): DeletionTask? {
+		val history = historyRepository.getOne(manga.manga) ?: return null
+		val chapters = manga.manga.chapters ?: localMangaRepository.getDetails(manga.manga).chapters
+		if (chapters.isNullOrEmpty()) {
+			return null
+		}
+		val branch = (chapters.findById(history.chapterId) ?: return null).branch
+		val filteredChapters = manga.manga.getChapters(branch)?.takeWhile { it.id != history.chapterId }
+		return if (filteredChapters.isNullOrEmpty()) {
+			null
+		} else {
+			DeletionTask(
+				manga = manga,
+				chaptersIds = filteredChapters.ids(),
+			)
+		}
+	}
+
+	private suspend fun emitUpdate(subject: LocalManga) {
+		val updated = localMangaRepository.getDetails(subject.manga)
+		localStorageChanges.emit(subject.copy(manga = updated))
+	}
+
+	private class DeletionTask(
+		val manga: LocalManga,
+		val chaptersIds: Set<Long>,
+	)
+}

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

@@ -11,6 +11,7 @@ import androidx.core.content.ContextCompat
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.flow.MutableSharedFlow
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ErrorReporterReceiver
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
 import org.koitharu.kotatsu.core.ui.CoroutineIntentService
 import org.koitharu.kotatsu.core.util.ext.getDisplayMessage
@@ -45,10 +46,13 @@ class LocalChaptersRemoveService : CoroutineIntentService() {
 		val manga = intent.getParcelableExtraCompat<ParcelableManga>(EXTRA_MANGA)?.manga ?: return
 		val chaptersIds = intent.getLongArrayExtra(EXTRA_CHAPTERS_IDS)?.toSet() ?: return
 		startForeground()
-		val mangaWithChapters = localMangaRepository.getDetails(manga)
-		localMangaRepository.deleteChapters(mangaWithChapters, chaptersIds)
-		localStorageChanges.emit(LocalManga(localMangaRepository.getDetails(manga)))
-		ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+		try {
+			val mangaWithChapters = localMangaRepository.getDetails(manga)
+			localMangaRepository.deleteChapters(mangaWithChapters, chaptersIds)
+			localStorageChanges.emit(LocalManga(localMangaRepository.getDetails(manga)))
+		} finally {
+			ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+		}
 	}
 
 	override fun onError(startId: Int, error: Throwable) {
@@ -60,6 +64,7 @@ class LocalChaptersRemoveService : CoroutineIntentService() {
 			.setContentText(error.getDisplayMessage(resources))
 			.setSmallIcon(android.R.drawable.stat_notify_error)
 			.setAutoCancel(true)
+			.setContentIntent(ErrorReporterReceiver.getPendingIntent(this, error))
 			.build()
 		val nm = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 		nm.notify(NOTIFICATION_ID + startId, notification)

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

@@ -13,18 +13,25 @@ import androidx.work.await
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import org.koitharu.kotatsu.core.parser.MangaDataRepository
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.local.data.LocalMangaRepository
+import org.koitharu.kotatsu.local.domain.DeleteReadChaptersUseCase
 import java.util.concurrent.TimeUnit
 
 @HiltWorker
 class LocalStorageCleanupWorker @AssistedInject constructor(
 	@Assisted appContext: Context,
 	@Assisted params: WorkerParameters,
+	private val settings: AppSettings,
 	private val localMangaRepository: LocalMangaRepository,
 	private val dataRepository: MangaDataRepository,
+	private val deleteReadChaptersUseCase: DeleteReadChaptersUseCase,
 ) : CoroutineWorker(appContext, params) {
 
 	override suspend fun doWork(): Result {
+		if (settings.isAutoLocalChaptersCleanupEnabled) {
+			deleteReadChaptersUseCase.invoke()
+		}
 		return if (localMangaRepository.cleanup()) {
 			dataRepository.cleanupLocalManga()
 			Result.success()
@@ -44,7 +51,7 @@ class LocalStorageCleanupWorker @AssistedInject constructor(
 			val request = OneTimeWorkRequestBuilder<ImportWorker>()
 				.setConstraints(constraints)
 				.addTag(TAG)
-				.setBackoffCriteria(BackoffPolicy.LINEAR, 1, TimeUnit.MINUTES)
+				.setBackoffCriteria(BackoffPolicy.LINEAR, 10, TimeUnit.MINUTES)
 				.build()
 			WorkManager.getInstance(context).enqueueUniqueWork(TAG, ExistingWorkPolicy.KEEP, request).await()
 		}

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

@@ -2,18 +2,13 @@ package org.koitharu.kotatsu.local.ui.info
 
 import android.content.res.ColorStateList
 import android.os.Bundle
-import android.os.Parcelable
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
-import androidx.annotation.AttrRes
-import androidx.annotation.ColorInt
-import androidx.annotation.StringRes
-import androidx.core.graphics.ColorUtils
+import android.widget.Toast
 import androidx.core.widget.TextViewCompat
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.viewModels
-import com.google.android.material.color.MaterialColors
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.flow.combine
@@ -21,27 +16,24 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
 import org.koitharu.kotatsu.core.ui.AlertDialogFragment
 import org.koitharu.kotatsu.core.ui.widgets.SegmentedBarView
-import org.koitharu.kotatsu.core.util.Colors
 import org.koitharu.kotatsu.core.util.FileSize
-import org.koitharu.kotatsu.core.util.ext.combine
-import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import org.koitharu.kotatsu.core.util.KotatsuColors
 import org.koitharu.kotatsu.core.util.ext.observe
+import org.koitharu.kotatsu.core.util.ext.observeEvent
+import org.koitharu.kotatsu.core.util.ext.setProgressIcon
 import org.koitharu.kotatsu.core.util.ext.showDistinct
 import org.koitharu.kotatsu.core.util.ext.withArgs
 import org.koitharu.kotatsu.databinding.DialogLocalInfoBinding
 import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.settings.userdata.StorageUsage
 import com.google.android.material.R as materialR
 
 @AndroidEntryPoint
-class LocalInfoDialog : AlertDialogFragment<DialogLocalInfoBinding>() {
+class LocalInfoDialog : AlertDialogFragment<DialogLocalInfoBinding>(), View.OnClickListener {
 
 	private val viewModel: LocalInfoViewModel by viewModels()
 
 	override fun onBuildDialog(builder: MaterialAlertDialogBuilder): MaterialAlertDialogBuilder {
-		return super.onBuildDialog(builder)
-			.setTitle(R.string.saved_manga)
-			.setNegativeButton(R.string.close, null)
+		return super.onBuildDialog(builder).setTitle(R.string.saved_manga).setNegativeButton(R.string.close, null)
 	}
 
 	override fun onCreateViewBinding(inflater: LayoutInflater, container: ViewGroup?): DialogLocalInfoBinding {
@@ -53,13 +45,44 @@ class LocalInfoDialog : AlertDialogFragment<DialogLocalInfoBinding>() {
 		viewModel.path.observe(this) {
 			binding.textViewPath.text = it
 		}
-		combine(viewModel.size, viewModel.availableSize, ::Pair).observe(this) {
+		binding.chipCleanup.setOnClickListener(this)
+		combine(viewModel.size, viewModel.availableSize, ::Pair).observe(viewLifecycleOwner) {
 			if (it.first >= 0 && it.second >= 0) {
 				setSegments(it.first, it.second)
 			} else {
 				binding.barView.animateSegments(emptyList())
 			}
 		}
+		viewModel.onCleanedUp.observeEvent(viewLifecycleOwner, ::onCleanedUp)
+		viewModel.isCleaningUp.observe(viewLifecycleOwner) { loading ->
+			binding.chipCleanup.isClickable = !loading
+			dialog?.setCancelable(!loading)
+			if (loading) {
+				binding.chipCleanup.setProgressIcon()
+			} else {
+				binding.chipCleanup.setChipIconResource(R.drawable.ic_delete)
+			}
+		}
+	}
+
+	override fun onClick(v: View) {
+		when (v.id) {
+			R.id.chip_cleanup -> viewModel.cleanup()
+		}
+	}
+
+	private fun onCleanedUp(result: Pair<Int, Long>) {
+		val c = context ?: return
+		val text = if (result.first == 0 && result.second == 0L) {
+			c.getString(R.string.no_chapters_deleted)
+		} else {
+			c.getString(
+				R.string.chapters_deleted_pattern,
+				c.resources.getQuantityString(R.plurals.chapters, result.first, result.first),
+				FileSize.BYTES.format(c, result.second),
+			)
+		}
+		Toast.makeText(c, text, Toast.LENGTH_SHORT).show()
 	}
 
 	private fun setSegments(size: Long, available: Long) {
@@ -67,7 +90,7 @@ class LocalInfoDialog : AlertDialogFragment<DialogLocalInfoBinding>() {
 		val total = size + available
 		val segment = SegmentedBarView.Segment(
 			percent = (size.toDouble() / total.toDouble()).toFloat(),
-			color = Colors.segmentColor(view.context, materialR.attr.colorPrimary),
+			color = KotatsuColors.segmentColor(view.context, materialR.attr.colorPrimary),
 		)
 		requireViewBinding().labelUsed.text = view.context.getString(
 			R.string.memory_usage_pattern,

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

@@ -1,6 +1,5 @@
 package org.koitharu.kotatsu.local.ui.info
 
-import androidx.core.net.toFile
 import androidx.core.net.toUri
 import androidx.lifecycle.SavedStateHandle
 import dagger.hilt.android.lifecycle.HiltViewModel
@@ -8,12 +7,14 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
 import org.koitharu.kotatsu.core.ui.BaseViewModel
-import org.koitharu.kotatsu.core.ui.widgets.SegmentedBarView
+import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
+import org.koitharu.kotatsu.core.util.ext.call
 import org.koitharu.kotatsu.core.util.ext.computeSize
 import org.koitharu.kotatsu.core.util.ext.require
 import org.koitharu.kotatsu.core.util.ext.toFileOrNull
 import org.koitharu.kotatsu.local.data.LocalMangaRepository
 import org.koitharu.kotatsu.local.data.LocalStorageManager
+import org.koitharu.kotatsu.local.domain.DeleteReadChaptersUseCase
 import javax.inject.Inject
 
 @HiltViewModel
@@ -21,21 +22,42 @@ class LocalInfoViewModel @Inject constructor(
 	savedStateHandle: SavedStateHandle,
 	private val localMangaRepository: LocalMangaRepository,
 	private val storageManager: LocalStorageManager,
+	private val deleteReadChaptersUseCase: DeleteReadChaptersUseCase,
 ) : BaseViewModel() {
 
 	private val manga = savedStateHandle.require<ParcelableManga>(LocalInfoDialog.ARG_MANGA).manga
 
+	val isCleaningUp = MutableStateFlow(false)
+	val onCleanedUp = MutableEventFlow<Pair<Int, Long>>()
+
 	val path = MutableStateFlow<String?>(null)
 	val size = MutableStateFlow(-1L)
 	val availableSize = MutableStateFlow(-1L)
 
 	init {
-		launchLoadingJob(Dispatchers.Default) {
-			val file = manga.url.toUri().toFileOrNull() ?: localMangaRepository.findSavedManga(manga)?.file
-			requireNotNull(file)
-			path.value = file.path
-			size.value = file.computeSize()
-			availableSize.value = storageManager.computeAvailableSize()
+		computeSize()
+	}
+
+	fun cleanup() {
+		launchJob(Dispatchers.Default) {
+			try {
+				isCleaningUp.value = true
+				val oldSize = size.value
+				val chaptersCount = deleteReadChaptersUseCase.invoke(manga)
+				computeSize().join()
+				val newSize = size.value
+				onCleanedUp.call(chaptersCount to oldSize - newSize)
+			} finally {
+				isCleaningUp.value = false
+			}
 		}
 	}
+
+	private fun computeSize() = launchLoadingJob(Dispatchers.Default) {
+		val file = manga.url.toUri().toFileOrNull() ?: localMangaRepository.findSavedManga(manga)?.file
+		requireNotNull(file)
+		path.value = file.path
+		size.value = file.computeSize()
+		availableSize.value = storageManager.computeAvailableSize()
+	}
 }

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

@@ -6,6 +6,8 @@ import android.view.View
 import android.view.ViewGroup
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.activityViewModels
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
 import dagger.hilt.android.AndroidEntryPoint
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.model.MangaHistory
@@ -19,6 +21,7 @@ import org.koitharu.kotatsu.databinding.SheetChaptersBinding
 import org.koitharu.kotatsu.details.ui.adapter.ChaptersAdapter
 import org.koitharu.kotatsu.details.ui.mapChapters
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem
+import org.koitharu.kotatsu.details.ui.pager.chapters.ChapterGridSpanHelper
 import org.koitharu.kotatsu.details.ui.withVolumeHeaders
 import org.koitharu.kotatsu.history.data.PROGRESS_NONE
 import org.koitharu.kotatsu.list.ui.adapter.TypedListSpacingDecoration
@@ -64,6 +67,7 @@ class ChaptersSheet : BaseAdaptiveSheet<SheetChaptersBinding>(),
 			newCount = 0,
 			branch = currentChapter?.branch,
 			bookmarks = listOf(),
+			isGrid = settings.isChaptersGridView,
 		).withVolumeHeaders(binding.root.context)
 		if (chapters.isEmpty()) {
 			dismissAllowingStateLoss()
@@ -87,6 +91,14 @@ class ChaptersSheet : BaseAdaptiveSheet<SheetChaptersBinding>(),
 				adapter.items = chapters
 			}
 		}
+		ChapterGridSpanHelper.attach(binding.recyclerView)
+		binding.recyclerView.layoutManager = if (settings.isChaptersGridView) {
+			GridLayoutManager(context, ChapterGridSpanHelper.getSpanCount(binding.recyclerView)).apply {
+				spanSizeLookup = ChapterGridSpanHelper.SpanSizeLookup(binding.recyclerView)
+			}
+		} else {
+			LinearLayoutManager(context)
+		}
 	}
 
 	override fun onItemClick(item: ChapterListItem, view: View) {

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

@@ -176,6 +176,11 @@ class ReaderActivity :
 		idlingDetector.onUserInteraction()
 	}
 
+	override fun onPause() {
+		super.onPause()
+		viewModel.onPause()
+	}
+
 	override fun onIdle() {
 		viewModel.saveCurrentState(readerManager.currentReader?.getCurrentState())
 	}

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

@@ -58,6 +58,7 @@ import org.koitharu.kotatsu.reader.domain.DetectReaderModeUseCase
 import org.koitharu.kotatsu.reader.domain.PageLoader
 import org.koitharu.kotatsu.reader.ui.config.ReaderSettings
 import org.koitharu.kotatsu.reader.ui.pager.ReaderUiState
+import org.koitharu.kotatsu.stats.domain.StatsCollector
 import java.time.Instant
 import javax.inject.Inject
 
@@ -78,11 +79,11 @@ class ReaderViewModel @Inject constructor(
 	private val detailsLoadUseCase: DetailsLoadUseCase,
 	private val historyUpdateUseCase: HistoryUpdateUseCase,
 	private val detectReaderModeUseCase: DetectReaderModeUseCase,
+	private val statsCollector: StatsCollector,
 ) : BaseViewModel() {
 
 	private val intent = MangaIntent(savedStateHandle)
 	private val preselectedBranch = savedStateHandle.get<String>(ReaderActivity.EXTRA_BRANCH)
-	private val isIncognito = savedStateHandle.get<Boolean>(ReaderActivity.EXTRA_INCOGNITO) ?: false
 
 	private var loadingJob: Job? = null
 	private var pageSaveJob: Job? = null
@@ -98,7 +99,7 @@ class ReaderViewModel @Inject constructor(
 	val onShowToast = MutableEventFlow<Int>()
 	val uiState = MutableStateFlow<ReaderUiState?>(null)
 
-	val incognitoMode = if (isIncognito) {
+	val incognitoMode = if (savedStateHandle.get<Boolean>(ReaderActivity.EXTRA_INCOGNITO) == true) {
 		MutableStateFlow(true)
 	} else mangaFlow.map {
 		it != null && historyRepository.shouldSkip(it)
@@ -190,6 +191,12 @@ class ReaderViewModel @Inject constructor(
 		loadImpl()
 	}
 
+	fun onPause() {
+		manga?.let {
+			statsCollector.onPause(it.id)
+		}
+	}
+
 	fun switchMode(newMode: ReaderMode) {
 		launchJob {
 			val manga = checkNotNull(mangaData.value?.toManga())
@@ -208,7 +215,7 @@ class ReaderViewModel @Inject constructor(
 		if (state != null) {
 			currentState.value = state
 		}
-		if (isIncognito) {
+		if (incognitoMode.value) {
 			return
 		}
 		val readerState = state ?: currentState.value ?: return
@@ -377,7 +384,7 @@ class ReaderViewModel @Inject constructor(
 
 			chaptersLoader.loadSingleChapter(requireNotNull(currentState.value).chapterId)
 			// save state
-			if (!isIncognito) {
+			if (!incognitoMode.value) {
 				currentState.value?.let {
 					val percent = computePercent(it.chapterId, it.page)
 					historyUpdateUseCase.invoke(manga, it, percent)
@@ -426,6 +433,9 @@ class ReaderViewModel @Inject constructor(
 			percent = computePercent(state.chapterId, state.page),
 		)
 		uiState.value = newState
+		if (!incognitoMode.value) {
+			statsCollector.onStateChanged(m.id, state)
+		}
 	}
 
 	private fun computePercent(chapterId: Long, pageIndex: Int): Float {

app/src/main/kotlin/org/koitharu/kotatsu/settings/ServicesSettingsFragment.kt

@@ -1,7 +1,6 @@
 package org.koitharu.kotatsu.settings
 
 import android.accounts.AccountManager
-import android.content.ActivityNotFoundException
 import android.content.Intent
 import android.content.SharedPreferences
 import android.net.Uri
@@ -17,6 +16,7 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.ui.BasePreferenceFragment
 import org.koitharu.kotatsu.core.util.ext.getDisplayMessage
+import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import org.koitharu.kotatsu.core.util.ext.viewLifecycleScope
 import org.koitharu.kotatsu.scrobbling.anilist.data.AniListRepository
 import org.koitharu.kotatsu.scrobbling.common.data.ScrobblerRepository
@@ -29,6 +29,8 @@ import org.koitharu.kotatsu.sync.domain.SyncController
 import org.koitharu.kotatsu.sync.ui.SyncSettingsIntent
 import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
 import org.koitharu.kotatsu.scrobbling.kitsu.ui.KitsuAuthActivity
+import org.koitharu.kotatsu.settings.utils.SplitSwitchPreference
+import org.koitharu.kotatsu.stats.ui.StatsActivity
 import javax.inject.Inject
 
 @AndroidEntryPoint
@@ -52,11 +54,18 @@ class ServicesSettingsFragment : BasePreferenceFragment(R.string.services),
 
 	override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
 		addPreferencesFromResource(R.xml.pref_services)
-		bindSuggestionsSummary()
+		findPreference<SplitSwitchPreference>(AppSettings.KEY_STATS_ENABLED)?.let {
+			it.onContainerClickListener = Preference.OnPreferenceClickListener {
+				it.context.startActivity(Intent(it.context, StatsActivity::class.java))
+				true
+			}
+		}
 	}
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
+		bindSuggestionsSummary()
+		bindStatsSummary()
 		settings.subscribe(this)
 	}
 
@@ -77,6 +86,7 @@ class ServicesSettingsFragment : BasePreferenceFragment(R.string.services),
 	override fun onSharedPreferenceChanged(prefs: SharedPreferences?, key: String?) {
 		when (key) {
 			AppSettings.KEY_SUGGESTIONS -> bindSuggestionsSummary()
+			AppSettings.KEY_STATS_ENABLED -> bindStatsSummary()
 		}
 	}
 
@@ -195,4 +205,10 @@ class ServicesSettingsFragment : BasePreferenceFragment(R.string.services),
 			if (settings.isSuggestionsEnabled) R.string.enabled else R.string.disabled,
 		)
 	}
+
+	private fun bindStatsSummary() {
+		findPreference<Preference>(AppSettings.KEY_STATS_ENABLED)?.setSummary(
+			if (settings.isStatsEnabled) R.string.enabled else R.string.disabled,
+		)
+	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/settings/sources/SourceSettingsExt.kt

@@ -8,6 +8,7 @@ import androidx.preference.SwitchPreferenceCompat
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.parsers.config.ConfigKey
+import org.koitharu.kotatsu.parsers.network.UserAgents
 import org.koitharu.kotatsu.settings.utils.AutoCompleteTextViewPreference
 import org.koitharu.kotatsu.settings.utils.EditTextBindListener
 import org.koitharu.kotatsu.settings.utils.EditTextDefaultSummaryProvider
@@ -42,7 +43,13 @@ fun PreferenceFragmentCompat.addPreferencesFromRepository(repository: RemoteMang
 			}
 
 			is ConfigKey.UserAgent -> {
-				EditTextPreference(requireContext()).apply {
+				AutoCompleteTextViewPreference(requireContext()).apply {
+					entries = arrayOf(
+						UserAgents.FIREFOX_MOBILE,
+						UserAgents.CHROME_MOBILE,
+						UserAgents.FIREFOX_DESKTOP,
+						UserAgents.CHROME_DESKTOP,
+					)
 					summaryProvider = EditTextDefaultSummaryProvider(key.defaultValue)
 					setOnBindEditTextListener(
 						EditTextBindListener(
@@ -62,9 +69,18 @@ fun PreferenceFragmentCompat.addPreferencesFromRepository(repository: RemoteMang
 					setTitle(R.string.show_suspicious_content)
 				}
 			}
+
+			is ConfigKey.SplitByTranslations -> {
+				SwitchPreferenceCompat(requireContext()).apply {
+					setDefaultValue(key.defaultValue)
+					setTitle(R.string.split_by_translations)
+					setSummary(R.string.split_by_translations_summary)
+				}
+			}
 		}
 		preference.isIconSpaceReserved = false
 		preference.key = key.key
+		preference.order = 10
 		screen.addPreference(preference)
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/settings/sources/SourceSettingsFragment.kt

@@ -4,6 +4,7 @@ import android.os.Bundle
 import android.view.View
 import androidx.fragment.app.viewModels
 import androidx.preference.Preference
+import androidx.preference.SwitchPreferenceCompat
 import dagger.hilt.android.AndroidEntryPoint
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
@@ -18,7 +19,7 @@ import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.settings.sources.auth.SourceAuthActivity
 
 @AndroidEntryPoint
-class SourceSettingsFragment : BasePreferenceFragment(0) {
+class SourceSettingsFragment : BasePreferenceFragment(0), Preference.OnPreferenceChangeListener {
 
 	private val viewModel: SourceSettingsViewModel by viewModels()
 	private val exceptionResolver = ExceptionResolver(this)
@@ -34,6 +35,9 @@ class SourceSettingsFragment : BasePreferenceFragment(0) {
 		addPreferencesFromResource(R.xml.pref_source)
 		addPreferencesFromRepository(viewModel.repository)
 
+		findPreference<SwitchPreferenceCompat>(KEY_ENABLE)?.run {
+			setOnPreferenceChangeListener(this@SourceSettingsFragment)
+		}
 		findPreference<Preference>(KEY_AUTH)?.run {
 			val authProvider = viewModel.repository.getAuthProvider()
 			isVisible = authProvider != null
@@ -59,6 +63,9 @@ class SourceSettingsFragment : BasePreferenceFragment(0) {
 		viewModel.isLoading.observe(viewLifecycleOwner) { isLoading ->
 			findPreference<Preference>(KEY_AUTH)?.isEnabled = !isLoading
 		}
+		viewModel.isEnabled.observe(viewLifecycleOwner) { enabled ->
+			findPreference<SwitchPreferenceCompat>(KEY_ENABLE)?.isChecked = enabled
+		}
 		viewModel.onActionDone.observeEvent(viewLifecycleOwner, ReversibleActionObserver(listView))
 	}
 
@@ -68,6 +75,7 @@ class SourceSettingsFragment : BasePreferenceFragment(0) {
 				startActivity(SourceAuthActivity.newIntent(preference.context, viewModel.source))
 				true
 			}
+
 			AppSettings.KEY_COOKIES_CLEAR -> {
 				viewModel.clearCookies()
 				true
@@ -77,9 +85,18 @@ class SourceSettingsFragment : BasePreferenceFragment(0) {
 		}
 	}
 
+	override fun onPreferenceChange(preference: Preference, newValue: Any?): Boolean {
+		when (preference.key) {
+			KEY_ENABLE -> viewModel.setEnabled(newValue == true)
+			else -> return false
+		}
+		return true
+	}
+
 	companion object {
 
 		private const val KEY_AUTH = "auth"
+		private const val KEY_ENABLE = "enable"
 
 		const val EXTRA_SOURCE = "source"
 

app/src/main/kotlin/org/koitharu/kotatsu/settings/sources/SourceSettingsViewModel.kt

@@ -1,5 +1,6 @@
 package org.koitharu.kotatsu.settings.sources
 
+import android.content.SharedPreferences
 import androidx.lifecycle.SavedStateHandle
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
@@ -10,11 +11,14 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
+import org.koitharu.kotatsu.core.prefs.SourceSettings
 import org.koitharu.kotatsu.core.ui.BaseViewModel
 import org.koitharu.kotatsu.core.ui.util.ReversibleAction
 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.explore.data.MangaSourcesRepository
+import org.koitharu.kotatsu.parsers.config.ConfigKey
 import org.koitharu.kotatsu.parsers.exception.AuthRequiredException
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import javax.inject.Inject
@@ -24,19 +28,33 @@ class SourceSettingsViewModel @Inject constructor(
 	savedStateHandle: SavedStateHandle,
 	mangaRepositoryFactory: MangaRepository.Factory,
 	private val cookieJar: MutableCookieJar,
-) : BaseViewModel() {
+	private val mangaSourcesRepository: MangaSourcesRepository,
+) : BaseViewModel(), SharedPreferences.OnSharedPreferenceChangeListener {
 
 	val source = savedStateHandle.require<MangaSource>(SourceSettingsFragment.EXTRA_SOURCE)
 	val repository = mangaRepositoryFactory.create(source) as RemoteMangaRepository
 
 	val onActionDone = MutableEventFlow<ReversibleAction>()
 	val username = MutableStateFlow<String?>(null)
+	val isEnabled = mangaSourcesRepository.observeIsEnabled(source)
 	private var usernameLoadJob: Job? = null
 
 	init {
+		repository.getConfig().subscribe(this)
 		loadUsername()
 	}
 
+	override fun onCleared() {
+		repository.getConfig().unsubscribe(this)
+		super.onCleared()
+	}
+
+	override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences?, key: String?) {
+		if (key != SourceSettings.KEY_SLOWDOWN && key != SourceSettings.KEY_SORT_ORDER) {
+			repository.invalidateCache()
+		}
+	}
+
 	fun onResume() {
 		if (usernameLoadJob?.isActive != true) {
 			loadUsername()
@@ -55,6 +73,12 @@ class SourceSettingsViewModel @Inject constructor(
 		}
 	}
 
+	fun setEnabled(value: Boolean) {
+		launchJob(Dispatchers.Default) {
+			mangaSourcesRepository.setSourceEnabled(source, value)
+		}
+	}
+
 	private fun loadUsername() {
 		launchLoadingJob(Dispatchers.Default) {
 			try {

app/src/main/kotlin/org/koitharu/kotatsu/settings/sources/auth/SourceAuthActivity.kt

@@ -18,15 +18,16 @@ import org.koitharu.kotatsu.browser.BrowserCallback
 import org.koitharu.kotatsu.browser.BrowserClient
 import org.koitharu.kotatsu.browser.ProgressChromeClient
 import org.koitharu.kotatsu.browser.WebViewBackPressedCallback
+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.TaggedActivityResult
+import org.koitharu.kotatsu.core.util.ext.configureForParser
 import org.koitharu.kotatsu.core.util.ext.getSerializableExtraCompat
 import org.koitharu.kotatsu.databinding.ActivityBrowserBinding
 import org.koitharu.kotatsu.parsers.MangaParserAuthProvider
 import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.network.UserAgents
 import javax.inject.Inject
 import com.google.android.material.R as materialR
 
@@ -64,12 +65,7 @@ class SourceAuthActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallba
 			setDisplayHomeAsUpEnabled(true)
 			setHomeAsUpIndicator(materialR.drawable.abc_ic_clear_material)
 		}
-		with(viewBinding.webView.settings) {
-			javaScriptEnabled = true
-			domStorageEnabled = true
-			databaseEnabled = true
-			userAgentString = UserAgents.CHROME_MOBILE
-		}
+		viewBinding.webView.configureForParser(repository.headers[CommonHeaders.USER_AGENT])
 		CookieManager.getInstance().setAcceptThirdPartyCookies(viewBinding.webView, true)
 		viewBinding.webView.webViewClient = BrowserClient(this)
 		viewBinding.webView.webChromeClient = ProgressChromeClient(viewBinding.progressBar)

app/src/main/kotlin/org/koitharu/kotatsu/settings/sources/catalog/SourcesCatalogAdapter.kt

@@ -15,7 +15,7 @@ class SourcesCatalogAdapter(
 ) : BaseListAdapter<SourceCatalogItem>(), FastScroller.SectionIndexer {
 
 	init {
-		addDelegate(ListItemType.CHAPTER, sourceCatalogItemSourceAD(coil, lifecycleOwner, listener))
+		addDelegate(ListItemType.CHAPTER_LIST, sourceCatalogItemSourceAD(coil, lifecycleOwner, listener))
 		addDelegate(ListItemType.HINT_EMPTY, sourceCatalogItemHintAD(coil, lifecycleOwner))
 	}
 

app/src/main/kotlin/org/koitharu/kotatsu/settings/userdata/StorageUsagePreference.kt

@@ -3,20 +3,15 @@ package org.koitharu.kotatsu.settings.userdata
 import android.content.Context
 import android.content.res.ColorStateList
 import android.util.AttributeSet
-import androidx.annotation.AttrRes
-import androidx.annotation.ColorInt
 import androidx.annotation.StringRes
-import androidx.core.graphics.ColorUtils
 import androidx.core.widget.TextViewCompat
 import androidx.preference.Preference
 import androidx.preference.PreferenceViewHolder
-import com.google.android.material.color.MaterialColors
 import kotlinx.coroutines.flow.FlowCollector
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.ui.widgets.SegmentedBarView
-import org.koitharu.kotatsu.core.util.Colors
+import org.koitharu.kotatsu.core.util.KotatsuColors
 import org.koitharu.kotatsu.core.util.FileSize
-import org.koitharu.kotatsu.core.util.ext.getThemeColor
 import org.koitharu.kotatsu.databinding.PreferenceMemoryUsageBinding
 import com.google.android.material.R as materialR
 
@@ -39,15 +34,15 @@ class StorageUsagePreference @JvmOverloads constructor(
 		val binding = PreferenceMemoryUsageBinding.bind(holder.itemView)
 		val storageSegment = SegmentedBarView.Segment(
 			usage?.savedManga?.percent ?: 0f,
-			Colors.segmentColor(context, materialR.attr.colorPrimary),
+			KotatsuColors.segmentColor(context, materialR.attr.colorPrimary),
 		)
 		val pagesSegment = SegmentedBarView.Segment(
 			usage?.pagesCache?.percent ?: 0f,
-			Colors.segmentColor(context, materialR.attr.colorSecondary),
+			KotatsuColors.segmentColor(context, materialR.attr.colorSecondary),
 		)
 		val otherSegment = SegmentedBarView.Segment(
 			usage?.otherCache?.percent ?: 0f,
-			Colors.segmentColor(context, materialR.attr.colorTertiary),
+			KotatsuColors.segmentColor(context, materialR.attr.colorTertiary),
 		)
 
 		with(binding) {

app/src/main/kotlin/org/koitharu/kotatsu/settings/userdata/UserDataSettingsFragment.kt

@@ -94,6 +94,7 @@ class UserDataSettingsFragment : BasePreferenceFragment(R.string.data_and_privac
 		}
 		viewModel.onError.observeEvent(viewLifecycleOwner, SnackbarErrorObserver(listView, this))
 		viewModel.onActionDone.observeEvent(viewLifecycleOwner, ReversibleActionObserver(listView))
+		viewModel.onChaptersCleanedUp.observeEvent(viewLifecycleOwner, ::onChaptersCleanedUp)
 		settings.subscribe(this)
 	}
 
@@ -129,6 +130,11 @@ class UserDataSettingsFragment : BasePreferenceFragment(R.string.data_and_privac
 				true
 			}
 
+			AppSettings.KEY_CHAPTERS_CLEAR -> {
+				cleanupChapters()
+				true
+			}
+
 			AppSettings.KEY_UPDATES_FEED_CLEAR -> {
 				viewModel.clearUpdatesFeed()
 				true
@@ -191,6 +197,21 @@ class UserDataSettingsFragment : BasePreferenceFragment(R.string.data_and_privac
 		}
 	}
 
+	private fun onChaptersCleanedUp(result: Pair<Int, Long>) {
+		val c = context ?: return
+		val text = if (result.first == 0 && result.second == 0L) {
+			c.getString(R.string.no_chapters_deleted)
+		} else {
+			c.getString(
+				R.string.chapters_deleted_pattern,
+				c.resources.getQuantityString(R.plurals.chapters, result.first, result.first),
+				FileSize.BYTES.format(c, result.second),
+			)
+		}
+		Snackbar.make(listView, text, Snackbar.LENGTH_SHORT).show()
+	}
+
+
 	private fun Preference.bindBytesSizeSummary(stateFlow: StateFlow<Long>) {
 		stateFlow.observe(viewLifecycleOwner) { size ->
 			summary = if (size < 0) {
@@ -235,6 +256,16 @@ class UserDataSettingsFragment : BasePreferenceFragment(R.string.data_and_privac
 			}.show()
 	}
 
+	private fun cleanupChapters() {
+		MaterialAlertDialogBuilder(context ?: return)
+			.setTitle(R.string.delete_read_chapters)
+			.setMessage(R.string.delete_read_chapters_prompt)
+			.setNegativeButton(android.R.string.cancel, null)
+			.setPositiveButton(R.string.delete) { _, _ ->
+				viewModel.cleanupChapters()
+			}.show()
+	}
+
 	private fun postRestart() {
 		view?.postDelayed(400) {
 			activityRecreationHandle.recreateAll()

app/src/main/kotlin/org/koitharu/kotatsu/settings/userdata/UserDataSettingsViewModel.kt

@@ -18,8 +18,10 @@ import org.koitharu.kotatsu.core.ui.BaseViewModel
 import org.koitharu.kotatsu.core.ui.util.ReversibleAction
 import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
 import org.koitharu.kotatsu.core.util.ext.call
+import org.koitharu.kotatsu.core.util.ext.firstNotNull
 import org.koitharu.kotatsu.local.data.CacheDir
 import org.koitharu.kotatsu.local.data.LocalStorageManager
+import org.koitharu.kotatsu.local.domain.DeleteReadChaptersUseCase
 import org.koitharu.kotatsu.search.domain.MangaSearchRepository
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import java.util.EnumMap
@@ -33,6 +35,7 @@ class UserDataSettingsViewModel @Inject constructor(
 	private val trackingRepository: TrackingRepository,
 	private val cookieJar: MutableCookieJar,
 	private val settings: AppSettings,
+	private val deleteReadChaptersUseCase: DeleteReadChaptersUseCase,
 ) : BaseViewModel() {
 
 	val onActionDone = MutableEventFlow<ReversibleAction>()
@@ -44,6 +47,8 @@ class UserDataSettingsViewModel @Inject constructor(
 	val cacheSizes = EnumMap<CacheDir, MutableStateFlow<Long>>(CacheDir::class.java)
 	val storageUsage = MutableStateFlow<StorageUsage?>(null)
 
+	val onChaptersCleanedUp = MutableEventFlow<Pair<Int, Long>>()
+
 	val periodicalBackupFrequency = settings.observeAsFlow(
 		key = AppSettings.KEY_BACKUP_PERIODICAL_ENABLED,
 		valueProducer = { isPeriodicalBackupEnabled },
@@ -133,9 +138,24 @@ class UserDataSettingsViewModel @Inject constructor(
 		}
 	}
 
-	private fun loadStorageUsage() {
+	fun cleanupChapters() {
+		launchJob(Dispatchers.Default) {
+			try {
+				loadingKeys.update { it + AppSettings.KEY_CHAPTERS_CLEAR }
+				val oldSize = storageUsage.firstNotNull().savedManga.bytes
+				val chaptersCount = deleteReadChaptersUseCase.invoke()
+				loadStorageUsage().join()
+				val newSize = storageUsage.firstNotNull().savedManga.bytes
+				onChaptersCleanedUp.call(chaptersCount to oldSize - newSize)
+			} finally {
+				loadingKeys.update { it - AppSettings.KEY_CHAPTERS_CLEAR }
+			}
+		}
+	}
+
+	private fun loadStorageUsage(): Job {
 		val prevJob = storageUsageJob
-		storageUsageJob = launchJob(Dispatchers.Default) {
+		return launchJob(Dispatchers.Default) {
 			prevJob?.cancelAndJoin()
 			val pagesCacheSize = storageManager.computeCacheSize(CacheDir.PAGES)
 			val otherCacheSize = storageManager.computeCacheSize() - pagesCacheSize
@@ -160,6 +180,8 @@ class UserDataSettingsViewModel @Inject constructor(
 					percent = (availableSpace.toDouble() / totalBytes).toFloat(),
 				),
 			)
+		}.also {
+			storageUsageJob = it
 		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/settings/utils/SplitSwitchPreference.kt

@@ -0,0 +1,32 @@
+package org.koitharu.kotatsu.settings.utils
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.View
+import androidx.preference.PreferenceViewHolder
+import androidx.preference.SwitchPreferenceCompat
+import org.koitharu.kotatsu.R
+
+class SplitSwitchPreference @JvmOverloads constructor(
+	context: Context,
+	attrs: AttributeSet? = null,
+	defStyleAttr: Int = androidx.preference.R.attr.switchPreferenceCompatStyle,
+	defStyleRes: Int = 0
+) : SwitchPreferenceCompat(context, attrs, defStyleAttr, defStyleRes) {
+
+	init {
+		layoutResource = R.layout.preference_split_switch
+	}
+
+	var onContainerClickListener: OnPreferenceClickListener? = null
+
+	private val containerClickListener = View.OnClickListener { v ->
+		onContainerClickListener?.onPreferenceClick(this)
+	}
+
+	override fun onBindViewHolder(holder: PreferenceViewHolder) {
+		super.onBindViewHolder(holder)
+		holder.findViewById(R.id.press_container)?.setOnClickListener(containerClickListener)
+	}
+
+}

app/src/main/kotlin/org/koitharu/kotatsu/stats/data/StatsDao.kt

@@ -0,0 +1,72 @@
+package org.koitharu.kotatsu.stats.data
+
+import android.database.sqlite.SQLiteQueryBuilder
+import androidx.room.Dao
+import androidx.room.MapColumn
+import androidx.room.Query
+import androidx.room.RawQuery
+import androidx.room.Transaction
+import androidx.room.Upsert
+import androidx.sqlite.db.SimpleSQLiteQuery
+import androidx.sqlite.db.SupportSQLiteQuery
+import kotlinx.coroutines.flow.Flow
+import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.history.data.HistoryEntity
+import org.koitharu.kotatsu.history.data.HistoryWithManga
+
+@Dao
+abstract class StatsDao {
+
+	@Query("SELECT * FROM stats ORDER BY started_at")
+	abstract suspend fun findAll(): List<StatsEntity>
+
+	@Query("SELECT * FROM stats WHERE manga_id = :mangaId ORDER BY started_at")
+	abstract suspend fun findAll(mangaId: Long): List<StatsEntity>
+
+	@Query("SELECT IFNULL(SUM(pages),0) FROM stats WHERE manga_id = :mangaId")
+	abstract suspend fun getReadPagesCount(mangaId: Long): Int
+
+	@Query("SELECT IFNULL(SUM(duration)/SUM(pages), 0) FROM stats WHERE manga_id = :mangaId")
+	abstract suspend fun getAverageTimePerPage(mangaId: Long): Long
+
+	@Query("SELECT IFNULL(SUM(duration)/SUM(pages), 0) FROM stats")
+	abstract suspend fun getAverageTimePerPage(): Long
+
+	@Query("SELECT IFNULL(SUM(duration), 0) FROM stats WHERE manga_id = :mangaId")
+	abstract suspend fun getReadingTime(mangaId: Long): Long
+
+	@Query("SELECT IFNULL(SUM(duration), 0) FROM stats")
+	abstract suspend fun getTotalReadingTime(): Long
+
+	@Query("DELETE FROM stats")
+	abstract suspend fun clear()
+
+	@Query("SELECT COUNT(*) FROM stats WHERE manga_id = :mangaId")
+	abstract fun observeRowCount(mangaId: Long): Flow<Int>
+
+	@Upsert
+	abstract suspend fun upsert(entity: StatsEntity)
+
+	suspend fun getDurationStats(fromDate: Long, isNsfw: Boolean?, favouriteCategories: Set<Long>): Map<MangaEntity, Long> {
+		val conditions = ArrayList<String>()
+		conditions.add("stats.started_at >= $fromDate")
+		if (favouriteCategories.isNotEmpty()) {
+			val ids = favouriteCategories.joinToString(",")
+			conditions.add("stats.manga_id IN (SELECT manga_id FROM favourites WHERE category_id IN ($ids))")
+		}
+		if (isNsfw != null) {
+			val flag = if (isNsfw) 1 else 0
+			conditions.add("manga.nsfw = $flag")
+		}
+		val where = conditions.joinToString(separator = " AND ")
+		val query = SimpleSQLiteQuery(
+			"SELECT manga.*, SUM(duration) AS d FROM stats LEFT JOIN manga ON manga.manga_id = stats.manga_id WHERE $where GROUP BY manga.manga_id ORDER BY d DESC",
+		)
+		return getDurationStatsImpl(query)
+	}
+
+	@RawQuery
+	protected abstract fun getDurationStatsImpl(
+		query: SupportSQLiteQuery
+	): Map<@MapColumn("manga") MangaEntity, @MapColumn("d") Long>
+}

app/src/main/kotlin/org/koitharu/kotatsu/stats/data/StatsEntity.kt

@@ -0,0 +1,26 @@
+package org.koitharu.kotatsu.stats.data
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.history.data.HistoryEntity
+
+@Entity(
+	tableName = "stats",
+	primaryKeys = ["manga_id", "started_at"],
+	foreignKeys = [
+		ForeignKey(
+			entity = HistoryEntity::class,
+			parentColumns = ["manga_id"],
+			childColumns = ["manga_id"],
+			onDelete = ForeignKey.CASCADE,
+		),
+	],
+)
+data class StatsEntity(
+	@ColumnInfo(name = "manga_id") val mangaId: Long,
+	@ColumnInfo(name = "started_at") val startedAt: Long,
+	@ColumnInfo(name = "duration") val duration: Long,
+	@ColumnInfo(name = "pages") val pages: Int,
+)

app/src/main/kotlin/org/koitharu/kotatsu/stats/data/StatsRepository.kt

@@ -0,0 +1,94 @@
+package org.koitharu.kotatsu.stats.data
+
+import androidx.collection.LongIntMap
+import androidx.collection.MutableLongIntMap
+import androidx.room.withTransaction
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.db.entity.toManga
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.prefs.observeAsFlow
+import org.koitharu.kotatsu.core.util.ext.combine
+import org.koitharu.kotatsu.stats.domain.StatsPeriod
+import org.koitharu.kotatsu.stats.domain.StatsRecord
+import java.util.NavigableMap
+import java.util.TreeMap
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+
+class StatsRepository @Inject constructor(
+	private val settings: AppSettings,
+	private val db: MangaDatabase,
+) {
+
+	suspend fun getReadingStats(period: StatsPeriod, categories: Set<Long>): List<StatsRecord> {
+		val fromDate = if (period == StatsPeriod.ALL) {
+			0L
+		} else {
+			System.currentTimeMillis() - TimeUnit.DAYS.toMillis(period.days.toLong())
+		}
+		val stats = db.getStatsDao().getDurationStats(fromDate, null, categories)
+		val result = ArrayList<StatsRecord>(stats.size)
+		var other = StatsRecord(null, 0)
+		val total = stats.values.sum()
+		for ((mangaEntity, duration) in stats) {
+			val manga = mangaEntity.toManga(emptySet())
+			val percent = duration.toDouble() / total
+			if (percent < 0.05) {
+				other = other.copy(duration = other.duration + duration)
+			} else {
+				result += StatsRecord(
+					manga = manga,
+					duration = duration,
+				)
+			}
+		}
+		if (other.duration != 0L) {
+			result += other
+		}
+		return result
+	}
+
+	suspend fun getTimePerPage(mangaId: Long): Long = db.withTransaction {
+		val dao = db.getStatsDao()
+		val pages = dao.getReadPagesCount(mangaId)
+		val time = if (pages >= 10) {
+			dao.getAverageTimePerPage(mangaId)
+		} else {
+			dao.getAverageTimePerPage()
+		}
+		time
+	}
+
+	suspend fun getTotalPagesRead(mangaId: Long): Int {
+		return db.getStatsDao().getReadPagesCount(mangaId)
+	}
+
+	suspend fun getMangaTimeline(mangaId: Long): NavigableMap<Long, Int> {
+		val entities = db.getStatsDao().findAll(mangaId)
+		val map = TreeMap<Long, Int>()
+		for (e in entities) {
+			map[e.startedAt] = e.pages
+		}
+		return map
+	}
+
+	suspend fun clearStats() {
+		db.getStatsDao().clear()
+	}
+
+	fun observeHasStats(mangaId: Long): Flow<Boolean> = settings.observeAsFlow(AppSettings.KEY_STATS_ENABLED) {
+		isStatsEnabled
+	}.flatMapLatest { isEnabled ->
+		if (isEnabled) {
+			db.getStatsDao().observeRowCount(mangaId).map { it > 0 }
+		} else {
+			flowOf(false)
+		}
+	}.distinctUntilChanged()
+}