Fix NPE during PagesCache initialization

Currently translated at 100.0% (405 of 405 strings)

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

.github/FUNDING.yml

@@ -1 +1,2 @@
+ko_fi: xtimms
 custom: ["https://yoomoney.ru/to/410012543938752"]

.gitignore

@@ -7,6 +7,7 @@
 /.idea/modules.xml
 /.idea/misc.xml
 /.idea/discord.xml
+/.idea/compiler.xml
 /.idea/workspace.xml
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml

.idea/compiler.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="11" />
-  </component>
-</project>

.idea/gradle.xml

@@ -7,7 +7,7 @@
         <option name="testRunner" value="GRADLE" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="Embedded JDK" />
+        <option name="gradleJvm" value="jbr-17" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />

.idea/kotlinc.xml

@@ -3,4 +3,7 @@
   <component name="Kotlin2JvmCompilerArguments">
     <option name="jvmTarget" value="1.8" />
   </component>
+  <component name="KotlinJpsPluginSettings">
+    <option name="version" value="1.8.0" />
+  </component>
 </project>

.idea/ktlint.xml

@@ -1,7 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="KtlintProjectConfiguration">
+    <enableKtlint>false</enableKtlint>
     <androidMode>true</androidMode>
     <treatAsErrors>false</treatAsErrors>
+    <disabledRules>
+      <list>
+        <option value="no-empty-first-line-in-method-block" />
+      </list>
+    </disabledRules>
   </component>
 </project>

README.md

@@ -26,7 +26,7 @@ Download APK directly from GitHub:
 * Notifications about new chapters with updates feed
 * Shikimori integration (manga tracking)
 * Password/fingerprint protect access to the app
