Update parsers

- Remove HTML code so displaying on sites such as f-droid does not create a lot of wasted space

.editorconfig

@@ -8,10 +8,12 @@ indent_style = tab
 insert_final_newline = false
 max_line_length = 120
 tab_width = 4
+# noinspection EditorConfigKeyCorrectness
+disabled_rules=no-wildcard-imports,no-unused-imports
 
 [{*.ant,*.fxml,*.jhm,*.jnlp,*.jrxml,*.rng,*.tld,*.wsdl,*.xml,*.xsd,*.xsl,*.xslt,*.xul}]
 ij_continuation_indent_size = 4
 
-[{*.gradle.kts,*.kt,*.kts,*.main.kts}]
+[{*.kt,*.kts}]
 ij_kotlin_allow_trailing_comma = true
 ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL

.idea/ktlint.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KtlintProjectConfiguration">
+    <androidMode>true</androidMode>
+    <treatAsErrors>false</treatAsErrors>
+  </component>
+</project>

README.md

@@ -25,15 +25,25 @@ Download APK from Github Releases:
 * Tablet-optimized material design UI
 * Standard and Webtoon-optimized reader
 * Notifications about new chapters with updates feed
+* Available in multiple languages
+* Password protect access to the app
 
 ### Screenshots
 
-| ![Screenshot_20200226-210337](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/1.png) | ![](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/2.png) | ![Screenshot_20200226-210232](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/3.png) |
-|---|---|---|
-| ![Screenshot_20200226-210405](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/4.png)  | ![Screenshot_20200226-210151](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/5.png) | ![Screenshot_20200226-210223](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/6.png) |
+| ![Screenshot_20200226-210337](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/1.png) | ![](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/2.png)                           | ![Screenshot_20200226-210232](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/3.png) |
+|-----------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|
+| ![Screenshot_20200226-210405](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/4.png) | ![Screenshot_20200226-210151](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/5.png) | ![Screenshot_20200226-210223](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/phoneScreenshots/6.png) |
 
 | ![](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/tenInchScreenshots/1.png) | ![](https://github.com/nv95/Kotatsu/raw/devel/metadata/en-US/images/tenInchScreenshots/2.png) |
-|---|---|
+|-----------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|
+
+### Localization
+
+<a href="https://hosted.weblate.org/engage/kotatsu/">
+<img src="https://hosted.weblate.org/widgets/kotatsu/-/287x66-white.png" alt="Translation status" />
+</a>
+
+Kotatsu is localized in a number of different languages, if you would like to help improve these or add new languages, please head over to the Weblate <a href="https://hosted.weblate.org/engage/kotatsu/">project page</a> 
 
 ### License
 [![GNU GPLv3 Image](https://www.gnu.org/graphics/gplv3-127x51.png)](http://www.gnu.org/licenses/gpl-3.0.en.html)  

app/build.gradle

@@ -6,16 +6,16 @@ plugins {
 }
 
 android {
-	compileSdkVersion 31
-	buildToolsVersion '30.0.3'
+	compileSdkVersion 32
+	buildToolsVersion '32.0.0'
 	namespace 'org.koitharu.kotatsu'
 
 	defaultConfig {
 		applicationId 'org.koitharu.kotatsu'
 		minSdkVersion 21
-		targetSdkVersion 31
-		versionCode 399
-		versionName '3.0-alpha1'
+		targetSdkVersion 32
+		versionCode 401
+		versionName '3.1'
 		generatedDensities = []
 		testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
@@ -49,15 +49,14 @@ android {
 	kotlinOptions {
 		jvmTarget = JavaVersion.VERSION_1_8.toString()
 		freeCompilerArgs += [
-				'-Xjvm-default=enable',
-				'-Xopt-in=kotlinx.coroutines.ExperimentalCoroutinesApi',
-				'-Xopt-in=kotlinx.coroutines.FlowPreview',
-				'-Xopt-in=kotlin.contracts.ExperimentalContracts',
+				'-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi',
+				'-opt-in=kotlinx.coroutines.FlowPreview',
+				'-opt-in=kotlin.contracts.ExperimentalContracts',
 		]
 	}
 	lint {
 		abortOnError false
-		disable 'MissingTranslation'
+		disable 'MissingTranslation', 'PrivateResource'
 	}
 	testOptions {
 		unitTests.includeAndroidResources = true
@@ -66,10 +65,12 @@ android {
 }
 dependencies {
 	implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
-	implementation 'com.github.nv95:kotatsu-parsers:fe243c8acf'
+	implementation('com.github.nv95:kotatsu-parsers:8e23a7fcd4') {
+		exclude group: 'org.json', module: 'json'
+	}
 
-	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.0'
-	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0'
+	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1'
+	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.1'
 
 	implementation 'androidx.core:core-ktx:1.7.0'
 	implementation 'androidx.activity:activity-ktx:1.4.0'
@@ -83,10 +84,9 @@ dependencies {
 	implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
 	implementation 'androidx.recyclerview:recyclerview:1.2.1'
 	implementation 'androidx.viewpager2:viewpager2:1.1.0-beta01'
-	implementation 'androidx.asynclayoutinflater:asynclayoutinflater:1.0.0'
 	implementation 'androidx.preference:preference-ktx:1.2.0'
 	implementation 'androidx.work:work-runtime-ktx:2.7.1'
-	implementation 'com.google.android.material:material:1.6.0-alpha03'
+	implementation 'com.google.android.material:material:1.6.0-beta01'
 	//noinspection LifecycleAnnotationProcessorWithJava8
 	kapt 'androidx.lifecycle:lifecycle-compiler:2.4.1'
 
@@ -100,7 +100,7 @@ dependencies {
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl:4.3.2'
 	implementation 'com.hannesdorfmann:adapterdelegates4-kotlin-dsl-viewbinding:4.3.2'
 
-	implementation 'io.insert-koin:koin-android:3.1.5'
+	implementation 'io.insert-koin:koin-android:3.1.6'
 	implementation 'io.coil-kt:coil-base:1.4.0'
 	implementation 'com.davemorrissey.labs:subsampling-scale-image-view-androidx:3.10.0'
 	implementation 'com.github.solkin:disk-lru-cache:1.4'
@@ -108,8 +108,7 @@ dependencies {
 	debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.8.1'
 
 	testImplementation 'junit:junit:4.13.2'
-	testImplementation 'org.json:json:20211205'
-	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.0'
+	testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.1'
 	testImplementation 'io.insert-koin:koin-test-junit4:3.1.5'
 
 	androidTestImplementation 'androidx.test:runner:1.4.0'

app/src/debug/res/values/bools.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<resources>
-	<bool name="leak_canary_add_launcher_icon">false</bool>
+<resources xmlns:tools="http://schemas.android.com/tools">
+	<bool name="leak_canary_add_launcher_icon" tools:node="replace">false</bool>
 </resources>

app/src/main/AndroidManifest.xml

@@ -8,20 +8,23 @@
 	<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
 	<uses-permission android:name="android.permission.WAKE_LOCK" />
 	<uses-permission android:name="android.permission.VIBRATE" />
-	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 	<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
 
 	<application
 		android:name="org.koitharu.kotatsu.KotatsuApp"
 		android:allowBackup="true"
-		android:fullBackupContent="@xml/backup_descriptor"
+		android:backupAgent="org.koitharu.kotatsu.settings.backup.AppBackupAgent"
+		android:dataExtractionRules="@xml/backup_rules"
+		android:fullBackupContent="@xml/backup_content"
+		android:fullBackupOnly="true"
 		android:icon="@mipmap/ic_launcher"
 		android:label="@string/app_name"
+		android:networkSecurityConfig="@xml/network_security_config"
 		android:roundIcon="@mipmap/ic_launcher_round"
 		android:supportsRtl="true"
 		android:theme="@style/Theme.Kotatsu"
-		android:networkSecurityConfig="@xml/network_security_config"
 		tools:ignore="UnusedAttribute">
+
 		<activity
 			android:name="org.koitharu.kotatsu.main.ui.MainActivity"
 			android:exported="true">
@@ -55,15 +58,6 @@
 		<activity
 			android:name="org.koitharu.kotatsu.settings.SettingsActivity"
 			android:label="@string/settings" />
-		<activity
-			android:name="org.koitharu.kotatsu.reader.ui.SimpleSettingsActivity"
-			android:exported="true"
-			android:label="@string/settings">
-			<intent-filter>
-				<action android:name="android.intent.action.MANAGE_NETWORK_USAGE" />
-				<category android:name="android.intent.category.DEFAULT" />
-			</intent-filter>
-		</activity>
 		<activity
 			android:name="org.koitharu.kotatsu.browser.BrowserActivity"
 			android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
@@ -101,6 +95,7 @@
 			android:windowSoftInputMode="adjustResize" />
 		<activity
 			android:name="org.koitharu.kotatsu.download.ui.DownloadsActivity"
+			android:launchMode="singleTop"
 			android:label="@string/downloads" />
 		<activity android:name="org.koitharu.kotatsu.image.ui.ImageActivity"/>
 

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

@@ -2,22 +2,19 @@ package org.koitharu.kotatsu.base.domain
 
 import androidx.room.withTransaction
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.MangaEntity
-import org.koitharu.kotatsu.core.db.entity.MangaPrefsEntity
-import org.koitharu.kotatsu.core.db.entity.TagEntity
+import org.koitharu.kotatsu.core.db.entity.*
 import org.koitharu.kotatsu.core.prefs.ReaderMode
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.model.MangaTag
-import org.koitharu.kotatsu.utils.ext.mapToSet
 
 class MangaDataRepository(private val db: MangaDatabase) {
 
 	suspend fun savePreferences(manga: Manga, mode: ReaderMode) {
-		val tags = manga.tags.map(TagEntity.Companion::fromMangaTag)
+		val tags = manga.tags.toEntities()
 		db.withTransaction {
 			db.tagsDao.upsert(tags)
-			db.mangaDao.upsert(MangaEntity.from(manga), tags)
+			db.mangaDao.upsert(manga.toEntity(), tags)
 			db.preferencesDao.upsert(
 				MangaPrefsEntity(
 					mangaId = manga.id,
@@ -37,21 +34,19 @@ class MangaDataRepository(private val db: MangaDatabase) {
 
 	suspend fun resolveIntent(intent: MangaIntent): Manga? = when {
 		intent.manga != null -> intent.manga
-		intent.mangaId != 0L -> db.mangaDao.find(intent.mangaId)?.toManga()
+		intent.mangaId != 0L -> findMangaById(intent.mangaId)
 		else -> null // TODO resolve uri
 	}
 
 	suspend fun storeManga(manga: Manga) {
-		val tags = manga.tags.map(TagEntity.Companion::fromMangaTag)
+		val tags = manga.tags.toEntities()
 		db.withTransaction {
 			db.tagsDao.upsert(tags)
-			db.mangaDao.upsert(MangaEntity.from(manga), tags)
+			db.mangaDao.upsert(manga.toEntity(), tags)
 		}
 	}
 
 	suspend fun findTags(source: MangaSource): Set<MangaTag> {
-		return db.tagsDao.findTags(source.name).mapToSet {
-			it.toMangaTag()
-		}
+		return db.tagsDao.findTags(source.name).toMangaTags()
 	}
 }

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

@@ -14,7 +14,7 @@ import org.koitharu.kotatsu.core.network.CommonHeaders
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.parsers.util.await
-import org.koitharu.kotatsu.utils.ext.medianOrNull
+import org.koitharu.kotatsu.parsers.util.medianOrNull
 import java.io.InputStream
 import java.util.zip.ZipFile
 

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

@@ -42,4 +42,4 @@ abstract class AlertDialogFragment<B : ViewBinding> : DialogFragment() {
 	protected fun bindingOrNull(): B? = viewBinding
 
 	protected abstract fun onInflateView(inflater: LayoutInflater, container: ViewGroup?): B
-}
+}

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

@@ -7,6 +7,7 @@ import android.view.KeyEvent
 import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
+import androidx.annotation.CallSuper
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.view.ActionMode
 import androidx.appcompat.widget.ActionBarContextView
@@ -20,6 +21,7 @@ import androidx.viewbinding.ViewBinding
 import org.koin.android.ext.android.get
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.ui.util.ActionModeDelegate
 import org.koitharu.kotatsu.base.ui.util.WindowInsetsDelegate
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.prefs.AppSettings
@@ -36,6 +38,8 @@ abstract class BaseActivity<B : ViewBinding> : AppCompatActivity(),
 	@Suppress("LeakingThis")
 	protected val insetsDelegate = WindowInsetsDelegate(this)
 
+	val actionModeDelegate = ActionModeDelegate()
+
 	override fun onCreate(savedInstanceState: Bundle?) {
 		val settings = get<AppSettings>()
 		when {
@@ -90,8 +94,10 @@ abstract class BaseActivity<B : ViewBinding> : AppCompatActivity(),
 		return isNight && get<AppSettings>().isAmoledTheme
 	}
 
+	@CallSuper
 	override fun onSupportActionModeStarted(mode: ActionMode) {
 		super.onSupportActionModeStarted(mode)
+		actionModeDelegate.onSupportActionModeStarted(mode)
 		val insets = ViewCompat.getRootWindowInsets(binding.root)
 			?.getInsets(WindowInsetsCompat.Type.systemBars()) ?: return
 		val view = findViewById<ActionBarContextView?>(androidx.appcompat.R.id.action_mode_bar)
@@ -100,6 +106,12 @@ abstract class BaseActivity<B : ViewBinding> : AppCompatActivity(),
 		}
 	}
 
+	@CallSuper
+	override fun onSupportActionModeFinished(mode: ActionMode) {
+		super.onSupportActionModeFinished(mode)
+		actionModeDelegate.onSupportActionModeFinished(mode)
+	}
+
 	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/BaseBottomSheet.kt

@@ -9,11 +9,11 @@ import android.view.ViewGroup.LayoutParams
 import androidx.appcompat.app.AppCompatDialog
 import androidx.core.view.updateLayoutParams
 import androidx.viewbinding.ViewBinding
+import com.google.android.material.R as materialR
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.bottomsheet.BottomSheetDialog
 import com.google.android.material.bottomsheet.BottomSheetDialogFragment
 import org.koitharu.kotatsu.R
-import com.google.android.material.R as materialR
 
 abstract class BaseBottomSheet<B : ViewBinding> : BottomSheetDialogFragment() {
 
@@ -60,4 +60,4 @@ abstract class BaseBottomSheet<B : ViewBinding> : BottomSheetDialogFragment() {
 		}
 		b.isDraggable = !isLocked
 	}
-}
+}

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

@@ -6,10 +6,12 @@ import android.view.View
 import android.view.ViewGroup
 import androidx.fragment.app.Fragment
 import androidx.viewbinding.ViewBinding
+import org.koitharu.kotatsu.base.ui.util.ActionModeDelegate
 import org.koitharu.kotatsu.base.ui.util.WindowInsetsDelegate
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 
-abstract class BaseFragment<B : ViewBinding> : Fragment(),
+abstract class BaseFragment<B : ViewBinding> :
+	Fragment(),
 	WindowInsetsDelegate.WindowInsetsListener {
 
 	private var viewBinding: B? = null
@@ -23,6 +25,9 @@ abstract class BaseFragment<B : ViewBinding> : Fragment(),
 	@Suppress("LeakingThis")
 	protected val insetsDelegate = WindowInsetsDelegate(this)
 
+	protected val actionModeDelegate: ActionModeDelegate
+		get() = (requireActivity() as BaseActivity<*>).actionModeDelegate
+
 	override fun onCreateView(
 		inflater: LayoutInflater,
 		container: ViewGroup?,
@@ -47,4 +52,4 @@ abstract class BaseFragment<B : ViewBinding> : Fragment(),
 	protected fun bindingOrNull() = viewBinding
 
 	protected abstract fun onInflateView(inflater: LayoutInflater, container: ViewGroup?): B
-}
+}

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

@@ -6,14 +6,18 @@ import androidx.annotation.CallSuper
 import androidx.annotation.StringRes
 import androidx.core.graphics.Insets
 import androidx.core.view.updatePadding
+import androidx.fragment.app.Fragment
 import androidx.preference.PreferenceFragmentCompat
 import androidx.recyclerview.widget.RecyclerView
 import org.koin.android.ext.android.inject
 import org.koitharu.kotatsu.base.ui.util.RecyclerViewOwner
 import org.koitharu.kotatsu.base.ui.util.WindowInsetsDelegate
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.settings.SettingsActivity
+import org.koitharu.kotatsu.settings.SettingsHeadersFragment
 
-abstract class BasePreferenceFragment(@StringRes private val titleId: Int) : PreferenceFragmentCompat(),
+abstract class BasePreferenceFragment(@StringRes private val titleId: Int) :
+	PreferenceFragmentCompat(),
 	WindowInsetsDelegate.WindowInsetsListener,
 	RecyclerViewOwner {
 
@@ -39,16 +43,20 @@ abstract class BasePreferenceFragment(@StringRes private val titleId: Int) : Pre
 	override fun onResume() {
 		super.onResume()
 		if (titleId != 0) {
-			activity?.setTitle(titleId)
+			setTitle(getString(titleId))
 		}
 	}
 
 	@CallSuper
 	override fun onWindowInsetsChanged(insets: Insets) {
 		listView.updatePadding(
-			left = insets.left,
-			right = insets.right,
 			bottom = insets.bottom
 		)
 	}
-}
+
+	@Suppress("UsePropertyAccessSyntax")
+	protected fun setTitle(title: CharSequence) {
+		(parentFragment as? SettingsHeadersFragment)?.setTitle(title)
+			?: activity?.setTitle(title)
+	}
+}

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

@@ -3,11 +3,11 @@ package org.koitharu.kotatsu.base.ui
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
 import kotlinx.coroutines.*
 import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.utils.SingleLiveEvent
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
 
 abstract class BaseViewModel : ViewModel() {
 
@@ -33,7 +33,7 @@ abstract class BaseViewModel : ViewModel() {
 		}
 	}
 
-	protected fun createErrorHandler() = CoroutineExceptionHandler { _, throwable ->
+	private fun createErrorHandler() = CoroutineExceptionHandler { _, throwable ->
 		if (BuildConfig.DEBUG) {
 			throwable.printStackTrace()
 		}

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

@@ -0,0 +1,111 @@
+package org.koitharu.kotatsu.base.ui.list.decor
+
+import android.graphics.Canvas
+import android.graphics.Rect
+import android.graphics.RectF
+import android.view.View
+import androidx.core.view.children
+import androidx.recyclerview.widget.RecyclerView
+import androidx.recyclerview.widget.RecyclerView.NO_ID
+
+abstract class AbstractSelectionItemDecoration : RecyclerView.ItemDecoration() {
+
+	private val bounds = Rect()
+	private val boundsF = RectF()
+	private val selection = HashSet<Long>()
+
+	protected var hasBackground: Boolean = true
+	protected var hasForeground: Boolean = false
+	protected var isIncludeDecorAndMargins: Boolean = true
+
+	val checkedItemsCount: Int
+		get() = selection.size
+
+	val checkedItemsIds: Set<Long>
+		get() = selection
+
+	fun toggleItemChecked(id: Long) {
+		if (!selection.remove(id)) {
+			selection.add(id)
+		}
+	}
+
+	fun setItemIsChecked(id: Long, isChecked: Boolean) {
+		if (isChecked) {
+			selection.add(id)
+		} else {
+			selection.remove(id)
+		}
+	}
+
+	fun checkAll(ids: Collection<Long>) {
+		selection.addAll(ids)
+	}
+
+	fun clearSelection() {
+		selection.clear()
+	}
+
+	override fun onDraw(canvas: Canvas, parent: RecyclerView, state: RecyclerView.State) {
+		if (hasBackground) {
+			doDraw(canvas, parent, state, false)
+		} else {
+			super.onDraw(canvas, parent, state)
+		}
+	}
+
+	override fun onDrawOver(canvas: Canvas, parent: RecyclerView, state: RecyclerView.State) {
+		if (hasForeground) {
+			doDraw(canvas, parent, state, true)
+		} else {
+			super.onDrawOver(canvas, parent, state)
+		}
+	}
+
+	private fun doDraw(canvas: Canvas, parent: RecyclerView, state: RecyclerView.State, isOver: Boolean) {
+		val checkpoint = canvas.save()
+		if (parent.clipToPadding) {
+			canvas.clipRect(
+				parent.paddingLeft, parent.paddingTop, parent.width - parent.paddingRight,
+				parent.height - parent.paddingBottom
+			)
+		}
+
+		for (child in parent.children) {
+			val itemId = getItemId(parent, child)
+			if (itemId != NO_ID && itemId in selection) {
+				if (isIncludeDecorAndMargins) {
+					parent.getDecoratedBoundsWithMargins(child, bounds)
+				} else {
+					bounds.set(child.left, child.top, child.right, child.bottom)
+				}
+				boundsF.set(bounds)
+				boundsF.offset(child.translationX, child.translationY)
+				if (isOver) {
+					onDrawForeground(canvas, parent, child, boundsF, state)
+				} else {
+					onDrawBackground(canvas, parent, child, boundsF, state)
+				}
+			}
+		}
+		canvas.restoreToCount(checkpoint)
+	}
+
+	protected open fun getItemId(parent: RecyclerView, child: View) = parent.getChildItemId(child)
+
+	protected open fun onDrawBackground(
+		canvas: Canvas,
+		parent: RecyclerView,
+		child: View,
+		bounds: RectF,
+		state: RecyclerView.State,
+	) = Unit
+
+	protected open fun onDrawForeground(
+		canvas: Canvas,
+		parent: RecyclerView,
+		child: View,
+		bounds: RectF,
+		state: RecyclerView.State,
+	) = Unit
+}

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

@@ -0,0 +1,50 @@
+package org.koitharu.kotatsu.base.ui.util
+
+import androidx.appcompat.view.ActionMode
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+
+class ActionModeDelegate {
+
+	private var activeActionMode: ActionMode? = null
+	private var listeners: MutableList<ActionModeListener>? = null
+
+	val isActionModeStarted: Boolean
+		get() = activeActionMode != null
+
+	fun onSupportActionModeStarted(mode: ActionMode) {
+		activeActionMode = mode
+		listeners?.forEach { it.onActionModeStarted(mode) }
+	}
+
+	fun onSupportActionModeFinished(mode: ActionMode) {
+		activeActionMode = null
+		listeners?.forEach { it.onActionModeFinished(mode) }
+	}
+
+	fun addListener(listener: ActionModeListener) {
+		if (listeners == null) {
+			listeners = ArrayList()
+		}
+		checkNotNull(listeners).add(listener)
+	}
+
+	fun removeListener(listener: ActionModeListener) {
+		listeners?.remove(listener)
+	}
+
+	fun addListener(listener: ActionModeListener, owner: LifecycleOwner) {
+		addListener(listener)
+		owner.lifecycle.addObserver(ListenerLifecycleObserver(listener))
+	}
+
+	private inner class ListenerLifecycleObserver(
+		private val listener: ActionModeListener,
+	) : DefaultLifecycleObserver {
+
+		override fun onDestroy(owner: LifecycleOwner) {
+			super.onDestroy(owner)
+			removeListener(listener)
+		}
+	}
+}

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

@@ -0,0 +1,10 @@
+package org.koitharu.kotatsu.base.ui.util
+
+import androidx.appcompat.view.ActionMode
+
+interface ActionModeListener {
+
+	fun onActionModeStarted(mode: ActionMode)
+
+	fun onActionModeFinished(mode: ActionMode)
+}

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

@@ -0,0 +1,48 @@
+package org.koitharu.kotatsu.base.ui.util
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.View
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.coordinatorlayout.widget.CoordinatorLayout.Behavior
+import androidx.core.view.ViewCompat
+import com.google.android.material.floatingactionbutton.ExtendedFloatingActionButton
+
+class ShrinkOnScrollBehavior : Behavior<ExtendedFloatingActionButton> {
+
+	@Suppress("unused") constructor() : super()
+	@Suppress("unused") constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
+
+	override fun onStartNestedScroll(
+		coordinatorLayout: CoordinatorLayout,
+		child: ExtendedFloatingActionButton,
+		directTargetChild: View,
+		target: View,
+		axes: Int,
+		type: Int
+	): Boolean {
+		return axes == ViewCompat.SCROLL_AXIS_VERTICAL
+	}
+
+	override fun onNestedScroll(
+		coordinatorLayout: CoordinatorLayout,
+		child: ExtendedFloatingActionButton,
+		target: View,
+		dxConsumed: Int,
+		dyConsumed: Int,
+		dxUnconsumed: Int,
+		dyUnconsumed: Int,
+		type: Int,
+		consumed: IntArray
+	) {
+		if (dyConsumed > 0) {
+			if (child.isExtended) {
+				child.shrink()
+			}
+		} else if (dyConsumed < 0) {
+			if (!child.isExtended) {
+				child.extend()
+			}
+		}
+	}
+}

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

@@ -1,5 +1,6 @@
 package org.koitharu.kotatsu.base.ui.widgets
 
+import android.annotation.SuppressLint
 import android.content.Context
 import android.content.res.ColorStateList
 import android.content.res.TypedArray
@@ -14,10 +15,12 @@ import androidx.annotation.AttrRes
 import androidx.appcompat.widget.AppCompatCheckedTextView
 import androidx.core.content.res.use
 import androidx.core.content.withStyledAttributes
+import com.google.android.material.ripple.RippleUtils
 import com.google.android.material.shape.MaterialShapeDrawable
 import com.google.android.material.shape.ShapeAppearanceModel
 import org.koitharu.kotatsu.R
 
+@SuppressLint("RestrictedApi")
 class ListItemTextView @JvmOverloads constructor(
 	context: Context,
 	attrs: AttributeSet? = null,
@@ -33,9 +36,12 @@ class ListItemTextView @JvmOverloads constructor(
 
 	init {
 		context.withStyledAttributes(attrs, R.styleable.ListItemTextView, defStyleAttr) {
+			val itemRippleColor = getColorStateList(R.styleable.ListItemTextView_rippleColor)
+				?: getRippleColorFallback(context)
+			val shape = createShapeDrawable(this)
 			background = RippleDrawable(
-				getColorStateList(R.styleable.ListItemTextView_rippleColor) ?: getRippleColorFallback(context),
-				createShapeDrawable(this),
+				RippleUtils.sanitizeRippleDrawableColor(itemRippleColor),
+				shape,
 				ShapeDrawable(RectShape()),
 			)
 			checkedDrawableStart = getDrawable(R.styleable.ListItemTextView_checkedDrawableStart)

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

@@ -4,7 +4,6 @@ import android.webkit.WebChromeClient
 import android.webkit.WebView
 import androidx.core.view.isVisible
 import com.google.android.material.progressindicator.BaseProgressIndicator
-import org.koitharu.kotatsu.utils.ext.setIndeterminateCompat
 
 private const val PROGRESS_MAX = 100
 
@@ -22,10 +21,10 @@ class ProgressChromeClient(
 			return
 		}
 		if (newProgress in 1 until PROGRESS_MAX) {
-			progressIndicator.setIndeterminateCompat(false)
+			progressIndicator.isIndeterminate = false
 			progressIndicator.setProgressCompat(newProgress.coerceAtMost(PROGRESS_MAX), true)
 		} else {
-			progressIndicator.setIndeterminateCompat(true)
+			progressIndicator.setIndeterminate(true)
 		}
 	}
 }

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

@@ -1,6 +1,8 @@
 package org.koitharu.kotatsu.core.backup
 
 import android.content.Context
+import java.io.File
+import java.util.*
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.withContext
@@ -8,8 +10,6 @@ import org.json.JSONArray
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.utils.MutableZipFile
 import org.koitharu.kotatsu.utils.ext.format
-import java.io.File
-import java.util.*
 
 class BackupArchive(file: File) : MutableZipFile(file) {
 
@@ -40,7 +40,7 @@ class BackupArchive(file: File) : MutableZipFile(file) {
 			}
 			dir.mkdirs()
 			val filename = buildString {
-				append(context.getString(R.string.app_name).toLowerCase(Locale.ROOT))
+				append(context.getString(R.string.app_name).lowercase(Locale.ROOT))
 				append('_')
 				append(Date().format("ddMMyyyy"))
 				append(".bak")

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

@@ -1,28 +1,9 @@
 package org.koitharu.kotatsu.core.db
 
-import androidx.room.Room
 import org.koin.android.ext.koin.androidContext
 import org.koin.dsl.module
-import org.koitharu.kotatsu.core.db.migrations.*
 
 val databaseModule
 	get() = module {
-		single {
-			Room.databaseBuilder(
-				androidContext(),
-				MangaDatabase::class.java,
-				"kotatsu-db"
-			).addMigrations(
-				Migration1To2(),
-				Migration2To3(),
-				Migration3To4(),
-				Migration4To5(),
-				Migration5To6(),
-				Migration6To7(),
-				Migration7To8(),
-				Migration8To9(),
-			).addCallback(
-				DatabasePrePopulateCallback(androidContext().resources)
-			).build()
-		}
+		single { MangaDatabase.create(androidContext()) }
 	}

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

@@ -1,9 +1,12 @@
 package org.koitharu.kotatsu.core.db
 
+import android.content.Context
 import androidx.room.Database
+import androidx.room.Room
 import androidx.room.RoomDatabase
 import org.koitharu.kotatsu.core.db.dao.*
 import org.koitharu.kotatsu.core.db.entity.*
+import org.koitharu.kotatsu.core.db.migrations.*
 import org.koitharu.kotatsu.favourites.data.FavouriteCategoriesDao
 import org.koitharu.kotatsu.favourites.data.FavouriteCategoryEntity
 import org.koitharu.kotatsu.favourites.data.FavouriteEntity
@@ -18,7 +21,8 @@ import org.koitharu.kotatsu.suggestions.data.SuggestionEntity
 		MangaEntity::class, TagEntity::class, HistoryEntity::class, MangaTagsEntity::class,
 		FavouriteCategoryEntity::class, FavouriteEntity::class, MangaPrefsEntity::class,
 		TrackEntity::class, TrackLogEntity::class, SuggestionEntity::class
-	], version = 9
+	],
+	version = 9
 )
 abstract class MangaDatabase : RoomDatabase() {
 
@@ -39,4 +43,24 @@ abstract class MangaDatabase : RoomDatabase() {
 	abstract val trackLogsDao: TrackLogsDao
 
 	abstract val suggestionDao: SuggestionDao
+
+	companion object {
+
+		fun create(context: Context): MangaDatabase = Room.databaseBuilder(
+			context,
+			MangaDatabase::class.java,
+			"kotatsu-db"
+		).addMigrations(
+			Migration1To2(),
+			Migration2To3(),
+			Migration3To4(),
+			Migration4To5(),
+			Migration5To6(),
+			Migration6To7(),
+			Migration7To8(),
+			Migration8To9(),
+		).addCallback(
+			DatabasePrePopulateCallback(context.resources)
+		).build()
+	}
 }

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

@@ -12,7 +12,7 @@ abstract class TagsDao {
 	@Query(
 		"""SELECT tags.* FROM tags
 		LEFT JOIN manga_tags ON tags.tag_id = manga_tags.tag_id
-		GROUP BY manga_tags.tag_id 
+		GROUP BY tags.title 
 		ORDER BY COUNT(manga_id) DESC 
 		LIMIT :limit"""
 	)
@@ -22,7 +22,7 @@ abstract class TagsDao {
 		"""SELECT tags.* FROM tags
 		LEFT JOIN manga_tags ON tags.tag_id = manga_tags.tag_id 
 		WHERE tags.source = :source 
-		GROUP BY manga_tags.tag_id 
+		GROUP BY tags.title
 		ORDER BY COUNT(manga_id) DESC 
 		LIMIT :limit"""
 	)
@@ -32,7 +32,7 @@ abstract class TagsDao {
 		"""SELECT tags.* FROM tags
 		LEFT JOIN manga_tags ON tags.tag_id = manga_tags.tag_id 
 		WHERE tags.source = :source AND title LIKE :query
-		GROUP BY manga_tags.tag_id 
+		GROUP BY tags.title
 		ORDER BY COUNT(manga_id) DESC 
 		LIMIT :limit"""
 	)
@@ -42,7 +42,7 @@ abstract class TagsDao {
 		"""SELECT tags.* FROM tags
 		LEFT JOIN manga_tags ON tags.tag_id = manga_tags.tag_id 
 		WHERE title LIKE :query
-		GROUP BY manga_tags.tag_id 
+		GROUP BY tags.title
 		ORDER BY COUNT(manga_id) DESC 
 		LIMIT :limit"""
 	)

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

@@ -0,0 +1,76 @@
+package org.koitharu.kotatsu.core.db.entity
+
+import java.util.*
+import org.koitharu.kotatsu.core.model.TrackingLogItem
+import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.util.longHashCode
+import org.koitharu.kotatsu.parsers.util.mapToSet
+import org.koitharu.kotatsu.parsers.util.toTitleCase
+
+// Entity to model
+
+fun TagEntity.toMangaTag() = MangaTag(
+	key = this.key,
+	title = this.title.toTitleCase(),
+	source = MangaSource.valueOf(this.source),
+)
+
+fun Collection<TagEntity>.toMangaTags() = mapToSet(TagEntity::toMangaTag)
+
+fun MangaEntity.toManga(tags: Set<MangaTag>) = Manga(
+	id = this.id,
+	title = this.title,
+	altTitle = this.altTitle,
+	state = this.state?.let { MangaState.valueOf(it) },
+	rating = this.rating,
+	isNsfw = this.isNsfw,
+	url = this.url,
+	publicUrl = this.publicUrl,
+	coverUrl = this.coverUrl,
+	largeCoverUrl = this.largeCoverUrl,
+	author = this.author,
+	source = MangaSource.valueOf(this.source),
+	tags = tags
+)
+
+fun MangaWithTags.toManga() = manga.toManga(tags.toMangaTags())
+
+fun TrackLogWithManga.toTrackingLogItem() = TrackingLogItem(
+	id = trackLog.id,
+	chapters = trackLog.chapters.split('\n').filterNot { x -> x.isEmpty() },
+	manga = manga.toManga(tags.toMangaTags()),
+	createdAt = Date(trackLog.createdAt)
+)
+
+// Model to entity
+
+fun Manga.toEntity() = MangaEntity(
+	id = id,
+	url = url,
+	publicUrl = publicUrl,
+	source = source.name,
+	largeCoverUrl = largeCoverUrl,
+	coverUrl = coverUrl,
+	altTitle = altTitle,
+	rating = rating,
+	isNsfw = isNsfw,
+	state = state?.name,
+	title = title,
+	author = author,
+)
+
+fun MangaTag.toEntity() = TagEntity(
+	title = title,
+	key = key,
+	source = source.name,
+	id = "${key}_${source.name}".longHashCode()
+)
+
+fun Collection<MangaTag>.toEntities() = map(MangaTag::toEntity)
+
+// Other
+
+@Suppress("FunctionName")
+fun SortOrder(name: String, fallback: SortOrder): SortOrder = runCatching {
+	SortOrder.valueOf(name)
+}.getOrDefault(fallback)

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

@@ -3,10 +3,6 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.model.MangaState
-import org.koitharu.kotatsu.parsers.model.MangaTag
 
 @Entity(tableName = "manga")
 class MangaEntity(
@@ -16,46 +12,11 @@ class MangaEntity(
 	@ColumnInfo(name = "alt_title") val altTitle: String?,
 	@ColumnInfo(name = "url") val url: String,
 	@ColumnInfo(name = "public_url") val publicUrl: String,
-	@ColumnInfo(name = "rating") val rating: Float, //normalized value [0..1] or -1
+	@ColumnInfo(name = "rating") val rating: Float, // normalized value [0..1] or -1
 	@ColumnInfo(name = "nsfw") val isNsfw: Boolean,
 	@ColumnInfo(name = "cover_url") val coverUrl: String,
 	@ColumnInfo(name = "large_cover_url") val largeCoverUrl: String?,
 	@ColumnInfo(name = "state") val state: String?,
 	@ColumnInfo(name = "author") val author: String?,
 	@ColumnInfo(name = "source") val source: String
-) {
-
-	fun toManga(tags: Set<MangaTag> = emptySet()) = Manga(
-		id = this.id,
-		title = this.title,
-		altTitle = this.altTitle,
-		state = this.state?.let { MangaState.valueOf(it) },
-		rating = this.rating,
-		isNsfw = this.isNsfw,
-		url = this.url,
-		publicUrl = this.publicUrl,
-		coverUrl = this.coverUrl,
-		largeCoverUrl = this.largeCoverUrl,
-		author = this.author,
-		source = MangaSource.valueOf(this.source),
-		tags = tags
-	)
-
-	companion object {
-
-		fun from(manga: Manga) = MangaEntity(
-			id = manga.id,
-			url = manga.url,
-			publicUrl = manga.publicUrl,
-			source = manga.source.name,
-			largeCoverUrl = manga.largeCoverUrl,
-			coverUrl = manga.coverUrl,
-			altTitle = manga.altTitle,
-			rating = manga.rating,
-			isNsfw = manga.isNsfw,
-			state = manga.state?.name,
-			title = manga.title,
-			author = manga.author
-		)
-	}
-}
+)

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

@@ -6,13 +6,15 @@ import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
 
 @Entity(
-	tableName = "preferences", foreignKeys = [
+	tableName = "preferences",
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],
 			childColumns = ["manga_id"],
 			onDelete = ForeignKey.CASCADE
-		)]
+		)
+	]
 )
 class MangaPrefsEntity(
 	@PrimaryKey(autoGenerate = false)

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

@@ -5,7 +5,8 @@ import androidx.room.Entity
 import androidx.room.ForeignKey
 
 @Entity(
-	tableName = "manga_tags", primaryKeys = ["manga_id", "tag_id"], foreignKeys = [
+	tableName = "manga_tags", primaryKeys = ["manga_id", "tag_id"],
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],

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

@@ -3,7 +3,6 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.Embedded
 import androidx.room.Junction
 import androidx.room.Relation
-import org.koitharu.kotatsu.utils.ext.mapToSet
 
 class MangaWithTags(
 	@Embedded val manga: MangaEntity,
@@ -12,10 +11,5 @@ class MangaWithTags(
 		entityColumn = "tag_id",
 		associateBy = Junction(MangaTagsEntity::class)
 	)
-	val tags: List<TagEntity>
-) {
-
-	fun toManga() = manga.toManga(tags.mapToSet {
-		it.toMangaTag()
-	})
-}
+	val tags: List<TagEntity>,
+)

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

@@ -3,10 +3,6 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
-import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.model.MangaTag
-import org.koitharu.kotatsu.parsers.util.longHashCode
-import org.koitharu.kotatsu.parsers.util.toTitleCase
 
 @Entity(tableName = "tags")
 class TagEntity(
@@ -15,21 +11,4 @@ class TagEntity(
 	@ColumnInfo(name = "title") val title: String,
 	@ColumnInfo(name = "key") val key: String,
 	@ColumnInfo(name = "source") val source: String
-) {
-
-	fun toMangaTag() = MangaTag(
-		key = this.key,
-		title = this.title.toTitleCase(),
-		source = MangaSource.valueOf(this.source)
-	)
-
-	companion object {
-
-		fun fromMangaTag(tag: MangaTag) = TagEntity(
-			title = tag.title,
-			key = tag.key,
-			source = tag.source.name,
-			id = "${tag.key}_${tag.source.name}".longHashCode()
-		)
-	}
-}
+)

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

@@ -6,7 +6,8 @@ import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
 
 @Entity(
-	tableName = "tracks", foreignKeys = [
+	tableName = "tracks",
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],

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

@@ -6,7 +6,8 @@ import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
 
 @Entity(
-	tableName = "track_logs", foreignKeys = [
+	tableName = "track_logs",
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],
@@ -20,5 +21,5 @@ class TrackLogEntity(
 	@ColumnInfo(name = "id") val id: Long = 0L,
 	@ColumnInfo(name = "manga_id", index = true) val mangaId: Long,
 	@ColumnInfo(name = "chapters") val chapters: String,
-	@ColumnInfo(name = "created_at") val createdAt: Long = System.currentTimeMillis()
+	@ColumnInfo(name = "created_at") val createdAt: Long = System.currentTimeMillis(),
 )

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

@@ -3,9 +3,6 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.Embedded
 import androidx.room.Junction
 import androidx.room.Relation
-import org.koitharu.kotatsu.core.model.TrackingLogItem
-import org.koitharu.kotatsu.utils.ext.mapToSet
-import java.util.*
 
 class TrackLogWithManga(
 	@Embedded val trackLog: TrackLogEntity,
@@ -19,13 +16,5 @@ class TrackLogWithManga(
 		entityColumn = "tag_id",
 		associateBy = Junction(MangaTagsEntity::class)
 	)
-	val tags: List<TagEntity>
-) {
-
-	fun toTrackingLogItem() = TrackingLogItem(
-		id = trackLog.id,
-		chapters = trackLog.chapters.split('\n').filterNot { x -> x.isEmpty() },
-		manga = manga.toManga(tags.mapToSet { x -> x.toMangaTag() }),
-		createdAt = Date(trackLog.createdAt)
-	)
-}
+	val tags: List<TagEntity>,
+)

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

@@ -0,0 +1,28 @@
+package org.koitharu.kotatsu.core.model
+
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.util.mapToSet
+
+fun Manga.withoutChapters() = if (chapters.isNullOrEmpty()) {
+	this
+} else {
+	Manga(
+		id = id,
+		title = title,
+		altTitle = altTitle,
+		url = url,
+		publicUrl = publicUrl,
+		rating = rating,
+		isNsfw = isNsfw,
+		coverUrl = coverUrl,
+		tags = tags,
+		state = state,
+		author = author,
+		largeCoverUrl = largeCoverUrl,
+		description = description,
+		chapters = null,
+		source = source,
+	)
+}
+
+fun Collection<Manga>.ids() = mapToSet { it.id }

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

@@ -4,7 +4,7 @@ import android.os.Parcel
 import androidx.core.os.ParcelCompat
 import org.koitharu.kotatsu.parsers.model.*
 
-fun Manga.writeToParcel(out: Parcel, flags: Int) {
+fun Manga.writeToParcel(out: Parcel, flags: Int, withChapters: Boolean) {
 	out.writeLong(id)
 	out.writeString(title)
 	out.writeString(altTitle)
@@ -18,7 +18,11 @@ fun Manga.writeToParcel(out: Parcel, flags: Int) {
 	out.writeParcelable(ParcelableMangaTags(tags), flags)
 	out.writeSerializable(state)
 	out.writeString(author)
-	out.writeParcelable(chapters?.let(::ParcelableMangaChapters), flags)
+	if (withChapters) {
+		out.writeParcelable(chapters?.let(::ParcelableMangaChapters), flags)
+	} else {
+		out.writeString(null)
+	}
 	out.writeSerializable(source)
 }
 

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

@@ -4,13 +4,32 @@ import android.os.Parcel
 import android.os.Parcelable
 import org.koitharu.kotatsu.parsers.model.Manga
 
+// Limits to avoid TransactionTooLargeException
+private const val MAX_SAFE_SIZE = 1024 * 512 // Assume that 512 kb is safe parcel size
+private const val MAX_SAFE_CHAPTERS_COUNT = 40 // this is 100% safe
+
 class ParcelableManga(
 	val manga: Manga,
-): Parcelable {
+) : Parcelable {
+
 	constructor(parcel: Parcel) : this(parcel.readManga())
 
 	override fun writeToParcel(parcel: Parcel, flags: Int) {
-		manga.writeToParcel(parcel, flags)
+		val chapters = manga.chapters
+		if (chapters == null || chapters.size <= MAX_SAFE_CHAPTERS_COUNT) {
+			// fast path
+			manga.writeToParcel(parcel, flags, withChapters = true)
+			return
+		}
+		val tempParcel = Parcel.obtain()
+		manga.writeToParcel(tempParcel, flags, withChapters = true)
+		val size = tempParcel.dataSize()
+		if (size < MAX_SAFE_SIZE) {
+			parcel.appendFrom(tempParcel, 0, size)
+		} else {
+			manga.writeToParcel(parcel, flags, withChapters = false)
+		}
+		tempParcel.recycle()
 	}
 
 	override fun describeContents(): Int {

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

@@ -1,56 +0,0 @@
-package org.koitharu.kotatsu.core.network
-
-import android.util.Log
-import okhttp3.Interceptor
-import okhttp3.Request
-import okhttp3.Response
-import okio.Buffer
-import java.io.IOException
-import java.nio.charset.StandardCharsets
-
-private const val TAG = "CURL"
-
-class CurlLoggingInterceptor(
-	private val extraCurlOptions: String? = null,
-) : Interceptor {
-
-	@Throws(IOException::class)
-	override fun intercept(chain: Interceptor.Chain): Response {
-		val request: Request = chain.request()
-		var compressed = false
-		val curlCmd = StringBuilder("curl")
-		if (extraCurlOptions != null) {
-			curlCmd.append(" ").append(extraCurlOptions)
-		}
-		curlCmd.append(" -X ").append(request.method)
-		val headers = request.headers
-		var i = 0
-		val count = headers.size
-		while (i < count) {
-			val name = headers.name(i)
-			val value = headers.value(i)
-			if ("Accept-Encoding".equals(name, ignoreCase = true) && "gzip".equals(value,
-					ignoreCase = true)
-			) {
-				compressed = true
-			}
-			curlCmd.append(" -H " + "\"").append(name).append(": ").append(value).append("\"")
-			i++
-		}
-		val requestBody = request.body
-		if (requestBody != null) {
-			val buffer = Buffer()
-			requestBody.writeTo(buffer)
-			val contentType = requestBody.contentType()
-			val charset = contentType?.charset(StandardCharsets.UTF_8) ?: StandardCharsets.UTF_8
-			curlCmd.append(" --data $'")
-				.append(buffer.readString(charset).replace("\n", "\\n"))
-				.append("'")
-		}
-		curlCmd.append(if (compressed) " --compressed " else " ").append(request.url)
-		Log.d(TAG, "╭--- cURL (" + request.url + ")")
-		Log.d(TAG, curlCmd.toString())
-		Log.d(TAG, "╰--- (copy and paste the above line to a terminal)")
-		return chain.proceed(request)
-	}
-}

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

@@ -1,15 +1,13 @@
 package org.koitharu.kotatsu.core.network
 
+import java.util.concurrent.TimeUnit
 import okhttp3.CookieJar
 import okhttp3.OkHttpClient
 import org.koin.dsl.bind
 import org.koin.dsl.module
-import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.parser.MangaLoaderContextImpl
 import org.koitharu.kotatsu.local.data.LocalStorageManager
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
-import org.koitharu.kotatsu.utils.DownloadManagerHelper
-import java.util.concurrent.TimeUnit
 
 val networkModule
 	get() = module {
@@ -23,11 +21,7 @@ val networkModule
 				cache(get<LocalStorageManager>().createHttpCache())
 				addInterceptor(UserAgentInterceptor())
 				addInterceptor(CloudFlareInterceptor())
-				if (BuildConfig.DEBUG) {
-					addNetworkInterceptor(CurlLoggingInterceptor())
-				}
 			}.build()
 		}
-		factory { DownloadManagerHelper(get(), get()) }
 		single<MangaLoaderContext> { MangaLoaderContextImpl(get(), get(), get()) }
-	}
+	}

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

@@ -24,7 +24,7 @@ class ShortcutsRepository(
 	private val context: Context,
 	private val coil: ImageLoader,
 	private val historyRepository: HistoryRepository,
-	private val mangaRepository: MangaDataRepository
+	private val mangaRepository: MangaDataRepository,
 ) {
 
 	private val iconSize by lazy {
@@ -69,7 +69,7 @@ class ShortcutsRepository(
 			.setLongLabel(manga.title)
 			.setIcon(icon)
 			.setIntent(
-				ReaderActivity.newIntent(context, manga.id, null)
+				ReaderActivity.newIntent(context, manga.id)
 					.setAction(ReaderActivity.ACTION_MANGA_READ)
 			)
 	}

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

@@ -165,6 +165,18 @@ class AppSettings(context: Context) {
 			else -> SimpleDateFormat(format, Locale.getDefault())
 		}
 
+	fun getSuggestionsTagsBlacklistRegex(): Regex? {
+		val string = prefs.getString(KEY_SUGGESTIONS_EXCLUDE_TAGS, null)?.trimEnd(' ', ',')
+		if (string.isNullOrEmpty()) {
+			return null
+		}
+		val tags = string.split(',')
+		val regex = tags.joinToString(prefix = "(", separator = "|", postfix = ")") { tag ->
+			Regex.escape(tag.trim())
+		}
+		return Regex(regex, RegexOption.IGNORE_CASE)
+	}
+
 	fun getMangaSources(includeHidden: Boolean): List<MangaSource> {
 		val list = MangaSource.values().toMutableList()
 		list.remove(MangaSource.LOCAL)
@@ -247,17 +259,16 @@ class AppSettings(context: Context) {
 		const val KEY_PAGES_PRELOAD = "pages_preload"
 		const val KEY_SUGGESTIONS = "suggestions"
 		const val KEY_SUGGESTIONS_EXCLUDE_NSFW = "suggestions_exclude_nsfw"
+		const val KEY_SUGGESTIONS_EXCLUDE_TAGS = "suggestions_exclude_tags"
 		const val KEY_SEARCH_SINGLE_SOURCE = "search_single_source"
 
 		// About
 		const val KEY_APP_UPDATE = "app_update"
 		const val KEY_APP_UPDATE_AUTO = "app_update_auto"
 		const val KEY_APP_TRANSLATION = "about_app_translation"
-		const val KEY_APP_GRATITUDES = "about_gratitudes"
 		const val KEY_FEEDBACK_4PDA = "about_feedback_4pda"
 		const val KEY_FEEDBACK_DISCORD = "about_feedback_discord"
 		const val KEY_FEEDBACK_GITHUB = "about_feedback_github"
-		const val KEY_SUPPORT_DEVELOPER = "about_support_developer"
 
 		private const val NETWORK_NEVER = 0
 		private const val NETWORK_ALWAYS = 1

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

@@ -3,20 +3,12 @@ package org.koitharu.kotatsu.core.ui
 import android.content.Context
 import android.content.Intent
 import android.util.Log
-import java.io.PrintWriter
-import java.io.StringWriter
 import kotlin.system.exitProcess
 
 class AppCrashHandler(private val applicationContext: Context) : Thread.UncaughtExceptionHandler {
 
 	override fun uncaughtException(t: Thread, e: Throwable) {
-		val crashInfo = buildString {
-			val writer = StringWriter()
-			e.printStackTrace(PrintWriter(writer))
-			append(writer.toString().trimIndent())
-		}
-		val intent = Intent(applicationContext, CrashActivity::class.java)
-		intent.putExtra(Intent.EXTRA_TEXT, crashInfo)
+		val intent = CrashActivity.newIntent(applicationContext, e)
 		intent.flags = (Intent.FLAG_ACTIVITY_CLEAR_TASK or Intent.FLAG_ACTIVITY_NEW_TASK)
 		try {
 			applicationContext.startActivity(intent)

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

@@ -2,6 +2,7 @@ package org.koitharu.kotatsu.core.ui
 
 import android.app.Activity
 import android.content.ActivityNotFoundException
+import android.content.Context
 import android.content.Intent
 import android.net.Uri
 import android.os.Bundle
@@ -11,6 +12,7 @@ import android.view.View
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.databinding.ActivityCrashBinding
 import org.koitharu.kotatsu.main.ui.MainActivity
+import org.koitharu.kotatsu.parsers.util.ellipsize
 import org.koitharu.kotatsu.utils.ShareHelper
 
 class CrashActivity : Activity(), View.OnClickListener {
@@ -63,4 +65,19 @@ class CrashActivity : Activity(), View.OnClickListener {
 			}
 		}
 	}
+
+	companion object {
+
+		private const val MAX_TRACE_SIZE = 131071
+
+		fun newIntent(context: Context, error: Throwable): Intent {
+			val crashInfo = error
+				.stackTraceToString()
+				.trimIndent()
+				.ellipsize(MAX_TRACE_SIZE)
+			val intent = Intent(context, CrashActivity::class.java)
+			intent.putExtra(Intent.EXTRA_TEXT, crashInfo)
+			return intent
+		}
+	}
 }

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

@@ -7,11 +7,11 @@ import android.widget.AdapterView
 import android.widget.Spinner
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.view.ActionMode
+import androidx.appcompat.widget.SearchView
 import androidx.core.graphics.Insets
+import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
-import androidx.recyclerview.widget.RecyclerView
-import com.google.android.material.divider.MaterialDividerItemDecoration
 import org.koin.androidx.viewmodel.ext.android.sharedViewModel
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseFragment
@@ -26,11 +26,15 @@ 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 kotlin.math.roundToInt
 
-class ChaptersFragment : BaseFragment<FragmentChaptersBinding>(),
+class ChaptersFragment :
+	BaseFragment<FragmentChaptersBinding>(),
 	OnListItemClickListener<ChapterListItem>,
 	ActionMode.Callback,
-	AdapterView.OnItemSelectedListener {
+	AdapterView.OnItemSelectedListener,
+	MenuItem.OnActionExpandListener,
+	SearchView.OnQueryTextListener {
 
 	private val viewModel by sharedViewModel<DetailsViewModel>()
 
@@ -63,6 +67,10 @@ class ChaptersFragment : BaseFragment<FragmentChaptersBinding>(),
 		viewModel.isChaptersReversed.observe(viewLifecycleOwner) {
 			activity?.invalidateOptionsMenu()
 		}
+		viewModel.hasChapters.observe(viewLifecycleOwner) {
+			binding.textViewHolder.isGone = it
+			activity?.invalidateOptionsMenu()
+		}
 	}
 
 	override fun onDestroyView() {
@@ -75,11 +83,18 @@ class ChaptersFragment : BaseFragment<FragmentChaptersBinding>(),
 	override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
 		super.onCreateOptionsMenu(menu, inflater)
 		inflater.inflate(R.menu.opt_chapters, menu)
+		val searchMenuItem = menu.findItem(R.id.action_search)
+		searchMenuItem.setOnActionExpandListener(this)
+		val searchView = searchMenuItem.actionView as SearchView
+		searchView.setOnQueryTextListener(this)
+		searchView.setIconifiedByDefault(false)
+		searchView.queryHint = searchMenuItem.title
 	}
 
 	override fun onPrepareOptionsMenu(menu: Menu) {
 		super.onPrepareOptionsMenu(menu)
 		menu.findItem(R.id.action_reversed).isChecked = viewModel.isChaptersReversed.value == true
+		menu.findItem(R.id.action_search).isVisible = viewModel.hasChapters.value == true
 	}
 
 	override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
@@ -114,10 +129,11 @@ class ChaptersFragment : BaseFragment<FragmentChaptersBinding>(),
 		)
 		startActivity(
 			ReaderActivity.newIntent(
-				view.context,
-				viewModel.manga.value ?: return,
-				ReaderState(item.chapter.id, 0, 0)
-			), options.toBundle()
+				context = view.context,
+				manga = viewModel.manga.value ?: return,
+				state = ReaderState(item.chapter.id, 0, 0),
+			),
+			options.toBundle()
 		)
 	}
 
@@ -162,9 +178,7 @@ class ChaptersFragment : BaseFragment<FragmentChaptersBinding>(),
 	override fun onNothingSelected(parent: AdapterView<*>?) = Unit
 
 	override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
-		val manga = viewModel.manga.value
 		mode.menuInflater.inflate(R.menu.mode_chapters, menu)
-		mode.title = manga?.title
 		return true
 	}
 
@@ -174,12 +188,7 @@ class ChaptersFragment : BaseFragment<FragmentChaptersBinding>(),
 		menu.findItem(R.id.action_save).isVisible = items.none { x ->
 			x.chapter.source == MangaSource.LOCAL
 		}
-		mode.subtitle = resources.getQuantityString(
-			R.plurals.chapters_from_x,
-			items.size,
-			items.size,
-			chaptersAdapter?.itemCount ?: 0
-		)
+		mode.title = items.size.toString()
 		return true
 	}
 
@@ -189,6 +198,21 @@ class ChaptersFragment : BaseFragment<FragmentChaptersBinding>(),
 		actionMode = null
 	}
 
+	override fun onMenuItemActionExpand(item: MenuItem?): Boolean = true
+
+	override fun onMenuItemActionCollapse(item: MenuItem?): Boolean {
+		(item?.actionView as? SearchView)?.setQuery("", false)
+		viewModel.performChapterSearch(null)
+		return true
+	}
+
+	override fun onQueryTextSubmit(query: String?): Boolean = false
+
+	override fun onQueryTextChange(newText: String?): Boolean {
+		viewModel.performChapterSearch(newText)
+		return true
+	}
+
 	override fun onWindowInsetsChanged(insets: Insets) {
 		binding.recyclerViewChapters.updatePadding(
 			bottom = insets.bottom + (binding.spinnerBranches?.height ?: 0),
@@ -215,7 +239,8 @@ class ChaptersFragment : BaseFragment<FragmentChaptersBinding>(),
 		if (adapter.itemCount == 0) {
 			val position = list.indexOfFirst { it.hasFlag(ChapterListItem.FLAG_CURRENT) } - 1
 			if (position > 0) {
-				adapter.setItems(list, RecyclerViewScrollCallback(binding.recyclerViewChapters, position))
+				val offset = (resources.getDimensionPixelSize(R.dimen.chapter_list_item_height) * 0.6).roundToInt()
+				adapter.setItems(list, RecyclerViewScrollCallback(binding.recyclerViewChapters, position, offset))
 			} else {
 				adapter.items = list
 			}

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

@@ -1,8 +1,9 @@
 package org.koitharu.kotatsu.details.ui
 
+import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import android.net.Uri
+import android.content.IntentFilter
 import android.os.Bundle
 import android.view.Menu
 import android.view.MenuItem
@@ -15,6 +16,7 @@ import androidx.appcompat.view.ActionMode
 import androidx.core.content.pm.ShortcutManagerCompat
 import androidx.core.graphics.Insets
 import androidx.core.net.toFile
+import androidx.core.net.toUri
 import androidx.core.view.isVisible
 import androidx.core.view.updateLayoutParams
 import androidx.core.view.updatePadding
@@ -52,6 +54,13 @@ class DetailsActivity : BaseActivity<ActivityDetailsBinding>(), TabLayoutMediato
 		parametersOf(MangaIntent(intent))
 	}
 
+	private val downloadReceiver = object : BroadcastReceiver() {
+		override fun onReceive(context: Context?, intent: Intent?) {
+			val downloadedManga = DownloadService.getDownloadedManga(intent) ?: return
+			viewModel.onDownloadComplete(downloadedManga)
+		}
+	}
+
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
 		setContentView(ActivityDetailsBinding.inflate(layoutInflater))
@@ -71,6 +80,13 @@ class DetailsActivity : BaseActivity<ActivityDetailsBinding>(), TabLayoutMediato
 		viewModel.newChaptersCount.observe(this, ::onNewChaptersChanged)
 		viewModel.onMangaRemoved.observe(this, ::onMangaRemoved)
 		viewModel.onError.observe(this, ::onError)
+
+		registerReceiver(downloadReceiver, IntentFilter(DownloadService.ACTION_DOWNLOAD_COMPLETE))
+	}
+
+	override fun onDestroy() {
+		unregisterReceiver(downloadReceiver)
+		super.onDestroy()
 	}
 
 	private fun onMangaUpdated(manga: Manga) {
@@ -147,7 +163,7 @@ class DetailsActivity : BaseActivity<ActivityDetailsBinding>(), TabLayoutMediato
 		R.id.action_share -> {
 			viewModel.manga.value?.let {
 				if (it.source == MangaSource.LOCAL) {
-					ShareHelper(this).shareCbz(Uri.parse(it.url).toFile())
+					ShareHelper(this).shareCbz(listOf(it.url.toUri().toFile()))
 				} else {
 					ShareHelper(this).shareMangaLink(it)
 				}
@@ -256,9 +272,9 @@ class DetailsActivity : BaseActivity<ActivityDetailsBinding>(), TabLayoutMediato
 			setPositiveButton(R.string.read) { _, _ ->
 				startActivity(
 					ReaderActivity.newIntent(
-						this@DetailsActivity,
-						remoteManga,
-						ReaderState(chapterId, 0, 0)
+						context = this@DetailsActivity,
+						manga = remoteManga,
+						state = ReaderState(chapterId, 0, 0)
 					)
 				)
 			}

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

@@ -4,9 +4,7 @@ import android.app.ActivityOptions
 import android.os.Bundle
 import android.text.Spanned
 import android.text.method.LinkMovementMethod
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
+import android.view.*
 import androidx.core.content.ContextCompat
 import androidx.core.graphics.Insets
 import androidx.core.net.toUri
@@ -38,12 +36,20 @@ import org.koitharu.kotatsu.search.ui.SearchActivity
 import org.koitharu.kotatsu.utils.FileSize
 import org.koitharu.kotatsu.utils.ext.*
 
-class DetailsFragment : BaseFragment<FragmentDetailsBinding>(), View.OnClickListener,
-	View.OnLongClickListener, ChipsView.OnChipClickListener {
+class DetailsFragment :
+	BaseFragment<FragmentDetailsBinding>(),
+	View.OnClickListener,
+	View.OnLongClickListener,
+	ChipsView.OnChipClickListener {
 
 	private val viewModel by sharedViewModel<DetailsViewModel>()
 	private val coil by inject<ImageLoader>(mode = LazyThreadSafetyMode.NONE)
 
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		setHasOptionsMenu(true)
+	}
+
 	override fun onInflateView(
 		inflater: LayoutInflater,
 		container: ViewGroup?,
@@ -64,6 +70,11 @@ class DetailsFragment : BaseFragment<FragmentDetailsBinding>(), View.OnClickList
 		viewModel.readingHistory.observe(viewLifecycleOwner, ::onHistoryChanged)
 	}
 
+	override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
+		super.onCreateOptionsMenu(menu, inflater)
+		inflater.inflate(R.menu.opt_details_info, menu)
+	}
+
 	private fun onMangaUpdated(manga: Manga) {
 		with(binding) {
 			// Main
@@ -177,9 +188,9 @@ class DetailsFragment : BaseFragment<FragmentDetailsBinding>(), View.OnClickList
 				} else {
 					startActivity(
 						ReaderActivity.newIntent(
-							context ?: return,
-							manga,
-							null
+							context = context ?: return,
+							manga = manga,
+							branch = viewModel.selectedBranchValue,
 						)
 					)
 				}
@@ -216,11 +227,14 @@ class DetailsFragment : BaseFragment<FragmentDetailsBinding>(), View.OnClickList
 				v.showPopupMenu(R.menu.popup_read) {
 					when (it.itemId) {
 						R.id.action_read -> {
+							val branch = viewModel.selectedBranchValue
 							startActivity(
 								ReaderActivity.newIntent(
-									context ?: return@showPopupMenu false,
-									viewModel.manga.value ?: return@showPopupMenu false,
-									viewModel.chapters.value?.firstOrNull()?.let { c ->
+									context = context ?: return@showPopupMenu false,
+									manga = viewModel.manga.value ?: return@showPopupMenu false,
+									state = viewModel.chapters.value?.firstOrNull { c ->
+										c.chapter.branch == branch
+									}?.let { c ->
 										ReaderState(c.chapter.id, 0, 0)
 									}
 								)
@@ -276,4 +290,4 @@ class DetailsFragment : BaseFragment<FragmentDetailsBinding>(), View.OnClickList
 			.lifecycle(viewLifecycleOwner)
 			.enqueueWith(coil)
 	}
-}
+}

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

@@ -7,7 +7,9 @@ import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
+import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
 import org.koitharu.kotatsu.base.domain.MangaIntent
 import org.koitharu.kotatsu.base.ui.BaseViewModel
@@ -22,11 +24,11 @@ import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.parsers.util.toTitleCase
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.iterator
-import org.koitharu.kotatsu.utils.ext.mapToSet
 import java.io.IOException
 
 class DetailsViewModel(
@@ -40,7 +42,7 @@ class DetailsViewModel(
 ) : BaseViewModel() {
 
 	private var loadingJob: Job
-	private val mangaData = MutableStateFlow<Manga?>(intent.manga)
+	private val mangaData = MutableStateFlow(intent.manga)
 	private val selectedBranch = MutableStateFlow<String?>(null)
 
 	private val history = mangaData.mapNotNull { it?.id }
@@ -61,7 +63,9 @@ class DetailsViewModel(
 			trackingRepository.getNewChaptersCount(mangaId)
 		}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, 0)
 
-	private val remoteManga = MutableStateFlow<Manga?>(null)
+	// Remote manga for saved and saved for remote
+	private val relatedManga = MutableStateFlow<Manga?>(null)
+	private val chaptersQuery = MutableStateFlow("")
 
 	private val chaptersReversed = settings.observe()
 		.filter { it == AppSettings.KEY_REVERSE_CHAPTERS }
@@ -93,23 +97,34 @@ class DetailsViewModel(
 		branches.indexOf(selected)
 	}.asLiveData(viewModelScope.coroutineContext + Dispatchers.Default)
 
-	val chapters = combine(
-		mangaData.map { it?.chapters.orEmpty() },
-		remoteManga,
-		history.map { it?.chapterId },
-		newChapters,
-		selectedBranch
-	) { chapters, sourceManga, currentId, newCount, branch ->
-		val sourceChapters = sourceManga?.chapters
-		if (sourceManga?.source != MangaSource.LOCAL && !sourceChapters.isNullOrEmpty()) {
-			mapChaptersWithSource(chapters, sourceChapters, currentId, newCount, branch)
-		} else {
-			mapChapters(chapters, sourceChapters, currentId, newCount, branch)
-		}
-	}.combine(chaptersReversed) { list, reversed ->
-		if (reversed) list.asReversed() else list
+	val hasChapters = mangaData.map {
+		!(it?.chapters.isNullOrEmpty())
 	}.asLiveData(viewModelScope.coroutineContext + Dispatchers.Default)
 
+	val chapters = combine(
+		combine(
+			mangaData.map { it?.chapters.orEmpty() },
+			relatedManga,
+			history.map { it?.chapterId },
+			newChapters,
+			selectedBranch
+		) { chapters, related, currentId, newCount, branch ->
+			val relatedChapters = related?.chapters
+			if (related?.source != MangaSource.LOCAL && !relatedChapters.isNullOrEmpty()) {
+				mapChaptersWithSource(chapters, relatedChapters, currentId, newCount, branch)
+			} else {
+				mapChapters(chapters, relatedChapters, currentId, newCount, branch)
+			}
+		},
+		chaptersReversed,
+		chaptersQuery,
+	) { list, reversed, query ->
+		(if (reversed) list.asReversed() else list).filterSearch(query)
+	}.asLiveData(viewModelScope.coroutineContext + Dispatchers.Default)
+
+	val selectedBranchValue: String?
+		get() = selectedBranch.value
+
 	init {
 		loadingJob = doLoad()
 	}
@@ -139,7 +154,33 @@ class DetailsViewModel(
 	}
 
 	fun getRemoteManga(): Manga? {
-		return remoteManga.value
+		return relatedManga.value?.takeUnless { it.source == MangaSource.LOCAL }
+	}
+
+	fun performChapterSearch(query: String?) {
+		chaptersQuery.value = query?.trim().orEmpty()
+	}
+
+	fun onDownloadComplete(downloadedManga: Manga) {
+		val currentManga = mangaData.value ?: return
+		if (currentManga.id != downloadedManga.id) {
+			return
+		}
+		if (currentManga.source == MangaSource.LOCAL) {
+			reload()
+		} else {
+			viewModelScope.launch(Dispatchers.Default) {
+				runCatching {
+					localMangaRepository.getDetails(downloadedManga)
+				}.onSuccess {
+					relatedManga.value = it
+				}.onFailure {
+					if (BuildConfig.DEBUG) {
+						it.printStackTrace()
+					}
+				}
+			}
+		}
 	}
 
 	private fun doLoad() = launchLoadingJob(Dispatchers.Default) {
@@ -155,7 +196,7 @@ class DetailsViewModel(
 			predictBranch(manga.chapters)
 		}
 		mangaData.value = manga
-		remoteManga.value = runCatching {
+		relatedManga.value = runCatching {
 			if (manga.source == MangaSource.LOCAL) {
 				val m = localMangaRepository.getRemoteManga(manga) ?: return@runCatching null
 				MangaRepository(m.source).getDetails(m)
@@ -262,4 +303,13 @@ class DetailsViewModel(
 		}
 		return groups.maxByOrNull { it.value.size }?.key
 	}
-}
+
+	private fun List<ChapterListItem>.filterSearch(query: String): List<ChapterListItem> {
+		if (query.isEmpty() || this.isEmpty()) {
+			return this
+		}
+		return filter {
+			it.chapter.name.contains(query, ignoreCase = true)
+		}
+	}
+}

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

@@ -6,7 +6,7 @@ import android.view.ViewGroup
 import android.widget.BaseAdapter
 import android.widget.TextView
 import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.utils.ext.replaceWith
+import org.koitharu.kotatsu.parsers.util.replaceWith
 
 class BranchesAdapter : BaseAdapter() {
 

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

@@ -2,68 +2,32 @@ package org.koitharu.kotatsu.details.ui.adapter
 
 import android.content.Context
 import android.graphics.Canvas
+import android.graphics.Color
 import android.graphics.Paint
-import android.graphics.Rect
-import androidx.core.view.children
+import android.graphics.RectF
+import android.view.View
 import androidx.recyclerview.widget.RecyclerView
+import org.koitharu.kotatsu.base.ui.list.decor.AbstractSelectionItemDecoration
 import org.koitharu.kotatsu.utils.ext.getThemeColor
+import com.google.android.material.R as materialR
 
-class ChaptersSelectionDecoration(context: Context) : RecyclerView.ItemDecoration() {
+class ChaptersSelectionDecoration(context: Context) : AbstractSelectionItemDecoration() {
 
-	private val bounds = Rect()
-	private val selection = HashSet<Long>()
 	private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+	private val radius = context.resources.getDimension(materialR.dimen.abc_control_corner_material)
 
 	init {
-		paint.color = context.getThemeColor(com.google.android.material.R.attr.scrimBackground)
+		paint.color = context.getThemeColor(materialR.attr.colorSecondaryContainer, Color.LTGRAY)
 		paint.style = Paint.Style.FILL
 	}
 
-	val checkedItemsCount: Int
-		get() = selection.size
-
-	val checkedItemsIds: Set<Long>
-		get() = selection
-
-	fun toggleItemChecked(id: Long) {
-		if (!selection.remove(id)) {
-			selection.add(id)
-		}
-	}
-
-	fun setItemIsChecked(id: Long, isChecked: Boolean) {
-		if (isChecked) {
-			selection.add(id)
-		} else {
-			selection.remove(id)
-		}
-	}
-
-	fun checkAll(ids: Collection<Long>) {
-		selection.addAll(ids)
-	}
-
-	fun clearSelection() {
-		selection.clear()
-	}
-
-	override fun onDraw(canvas: Canvas, parent: RecyclerView, state: RecyclerView.State) {
-		canvas.save()
-		if (parent.clipToPadding) {
-			canvas.clipRect(
-				parent.paddingLeft, parent.paddingTop, parent.width - parent.paddingRight,
-				parent.height - parent.paddingBottom
-			)
-		}
-
-		for (child in parent.children) {
-			val itemId = parent.getChildItemId(child)
-			if (itemId in selection) {
-				parent.getDecoratedBoundsWithMargins(child, bounds)
-				bounds.offset(child.translationX.toInt(), child.translationY.toInt())
-				canvas.drawRect(bounds, paint)
-			}
-		}
-		canvas.restore()
+	override fun onDrawBackground(
+		canvas: Canvas,
+		parent: RecyclerView,
+		child: View,
+		bounds: RectF,
+		state: RecyclerView.State,
+	) {
+		canvas.drawRoundRect(bounds, radius, radius, paint)
 	}
 }

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

@@ -8,8 +8,8 @@ import coil.ImageLoader
 import coil.request.ImageRequest
 import coil.size.Scale
 import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.sync.Semaphore
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okio.IOException
@@ -25,13 +25,16 @@ import org.koitharu.kotatsu.parsers.util.await
 import org.koitharu.kotatsu.utils.ext.deleteAwait
 import org.koitharu.kotatsu.utils.ext.referer
 import org.koitharu.kotatsu.utils.ext.waitForNetwork
+import org.koitharu.kotatsu.utils.progress.ProgressJob
 import java.io.File
 
 private const val MAX_DOWNLOAD_ATTEMPTS = 3
+private const val MAX_PARALLEL_DOWNLOADS = 2
 private const val DOWNLOAD_ERROR_DELAY = 500L
 private const val TEMP_PAGE_FILE = "page.tmp"
 
 class DownloadManager(
+	private val coroutineScope: CoroutineScope,
 	private val context: Context,
 	private val imageLoader: ImageLoader,
 	private val okHttp: OkHttpClient,
@@ -39,7 +42,7 @@ class DownloadManager(
 	private val localMangaRepository: LocalMangaRepository,
 ) {
 
-	private val connectivityManager = context.getSystemService(
+	private val connectivityManager = context.applicationContext.getSystemService(
 		Context.CONNECTIVITY_SERVICE
 	) as ConnectivityManager
 	private val coverWidth = context.resources.getDimensionPixelSize(
@@ -48,9 +51,29 @@ class DownloadManager(
 	private val coverHeight = context.resources.getDimensionPixelSize(
 		androidx.core.R.dimen.compat_notification_large_icon_max_height
 	)
+	private val semaphore = Semaphore(MAX_PARALLEL_DOWNLOADS)
 
-	fun downloadManga(manga: Manga, chaptersIds: Set<Long>?, startId: Int) = flow<State> {
-		emit(State.Preparing(startId, manga, null))
+	fun downloadManga(
+		manga: Manga,
+		chaptersIds: Set<Long>?,
+		startId: Int,
+	): ProgressJob<DownloadState> {
+		val stateFlow = MutableStateFlow<DownloadState>(
+			DownloadState.Queued(startId = startId, manga = manga, cover = null)
+		)
+		val job = downloadMangaImpl(manga, chaptersIds, stateFlow, startId)
+		return ProgressJob(job, stateFlow)
+	}
+
+	private fun downloadMangaImpl(
+		manga: Manga,
+		chaptersIds: Set<Long>?,
+		outState: MutableStateFlow<DownloadState>,
+		startId: Int,
+	): Job = coroutineScope.launch(Dispatchers.Default + errorStateHandler(outState)) {
+		semaphore.acquire()
+		coroutineContext[WakeLockNode]?.acquire()
+		outState.value = DownloadState.Preparing(startId, manga, null)
 		var cover: Drawable? = null
 		val destination = localMangaRepository.getOutputDir()
 		checkNotNull(destination) { context.getString(R.string.cannot_find_available_storage) }
@@ -67,7 +90,7 @@ class DownloadManager(
 						.build()
 				).drawable
 			}.getOrNull()
-			emit(State.Preparing(startId, manga, cover))
+			outState.value = DownloadState.Preparing(startId, manga, cover)
 			val data = if (manga.chapters == null) repo.getDetails(manga) else manga
 			output = MangaZip.findInDir(destination, data)
 			output.prepare(data)
@@ -96,43 +119,43 @@ class DownloadManager(
 									MimeTypeMap.getFileExtensionFromUrl(url)
 								)
 							} catch (e: IOException) {
-								emit(State.WaitingForNetwork(startId, manga, cover))
+								outState.value = DownloadState.WaitingForNetwork(startId, data, cover)
 								connectivityManager.waitForNetwork()
 								continue@failsafe
 							}
 						} while (false)
 
-						emit(State.Progress(
-							startId, manga, cover,
+						outState.value = DownloadState.Progress(
+							startId, data, cover,
 							totalChapters = chapters.size,
 							currentChapter = chapterIndex,
 							totalPages = pages.size,
 							currentPage = pageIndex,
-						))
+						)
 					}
 				}
 			}
-			emit(State.PostProcessing(startId, manga, cover))
+			outState.value = DownloadState.PostProcessing(startId, data, cover)
 			if (!output.compress()) {
 				throw RuntimeException("Cannot create target file")
 			}
 			val localManga = localMangaRepository.getFromFile(output.file)
-			emit(State.Done(startId, manga, cover, localManga))
+			outState.value = DownloadState.Done(startId, data, cover, localManga)
 		} catch (_: CancellationException) {
-			emit(State.Cancelling(startId, manga, cover))
+			outState.value = DownloadState.Cancelled(startId, manga, cover)
 		} catch (e: Throwable) {
 			if (BuildConfig.DEBUG) {
 				e.printStackTrace()
 			}
-			emit(State.Error(startId, manga, cover, e))
+			outState.value = DownloadState.Error(startId, manga, cover, e)
 		} finally {
 			withContext(NonCancellable) {
 				output?.cleanup()
 				File(destination, TEMP_PAGE_FILE).deleteAwait()
 			}
+			coroutineContext[WakeLockNode]?.release()
+			semaphore.release()
 		}
-	}.catch { e ->
-		emit(State.Error(startId, manga, null, e))
 	}
 
 	private suspend fun downloadFile(url: String, referer: String, destination: File): File {
@@ -165,71 +188,13 @@ class DownloadManager(
 		}
 	}
 
-	sealed interface State {
-
-		val startId: Int
-		val manga: Manga
-		val cover: Drawable?
-
-		data class Queued(
-			override val startId: Int,
-			override val manga: Manga,
-			override val cover: Drawable?,
-		) : State
-
-		data class Preparing(
-			override val startId: Int,
-			override val manga: Manga,
-			override val cover: Drawable?,
-		) : State
-
-		data class Progress(
-			override val startId: Int,
-			override val manga: Manga,
-			override val cover: Drawable?,
-			val totalChapters: Int,
-			val currentChapter: Int,
-			val totalPages: Int,
-			val currentPage: Int,
-		): State {
-
-			val max: Int = totalChapters * totalPages
-
-			val progress: Int = totalPages * currentChapter + currentPage + 1
-
-			val percent: Float = progress.toFloat() / max
-		}
-
-		data class WaitingForNetwork(
-			override val startId: Int,
-			override val manga: Manga,
-			override val cover: Drawable?,
-		): State
-
-		data class Done(
-			override val startId: Int,
-			override val manga: Manga,
-			override val cover: Drawable?,
-			val localManga: Manga,
-		) : State
-
-		data class Error(
-			override val startId: Int,
-			override val manga: Manga,
-			override val cover: Drawable?,
-			val error: Throwable,
-		) : State
-
-		data class Cancelling(
-			override val startId: Int,
-			override val manga: Manga,
-			override val cover: Drawable?,
-		): State
-
-		data class PostProcessing(
-			override val startId: Int,
-			override val manga: Manga,
-			override val cover: Drawable?,
-		) : State
+	private fun errorStateHandler(outState: MutableStateFlow<DownloadState>) = CoroutineExceptionHandler { _, throwable ->
+		val prevValue = outState.value
+		outState.value = DownloadState.Error(
+			startId = prevValue.startId,
+			manga = prevValue.manga,
+			cover = prevValue.cover,
+			error = throwable,
+		)
 	}
-}
+}

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

@@ -0,0 +1,251 @@
+package org.koitharu.kotatsu.download.domain
+
+import android.graphics.drawable.Drawable
+import org.koitharu.kotatsu.parsers.model.Manga
+
+sealed interface DownloadState {
+
+	val startId: Int
+	val manga: Manga
+	val cover: Drawable?
+
+	class Queued(
+		override val startId: Int,
+		override val manga: Manga,
+		override val cover: Drawable?,
+	) : DownloadState {
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as Queued
+
+			if (startId != other.startId) return false
+			if (manga != other.manga) return false
+			if (cover != other.cover) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = startId
+			result = 31 * result + manga.hashCode()
+			result = 31 * result + (cover?.hashCode() ?: 0)
+			return result
+		}
+	}
+
+	class Preparing(
+		override val startId: Int,
+		override val manga: Manga,
+		override val cover: Drawable?,
+	) : DownloadState {
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as Preparing
+
+			if (startId != other.startId) return false
+			if (manga != other.manga) return false
+			if (cover != other.cover) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = startId
+			result = 31 * result + manga.hashCode()
+			result = 31 * result + (cover?.hashCode() ?: 0)
+			return result
+		}
+	}
+
+	class Progress(
+		override val startId: Int,
+		override val manga: Manga,
+		override val cover: Drawable?,
+		val totalChapters: Int,
+		val currentChapter: Int,
+		val totalPages: Int,
+		val currentPage: Int,
+	) : DownloadState {
+
+		val max: Int = totalChapters * totalPages
+
+		val progress: Int = totalPages * currentChapter + currentPage + 1
+
+		val percent: Float = progress.toFloat() / max
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as Progress
+
+			if (startId != other.startId) return false
+			if (manga != other.manga) return false
+			if (cover != other.cover) return false
+			if (totalChapters != other.totalChapters) return false
+			if (currentChapter != other.currentChapter) return false
+			if (totalPages != other.totalPages) return false
+			if (currentPage != other.currentPage) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = startId
+			result = 31 * result + manga.hashCode()
+			result = 31 * result + (cover?.hashCode() ?: 0)
+			result = 31 * result + totalChapters
+			result = 31 * result + currentChapter
+			result = 31 * result + totalPages
+			result = 31 * result + currentPage
+			return result
+		}
+	}
+
+	class WaitingForNetwork(
+		override val startId: Int,
+		override val manga: Manga,
+		override val cover: Drawable?,
+	) : DownloadState {
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as WaitingForNetwork
+
+			if (startId != other.startId) return false
+			if (manga != other.manga) return false
+			if (cover != other.cover) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = startId
+			result = 31 * result + manga.hashCode()
+			result = 31 * result + (cover?.hashCode() ?: 0)
+			return result
+		}
+	}
+
+	class Done(
+		override val startId: Int,
+		override val manga: Manga,
+		override val cover: Drawable?,
+		val localManga: Manga,
+	) : DownloadState {
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as Done
+
+			if (startId != other.startId) return false
+			if (manga != other.manga) return false
+			if (cover != other.cover) return false
+			if (localManga != other.localManga) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = startId
+			result = 31 * result + manga.hashCode()
+			result = 31 * result + (cover?.hashCode() ?: 0)
+			result = 31 * result + localManga.hashCode()
+			return result
+		}
+	}
+
+	class Error(
+		override val startId: Int,
+		override val manga: Manga,
+		override val cover: Drawable?,
+		val error: Throwable,
+	) : DownloadState {
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as Error
+
+			if (startId != other.startId) return false
+			if (manga != other.manga) return false
+			if (cover != other.cover) return false
+			if (error != other.error) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = startId
+			result = 31 * result + manga.hashCode()
+			result = 31 * result + (cover?.hashCode() ?: 0)
+			result = 31 * result + error.hashCode()
+			return result
+		}
+	}
+
+	class Cancelled(
+		override val startId: Int,
+		override val manga: Manga,
+		override val cover: Drawable?,
+	) : DownloadState {
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as Cancelled
+
+			if (startId != other.startId) return false
+			if (manga != other.manga) return false
+			if (cover != other.cover) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = startId
+			result = 31 * result + manga.hashCode()
+			result = 31 * result + (cover?.hashCode() ?: 0)
+			return result
+		}
+	}
+
+	class PostProcessing(
+		override val startId: Int,
+		override val manga: Manga,
+		override val cover: Drawable?,
+	) : DownloadState {
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as PostProcessing
+
+			if (startId != other.startId) return false
+			if (manga != other.manga) return false
+			if (cover != other.cover) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = startId
+			result = 31 * result + manga.hashCode()
+			result = 31 * result + (cover?.hashCode() ?: 0)
+			return result
+		}
+	}
+}

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

@@ -0,0 +1,25 @@
+package org.koitharu.kotatsu.download.domain
+
+import android.os.PowerManager
+import kotlin.coroutines.AbstractCoroutineContextElement
+import kotlin.coroutines.CoroutineContext
+
+class WakeLockNode(
+	private val wakeLock: PowerManager.WakeLock,
+	private val timeout: Long,
+) : AbstractCoroutineContextElement(Key) {
+
+	init {
+		wakeLock.setReferenceCounted(true)
+	}
+
+	fun acquire() {
+		wakeLock.acquire(timeout)
+	}
+
+	fun release() {
+		wakeLock.release()
+	}
+
+	companion object Key : CoroutineContext.Key<WakeLockNode>
+}

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

@@ -9,18 +9,20 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.databinding.ItemDownloadBinding
-import org.koitharu.kotatsu.download.domain.DownloadManager
+import org.koitharu.kotatsu.download.domain.DownloadState
+import org.koitharu.kotatsu.parsers.util.format
 import org.koitharu.kotatsu.utils.ext.*
 import org.koitharu.kotatsu.utils.progress.ProgressJob
 
 fun downloadItemAD(
 	scope: CoroutineScope,
 	coil: ImageLoader,
-) = adapterDelegateViewBinding<ProgressJob<DownloadManager.State>, ProgressJob<DownloadManager.State>, ItemDownloadBinding>(
+) = adapterDelegateViewBinding<ProgressJob<DownloadState>, ProgressJob<DownloadState>, ItemDownloadBinding>(
 	{ inflater, parent -> ItemDownloadBinding.inflate(inflater, parent, false) }
 ) {
 
 	var job: Job? = null
+	val percentPattern = context.resources.getString(R.string.percent_string_pattern)
 
 	bind {
 		job?.cancel()
@@ -35,62 +37,62 @@ fun downloadItemAD(
 		}.onEach { state ->
 			binding.textViewTitle.text = state.manga.title
 			when (state) {
-				is DownloadManager.State.Cancelling -> {
+				is DownloadState.Cancelled -> {
 					binding.textViewStatus.setText(R.string.cancelling_)
-					binding.progressBar.setIndeterminateCompat(true)
+					binding.progressBar.isIndeterminate = true
 					binding.progressBar.isVisible = true
 					binding.textViewPercent.isVisible = false
 					binding.textViewDetails.isVisible = false
 				}
-				is DownloadManager.State.Done -> {
+				is DownloadState.Done -> {
 					binding.textViewStatus.setText(R.string.download_complete)
-					binding.progressBar.setIndeterminateCompat(false)
+					binding.progressBar.isIndeterminate = false
 					binding.progressBar.isVisible = false
 					binding.textViewPercent.isVisible = false
 					binding.textViewDetails.isVisible = false
 				}
-				is DownloadManager.State.Error -> {
+				is DownloadState.Error -> {
 					binding.textViewStatus.setText(R.string.error_occurred)
-					binding.progressBar.setIndeterminateCompat(false)
+					binding.progressBar.isIndeterminate = false
 					binding.progressBar.isVisible = false
 					binding.textViewPercent.isVisible = false
 					binding.textViewDetails.text = state.error.getDisplayMessage(context.resources)
 					binding.textViewDetails.isVisible = true
 				}
-				is DownloadManager.State.PostProcessing -> {
+				is DownloadState.PostProcessing -> {
 					binding.textViewStatus.setText(R.string.processing_)
-					binding.progressBar.setIndeterminateCompat(true)
+					binding.progressBar.isIndeterminate = true
 					binding.progressBar.isVisible = true
 					binding.textViewPercent.isVisible = false
 					binding.textViewDetails.isVisible = false
 				}
-				is DownloadManager.State.Preparing -> {
+				is DownloadState.Preparing -> {
 					binding.textViewStatus.setText(R.string.preparing_)
-					binding.progressBar.setIndeterminateCompat(true)
+					binding.progressBar.isIndeterminate = true
 					binding.progressBar.isVisible = true
 					binding.textViewPercent.isVisible = false
 					binding.textViewDetails.isVisible = false
 				}
-				is DownloadManager.State.Progress -> {
+				is DownloadState.Progress -> {
 					binding.textViewStatus.setText(R.string.manga_downloading_)
-					binding.progressBar.setIndeterminateCompat(false)
+					binding.progressBar.isIndeterminate = false
 					binding.progressBar.isVisible = true
 					binding.progressBar.max = state.max
 					binding.progressBar.setProgressCompat(state.progress, true)
-					binding.textViewPercent.text = (state.percent * 100f).format(1) + "%"
+					binding.textViewPercent.text = percentPattern.format((state.percent * 100f).format(1))
 					binding.textViewPercent.isVisible = true
 					binding.textViewDetails.isVisible = false
 				}
-				is DownloadManager.State.Queued -> {
+				is DownloadState.Queued -> {
 					binding.textViewStatus.setText(R.string.queued)
-					binding.progressBar.setIndeterminateCompat(false)
+					binding.progressBar.isIndeterminate = false
 					binding.progressBar.isVisible = false
 					binding.textViewPercent.isVisible = false
 					binding.textViewDetails.isVisible = false
 				}
-				is DownloadManager.State.WaitingForNetwork -> {
+				is DownloadState.WaitingForNetwork -> {
 					binding.textViewStatus.setText(R.string.waiting_for_network)
-					binding.progressBar.setIndeterminateCompat(false)
+					binding.progressBar.isIndeterminate = false
 					binding.progressBar.isVisible = false
 					binding.textViewPercent.isVisible = false
 					binding.textViewDetails.isVisible = false

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

@@ -4,13 +4,13 @@ import androidx.recyclerview.widget.DiffUtil
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
 import kotlinx.coroutines.CoroutineScope
-import org.koitharu.kotatsu.download.domain.DownloadManager
+import org.koitharu.kotatsu.download.domain.DownloadState
 import org.koitharu.kotatsu.utils.progress.ProgressJob
 
 class DownloadsAdapter(
 	scope: CoroutineScope,
 	coil: ImageLoader,
-) : AsyncListDifferDelegationAdapter<ProgressJob<DownloadManager.State>>(DiffCallback()) {
+) : AsyncListDifferDelegationAdapter<ProgressJob<DownloadState>>(DiffCallback()) {
 
 	init {
 		delegatesManager.addDelegate(downloadItemAD(scope, coil))
@@ -21,18 +21,18 @@ class DownloadsAdapter(
 		return items[position].progressValue.startId.toLong()
 	}
 
-	private class DiffCallback : DiffUtil.ItemCallback<ProgressJob<DownloadManager.State>>() {
+	private class DiffCallback : DiffUtil.ItemCallback<ProgressJob<DownloadState>>() {
 
 		override fun areItemsTheSame(
-			oldItem: ProgressJob<DownloadManager.State>,
-			newItem: ProgressJob<DownloadManager.State>,
+			oldItem: ProgressJob<DownloadState>,
+			newItem: ProgressJob<DownloadState>,
 		): Boolean {
 			return oldItem.progressValue.startId == newItem.progressValue.startId
 		}
 
 		override fun areContentsTheSame(
-			oldItem: ProgressJob<DownloadManager.State>,
-			newItem: ProgressJob<DownloadManager.State>,
+			oldItem: ProgressJob<DownloadState>,
+			newItem: ProgressJob<DownloadState>,
 		): Boolean {
 			return oldItem.progressValue == newItem.progressValue
 		}

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

@@ -11,19 +11,17 @@ import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.ContextCompat
 import androidx.core.graphics.drawable.toBitmap
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.CrashActivity
 import org.koitharu.kotatsu.details.ui.DetailsActivity
-import org.koitharu.kotatsu.download.domain.DownloadManager
+import org.koitharu.kotatsu.download.domain.DownloadState
 import org.koitharu.kotatsu.download.ui.DownloadsActivity
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.util.format
 import org.koitharu.kotatsu.utils.PendingIntentCompat
-import org.koitharu.kotatsu.utils.ext.format
 import org.koitharu.kotatsu.utils.ext.getDisplayMessage
 import com.google.android.material.R as materialR
 
-class DownloadNotification(
-	private val context: Context,
-	startId: Int,
-) {
+class DownloadNotification(private val context: Context, startId: Int) {
 
 	private val builder = NotificationCompat.Builder(context, CHANNEL_ID)
 	private val cancelAction = NotificationCompat.Action(
@@ -47,9 +45,11 @@ class DownloadNotification(
 		builder.setOnlyAlertOnce(true)
 		builder.setDefaults(0)
 		builder.color = ContextCompat.getColor(context, R.color.blue_primary)
+		builder.foregroundServiceBehavior = NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE
+		builder.setSilent(true)
 	}
 
-	fun create(state: DownloadManager.State): Notification {
+	fun create(state: DownloadState): Notification {
 		builder.setContentTitle(state.manga.title)
 		builder.setContentText(context.getString(R.string.manga_downloading_))
 		builder.setProgress(1, 0, true)
@@ -59,13 +59,14 @@ class DownloadNotification(
 		builder.setLargeIcon(state.cover?.toBitmap())
 		builder.clearActions()
 		when (state) {
-			is DownloadManager.State.Cancelling -> {
+			is DownloadState.Cancelled -> {
 				builder.setProgress(1, 0, true)
 				builder.setContentText(context.getString(R.string.cancelling_))
 				builder.setContentIntent(null)
 				builder.setStyle(null)
+				builder.setOngoing(true)
 			}
-			is DownloadManager.State.Done -> {
+			is DownloadState.Done -> {
 				builder.setProgress(0, 0, false)
 				builder.setContentText(context.getString(R.string.download_complete))
 				builder.setContentIntent(createMangaIntent(context, state.localManga))
@@ -73,40 +74,60 @@ class DownloadNotification(
 				builder.setSmallIcon(android.R.drawable.stat_sys_download_done)
 				builder.setCategory(null)
 				builder.setStyle(null)
+				builder.setOngoing(false)
 			}
-			is DownloadManager.State.Error -> {
+			is DownloadState.Error -> {
 				val message = state.error.getDisplayMessage(context.resources)
 				builder.setProgress(0, 0, false)
 				builder.setSmallIcon(android.R.drawable.stat_notify_error)
 				builder.setSubText(context.getString(R.string.error))
 				builder.setContentText(message)
 				builder.setAutoCancel(true)
+				builder.setOngoing(false)
+				builder.setContentIntent(
+					PendingIntent.getActivity(
+						context,
+						state.manga.hashCode(),
+						CrashActivity.newIntent(context, state.error),
+						PendingIntent.FLAG_CANCEL_CURRENT or PendingIntentCompat.FLAG_IMMUTABLE
+					)
+				)
 				builder.setCategory(NotificationCompat.CATEGORY_ERROR)
 				builder.setStyle(NotificationCompat.BigTextStyle().bigText(message))
 			}
-			is DownloadManager.State.PostProcessing -> {
+			is DownloadState.PostProcessing -> {
 				builder.setProgress(1, 0, true)
 				builder.setContentText(context.getString(R.string.processing_))
 				builder.setStyle(null)
+				builder.setOngoing(true)
 			}
-			is DownloadManager.State.Queued,
-			is DownloadManager.State.Preparing -> {
+			is DownloadState.Queued -> {
+				builder.setProgress(0, 0, false)
+				builder.setContentText(context.getString(R.string.queued))
+				builder.setStyle(null)
+				builder.setOngoing(true)
+				builder.addAction(cancelAction)
+			}
+			is DownloadState.Preparing -> {
 				builder.setProgress(1, 0, true)
 				builder.setContentText(context.getString(R.string.preparing_))
 				builder.setStyle(null)
+				builder.setOngoing(true)
 				builder.addAction(cancelAction)
 			}
-			is DownloadManager.State.Progress -> {
+			is DownloadState.Progress -> {
 				builder.setProgress(state.max, state.progress, false)
 				builder.setContentText((state.percent * 100).format() + "%")
 				builder.setCategory(NotificationCompat.CATEGORY_PROGRESS)
 				builder.setStyle(null)
+				builder.setOngoing(true)
 				builder.addAction(cancelAction)
 			}
-			is DownloadManager.State.WaitingForNetwork -> {
+			is DownloadState.WaitingForNetwork -> {
 				builder.setProgress(0, 0, false)
 				builder.setContentText(context.getString(R.string.waiting_for_network))
 				builder.setStyle(null)
+				builder.setOngoing(true)
 				builder.addAction(cancelAction)
 			}
 		}

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

@@ -8,19 +8,15 @@ import android.os.Binder
 import android.os.IBinder
 import android.os.PowerManager
 import android.widget.Toast
-import androidx.core.app.NotificationManagerCompat
-import androidx.core.app.ServiceCompat
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.lifecycleScope
-import kotlinx.coroutines.Dispatchers
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.mapLatest
-import kotlinx.coroutines.isActive
+import kotlinx.coroutines.flow.transformWhile
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.plus
 import org.koin.android.ext.android.get
 import org.koin.core.context.GlobalContext
 import org.koitharu.kotatsu.BuildConfig
@@ -28,33 +24,41 @@ import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseService
 import org.koitharu.kotatsu.base.ui.dialog.CheckBoxAlertDialog
 import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.model.withoutChapters
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.download.domain.DownloadManager
+import org.koitharu.kotatsu.download.domain.DownloadState
+import org.koitharu.kotatsu.download.domain.WakeLockNode
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.utils.ext.connectivityManager
+import org.koitharu.kotatsu.utils.ext.throttle
 import org.koitharu.kotatsu.utils.ext.toArraySet
 import org.koitharu.kotatsu.utils.progress.ProgressJob
 import java.util.concurrent.TimeUnit
-import kotlin.collections.set
 
 class DownloadService : BaseService() {
 
-	private lateinit var notificationManager: NotificationManagerCompat
-	private lateinit var wakeLock: PowerManager.WakeLock
 	private lateinit var downloadManager: DownloadManager
+	private lateinit var notificationSwitcher: ForegroundNotificationSwitcher
 
-	private val jobs = LinkedHashMap<Int, ProgressJob<DownloadManager.State>>()
+	private val jobs = LinkedHashMap<Int, ProgressJob<DownloadState>>()
 	private val jobCount = MutableStateFlow(0)
-	private val mutex = Mutex()
 	private val controlReceiver = ControlReceiver()
 	private var binder: DownloadBinder? = null
 
 	override fun onCreate() {
 		super.onCreate()
-		notificationManager = NotificationManagerCompat.from(this)
-		wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager)
+		notificationSwitcher = ForegroundNotificationSwitcher(this)
+		val wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager)
 			.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "kotatsu:downloading")
-		downloadManager = DownloadManager(this, get(), get(), get(), get())
+		downloadManager = DownloadManager(
+			coroutineScope = lifecycleScope + WakeLockNode(wakeLock, TimeUnit.HOURS.toMillis(1)),
+			context = this,
+			imageLoader = get(),
+			okHttp = get(),
+			cache = get(),
+			localMangaRepository = get(),
+		)
 		DownloadNotification.createChannel(this)
 		registerReceiver(controlReceiver, IntentFilter(ACTION_DOWNLOAD_CANCEL))
 	}
@@ -66,7 +70,6 @@ class DownloadService : BaseService() {
 		return if (manga != null) {
 			jobs[startId] = downloadManga(startId, manga, chapters)
 			jobCount.value = jobs.size
-			Toast.makeText(this, R.string.manga_downloading_, Toast.LENGTH_SHORT).show()
 			START_REDELIVER_INTENT
 		} else {
 			stopSelf(startId)
@@ -94,47 +97,50 @@ class DownloadService : BaseService() {
 		startId: Int,
 		manga: Manga,
 		chaptersIds: Set<Long>?,
-	): ProgressJob<DownloadManager.State> {
-		val initialState = DownloadManager.State.Queued(startId, manga, null)
-		val stateFlow = MutableStateFlow<DownloadManager.State>(initialState)
-		val job = lifecycleScope.launch {
-			mutex.withLock {
-				wakeLock.acquire(TimeUnit.HOURS.toMillis(1))
-				val notification = DownloadNotification(this@DownloadService, startId)
-				startForeground(startId, notification.create(initialState))
-				try {
-					withContext(Dispatchers.Default) {
-						downloadManager.downloadManga(manga, chaptersIds, startId)
-							.collect { state ->
-								stateFlow.value = state
-								notificationManager.notify(startId, notification.create(state))
-							}
-					}
-					if (stateFlow.value is DownloadManager.State.Done) {
-						sendBroadcast(
-							Intent(ACTION_DOWNLOAD_COMPLETE)
-								.putExtra(EXTRA_MANGA, ParcelableManga(manga))
-						)
-					}
-				} finally {
-					ServiceCompat.stopForeground(
-						this@DownloadService,
-						if (isActive) {
-							ServiceCompat.STOP_FOREGROUND_DETACH
-						} else {
-							ServiceCompat.STOP_FOREGROUND_REMOVE
-						}
-					)
-					if (wakeLock.isHeld) {
-						wakeLock.release()
-					}
-					stopSelf(startId)
-				}
-			}
-		}
-		return ProgressJob(job, stateFlow)
+	): ProgressJob<DownloadState> {
+		val job = downloadManager.downloadManga(manga, chaptersIds, startId)
+		listenJob(job)
+		return job
 	}
 
+	private fun listenJob(job: ProgressJob<DownloadState>) {
+		lifecycleScope.launch {
+			val startId = job.progressValue.startId
+			val notification = DownloadNotification(this@DownloadService, startId)
+			notificationSwitcher.notify(startId, notification.create(job.progressValue))
+			job.progressAsFlow()
+				.throttle { state -> if (state is DownloadState.Progress) 400L else 0L }
+				.whileActive()
+				.collect { state ->
+					notificationSwitcher.notify(startId, notification.create(state))
+				}
+			job.join()
+			(job.progressValue as? DownloadState.Done)?.let {
+				sendBroadcast(
+					Intent(ACTION_DOWNLOAD_COMPLETE)
+						.putExtra(EXTRA_MANGA, ParcelableManga(it.localManga.withoutChapters()))
+				)
+			}
+			notificationSwitcher.detach(
+				startId,
+				if (job.isCancelled) {
+					null
+				} else {
+					notification.create(job.progressValue)
+				}
+			)
+			stopSelf(startId)
+		}
+	}
+
+	private fun Flow<DownloadState>.whileActive(): Flow<DownloadState> = transformWhile { state ->
+		emit(state)
+		!state.isTerminal
+	}
+
+	private val DownloadState.isTerminal: Boolean
+		get() = this is DownloadState.Done || this is DownloadState.Error || this is DownloadState.Cancelled
+
 	inner class ControlReceiver : BroadcastReceiver() {
 
 		override fun onReceive(context: Context, intent: Intent?) {
@@ -150,7 +156,7 @@ class DownloadService : BaseService() {
 
 	class DownloadBinder(private val service: DownloadService) : Binder() {
 
-		val downloads: Flow<Collection<ProgressJob<DownloadManager.State>>>
+		val downloads: Flow<Collection<ProgressJob<DownloadState>>>
 			get() = service.jobCount.mapLatest { service.jobs.values }
 	}
 
@@ -177,11 +183,42 @@ class DownloadService : BaseService() {
 					intent.putExtra(EXTRA_CHAPTERS_IDS, chaptersIds.toLongArray())
 				}
 				ContextCompat.startForegroundService(context, intent)
+				Toast.makeText(context, R.string.manga_downloading_, Toast.LENGTH_SHORT).show()
 			}
 		}
 
+		fun start(context: Context, manga: Collection<Manga>) {
+			if (manga.isEmpty()) {
+				return
+			}
+			confirmDataTransfer(context) {
+				for (item in manga) {
+					val intent = Intent(context, DownloadService::class.java)
+					intent.putExtra(EXTRA_MANGA, ParcelableManga(item))
+					ContextCompat.startForegroundService(context, intent)
+				}
+			}
+		}
+
+		fun confirmAndStart(context: Context, items: Set<Manga>) {
+			MaterialAlertDialogBuilder(context)
+				.setTitle(R.string.save_manga)
+				.setMessage(R.string.batch_manga_save_confirm)
+				.setNegativeButton(android.R.string.cancel, null)
+				.setPositiveButton(R.string.save) { _, _ ->
+					start(context, items)
+				}.show()
+		}
+
 		fun getCancelIntent(startId: Int) = Intent(ACTION_DOWNLOAD_CANCEL)
-			.putExtra(ACTION_DOWNLOAD_CANCEL, startId)
+			.putExtra(EXTRA_CANCEL_ID, startId)
+
+		fun getDownloadedManga(intent: Intent?): Manga? {
+			if (intent?.action == ACTION_DOWNLOAD_COMPLETE) {
+				return intent.getParcelableExtra<ParcelableManga>(EXTRA_MANGA)?.manga
+			}
+			return null
+		}
 
 		private fun confirmDataTransfer(context: Context, callback: () -> Unit) {
 			val settings = GlobalContext.get().get<AppSettings>()

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

@@ -0,0 +1,72 @@
+package org.koitharu.kotatsu.download.ui.service
+
+import android.app.Notification
+import android.app.NotificationManager
+import android.app.Service
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.SparseArray
+import androidx.core.app.ServiceCompat
+import androidx.core.util.isEmpty
+import androidx.core.util.size
+
+private const val DEFAULT_DELAY = 500L
+
+class ForegroundNotificationSwitcher(
+	private val service: Service,
+) {
+
+	private val notificationManager = service.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+	private val notifications = SparseArray<Notification>()
+	private val handler = Handler(Looper.getMainLooper())
+
+	@Synchronized
+	fun notify(startId: Int, notification: Notification) {
+		if (notifications.isEmpty()) {
+			StartForegroundRunnable(startId, notification)
+		} else {
+			notificationManager.notify(startId, notification)
+		}
+		notifications[startId] = notification
+	}
+
+	@Synchronized
+	fun detach(startId: Int, notification: Notification?) {
+		notifications.remove(startId)
+		if (notifications.isEmpty()) {
+			ServiceCompat.stopForeground(service, ServiceCompat.STOP_FOREGROUND_DETACH)
+		}
+		val nextIndex = notifications.size - 1
+		if (nextIndex >= 0) {
+			val nextStartId = notifications.keyAt(nextIndex)
+			val nextNotification = notifications.valueAt(nextIndex)
+			service.startForeground(nextStartId, nextNotification)
+		}
+		handler.postDelayed(NotifyRunnable(startId, notification), DEFAULT_DELAY)
+	}
+
+	private inner class StartForegroundRunnable(
+		private val startId: Int,
+		private val notification: Notification,
+	) : Runnable {
+
+		override fun run() {
+			service.startForeground(startId, notification)
+		}
+	}
+
+	private inner class NotifyRunnable(
+		private val startId: Int,
+		private val notification: Notification?,
+	) : Runnable {
+
+		override fun run() {
+			if (notification != null) {
+				notificationManager.notify(startId, notification)
+			} else {
+				notificationManager.cancel(startId)
+			}
+		}
+	}
+}

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

@@ -0,0 +1,14 @@
+package org.koitharu.kotatsu.favourites.data
+
+import java.util.*
+import org.koitharu.kotatsu.core.db.entity.SortOrder
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.parsers.model.SortOrder
+
+fun FavouriteCategoryEntity.toFavouriteCategory(id: Long = categoryId.toLong()) = FavouriteCategory(
+	id = id,
+	title = title,
+	sortKey = sortKey,
+	order = SortOrder(order, SortOrder.NEWEST),
+	createdAt = Date(createdAt),
+)

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

@@ -3,9 +3,6 @@ package org.koitharu.kotatsu.favourites.data
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.parsers.model.SortOrder
-import java.util.*
 
 @Entity(tableName = "favourite_categories")
 class FavouriteCategoryEntity(
@@ -15,13 +12,4 @@ class FavouriteCategoryEntity(
 	@ColumnInfo(name = "sort_key") val sortKey: Int,
 	@ColumnInfo(name = "title") val title: String,
 	@ColumnInfo(name = "order") val order: String,
-) {
-
-	fun toFavouriteCategory(id: Long? = null) = FavouriteCategory(
-		id = id ?: categoryId.toLong(),
-		title = title,
-		sortKey = sortKey,
-		order = SortOrder.values().find { x -> x.name == order } ?: SortOrder.NEWEST,
-		createdAt = Date(createdAt),
-	)
-}
+)

app/src/main/java/org/koitharu/kotatsu/favourites/domain/FavouritesRepository.kt

@@ -6,36 +6,35 @@ import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.MangaEntity
-import org.koitharu.kotatsu.core.db.entity.TagEntity
+import org.koitharu.kotatsu.core.db.entity.*
 import org.koitharu.kotatsu.core.model.FavouriteCategory
 import org.koitharu.kotatsu.favourites.data.FavouriteCategoryEntity
 import org.koitharu.kotatsu.favourites.data.FavouriteEntity
+import org.koitharu.kotatsu.favourites.data.toFavouriteCategory
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.utils.ext.mapItems
-import org.koitharu.kotatsu.utils.ext.mapToSet
 
 class FavouritesRepository(private val db: MangaDatabase) {
 
 	suspend fun getAllManga(): List<Manga> {
 		val entities = db.favouritesDao.findAll()
-		return entities.map { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+		return entities.map { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
 	fun observeAll(order: SortOrder): Flow<List<Manga>> {
 		return db.favouritesDao.observeAll(order)
-			.mapItems { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+			.mapItems { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
 	suspend fun getManga(categoryId: Long): List<Manga> {
 		val entities = db.favouritesDao.findAll(categoryId)
-		return entities.map { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+		return entities.map { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
 	fun observeAll(categoryId: Long, order: SortOrder): Flow<List<Manga>> {
 		return db.favouritesDao.observeAll(categoryId, order)
-			.mapItems { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+			.mapItems { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
 	fun observeAll(categoryId: Long): Flow<List<Manga>> {
@@ -43,21 +42,6 @@ class FavouritesRepository(private val db: MangaDatabase) {
 			.flatMapLatest { order -> observeAll(categoryId, order) }
 	}
 
-	suspend fun getManga(categoryId: Long, offset: Int): List<Manga> {
-		val entities = db.favouritesDao.findAll(categoryId, offset, 20)
-		return entities.map { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
-	}
-
-	suspend fun getAllCategories(): List<FavouriteCategory> {
-		val entities = db.favouriteCategoriesDao.findAll()
-		return entities.map { it.toFavouriteCategory() }
-	}
-
-	suspend fun getCategories(mangaId: Long): List<FavouriteCategory> {
-		val entities = db.favouritesDao.find(mangaId)?.categories
-		return entities?.map { it.toFavouriteCategory() }.orEmpty()
-	}
-
 	fun observeCategories(): Flow<List<FavouriteCategory>> {
 		return db.favouriteCategoriesDao.observeAll().mapItems {
 			it.toFavouriteCategory()
@@ -70,8 +54,8 @@ class FavouritesRepository(private val db: MangaDatabase) {
 		}.distinctUntilChanged()
 	}
 
-	fun observeCategoriesIds(mangaId: Long): Flow<List<Long>> {
-		return db.favouritesDao.observeIds(mangaId)
+	fun observeCategoriesIds(mangaId: Long): Flow<Set<Long>> {
+		return db.favouritesDao.observeIds(mangaId).map { it.toSet() }
 	}
 
 	suspend fun addCategory(title: String): FavouriteCategory {
@@ -107,27 +91,37 @@ class FavouritesRepository(private val db: MangaDatabase) {
 		}
 	}
 
-	suspend fun addToCategory(manga: Manga, categoryId: Long) {
-		val tags = manga.tags.map(TagEntity.Companion::fromMangaTag)
+	suspend fun addToCategory(categoryId: Long, mangas: Collection<Manga>) {
 		db.withTransaction {
-			db.tagsDao.upsert(tags)
-			db.mangaDao.upsert(MangaEntity.from(manga), tags)
-			val entity = FavouriteEntity(manga.id, categoryId, System.currentTimeMillis())
-			db.favouritesDao.insert(entity)
+			for (manga in mangas) {
+				val tags = manga.tags.toEntities()
+				db.tagsDao.upsert(tags)
+				db.mangaDao.upsert(manga.toEntity(), tags)
+				val entity = FavouriteEntity(manga.id, categoryId, System.currentTimeMillis())
+				db.favouritesDao.insert(entity)
+			}
 		}
 	}
 
-	suspend fun removeFromCategory(manga: Manga, categoryId: Long) {
-		db.favouritesDao.delete(categoryId, manga.id)
+	suspend fun removeFromFavourites(ids: Collection<Long>) {
+		db.withTransaction {
+			for (id in ids) {
+				db.favouritesDao.delete(id)
+			}
+		}
 	}
 
-	suspend fun removeFromFavourites(manga: Manga) {
-		db.favouritesDao.delete(manga.id)
+	suspend fun removeFromCategory(categoryId: Long, ids: Collection<Long>) {
+		db.withTransaction {
+			for (id in ids) {
+				db.favouritesDao.delete(categoryId, id)
+			}
+		}
 	}
 
 	private fun observeOrder(categoryId: Long): Flow<SortOrder> {
 		return db.favouriteCategoriesDao.observe(categoryId)
-			.map { x -> SortOrder.values().find { it.name == x.order } ?: SortOrder.NEWEST }
+			.map { x -> SortOrder(x.order, SortOrder.NEWEST) }
 			.distinctUntilChanged()
 	}
 }

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

@@ -2,14 +2,19 @@ package org.koitharu.kotatsu.favourites.ui
 
 import android.os.Bundle
 import android.view.*
+import androidx.appcompat.view.ActionMode
 import androidx.core.graphics.Insets
+import androidx.core.view.children
 import androidx.core.view.updateLayoutParams
 import androidx.core.view.updatePadding
 import com.google.android.material.snackbar.Snackbar
+import com.google.android.material.tabs.TabLayout
 import com.google.android.material.tabs.TabLayoutMediator
+import java.util.*
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseFragment
+import org.koitharu.kotatsu.base.ui.util.ActionModeListener
 import org.koitharu.kotatsu.core.model.FavouriteCategory
 import org.koitharu.kotatsu.core.ui.titleRes
 import org.koitharu.kotatsu.databinding.FragmentFavouritesBinding
@@ -21,10 +26,12 @@ import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.utils.ext.getDisplayMessage
 import org.koitharu.kotatsu.utils.ext.measureHeight
 import org.koitharu.kotatsu.utils.ext.showPopupMenu
-import java.util.*
 
-class FavouritesContainerFragment : BaseFragment<FragmentFavouritesBinding>(),
-	FavouritesTabLongClickListener, CategoriesEditDelegate.CategoriesEditCallback {
+class FavouritesContainerFragment :
+	BaseFragment<FragmentFavouritesBinding>(),
+	FavouritesTabLongClickListener,
+	CategoriesEditDelegate.CategoriesEditCallback,
+	ActionModeListener {
 
 	private val viewModel by viewModel<FavouritesCategoriesViewModel>()
 	private val editDelegate by lazy(LazyThreadSafetyMode.NONE) {
@@ -51,6 +58,7 @@ class FavouritesContainerFragment : BaseFragment<FragmentFavouritesBinding>(),
 		binding.pager.adapter = adapter
 		pagerAdapter = adapter
 		TabLayoutMediator(binding.tabs, binding.pager, adapter).attach()
+		actionModeDelegate.addListener(this, viewLifecycleOwner)
 
 		viewModel.categories.observe(viewLifecycleOwner, ::onCategoriesChanged)
 		viewModel.onError.observe(viewLifecycleOwner, ::onError)
@@ -61,6 +69,16 @@ class FavouritesContainerFragment : BaseFragment<FragmentFavouritesBinding>(),
 		super.onDestroyView()
 	}
 
+	override fun onActionModeStarted(mode: ActionMode) {
+		binding.pager.isUserInputEnabled = false
+		binding.tabs.setTabsEnabled(false)
+	}
+
+	override fun onActionModeFinished(mode: ActionMode) {
+		binding.pager.isUserInputEnabled = true
+		binding.tabs.setTabsEnabled(true)
+	}
+
 	override fun onWindowInsetsChanged(insets: Insets) {
 		val headerHeight = (activity as? AppBarOwner)?.appBar?.measureHeight() ?: insets.top
 		binding.root.updatePadding(
@@ -146,18 +164,20 @@ class FavouritesContainerFragment : BaseFragment<FragmentFavouritesBinding>(),
 	private fun createOrderSubmenu(menu: Menu, category: FavouriteCategory) {
 		val submenu = menu.findItem(R.id.action_order)?.subMenu ?: return
 		for ((i, item) in CategoriesActivity.SORT_ORDERS.withIndex()) {
-			val menuItem = submenu.add(
-				R.id.group_order,
-				Menu.NONE,
-				i,
-				item.titleRes
-			)
+			val menuItem = submenu.add(R.id.group_order, Menu.NONE, i, item.titleRes)
 			menuItem.isCheckable = true
 			menuItem.isChecked = item == category.order
 		}
 		submenu.setGroupCheckable(R.id.group_order, true, true)
 	}
 
+	private fun TabLayout.setTabsEnabled(enabled: Boolean) {
+		val tabStrip = getChildAt(0) as? ViewGroup ?: return
+		for (tab in tabStrip.children) {
+			tab.isEnabled = enabled
+		}
+	}
+
 	companion object {
 
 		fun newInstance() = FavouritesContainerFragment()

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

@@ -2,18 +2,20 @@ package org.koitharu.kotatsu.favourites.ui.categories.select
 
 import android.os.Bundle
 import android.view.LayoutInflater
+import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
 import android.widget.Toast
+import androidx.appcompat.widget.Toolbar
 import androidx.fragment.app.FragmentManager
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import org.koin.core.parameter.parametersOf
 import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.base.domain.MangaIntent
 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.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.model.withoutChapters
 import org.koitharu.kotatsu.databinding.DialogFavoriteCategoriesBinding
 import org.koitharu.kotatsu.favourites.ui.categories.CategoriesEditDelegate
 import org.koitharu.kotatsu.favourites.ui.categories.select.adapter.MangaCategoriesAdapter
@@ -22,12 +24,14 @@ import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.utils.ext.getDisplayMessage
 import org.koitharu.kotatsu.utils.ext.withArgs
 
-class FavouriteCategoriesDialog : BaseBottomSheet<DialogFavoriteCategoriesBinding>(),
-	OnListItemClickListener<MangaCategoryItem>, CategoriesEditDelegate.CategoriesEditCallback,
-	View.OnClickListener {
+class FavouriteCategoriesDialog :
+	BaseBottomSheet<DialogFavoriteCategoriesBinding>(),
+	OnListItemClickListener<MangaCategoryItem>,
+	CategoriesEditDelegate.CategoriesEditCallback,
+	Toolbar.OnMenuItemClickListener {
 
 	private val viewModel by viewModel<MangaCategoriesViewModel> {
-		parametersOf(requireNotNull(arguments?.getParcelable<ParcelableManga>(MangaIntent.KEY_MANGA)).manga)
+		parametersOf(requireNotNull(arguments?.getParcelableArrayList<ParcelableManga>(KEY_MANGA_LIST)).map { it.manga })
 	}
 
 	private var adapter: MangaCategoriesAdapter? = null
@@ -44,7 +48,7 @@ class FavouriteCategoriesDialog : BaseBottomSheet<DialogFavoriteCategoriesBindin
 		super.onViewCreated(view, savedInstanceState)
 		adapter = MangaCategoriesAdapter(this)
 		binding.recyclerViewCategories.adapter = adapter
-		binding.textViewAdd.setOnClickListener(this)
+		binding.toolbar.setOnMenuItemClickListener(this)
 
 		viewModel.content.observe(viewLifecycleOwner, this::onContentChanged)
 		viewModel.onError.observe(viewLifecycleOwner, ::onError)
@@ -55,9 +59,13 @@ class FavouriteCategoriesDialog : BaseBottomSheet<DialogFavoriteCategoriesBindin
 		super.onDestroyView()
 	}
 
-	override fun onClick(v: View) {
-		when (v.id) {
-			R.id.textView_add -> editDelegate.createCategory()
+	override fun onMenuItemClick(item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.action_create -> {
+				editDelegate.createCategory()
+				true
+			}
+			else -> false
 		}
 	}
 
@@ -84,10 +92,15 @@ class FavouriteCategoriesDialog : BaseBottomSheet<DialogFavoriteCategoriesBindin
 	companion object {
 
 		private const val TAG = "FavouriteCategoriesDialog"
+		private const val KEY_MANGA_LIST = "manga_list"
 
-		fun show(fm: FragmentManager, manga: Manga) = FavouriteCategoriesDialog()
-			.withArgs(1) {
-				putParcelable(MangaIntent.KEY_MANGA, ParcelableManga(manga))
-			}.show(fm, TAG)
+		fun show(fm: FragmentManager, manga: Manga) = Companion.show(fm, listOf(manga))
+
+		fun show(fm: FragmentManager, manga: Collection<Manga>) = FavouriteCategoriesDialog().withArgs(1) {
+			putParcelableArrayList(
+				KEY_MANGA_LIST,
+				manga.mapTo(ArrayList(manga.size)) { ParcelableManga(it.withoutChapters()) }
+			)
+		}.show(fm, TAG)
 	}
 }

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

@@ -4,19 +4,20 @@ import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.combine
 import org.koitharu.kotatsu.base.ui.BaseViewModel
+import org.koitharu.kotatsu.core.model.ids
 import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
 import org.koitharu.kotatsu.favourites.ui.categories.select.model.MangaCategoryItem
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 
 class MangaCategoriesViewModel(
-	private val manga: Manga,
+	private val manga: List<Manga>,
 	private val favouritesRepository: FavouritesRepository
 ) : BaseViewModel() {
 
 	val content = combine(
 		favouritesRepository.observeCategories(),
-		favouritesRepository.observeCategoriesIds(manga.id)
+		observeCategoriesIds(),
 	) { all, checked ->
 		all.map {
 			MangaCategoryItem(
@@ -30,9 +31,9 @@ class MangaCategoriesViewModel(
 	fun setChecked(categoryId: Long, isChecked: Boolean) {
 		launchJob(Dispatchers.Default) {
 			if (isChecked) {
-				favouritesRepository.addToCategory(manga, categoryId)
+				favouritesRepository.addToCategory(categoryId, manga)
 			} else {
-				favouritesRepository.removeFromCategory(manga, categoryId)
+				favouritesRepository.removeFromCategory(categoryId, manga.ids())
 			}
 		}
 	}
@@ -42,4 +43,25 @@ class MangaCategoriesViewModel(
 			favouritesRepository.addCategory(name)
 		}
 	}
+
+	private fun observeCategoriesIds() = if (manga.size == 1) {
+		// Fast path
+		favouritesRepository.observeCategoriesIds(manga[0].id)
+	} else {
+		combine(
+			manga.map { favouritesRepository.observeCategoriesIds(it.id) }
+		) { array ->
+			val result = HashSet<Long>()
+			var isFirst = true
+			for (ids in array) {
+				if (isFirst) {
+					result.addAll(ids)
+					isFirst = false
+				} else {
+					result.retainAll(ids.toSet())
+				}
+			}
+			result
+		}
+	}
 }

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

@@ -2,13 +2,13 @@ package org.koitharu.kotatsu.favourites.ui.categories.select.adapter
 
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
-import org.koitharu.kotatsu.databinding.ItemCategoryCheckableBinding
+import org.koitharu.kotatsu.databinding.ItemCheckableNewBinding
 import org.koitharu.kotatsu.favourites.ui.categories.select.model.MangaCategoryItem
 
 fun mangaCategoryAD(
 	clickListener: OnListItemClickListener<MangaCategoryItem>
-) = adapterDelegateViewBinding<MangaCategoryItem, MangaCategoryItem, ItemCategoryCheckableBinding>(
-	{ inflater, parent -> ItemCategoryCheckableBinding.inflate(inflater, parent, false) }
+) = adapterDelegateViewBinding<MangaCategoryItem, MangaCategoryItem, ItemCheckableNewBinding>(
+	{ inflater, parent -> ItemCheckableNewBinding.inflate(inflater, parent, false) }
 ) {
 
 	itemView.setOnClickListener {
@@ -16,7 +16,7 @@ fun mangaCategoryAD(
 	}
 
 	bind {
-		with(binding.checkedTextView) {
+		with(binding.root) {
 			text = item.name
 			isChecked = item.isChecked
 		}

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

@@ -1,13 +1,12 @@
 package org.koitharu.kotatsu.favourites.ui.list
 
 import android.view.Menu
-import android.view.MenuInflater
 import android.view.MenuItem
+import androidx.appcompat.view.ActionMode
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import org.koin.core.parameter.parametersOf
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.list.ui.MangaListFragment
-import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.utils.ext.withArgs
 
 class FavouritesListFragment : MangaListFragment() {
@@ -23,17 +22,20 @@ class FavouritesListFragment : MangaListFragment() {
 
 	override fun onScrolledToEnd() = Unit
 
-	override fun onCreatePopupMenu(inflater: MenuInflater, menu: Menu, data: Manga) {
-		super.onCreatePopupMenu(inflater, menu, data)
-		inflater.inflate(R.menu.popup_favourites, menu)
+	override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
+		mode.menuInflater.inflate(R.menu.mode_favourites, menu)
+		return super.onCreateActionMode(mode, menu)
 	}
 
-	override fun onPopupMenuItemSelected(item: MenuItem, data: Manga) = when (item.itemId) {
-		R.id.action_remove -> {
-			viewModel.removeFromFavourites(data)
-			true
+	override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.action_remove -> {
+				viewModel.removeFromFavourites(selectedItemsIds)
+				mode.finish()
+				true
+			}
+			else -> super.onActionItemClicked(mode, item)
 		}
-		else -> super.onPopupMenuItemSelected(item, data)
 	}
 
 	companion object {

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

@@ -13,7 +13,6 @@ import org.koitharu.kotatsu.list.ui.model.EmptyState
 import org.koitharu.kotatsu.list.ui.model.LoadingState
 import org.koitharu.kotatsu.list.ui.model.toErrorState
 import org.koitharu.kotatsu.list.ui.model.toUi
-import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
@@ -56,12 +55,15 @@ class FavouritesListViewModel(
 
 	override fun onRetry() = Unit
 
-	fun removeFromFavourites(manga: Manga) {
+	fun removeFromFavourites(ids: Set<Long>) {
+		if (ids.isEmpty()) {
+			return
+		}
 		launchJob {
 			if (categoryId == 0L) {
-				repository.removeFromFavourites(manga)
+				repository.removeFromFavourites(ids)
 			} else {
-				repository.removeFromCategory(manga, categoryId)
+				repository.removeFromCategory(categoryId, ids)
 			}
 		}
 	}

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

@@ -0,0 +1,12 @@
+package org.koitharu.kotatsu.history.data
+
+import java.util.*
+import org.koitharu.kotatsu.core.model.MangaHistory
+
+fun HistoryEntity.toMangaHistory() = MangaHistory(
+	createdAt = Date(createdAt),
+	updatedAt = Date(updatedAt),
+	chapterId = chapterId,
+	page = page,
+	scroll = scroll.toInt()
+)

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

@@ -5,7 +5,6 @@ import kotlinx.coroutines.flow.Flow
 import org.koitharu.kotatsu.core.db.entity.MangaEntity
 import org.koitharu.kotatsu.core.db.entity.TagEntity
 
-
 @Dao
 abstract class HistoryDao {
 
@@ -23,8 +22,15 @@ abstract class HistoryDao {
 	@Query("SELECT * FROM manga WHERE manga_id IN (SELECT manga_id FROM history)")
 	abstract suspend fun findAllManga(): List<MangaEntity>
 
-	@Query("SELECT * FROM tags WHERE tag_id IN (SELECT tag_id FROM manga_tags WHERE manga_id IN (SELECT manga_id FROM history))")
-	abstract suspend fun findAllTags(): List<TagEntity>
+	@Query(
+		"""SELECT tags.* FROM tags
+		LEFT JOIN manga_tags ON tags.tag_id = manga_tags.tag_id
+		INNER JOIN history ON history.manga_id = manga_tags.manga_id
+		GROUP BY manga_tags.tag_id 
+		ORDER BY COUNT(manga_tags.manga_id) DESC 
+		LIMIT :limit"""
+	)
+	abstract suspend fun findPopularTags(limit: Int): List<TagEntity>
 
 	@Query("SELECT * FROM history WHERE manga_id = :id")
 	abstract suspend fun find(id: Long): HistoryEntity?
@@ -32,6 +38,9 @@ abstract class HistoryDao {
 	@Query("SELECT * FROM history WHERE manga_id = :id")
 	abstract fun observe(id: Long): Flow<HistoryEntity?>
 
+	@Query("SELECT COUNT(*) FROM history")
+	abstract fun observeCount(): Flow<Int>
+
 	@Query("DELETE FROM history")
 	abstract suspend fun clear()
 
@@ -60,5 +69,4 @@ abstract class HistoryDao {
 			true
 		} else false
 	}
-
 }

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

@@ -5,11 +5,10 @@ import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
 import org.koitharu.kotatsu.core.db.entity.MangaEntity
-import org.koitharu.kotatsu.core.model.MangaHistory
-import java.util.*
 
 @Entity(
-	tableName = "history", foreignKeys = [
+	tableName = "history",
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],
@@ -26,13 +25,4 @@ class HistoryEntity(
 	@ColumnInfo(name = "chapter_id") val chapterId: Long,
 	@ColumnInfo(name = "page") val page: Int,
 	@ColumnInfo(name = "scroll") val scroll: Float,
-) {
-
-	fun toMangaHistory() = MangaHistory(
-		createdAt = Date(createdAt),
-		updatedAt = Date(updatedAt),
-		chapterId = chapterId,
-		page = page,
-		scroll = scroll.toInt()
-	)
-}
+)

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

@@ -19,5 +19,5 @@ class HistoryWithManga(
 		entityColumn = "tag_id",
 		associateBy = Junction(MangaTagsEntity::class)
 	)
-	val tags: List<TagEntity>
+	val tags: List<TagEntity>,
 )

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

@@ -2,18 +2,18 @@ package org.koitharu.kotatsu.history.domain
 
 import androidx.room.withTransaction
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.MangaEntity
-import org.koitharu.kotatsu.core.db.entity.TagEntity
+import org.koitharu.kotatsu.core.db.entity.*
 import org.koitharu.kotatsu.core.model.MangaHistory
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.history.data.HistoryEntity
+import org.koitharu.kotatsu.history.data.toMangaHistory
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaTag
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.ext.mapItems
-import org.koitharu.kotatsu.utils.ext.mapToSet
 
 class HistoryRepository(
 	private val db: MangaDatabase,
@@ -23,20 +23,25 @@ class HistoryRepository(
 
 	suspend fun getList(offset: Int, limit: Int = 20): List<Manga> {
 		val entities = db.historyDao.findAll(offset, limit)
-		return entities.map { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+		return entities.map { it.manga.toManga(it.tags.toMangaTags()) }
+	}
+
+	suspend fun getLastOrNull(): Manga? {
+		val entity = db.historyDao.findAll(0, 1).firstOrNull() ?: return null
+		return entity.manga.toManga(entity.tags.toMangaTags())
 	}
 
 	fun observeAll(): Flow<List<Manga>> {
 		return db.historyDao.observeAll().mapItems {
-			it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag))
+			it.manga.toManga(it.tags.toMangaTags())
 		}
 	}
 
 	fun observeAllWithHistory(): Flow<List<MangaWithHistory>> {
 		return db.historyDao.observeAll().mapItems {
 			MangaWithHistory(
-				it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)),
-				it.history.toMangaHistory()
+				it.manga.toManga(it.tags.toMangaTags()),
+				it.history.toMangaHistory(),
 			)
 		}
 	}
@@ -47,14 +52,20 @@ class HistoryRepository(
 		}
 	}
 
+	fun observeHasItems(): Flow<Boolean> {
+		return db.historyDao.observeCount()
+			.map { it > 0 }
+			.distinctUntilChanged()
+	}
+
 	suspend fun addOrUpdate(manga: Manga, chapterId: Long, page: Int, scroll: Int) {
 		if (manga.isNsfw && settings.isHistoryExcludeNsfw) {
 			return
 		}
-		val tags = manga.tags.map(TagEntity.Companion::fromMangaTag)
+		val tags = manga.tags.toEntities()
 		db.withTransaction {
 			db.tagsDao.upsert(tags)
-			db.mangaDao.upsert(MangaEntity.from(manga), tags)
+			db.mangaDao.upsert(manga.toEntity(), tags)
 			db.historyDao.upsert(
 				HistoryEntity(
 					mangaId = manga.id,
@@ -62,7 +73,7 @@ class HistoryRepository(
 					updatedAt = System.currentTimeMillis(),
 					chapterId = chapterId,
 					page = page,
-					scroll = scroll.toFloat() // we migrate to int, but decide to not update database
+					scroll = scroll.toFloat(), // we migrate to int, but decide to not update database
 				)
 			)
 			trackingRepository.upsert(manga)
@@ -81,17 +92,25 @@ class HistoryRepository(
 		db.historyDao.delete(manga.id)
 	}
 
+	suspend fun delete(ids: Collection<Long>) {
+		db.withTransaction {
+			for (id in ids) {
+				db.historyDao.delete(id)
+			}
+		}
+	}
+
 	/**
 	 * Try to replace one manga with another one
 	 * Useful for replacing saved manga on deleting it with remove source
 	 */
 	suspend fun deleteOrSwap(manga: Manga, alternative: Manga?) {
-		if (alternative == null || db.mangaDao.update(MangaEntity.from(alternative)) <= 0) {
+		if (alternative == null || db.mangaDao.update(alternative.toEntity()) <= 0) {
 			db.historyDao.delete(manga.id)
 		}
 	}
 
-	suspend fun getAllTags(): Set<MangaTag> {
-		return db.historyDao.findAllTags().mapToSet { x -> x.toMangaTag() }
+	suspend fun getPopularTags(limit: Int): List<MangaTag> {
+		return db.historyDao.findPopularTags(limit).map { x -> x.toMangaTag() }
 	}
 }

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

@@ -5,13 +5,11 @@ import android.view.Menu
 import android.view.MenuInflater
 import android.view.MenuItem
 import android.view.View
+import androidx.appcompat.view.ActionMode
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.google.android.material.snackbar.Snackbar
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.list.ui.MangaListFragment
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.util.ellipsize
 
 class HistoryListFragment : MangaListFragment() {
 
@@ -20,7 +18,6 @@ class HistoryListFragment : MangaListFragment() {
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
-		viewModel.onItemRemoved.observe(viewLifecycleOwner, ::onItemRemoved)
 		viewModel.isGroupingEnabled.observe(viewLifecycleOwner) {
 			activity?.invalidateOptionsMenu()
 		}
@@ -59,30 +56,22 @@ class HistoryListFragment : MangaListFragment() {
 		}
 	}
 
-	override fun onCreatePopupMenu(inflater: MenuInflater, menu: Menu, data: Manga) {
-		super.onCreatePopupMenu(inflater, menu, data)
-		inflater.inflate(R.menu.popup_history, menu)
+	override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
+		mode.menuInflater.inflate(R.menu.mode_history, menu)
+		return super.onCreateActionMode(mode, menu)
 	}
 
-	override fun onPopupMenuItemSelected(item: MenuItem, data: Manga): Boolean {
+	override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
 		return when (item.itemId) {
 			R.id.action_remove -> {
-				viewModel.removeFromHistory(data)
+				viewModel.removeFromHistory(selectedItemsIds)
+				mode.finish()
 				true
 			}
-			else -> super.onPopupMenuItemSelected(item, data)
+			else -> super.onActionItemClicked(mode, item)
 		}
 	}
 
-	private fun onItemRemoved(item: Manga) {
-		Snackbar.make(
-			binding.recyclerView, getString(
-				R.string._s_removed_from_history,
-				item.title.ellipsize(16)
-			), Snackbar.LENGTH_SHORT
-		).show()
-	}
-
 	companion object {
 
 		fun newInstance() = HistoryListFragment()

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

@@ -2,6 +2,8 @@ package org.koitharu.kotatsu.history.ui
 
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
+import java.util.*
+import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
 import org.koitharu.kotatsu.R
@@ -13,14 +15,10 @@ import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.history.domain.MangaWithHistory
 import org.koitharu.kotatsu.list.ui.MangaListViewModel
 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.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.daysDiff
 import org.koitharu.kotatsu.utils.ext.onFirst
-import java.util.*
-import java.util.concurrent.TimeUnit
 
 class HistoryListViewModel(
 	private val repository: HistoryRepository,
@@ -29,7 +27,6 @@ class HistoryListViewModel(
 	private val trackingRepository: TrackingRepository,
 ) : MangaListViewModel(settings) {
 
-	val onItemRemoved = SingleLiveEvent<Manga>()
 	val isGroupingEnabled = MutableLiveData<Boolean>()
 
 	private val historyGrouping = settings.observe()
@@ -72,10 +69,12 @@ class HistoryListViewModel(
 		}
 	}
 
-	fun removeFromHistory(manga: Manga) {
+	fun removeFromHistory(ids: Set<Long>) {
+		if (ids.isEmpty()) {
+			return
+		}
 		launchJob {
-			repository.delete(manga)
-			onItemRemoved.call(manga)
+			repository.delete(ids)
 			shortcutsRepository.updateShortcuts()
 		}
 	}

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

@@ -3,9 +3,11 @@ package org.koitharu.kotatsu.list.ui
 import android.os.Bundle
 import android.view.*
 import androidx.annotation.CallSuper
-import androidx.appcompat.widget.PopupMenu
+import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.view.ActionMode
+import androidx.collection.ArraySet
 import androidx.core.graphics.Insets
-import androidx.core.view.GravityCompat
+import androidx.core.view.isNotEmpty
 import androidx.core.view.updatePadding
 import androidx.recyclerview.widget.GridLayoutManager
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
@@ -24,37 +26,46 @@ import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.prefs.ListMode
 import org.koitharu.kotatsu.databinding.FragmentListBinding
 import org.koitharu.kotatsu.details.ui.DetailsActivity
-import org.koitharu.kotatsu.list.ui.adapter.AsyncViewFactory
+import org.koitharu.kotatsu.download.ui.service.DownloadService
+import org.koitharu.kotatsu.favourites.ui.categories.select.FavouriteCategoriesDialog
 import org.koitharu.kotatsu.list.ui.adapter.MangaListAdapter
 import org.koitharu.kotatsu.list.ui.adapter.MangaListAdapter.Companion.ITEM_TYPE_MANGA_GRID
 import org.koitharu.kotatsu.list.ui.adapter.MangaListListener
 import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.list.ui.model.MangaItemModel
 import org.koitharu.kotatsu.main.ui.AppBarOwner
 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.utils.ShareHelper
 import org.koitharu.kotatsu.utils.ext.*
 
-private const val PREFETCH_ITEM_LIST = 10
-private const val PREFETCH_ITEM_DETAILED = 8
-private const val PREFETCH_ITEM_GRID = 16
-
-abstract class MangaListFragment : BaseFragment<FragmentListBinding>(),
-	PaginationScrollListener.Callback, MangaListListener,
-	SwipeRefreshLayout.OnRefreshListener {
+abstract class MangaListFragment :
+	BaseFragment<FragmentListBinding>(),
+	PaginationScrollListener.Callback,
+	MangaListListener,
+	SwipeRefreshLayout.OnRefreshListener,
+	ActionMode.Callback {
 
 	private var listAdapter: MangaListAdapter? = null
 	private var paginationListener: PaginationScrollListener? = null
+	private var selectionDecoration: MangaSelectionDecoration? = null
+	private var actionMode: ActionMode? = null
 	private val spanResolver = MangaListSpanResolver()
 	private val spanSizeLookup = SpanSizeLookup()
 	private val listCommitCallback = Runnable {
 		spanSizeLookup.invalidateCache()
 	}
-	private var asyncViewFactory: AsyncViewFactory? = null
 	open val isSwipeRefreshEnabled = true
 
 	protected abstract val viewModel: MangaListViewModel
 
+	protected val selectedItemsIds: Set<Long>
+		get() = selectionDecoration?.checkedItemsIds?.toSet().orEmpty()
+
+	protected val selectedItems: Set<Manga>
+		get() = collectSelectedItems()
+
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
 		setHasOptionsMenu(true)
@@ -67,17 +78,17 @@ abstract class MangaListFragment : BaseFragment<FragmentListBinding>(),
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
-		asyncViewFactory = AsyncViewFactory(binding.recyclerView)
 		listAdapter = MangaListAdapter(
 			coil = get(),
 			lifecycleOwner = viewLifecycleOwner,
 			listener = this,
-			viewFactory = checkNotNull(asyncViewFactory),
 		)
+		selectionDecoration = MangaSelectionDecoration(view.context)
 		paginationListener = PaginationScrollListener(4, this)
 		with(binding.recyclerView) {
 			setHasFixedSize(true)
 			adapter = listAdapter
+			addItemDecoration(selectionDecoration!!)
 			addOnScrollListener(paginationListener!!)
 		}
 		with(binding.swipeRefreshLayout) {
@@ -97,8 +108,7 @@ abstract class MangaListFragment : BaseFragment<FragmentListBinding>(),
 	override fun onDestroyView() {
 		listAdapter = null
 		paginationListener = null
-		asyncViewFactory?.clear()
-		asyncViewFactory = null
+		selectionDecoration = null
 		spanSizeLookup.invalidateCache()
 		super.onDestroyView()
 	}
@@ -117,22 +127,28 @@ abstract class MangaListFragment : BaseFragment<FragmentListBinding>(),
 	}
 
 	override fun onItemClick(item: Manga, view: View) {
+		if (selectionDecoration?.checkedItemsCount != 0) {
+			selectionDecoration?.toggleItemChecked(item.id)
+			if (selectionDecoration?.checkedItemsCount == 0) {
+				actionMode?.finish()
+			} else {
+				actionMode?.invalidate()
+				binding.recyclerView.invalidateItemDecorations()
+			}
+			return
+		}
 		startActivity(DetailsActivity.newIntent(context ?: return, item))
 	}
 
 	override fun onItemLongClick(item: Manga, view: View): Boolean {
-		val menu = PopupMenu(context ?: return false, view)
-		onCreatePopupMenu(menu.menuInflater, menu.menu, item)
-		return if (menu.menu.hasVisibleItems()) {
-			menu.setOnMenuItemClickListener {
-				onPopupMenuItemSelected(it, item)
-			}
-			menu.gravity = GravityCompat.END or Gravity.TOP
-			menu.show()
-			true
-		} else {
-			false
+		if (actionMode == null) {
+			actionMode = (activity as? AppCompatActivity)?.startSupportActionMode(this)
 		}
+		return actionMode?.also {
+			selectionDecoration?.setItemIsChecked(item.id, true)
+			binding.recyclerView.invalidateItemDecorations()
+			it.invalidate()
+		} != null
 	}
 
 	@CallSuper
@@ -172,7 +188,7 @@ abstract class MangaListFragment : BaseFragment<FragmentListBinding>(),
 	@CallSuper
 	protected open fun onLoadingStateChanged(isLoading: Boolean) {
 		binding.swipeRefreshLayout.isEnabled = binding.swipeRefreshLayout.isRefreshing ||
-				isSwipeRefreshEnabled && !isLoading
+			isSwipeRefreshEnabled && !isLoading
 		if (!isLoading) {
 			binding.swipeRefreshLayout.isRefreshing = false
 		}
@@ -194,6 +210,10 @@ abstract class MangaListFragment : BaseFragment<FragmentListBinding>(),
 				headerHeight + resources.resolveDp(-72),
 				headerHeight + resources.resolveDp(10),
 			)
+		} else {
+			binding.recyclerView.updatePadding(
+				bottom = insets.bottom,
+			)
 		}
 	}
 
@@ -219,26 +239,18 @@ abstract class MangaListFragment : BaseFragment<FragmentListBinding>(),
 		with(binding.recyclerView) {
 			clearItemDecorations()
 			removeOnLayoutChangeListener(spanResolver)
-			asyncViewFactory?.clear()
-			val isListPending = viewModel.isListPending()
 			when (mode) {
 				ListMode.LIST -> {
 					layoutManager = FitHeightLinearLayoutManager(context)
 					val spacing = resources.getDimensionPixelOffset(R.dimen.list_spacing)
 					addItemDecoration(SpacingItemDecoration(spacing))
 					updatePadding(left = spacing, right = spacing)
-					if (isListPending) {
-						asyncViewFactory?.prefetch(R.layout.item_manga_list, PREFETCH_ITEM_LIST)
-					}
 				}
 				ListMode.DETAILED_LIST -> {
 					layoutManager = FitHeightLinearLayoutManager(context)
 					val spacing = resources.getDimensionPixelOffset(R.dimen.list_spacing)
 					updatePadding(left = spacing, right = spacing)
 					addItemDecoration(SpacingItemDecoration(spacing))
-					if (isListPending) {
-						asyncViewFactory?.prefetch(R.layout.item_manga_list_details, PREFETCH_ITEM_DETAILED)
-					}
 				}
 				ListMode.GRID -> {
 					layoutManager = FitHeightGridLayoutManager(context, spanResolver.spanCount).also {
@@ -248,17 +260,69 @@ abstract class MangaListFragment : BaseFragment<FragmentListBinding>(),
 					addItemDecoration(SpacingItemDecoration(spacing))
 					updatePadding(left = spacing, right = spacing)
 					addOnLayoutChangeListener(spanResolver)
-					if (isListPending) {
-						asyncViewFactory?.prefetch(R.layout.item_manga_grid, PREFETCH_ITEM_GRID)
-					}
 				}
 			}
+			selectionDecoration?.let { addItemDecoration(it) }
 		}
 	}
 
-	protected open fun onCreatePopupMenu(inflater: MenuInflater, menu: Menu, data: Manga) = Unit
+	override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
+		return menu.isNotEmpty()
+	}
 
-	protected open fun onPopupMenuItemSelected(item: MenuItem, data: Manga) = false
+	@CallSuper
+	override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
+		mode.title = selectionDecoration?.checkedItemsCount?.toString()
+		return true
+	}
+
+	override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.action_select_all -> {
+				val ids = listAdapter?.items?.mapNotNull {
+					(it as? MangaItemModel)?.id
+				} ?: return false
+				selectionDecoration?.checkAll(ids)
+				binding.recyclerView.invalidateItemDecorations()
+				mode.invalidate()
+				true
+			}
+			R.id.action_share -> {
+				ShareHelper(requireContext()).shareMangaLinks(selectedItems)
+				mode.finish()
+				true
+			}
+			R.id.action_favourite -> {
+				FavouriteCategoriesDialog.show(childFragmentManager, selectedItems)
+				mode.finish()
+				true
+			}
+			R.id.action_save -> {
+				DownloadService.confirmAndStart(requireContext(), selectedItems)
+				mode.finish()
+				true
+			}
+			else -> false
+		}
+	}
+
+	override fun onDestroyActionMode(mode: ActionMode) {
+		selectionDecoration?.clearSelection()
+		binding.recyclerView.invalidateItemDecorations()
+		actionMode = null
+	}
+
+	private fun collectSelectedItems(): Set<Manga> {
+		val checkedIds = selectionDecoration?.checkedItemsIds ?: return emptySet()
+		val items = listAdapter?.items ?: return emptySet()
+		val result = ArraySet<Manga>(checkedIds.size)
+		for (item in items) {
+			if (item is MangaItemModel && item.id in checkedIds) {
+				result.add(item.manga)
+			}
+		}
+		return result
+	}
 
 	private inner class SpanSizeLookup : GridLayoutManager.SpanSizeLookup() {
 

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

@@ -44,10 +44,4 @@ abstract class MangaListViewModel(
 	abstract fun onRefresh()
 
 	abstract fun onRetry()
-
-	fun isListPending(): Boolean {
-		return content.value?.any {
-			it is MangaListModel || it is MangaGridModel || it is MangaListDetailedModel
-		} != true
-	}
 }

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

@@ -0,0 +1,71 @@
+package org.koitharu.kotatsu.list.ui
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.RectF
+import android.view.View
+import androidx.cardview.widget.CardView
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.ColorUtils
+import androidx.recyclerview.widget.RecyclerView
+import androidx.recyclerview.widget.RecyclerView.NO_ID
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.ui.list.decor.AbstractSelectionItemDecoration
+import org.koitharu.kotatsu.list.ui.model.MangaItemModel
+import org.koitharu.kotatsu.utils.ext.getItem
+import org.koitharu.kotatsu.utils.ext.getThemeColor
+import com.google.android.material.R as materialR
+
+class MangaSelectionDecoration(context: Context) : AbstractSelectionItemDecoration() {
+
+	private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+	private val checkIcon = ContextCompat.getDrawable(context, materialR.drawable.ic_mtrl_checked_circle)
+	private val iconOffset = context.resources.getDimensionPixelOffset(R.dimen.grid_spacing_outer)
+	private val strokeColor = context.getThemeColor(materialR.attr.colorPrimary, Color.RED)
+	private val fillColor = ColorUtils.setAlphaComponent(
+		ColorUtils.blendARGB(strokeColor, context.getThemeColor(materialR.attr.colorSurface), 0.8f),
+		0x74
+	)
+
+	init {
+		hasBackground = false
+		hasForeground = true
+		isIncludeDecorAndMargins = false
+
+		paint.strokeWidth = context.resources.getDimension(R.dimen.selection_stroke_width)
+		checkIcon?.setTint(strokeColor)
+	}
+
+	override fun getItemId(parent: RecyclerView, child: View): Long {
+		val holder = parent.getChildViewHolder(child) ?: return NO_ID
+		val item = holder.getItem<MangaItemModel>() ?: return NO_ID
+		return item.id
+	}
+
+	override fun onDrawForeground(
+		canvas: Canvas,
+		parent: RecyclerView,
+		child: View,
+		bounds: RectF,
+		state: RecyclerView.State,
+	) {
+		val radius = (child as? CardView)?.radius ?: 0f
+		paint.color = fillColor
+		paint.style = Paint.Style.FILL
+		canvas.drawRoundRect(bounds, radius, radius, paint)
+		paint.color = strokeColor
+		paint.style = Paint.Style.STROKE
+		canvas.drawRoundRect(bounds, radius, radius, paint)
+		checkIcon?.run {
+			setBounds(
+				(bounds.left + iconOffset).toInt(),
+				(bounds.top + iconOffset).toInt(),
+				(bounds.left + iconOffset + intrinsicWidth).toInt(),
+				(bounds.top + iconOffset + intrinsicHeight).toInt(),
+			)
+			draw(canvas)
+		}
+	}
+}

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

@@ -1,58 +0,0 @@
-package org.koitharu.kotatsu.list.ui.adapter
-
-import android.util.Log
-import android.util.SparseArray
-import android.view.View
-import android.view.ViewGroup
-import androidx.annotation.LayoutRes
-import androidx.asynclayoutinflater.view.AsyncLayoutInflater
-import androidx.core.util.valueIterator
-import org.koitharu.kotatsu.BuildConfig
-import java.util.*
-
-class AsyncViewFactory(private val parent: ViewGroup) : AsyncLayoutInflater.OnInflateFinishedListener {
-
-	private val asyncInflater = AsyncLayoutInflater(parent.context)
-	private val pool = SparseArray<LinkedList<View>>()
-
-	override fun onInflateFinished(view: View, resid: Int, parent: ViewGroup?) {
-		var list = pool.get(resid)
-		if (list != null) {
-			list.addLast(view)
-		} else {
-			list = LinkedList()
-			list.add(view)
-			pool.put(resid, list)
-		}
-	}
-
-	fun clear() {
-		if (BuildConfig.DEBUG) {
-			pool.valueIterator().forEach {
-				if (it.isNotEmpty()) {
-					Log.w("AsyncViewFactory", "You have ${it.size} unconsumed prefetched items")
-				}
-			}
-		}
-		pool.clear()
-	}
-
-	fun prefetch(@LayoutRes resId: Int, count: Int) {
-		if (count <= 0) return
-		repeat(count) {
-			asyncInflater.inflate(resId, parent, this)
-		}
-	}
-
-	operator fun get(@LayoutRes resId: Int): View? {
-		val result = pool.get(resId)?.removeFirstOrNull()
-		if (BuildConfig.DEBUG && result == null) {
-			Log.w("AsyncViewFactory", "Item requested but missing")
-		}
-		return result
-	}
-
-	fun getCount(@LayoutRes resId: Int): Int {
-		return pool[resId]?.size ?: 0
-	}
-}

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

@@ -20,15 +20,8 @@ fun mangaGridItemAD(
 	coil: ImageLoader,
 	lifecycleOwner: LifecycleOwner,
 	clickListener: OnListItemClickListener<Manga>,
-	viewFactory: AsyncViewFactory,
 ) = adapterDelegateViewBinding<MangaGridModel, ListModel, ItemMangaGridBinding>(
-	{ inflater, parent ->
-		viewFactory[R.layout.item_manga_grid]?.let {
-			ItemMangaGridBinding.bind(it)
-		} ?: run {
-			ItemMangaGridBinding.inflate(inflater, parent, false)
-		}
-	}
+	{ inflater, parent -> ItemMangaGridBinding.inflate(inflater, parent, false) }
 ) {
 
 	var imageRequest: Disposable? = null

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

@@ -12,20 +12,13 @@ class MangaListAdapter(
 	coil: ImageLoader,
 	lifecycleOwner: LifecycleOwner,
 	listener: MangaListListener,
-	viewFactory: AsyncViewFactory,
 ) : AsyncListDifferDelegationAdapter<ListModel>(DiffCallback()) {
 
 	init {
 		delegatesManager
-			.addDelegate(
-				ITEM_TYPE_MANGA_LIST,
-				mangaListItemAD(coil, lifecycleOwner, listener, viewFactory)
-			)
-			.addDelegate(
-				ITEM_TYPE_MANGA_LIST_DETAILED,
-				mangaListDetailedItemAD(coil, lifecycleOwner, listener, viewFactory)
-			)
-			.addDelegate(ITEM_TYPE_MANGA_GRID, mangaGridItemAD(coil, lifecycleOwner, listener, viewFactory))
+			.addDelegate(ITEM_TYPE_MANGA_LIST, mangaListItemAD(coil, lifecycleOwner, listener))
+			.addDelegate(ITEM_TYPE_MANGA_LIST_DETAILED, mangaListDetailedItemAD(coil, lifecycleOwner, listener))
+			.addDelegate(ITEM_TYPE_MANGA_GRID, mangaGridItemAD(coil, lifecycleOwner, listener))
 			.addDelegate(ITEM_TYPE_LOADING_FOOTER, loadingFooterAD())
 			.addDelegate(ITEM_TYPE_LOADING_STATE, loadingStateAD())
 			.addDelegate(ITEM_TYPE_DATE, relatedDateItemAD())

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

@@ -21,15 +21,8 @@ fun mangaListDetailedItemAD(
 	coil: ImageLoader,
 	lifecycleOwner: LifecycleOwner,
 	clickListener: OnListItemClickListener<Manga>,
-	viewFactory: AsyncViewFactory,
 ) = adapterDelegateViewBinding<MangaListDetailedModel, ListModel, ItemMangaListDetailsBinding>(
-	{ inflater, parent ->
-		viewFactory[R.layout.item_manga_list_details]?.let {
-			ItemMangaListDetailsBinding.bind(it)
-		} ?: run {
-			ItemMangaListDetailsBinding.inflate(inflater, parent, false)
-		}
-	}
+	{ inflater, parent -> ItemMangaListDetailsBinding.inflate(inflater, parent, false) }
 ) {
 
 	var imageRequest: Disposable? = null

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

@@ -21,15 +21,8 @@ fun mangaListItemAD(
 	coil: ImageLoader,
 	lifecycleOwner: LifecycleOwner,
 	clickListener: OnListItemClickListener<Manga>,
-	viewFactory: AsyncViewFactory,
 ) = adapterDelegateViewBinding<MangaListModel, ListModel, ItemMangaListBinding>(
-	{ inflater, parent ->
-		viewFactory[R.layout.item_manga_list]?.let {
-			ItemMangaListBinding.bind(it)
-		} ?: run {
-			ItemMangaListBinding.inflate(inflater, parent, false)
-		}
-	}
+	{ inflater, parent -> ItemMangaListBinding.inflate(inflater, parent, false) }
 ) {
 
 	var imageRequest: Disposable? = null

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

@@ -3,9 +3,9 @@ package org.koitharu.kotatsu.list.ui.model
 import org.koitharu.kotatsu.parsers.model.Manga
 
 data class MangaGridModel(
-	val id: Long,
+	override val id: Long,
 	val title: String,
 	val coverUrl: String,
-	val manga: Manga,
+	override val manga: Manga,
 	val counter: Int,
-) : ListModel
+) : MangaItemModel

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

@@ -0,0 +1,9 @@
+package org.koitharu.kotatsu.list.ui.model
+
+import org.koitharu.kotatsu.parsers.model.Manga
+
+sealed interface MangaItemModel : ListModel {
+
+	val id: Long
+	val manga: Manga
+}

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

@@ -3,12 +3,12 @@ package org.koitharu.kotatsu.list.ui.model
 import org.koitharu.kotatsu.parsers.model.Manga
 
 data class MangaListDetailedModel(
-	val id: Long,
+	override val id: Long,
 	val title: String,
 	val subtitle: String?,
 	val tags: String,
 	val coverUrl: String,
 	val rating: String?,
-	val manga: Manga,
+	override val manga: Manga,
 	val counter: Int,
-) : ListModel
+) : MangaItemModel

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

@@ -3,10 +3,10 @@ package org.koitharu.kotatsu.list.ui.model
 import org.koitharu.kotatsu.parsers.model.Manga
 
 data class MangaListModel(
-	val id: Long,
+	override val id: Long,
 	val title: String,
 	val subtitle: String,
 	val coverUrl: String,
-	val manga: Manga,
+	override val manga: Manga,
 	val counter: Int,
-) : ListModel
+) : MangaItemModel

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

@@ -6,6 +6,7 @@ import org.koin.dsl.module
 import org.koitharu.kotatsu.local.data.LocalStorageManager
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.local.ui.LocalListViewModel
+import org.koitharu.kotatsu.utils.ExternalStorageHelper
 
 val localModule
 	get() = module {
@@ -13,5 +14,7 @@ val localModule
 		single { LocalStorageManager(androidContext(), get()) }
 		single { LocalMangaRepository(get()) }
 
+		factory { ExternalStorageHelper(androidContext()) }
+
 		viewModel { LocalListViewModel(get(), get(), get(), get()) }
 	}

app/src/main/java/org/koitharu/kotatsu/local/domain/LocalMangaRepository.kt

@@ -46,9 +46,13 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		return files.mapNotNull { x -> runCatching { getFromFile(x) }.getOrNull() }
 	}
 
-	override suspend fun getDetails(manga: Manga) = if (manga.chapters == null) {
-		getFromFile(Uri.parse(manga.url).toFile())
-	} else manga
+	override suspend fun getDetails(manga: Manga) = when {
+		manga.source != MangaSource.LOCAL -> requireNotNull(findSavedManga(manga)) {
+			"Manga is not local or saved"
+		}
+		manga.chapters == null -> getFromFile(Uri.parse(manga.url).toFile())
+		else -> manga
+	}
 
 	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
 		return runInterruptible(Dispatchers.IO){
@@ -102,8 +106,7 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 				url = fileUri,
 				coverUrl = zipUri(
 					file,
-					entryName = index.getCoverEntry()
-						?: findFirstEntry(zip.entries(), isImage = true)?.name.orEmpty()
+					entryName = index.getCoverEntry() ?: findFirstImageEntry(zip.entries())?.name.orEmpty()
 				),
 				chapters = info.chapters?.map { c ->
 					c.copy(url = fileUri, source = MangaSource.LOCAL)
@@ -125,7 +128,7 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 			url = fileUri,
 			publicUrl = fileUri,
 			source = MangaSource.LOCAL,
-			coverUrl = zipUri(file, findFirstEntry(zip.entries(), isImage = true)?.name.orEmpty()),
+			coverUrl = zipUri(file, findFirstImageEntry(zip.entries())?.name.orEmpty()),
 			chapters = chapters.sortedWith(AlphanumComparator()).mapIndexed { i, s ->
 				MangaChapter(
 					id = "$i$s".longHashCode(),
@@ -184,20 +187,16 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		}
 	}
 
-	private fun zipUri(file: File, entryName: String) = Uri.fromParts("cbz", file.path, entryName).toString()
+	private fun zipUri(file: File, entryName: String) = "cbz://${file.path}#$entryName"
 
-	private fun findFirstEntry(entries: Enumeration<out ZipEntry>, isImage: Boolean): ZipEntry? {
+	private fun findFirstImageEntry(entries: Enumeration<out ZipEntry>): ZipEntry? {
 		val list = entries.toList()
 			.filterNot { it.isDirectory }
 			.sortedWith(compareBy(AlphanumComparator()) { x -> x.name })
-		return if (isImage) {
-			val map = MimeTypeMap.getSingleton()
-			list.firstOrNull {
-				map.getMimeTypeFromExtension(it.name.substringAfterLast('.'))
-					?.startsWith("image/") == true
-			}
-		} else {
-			list.firstOrNull()
+		val map = MimeTypeMap.getSingleton()
+		return list.firstOrNull {
+			map.getMimeTypeFromExtension(it.name.substringAfterLast('.'))
+				?.startsWith("image/") == true
 		}
 	}
 

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

@@ -9,6 +9,9 @@ import android.view.MenuItem
 import android.view.View
 import androidx.activity.result.ActivityResultCallback
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.appcompat.view.ActionMode
+import androidx.core.net.toFile
+import androidx.core.net.toUri
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.snackbar.Snackbar
 import org.koin.androidx.viewmodel.ext.android.viewModel
@@ -16,8 +19,7 @@ import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.download.ui.service.DownloadService
 import org.koitharu.kotatsu.list.ui.MangaListFragment
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.util.ellipsize
+import org.koitharu.kotatsu.utils.ShareHelper
 import org.koitharu.kotatsu.utils.progress.Progress
 
 class LocalListFragment : MangaListFragment(), ActivityResultCallback<List<@JvmSuppressWildcards Uri>> {
@@ -46,7 +48,7 @@ class LocalListFragment : MangaListFragment(), ActivityResultCallback<List<@JvmS
 
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
-		viewModel.onMangaRemoved.observe(viewLifecycleOwner, ::onItemRemoved)
+		viewModel.onMangaRemoved.observe(viewLifecycleOwner) { onItemRemoved() }
 		viewModel.importProgress.observe(viewLifecycleOwner, ::onImportProgressChanged)
 	}
 
@@ -97,35 +99,41 @@ class LocalListFragment : MangaListFragment(), ActivityResultCallback<List<@JvmS
 		viewModel.importFiles(result)
 	}
 
-	override fun onCreatePopupMenu(inflater: MenuInflater, menu: Menu, data: Manga) {
-		super.onCreatePopupMenu(inflater, menu, data)
-		inflater.inflate(R.menu.popup_local, menu)
+	override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
+		mode.menuInflater.inflate(R.menu.mode_local, menu)
+		return super.onCreateActionMode(mode, menu)
 	}
 
-	override fun onPopupMenuItemSelected(item: MenuItem, data: Manga): Boolean {
+	override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
 		return when (item.itemId) {
-			R.id.action_delete -> {
-				MaterialAlertDialogBuilder(context ?: return false)
-					.setTitle(R.string.delete_manga)
-					.setMessage(getString(R.string.text_delete_local_manga, data.title))
-					.setPositiveButton(R.string.delete) { _, _ ->
-						viewModel.delete(data)
-					}
-					.setNegativeButton(android.R.string.cancel, null)
-					.show()
+			R.id.action_remove -> {
+				showDeletionConfirm(selectedItemsIds, mode)
 				true
 			}
-			else -> super.onPopupMenuItemSelected(item, data)
+			R.id.action_share -> {
+				val files = selectedItems.map { it.url.toUri().toFile() }
+				ShareHelper(requireContext()).shareCbz(files)
+				mode.finish()
+				true
+			}
+			else -> super.onActionItemClicked(mode, item)
 		}
 	}
 
-	private fun onItemRemoved(item: Manga) {
-		Snackbar.make(
-			binding.recyclerView, getString(
-				R.string._s_deleted_from_local_storage,
-				item.title.ellipsize(16)
-			), Snackbar.LENGTH_SHORT
-		).show()
+	private fun showDeletionConfirm(ids: Set<Long>, mode: ActionMode) {
+		MaterialAlertDialogBuilder(context ?: return)
+			.setTitle(R.string.delete_manga)
+			.setMessage(getString(R.string.text_delete_local_manga_batch))
+			.setPositiveButton(R.string.delete) { _, _ ->
+				viewModel.delete(ids)
+				mode.finish()
+			}
+			.setNegativeButton(android.R.string.cancel, null)
+			.show()
+	}
+
+	private fun onItemRemoved() {
+		Snackbar.make(binding.recyclerView, R.string.removal_completed, Snackbar.LENGTH_SHORT).show()
 	}
 
 	private fun onImportProgressChanged(progress: Progress?) {

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

@@ -3,10 +3,12 @@ package org.koitharu.kotatsu.local.ui
 import android.net.Uri
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
+import java.io.IOException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.os.ShortcutsRepository
@@ -19,7 +21,6 @@ import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.progress.Progress
-import java.io.IOException
 
 class LocalListViewModel(
 	private val repository: LocalMangaRepository,
@@ -28,7 +29,7 @@ class LocalListViewModel(
 	private val shortcutsRepository: ShortcutsRepository,
 ) : MangaListViewModel(settings) {
 
-	val onMangaRemoved = SingleLiveEvent<Manga>()
+	val onMangaRemoved = SingleLiveEvent<Unit>()
 	val importProgress = MutableLiveData<Progress?>(null)
 	private val listError = MutableStateFlow<Throwable?>(null)
 	private val mangaList = MutableStateFlow<List<Manga>?>(null)
@@ -87,18 +88,23 @@ class LocalListViewModel(
 		}
 	}
 
-	fun delete(manga: Manga) {
-		launchJob {
+	fun delete(ids: Set<Long>) {
+		launchLoadingJob {
 			withContext(Dispatchers.Default) {
-				val original = repository.getRemoteManga(manga)
-				repository.delete(manga) || throw IOException("Unable to delete file")
-				runCatching {
-					historyRepository.deleteOrSwap(manga, original)
+				val itemsToRemove = checkNotNull(mangaList.value).filter { it.id in ids }
+				for (manga in itemsToRemove) {
+					val original = repository.getRemoteManga(manga)
+					repository.delete(manga) || throw IOException("Unable to delete file")
+					runCatching {
+						historyRepository.deleteOrSwap(manga, original)
+					}
+					mangaList.update { list ->
+						list?.filterNot { it.id == manga.id }
+					}
 				}
-				mangaList.value = mangaList.value?.filterNot { it.id == manga.id }
 			}
 			shortcutsRepository.updateShortcuts()
-			onMangaRemoved.call(manga)
+			onMangaRemoved.call(Unit)
 		}
 	}
 

app/src/main/java/org/koitharu/kotatsu/main/ui/MainActivity.kt

@@ -8,18 +8,15 @@ import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup.MarginLayoutParams
 import androidx.appcompat.app.ActionBarDrawerToggle
+import androidx.appcompat.view.ActionMode
 import androidx.core.content.ContextCompat
 import androidx.core.graphics.Insets
-import androidx.core.view.GravityCompat
-import androidx.core.view.ViewCompat
-import androidx.core.view.updateLayoutParams
-import androidx.core.view.updatePadding
+import androidx.core.view.*
 import androidx.drawerlayout.widget.DrawerLayout
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentTransaction
 import androidx.fragment.app.commit
 import androidx.lifecycle.lifecycleScope
-import androidx.swiperefreshlayout.widget.CircularProgressDrawable
 import com.google.android.material.appbar.AppBarLayout
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.navigation.NavigationView
@@ -58,11 +55,13 @@ import org.koitharu.kotatsu.suggestions.ui.SuggestionsWorker
 import org.koitharu.kotatsu.tracker.ui.FeedFragment
 import org.koitharu.kotatsu.tracker.work.TrackWorker
 import org.koitharu.kotatsu.utils.ext.*
+import com.google.android.material.R as materialR
 
 private const val TAG_PRIMARY = "primary"
 private const val TAG_SEARCH = "search"
 
-class MainActivity : BaseActivity<ActivityMainBinding>(),
+class MainActivity :
+	BaseActivity<ActivityMainBinding>(),
 	NavigationView.OnNavigationItemSelectedListener,
 	AppBarOwner,
 	View.OnClickListener,
@@ -92,7 +91,9 @@ class MainActivity : BaseActivity<ActivityMainBinding>(),
 				R.string.open_menu,
 				R.string.close_menu
 			).apply {
-				setHomeAsUpIndicator(ContextCompat.getDrawable(this@MainActivity, R.drawable.ic_arrow_back))
+				setHomeAsUpIndicator(
+					ContextCompat.getDrawable(this@MainActivity, materialR.drawable.abc_ic_ab_back_material)
+				)
 				setToolbarNavigationClickListener {
 					binding.searchView.hideKeyboard()
 					onBackPressed()
@@ -106,7 +107,7 @@ class MainActivity : BaseActivity<ActivityMainBinding>(),
 			onFocusChangeListener = this@MainActivity
 			searchSuggestionListener = this@MainActivity
 			if (drawer == null) {
-				drawableStart = ContextCompat.getDrawable(context, R.drawable.ic_search)
+				drawableStart = context.getThemeDrawable(materialR.attr.actionModeWebSearchDrawable)
 			}
 		}
 
@@ -130,6 +131,7 @@ class MainActivity : BaseActivity<ActivityMainBinding>(),
 		viewModel.onOpenReader.observe(this, this::onOpenReader)
 		viewModel.onError.observe(this, this::onError)
 		viewModel.isLoading.observe(this, this::onLoadingStateChanged)
+		viewModel.isResumeEnabled.observe(this, this::onResumeEnabledChanged)
 		viewModel.remoteSources.observe(this, this::updateSideMenu)
 		viewModel.isSuggestionsEnabled.observe(this, this::setSuggestionsEnabled)
 	}
@@ -284,6 +286,16 @@ class MainActivity : BaseActivity<ActivityMainBinding>(),
 			}.show()
 	}
 
+	override fun onSupportActionModeStarted(mode: ActionMode) {
+		super.onSupportActionModeStarted(mode)
+		adjustDrawerLock()
+	}
+
+	override fun onSupportActionModeFinished(mode: ActionMode) {
+		super.onSupportActionModeFinished(mode)
+		adjustDrawerLock()
+	}
+
 	private fun onOpenReader(manga: Manga) {
 		val options = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 			ActivityOptions.makeClipRevealAnimation(
@@ -294,25 +306,19 @@ class MainActivity : BaseActivity<ActivityMainBinding>(),
 				binding.fab, 0, 0, binding.fab.measuredWidth, binding.fab.measuredHeight
 			)
 		}
-		startActivity(ReaderActivity.newIntent(this, manga, null), options?.toBundle())
+		startActivity(ReaderActivity.newIntent(this, manga), options?.toBundle())
 	}
 
 	private fun onError(e: Throwable) {
-		Snackbar.make(binding.container, e.getDisplayMessage(resources), Snackbar.LENGTH_SHORT)
-			.show()
+		Snackbar.make(binding.container, e.getDisplayMessage(resources), Snackbar.LENGTH_SHORT).show()
 	}
 
 	private fun onLoadingStateChanged(isLoading: Boolean) {
 		binding.fab.isEnabled = !isLoading
-		if (isLoading) {
-			binding.fab.setImageDrawable(CircularProgressDrawable(this).also {
-				it.setColorSchemeColors(R.color.kotatsu_onPrimaryContainer)
-				it.strokeWidth = resources.resolveDp(3.5f)
-				it.start()
-			})
-		} else {
-			binding.fab.setImageResource(R.drawable.ic_read_fill)
-		}
+	}
+
+	private fun onResumeEnabledChanged(isEnabled: Boolean) {
+		adjustFabVisibility(isResumeEnabled = isEnabled)
 	}
 
 	private fun updateSideMenu(remoteSources: List<MangaSource>) {
@@ -366,14 +372,14 @@ class MainActivity : BaseActivity<ActivityMainBinding>(),
 	}
 
 	private fun onSearchOpened() {
-		drawer?.setDrawerLockMode(DrawerLayout.LOCK_MODE_LOCKED_CLOSED)
 		drawerToggle?.isDrawerIndicatorEnabled = false
+		adjustDrawerLock()
 		adjustFabVisibility(isSearchOpened = true)
 	}
 
 	private fun onSearchClosed() {
-		drawer?.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED)
 		drawerToggle?.isDrawerIndicatorEnabled = true
+		adjustDrawerLock()
 		adjustFabVisibility(isSearchOpened = false)
 	}
 
@@ -391,9 +397,27 @@ class MainActivity : BaseActivity<ActivityMainBinding>(),
 	}
 
 	private fun adjustFabVisibility(
+		isResumeEnabled: Boolean = viewModel.isResumeEnabled.value == true,
 		topFragment: Fragment? = supportFragmentManager.findFragmentByTag(TAG_PRIMARY),
 		isSearchOpened: Boolean = supportFragmentManager.findFragmentByTag(TAG_SEARCH)?.isVisible == true,
 	) {
-		if (!isSearchOpened && topFragment is HistoryListFragment) binding.fab.show() else binding.fab.hide()
+		val fab = binding.fab
+		if (isResumeEnabled && !isSearchOpened && topFragment is HistoryListFragment) {
+			if (!fab.isVisible) {
+				fab.show()
+			}
+		} else {
+			if (fab.isVisible) {
+				fab.hide()
+			}
+		}
+	}
+
+	private fun adjustDrawerLock() {
+		val drawer = drawer ?: return
+		val isLocked = actionModeDelegate.isActionModeStarted || (drawerToggle?.isDrawerIndicatorEnabled == false)
+		drawer.setDrawerLockMode(
+			if (isLocked) DrawerLayout.LOCK_MODE_LOCKED_CLOSED else DrawerLayout.LOCK_MODE_UNLOCKED
+		)
 	}
 }

app/src/main/java/org/koitharu/kotatsu/main/ui/MainViewModel.kt

@@ -27,6 +27,10 @@ class MainViewModel(
 		.map { settings.isSuggestionsEnabled }
 		.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
 
+	val isResumeEnabled = historyRepository
+		.observeHasItems()
+		.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
+
 	val remoteSources = settings.observe()
 		.filter { it == AppSettings.KEY_SOURCES_ORDER || it == AppSettings.KEY_SOURCES_HIDDEN }
 		.onStart { emit("") }
@@ -35,9 +39,8 @@ class MainViewModel(
 
 	fun openLastReader() {
 		launchLoadingJob {
-			val manga = historyRepository.getList(0, 1).firstOrNull()
-				?: throw EmptyHistoryException()
+			val manga = historyRepository.getLastOrNull() ?: throw EmptyHistoryException()
 			onOpenReader.call(manga)
 		}
 	}
-}
+}

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

@@ -13,6 +13,15 @@ val readerModule
 		single { PagesCache(get()) }
 
 		viewModel { params ->
-			ReaderViewModel(params[0], params[1], get(), get(), get(), get(), get())
+			ReaderViewModel(
+				intent = params[0],
+				initialState = params[1],
+				preselectedBranch = params[2],
+				dataRepository = get(),
+				historyRepository = get(),
+				shortcutsRepository = get(),
+				settings = get(),
+				externalStorageHelper = get(),
+			)
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/reader/domain/PageLoader.kt

@@ -6,6 +6,10 @@ import android.graphics.BitmapFactory
 import android.net.Uri
 import androidx.collection.LongSparseArray
 import androidx.collection.set
+import java.io.File
+import java.util.*
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.zip.ZipFile
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -27,10 +31,6 @@ import org.koitharu.kotatsu.parsers.util.await
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
 import org.koitharu.kotatsu.utils.ext.connectivityManager
 import org.koitharu.kotatsu.utils.progress.ProgressDeferred
-import java.io.File
-import java.util.*
-import java.util.concurrent.atomic.AtomicInteger
-import java.util.zip.ZipFile
 
 private const val PROGRESS_UNDEFINED = -1f
 private const val PREFETCH_LIMIT_DEFAULT = 10
@@ -77,7 +77,7 @@ class PageLoader : KoinComponent, Closeable {
 		}
 	}
 
-	fun loadPageAsync(page: MangaPage, force: Boolean) : ProgressDeferred<File, Float> {
+	fun loadPageAsync(page: MangaPage, force: Boolean): ProgressDeferred<File, Float> {
 		if (!force) {
 			cache[page.url]?.let {
 				return getCompletedTask(it)

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

@@ -5,8 +5,6 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.fragment.app.FragmentManager
-import androidx.recyclerview.widget.RecyclerView
-import com.google.android.material.divider.MaterialDividerItemDecoration
 import org.koin.android.ext.android.get
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseBottomSheet
@@ -21,6 +19,7 @@ import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.utils.BottomSheetToolbarController
 import org.koitharu.kotatsu.utils.RecyclerViewScrollCallback
 import org.koitharu.kotatsu.utils.ext.withArgs
+import kotlin.math.roundToInt
 
 class ChaptersBottomSheet : BaseBottomSheet<SheetChaptersBinding>(), OnListItemClickListener<ChapterListItem> {
 
@@ -35,9 +34,6 @@ class ChaptersBottomSheet : BaseBottomSheet<SheetChaptersBinding>(), OnListItemC
 		if (!resources.getBoolean(R.bool.is_tablet)) {
 			binding.toolbar.navigationIcon = null
 		}
-		binding.recyclerView.addItemDecoration(
-			MaterialDividerItemDecoration(view.context, RecyclerView.VERTICAL)
-		)
 		val chapters = arguments?.getParcelable<ParcelableMangaChapters>(ARG_CHAPTERS)?.chapters
 		if (chapters.isNullOrEmpty()) {
 			dismissAllowingStateLoss()
@@ -59,7 +55,8 @@ class ChaptersBottomSheet : BaseBottomSheet<SheetChaptersBinding>(), OnListItemC
 		binding.recyclerView.adapter = ChaptersAdapter(this).also { adapter ->
 			if (currentPosition >= 0) {
 				val targetPosition = (currentPosition - 1).coerceAtLeast(0)
-				adapter.setItems(items, RecyclerViewScrollCallback(binding.recyclerView, targetPosition))
+				val offset = (resources.getDimensionPixelSize(R.dimen.chapter_list_item_height) * 0.6).roundToInt()
+				adapter.setItems(items, RecyclerViewScrollCallback(binding.recyclerView, targetPosition, offset))
 			} else {
 				adapter.items = items
 			}

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

@@ -0,0 +1,26 @@
+package org.koitharu.kotatsu.reader.ui
+
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Environment
+import android.provider.DocumentsContract
+import android.webkit.MimeTypeMap
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.core.net.toUri
+
+class PageSaveContract : ActivityResultContracts.CreateDocument() {
+
+	override fun createIntent(context: Context, input: String): Intent {
+		val intent = super.createIntent(context, input)
+		intent.type = MimeTypeMap.getSingleton()
+			.getMimeTypeFromExtension(input.substringAfterLast('.')) ?: "image/*"
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+			intent.putExtra(
+				DocumentsContract.EXTRA_INITIAL_URI,
+				Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES).toUri(),
+			)
+		}
+		return intent
+	}
+}

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

@@ -1,18 +1,15 @@
 package org.koitharu.kotatsu.reader.ui
 
-import android.Manifest
 import android.content.Context
 import android.content.DialogInterface
 import android.content.Intent
-import android.content.pm.PackageManager
 import android.net.Uri
 import android.os.Bundle
 import android.view.*
 import android.widget.Toast
 import androidx.activity.result.ActivityResultCallback
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.core.content.ContextCompat
 import androidx.core.graphics.Insets
+import androidx.core.net.toUri
 import androidx.core.view.*
 import androidx.fragment.app.commit
 import androidx.lifecycle.lifecycleScope
@@ -47,6 +44,7 @@ import org.koitharu.kotatsu.reader.ui.pager.standard.PagerReaderFragment
 import org.koitharu.kotatsu.reader.ui.pager.webtoon.WebtoonReaderFragment
 import org.koitharu.kotatsu.reader.ui.thumbnails.OnPageSelectListener
 import org.koitharu.kotatsu.reader.ui.thumbnails.PagesThumbnailsSheet
+import org.koitharu.kotatsu.settings.SettingsActivity
 import org.koitharu.kotatsu.utils.GridTouchHelper
 import org.koitharu.kotatsu.utils.ScreenOrientationHelper
 import org.koitharu.kotatsu.utils.ShareHelper
@@ -54,22 +52,28 @@ import org.koitharu.kotatsu.utils.ext.getDisplayMessage
 import org.koitharu.kotatsu.utils.ext.hasGlobalPoint
 import org.koitharu.kotatsu.utils.ext.observeWithPrevious
 
-class ReaderActivity : BaseFullscreenActivity<ActivityReaderBinding>(),
+class ReaderActivity :
+	BaseFullscreenActivity<ActivityReaderBinding>(),
 	ChaptersBottomSheet.OnChapterChangeListener,
-	GridTouchHelper.OnGridTouchListener, OnPageSelectListener, ReaderConfigDialog.Callback,
-	ActivityResultCallback<Boolean>, ReaderControlDelegate.OnInteractionListener, OnApplyWindowInsetsListener {
+	GridTouchHelper.OnGridTouchListener,
+	OnPageSelectListener,
+	ReaderConfigDialog.Callback,
+	ActivityResultCallback<Uri?>,
+	ReaderControlDelegate.OnInteractionListener,
+	OnApplyWindowInsetsListener {
 
 	private val viewModel by viewModel<ReaderViewModel> {
-		parametersOf(MangaIntent(intent), intent?.getParcelableExtra<ReaderState>(EXTRA_STATE))
+		parametersOf(
+			MangaIntent(intent),
+			intent?.getParcelableExtra<ReaderState>(EXTRA_STATE),
+			intent?.getStringExtra(EXTRA_BRANCH),
+		)
 	}
 
 	private lateinit var touchHelper: GridTouchHelper
 	private lateinit var orientationHelper: ScreenOrientationHelper
 	private lateinit var controlDelegate: ReaderControlDelegate
-	private val permissionsRequest = registerForActivityResult(
-		ActivityResultContracts.RequestPermission(),
-		this
-	)
+	private val savePageRequest = registerForActivityResult(PageSaveContract(), this)
 	private var gestureInsets: Insets = Insets.NONE
 
 	private val reader
@@ -142,7 +146,8 @@ class ReaderActivity : BaseFullscreenActivity<ActivityReaderBinding>(),
 		when (item.itemId) {
 			R.id.action_reader_mode -> {
 				ReaderConfigDialog.show(
-					supportFragmentManager, when (reader) {
+					supportFragmentManager,
+					when (reader) {
 						is PagerReaderFragment -> ReaderMode.STANDARD
 						is WebtoonReaderFragment -> ReaderMode.WEBTOON
 						is ReversedReaderFragment -> ReaderMode.REVERSED
@@ -154,7 +159,7 @@ class ReaderActivity : BaseFullscreenActivity<ActivityReaderBinding>(),
 				)
 			}
 			R.id.action_settings -> {
-				startActivity(SimpleSettingsActivity.newReaderSettingsIntent(this))
+				startActivity(SettingsActivity.newReaderSettingsIntent(this))
 			}
 			R.id.action_chapters -> {
 				ChaptersBottomSheet.show(
@@ -180,29 +185,22 @@ class ReaderActivity : BaseFullscreenActivity<ActivityReaderBinding>(),
 				}
 			}
 			R.id.action_save_page -> {
-				if (!viewModel.content.value?.pages.isNullOrEmpty()) {
-					if (ContextCompat.checkSelfPermission(
-							this,
-							Manifest.permission.WRITE_EXTERNAL_STORAGE
-						) == PackageManager.PERMISSION_GRANTED
-					) {
-						onActivityResult(true)
-					} else {
-						permissionsRequest.launch(Manifest.permission.WRITE_EXTERNAL_STORAGE)
+				viewModel.getCurrentPage()?.also { page ->
+					viewModel.saveCurrentState(reader?.getCurrentState())
+					val name = page.url.toUri().run {
+						fragment ?: lastPathSegment ?: ""
 					}
-				} else {
-					showWaitWhileLoading()
-				}
+					savePageRequest.launch(name)
+				} ?: showWaitWhileLoading()
 			}
 			else -> return super.onOptionsItemSelected(item)
 		}
 		return true
 	}
 
-	override fun onActivityResult(result: Boolean) {
-		if (result) {
-			viewModel.saveCurrentState(reader?.getCurrentState())
-			viewModel.saveCurrentPage()
+	override fun onActivityResult(uri: Uri?) {
+		if (uri != null) {
+			viewModel.saveCurrentPage(uri)
 		}
 	}
 
@@ -286,7 +284,7 @@ class ReaderActivity : BaseFullscreenActivity<ActivityReaderBinding>(),
 
 	private fun onPageSaved(uri: Uri?) {
 		if (uri != null) {
-			Snackbar.make(binding.container, R.string.page_saved, Snackbar.LENGTH_INDEFINITE)
+			Snackbar.make(binding.container, R.string.page_saved, Snackbar.LENGTH_LONG)
 				.setAnchorView(binding.appbarBottom)
 				.setAction(R.string.share) {
 					ShareHelper(this).shareImage(uri)
@@ -407,18 +405,29 @@ class ReaderActivity : BaseFullscreenActivity<ActivityReaderBinding>(),
 
 		const val ACTION_MANGA_READ = "${BuildConfig.APPLICATION_ID}.action.READ_MANGA"
 		private const val EXTRA_STATE = "state"
+		private const val EXTRA_BRANCH = "branch"
 		private const val TOAST_DURATION = 1500L
 
+		fun newIntent(context: Context, manga: Manga): Intent {
+			return Intent(context, ReaderActivity::class.java)
+				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga))
+		}
+
+		fun newIntent(context: Context, manga: Manga, branch: String?): Intent {
+			return Intent(context, ReaderActivity::class.java)
+				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga))
+				.putExtra(EXTRA_BRANCH, branch)
+		}
+
 		fun newIntent(context: Context, manga: Manga, state: ReaderState?): Intent {
 			return Intent(context, ReaderActivity::class.java)
 				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga))
 				.putExtra(EXTRA_STATE, state)
 		}
 
-		fun newIntent(context: Context, mangaId: Long, state: ReaderState?): Intent {
+		fun newIntent(context: Context, mangaId: Long): Intent {
 			return Intent(context, ReaderActivity::class.java)
 				.putExtra(MangaIntent.KEY_ID, mangaId)
-				.putExtra(EXTRA_STATE, state)
 		}
 	}
-}
+}

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

@@ -20,8 +20,10 @@ data class ReaderState(
 			scroll = history.scroll
 		)
 
-		fun initial(manga: Manga) = ReaderState(
-			chapterId = manga.chapters?.firstOrNull()?.id ?: error("Cannot find first chapter"),
+		fun initial(manga: Manga, branch: String?) = ReaderState(
+			chapterId = manga.chapters?.firstOrNull {
+				it.branch == branch
+			}?.id ?: error("Cannot find first chapter"),
 			page = 0,
 			scroll = 0
 		)

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

@@ -8,6 +8,7 @@ import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.get
+import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
 import org.koitharu.kotatsu.base.domain.MangaIntent
 import org.koitharu.kotatsu.base.domain.MangaUtils
@@ -25,7 +26,7 @@ import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.reader.domain.PageLoader
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
 import org.koitharu.kotatsu.reader.ui.pager.ReaderUiState
-import org.koitharu.kotatsu.utils.DownloadManagerHelper
+import org.koitharu.kotatsu.utils.ExternalStorageHelper
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.IgnoreErrors
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
@@ -34,11 +35,12 @@ import org.koitharu.kotatsu.utils.ext.processLifecycleScope
 class ReaderViewModel(
 	private val intent: MangaIntent,
 	initialState: ReaderState?,
+	private val preselectedBranch: String?,
 	private val dataRepository: MangaDataRepository,
 	private val historyRepository: HistoryRepository,
 	private val shortcutsRepository: ShortcutsRepository,
 	private val settings: AppSettings,
-	private val downloadManagerHelper: DownloadManagerHelper,
+	private val externalStorageHelper: ExternalStorageHelper,
 ) : BaseViewModel() {
 
 	private var loadingJob: Job? = null
@@ -135,25 +137,29 @@ class ReaderViewModel(
 		return pages.filter { it.chapterId == chapterId }.map { it.toMangaPage() }
 	}
 
-	fun saveCurrentPage() {
+	fun saveCurrentPage(destination: Uri) {
 		launchJob(Dispatchers.Default) {
 			try {
-				val state = currentState.value ?: error("Undefined state")
-				val page = content.value?.pages?.find {
-					it.chapterId == state.chapterId && it.index == state.page
-				}?.toMangaPage() ?: error("Page not found")
-				val repo = MangaRepository(page.source)
-				val pageUrl = repo.getPageUrl(page)
-				val downloadId = downloadManagerHelper.downloadPage(page, pageUrl)
-				val uri = downloadManagerHelper.awaitDownload(downloadId)
-				onPageSaved.postCall(uri)
+				val page = getCurrentPage() ?: error("Page not found")
+				externalStorageHelper.savePage(page, destination)
+				onPageSaved.postCall(destination)
 			} catch (_: CancellationException) {
 			} catch (e: Exception) {
+				if (BuildConfig.DEBUG) {
+					e.printStackTrace()
+				}
 				onPageSaved.postCall(null)
 			}
 		}
 	}
 
+	fun getCurrentPage(): MangaPage? {
+		val state = currentState.value ?: return null
+		return content.value?.pages?.find {
+			it.chapterId == state.chapterId && it.index == state.page
+		}?.toMangaPage()
+	}
+
 	fun switchChapter(id: Long) {
 		val prevJob = loadingJob
 		loadingJob = launchLoadingJob(Dispatchers.Default) {
@@ -188,8 +194,7 @@ class ReaderViewModel(
 
 	private fun loadImpl() {
 		loadingJob = launchLoadingJob(Dispatchers.Default) {
-			var manga = dataRepository.resolveIntent(intent)
-				?: throw MangaNotFoundException("Cannot find manga")
+			var manga = dataRepository.resolveIntent(intent) ?: throw MangaNotFoundException("Cannot find manga")
 			mangaData.value = manga
 			val repo = MangaRepository(manga.source)
 			manga = repo.getDetails(manga)
@@ -197,21 +202,20 @@ class ReaderViewModel(
 				chapters.put(it.id, it)
 			}
 			// determine mode
-			val mode =
-				dataRepository.getReaderMode(manga.id) ?: manga.chapters?.randomOrNull()?.let {
-					val pages = repo.getPages(it)
-					val isWebtoon = MangaUtils.determineMangaIsWebtoon(pages)
-					val newMode = getReaderMode(isWebtoon)
-					if (isWebtoon != null) {
-						dataRepository.savePreferences(manga, newMode)
-					}
-					newMode
-				} ?: error("There are no chapters in this manga")
+			val mode = dataRepository.getReaderMode(manga.id) ?: manga.chapters?.randomOrNull()?.let {
+				val pages = repo.getPages(it)
+				val isWebtoon = MangaUtils.determineMangaIsWebtoon(pages)
+				val newMode = getReaderMode(isWebtoon)
+				if (isWebtoon != null) {
+					dataRepository.savePreferences(manga, newMode)
+				}
+				newMode
+			} ?: error("There are no chapters in this manga")
 			// obtain state
 			if (currentState.value == null) {
 				currentState.value = historyRepository.getOne(manga)?.let {
 					ReaderState.from(it)
-				} ?: ReaderState.initial(manga)
+				} ?: ReaderState.initial(manga, preselectedBranch)
 			}
 
 			val branch = chapters[currentState.value?.chapterId ?: 0L].branch
@@ -327,6 +331,5 @@ class ReaderViewModel(
 				)
 			}
 		}
-
 	}
-}
+}

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

@@ -1,75 +0,0 @@
-package org.koitharu.kotatsu.reader.ui
-
-import android.content.Context
-import android.content.Intent
-import android.os.Bundle
-import android.view.ViewGroup
-import androidx.core.graphics.Insets
-import androidx.core.view.updateLayoutParams
-import androidx.core.view.updatePadding
-import androidx.fragment.app.commit
-import org.koitharu.kotatsu.BuildConfig
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.base.ui.BaseActivity
-import org.koitharu.kotatsu.databinding.ActivitySettingsSimpleBinding
-import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.settings.*
-
-class SimpleSettingsActivity : BaseActivity<ActivitySettingsSimpleBinding>() {
-
-	override fun onCreate(savedInstanceState: Bundle?) {
-		super.onCreate(savedInstanceState)
-		setContentView(ActivitySettingsSimpleBinding.inflate(layoutInflater))
-		supportActionBar?.setDisplayHomeAsUpEnabled(true)
-		supportFragmentManager.commit {
-			replace(
-				R.id.container,
-				when (intent?.action) {
-					Intent.ACTION_MANAGE_NETWORK_USAGE -> NetworkSettingsFragment()
-					ACTION_READER -> ReaderSettingsFragment()
-					ACTION_SUGGESTIONS -> SuggestionsSettingsFragment()
-					ACTION_SOURCE -> SourceSettingsFragment.newInstance(
-						intent.getSerializableExtra(EXTRA_SOURCE) as? MangaSource ?: MangaSource.LOCAL
-					)
-					else -> MainSettingsFragment()
-				}
-			)
-		}
-	}
-
-	override fun onWindowInsetsChanged(insets: Insets) {
-		with(binding.toolbar) {
-			updatePadding(
-				left = insets.left,
-				right = insets.right
-			)
-			updateLayoutParams<ViewGroup.MarginLayoutParams> {
-				topMargin = insets.top
-			}
-		}
-	}
-
-	companion object {
-
-		private const val ACTION_READER =
-			"${BuildConfig.APPLICATION_ID}.action.MANAGE_READER_SETTINGS"
-		private const val ACTION_SUGGESTIONS =
-			"${BuildConfig.APPLICATION_ID}.action.MANAGE_SUGGESTIONS"
-		private const val ACTION_SOURCE =
-			"${BuildConfig.APPLICATION_ID}.action.MANAGE_SOURCE_SETTINGS"
-		private const val EXTRA_SOURCE = "source"
-
-		fun newReaderSettingsIntent(context: Context) =
-			Intent(context, SimpleSettingsActivity::class.java)
-				.setAction(ACTION_READER)
-
-		fun newSuggestionsSettingsIntent(context: Context) =
-			Intent(context, SimpleSettingsActivity::class.java)
-				.setAction(ACTION_SUGGESTIONS)
-
-		fun newSourceSettingsIntent(context: Context, source: MangaSource) =
-			Intent(context, SimpleSettingsActivity::class.java)
-				.setAction(ACTION_SOURCE)
-				.putExtra(EXTRA_SOURCE, source)
-	}
-}

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

@@ -6,6 +6,7 @@ import androidx.recyclerview.widget.RecyclerView
 import androidx.viewbinding.ViewBinding
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.databinding.LayoutPageInfoBinding
 import org.koitharu.kotatsu.reader.domain.PageLoader
 
 abstract class BasePageHolder<B : ViewBinding>(
@@ -16,6 +17,7 @@ abstract class BasePageHolder<B : ViewBinding>(
 ) : RecyclerView.ViewHolder(binding.root), PageHolderDelegate.Callback {
 
 	protected val delegate = PageHolderDelegate(loader, settings, this, exceptionResolver)
+	protected val bindingInfo = LayoutPageInfoBinding.bind(binding.root)
 
 	val context: Context
 		get() = itemView.context

app/src/main/java/org/koitharu/kotatsu/reader/ui/pager/reversed/ReversedReaderFragment.kt

@@ -1,10 +1,12 @@
 package org.koitharu.kotatsu.reader.ui.pager.reversed
 
+import android.annotation.SuppressLint
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.core.view.children
+import kotlin.math.absoluteValue
 import kotlinx.coroutines.async
 import org.koin.android.ext.android.get
 import org.koitharu.kotatsu.databinding.FragmentReaderStandardBinding
@@ -17,7 +19,6 @@ import org.koitharu.kotatsu.utils.ext.doOnPageChanged
 import org.koitharu.kotatsu.utils.ext.recyclerView
 import org.koitharu.kotatsu.utils.ext.resetTransformations
 import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
-import kotlin.math.absoluteValue
 
 class ReversedReaderFragment : BaseReader<FragmentReaderStandardBinding>() {
 
@@ -28,6 +29,7 @@ class ReversedReaderFragment : BaseReader<FragmentReaderStandardBinding>() {
 		container: ViewGroup?
 	) = FragmentReaderStandardBinding.inflate(inflater, container, false)
 
+	@SuppressLint("NotifyDataSetChanged")
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
 		pagerAdapter = ReversedPagesAdapter(viewModel.pageLoader, get(), exceptionResolver)