-* History and favourites synchronization across devices (coming soon)
+* History and favourites [synchronization](https://github.com/KotatsuApp/kotatsu-syncserver) across devices
 
 ### Screenshots
 

app/build.gradle

@@ -7,16 +7,16 @@ plugins {
 }
 
 android {
-	compileSdkVersion 33
-	buildToolsVersion '33.0.0'
-	namespace 'org.koitharu.kotatsu'
+	compileSdk = 33
+	buildToolsVersion = '33.0.1'
+	namespace = 'org.koitharu.kotatsu'
 
 	defaultConfig {
 		applicationId 'org.koitharu.kotatsu'
 		minSdkVersion 21
 		targetSdkVersion 33
-		versionCode 496
-		versionName '4.0-a7'
+		versionCode 511
+		versionName '4.3'
 		generatedDensities = []
 		testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
@@ -56,10 +56,12 @@ android {
 	kotlinOptions {
 		jvmTarget = JavaVersion.VERSION_1_8.toString()
 		freeCompilerArgs += [
+			'-opt-in=kotlin.ExperimentalStdlibApi',
 			'-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi',
 			'-opt-in=kotlinx.coroutines.FlowPreview',
 			'-opt-in=kotlin.contracts.ExperimentalContracts',
 			'-opt-in=coil.annotation.ExperimentalCoilApi',
+			'-opt-in=com.google.android.material.badge.ExperimentalBadgeUtils',
 		]
 	}
 	lint {
@@ -82,15 +84,17 @@ afterEvaluate {
 	}
 }
 dependencies {
-	implementation('com.github.KotatsuApp:kotatsu-parsers:b3a9c5fcda') {
+	implementation('com.github.KotatsuApp:kotatsu-parsers:cf00732023') {
 		exclude group: 'org.json', module: 'json'
 	}
 
+	implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.8.0'
 	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
 
-	implementation 'androidx.core:core-ktx:1.8.0'
-	implementation 'androidx.activity:activity-ktx:1.5.1'
-	implementation 'androidx.fragment:fragment-ktx:1.5.2'
+	implementation "androidx.appcompat:appcompat:1.6.0"
+	implementation 'androidx.core:core-ktx:1.9.0'
+	implementation 'androidx.activity:activity-ktx:1.6.1'
+	implementation 'androidx.fragment:fragment-ktx:1.5.5'
 	implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1'
 	implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.5.1'
 	implementation 'androidx.lifecycle:lifecycle-service:2.5.1'
@@ -101,51 +105,52 @@ dependencies {
 	implementation 'androidx.viewpager2:viewpager2:1.1.0-beta01'
 	implementation 'androidx.preference:preference-ktx:1.2.0'
 	implementation 'androidx.work:work-runtime-ktx:2.7.1'
-	implementation 'androidx.biometric:biometric-ktx:1.2.0-alpha04'
-	implementation 'com.google.android.material:material:1.7.0-rc01'
+	implementation 'androidx.biometric:biometric-ktx:1.2.0-alpha05'
+	implementation 'com.google.android.material:material:1.8.0-rc01'
 	//noinspection LifecycleAnnotationProcessorWithJava8
 	kapt 'androidx.lifecycle:lifecycle-compiler:2.5.1'
 
-	implementation 'androidx.room:room-runtime:2.4.3'
-	implementation 'androidx.room:room-ktx:2.4.3'
-	kapt 'androidx.room:room-compiler:2.4.3'
+	implementation 'androidx.room:room-runtime:2.5.0'
+	implementation 'androidx.room:room-ktx:2.5.0'
+	kapt 'androidx.room:room-compiler:2.5.0'
 
 	implementation 'com.squareup.okhttp3:okhttp:4.10.0'
 	implementation 'com.squareup.okhttp3:okhttp-dnsoverhttps:4.9.3'
-	implementation 'com.squareup.okio:okio:3.2.0'
+	implementation 'com.squareup.okio:okio:3.3.0'
 
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl:4.3.2'
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl-viewbinding:4.3.2'
 
-	implementation "com.google.dagger:hilt-android:2.43.2"
-	kapt "com.google.dagger:hilt-compiler:2.43.2"
+	implementation 'com.google.dagger:hilt-android:2.44.2'
+	kapt 'com.google.dagger:hilt-compiler:2.44.2'
 	implementation 'androidx.hilt:hilt-work:1.0.0'
 	kapt 'androidx.hilt:hilt-compiler:1.0.0'
 
-	implementation 'io.coil-kt:coil-base:2.2.1'
-	implementation 'io.coil-kt:coil-svg:2.2.1'
-	implementation 'com.github.KotatsuApp:subsampling-scale-image-view:fc92ecb766'
+	implementation 'io.coil-kt:coil-base:2.2.2'
+	implementation 'io.coil-kt:coil-svg:2.2.2'
+	implementation 'com.github.KotatsuApp:subsampling-scale-image-view:1b19231b2f'
 	implementation 'com.github.solkin:disk-lru-cache:1.4'
+	implementation 'io.noties.markwon:core:4.6.2'
 
-	implementation 'ch.acra:acra-http:5.9.6'
-	implementation 'ch.acra:acra-dialog:5.9.6'
+	implementation 'ch.acra:acra-http:5.9.7'
+	implementation 'ch.acra:acra-dialog:5.9.7'
 
-	debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.9.1'
+	debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.10'
 
 	testImplementation 'junit:junit:4.13.2'
-	testImplementation 'org.json:json:20220320'
+	testImplementation 'org.json:json:20220924'
 	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
 
-	androidTestImplementation 'androidx.test:runner:1.4.0'
-	androidTestImplementation 'androidx.test:rules:1.4.0'
-	androidTestImplementation 'androidx.test:core-ktx:1.4.0'
-	androidTestImplementation 'androidx.test.ext:junit-ktx:1.1.3'
+	androidTestImplementation 'androidx.test:runner:1.5.2'
+	androidTestImplementation 'androidx.test:rules:1.5.0'
+	androidTestImplementation 'androidx.test:core-ktx:1.5.0'
+	androidTestImplementation 'androidx.test.ext:junit-ktx:1.1.5'
 
 	androidTestImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
 
-	androidTestImplementation 'androidx.room:room-testing:2.4.3'
+	androidTestImplementation 'androidx.room:room-testing:2.5.0'
 	androidTestImplementation 'com.squareup.moshi:moshi-kotlin:1.14.0'
 
-	androidTestImplementation 'com.google.dagger:hilt-android-testing:2.43.2'
-	kaptAndroidTest 'com.google.dagger:hilt-android-compiler:2.43.2'
+	androidTestImplementation 'com.google.dagger:hilt-android-testing:2.44.2'
+	kaptAndroidTest 'com.google.dagger:hilt-android-compiler:2.44.2'
 }

app/proguard-rules.pro

@@ -14,3 +14,4 @@
 
 -keep class org.koitharu.kotatsu.core.exceptions.* { *; }
 -keep class org.koitharu.kotatsu.settings.NotificationSettingsLegacyFragment
+-keep class org.koitharu.kotatsu.core.prefs.ScreenshotsPolicy { *; }

app/src/main/AndroidManifest.xml

@@ -28,6 +28,8 @@
 		android:fullBackupOnly="true"
 		android:icon="@mipmap/ic_launcher"
 		android:label="@string/app_name"
+		android:largeHeap="true"
+		android:localeConfig="@xml/locales"
 		android:networkSecurityConfig="@xml/network_security_config"
 		android:roundIcon="@mipmap/ic_launcher_round"
 		android:supportsRtl="true"
@@ -68,6 +70,9 @@
 		<activity
 			android:name="org.koitharu.kotatsu.history.ui.HistoryActivity"
 			android:label="@string/history" />
+		<activity
+			android:name="org.koitharu.kotatsu.tracker.ui.updates.UpdatesActivity"
+			android:label="@string/updates" />
 		<activity
 			android:name="org.koitharu.kotatsu.favourites.ui.FavouritesActivity"
 			android:label="@string/favourites" />
@@ -105,8 +110,7 @@
 		<activity
 			android:name="org.koitharu.kotatsu.widget.shelf.ShelfConfigActivity"
 			android:exported="true"
-			android:label="@string/manga_shelf"
-			android:theme="@style/Theme.Kotatsu.DialogWhenLarge">
+			android:label="@string/manga_shelf">
 			<intent-filter>
 				<action android:name="android.appwidget.action.APPWIDGET_CONFIGURE" />
 			</intent-filter>
@@ -124,18 +128,18 @@
 		<activity
 			android:name="org.koitharu.kotatsu.download.ui.DownloadsActivity"
 			android:label="@string/downloads"
-			android:launchMode="singleTop"
-			android:theme="@style/Theme.Kotatsu.DialogWhenLarge" />
+			android:launchMode="singleTop" />
 		<activity android:name="org.koitharu.kotatsu.image.ui.ImageActivity" />
-		<activity
-			android:name="org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity"
-			android:theme="@style/Theme.Kotatsu.DialogWhenLarge" />
+		<activity android:name="org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity" />
 		<activity
 			android:name="org.koitharu.kotatsu.sync.ui.SyncAuthActivity"
 			android:label="@string/sync" />
 		<activity
 			android:name="org.koitharu.kotatsu.reader.ui.colorfilter.ColorFilterConfigActivity"
 			android:label="@string/color_correction" />
+		<activity
+			android:name="org.koitharu.kotatsu.shelf.ui.config.ShelfSettingsActivity"
+			android:label="@string/settings" />
 
 		<service
 			android:name="org.koitharu.kotatsu.download.ui.service.DownloadService"
@@ -184,6 +188,9 @@
 				android:name="android.content.SyncAdapter"
 				android:resource="@xml/sync_history" />
 		</service>
+		<service
+			android:name="org.koitharu.kotatsu.details.service.MangaPrefetchService"
+			android:exported="false" />
 
 		<provider
 			android:name="org.koitharu.kotatsu.search.ui.MangaSuggestionsProvider"
@@ -244,6 +251,9 @@
 		<meta-data
 			android:name="android.webkit.WebView.MetricsOptOut"
 			android:value="true" />
+		<meta-data
+			android:name="com.samsung.android.icon_container.has_icon_container"
+			android:value="@bool/com_samsung_android_icon_container_has_icon_container" />
 
 	</application>
 

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

@@ -10,7 +10,6 @@ import androidx.hilt.work.HiltWorkerFactory
 import androidx.room.InvalidationTracker
 import androidx.work.Configuration
 import dagger.hilt.android.HiltAndroidApp
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import org.acra.ReportField
@@ -25,6 +24,7 @@ import org.koitharu.kotatsu.local.data.PagesCache
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.utils.ext.processLifecycleScope
+import javax.inject.Inject
 
 @HiltAndroidApp
 class KotatsuApp : Application(), Configuration.Provider {
@@ -50,6 +50,7 @@ class KotatsuApp : Application(), Configuration.Provider {
 			enableStrictMode()
 		}
 		AppCompatDelegate.setDefaultNightMode(settings.theme)
+		AppCompatDelegate.setApplicationLocales(settings.appLocales)
 		setupActivityLifecycleCallbacks()
 		processLifecycleScope.launch(Dispatchers.Default) {
 			setupDatabaseObservers()
@@ -72,6 +73,7 @@ class KotatsuApp : Application(), Configuration.Provider {
 			}
 			reportContent = listOf(
 				ReportField.PACKAGE_NAME,
+				ReportField.INSTALLATION_ID,
 				ReportField.APP_VERSION_CODE,
 				ReportField.APP_VERSION_NAME,
 				ReportField.ANDROID_VERSION,

app/src/main/java/org/koitharu/kotatsu/base/domain/ReversibleHandle.kt

@@ -1,9 +1,12 @@
 package org.koitharu.kotatsu.base.domain
 
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.processLifecycleScope
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
 fun interface ReversibleHandle {
 
@@ -11,8 +14,10 @@ fun interface ReversibleHandle {
 }
 
 fun ReversibleHandle.reverseAsync() = processLifecycleScope.launch(Dispatchers.Default) {
-	runCatching {
-		reverse()
+	runCatchingCancellable {
+		withContext(NonCancellable) {
+			reverse()
+		}
 	}.onFailure {
 		it.printStackTraceDebug()
 	}
@@ -21,4 +26,4 @@ fun ReversibleHandle.reverseAsync() = processLifecycleScope.launch(Dispatchers.D
 operator fun ReversibleHandle.plus(other: ReversibleHandle) = ReversibleHandle {
 	this.reverse()
 	other.reverse()
-}
+}

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

@@ -20,7 +20,6 @@ import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updateLayoutParams
 import androidx.viewbinding.ViewBinding
 import dagger.hilt.android.EntryPointAccessors
-import javax.inject.Inject
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.util.ActionModeDelegate
@@ -30,6 +29,7 @@ import org.koitharu.kotatsu.base.ui.util.inject
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.utils.ext.getThemeColor
+import javax.inject.Inject
 
 abstract class BaseActivity<B : ViewBinding> :
 	AppCompatActivity(),
@@ -53,7 +53,6 @@ abstract class BaseActivity<B : ViewBinding> :
 		EntryPointAccessors.fromApplication(this, BaseActivityEntryPoint::class.java).inject(this)
 		val isAmoled = settings.isAmoledTheme
 		val isDynamic = settings.isDynamicTheme
-		// TODO support DialogWhenLarge theme
 		when {
 			isAmoled && isDynamic -> setTheme(R.style.Theme_Kotatsu_Monet_Amoled)
 			isAmoled -> setTheme(R.style.Theme_Kotatsu_Amoled)
@@ -134,6 +133,7 @@ abstract class BaseActivity<B : ViewBinding> :
 		window.statusBarColor = getThemeColor(android.R.attr.statusBarColor)
 	}
 
+	@Suppress("OVERRIDE_DEPRECATION", "DEPRECATION")
 	override fun onBackPressed() {
 		if ( // https://issuetracker.google.com/issues/139738913
 			Build.VERSION.SDK_INT == Build.VERSION_CODES.Q &&

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

@@ -4,11 +4,13 @@ import android.app.Service
 import android.content.Intent
 import androidx.lifecycle.lifecycleScope
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 
 abstract class CoroutineIntentService : BaseService() {
 
@@ -21,17 +23,29 @@ abstract class CoroutineIntentService : BaseService() {
 		return Service.START_REDELIVER_INTENT
 	}
 
-	private fun launchCoroutine(intent: Intent?, startId: Int) = lifecycleScope.launch {
+	private fun launchCoroutine(intent: Intent?, startId: Int) = lifecycleScope.launch(errorHandler(startId)) {
 		mutex.withLock {
 			try {
-				withContext(dispatcher) {
-					processIntent(intent)
+				if (intent != null) {
+					withContext(dispatcher) {
+						processIntent(startId, intent)
+					}
 				}
+			} catch (e: Throwable) {
+				e.printStackTraceDebug()
+				onError(startId, e)
 			} finally {
 				stopSelf(startId)
 			}
 		}
 	}
 
-	protected abstract suspend fun processIntent(intent: Intent?)
+	protected abstract suspend fun processIntent(startId: Int, intent: Intent)
+
+	protected abstract fun onError(startId: Int, error: Throwable)
+
+	private fun errorHandler(startId: Int) = CoroutineExceptionHandler { _, throwable ->
+		throwable.printStackTraceDebug()
+		onError(startId, throwable)
+	}
 }

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

@@ -0,0 +1,22 @@
+package org.koitharu.kotatsu.base.ui
+
+import android.app.Activity
+import android.app.Application.ActivityLifecycleCallbacks
+import android.os.Bundle
+
+interface DefaultActivityLifecycleCallbacks : ActivityLifecycleCallbacks {
+
+	override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+
+	override fun onActivityStarted(activity: Activity) = Unit
+
+	override fun onActivityResumed(activity: Activity) = Unit
+
+	override fun onActivityPaused(activity: Activity) = Unit
+
+	override fun onActivityStopped(activity: Activity) = Unit
+
+	override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+
+	override fun onActivityDestroyed(activity: Activity) = Unit
+}

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

@@ -6,7 +6,7 @@ import android.view.View.OnLongClickListener
 import com.hannesdorfmann.adapterdelegates4.dsl.AdapterDelegateViewBindingViewHolder
 
 class AdapterDelegateClickListenerAdapter<I>(
-	private val adapterDelegate: AdapterDelegateViewBindingViewHolder<I, *>,
+	private val adapterDelegate: AdapterDelegateViewBindingViewHolder<out I, *>,
 	private val clickListener: OnListItemClickListener<I>,
 ) : OnClickListener, OnLongClickListener {
 
@@ -17,4 +17,4 @@ class AdapterDelegateClickListenerAdapter<I>(
 	override fun onLongClick(v: View): Boolean {
 		return clickListener.onItemLongClick(adapterDelegate.item, v)
 	}
-}
+}

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

@@ -2,20 +2,20 @@ package org.koitharu.kotatsu.base.ui.list
 
 import android.app.Activity
 import android.os.Bundle
-import android.util.ArrayMap
 import android.view.Menu
 import android.view.MenuItem
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.view.ActionMode
+import androidx.collection.ArrayMap
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import androidx.lifecycle.LifecycleOwner
 import androidx.recyclerview.widget.RecyclerView
 import androidx.savedstate.SavedStateRegistry
 import androidx.savedstate.SavedStateRegistryOwner
-import kotlin.coroutines.EmptyCoroutineContext
 import kotlinx.coroutines.Dispatchers
 import org.koitharu.kotatsu.base.ui.list.decor.AbstractSelectionItemDecoration
+import kotlin.coroutines.EmptyCoroutineContext
 
 private const val PROVIDER_NAME = "selection_decoration_sectioned"
 
@@ -60,7 +60,19 @@ class SectionedSelectionController<T : Any>(
 			startActionMode()
 			notifySelectionChanged()
 		}
-		recyclerView.addItemDecoration(decoration)
+		var shouldAddDecoration = true
+		for (i in (0 until recyclerView.itemDecorationCount).reversed()) {
+			val decor = recyclerView.getItemDecorationAt(i)
+			if (decor === decoration) {
+				shouldAddDecoration = false
+				break
+			} else if (decor.javaClass == decoration.javaClass) {
+				recyclerView.removeItemDecorationAt(i)
+			}
+		}
+		if (shouldAddDecoration) {
+			recyclerView.addItemDecoration(decoration)
+		}
 		if (pendingData?.isEmpty() == true) {
 			pendingData = null
 		}

app/src/main/java/org/koitharu/kotatsu/base/ui/list/fastscroll/FastScroller.kt

@@ -516,6 +516,6 @@ class FastScroller @JvmOverloads constructor(
 
 	interface SectionIndexer {
 
-		fun getSectionText(context: Context, position: Int): CharSequence
+		fun getSectionText(context: Context, position: Int): CharSequence?
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/base/ui/util/ActivityRecreationHandle.kt

@@ -1,14 +1,14 @@
 package org.koitharu.kotatsu.base.ui.util
 
 import android.app.Activity
-import android.app.Application.ActivityLifecycleCallbacks
 import android.os.Bundle
-import java.util.*
+import org.koitharu.kotatsu.base.ui.DefaultActivityLifecycleCallbacks
+import java.util.WeakHashMap
 import javax.inject.Inject
 import javax.inject.Singleton
 
 @Singleton
-class ActivityRecreationHandle @Inject constructor() : ActivityLifecycleCallbacks {
+class ActivityRecreationHandle @Inject constructor() : DefaultActivityLifecycleCallbacks {
 
 	private val activities = WeakHashMap<Activity, Unit>()
 
@@ -16,16 +16,6 @@ class ActivityRecreationHandle @Inject constructor() : ActivityLifecycleCallback
 		activities[activity] = Unit
 	}
 
-	override fun onActivityStarted(activity: Activity) = Unit
-
-	override fun onActivityResumed(activity: Activity) = Unit
-
-	override fun onActivityPaused(activity: Activity) = Unit
-
-	override fun onActivityStopped(activity: Activity) = Unit
-
-	override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
-
 	override fun onActivityDestroyed(activity: Activity) {
 		activities.remove(activity)
 	}

app/src/main/java/org/koitharu/kotatsu/base/ui/util/ShrinkOnScrollBehavior.kt

@@ -8,10 +8,12 @@ import androidx.coordinatorlayout.widget.CoordinatorLayout.Behavior
 import androidx.core.view.ViewCompat
 import com.google.android.material.floatingactionbutton.ExtendedFloatingActionButton
 
-class ShrinkOnScrollBehavior : Behavior<ExtendedFloatingActionButton> {
+open class ShrinkOnScrollBehavior : Behavior<ExtendedFloatingActionButton> {
 
-	@Suppress("unused") constructor() : super()
-	@Suppress("unused") constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
+	@Suppress("unused")
+	constructor() : super()
+	@Suppress("unused")
+	constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
 
 	override fun onStartNestedScroll(
 		coordinatorLayout: CoordinatorLayout,
@@ -45,4 +47,4 @@ class ShrinkOnScrollBehavior : Behavior<ExtendedFloatingActionButton> {
 			}
 		}
 	}
-}
+}

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

@@ -5,6 +5,7 @@ import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.RecyclerView
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
+import kotlin.jvm.internal.Intrinsics
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.base.ui.list.SectionedSelectionController
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
@@ -12,7 +13,6 @@ import org.koitharu.kotatsu.bookmarks.ui.model.BookmarksGroup
 import org.koitharu.kotatsu.list.ui.adapter.*
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.parsers.model.Manga
-import kotlin.jvm.internal.Intrinsics
 
 class BookmarksGroupAdapter(
 	coil: ImageLoader,
@@ -34,11 +34,11 @@ class BookmarksGroupAdapter(
 					selectionController = selectionController,
 					bookmarkClickListener = bookmarkClickListener,
 					groupClickListener = groupClickListener,
-				)
+				),
 			)
 			.addDelegate(loadingStateAD())
 			.addDelegate(loadingFooterAD())
-			.addDelegate(emptyStateListAD(listener))
+			.addDelegate(emptyStateListAD(coil, listener))
 			.addDelegate(errorStateListAD(listener))
 	}
 
@@ -64,4 +64,4 @@ class BookmarksGroupAdapter(
 			}
 		}
 	}
-}
+}

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

@@ -4,12 +4,12 @@ import android.graphics.Bitmap
 import android.webkit.WebView
 import android.webkit.WebViewClient
 import okhttp3.HttpUrl.Companion.toHttpUrl
-import org.koitharu.kotatsu.core.network.AndroidCookieJar
+import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
 
 private const val CF_CLEARANCE = "cf_clearance"
 
 class CloudFlareClient(
-	private val cookieJar: AndroidCookieJar,
+	private val cookieJar: MutableCookieJar,
 	private val callback: CloudFlareCallback,
 	private val targetUrl: String,
 ) : WebViewClient() {
@@ -42,4 +42,4 @@ class CloudFlareClient(
 		return cookieJar.loadForRequest(targetUrl.toHttpUrl())
 			.find { it.name == CF_CLEARANCE }?.value
 	}
-}
+}

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

@@ -12,13 +12,13 @@ import androidx.core.view.isInvisible
 import androidx.fragment.app.setFragmentResult
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.base.ui.AlertDialogFragment
-import org.koitharu.kotatsu.core.network.AndroidCookieJar
 import org.koitharu.kotatsu.core.network.UserAgentInterceptor
+import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
 import org.koitharu.kotatsu.databinding.FragmentCloudflareBinding
 import org.koitharu.kotatsu.utils.ext.stringArgument
 import org.koitharu.kotatsu.utils.ext.withArgs
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class CloudFlareDialog : AlertDialogFragment<FragmentCloudflareBinding>(), CloudFlareCallback {
@@ -27,7 +27,7 @@ class CloudFlareDialog : AlertDialogFragment<FragmentCloudflareBinding>(), Cloud
 	private val pendingResult = Bundle(1)
 
 	@Inject
-	lateinit var cookieJar: AndroidCookieJar
+	lateinit var cookieJar: MutableCookieJar
 
 	override fun onInflateView(
 		inflater: LayoutInflater,

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

@@ -4,6 +4,7 @@ import android.app.Application
 import android.content.Context
 import android.provider.SearchRecentSuggestions
 import android.text.Html
+import android.util.AndroidRuntimeException
 import androidx.collection.arraySetOf
 import androidx.room.InvalidationTracker
 import coil.ComponentRegistry
@@ -18,15 +19,20 @@ import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import dagger.multibindings.ElementsIntoSet
-import java.util.concurrent.TimeUnit
-import javax.inject.Singleton
 import kotlinx.coroutines.Dispatchers
 import okhttp3.CookieJar
 import okhttp3.OkHttpClient
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.base.ui.util.ActivityRecreationHandle
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.core.cache.MemoryContentCache
+import org.koitharu.kotatsu.core.cache.StubContentCache
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.network.*
+import org.koitharu.kotatsu.core.network.cookies.AndroidCookieJar
+import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
+import org.koitharu.kotatsu.core.network.cookies.PreferencesCookieJar
+import org.koitharu.kotatsu.core.os.NetworkState
 import org.koitharu.kotatsu.core.os.ShortcutsUpdater
 import org.koitharu.kotatsu.core.parser.MangaLoaderContextImpl
 import org.koitharu.kotatsu.core.parser.MangaRepository
@@ -40,16 +46,21 @@ import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.search.ui.MangaSuggestionsProvider
 import org.koitharu.kotatsu.settings.backup.BackupObserver
 import org.koitharu.kotatsu.sync.domain.SyncController
+import org.koitharu.kotatsu.utils.IncognitoModeIndicator
+import org.koitharu.kotatsu.utils.ext.activityManager
+import org.koitharu.kotatsu.utils.ext.connectivityManager
 import org.koitharu.kotatsu.utils.ext.isLowRamDevice
 import org.koitharu.kotatsu.utils.image.CoilImageGetter
 import org.koitharu.kotatsu.widget.WidgetUpdater
+import java.util.concurrent.TimeUnit
+import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
 interface AppModule {
 
 	@Binds
-	fun bindCookieJar(androidCookieJar: AndroidCookieJar): CookieJar
+	fun bindCookieJar(androidCookieJar: MutableCookieJar): CookieJar
 
 	@Binds
 	fun bindMangaLoaderContext(mangaLoaderContextImpl: MangaLoaderContextImpl): MangaLoaderContext
@@ -59,6 +70,17 @@ interface AppModule {
 
 	companion object {
 
+		@Provides
+		@Singleton
+		fun provideCookieJar(
+			@ApplicationContext context: Context
+		): MutableCookieJar = try {
+			AndroidCookieJar()
+		} catch (e: AndroidRuntimeException) {
+			// WebView is not available
+			PreferencesCookieJar(context)
+		}
+
 		@Provides
 		@Singleton
 		fun provideOkHttpClient(
@@ -80,6 +102,12 @@ interface AppModule {
 			}.build()
 		}
 
+		@Provides
+		@Singleton
+		fun provideNetworkState(
+			@ApplicationContext context: Context
+		) = NetworkState(context.connectivityManager)
+
 		@Provides
 		@Singleton
 		fun provideMangaDatabase(
@@ -152,9 +180,23 @@ interface AppModule {
 		fun provideActivityLifecycleCallbacks(
 			appProtectHelper: AppProtectHelper,
 			activityRecreationHandle: ActivityRecreationHandle,
+			incognitoModeIndicator: IncognitoModeIndicator,
 		): Set<@JvmSuppressWildcards Application.ActivityLifecycleCallbacks> = arraySetOf(
 			appProtectHelper,
 			activityRecreationHandle,
+			incognitoModeIndicator,
 		)
+
+		@Provides
+		@Singleton
+		fun provideContentCache(
+			application: Application,
+		): ContentCache {
+			return if (application.activityManager?.isLowRamDevice == true) {
+				StubContentCache()
+			} else {
+				MemoryContentCache(application)
+			}
+		}
 	}
 }

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

@@ -1,13 +1,14 @@
 package org.koitharu.kotatsu.core.backup
 
 import androidx.room.withTransaction
-import javax.inject.Inject
 import org.json.JSONArray
 import org.json.JSONObject
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.parsers.util.json.JSONIterator
 import org.koitharu.kotatsu.parsers.util.json.mapJSON
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import javax.inject.Inject
 
 private const val PAGE_SIZE = 10
 
@@ -85,7 +86,7 @@ class BackupRepository @Inject constructor(private val db: MangaDatabase) {
 				JsonDeserializer(it).toTagEntity()
 			}
 			val history = JsonDeserializer(item).toHistoryEntity()
-			result += runCatching {
+			result += runCatchingCancellable {
 				db.withTransaction {
 					db.tagsDao.upsert(tags)
 					db.mangaDao.upsert(manga, tags)
@@ -100,7 +101,7 @@ class BackupRepository @Inject constructor(private val db: MangaDatabase) {
 		val result = CompositeResult()
 		for (item in entry.data.JSONIterator()) {
 			val category = JsonDeserializer(item).toFavouriteCategoryEntity()
-			result += runCatching {
+			result += runCatchingCancellable {
 				db.favouriteCategoriesDao.upsert(category)
 			}
 		}
@@ -116,7 +117,7 @@ class BackupRepository @Inject constructor(private val db: MangaDatabase) {
 				JsonDeserializer(it).toTagEntity()
 			}
 			val favourite = JsonDeserializer(item).toFavouriteEntity()
-			result += runCatching {
+			result += runCatchingCancellable {
 				db.withTransaction {
 					db.tagsDao.upsert(tags)
 					db.mangaDao.upsert(manga, tags)

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

@@ -0,0 +1,23 @@
+package org.koitharu.kotatsu.core.cache
+
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+interface ContentCache {
+
+	val isCachingEnabled: Boolean
+
+	suspend fun getDetails(source: MangaSource, url: String): Manga?
+
+	fun putDetails(source: MangaSource, url: String, details: SafeDeferred<Manga>)
+
+	suspend fun getPages(source: MangaSource, url: String): List<MangaPage>?
+
+	fun putPages(source: MangaSource, url: String, pages: SafeDeferred<List<MangaPage>>)
+
+	data class Key(
+		val source: MangaSource,
+		val url: String,
+	)
+}

app/src/main/java/org/koitharu/kotatsu/core/cache/DeferredLruCache.kt

@@ -0,0 +1,5 @@
+package org.koitharu.kotatsu.core.cache
+
+import androidx.collection.LruCache
+
+class DeferredLruCache<T>(maxSize: Int) : LruCache<ContentCache.Key, SafeDeferred<T>>(maxSize)

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

@@ -0,0 +1,59 @@
+package org.koitharu.kotatsu.core.cache
+
+import android.app.Application
+import android.content.ComponentCallbacks2
+import android.content.res.Configuration
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+class MemoryContentCache(application: Application) : ContentCache, ComponentCallbacks2 {
+
+	init {
+		application.registerComponentCallbacks(this)
+	}
+
+	private val detailsCache = DeferredLruCache<Manga>(4)
+	private val pagesCache = DeferredLruCache<List<MangaPage>>(4)
+
+	override val isCachingEnabled: Boolean = true
+
+	override suspend fun getDetails(source: MangaSource, url: String): Manga? {
+		return detailsCache[ContentCache.Key(source, url)]?.awaitOrNull()
+	}
+
+	override fun putDetails(source: MangaSource, url: String, details: SafeDeferred<Manga>) {
+		detailsCache.put(ContentCache.Key(source, url), details)
+	}
+
+	override suspend fun getPages(source: MangaSource, url: String): List<MangaPage>? {
+		return pagesCache[ContentCache.Key(source, url)]?.awaitOrNull()
+	}
+
+	override fun putPages(source: MangaSource, url: String, pages: SafeDeferred<List<MangaPage>>) {
+		pagesCache.put(ContentCache.Key(source, url), pages)
+	}
+
+	override fun onConfigurationChanged(newConfig: Configuration) = Unit
+
+	override fun onLowMemory() = Unit
+
+	override fun onTrimMemory(level: Int) {
+		trimCache(detailsCache, level)
+		trimCache(pagesCache, level)
+	}
+
+	private fun trimCache(cache: DeferredLruCache<*>, level: Int) {
+		when (level) {
+			ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL,
+			ComponentCallbacks2.TRIM_MEMORY_COMPLETE,
+			ComponentCallbacks2.TRIM_MEMORY_MODERATE -> cache.evictAll()
+
+			ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN,
+			ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW,
+			ComponentCallbacks2.TRIM_MEMORY_BACKGROUND -> cache.trimToSize(1)
+
+			else -> cache.trimToSize(cache.maxSize() / 2)
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/core/cache/SafeDeferred.kt

@@ -0,0 +1,20 @@
+package org.koitharu.kotatsu.core.cache
+
+import kotlinx.coroutines.Deferred
+
+class SafeDeferred<T>(
+	private val delegate: Deferred<Result<T>>,
+) {
+
+	suspend fun await(): T {
+		return delegate.await().getOrThrow()
+	}
+
+	suspend fun awaitOrNull(): T? {
+		return delegate.await().getOrNull()
+	}
+
+	fun cancel() {
+		delegate.cancel()
+	}
+}

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

@@ -0,0 +1,18 @@
+package org.koitharu.kotatsu.core.cache
+
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+class StubContentCache : ContentCache {
+
+	override val isCachingEnabled: Boolean = false
+
+	override suspend fun getDetails(source: MangaSource, url: String): Manga? = null
+
+	override fun putDetails(source: MangaSource, url: String, details: SafeDeferred<Manga>) = Unit
+
+	override suspend fun getPages(source: MangaSource, url: String): List<MangaPage>? = null
+
+	override fun putPages(source: MangaSource, url: String, pages: SafeDeferred<List<MangaPage>>) = Unit
+}

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

@@ -14,11 +14,11 @@ abstract class MangaDao {
 	abstract suspend fun find(id: Long): MangaWithTags?
 
 	@Transaction
-	@Query("SELECT * FROM manga WHERE title LIKE :query OR alt_title LIKE :query LIMIT :limit")
+	@Query("SELECT * FROM manga WHERE (title LIKE :query OR alt_title LIKE :query) AND manga_id IN (SELECT manga_id FROM favourites UNION SELECT manga_id FROM history) LIMIT :limit")
 	abstract suspend fun searchByTitle(query: String, limit: Int): List<MangaWithTags>
 
 	@Transaction
-	@Query("SELECT * FROM manga WHERE (title LIKE :query OR alt_title LIKE :query) AND source = :source LIMIT :limit")
+	@Query("SELECT * FROM manga WHERE (title LIKE :query OR alt_title LIKE :query) AND source = :source AND manga_id IN (SELECT manga_id FROM favourites UNION SELECT manga_id FROM history) LIMIT :limit")
 	abstract suspend fun searchByTitle(query: String, source: String, limit: Int): List<MangaWithTags>
 
 	@Insert(onConflict = OnConflictStrategy.IGNORE)
@@ -47,4 +47,4 @@ abstract class MangaDao {
 			}
 		}
 	}
-}
+}

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

@@ -13,16 +13,6 @@ abstract class PreferencesDao {
 	@Query("SELECT * FROM preferences WHERE manga_id = :mangaId")
 	abstract fun observe(mangaId: Long): Flow<MangaPrefsEntity?>
 
-	@Insert(onConflict = OnConflictStrategy.IGNORE)
-	abstract suspend fun insert(pref: MangaPrefsEntity): Long
-
-	@Update
-	abstract suspend fun update(pref: MangaPrefsEntity): Int
-
-	@Transaction
-	open suspend fun upsert(pref: MangaPrefsEntity) {
-		if (update(pref) == 0) {
-			insert(pref)
-		}
-	}
+	@Upsert
+	abstract suspend fun upsert(pref: MangaPrefsEntity)
 }

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

@@ -14,7 +14,7 @@ abstract class TagsDao {
 		LEFT JOIN manga_tags ON tags.tag_id = manga_tags.tag_id
 		GROUP BY tags.title 
 		ORDER BY COUNT(manga_id) DESC 
-		LIMIT :limit"""
+		LIMIT :limit""",
 	)
 	abstract suspend fun findPopularTags(limit: Int): List<TagEntity>
 
@@ -24,7 +24,7 @@ abstract class TagsDao {
 		WHERE tags.source = :source 
 		GROUP BY tags.title
 		ORDER BY COUNT(manga_id) DESC 
-		LIMIT :limit"""
+		LIMIT :limit""",
 	)
 	abstract suspend fun findPopularTags(source: String, limit: Int): List<TagEntity>
 
@@ -34,7 +34,7 @@ abstract class TagsDao {
 		WHERE tags.source = :source AND title LIKE :query
 		GROUP BY tags.title
 		ORDER BY COUNT(manga_id) DESC 
-		LIMIT :limit"""
+		LIMIT :limit""",
 	)
 	abstract suspend fun findTags(source: String, query: String, limit: Int): List<TagEntity>
 
@@ -44,22 +44,10 @@ abstract class TagsDao {
 		WHERE title LIKE :query
 		GROUP BY tags.title
 		ORDER BY COUNT(manga_id) DESC 
-		LIMIT :limit"""
+		LIMIT :limit""",
 	)
 	abstract suspend fun findTags(query: String, limit: Int): List<TagEntity>
 
-	@Insert(onConflict = OnConflictStrategy.IGNORE)
-	abstract suspend fun insert(tag: TagEntity): Long
-
-	@Update(onConflict = OnConflictStrategy.IGNORE)
-	abstract suspend fun update(tag: TagEntity): Int
-
-	@Transaction
-	open suspend fun upsert(tags: Iterable<TagEntity>) {
-		tags.forEach { tag ->
-			if (update(tag) <= 0) {
-				insert(tag)
-			}
-		}
-	}
-}
+	@Upsert
+	abstract suspend fun upsert(tags: Iterable<TagEntity>)
+}

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

@@ -11,7 +11,7 @@ import org.koitharu.kotatsu.utils.ext.longHashCode
 fun TagEntity.toMangaTag() = MangaTag(
 	key = this.key,
 	title = this.title.toTitleCase(),
-	source = MangaSource(this.source) ?: MangaSource.DUMMY,
+	source = MangaSource(this.source),
 )
 
 fun Collection<TagEntity>.toMangaTags() = mapToSet(TagEntity::toMangaTag)
@@ -28,7 +28,7 @@ fun MangaEntity.toManga(tags: Set<MangaTag>) = Manga(
 	coverUrl = this.coverUrl,
 	largeCoverUrl = this.largeCoverUrl,
 	author = this.author,
-	source = MangaSource(this.source) ?: MangaSource.DUMMY,
+	source = MangaSource(this.source),
 	tags = tags,
 )
 

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

@@ -1,14 +1,11 @@
 package org.koitharu.kotatsu.core.exceptions.resolve
 
-import android.util.ArrayMap
 import androidx.activity.result.ActivityResultCallback
 import androidx.activity.result.ActivityResultLauncher
 import androidx.annotation.StringRes
+import androidx.collection.ArrayMap
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 import kotlinx.coroutines.suspendCancellableCoroutine
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.browser.BrowserActivity
@@ -20,6 +17,9 @@ import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.settings.sources.auth.SourceAuthActivity
 import org.koitharu.kotatsu.utils.TaggedActivityResult
 import org.koitharu.kotatsu.utils.isSuccess
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
 
 class ExceptionResolver private constructor(
 	private val activity: FragmentActivity?,
@@ -49,6 +49,7 @@ class ExceptionResolver private constructor(
 			openInBrowser(e.url)
 			false
 		}
+
 		else -> false
 	}
 

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

@@ -4,13 +4,6 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.content.pm.PackageManager
 import dagger.hilt.android.qualifiers.ApplicationContext
-import java.io.ByteArrayInputStream
-import java.io.InputStream
-import java.security.MessageDigest
-import java.security.cert.CertificateFactory
-import java.security.cert.X509Certificate
-import javax.inject.Inject
-import javax.inject.Singleton
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -24,6 +17,14 @@ import org.koitharu.kotatsu.parsers.util.json.mapJSONNotNull
 import org.koitharu.kotatsu.parsers.util.parseJsonArray
 import org.koitharu.kotatsu.utils.ext.asArrayList
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import java.io.ByteArrayInputStream
+import java.io.InputStream
+import java.security.MessageDigest
+import java.security.cert.CertificateFactory
+import java.security.cert.X509Certificate
+import javax.inject.Inject
+import javax.inject.Singleton
 
 private const val CERT_SHA1 = "2C:19:C7:E8:07:61:2B:8E:94:51:1B:FD:72:67:07:64:5D:C2:58:AE"
 
@@ -59,7 +60,7 @@ class AppUpdateRepository @Inject constructor(
 		if (!isUpdateSupported()) {
 			return@withContext null
 		}
-		runCatching {
+		runCatchingCancellable {
 			val currentVersion = VersionId(BuildConfig.VERSION_NAME)
 			val available = getAvailableVersions().asArrayList()
 			available.sortBy { it.versionId }
@@ -79,6 +80,12 @@ class AppUpdateRepository @Inject constructor(
 		return BuildConfig.DEBUG || getCertificateSHA1Fingerprint() == CERT_SHA1
 	}
 
+	suspend fun getCurrentVersionChangelog(): String? {
+		val currentVersion = VersionId(BuildConfig.VERSION_NAME)
+		val available = getAvailableVersions()
+		return available.find { x -> x.versionId == currentVersion }?.description
+	}
+
 	@Suppress("DEPRECATION")
 	@SuppressLint("PackageManagerGetSignatures")
 	private fun getCertificateSHA1Fingerprint(): String? = runCatching {

app/src/main/java/org/koitharu/kotatsu/core/logs/FileLogger.kt

@@ -0,0 +1,128 @@
+package org.koitharu.kotatsu.core.logs
+
+import android.content.Context
+import androidx.annotation.WorkerThread
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runInterruptible
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.processLifecycleScope
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import org.koitharu.kotatsu.utils.ext.subdir
+import java.io.File
+import java.io.FileOutputStream
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.concurrent.ConcurrentLinkedQueue
+
+private const val DIR = "logs"
+private const val FLUSH_DELAY = 2_000L
+private const val MAX_SIZE_BYTES = 1024 * 1024 // 1 MB
+
+class FileLogger(
+	context: Context,
+	private val settings: AppSettings,
+	name: String,
+) {
+
+	val file by lazy {
+		val dir = context.getExternalFilesDir(DIR) ?: context.filesDir.subdir(DIR)
+		File(dir, "$name.log")
+	}
+	val isEnabled: Boolean
+		get() = settings.isLoggingEnabled
+	private val dateFormat = SimpleDateFormat.getDateTimeInstance(
+		SimpleDateFormat.SHORT,
+		SimpleDateFormat.SHORT,
+		Locale.ROOT,
+	)
+	private val buffer = ConcurrentLinkedQueue<String>()
+	private val mutex = Mutex()
+	private var flushJob: Job? = null
+
+	fun log(message: String, e: Throwable? = null) {
+		if (!isEnabled) {
+			return
+		}
+		val text = buildString {
+			append(dateFormat.format(Date()))
+			append(": ")
+			if (e != null) {
+				append("E!")
+			}
+			append(message)
+			if (e != null) {
+				append(' ')
+				append(e.stackTraceToString())
+				appendLine()
+			}
+		}
+		buffer.add(text)
+		postFlush()
+	}
+
+	suspend fun flush() {
+		if (!isEnabled) {
+			return
+		}
+		flushJob?.cancelAndJoin()
+		flushImpl()
+	}
+
+	private fun postFlush() {
+		if (flushJob?.isActive == true) {
+			return
+		}
+		flushJob = processLifecycleScope.launch(Dispatchers.Default) {
+			delay(FLUSH_DELAY)
+			runCatchingCancellable {
+				flushImpl()
+			}.onFailure {
+				it.printStackTraceDebug()
+			}
+		}
+	}
+
+	private suspend fun flushImpl() {
+		mutex.withLock {
+			if (buffer.isEmpty()) {
+				return
+			}
+			runInterruptible(Dispatchers.IO) {
+				if (file.length() > MAX_SIZE_BYTES) {
+					rotate()
+				}
+				FileOutputStream(file, true).use {
+					while (true) {
+						val message = buffer.poll() ?: break
+						it.write(message.toByteArray())
+						it.write('\n'.code)
+					}
+					it.flush()
+				}
+			}
+		}
+	}
+
+	@WorkerThread
+	private fun rotate() {
+		val length = file.length()
+		val bakFile = File(file.parentFile, file.name + ".bak")
+		file.renameTo(bakFile)
+		bakFile.inputStream().use { input ->
+			input.skip(length - MAX_SIZE_BYTES / 2)
+			file.outputStream().use { output ->
+				input.copyTo(output)
+				output.flush()
+			}
+		}
+		bakFile.delete()
+	}
+}

app/src/main/java/org/koitharu/kotatsu/core/logs/Loggers.kt

@@ -0,0 +1,7 @@
+package org.koitharu.kotatsu.core.logs
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class TrackerLogger

app/src/main/java/org/koitharu/kotatsu/core/logs/LoggersModule.kt

@@ -0,0 +1,31 @@
+package org.koitharu.kotatsu.core.logs
+
+import android.content.Context
+import androidx.collection.arraySetOf
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import dagger.multibindings.ElementsIntoSet
+import org.koitharu.kotatsu.core.prefs.AppSettings
+
+@Module
+@InstallIn(SingletonComponent::class)
+object LoggersModule {
+
+	@Provides
+	@TrackerLogger
+	fun provideTrackerLogger(
+		@ApplicationContext context: Context,
+		settings: AppSettings,
+	) = FileLogger(context, settings, "tracker")
+
+	@Provides
+	@ElementsIntoSet
+	fun provideAllLoggers(
+		@TrackerLogger trackerLogger: FileLogger,
+	): Set<@JvmSuppressWildcards FileLogger> = arraySetOf(
+		trackerLogger,
+	)
+}

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

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

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

@@ -2,7 +2,12 @@ package org.koitharu.kotatsu.core.model.parcelable
 
 import android.os.Parcel
 import androidx.core.os.ParcelCompat
-import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.utils.ext.readParcelableCompat
+import org.koitharu.kotatsu.utils.ext.readSerializableCompat
 
 fun Manga.writeToParcel(out: Parcel, flags: Int, withChapters: Boolean) {
 	out.writeLong(id)
@@ -37,11 +42,11 @@ fun Parcel.readManga() = Manga(
 	coverUrl = requireNotNull(readString()),
 	largeCoverUrl = readString(),
 	description = readString(),
-	tags = requireNotNull(readParcelable<ParcelableMangaTags>(ParcelableMangaTags::class.java.classLoader)).tags,
-	state = readSerializable() as MangaState?,
+	tags = requireNotNull(readParcelableCompat<ParcelableMangaTags>()).tags,
+	state = readSerializableCompat(),
 	author = readString(),
-	chapters = readParcelable<ParcelableMangaChapters>(ParcelableMangaChapters::class.java.classLoader)?.chapters,
-	source = readSerializable() as MangaSource,
+	chapters = readParcelableCompat<ParcelableMangaChapters>()?.chapters,
+	source = checkNotNull(readSerializableCompat()),
 )
 
 fun MangaPage.writeToParcel(out: Parcel) {
@@ -57,7 +62,7 @@ fun Parcel.readMangaPage() = MangaPage(
 	url = requireNotNull(readString()),
 	referer = requireNotNull(readString()),
 	preview = readString(),
-	source = readSerializable() as MangaSource,
+	source = checkNotNull(readSerializableCompat()),
 )
 
 fun MangaChapter.writeToParcel(out: Parcel) {
@@ -79,7 +84,7 @@ fun Parcel.readMangaChapter() = MangaChapter(
 	scanlator = readString(),
 	uploadDate = readLong(),
 	branch = readString(),
-	source = readSerializable() as MangaSource,
+	source = checkNotNull(readSerializableCompat()),
 )
 
 fun MangaTag.writeToParcel(out: Parcel) {
@@ -91,5 +96,5 @@ fun MangaTag.writeToParcel(out: Parcel) {
 fun Parcel.readMangaTag() = MangaTag(
 	title = requireNotNull(readString()),
 	key = requireNotNull(readString()),
-	source = readSerializable() as MangaSource,
-)
+	source = checkNotNull(readSerializableCompat()),
+)

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

@@ -50,4 +50,4 @@ class ParcelableManga(
 			return arrayOfNulls(size)
 		}
 	}
-}
+}

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

@@ -1,19 +1,17 @@
-package org.koitharu.kotatsu.core.network
+package org.koitharu.kotatsu.core.network.cookies
 
 import android.webkit.CookieManager
-import javax.inject.Inject
-import javax.inject.Singleton
+import androidx.annotation.WorkerThread
+import okhttp3.Cookie
+import okhttp3.HttpUrl
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
-import okhttp3.Cookie
-import okhttp3.CookieJar
-import okhttp3.HttpUrl
 
-@Singleton
-class AndroidCookieJar @Inject constructor() : CookieJar {
+class AndroidCookieJar : MutableCookieJar {
 
 	private val cookieManager = CookieManager.getInstance()
 
+	@WorkerThread
 	override fun loadForRequest(url: HttpUrl): List<Cookie> {
 		val rawCookie = cookieManager.getCookie(url.toString()) ?: return emptyList()
 		return rawCookie.split(';').mapNotNull {
@@ -21,6 +19,7 @@ class AndroidCookieJar @Inject constructor() : CookieJar {
 		}
 	}
 
+	@WorkerThread
 	override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
 		if (cookies.isEmpty()) {
 			return
@@ -31,7 +30,7 @@ class AndroidCookieJar @Inject constructor() : CookieJar {
 		}
 	}
 
-	suspend fun clear() = suspendCoroutine<Boolean> { continuation ->
+	override suspend fun clear() = suspendCoroutine<Boolean> { continuation ->
 		cookieManager.removeAllCookies(continuation::resume)
 	}
 }

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

@@ -0,0 +1,84 @@
+package org.koitharu.kotatsu.core.network.cookies
+
+import android.util.Base64
+import okhttp3.Cookie
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.ObjectInputStream
+import java.io.ObjectOutputStream
+
+
+class CookieWrapper(
+	val cookie: Cookie,
+) {
+
+	constructor(encodedString: String) : this(
+		ObjectInputStream(ByteArrayInputStream(Base64.decode(encodedString, Base64.NO_WRAP))).use {
+			val name = it.readUTF()
+			val value = it.readUTF()
+			val expiresAt = it.readLong()
+			val domain = it.readUTF()
+			val path = it.readUTF()
+			val secure = it.readBoolean()
+			val httpOnly = it.readBoolean()
+			val persistent = it.readBoolean()
+			val hostOnly = it.readBoolean()
+			Cookie.Builder().also { c ->
+				c.name(name)
+				c.value(value)
+				if (persistent) {
+					c.expiresAt(expiresAt)
+				}
+				if (hostOnly) {
+					c.hostOnlyDomain(domain)
+				} else {
+					c.domain(domain)
+				}
+				c.path(path)
+				if (secure) {
+					c.secure()
+				}
+				if (httpOnly) {
+					c.httpOnly()
+				}
+			}.build()
+		},
+	)
+
+	fun encode(): String {
+		val output = ByteArrayOutputStream()
+		ObjectOutputStream(output).use {
+			it.writeUTF(cookie.name)
+			it.writeUTF(cookie.value)
+			it.writeLong(cookie.expiresAt)
+			it.writeUTF(cookie.domain)
+			it.writeUTF(cookie.path)
+			it.writeBoolean(cookie.secure)
+			it.writeBoolean(cookie.httpOnly)
+			it.writeBoolean(cookie.persistent)
+			it.writeBoolean(cookie.hostOnly)
+		}
+		return Base64.encodeToString(output.toByteArray(), Base64.NO_WRAP)
+	}
+
+	fun isExpired() = cookie.expiresAt < System.currentTimeMillis()
+
+	fun key(): String {
+		return (if (cookie.secure) "https" else "http") + "://" + cookie.domain + cookie.path + "|" + cookie.name
+	}
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as CookieWrapper
+
+		if (cookie != other.cookie) return false
+
+		return true
+	}
+
+	override fun hashCode(): Int {
+		return cookie.hashCode()
+	}
+}

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

@@ -0,0 +1,17 @@
+package org.koitharu.kotatsu.core.network.cookies
+
+import androidx.annotation.WorkerThread
+import okhttp3.Cookie
+import okhttp3.CookieJar
+import okhttp3.HttpUrl
+
+interface MutableCookieJar : CookieJar {
+
+	@WorkerThread
+	override fun loadForRequest(url: HttpUrl): List<Cookie>
+
+	@WorkerThread
+	override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>)
+
+	suspend fun clear(): Boolean
+}

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

@@ -0,0 +1,89 @@
+package org.koitharu.kotatsu.core.network.cookies
+
+import android.content.Context
+import androidx.annotation.WorkerThread
+import androidx.collection.ArrayMap
+import androidx.core.content.edit
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import okhttp3.Cookie
+import okhttp3.HttpUrl
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+
+private const val PREFS_NAME = "cookies"
+
+class PreferencesCookieJar(
+	context: Context,
+) : MutableCookieJar {
+
+	private val cache = ArrayMap<String, CookieWrapper>()
+	private val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+	private var isLoaded = false
+
+	@WorkerThread
+	override fun loadForRequest(url: HttpUrl): List<Cookie> {
+		loadPersistent()
+		val expired = HashSet<String>()
+		val result = ArrayList<Cookie>()
+		for ((key, cookie) in cache) {
+			if (cookie.isExpired()) {
+				expired += key
+			} else if (cookie.cookie.matches(url)) {
+				result += cookie.cookie
+			}
+		}
+		if (expired.isNotEmpty()) {
+			cache.removeAll(expired)
+			removePersistent(expired)
+		}
+		return result
+	}
+
+	@WorkerThread
+	override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
+		val wrapped = cookies.map { CookieWrapper(it) }
+		prefs.edit(commit = true) {
+			for (cookie in wrapped) {
+				val key = cookie.key()
+				cache[key] = cookie
+				if (cookie.cookie.persistent) {
+					putString(key, cookie.encode())
+				}
+			}
+		}
+	}
+
+	override suspend fun clear(): Boolean {
+		cache.clear()
+		withContext(Dispatchers.IO) {
+			prefs.edit(commit = true) { clear() }
+		}
+		return true
+	}
+
+	@Synchronized
+	private fun loadPersistent() {
+		if (!isLoaded) {
+			val map = prefs.all
+			cache.ensureCapacity(map.size)
+			for ((k, v) in map) {
+				val cookie = try {
+					CookieWrapper(v as String)
+				} catch (e: Exception) {
+					e.printStackTraceDebug()
+					continue
+				}
+				cache[k] = cookie
+			}
+			isLoaded = true
+		}
+	}
+
+	private fun removePersistent(keys: Collection<String>) {
+		prefs.edit(commit = true) {
+			for (key in keys) {
+				remove(key)
+			}
+		}
+	}
+}

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

@@ -0,0 +1,46 @@
+package org.koitharu.kotatsu.core.os
+
+import android.net.ConnectivityManager
+import android.net.ConnectivityManager.NetworkCallback
+import android.net.Network
+import android.net.NetworkRequest
+import kotlinx.coroutines.flow.first
+import org.koitharu.kotatsu.utils.MediatorStateFlow
+import org.koitharu.kotatsu.utils.ext.isNetworkAvailable
+
+class NetworkState(
+	private val connectivityManager: ConnectivityManager,
+) : MediatorStateFlow<Boolean>(connectivityManager.isNetworkAvailable) {
+
+	private val callback = NetworkCallbackImpl()
+
+	override fun onActive() {
+		invalidate()
+		val request = NetworkRequest.Builder().build()
+		connectivityManager.registerNetworkCallback(request, callback)
+	}
+
+	override fun onInactive() {
+		connectivityManager.unregisterNetworkCallback(callback)
+	}
+
+	suspend fun awaitForConnection() {
+		if (value) {
+			return
+		}
+		first { it }
+	}
+
+	private fun invalidate() {
+		publishValue(connectivityManager.isNetworkAvailable)
+	}
+
+	private inner class NetworkCallbackImpl : NetworkCallback() {
+
+		override fun onAvailable(network: Network) = invalidate()
+
+		override fun onLost(network: Network) = invalidate()
+
+		override fun onUnavailable() = invalidate()
+	}
+}

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

@@ -17,8 +17,6 @@ import coil.request.ImageRequest
 import coil.size.Precision
 import coil.size.Scale
 import dagger.hilt.android.qualifiers.ApplicationContext
-import javax.inject.Inject
-import javax.inject.Singleton
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
@@ -32,6 +30,9 @@ import org.koitharu.kotatsu.reader.ui.ReaderActivity
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.processLifecycleScope
 import org.koitharu.kotatsu.utils.ext.requireBitmap
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import javax.inject.Inject
+import javax.inject.Singleton
 
 @Singleton
 class ShortcutsUpdater @Inject constructor(
@@ -92,7 +93,7 @@ class ShortcutsUpdater @Inject constructor(
 	}
 
 	@RequiresApi(Build.VERSION_CODES.N_MR1)
-	private suspend fun updateShortcutsImpl() = runCatching {
+	private suspend fun updateShortcutsImpl() = runCatchingCancellable {
 		val manager = context.getSystemService(Context.SHORTCUT_SERVICE) as ShortcutManager
 		val shortcuts = historyRepository.getList(0, manager.maxShortcutCountPerActivity)
 			.filter { x -> x.title.isNotEmpty() }
@@ -112,7 +113,7 @@ class ShortcutsUpdater @Inject constructor(
 	}
 
 	private suspend fun buildShortcutInfo(manga: Manga): ShortcutInfoCompat.Builder {
-		val icon = runCatching {
+		val icon = runCatchingCancellable {
 			coil.execute(
 				ImageRequest.Builder(context)
 					.data(manga.coverUrl)

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

@@ -6,25 +6,25 @@ import android.util.Base64
 import android.webkit.WebView
 import androidx.core.os.LocaleListCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
-import java.util.*
-import javax.inject.Inject
-import javax.inject.Singleton
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
-import org.koitharu.kotatsu.core.network.AndroidCookieJar
+import org.koitharu.kotatsu.core.network.cookies.MutableCookieJar
 import org.koitharu.kotatsu.core.prefs.SourceSettings
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.config.MangaSourceConfig
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.utils.ext.toList
+import java.util.*
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
 
 @Singleton
 class MangaLoaderContextImpl @Inject constructor(
 	override val httpClient: OkHttpClient,
-	override val cookieJar: AndroidCookieJar,
+	override val cookieJar: MutableCookieJar,
 	@ApplicationContext private val androidContext: Context,
 ) : MangaLoaderContext() {
 

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

@@ -1,13 +1,19 @@
 package org.koitharu.kotatsu.core.parser
 
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.local.domain.LocalMangaRepository
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import java.lang.ref.WeakReference
-import java.util.*
+import java.util.EnumMap
 import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.collections.set
-import org.koitharu.kotatsu.local.domain.LocalMangaRepository
-import org.koitharu.kotatsu.parsers.MangaLoaderContext
-import org.koitharu.kotatsu.parsers.model.*
 
 interface MangaRepository {
 
@@ -31,6 +37,7 @@ interface MangaRepository {
 	class Factory @Inject constructor(
 		private val localMangaRepository: LocalMangaRepository,
 		private val loaderContext: MangaLoaderContext,
+		private val contentCache: ContentCache,
 	) {
 
 		private val cache = EnumMap<MangaSource, WeakReference<RemoteMangaRepository>>(MangaSource::class.java)
@@ -42,7 +49,7 @@ interface MangaRepository {
 			cache[source]?.get()?.let { return it }
 			return synchronized(cache) {
 				cache[source]?.get()?.let { return it }
-				val repository = RemoteMangaRepository(MangaParser(source, loaderContext))
+				val repository = RemoteMangaRepository(MangaParser(source, loaderContext), contentCache)
 				cache[source] = WeakReference(repository)
 				repository
 			}

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

@@ -1,12 +1,31 @@
 package org.koitharu.kotatsu.core.parser
 
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.MainCoroutineDispatcher
+import kotlinx.coroutines.async
+import kotlinx.coroutines.currentCoroutineContext
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.core.cache.SafeDeferred
 import org.koitharu.kotatsu.core.prefs.SourceSettings
 import org.koitharu.kotatsu.parsers.MangaParser
 import org.koitharu.kotatsu.parsers.MangaParserAuthProvider
 import org.koitharu.kotatsu.parsers.config.ConfigKey
-import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.model.Favicons
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.utils.ext.processLifecycleScope
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
-class RemoteMangaRepository(private val parser: MangaParser) : MangaRepository {
+class RemoteMangaRepository(
+	private val parser: MangaParser,
+	private val cache: ContentCache,
+) : MangaRepository {
 
 	override val source: MangaSource
 		get() = parser.source
@@ -28,9 +47,23 @@ class RemoteMangaRepository(private val parser: MangaParser) : MangaRepository {
 		return parser.getList(offset, tags, sortOrder)
 	}
 
-	override suspend fun getDetails(manga: Manga): Manga = parser.getDetails(manga)
+	override suspend fun getDetails(manga: Manga): Manga {
+		cache.getDetails(source, manga.url)?.let { return it }
+		val details = asyncSafe {
+			parser.getDetails(manga)
+		}
+		cache.putDetails(source, manga.url, details)
+		return details.await()
+	}
 
-	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> = parser.getPages(chapter)
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		cache.getPages(source, chapter.url)?.let { return it }
+		val pages = asyncSafe {
+			parser.getPages(chapter)
+		}
+		cache.putPages(source, chapter.url, pages)
+		return pages.await()
+	}
 
 	override suspend fun getPageUrl(page: MangaPage): String = parser.getPageUrl(page)
 
@@ -45,4 +78,16 @@ class RemoteMangaRepository(private val parser: MangaParser) : MangaRepository {
 	}
 
 	private fun getConfig() = parser.config as SourceSettings
-}
+
+	private suspend fun <T> asyncSafe(block: suspend CoroutineScope.() -> T): SafeDeferred<T> {
+		var dispatcher = currentCoroutineContext()[CoroutineDispatcher.Key]
+		if (dispatcher == null || dispatcher is MainCoroutineDispatcher) {
+			dispatcher = Dispatchers.Default
+		}
+		return SafeDeferred(
+			processLifecycleScope.async(dispatcher) {
+				runCatchingCancellable { block() }
+			},
+		)
+	}
+}

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

@@ -14,7 +14,6 @@ import coil.network.HttpException
 import coil.request.Options
 import coil.size.Size
 import coil.size.pxOrElse
-import java.net.HttpURLConnection
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.Response
@@ -27,6 +26,7 @@ import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.local.data.CacheDir
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.util.await
+import java.net.HttpURLConnection
 
 private const val FALLBACK_SIZE = 9999 // largest icon
 
@@ -150,7 +150,7 @@ class FaviconFetcher(
 
 		override fun create(data: Uri, options: Options, imageLoader: ImageLoader): Fetcher? {
 			return if (data.scheme == URI_SCHEME_FAVICON) {
-				val mangaSource = MangaSource(data.schemeSpecificPart) ?: return null
+				val mangaSource = MangaSource(data.schemeSpecificPart)
 				FaviconFetcher(okHttpClient, diskCache, mangaSource, options, mangaRepositoryFactory)
 			} else {
 				null

app/src/main/java/org/koitharu/kotatsu/core/prefs/AppSection.kt

@@ -1,6 +0,0 @@
-package org.koitharu.kotatsu.core.prefs
-
-enum class AppSection {
-
-	LOCAL, FAVOURITES, HISTORY, FEED, SUGGESTIONS
-}

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

@@ -2,35 +2,40 @@ package org.koitharu.kotatsu.core.prefs
 
 import android.content.Context
 import android.content.SharedPreferences
-import android.net.ConnectivityManager
 import android.net.Uri
 import android.provider.Settings
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.collection.arraySetOf
 import androidx.core.content.edit
+import androidx.core.os.LocaleListCompat
 import androidx.preference.PreferenceManager
 import com.google.android.material.color.DynamicColors
 import dagger.hilt.android.qualifiers.ApplicationContext
-import java.io.File
-import java.text.DateFormat
-import java.text.SimpleDateFormat
-import java.util.*
-import javax.inject.Inject
-import javax.inject.Singleton
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.model.ZoomMode
 import org.koitharu.kotatsu.core.network.DoHProvider
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.shelf.domain.ShelfSection
+import org.koitharu.kotatsu.utils.ext.connectivityManager
 import org.koitharu.kotatsu.utils.ext.getEnumValue
 import org.koitharu.kotatsu.utils.ext.observe
 import org.koitharu.kotatsu.utils.ext.putEnumValue
 import org.koitharu.kotatsu.utils.ext.toUriOrNull
+import java.io.File
+import java.text.DateFormat
+import java.text.SimpleDateFormat
+import java.util.Collections
+import java.util.EnumSet
+import java.util.Locale
+import javax.inject.Inject
+import javax.inject.Singleton
 
 @Singleton
 class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 
 	private val prefs = PreferenceManager.getDefaultSharedPreferences(context)
+	private val connectivityManager = context.connectivityManager
 
 	private val remoteSources = EnumSet.allOf(MangaSource::class.java).apply {
 		remove(MangaSource.LOCAL)
@@ -42,14 +47,26 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val remoteMangaSources: Set<MangaSource>
 		get() = Collections.unmodifiableSet(remoteSources)
 
+	var shelfSections: List<ShelfSection>
+		get() {
+			val raw = prefs.getString(KEY_SHELF_SECTIONS, null)
+			val values = enumValues<ShelfSection>()
+			if (raw.isNullOrEmpty()) {
+				return values.toList()
+			}
+			return raw.split('|')
+				.mapNotNull { values.getOrNull(it.toIntOrNull() ?: -1) }
+				.distinct()
+		}
+		set(value) {
+			val raw = value.joinToString("|") { it.ordinal.toString() }
+			prefs.edit { putString(KEY_SHELF_SECTIONS, raw) }
+		}
+
 	var listMode: ListMode
 		get() = prefs.getEnumValue(KEY_LIST_MODE, ListMode.GRID)
 		set(value) = prefs.edit { putEnumValue(KEY_LIST_MODE, value) }
 
-	var defaultSection: AppSection
-		get() = prefs.getEnumValue(KEY_APP_SECTION, AppSection.HISTORY)
-		set(value) = prefs.edit { putEnumValue(KEY_APP_SECTION, value) }
-
 	val theme: Int
 		get() = prefs.getString(KEY_THEME, null)?.toIntOrNull() ?: AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
 
@@ -63,6 +80,17 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getInt(KEY_GRID_SIZE, 100)
 		set(value) = prefs.edit { putInt(KEY_GRID_SIZE, value) }
 
+	var appLocales: LocaleListCompat
+		get() {
+			val raw = prefs.getString(KEY_APP_LOCALE, null)
+			return LocaleListCompat.forLanguageTags(raw)
+		}
+		set(value) {
+			prefs.edit {
+				putString(KEY_APP_LOCALE, value.toLanguageTags())
+			}
+		}
+
 	val readerPageSwitch: Set<String>
 		get() = prefs.getStringSet(KEY_READER_SWITCHERS, null) ?: setOf(PAGE_SWITCH_TAPS)
 
@@ -131,6 +159,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getString(KEY_APP_PASSWORD, null)
 		set(value) = prefs.edit { if (value != null) putString(KEY_APP_PASSWORD, value) else remove(KEY_APP_PASSWORD) }
 
+	val isLoggingEnabled: Boolean
+		get() = prefs.getBoolean(KEY_LOGGING_ENABLED, false)
+
 	var isBiometricProtectionEnabled: Boolean
 		get() = prefs.getBoolean(KEY_PROTECT_APP_BIOMETRIC, true)
 		set(value) = prefs.edit { putBoolean(KEY_PROTECT_APP_BIOMETRIC, value) }
@@ -141,6 +172,11 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isDynamicShortcutsEnabled: Boolean
 		get() = prefs.getBoolean(KEY_SHORTCUTS, true)
 
+	fun isContentPrefetchEnabled(): Boolean {
+		val policy = NetworkPolicy.from(prefs.getString(KEY_PREFETCH_CONTENT, null), NetworkPolicy.NEVER)
+		return policy.isNetworkAllowed(connectivityManager)
+	}
+
 	var sourcesOrder: List<String>
 		get() = prefs.getString(KEY_SOURCES_ORDER, null)
 			?.split('|')
@@ -206,6 +242,9 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 	val isReaderBarEnabled: Boolean
 		get() = prefs.getBoolean(KEY_READER_BAR, true)
 
+	val isReaderSliderEnabled: Boolean
+		get() = prefs.getBoolean(KEY_READER_SLIDER, true)
+
 	val dnsOverHttps: DoHProvider
 		get() = prefs.getEnumValue(KEY_DOH, DoHProvider.NONE)
 
@@ -213,12 +252,12 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		get() = prefs.getEnumValue(KEY_LOCAL_LIST_ORDER, SortOrder.NEWEST)
 		set(value) = prefs.edit { putEnumValue(KEY_LOCAL_LIST_ORDER, value) }
 
-	fun isPagesPreloadAllowed(cm: ConnectivityManager): Boolean {
-		return when (prefs.getString(KEY_PAGES_PRELOAD, null)?.toIntOrNull()) {
-			NETWORK_ALWAYS -> true
-			NETWORK_NEVER -> false
-			else -> cm.isActiveNetworkMetered
-		}
+	val isWebtoonZoomEnable: Boolean
+		get() = prefs.getBoolean(KEY_WEBTOON_ZOOM, true)
+
+	fun isPagesPreloadEnabled(): Boolean {
+		val policy = NetworkPolicy.from(prefs.getString(KEY_PAGES_PRELOAD, null), NetworkPolicy.NON_METERED)
+		return policy.isNetworkAllowed(connectivityManager)
 	}
 
 	fun getDateFormat(format: String = prefs.getString(KEY_DATE_FORMAT, "").orEmpty()): DateFormat =
@@ -272,7 +311,6 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val TRACK_FAVOURITES = "favourites"
 
 		const val KEY_LIST_MODE = "list_mode_2"
-		const val KEY_APP_SECTION = "app_section_2"
 		const val KEY_THEME = "theme"
 		const val KEY_DYNAMIC_THEME = "dynamic_theme"
 		const val KEY_THEME_AMOLED = "amoled_theme"
@@ -328,16 +366,19 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_INCOGNITO_MODE = "incognito"
 		const val KEY_SYNC = "sync"
 		const val KEY_READER_BAR = "reader_bar"
+		const val KEY_READER_SLIDER = "reader_slider"
 		const val KEY_SHORTCUTS = "dynamic_shortcuts"
 		const val KEY_READER_TAPS_LTR = "reader_taps_ltr"
 		const val KEY_LOCAL_LIST_ORDER = "local_order"
+		const val KEY_WEBTOON_ZOOM = "webtoon_zoom"
+		const val KEY_SHELF_SECTIONS = "shelf_sections_2"
+		const val KEY_PREFETCH_CONTENT = "prefetch_content"
+		const val KEY_APP_LOCALE = "app_locale"
+		const val KEY_LOGGING_ENABLED = "logging"
+		const val KEY_LOGS_SHARE = "logs_share"
 
 		// About
 		const val KEY_APP_UPDATE = "app_update"
 		const val KEY_APP_TRANSLATION = "about_app_translation"
-
-		private const val NETWORK_NEVER = 0
-		private const val NETWORK_ALWAYS = 1
-		private const val NETWORK_NON_METERED = 2
 	}
 }

app/src/main/java/org/koitharu/kotatsu/core/prefs/NetworkPolicy.kt

@@ -0,0 +1,26 @@
+package org.koitharu.kotatsu.core.prefs
+
+import android.net.ConnectivityManager
+
+enum class NetworkPolicy(
+	private val key: Int,
+) {
+
+	NEVER(0),
+	ALWAYS(1),
+	NON_METERED(2);
+
+	fun isNetworkAllowed(cm: ConnectivityManager) = when (this) {
+		NEVER -> false
+		ALWAYS -> true
+		NON_METERED -> !cm.isActiveNetworkMetered
+	}
+
+	companion object {
+
+		fun from(key: String?, default: NetworkPolicy): NetworkPolicy {
+			val intKey = key?.toIntOrNull() ?: return default
+			return enumValues<NetworkPolicy>().find { it.key == intKey } ?: default
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/core/ui/MangaErrorDialog.kt

@@ -54,7 +54,7 @@ class MangaErrorDialog : AlertDialogFragment<DialogMangaErrorBinding>() {
 			.setNegativeButton(android.R.string.cancel, null)
 			.setPositiveButton(R.string.report) { _, _ ->
 				dismiss()
-				error.report(TAG)
+				error.report()
 			}.setTitle(R.string.error_occurred)
 	}
 

app/src/main/java/org/koitharu/kotatsu/core/zip/ZipOutput.kt

@@ -52,10 +52,13 @@ class ZipOutput(
 		return if (entryNames.add(entry.name)) {
 			val zipEntry = ZipEntry(entry.name)
 			output.putNextEntry(zipEntry)
-			other.getInputStream(entry).use { input ->
-				input.copyTo(output)
+			try {
+				other.getInputStream(entry).use { input ->
+					input.copyTo(output)
+				}
+			} finally {
+				output.closeEntry()
 			}
-			output.closeEntry()
 			true
 		} else {
 			false
@@ -115,4 +118,4 @@ class ZipOutput(
 		closeEntry()
 		return true
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/details/service/MangaPrefetchService.kt

@@ -0,0 +1,116 @@
+package org.koitharu.kotatsu.details.service
+
+import android.content.Context
+import android.content.Intent
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.EntryPointAccessors
+import org.koitharu.kotatsu.base.ui.CoroutineIntentService
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableMangaChapters
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.history.domain.HistoryRepository
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.utils.ext.getParcelableExtraCompat
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class MangaPrefetchService : CoroutineIntentService() {
+
+	@Inject
+	lateinit var mangaRepositoryFactory: MangaRepository.Factory
+
+	@Inject
+	lateinit var cache: ContentCache
+
+	@Inject
+	lateinit var historyRepository: HistoryRepository
+
+	override suspend fun processIntent(startId: Int, intent: Intent) {
+		when (intent.action) {
+			ACTION_PREFETCH_DETAILS -> prefetchDetails(
+				manga = intent.getParcelableExtraCompat<ParcelableManga>(EXTRA_MANGA)?.manga ?: return,
+			)
+
+			ACTION_PREFETCH_PAGES -> prefetchPages(
+				chapter = intent.getParcelableExtraCompat<ParcelableMangaChapters>(EXTRA_CHAPTER)
+					?.chapters?.singleOrNull() ?: return,
+			)
+
+			ACTION_PREFETCH_LAST -> prefetchLast()
+		}
+	}
+
+	override fun onError(startId: Int, error: Throwable) = Unit
+
+	private suspend fun prefetchDetails(manga: Manga) {
+		val source = mangaRepositoryFactory.create(manga.source)
+		runCatchingCancellable { source.getDetails(manga) }
+	}
+
+	private suspend fun prefetchPages(chapter: MangaChapter) {
+		val source = mangaRepositoryFactory.create(chapter.source)
+		runCatchingCancellable { source.getPages(chapter) }
+	}
+
+	private suspend fun prefetchLast() {
+		val last = historyRepository.getLastOrNull() ?: return
+		if (last.source == MangaSource.LOCAL) return
+		val repo = mangaRepositoryFactory.create(last.source)
+		val details = runCatchingCancellable { repo.getDetails(last) }.getOrNull() ?: return
+		val chapters = details.chapters
+		if (chapters.isNullOrEmpty()) {
+			return
+		}
+		val history = historyRepository.getOne(last)
+		val chapter = if (history == null) {
+			chapters.firstOrNull()
+		} else {
+			chapters.find { x -> x.id == history.chapterId } ?: chapters.firstOrNull()
+		} ?: return
+		runCatchingCancellable { repo.getPages(chapter) }
+	}
+
+	companion object {
+
+		private const val EXTRA_MANGA = "manga"
+		private const val EXTRA_CHAPTER = "manga"
+		private const val ACTION_PREFETCH_DETAILS = "details"
+		private const val ACTION_PREFETCH_PAGES = "pages"
+		private const val ACTION_PREFETCH_LAST = "last"
+
+		fun prefetchDetails(context: Context, manga: Manga) {
+			if (!isPrefetchAvailable(context, manga.source)) return
+			val intent = Intent(context, MangaPrefetchService::class.java)
+			intent.action = ACTION_PREFETCH_DETAILS
+			intent.putExtra(EXTRA_MANGA, ParcelableManga(manga, withChapters = false))
+			context.startService(intent)
+		}
+
+		fun prefetchPages(context: Context, chapter: MangaChapter) {
+			if (!isPrefetchAvailable(context, chapter.source)) return
+			val intent = Intent(context, MangaPrefetchService::class.java)
+			intent.action = ACTION_PREFETCH_PAGES
+			intent.putExtra(EXTRA_CHAPTER, ParcelableMangaChapters(listOf(chapter)))
+			context.startService(intent)
+		}
+
+		fun prefetchLast(context: Context) {
+			if (!isPrefetchAvailable(context, null)) return
+			val intent = Intent(context, MangaPrefetchService::class.java)
+			intent.action = ACTION_PREFETCH_LAST
+			context.startService(intent)
+		}
+
+		private fun isPrefetchAvailable(context: Context, source: MangaSource?): Boolean {
+			if (source == MangaSource.LOCAL) {
+				return false
+			}
+			val entryPoint = EntryPointAccessors.fromApplication(context, PrefetchCompanionEntryPoint::class.java)
+			return entryPoint.contentCache.isCachingEnabled && entryPoint.settings.isContentPrefetchEnabled()
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/details/service/PrefetchCompanionEntryPoint.kt

@@ -0,0 +1,14 @@
+package org.koitharu.kotatsu.details.service
+
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import org.koitharu.kotatsu.core.cache.ContentCache
+import org.koitharu.kotatsu.core.prefs.AppSettings
+
+@EntryPoint
+@InstallIn(SingletonComponent::class)
+interface PrefetchCompanionEntryPoint {
+	val settings: AppSettings
+	val contentCache: ContentCache
+}

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

@@ -1,17 +1,16 @@
 package org.koitharu.kotatsu.details.ui
 
 import android.os.Bundle
-import android.view.*
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
 import androidx.appcompat.view.ActionMode
-import androidx.coordinatorlayout.widget.CoordinatorLayout
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
-import androidx.core.view.updateLayoutParams
-import androidx.core.view.updatePadding
 import androidx.fragment.app.activityViewModels
-import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.snackbar.Snackbar
-import kotlin.math.roundToInt
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseFragment
 import org.koitharu.kotatsu.base.ui.list.ListSelectionController
@@ -26,8 +25,8 @@ import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.reader.ui.ReaderActivity
 import org.koitharu.kotatsu.reader.ui.ReaderState
 import org.koitharu.kotatsu.utils.RecyclerViewScrollCallback
-import org.koitharu.kotatsu.utils.ext.parents
 import org.koitharu.kotatsu.utils.ext.scaleUpActivityOptionsOf
+import kotlin.math.roundToInt
 
 class ChaptersFragment :
 	BaseFragment<FragmentChaptersBinding>(),
@@ -104,6 +103,7 @@ class ChaptersFragment :
 				mode.finish()
 				true
 			}
+
 			R.id.action_delete -> {
 				val ids = selectionController?.peekCheckedIds()
 				val manga = viewModel.manga.value
@@ -122,6 +122,7 @@ class ChaptersFragment :
 				mode.finish()
 				true
 			}
+
 			R.id.action_select_range -> {
 				val items = chaptersAdapter?.items ?: return false
 				val ids = HashSet(controller.peekCheckedIds())
@@ -141,11 +142,20 @@ class ChaptersFragment :
 				controller.addAll(ids)
 				true
 			}
+
 			R.id.action_select_all -> {
 				val ids = chaptersAdapter?.items?.map { it.chapter.id } ?: return false
-				selectionController?.addAll(ids)
+				controller.addAll(ids)
 				true
 			}
+
+			R.id.action_mark_current -> {
+				val id = controller.peekCheckedIds().singleOrNull() ?: return false
+				viewModel.markChapterAsCurrent(id)
+				mode.finish()
+				true
+			}
+
 			else -> false
 		}
 	}
@@ -166,6 +176,7 @@ class ChaptersFragment :
 			x.chapter.source == MangaSource.LOCAL
 		}
 		menu.findItem(R.id.action_select_all).isVisible = items.size < allItems.size
+		menu.findItem(R.id.action_mark_current).isVisible = items.size == 1
 		mode.title = items.size.toString()
 		var hasGap = false
 		for (i in 0 until items.size - 1) {
@@ -202,18 +213,4 @@ class ChaptersFragment :
 	private fun onLoadingStateChanged(isLoading: Boolean) {
 		binding.progressBar.isVisible = isLoading
 	}
-
-	private fun findBottomSheetBehavior(): BottomSheetBehavior<*>? {
-		val v = view ?: return null
-		for (p in v.parents) {
-			val layoutParams = (p as? View)?.layoutParams
-			if (layoutParams is CoordinatorLayout.LayoutParams) {
-				val behavior = layoutParams.behavior
-				if (behavior is BottomSheetBehavior<*>) {
-					return behavior
-				}
-			}
-		}
-		return null
-	}
 }

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

@@ -23,8 +23,8 @@ 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_search)?.isVisible = viewModel.isChaptersEmpty.value == false
 	}
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean = when (menuItem.itemId) {

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

@@ -18,13 +18,12 @@ import androidx.core.graphics.Insets
 import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
+import androidx.lifecycle.Observer
 import androidx.lifecycle.lifecycleScope
-import com.google.android.material.badge.BadgeDrawable
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.snackbar.BaseTransientBottomBar
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.MangaIntent
@@ -35,14 +34,21 @@ import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
 import org.koitharu.kotatsu.core.os.ShortcutsUpdater
 import org.koitharu.kotatsu.core.ui.MangaErrorDialog
 import org.koitharu.kotatsu.databinding.ActivityDetailsBinding
+import org.koitharu.kotatsu.details.service.MangaPrefetchService
+import org.koitharu.kotatsu.details.ui.model.ChapterListItem
 import org.koitharu.kotatsu.details.ui.model.HistoryInfo
 import org.koitharu.kotatsu.download.ui.service.DownloadService
-import org.koitharu.kotatsu.list.ui.adapter.bindBadge
 import org.koitharu.kotatsu.main.ui.owners.NoModalBottomSheetOwner
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.reader.ui.ReaderActivity
 import org.koitharu.kotatsu.reader.ui.ReaderState
-import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.ViewBadge
+import org.koitharu.kotatsu.utils.ext.assistedViewModels
+import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.isReportable
+import org.koitharu.kotatsu.utils.ext.setNavigationBarTransparentCompat
+import org.koitharu.kotatsu.utils.ext.textAndVisible
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class DetailsActivity :
@@ -60,7 +66,7 @@ class DetailsActivity :
 	@Inject
 	lateinit var shortcutsUpdater: ShortcutsUpdater
 
-	private var badge: BadgeDrawable? = null
+	private lateinit var viewBadge: ViewBadge
 
 	private val viewModel: DetailsViewModel by assistedViewModels {
 		viewModelFactory.create(MangaIntent(intent))
@@ -83,6 +89,7 @@ class DetailsActivity :
 		}
 		binding.buttonRead.setOnClickListener(this)
 		binding.buttonDropdown.setOnClickListener(this)
+		viewBadge = ViewBadge(binding.buttonRead, this)
 
 		chaptersMenuProvider = if (binding.layoutBottom != null) {
 			val bsMediator = ChaptersBottomSheetMediator(checkNotNull(binding.layoutBottom))
@@ -116,6 +123,7 @@ class DetailsActivity :
 		viewModel.branches.observe(this) {
 			binding.buttonDropdown.isVisible = it.size > 1
 		}
+		viewModel.chapters.observe(this, PrefetchObserver(this))
 
 		registerReceiver(downloadReceiver, IntentFilter(DownloadService.ACTION_DOWNLOAD_COMPLETE))
 		addMenuProvider(
@@ -151,6 +159,7 @@ class DetailsActivity :
 					)
 				}
 			}
+
 			R.id.button_dropdown -> showBranchPopupMenu()
 		}
 	}
@@ -188,10 +197,12 @@ class DetailsActivity :
 			ExceptionResolver.canResolve(e) -> {
 				resolveError(e)
 			}
+
 			manga == null -> {
 				Toast.makeText(this, e.getDisplayMessage(resources), Toast.LENGTH_LONG).show()
 				finishAfterTransition()
 			}
+
 			else -> {
 				val snackbar = makeSnackbar(
 					e.getDisplayMessage(resources),
@@ -221,18 +232,18 @@ class DetailsActivity :
 		}
 	}
 
-	private fun onHistoryChanged(info: HistoryInfo?) {
+	private fun onHistoryChanged(info: HistoryInfo) {
 		with(binding.buttonRead) {
-			if (info?.history != null) {
+			if (info.history != null) {
 				setText(R.string._continue)
-				setIconResource(R.drawable.ic_play)
+				setIconResource(if (info.isIncognitoMode) R.drawable.ic_incognito else R.drawable.ic_play)
 			} else {
 				setText(R.string.read)
-				setIconResource(R.drawable.ic_read)
+				setIconResource(if (info.isIncognitoMode) R.drawable.ic_incognito else R.drawable.ic_play)
 			}
 		}
 		val text = when {
-			info == null -> getString(R.string.loading_)
+			!info.isValid -> getString(R.string.loading_)
 			info.currentChapter >= 0 -> getString(R.string.chapter_d_of_d, info.currentChapter + 1, info.totalChapters)
 			info.totalChapters == 0 -> getString(R.string.no_chapters)
 			else -> resources.getQuantityString(R.plurals.chapters, info.totalChapters, info.totalChapters)
@@ -242,7 +253,7 @@ class DetailsActivity :
 	}
 
 	private fun onNewChaptersChanged(newChapters: Int) {
-		badge = binding.buttonRead.bindBadge(badge, newChapters)
+		viewBadge.counter = newChapters
 	}
 
 	fun showChapterMissingDialog(chapterId: Long) {
@@ -318,6 +329,24 @@ class DetailsActivity :
 		return sb
 	}
 
+	private class PrefetchObserver(
+		private val context: Context,
+	) : Observer<List<ChapterListItem>> {
+
+		private var isCalled = false
+
+		override fun onChanged(t: List<ChapterListItem>?) {
+			if (t.isNullOrEmpty()) {
+				return
+			}
+			if (!isCalled) {
+				isCalled = true
+				val item = t.find { it.hasFlag(ChapterListItem.FLAG_CURRENT) } ?: t.first()
+				MangaPrefetchService.prefetchPages(context, item.chapter)
+			}
+		}
+	}
+
 	companion object {
 
 		fun newIntent(context: Context, manga: Manga): Intent {

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

@@ -18,7 +18,6 @@ import coil.request.ImageRequest
 import coil.util.CoilUtils
 import com.google.android.material.chip.Chip
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseFragment
@@ -27,9 +26,9 @@ import org.koitharu.kotatsu.base.ui.list.decor.SpacingItemDecoration
 import org.koitharu.kotatsu.base.ui.widgets.ChipsView
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.bookmarks.ui.adapter.BookmarksAdapter
-import org.koitharu.kotatsu.core.model.MangaHistory
 import org.koitharu.kotatsu.databinding.FragmentDetailsBinding
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem
+import org.koitharu.kotatsu.details.ui.model.HistoryInfo
 import org.koitharu.kotatsu.details.ui.scrobbling.ScrobblingItemDecoration
 import org.koitharu.kotatsu.details.ui.scrobbling.ScrollingInfoAdapter
 import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
@@ -45,8 +44,20 @@ import org.koitharu.kotatsu.scrobbling.domain.model.ScrobblingInfo
 import org.koitharu.kotatsu.search.ui.MangaListActivity
 import org.koitharu.kotatsu.search.ui.SearchActivity
 import org.koitharu.kotatsu.utils.FileSize
-import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.ext.computeSize
+import org.koitharu.kotatsu.utils.ext.crossfade
+import org.koitharu.kotatsu.utils.ext.drawableTop
+import org.koitharu.kotatsu.utils.ext.enqueueWith
+import org.koitharu.kotatsu.utils.ext.ifNullOrEmpty
+import org.koitharu.kotatsu.utils.ext.measureHeight
+import org.koitharu.kotatsu.utils.ext.referer
+import org.koitharu.kotatsu.utils.ext.resolveDp
+import org.koitharu.kotatsu.utils.ext.scaleUpActivityOptionsOf
+import org.koitharu.kotatsu.utils.ext.textAndVisible
+import org.koitharu.kotatsu.utils.ext.toFileOrNull
+import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
 import org.koitharu.kotatsu.utils.image.CoverSizeResolver
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class DetailsFragment :
@@ -75,7 +86,7 @@ class DetailsFragment :
 		binding.chipsTags.onChipClickListener = this
 		viewModel.manga.observe(viewLifecycleOwner, ::onMangaUpdated)
 		viewModel.isLoading.observe(viewLifecycleOwner, ::onLoadingStateChanged)
-		viewModel.readingHistory.observe(viewLifecycleOwner, ::onHistoryChanged)
+		viewModel.historyInfo.observe(viewLifecycleOwner, ::onHistoryChanged)
 		viewModel.bookmarks.observe(viewLifecycleOwner, ::onBookmarksChanged)
 		viewModel.scrobblingInfo.observe(viewLifecycleOwner, ::onScrobblingInfoChanged)
 		viewModel.description.observe(viewLifecycleOwner, ::onDescriptionChanged)
@@ -123,12 +134,14 @@ class DetailsFragment :
 						drawableTop = ContextCompat.getDrawable(context, R.drawable.ic_state_finished)
 					}
 				}
+
 				MangaState.ONGOING -> {
 					infoLayout.textViewState.apply {
 						textAndVisible = resources.getString(R.string.state_ongoing)
 						drawableTop = ContextCompat.getDrawable(context, R.drawable.ic_state_ongoing)
 					}
 				}
+
 				else -> infoLayout.textViewState.isVisible = false
 			}
 			if (manga.source == MangaSource.LOCAL) {
@@ -178,8 +191,8 @@ class DetailsFragment :
 		}
 	}
 
-	private fun onHistoryChanged(history: MangaHistory?) {
-		binding.progressView.setPercent(history?.percent ?: PROGRESS_NONE, animate = true)
+	private fun onHistoryChanged(history: HistoryInfo) {
+		binding.progressView.setPercent(history.history?.percent ?: PROGRESS_NONE, animate = true)
 	}
 
 	private fun onLoadingStateChanged(isLoading: Boolean) {
@@ -229,6 +242,7 @@ class DetailsFragment :
 					),
 				)
 			}
+
 			R.id.textView_source -> {
 				startActivity(
 					MangaListActivity.newIntent(
@@ -237,6 +251,7 @@ class DetailsFragment :
 					),
 				)
 			}
+
 			R.id.imageView_cover -> {
 				startActivity(
 					ImageActivity.newIntent(v.context, manga.largeCoverUrl.ifNullOrEmpty { manga.coverUrl }),
@@ -249,7 +264,7 @@ class DetailsFragment :
 	override fun onLongClick(v: View): Boolean {
 		when (v.id) {
 			R.id.button_read -> {
-				if (viewModel.readingHistory.value == null) {
+				if (viewModel.historyInfo.value?.history == null) {
 					return false
 				}
 				val menu = PopupMenu(v.context, v)
@@ -271,12 +286,14 @@ class DetailsFragment :
 							)
 							true
 						}
+
 						else -> false
 					}
 				}
 				menu.show()
 				return true
 			}
+
 			else -> return false
 		}
 	}

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

@@ -13,10 +13,18 @@ import androidx.lifecycle.viewModelScope
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
-import java.io.IOException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChangedBy
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.transformLatest
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.R
@@ -45,6 +53,8 @@ import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.asFlowLiveData
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
+import java.io.IOException
 
 class DetailsViewModel @AssistedInject constructor(
 	@Assisted intent: MangaIntent,
@@ -79,8 +89,14 @@ class DetailsViewModel @AssistedInject constructor(
 	private val favourite = favouritesRepository.observeCategoriesIds(delegate.mangaId).map { it.isNotEmpty() }
 		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, false)
 
-	private val newChapters = trackingRepository.observeNewChaptersCount(delegate.mangaId)
-		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, 0)
+	private val newChapters = settings.observeAsFlow(AppSettings.KEY_TRACKER_ENABLED) { isTrackerEnabled }
+		.flatMapLatest { isEnabled ->
+			if (isEnabled) {
+				trackingRepository.observeNewChaptersCount(delegate.mangaId)
+			} else {
+				flowOf(0)
+			}
+		}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, 0)
 
 	private val chaptersQuery = MutableStateFlow("")
 
@@ -90,17 +106,18 @@ class DetailsViewModel @AssistedInject constructor(
 	val manga = delegate.manga.filterNotNull().asLiveData(viewModelScope.coroutineContext)
 	val favouriteCategories = favourite.asLiveData(viewModelScope.coroutineContext)
 	val newChaptersCount = newChapters.asLiveData(viewModelScope.coroutineContext)
-
-	@Deprecated("")
-	val readingHistory = history.asLiveData(viewModelScope.coroutineContext)
 	val isChaptersReversed = chaptersReversed.asLiveData(viewModelScope.coroutineContext)
 
-	val historyInfo = combine(
+	val historyInfo: LiveData<HistoryInfo> = combine(
 		delegate.manga,
 		history,
-	) { m, h ->
-		HistoryInfo(m, h)
-	}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, null)
+		historyRepository.observeShouldSkip(delegate.manga),
+	) { m, h, im ->
+		HistoryInfo(m, h, im)
+	}.asFlowLiveData(
+		context = viewModelScope.coroutineContext + Dispatchers.Default,
+		defaultValue = HistoryInfo(null, null, false),
+	)
 
 	val bookmarks = delegate.manga.flatMapLatest {
 		if (it != null) bookmarksRepository.observeBookmarks(it) else flowOf(emptyList())
@@ -189,7 +206,7 @@ class DetailsViewModel @AssistedInject constructor(
 			checkNotNull(manga) { "Cannot find saved manga for ${m.title}" }
 			val original = localMangaRepository.getRemoteManga(manga)
 			localMangaRepository.delete(manga) || throw IOException("Unable to delete file")
-			runCatching {
+			runCatchingCancellable {
 				historyRepository.deleteOrSwap(manga, original)
 			}
 			onMangaRemoved.postCall(manga)
@@ -228,7 +245,7 @@ class DetailsViewModel @AssistedInject constructor(
 			reload()
 		} else {
 			viewModelScope.launch(Dispatchers.Default) {
-				runCatching {
+				runCatchingCancellable {
 					localMangaRepository.getDetails(downloadedManga)
 				}.onSuccess {
 					delegate.relatedManga.value = it
@@ -264,6 +281,17 @@ class DetailsViewModel @AssistedInject constructor(
 		}
 	}
 
+	fun markChapterAsCurrent(chapterId: Long) {
+		launchJob(Dispatchers.Default) {
+			val manga = checkNotNull(delegate.manga.value)
+			val chapters = checkNotNull(manga.chapters)
+			val chapterIndex = chapters.indexOfFirst { it.id == chapterId }
+			check(chapterIndex in chapters.indices) { "Chapter not found" }
+			val percent = chapterIndex / chapters.size.toFloat()
+			historyRepository.addOrUpdate(manga = manga, chapterId = chapterId, page = 0, scroll = 0, percent = percent)
+		}
+	}
+
 	private fun doLoad() = launchLoadingJob(Dispatchers.Default) {
 		delegate.doLoad()
 	}

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

@@ -17,6 +17,7 @@ import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
 class MangaDetailsDelegate(
 	private val intent: MangaIntent,
@@ -45,9 +46,9 @@ class MangaDetailsDelegate(
 		val hist = historyRepository.getOne(manga)
 		selectedBranch.value = manga.getPreferredBranch(hist)
 		mangaData.value = manga
-		relatedManga.value = runCatching {
+		relatedManga.value = runCatchingCancellable {
 			if (manga.source == MangaSource.LOCAL) {
-				val m = localMangaRepository.getRemoteManga(manga) ?: return@runCatching null
+				val m = localMangaRepository.getRemoteManga(manga) ?: return@runCatchingCancellable null
 				mangaRepositoryFactory.create(m.source).getDetails(m)
 			} else {
 				localMangaRepository.findSavedManga(manga)

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

@@ -34,7 +34,7 @@ fun chapterListItemAD(
 		when (item.status) {
 			FLAG_UNREAD -> {
 				binding.textViewNumber.setBackgroundResource(R.drawable.bg_badge_default)
-				binding.textViewNumber.setTextColor(context.getThemeColor(android.R.attr.textColorSecondaryInverse))
+				binding.textViewNumber.setTextColor(context.getThemeColor(com.google.android.material.R.attr.colorOnTertiary))
 			}
 			FLAG_CURRENT -> {
 				binding.textViewNumber.setBackgroundResource(R.drawable.bg_badge_accent)
@@ -53,4 +53,4 @@ fun chapterListItemAD(
 		binding.imageViewDownloaded.isVisible = item.hasFlag(FLAG_DOWNLOADED)
 		binding.imageViewNew.isVisible = item.hasFlag(FLAG_NEW)
 	}
-}
+}

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

@@ -42,7 +42,8 @@ class ChaptersAdapter(
 		}
 	}
 
-	override fun getSectionText(context: Context, position: Int): CharSequence {
-		return items[position].chapter.number.toString()
+	override fun getSectionText(context: Context, position: Int): CharSequence? {
+		val item = items.getOrNull(position) ?: return null
+		return item.chapter.number.toString()
 	}
-}
+}

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

@@ -7,8 +7,12 @@ class HistoryInfo(
 	val totalChapters: Int,
 	val currentChapter: Int,
 	val history: MangaHistory?,
+	val isIncognitoMode: Boolean,
 ) {
 
+	val isValid: Boolean
+		get() = totalChapters >= 0
+
 	override fun equals(other: Any?): Boolean {
 		if (this === other) return true
 		if (javaClass != other?.javaClass) return false
@@ -18,6 +22,7 @@ class HistoryInfo(
 		if (totalChapters != other.totalChapters) return false
 		if (currentChapter != other.currentChapter) return false
 		if (history != other.history) return false
+		if (isIncognitoMode != other.isIncognitoMode) return false
 
 		return true
 	}
@@ -26,20 +31,21 @@ class HistoryInfo(
 		var result = totalChapters
 		result = 31 * result + currentChapter
 		result = 31 * result + (history?.hashCode() ?: 0)
+		result = 31 * result + isIncognitoMode.hashCode()
 		return result
 	}
 }
 
-@Suppress("FunctionName")
-fun HistoryInfo(manga: Manga?, history: MangaHistory?): HistoryInfo? {
-	val chapters = manga?.chapters ?: return null
+fun HistoryInfo(manga: Manga?, history: MangaHistory?, isIncognitoMode: Boolean): HistoryInfo {
+	val chapters = manga?.chapters
 	return HistoryInfo(
-		totalChapters = chapters.size,
-		currentChapter = if (history != null) {
+		totalChapters = chapters?.size ?: -1,
+		currentChapter = if (history != null && !chapters.isNullOrEmpty()) {
 			chapters.indexOfFirst { it.id == history.chapterId }
 		} else {
 			-1
 		},
 		history = history,
+		isIncognitoMode = isIncognitoMode,
 	)
 }

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

@@ -9,11 +9,17 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import dagger.hilt.android.qualifiers.ApplicationContext
-import java.io.File
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
+import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.internal.closeQuietly
@@ -29,10 +35,13 @@ import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.util.await
+import org.koitharu.kotatsu.utils.ext.copyToSuspending
 import org.koitharu.kotatsu.utils.ext.deleteAwait
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.referer
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 import org.koitharu.kotatsu.utils.progress.PausingProgressJob
+import java.io.File
 
 private const val MAX_FAILSAFE_ATTEMPTS = 2
 private const val DOWNLOAD_ERROR_DELAY = 500L
@@ -155,7 +164,7 @@ class DownloadManager @AssistedInject constructor(
 					}
 					outState.value = DownloadState.PostProcessing(startId, data, cover)
 					output.mergeWithExisting()
-					output.finalize()
+					output.finish()
 					val localManga = localMangaRepository.getFromFile(output.file)
 					outState.value = DownloadState.Done(startId, data, cover, localManga)
 				} catch (e: CancellationException) {
@@ -210,10 +219,8 @@ class DownloadManager @AssistedInject constructor(
 		val call = okHttp.newCall(request)
 		val file = File(destination, tempFileName)
 		val response = call.clone().await()
-		runInterruptible(Dispatchers.IO) {
-			file.outputStream().use { out ->
-				checkNotNull(response.body).byteStream().copyTo(out)
-			}
+		file.outputStream().use { out ->
+			checkNotNull(response.body).byteStream().copyToSuspending(out)
 		}
 		return file
 	}
@@ -231,7 +238,7 @@ class DownloadManager @AssistedInject constructor(
 			)
 		}
 
-	private suspend fun loadCover(manga: Manga) = runCatching {
+	private suspend fun loadCover(manga: Manga) = runCatchingCancellable {
 		imageLoader.execute(
 			ImageRequest.Builder(context)
 				.data(manga.coverUrl)

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

@@ -34,7 +34,7 @@ class DownloadsActivity : BaseActivity<ActivityDownloadsBinding>() {
 		setContentView(ActivityDownloadsBinding.inflate(layoutInflater))
 		supportActionBar?.setDisplayHomeAsUpEnabled(true)
 		val adapter = DownloadsAdapter(lifecycleScope, coil)
-		val spacing = resources.getDimensionPixelOffset(R.dimen.grid_spacing)
+		val spacing = resources.getDimensionPixelOffset(R.dimen.list_spacing)
 		binding.recyclerView.addItemDecoration(SpacingItemDecoration(spacing))
 		binding.recyclerView.setHasFixedSize(true)
 		binding.recyclerView.adapter = adapter

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

@@ -16,10 +16,12 @@ import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import dagger.hilt.android.AndroidEntryPoint
-import java.util.concurrent.TimeUnit
-import javax.inject.Inject
-import kotlin.collections.set
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.transformWhile
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.R
@@ -28,10 +30,14 @@ import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
 import org.koitharu.kotatsu.download.domain.DownloadManager
 import org.koitharu.kotatsu.download.domain.DownloadState
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.utils.ext.getParcelableExtraCompat
 import org.koitharu.kotatsu.utils.ext.throttle
 import org.koitharu.kotatsu.utils.progress.PausingProgressJob
 import org.koitharu.kotatsu.utils.progress.ProgressJob
 import org.koitharu.kotatsu.utils.progress.TimeLeftEstimator
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+import kotlin.collections.set
 
 @AndroidEntryPoint
 class DownloadService : BaseService() {
@@ -65,7 +71,7 @@ class DownloadService : BaseService() {
 
 	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
 		super.onStartCommand(intent, flags, startId)
-		val manga = intent?.getParcelableExtra<ParcelableManga>(EXTRA_MANGA)?.manga
+		val manga = intent?.getParcelableExtraCompat<ParcelableManga>(EXTRA_MANGA)?.manga
 		val chapters = intent?.getLongArrayExtra(EXTRA_CHAPTERS_IDS)
 		return if (manga != null) {
 			jobs[startId] = downloadManga(startId, manga, chapters)
@@ -84,7 +90,9 @@ class DownloadService : BaseService() {
 
 	override fun onDestroy() {
 		unregisterReceiver(controlReceiver)
-		wakeLock.release()
+		if (wakeLock.isHeld) {
+			wakeLock.release()
+		}
 		isRunning = false
 		super.onDestroy()
 	}
@@ -168,6 +176,7 @@ class DownloadService : BaseService() {
 					val cancelId = intent.getIntExtra(EXTRA_CANCEL_ID, 0)
 					jobs[cancelId]?.cancel()
 				}
+
 				ACTION_DOWNLOAD_RESUME -> {
 					val cancelId = intent.getIntExtra(EXTRA_CANCEL_ID, 0)
 					jobs[cancelId]?.resume()
@@ -254,7 +263,7 @@ class DownloadService : BaseService() {
 
 		fun getDownloadedManga(intent: Intent?): Manga? {
 			if (intent?.action == ACTION_DOWNLOAD_COMPLETE) {
-				return intent.getParcelableExtra<ParcelableManga>(EXTRA_MANGA)?.manga
+				return intent.getParcelableExtraCompat<ParcelableManga>(EXTRA_MANGA)?.manga
 			}
 			return null
 		}

app/src/main/java/org/koitharu/kotatsu/explore/ui/ExploreFragment.kt

@@ -2,8 +2,10 @@ package org.koitharu.kotatsu.explore.ui
 
 import android.os.Bundle
 import android.view.LayoutInflater
+import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
+import androidx.appcompat.widget.PopupMenu
 import androidx.core.graphics.Insets
 import androidx.core.view.updatePadding
 import androidx.fragment.app.viewModels
@@ -11,11 +13,12 @@ import androidx.recyclerview.widget.RecyclerView
 import coil.ImageLoader
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.domain.reverseAsync
 import org.koitharu.kotatsu.base.ui.BaseFragment
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.base.ui.util.RecyclerViewOwner
+import org.koitharu.kotatsu.base.ui.util.ReversibleAction
 import org.koitharu.kotatsu.bookmarks.ui.BookmarksActivity
 import org.koitharu.kotatsu.databinding.FragmentExploreBinding
 import org.koitharu.kotatsu.details.ui.DetailsActivity
@@ -31,6 +34,7 @@ import org.koitharu.kotatsu.search.ui.MangaListActivity
 import org.koitharu.kotatsu.settings.SettingsActivity
 import org.koitharu.kotatsu.suggestions.ui.SuggestionsActivity
 import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class ExploreFragment :
@@ -67,6 +71,7 @@ class ExploreFragment :
 		}
 		viewModel.onError.observe(viewLifecycleOwner, ::onError)
 		viewModel.onOpenManga.observe(viewLifecycleOwner, ::onOpenManga)
+		viewModel.onActionDone.observe(viewLifecycleOwner, ::onActionDone)
 	}
 
 	override fun onDestroyView() {
@@ -95,6 +100,7 @@ class ExploreFragment :
 				viewModel.openRandom()
 				return
 			}
+
 			else -> return
 		}
 		startActivity(intent)
@@ -105,6 +111,14 @@ class ExploreFragment :
 		startActivity(intent)
 	}
 
+	override fun onItemLongClick(item: ExploreItem.Source, view: View): Boolean {
+		val menu = PopupMenu(view.context, view)
+		menu.inflate(R.menu.popup_source)
+		menu.setOnMenuItemClickListener(SourceMenuListener(item))
+		menu.show()
+		return true
+	}
+
 	override fun onRetryClick(error: Throwable) = Unit
 
 	override fun onEmptyActionClick() = onManageClick(requireView())
@@ -124,6 +138,37 @@ class ExploreFragment :
 		startActivity(intent)
 	}
 
+	private fun onActionDone(action: ReversibleAction) {
+		val handle = action.handle
+		val length = if (handle == null) Snackbar.LENGTH_SHORT else Snackbar.LENGTH_LONG
+		val snackbar = Snackbar.make(binding.recyclerView, action.stringResId, length)
+		if (handle != null) {
+			snackbar.setAction(R.string.undo) { handle.reverseAsync() }
+		}
+		snackbar.anchorView = (activity as? BottomNavOwner)?.bottomNav
+		snackbar.show()
+	}
+
+	private inner class SourceMenuListener(
+		private val sourceItem: ExploreItem.Source,
+	) : PopupMenu.OnMenuItemClickListener {
+
+		override fun onMenuItemClick(item: MenuItem): Boolean {
+			when (item.itemId) {
+				R.id.action_settings -> {
+					startActivity(SettingsActivity.newSourceSettingsIntent(requireContext(), sourceItem.source))
+				}
+
+				R.id.action_hide -> {
+					viewModel.hideSource(sourceItem.source)
+				}
+
+				else -> return false
+			}
+			return true
+		}
+	}
+
 	companion object {
 
 		fun newInstance() = ExploreFragment()

app/src/main/java/org/koitharu/kotatsu/explore/ui/ExploreViewModel.kt

@@ -4,11 +4,17 @@ import androidx.lifecycle.LiveData
 import androidx.lifecycle.asFlow
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onStart
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.domain.ReversibleHandle
 import org.koitharu.kotatsu.base.ui.BaseViewModel
+import org.koitharu.kotatsu.base.ui.util.ReversibleAction
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.explore.domain.ExploreRepository
 import org.koitharu.kotatsu.explore.ui.model.ExploreItem
@@ -16,6 +22,7 @@ import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
+import javax.inject.Inject
 
 @HiltViewModel
 class ExploreViewModel @Inject constructor(
@@ -24,6 +31,7 @@ class ExploreViewModel @Inject constructor(
 ) : BaseViewModel() {
 
 	val onOpenManga = SingleLiveEvent<Manga>()
+	val onActionDone = SingleLiveEvent<ReversibleAction>()
 
 	val content: LiveData<List<ExploreItem>> = isLoading.asFlow().flatMapLatest { loading ->
 		if (loading) {
@@ -40,6 +48,16 @@ class ExploreViewModel @Inject constructor(
 		}
 	}
 
+	fun hideSource(source: MangaSource) {
+		launchJob(Dispatchers.Default) {
+			settings.hiddenSources += source.name
+			val rollback = ReversibleHandle {
+				settings.hiddenSources -= source.name
+			}
+			onActionDone.postCall(ReversibleAction(R.string.source_disabled, rollback))
+		}
+	}
+
 	private fun createContentFlow() = settings.observe()
 		.filter {
 			it == AppSettings.KEY_SOURCES_HIDDEN ||
@@ -61,7 +79,7 @@ class ExploreViewModel @Inject constructor(
 			sources.mapTo(result) { ExploreItem.Source(it) }
 		} else {
 			result += ExploreItem.EmptyHint(
-				icon = R.drawable.ic_empty_search,
+				icon = R.drawable.ic_empty_common,
 				textPrimary = R.string.no_manga_sources,
 				textSecondary = R.string.no_manga_sources_text,
 				actionStringRes = R.string.manage,

app/src/main/java/org/koitharu/kotatsu/explore/ui/model/ExploreItem.kt

@@ -1,6 +1,5 @@
 package org.koitharu.kotatsu.explore.ui.model
 
-import android.net.Uri
 import androidx.annotation.DrawableRes
 import androidx.annotation.StringRes
 import org.koitharu.kotatsu.list.ui.model.EmptyState
@@ -73,6 +72,7 @@ sealed interface ExploreItem : ListModel {
 		}
 	}
 
+	@Deprecated("")
 	class EmptyHint(
 		@DrawableRes icon: Int,
 		@StringRes textPrimary: Int,
@@ -81,4 +81,4 @@ sealed interface ExploreItem : ListModel {
 	) : EmptyState(icon, textPrimary, textSecondary, actionStringRes), ExploreItem
 
 	object Loading : ExploreItem
-}
+}

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

@@ -21,9 +21,6 @@ abstract class FavouriteCategoriesDao {
 	@Insert(onConflict = OnConflictStrategy.ABORT)
 	abstract suspend fun insert(category: FavouriteCategoryEntity): Long
 
-	@Update
-	abstract suspend fun update(category: FavouriteCategoryEntity): Int
-
 	suspend fun delete(id: Long) = setDeletedAt(id, System.currentTimeMillis())
 
 	@Query("UPDATE favourite_categories SET title = :title, `order` = :order, `track` = :tracker  WHERE category_id = :id")
@@ -51,12 +48,8 @@ abstract class FavouriteCategoriesDao {
 		return (getMaxSortKey() ?: 0) + 1
 	}
 
-	@Transaction
-	open suspend fun upsert(entity: FavouriteCategoryEntity) {
-		if (update(entity) == 0) {
-			insert(entity)
-		}
-	}
+	@Upsert
+	abstract suspend fun upsert(entity: FavouriteCategoryEntity)
 
 	@Query("UPDATE favourite_categories SET deleted_at = :deletedAt WHERE category_id = :id")
 	protected abstract suspend fun setDeletedAt(id: Long, deletedAt: Long)

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

@@ -99,11 +99,6 @@ abstract class FavouritesDao {
 	@Insert(onConflict = OnConflictStrategy.REPLACE)
 	abstract suspend fun insert(favourite: FavouriteEntity)
 
-	/** UPDATE **/
-
-	@Update
-	abstract suspend fun update(favourite: FavouriteEntity): Int
-
 	/** DELETE **/
 
 	suspend fun delete(mangaId: Long) = setDeletedAt(
@@ -138,12 +133,8 @@ abstract class FavouritesDao {
 
 	/** TOOLS **/
 
-	@Transaction
-	open suspend fun upsert(entity: FavouriteEntity) {
-		if (update(entity) == 0) {
-			insert(entity)
-		}
-	}
+	@Upsert
+	abstract suspend fun upsert(entity: FavouriteEntity)
 
 	@Transaction
 	@RawQuery(observedEntities = [FavouriteEntity::class])
@@ -166,6 +157,7 @@ abstract class FavouritesDao {
 		SortOrder.NEWEST,
 		SortOrder.UPDATED,
 		-> "created_at DESC"
+
 		SortOrder.ALPHABETICAL -> "title ASC"
 		else -> throw IllegalArgumentException("Sort order $sortOrder is not supported")
 	}

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

@@ -13,6 +13,7 @@ import org.koitharu.kotatsu.core.model.FavouriteCategory
 import org.koitharu.kotatsu.databinding.ActivityContainerBinding
 import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment
 import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment.Companion.NO_ID
+import kotlin.text.Typography.dagger
 
 @AndroidEntryPoint
 class FavouritesActivity : BaseActivity<ActivityContainerBinding>() {
@@ -28,6 +29,7 @@ class FavouritesActivity : BaseActivity<ActivityContainerBinding>() {
 		val fm = supportFragmentManager
 		if (fm.findFragmentById(R.id.container) == null) {
 			fm.commit {
+				setReorderingAllowed(true)
 				val fragment = FavouritesListFragment.newInstance(intent.getLongExtra(EXTRA_CATEGORY_ID, NO_ID))
 				replace(R.id.container, fragment)
 			}

app/src/main/java/org/koitharu/kotatsu/favourites/ui/categories/adapter/CategoriesAdapter.kt

@@ -4,12 +4,12 @@ import androidx.lifecycle.LifecycleOwner
 import androidx.recyclerview.widget.DiffUtil
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
+import kotlin.jvm.internal.Intrinsics
 import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesListListener
 import org.koitharu.kotatsu.list.ui.adapter.ListStateHolderListener
 import org.koitharu.kotatsu.list.ui.adapter.emptyStateListAD
 import org.koitharu.kotatsu.list.ui.adapter.loadingStateAD
 import org.koitharu.kotatsu.list.ui.model.ListModel
-import kotlin.jvm.internal.Intrinsics
 
 class CategoriesAdapter(
 	coil: ImageLoader,
@@ -20,7 +20,7 @@ class CategoriesAdapter(
 
 	init {
 		delegatesManager.addDelegate(categoryAD(coil, lifecycleOwner, onItemClickListener))
-			.addDelegate(emptyStateListAD(listListener))
+			.addDelegate(emptyStateListAD(coil, listListener))
 			.addDelegate(loadingStateAD())
 	}
 
@@ -56,4 +56,4 @@ class CategoriesAdapter(
 			}
 		}
 	}
-}
+}

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

@@ -7,15 +7,16 @@ import android.view.View
 import androidx.appcompat.view.ActionMode
 import androidx.appcompat.widget.PopupMenu
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.ui.titleRes
 import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesActivity
 import org.koitharu.kotatsu.list.ui.MangaListFragment
 import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.utils.ext.addMenuProvider
 import org.koitharu.kotatsu.utils.ext.assistedViewModels
 import org.koitharu.kotatsu.utils.ext.withArgs
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickListener {
@@ -23,9 +24,7 @@ class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickLis
 	@Inject
 	lateinit var viewModelFactory: FavouritesListViewModel.Factory
 
-	override val viewModel by assistedViewModels<FavouritesListViewModel> {
-		viewModelFactory.create(categoryId)
-	}
+	override val viewModel by assistedViewModels { viewModelFactory.create(categoryId) }
 
 	private val categoryId: Long
 		get() = arguments?.getLong(ARG_CATEGORY_ID) ?: NO_ID
@@ -34,6 +33,9 @@ class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickLis
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
+		if (viewModel.categoryId != NO_ID) {
+			addMenuProvider(FavouritesListMenuProvider(view.context, viewModel))
+		}
 		viewModel.sortOrder.observe(viewLifecycleOwner) { activity?.invalidateOptionsMenu() }
 	}
 
@@ -73,6 +75,7 @@ class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickLis
 				mode.finish()
 				true
 			}
+
 			else -> super.onActionItemClicked(controller, mode, item)
 		}
 	}

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

@@ -0,0 +1,56 @@
+package org.koitharu.kotatsu.favourites.ui.list
+
+import android.content.Context
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import androidx.core.view.MenuProvider
+import androidx.core.view.forEach
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.titleRes
+import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesActivity
+import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity
+import org.koitharu.kotatsu.parsers.model.SortOrder
+
+class FavouritesListMenuProvider(
+	private val context: Context,
+	private val viewModel: FavouritesListViewModel,
+) : MenuProvider {
+
+	override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
+		menuInflater.inflate(R.menu.opt_favourites, menu)
+		val subMenu = menu.findItem(R.id.action_order)?.subMenu ?: return
+		for (order in FavouriteCategoriesActivity.SORT_ORDERS) {
+			subMenu.add(R.id.group_order, Menu.NONE, order.ordinal, order.titleRes)
+		}
+		subMenu.setGroupCheckable(R.id.group_order, true, true)
+	}
+
+	override fun onPrepareMenu(menu: Menu) {
+		super.onPrepareMenu(menu)
+		val order = viewModel.sortOrder.value ?: return
+		menu.findItem(R.id.action_order)?.subMenu?.forEach { item ->
+			if (item.order == order.ordinal) {
+				item.isChecked = true
+			}
+		}
+	}
+
+	override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+		if (menuItem.groupId == R.id.group_order) {
+			val order = enumValues<SortOrder>()[menuItem.order]
+			viewModel.setSortOrder(order)
+			return true
+		}
+		return when (menuItem.itemId) {
+			R.id.action_edit -> {
+				context.startActivity(
+					FavouritesCategoryEditActivity.newIntent(context, viewModel.categoryId),
+				)
+				true
+			}
+
+			else -> false
+		}
+	}
+}

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

@@ -28,9 +28,10 @@ import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.asFlowLiveData
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 
 class FavouritesListViewModel @AssistedInject constructor(
-	@Assisted private val categoryId: Long,
+	@Assisted val categoryId: Long,
 	private val repository: FavouritesRepository,
 	private val trackingRepository: TrackingRepository,
 	private val historyRepository: HistoryRepository,
@@ -54,7 +55,7 @@ class FavouritesListViewModel @AssistedInject constructor(
 		} else {
 			repository.observeAll(categoryId)
 		},
-		createListModeFlow(),
+		listModeFlow,
 	) { list, mode ->
 		when {
 			list.isEmpty() -> listOf(
@@ -69,6 +70,7 @@ class FavouritesListViewModel @AssistedInject constructor(
 					actionStringRes = 0,
 				),
 			)
+
 			else -> list.toUi(mode, this)
 		}
 	}.catch {
@@ -79,7 +81,7 @@ class FavouritesListViewModel @AssistedInject constructor(
 		if (categoryId != NO_ID) {
 			launchJob {
 				categoryName = withContext(Dispatchers.Default) {
-					runCatching {
+					runCatchingCancellable {
 						repository.getCategory(categoryId).title
 					}.getOrNull()
 				}
@@ -115,7 +117,11 @@ class FavouritesListViewModel @AssistedInject constructor(
 	}
 
 	override suspend fun getCounter(mangaId: Long): Int {
-		return trackingRepository.getNewChaptersCount(mangaId)
+		return if (settings.isTrackerEnabled) {
+			trackingRepository.getNewChaptersCount(mangaId)
+		} else {
+			0
+		}
 	}
 
 	override suspend fun getProgress(mangaId: Long): Float {

app/src/main/java/org/koitharu/kotatsu/history/domain/HistoryRepository.kt

@@ -1,15 +1,23 @@
 package org.koitharu.kotatsu.history.domain
 
 import androidx.room.withTransaction
-import javax.inject.Inject
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.distinctUntilChangedBy
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onStart
 import org.koitharu.kotatsu.base.domain.ReversibleHandle
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.*
+import org.koitharu.kotatsu.core.db.entity.toEntities
+import org.koitharu.kotatsu.core.db.entity.toEntity
+import org.koitharu.kotatsu.core.db.entity.toManga
+import org.koitharu.kotatsu.core.db.entity.toMangaTag
+import org.koitharu.kotatsu.core.db.entity.toMangaTags
 import org.koitharu.kotatsu.core.model.MangaHistory
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.prefs.observeAsFlow
 import org.koitharu.kotatsu.history.data.HistoryEntity
 import org.koitharu.kotatsu.history.data.toMangaHistory
 import org.koitharu.kotatsu.parsers.model.Manga
@@ -18,6 +26,7 @@ import org.koitharu.kotatsu.scrobbling.domain.Scrobbler
 import org.koitharu.kotatsu.scrobbling.domain.tryScrobble
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.ext.mapItems
+import javax.inject.Inject
 
 const val PROGRESS_NONE = -1f
 
@@ -66,7 +75,7 @@ class HistoryRepository @Inject constructor(
 	}
 
 	suspend fun addOrUpdate(manga: Manga, chapterId: Long, page: Int, scroll: Int, percent: Float) {
-		if (manga.isNsfw && settings.isHistoryExcludeNsfw || settings.isIncognitoModeEnabled) {
+		if (shouldSkip(manga)) {
 			return
 		}
 		val tags = manga.tags.toEntities()
@@ -138,6 +147,30 @@ class HistoryRepository @Inject constructor(
 		return db.historyDao.findPopularTags(limit).map { x -> x.toMangaTag() }
 	}
 
+	fun shouldSkip(manga: Manga): Boolean {
+		return manga.isNsfw && settings.isHistoryExcludeNsfw || settings.isIncognitoModeEnabled
+	}
+
+	fun observeShouldSkip(manga: Manga): Flow<Boolean> {
+		return settings.observe()
+			.filter { key -> key == AppSettings.KEY_INCOGNITO_MODE || key == AppSettings.KEY_HISTORY_EXCLUDE_NSFW }
+			.onStart { emit("") }
+			.map { shouldSkip(manga) }
+			.distinctUntilChanged()
+	}
+
+	fun observeShouldSkip(mangaFlow: Flow<Manga?>): Flow<Boolean> {
+		return mangaFlow
+			.distinctUntilChangedBy { it?.isNsfw }
+			.flatMapLatest { m ->
+				if (m != null) {
+					observeShouldSkip(m)
+				} else {
+					settings.observeAsFlow(AppSettings.KEY_INCOGNITO_MODE) { isIncognitoModeEnabled }
+				}
+			}
+	}
+
 	private suspend fun recover(ids: Collection<Long>) {
 		db.withTransaction {
 			for (id in ids) {

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

@@ -12,6 +12,7 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseActivity
 import org.koitharu.kotatsu.databinding.ActivityContainerBinding
 import org.koitharu.kotatsu.main.ui.owners.AppBarOwner
+import kotlin.text.Typography.dagger
 
 @AndroidEntryPoint
 class HistoryActivity :
@@ -28,6 +29,7 @@ class HistoryActivity :
 		val fm = supportFragmentManager
 		if (fm.findFragmentById(R.id.container) == null) {
 			fm.commit {
+				setReorderingAllowed(true)
 				val fragment = HistoryListFragment.newInstance()
 				replace(R.id.container, fragment)
 			}

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

@@ -14,14 +14,14 @@ class HistoryListAdapter(
 	listener: MangaListListener
 ) : MangaListAdapter(coil, lifecycleOwner, listener), FastScroller.SectionIndexer {
 
-	override fun getSectionText(context: Context, position: Int): CharSequence {
+	override fun getSectionText(context: Context, position: Int): CharSequence? {
 		val list = items
 		for (i in (0..position).reversed()) {
-			val item = list[i]
+			val item = list.getOrNull(i) ?: continue
 			if (item is DateTimeAgo) {
 				return item.format(context.resources)
 			}
 		}
-		return ""
+		return null
 	}
-}
+}

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

@@ -5,9 +5,9 @@ import android.view.Menu
 import android.view.MenuInflater
 import android.view.MenuItem
 import androidx.core.view.MenuProvider
+import com.google.android.material.R as materialR
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import org.koitharu.kotatsu.R
-import com.google.android.material.R as materialR
 
 class HistoryListMenuProvider(
 	private val context: Context,
@@ -38,6 +38,6 @@ class HistoryListMenuProvider(
 	}
 
 	override fun onPrepareMenu(menu: Menu) {
-		menu.findItem(R.id.action_history_grouping).isChecked = viewModel.isGroupingEnabled.value == true
+		menu.findItem(R.id.action_history_grouping)?.isChecked = viewModel.isGroupingEnabled.value == true
 	}
 }

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

@@ -3,9 +3,6 @@ package org.koitharu.kotatsu.history.ui
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
-import java.util.*
-import java.util.concurrent.TimeUnit
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
@@ -21,11 +18,20 @@ import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.history.domain.MangaWithHistory
 import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
 import org.koitharu.kotatsu.list.ui.MangaListViewModel
-import org.koitharu.kotatsu.list.ui.model.*
+import org.koitharu.kotatsu.list.ui.model.EmptyState
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.list.ui.model.LoadingState
+import org.koitharu.kotatsu.list.ui.model.toErrorState
+import org.koitharu.kotatsu.list.ui.model.toGridModel
+import org.koitharu.kotatsu.list.ui.model.toListDetailedModel
+import org.koitharu.kotatsu.list.ui.model.toListModel
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.asFlowLiveData
 import org.koitharu.kotatsu.utils.ext.daysDiff
 import org.koitharu.kotatsu.utils.ext.onFirst
+import java.util.Date
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
 
 @HiltViewModel
 class HistoryListViewModel @Inject constructor(
@@ -42,7 +48,7 @@ class HistoryListViewModel @Inject constructor(
 	override val content = combine(
 		repository.observeAllWithHistory(),
 		historyGrouping,
-		createListModeFlow(),
+		listModeFlow,
 	) { list, grouped, mode ->
 		when {
 			list.isEmpty() -> listOf(
@@ -53,6 +59,7 @@ class HistoryListViewModel @Inject constructor(
 					actionStringRes = 0,
 				),
 			)
+
 			else -> mapList(list, grouped, mode)
 		}
 	}.onStart {
@@ -103,7 +110,11 @@ class HistoryListViewModel @Inject constructor(
 				}
 				prevDate = date
 			}
-			val counter = trackingRepository.getNewChaptersCount(manga.id)
+			val counter = if (settings.isTrackerEnabled) {
+				trackingRepository.getNewChaptersCount(manga.id)
+			} else {
+				0
+			}
 			val percent = if (showPercent) history.percent else PROGRESS_NONE
 			result += when (mode) {
 				ListMode.LIST -> manga.toListModel(counter, percent)

app/src/main/java/org/koitharu/kotatsu/image/ui/ImageActivity.kt

@@ -79,7 +79,7 @@ class ImageActivity : BaseActivity<ActivityImageBinding>() {
 
 		private fun setDrawable(drawable: Drawable?) {
 			if (drawable != null) {
-				view.setImage(ImageSource.bitmap(drawable.toBitmap()))
+				view.setImage(ImageSource.Bitmap(drawable.toBitmap()))
 			} else {
 				view.recycle()
 			}

app/src/main/java/org/koitharu/kotatsu/library/domain/LibraryRepository.kt

@@ -1,38 +0,0 @@
-package org.koitharu.kotatsu.library.domain
-
-import javax.inject.Inject
-import kotlinx.coroutines.flow.*
-import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.toManga
-import org.koitharu.kotatsu.core.db.entity.toMangaTags
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.favourites.data.FavouriteCategoryEntity
-import org.koitharu.kotatsu.favourites.data.toFavouriteCategory
-import org.koitharu.kotatsu.parsers.model.Manga
-
-class LibraryRepository @Inject constructor(
-	private val db: MangaDatabase,
-) {
-
-	fun observeFavourites(): Flow<Map<FavouriteCategory, List<Manga>>> {
-		return db.favouriteCategoriesDao.observeAll()
-			.flatMapLatest { categories ->
-				val cats = categories.filter { it.isVisibleInLibrary }
-				if (cats.isEmpty()) {
-					flowOf(emptyMap())
-				} else {
-					observeCategoriesContent(cats)
-				}
-			}
-	}
-
-	private fun observeCategoriesContent(
-		categories: List<FavouriteCategoryEntity>,
-	) = combine<Pair<FavouriteCategory, List<Manga>>, Map<FavouriteCategory, List<Manga>>>(
-		categories.map { cat ->
-			val category = cat.toFavouriteCategory()
-			db.favouritesDao.observeAll(category.id, category.order)
-				.map { category to it.map { x -> x.manga.toManga(x.tags.toMangaTags()) } }
-		},
-	) { array -> array.toMap() }
-}

app/src/main/java/org/koitharu/kotatsu/library/ui/LibraryViewModel.kt

@@ -1,190 +0,0 @@
-package org.koitharu.kotatsu.library.ui
-
-import androidx.collection.ArraySet
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import java.util.*
-import javax.inject.Inject
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.combine
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.base.ui.BaseViewModel
-import org.koitharu.kotatsu.base.ui.util.ReversibleAction
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.ListMode
-import org.koitharu.kotatsu.core.ui.DateTimeAgo
-import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
-import org.koitharu.kotatsu.history.domain.HistoryRepository
-import org.koitharu.kotatsu.history.domain.MangaWithHistory
-import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
-import org.koitharu.kotatsu.library.domain.LibraryRepository
-import org.koitharu.kotatsu.library.ui.model.LibrarySectionModel
-import org.koitharu.kotatsu.list.domain.ListExtraProvider
-import org.koitharu.kotatsu.list.ui.model.*
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.tracker.domain.TrackingRepository
-import org.koitharu.kotatsu.utils.SingleLiveEvent
-import org.koitharu.kotatsu.utils.asFlowLiveData
-import org.koitharu.kotatsu.utils.ext.daysDiff
-
-private const val HISTORY_MAX_SEGMENTS = 2
-
-@HiltViewModel
-class LibraryViewModel @Inject constructor(
-	repository: LibraryRepository,
-	private val historyRepository: HistoryRepository,
-	private val favouritesRepository: FavouritesRepository,
-	private val trackingRepository: TrackingRepository,
-	private val settings: AppSettings,
-) : BaseViewModel(), ListExtraProvider {
-
-	val onActionDone = SingleLiveEvent<ReversibleAction>()
-
-	val content: LiveData<List<ListModel>> = combine(
-		historyRepository.observeAllWithHistory(),
-		repository.observeFavourites(),
-	) { history, favourites ->
-		mapList(history, favourites)
-	}.catch { e ->
-		emit(listOf(e.toErrorState(canRetry = false)))
-	}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, listOf(LoadingState))
-
-	override suspend fun getCounter(mangaId: Long): Int {
-		return trackingRepository.getNewChaptersCount(mangaId)
-	}
-
-	override suspend fun getProgress(mangaId: Long): Float {
-		return if (settings.isReadingIndicatorsEnabled) {
-			historyRepository.getProgress(mangaId)
-		} else {
-			PROGRESS_NONE
-		}
-	}
-
-	fun removeFromFavourites(category: FavouriteCategory, ids: Set<Long>) {
-		if (ids.isEmpty()) {
-			return
-		}
-		launchJob(Dispatchers.Default) {
-			val handle = favouritesRepository.removeFromCategory(category.id, ids)
-			onActionDone.postCall(ReversibleAction(R.string.removed_from_favourites, handle))
-		}
-	}
-
-	fun removeFromHistory(ids: Set<Long>) {
-		if (ids.isEmpty()) {
-			return
-		}
-		launchJob(Dispatchers.Default) {
-			val handle = historyRepository.delete(ids)
-			onActionDone.postCall(ReversibleAction(R.string.removed_from_history, handle))
-		}
-	}
-
-	fun clearHistory(minDate: Long) {
-		launchJob(Dispatchers.Default) {
-			val stringRes = if (minDate <= 0) {
-				historyRepository.clear()
-				R.string.history_cleared
-			} else {
-				historyRepository.deleteAfter(minDate)
-				R.string.removed_from_history
-			}
-			onActionDone.postCall(ReversibleAction(stringRes, null))
-		}
-	}
-
-	fun getManga(ids: Set<Long>): Set<Manga> {
-		val snapshot = content.value ?: return emptySet()
-		val result = ArraySet<Manga>(ids.size)
-		for (section in snapshot) {
-			if (section !is LibrarySectionModel) {
-				continue
-			}
-			for (item in section.items) {
-				if (item.id in ids) {
-					result.add(item.manga)
-					if (result.size == ids.size) {
-						return result
-					}
-				}
-			}
-		}
-		return result
-	}
-
-	private suspend fun mapList(
-		history: List<MangaWithHistory>,
-		favourites: Map<FavouriteCategory, List<Manga>>,
-	): List<ListModel> {
-		val result = ArrayList<ListModel>(favourites.keys.size + 1)
-		if (history.isNotEmpty()) {
-			mapHistory(result, history)
-		}
-		if (favourites.isNotEmpty()) {
-			mapFavourites(result, favourites)
-		}
-		if (result.isEmpty()) {
-			result += EmptyState(
-				icon = R.drawable.ic_empty_history,
-				textPrimary = R.string.text_shelf_holder_primary,
-				textSecondary = R.string.text_shelf_holder_secondary,
-				actionStringRes = 0,
-			)
-		}
-		result.trimToSize()
-		return result
-	}
-
-	private suspend fun mapHistory(
-		destination: MutableList<in LibrarySectionModel.History>,
-		list: List<MangaWithHistory>,
-	) {
-		val showPercent = settings.isReadingIndicatorsEnabled
-		val groups = list.groupByTo(LinkedHashMap()) { timeAgo(it.history.updatedAt) }
-		while (groups.size > HISTORY_MAX_SEGMENTS) {
-			val lastKey = groups.keys.last()
-			val subList = groups.remove(lastKey) ?: continue
-			groups[groups.keys.last()]?.addAll(subList)
-		}
-		for ((timeAgo, subList) in groups) {
-			destination += LibrarySectionModel.History(
-				items = subList.map { (manga, history) ->
-					val counter = trackingRepository.getNewChaptersCount(manga.id)
-					val percent = if (showPercent) history.percent else PROGRESS_NONE
-					manga.toGridModel(counter, percent)
-				},
-				timeAgo = timeAgo,
-				showAllButtonText = R.string.show_all,
-			)
-		}
-	}
-
-	private suspend fun mapFavourites(
-		destination: MutableList<in LibrarySectionModel.Favourites>,
-		favourites: Map<FavouriteCategory, List<Manga>>,
-	) {
-		for ((category, list) in favourites) {
-			if (list.isNotEmpty()) {
-				destination += LibrarySectionModel.Favourites(
-					items = list.toUi(ListMode.GRID, this),
-					category = category,
-					showAllButtonText = R.string.show_all,
-				)
-			}
-		}
-	}
-
-	private fun timeAgo(date: Date): DateTimeAgo {
-		val diffDays = -date.daysDiff(System.currentTimeMillis())
-		return when {
-			diffDays < 1 -> DateTimeAgo.Today
-			diffDays == 1 -> DateTimeAgo.Yesterday
-			diffDays <= 3 -> DateTimeAgo.DaysAgo(diffDays)
-			else -> DateTimeAgo.LongAgo
-		}
-	}
-}

app/src/main/java/org/koitharu/kotatsu/library/ui/adapter/LibraryListEventListener.kt

@@ -1,15 +0,0 @@
-package org.koitharu.kotatsu.library.ui.adapter
-
-import android.view.View
-import org.koitharu.kotatsu.library.ui.model.LibrarySectionModel
-import org.koitharu.kotatsu.list.ui.adapter.ListStateHolderListener
-import org.koitharu.kotatsu.parsers.model.Manga
-
-interface LibraryListEventListener : ListStateHolderListener {
-
-	fun onItemClick(item: Manga, section: LibrarySectionModel, view: View)
-
-	fun onItemLongClick(item: Manga, section: LibrarySectionModel, view: View): Boolean
-
-	fun onSectionClick(section: LibrarySectionModel, view: View)
-}

app/src/main/java/org/koitharu/kotatsu/library/ui/config/categories/LibraryCategoriesConfigAdapter.kt

@@ -1,32 +0,0 @@
-package org.koitharu.kotatsu.library.ui.config.categories
-
-import androidx.recyclerview.widget.DiffUtil
-import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
-import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-
-class LibraryCategoriesConfigAdapter(
-	listener: OnListItemClickListener<FavouriteCategory>,
-) : AsyncListDifferDelegationAdapter<FavouriteCategory>(DiffCallback()) {
-
-	init {
-		delegatesManager.addDelegate(libraryCategoryAD(listener))
-	}
-
-	class DiffCallback : DiffUtil.ItemCallback<FavouriteCategory>() {
-
-		override fun areItemsTheSame(oldItem: FavouriteCategory, newItem: FavouriteCategory): Boolean {
-			return oldItem.id == newItem.id
-		}
-
-		override fun areContentsTheSame(oldItem: FavouriteCategory, newItem: FavouriteCategory): Boolean {
-			return oldItem.isVisibleInLibrary == newItem.isVisibleInLibrary && oldItem.title == newItem.title
-		}
-
-		override fun getChangePayload(oldItem: FavouriteCategory, newItem: FavouriteCategory): Any? {
-			return if (oldItem.isVisibleInLibrary == newItem.isVisibleInLibrary) {
-				super.getChangePayload(oldItem, newItem)
-			} else Unit
-		}
-	}
-}

app/src/main/java/org/koitharu/kotatsu/library/ui/config/categories/LibraryCategoriesConfigSheet.kt

@@ -1,54 +0,0 @@
-package org.koitharu.kotatsu.library.ui.config.categories
-
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.core.view.isVisible
-import androidx.fragment.app.FragmentManager
-import androidx.fragment.app.viewModels
-import dagger.hilt.android.AndroidEntryPoint
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.base.ui.BaseBottomSheet
-import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.databinding.SheetBaseBinding
-
-@AndroidEntryPoint
-class LibraryCategoriesConfigSheet :
-	BaseBottomSheet<SheetBaseBinding>(),
-	OnListItemClickListener<FavouriteCategory>,
-	View.OnClickListener {
-
-	private val viewModel by viewModels<LibraryCategoriesConfigViewModel>()
-
-	override fun onInflateView(inflater: LayoutInflater, container: ViewGroup?): SheetBaseBinding {
-		return SheetBaseBinding.inflate(inflater, container, false)
-	}
-
-	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-		super.onViewCreated(view, savedInstanceState)
-		binding.headerBar.toolbar.setTitle(R.string.favourites_categories)
-		binding.buttonDone.isVisible = true
-		binding.buttonDone.setOnClickListener(this)
-		val adapter = LibraryCategoriesConfigAdapter(this)
-		binding.recyclerView.adapter = adapter
-
-		viewModel.content.observe(viewLifecycleOwner) { adapter.items = it }
-	}
-
-	override fun onItemClick(item: FavouriteCategory, view: View) {
-		viewModel.toggleItem(item)
-	}
-
-	override fun onClick(v: View?) {
-		dismiss()
-	}
-
-	companion object {
-
-		private const val TAG = "LibraryCategoriesConfigSheet"
-
-		fun show(fm: FragmentManager) = LibraryCategoriesConfigSheet().show(fm, TAG)
-	}
-}

app/src/main/java/org/koitharu/kotatsu/library/ui/config/categories/LibraryCategoriesConfigViewModel.kt

@@ -1,30 +0,0 @@
-package org.koitharu.kotatsu.library.ui.config.categories
-
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import org.koitharu.kotatsu.base.ui.BaseViewModel
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
-import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
-
-@HiltViewModel
-class LibraryCategoriesConfigViewModel @Inject constructor(
-	private val favouritesRepository: FavouritesRepository,
-) : BaseViewModel() {
-
-	val content = favouritesRepository.observeCategories()
-		.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default, emptyList())
-
-	private var updateJob: Job? = null
-
-	fun toggleItem(category: FavouriteCategory) {
-		val prevJob = updateJob
-		updateJob = launchJob(Dispatchers.Default) {
-			prevJob?.join()
-			favouritesRepository.updateCategory(category.id, !category.isVisibleInLibrary)
-		}
-	}
-}

app/src/main/java/org/koitharu/kotatsu/library/ui/config/categories/LibraryCategoryAD.kt

@@ -1,21 +0,0 @@
-package org.koitharu.kotatsu.library.ui.config.categories
-
-import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
-import org.koitharu.kotatsu.base.ui.list.AdapterDelegateClickListenerAdapter
-import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.databinding.ItemCategoryCheckableMultipleBinding
-
-fun libraryCategoryAD(
-	listener: OnListItemClickListener<FavouriteCategory>,
-) = adapterDelegateViewBinding<FavouriteCategory, FavouriteCategory, ItemCategoryCheckableMultipleBinding>(
-	{ layoutInflater, parent -> ItemCategoryCheckableMultipleBinding.inflate(layoutInflater, parent, false) },
-) {
-	val eventListener = AdapterDelegateClickListenerAdapter(this, listener)
-	itemView.setOnClickListener(eventListener)
-
-	bind {
-		binding.root.text = item.title
-		binding.root.isChecked = item.isVisibleInLibrary
-	}
-}

app/src/main/java/org/koitharu/kotatsu/library/ui/model/LibrarySectionModel.kt

@@ -1,94 +0,0 @@
-package org.koitharu.kotatsu.library.ui.model
-
-import android.content.res.Resources
-import androidx.annotation.StringRes
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.core.ui.DateTimeAgo
-import org.koitharu.kotatsu.list.ui.model.ListModel
-import org.koitharu.kotatsu.list.ui.model.MangaItemModel
-
-sealed class LibrarySectionModel(
-	val items: List<MangaItemModel>,
-	@StringRes val showAllButtonText: Int,
-) : ListModel {
-
-	abstract val key: Any
-	abstract fun getTitle(resources: Resources): CharSequence
-
-	class History(
-		items: List<MangaItemModel>,
-		val timeAgo: DateTimeAgo?,
-		showAllButtonText: Int,
-	) : LibrarySectionModel(items, showAllButtonText) {
-
-		override val key: Any
-			get() = timeAgo?.javaClass ?: this::class.java
-
-		override fun getTitle(resources: Resources): CharSequence {
-			return timeAgo?.format(resources) ?: resources.getString(R.string.history)
-		}
-
-		override fun equals(other: Any?): Boolean {
-			if (this === other) return true
-			if (javaClass != other?.javaClass) return false
-
-			other as History
-
-			if (timeAgo != other.timeAgo) return false
-			if (showAllButtonText != other.showAllButtonText) return false
-			if (items != other.items) return false
-
-			return true
-		}
-
-		override fun hashCode(): Int {
-			var result = items.hashCode()
-			result = 31 * result + (timeAgo?.hashCode() ?: 0)
-			result = 31 * result + showAllButtonText.hashCode()
-			return result
-		}
-
-		override fun toString(): String {
-			return "hist_$timeAgo"
-		}
-	}
-
-	class Favourites(
-		items: List<MangaItemModel>,
-		val category: FavouriteCategory,
-		showAllButtonText: Int,
-	) : LibrarySectionModel(items, showAllButtonText) {
-
-		override val key: Any
-			get() = category.id
-
-		override fun getTitle(resources: Resources): CharSequence {
-			return category.title
-		}
-
-		override fun equals(other: Any?): Boolean {
-			if (this === other) return true
-			if (javaClass != other?.javaClass) return false
-
-			other as Favourites
-
-			if (category != other.category) return false
-			if (showAllButtonText != other.showAllButtonText) return false
-			if (items != other.items) return false
-
-			return true
-		}
-
-		override fun hashCode(): Int {
-			var result = items.hashCode()
-			result = 31 * result + category.hashCode()
-			result = 31 * result + showAllButtonText.hashCode()
-			return result
-		}
-
-		override fun toString(): String {
-			return "fav_${category.id}"
-		}
-	}
-}

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

@@ -6,24 +6,23 @@ import android.view.View
 import android.view.ViewGroup
 import androidx.core.view.isVisible
 import androidx.fragment.app.FragmentManager
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.button.MaterialButtonToggleGroup
 import com.google.android.material.slider.Slider
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.base.ui.AlertDialogFragment
-import org.koitharu.kotatsu.base.ui.widgets.CheckableButtonGroup
+import org.koitharu.kotatsu.base.ui.BaseBottomSheet
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.prefs.ListMode
 import org.koitharu.kotatsu.databinding.DialogListModeBinding
 import org.koitharu.kotatsu.utils.ext.setValueRounded
 import org.koitharu.kotatsu.utils.progress.IntPercentLabelFormatter
+import javax.inject.Inject
 
 @AndroidEntryPoint
-class ListModeSelectDialog :
-	AlertDialogFragment<DialogListModeBinding>(),
-	CheckableButtonGroup.OnCheckedChangeListener,
-	Slider.OnChangeListener {
+class ListModeBottomSheet :
+	BaseBottomSheet<DialogListModeBinding>(),
+	Slider.OnChangeListener,
+	MaterialButtonToggleGroup.OnButtonCheckedListener {
 
 	@Inject
 	lateinit var settings: AppSettings
@@ -33,13 +32,6 @@ class ListModeSelectDialog :
 		container: ViewGroup?,
 	) = DialogListModeBinding.inflate(inflater, container, false)
 
-	override fun onBuildDialog(builder: MaterialAlertDialogBuilder): MaterialAlertDialogBuilder {
-		return super.onBuildDialog(builder)
-			.setTitle(R.string.list_mode)
-			.setPositiveButton(R.string.done, null)
-			.setCancelable(true)
-	}
-
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
 		val mode = settings.listMode
@@ -53,10 +45,13 @@ class ListModeSelectDialog :
 		binding.sliderGrid.setValueRounded(settings.gridSize.toFloat())
 		binding.sliderGrid.addOnChangeListener(this)
 
-		binding.checkableGroup.onCheckedChangeListener = this
+		binding.checkableGroup.addOnButtonCheckedListener(this)
 	}
 
-	override fun onCheckedChanged(group: CheckableButtonGroup, checkedId: Int) {
+	override fun onButtonChecked(group: MaterialButtonToggleGroup?, checkedId: Int, isChecked: Boolean) {
+		if (!isChecked) {
+			return
+		}
 		val mode = when (checkedId) {
 			R.id.button_list -> ListMode.LIST
 			R.id.button_list_detailed -> ListMode.DETAILED_LIST
@@ -78,6 +73,6 @@ class ListModeSelectDialog :
 
 		private const val TAG = "ListModeSelectDialog"
 
-		fun show(fm: FragmentManager) = ListModeSelectDialog().show(fm, TAG)
+		fun show(fm: FragmentManager) = ListModeBottomSheet().show(fm, TAG)
 	}
 }

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

@@ -1,7 +1,11 @@
 package org.koitharu.kotatsu.list.ui
 
 import android.os.Bundle
-import android.view.*
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
 import android.view.ViewGroup.MarginLayoutParams
 import androidx.annotation.CallSuper
 import androidx.appcompat.view.ActionMode
@@ -15,7 +19,6 @@ import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 import coil.ImageLoader
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.launch
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.domain.reverseAsync
@@ -42,13 +45,23 @@ import org.koitharu.kotatsu.list.ui.adapter.MangaListListener
 import org.koitharu.kotatsu.list.ui.model.ListHeader
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.list.ui.model.MangaItemModel
+import org.koitharu.kotatsu.main.ui.MainActivity
 import org.koitharu.kotatsu.main.ui.owners.AppBarOwner
 import org.koitharu.kotatsu.main.ui.owners.BottomNavOwner
-import org.koitharu.kotatsu.main.ui.MainActivity
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.reader.ui.ReaderActivity
+import org.koitharu.kotatsu.search.ui.MangaListActivity
 import org.koitharu.kotatsu.utils.ShareHelper
-import org.koitharu.kotatsu.utils.ext.*
+import org.koitharu.kotatsu.utils.ext.addMenuProvider
+import org.koitharu.kotatsu.utils.ext.clearItemDecorations
+import org.koitharu.kotatsu.utils.ext.getDisplayMessage
+import org.koitharu.kotatsu.utils.ext.getThemeColor
+import org.koitharu.kotatsu.utils.ext.measureHeight
+import org.koitharu.kotatsu.utils.ext.resolveDp
+import org.koitharu.kotatsu.utils.ext.scaleUpActivityOptionsOf
+import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
+import javax.inject.Inject
 
 @AndroidEntryPoint
 abstract class MangaListFragment :
@@ -138,6 +151,20 @@ abstract class MangaListFragment :
 		return selectionController?.onItemLongClick(item.id) ?: false
 	}
 
+	override fun onReadClick(manga: Manga, view: View) {
+		if (selectionController?.onItemClick(manga.id) != true) {
+			val intent = ReaderActivity.newIntent(context ?: return, manga)
+			startActivity(intent, scaleUpActivityOptionsOf(view).toBundle())
+		}
+	}
+
+	override fun onTagClick(manga: Manga, tag: MangaTag, view: View) {
+		if (selectionController?.onItemClick(manga.id) != true) {
+			val intent = MangaListActivity.newIntent(context ?: return, setOf(tag))
+			startActivity(intent)
+		}
+	}
+
 	@CallSuper
 	override fun onRefresh() {
 		binding.swipeRefreshLayout.isRefreshing = true
@@ -251,12 +278,14 @@ abstract class MangaListFragment :
 					)
 					addItemDecoration(decoration)
 				}
+
 				ListMode.DETAILED_LIST -> {
 					layoutManager = FitHeightLinearLayoutManager(context)
 					val spacing = resources.getDimensionPixelOffset(R.dimen.list_spacing)
 					updatePadding(left = spacing, right = spacing)
 					addItemDecoration(SpacingItemDecoration(spacing))
 				}
+
 				ListMode.GRID -> {
 					layoutManager = FitHeightGridLayoutManager(context, checkNotNull(spanResolver).spanCount).also {
 						it.spanSizeLookup = spanSizeLookup
@@ -284,21 +313,25 @@ abstract class MangaListFragment :
 				selectionController?.addAll(ids)
 				true
 			}
+
 			R.id.action_share -> {
 				ShareHelper(requireContext()).shareMangaLinks(selectedItems)
 				mode.finish()
 				true
 			}
+
 			R.id.action_favourite -> {
 				FavouriteCategoriesBottomSheet.show(childFragmentManager, selectedItems)
 				mode.finish()
 				true
 			}
+
 			R.id.action_save -> {
 				DownloadService.confirmAndStart(requireContext(), selectedItems)
 				mode.finish()
 				true
 			}
+
 			else -> false
 		}
 	}

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

@@ -17,9 +17,10 @@ class MangaListMenuProvider(
 
 	override fun onMenuItemSelected(menuItem: MenuItem): Boolean = when (menuItem.itemId) {
 		R.id.action_list_mode -> {
-			ListModeSelectDialog.show(fragment.childFragmentManager)
+			ListModeBottomSheet.show(fragment.childFragmentManager)
 			true
 		}
+
 		else -> false
 	}
-}
+}

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

@@ -1,26 +1,29 @@
 package org.koitharu.kotatsu.list.ui
 
 import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.base.ui.BaseViewModel
 import org.koitharu.kotatsu.base.ui.util.ReversibleAction
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.prefs.ListMode
 import org.koitharu.kotatsu.core.prefs.observeAsFlow
 import org.koitharu.kotatsu.core.prefs.observeAsLiveData
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.parsers.model.MangaTag
 import org.koitharu.kotatsu.utils.SingleLiveEvent
+import org.koitharu.kotatsu.utils.asFlowLiveData
 
 abstract class MangaListViewModel(
 	private val settings: AppSettings,
 ) : BaseViewModel() {
 
 	abstract val content: LiveData<List<ListModel>>
-	val listMode = MutableLiveData<ListMode>()
+	protected val listModeFlow = settings.observeAsFlow(AppSettings.KEY_LIST_MODE) { listMode }
+		.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Lazily, settings.listMode)
+	val listMode = listModeFlow.asFlowLiveData(viewModelScope.coroutineContext)
 	val onActionDone = SingleLiveEvent<ReversibleAction>()
 	val gridScale = settings.observeAsLiveData(
 		context = viewModelScope.coroutineContext + Dispatchers.Default,
@@ -30,13 +33,6 @@ abstract class MangaListViewModel(
 
 	open fun onUpdateFilter(tags: Set<MangaTag>) = Unit
 
-	protected fun createListModeFlow() = settings.observeAsFlow(AppSettings.KEY_LIST_MODE) { listMode }
-		.onEach {
-			if (listMode.value != it) {
-				listMode.postValue(it)
-			}
-		}
-
 	abstract fun onRefresh()
 
 	abstract fun onRetry()