Update parsers

Currently translated at 100.0% (274 of 274 strings)

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

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+    - name: ⚠️ Source issue
+      url: https://github.com/nv95/kotatsu-parsers/issues/new
+      about: Issues and requests for sources should be opened in the kotatsu-parsers repository instead

.github/ISSUE_TEMPLATE/report_issue.yml

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

.github/ISSUE_TEMPLATE/request_feature.yml

@@ -0,0 +1,39 @@
+name: ⭐ Feature request
+description: Suggest a feature to improve Kotatsu
+labels: [feature request]
+body:
+
+    - type: textarea
+      id: feature-description
+      attributes:
+          label: Describe your suggested feature
+          description: How can Kotatsu be improved?
+          placeholder: |
+              Example:
+                "It should work like this..."
+      validations:
+          required: true
+
+    - type: textarea
+      id: other-details
+      attributes:
+          label: Other details
+          placeholder: |
+              Additional details and attachments.
+
+    - type: checkboxes
+      id: acknowledgements
+      attributes:
+          label: Acknowledgements
+          description: Read this carefully, we will close and ignore your issue if you skimmed through this.
+          options:
+              - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open issue.
+                required: true
+              - label: I have written a short but informative title.
+                required: true
+              - label: If this is an issue with a source, I should be opening an issue in the [parsers repository](https://github.com/nv95/kotatsu-parsers/issues/new).
+                required: true
+              - label: I have updated the app to version **[3.2](https://github.com/nv95/Kotatsu/releases/latest)**.
+                required: true
+              - label: I will fill out all of the requested information in this form.
+                required: true

.gitignore

@@ -9,6 +9,7 @@
 /.idea/workspace.xml
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml
+/.idea/kotlinScripting.xml
 .DS_Store
 /build
 /captures

.idea/gradle.xml

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

.idea/inspectionProfiles/Project_Default.xml

@@ -1,8 +1,10 @@
 <component name="InspectionProjectProfileManager">
   <profile version="1.0">
     <option name="myName" value="Project Default" />
-    <inspection_tool class="BooleanLiteralArgument" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
+    <inspection_tool class="BooleanLiteralArgument" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
+    <inspection_tool class="Destructure" enabled="true" level="INFO" enabled_by_default="true" />
     <inspection_tool class="KeySetIterationMayUseEntrySet" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="ReplaceCollectionCountWithSize" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="TrailingComma" enabled="true" level="INFORMATION" enabled_by_default="true" />
     <inspection_tool class="ZeroLengthArrayInitialization" enabled="true" level="WARNING" enabled_by_default="true" />
   </profile>

app/build.gradle

@@ -14,8 +14,8 @@ android {
 		applicationId 'org.koitharu.kotatsu'
 		minSdkVersion 21
 		targetSdkVersion 32
-		versionCode 401
-		versionName '3.1'
+		versionCode 404
+		versionName '3.2'
 		generatedDensities = []
 		testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
@@ -65,7 +65,7 @@ android {
 }
 dependencies {
 	implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
-	implementation('com.github.nv95:kotatsu-parsers:8e23a7fcd4') {
+	implementation('com.github.nv95:kotatsu-parsers:72cd6fbadf') {
 		exclude group: 'org.json', module: 'json'
 	}
 
@@ -86,7 +86,7 @@ dependencies {
 	implementation 'androidx.viewpager2:viewpager2:1.1.0-beta01'
 	implementation 'androidx.preference:preference-ktx:1.2.0'
 	implementation 'androidx.work:work-runtime-ktx:2.7.1'
-	implementation 'com.google.android.material:material:1.6.0-beta01'
+	implementation 'com.google.android.material:material:1.6.0-rc01'
 	//noinspection LifecycleAnnotationProcessorWithJava8
 	kapt 'androidx.lifecycle:lifecycle-compiler:2.4.1'
 

app/src/debug/java/org/koitharu/kotatsu/core/parser/DummyParser.kt

@@ -0,0 +1,40 @@
+package org.koitharu.kotatsu.core.parser
+
+import java.util.*
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaParser
+import org.koitharu.kotatsu.parsers.config.ConfigKey
+import org.koitharu.kotatsu.parsers.model.*
+
+/**
+ * This parser is just for parser development, it should not be used in releases
+ */
+class DummyParser(override val context: MangaLoaderContext) : MangaParser(MangaSource.DUMMY) {
+
+	override val configKeyDomain: ConfigKey.Domain
+		get() = ConfigKey.Domain("", null)
+
+	override val sortOrders: Set<SortOrder>
+		get() = EnumSet.allOf(SortOrder::class.java)
+
+	override suspend fun getDetails(manga: Manga): Manga {
+		TODO("Not yet implemented")
+	}
+
+	override suspend fun getList(
+		offset: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder?
+	): List<Manga> {
+		TODO("Not yet implemented")
+	}
+
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		TODO("Not yet implemented")
+	}
+
+	override suspend fun getTags(): Set<MangaTag> {
+		TODO("Not yet implemented")
+	}
+}

app/src/debug/java/org/koitharu/kotatsu/core/parser/MangaParser.kt

@@ -0,0 +1,14 @@
+package org.koitharu.kotatsu.core.parser
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaParser
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.newParser
+
+fun MangaParser(source: MangaSource, loaderContext: MangaLoaderContext): MangaParser {
+	return if (source == MangaSource.DUMMY) {
+		DummyParser(loaderContext)
+	} else {
+		source.newParser(loaderContext)
+	}
+}

app/src/main/AndroidManifest.xml

@@ -102,6 +102,7 @@
 		<service
 			android:name="org.koitharu.kotatsu.download.ui.service.DownloadService"
 			android:foregroundServiceType="dataSync" />
+		<service android:name="org.koitharu.kotatsu.local.ui.LocalChaptersRemoveService" />
 		<service
 			android:name="org.koitharu.kotatsu.widget.shelf.ShelfWidgetService"
 			android:permission="android.permission.BIND_REMOTEVIEWS" />

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

@@ -26,7 +26,8 @@ import org.koitharu.kotatsu.base.ui.util.WindowInsetsDelegate
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
 import org.koitharu.kotatsu.core.prefs.AppSettings
 
-abstract class BaseActivity<B : ViewBinding> : AppCompatActivity(),
+abstract class BaseActivity<B : ViewBinding> :
+	AppCompatActivity(),
 	WindowInsetsDelegate.WindowInsetsListener {
 
 	protected lateinit var binding: B
@@ -123,4 +124,4 @@ abstract class BaseActivity<B : ViewBinding> : AppCompatActivity(),
 			super.onBackPressed()
 		}
 	}
-}
+}

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

@@ -1,18 +1,18 @@
 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.base.ui.util.CountedBooleanLiveData
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 
 abstract class BaseViewModel : ViewModel() {
 
 	val onError = SingleLiveEvent<Throwable>()
-	val isLoading = MutableLiveData(false)
+	val isLoading = CountedBooleanLiveData()
 
 	protected fun launchJob(
 		context: CoroutineContext = EmptyCoroutineContext,

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

@@ -0,0 +1,37 @@
+package org.koitharu.kotatsu.base.ui
+
+import android.app.Service
+import android.content.Intent
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+
+abstract class CoroutineIntentService : BaseService() {
+
+	private val mutex = Mutex()
+	protected open val dispatcher: CoroutineDispatcher = Dispatchers.Default
+
+	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+		super.onStartCommand(intent, flags, startId)
+		launchCoroutine(intent, startId)
+		return Service.START_REDELIVER_INTENT
+	}
+
+	private fun launchCoroutine(intent: Intent?, startId: Int) = lifecycleScope.launch {
+		mutex.withLock {
+			try {
+				withContext(dispatcher) {
+					processIntent(intent)
+				}
+			} finally {
+				stopSelf(startId)
+			}
+		}
+	}
+
+	protected abstract suspend fun processIntent(intent: Intent?)
+}

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

@@ -2,6 +2,7 @@ package org.koitharu.kotatsu.base.ui.dialog
 
 import android.content.Context
 import android.content.DialogInterface
+import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.BaseAdapter
@@ -12,7 +13,6 @@ import kotlinx.coroutines.runBlocking
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.databinding.ItemStorageBinding
 import org.koitharu.kotatsu.local.data.LocalStorageManager
-import org.koitharu.kotatsu.utils.ext.inflate
 import java.io.File
 
 class StorageSelectDialog private constructor(private val delegate: AlertDialog) :
@@ -66,7 +66,7 @@ class StorageSelectDialog private constructor(private val delegate: AlertDialog)
 		val volumes = getAvailableVolumes(storageManager)
 
 		override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
-			val view = convertView ?: parent.inflate(R.layout.item_storage)
+			val view = convertView ?: LayoutInflater.from(parent.context).inflate(R.layout.item_storage, parent, false)
 			val binding = (view.tag as? ItemStorageBinding) ?: ItemStorageBinding.bind(view).also {
 				view.tag = it
 			}

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

@@ -0,0 +1,35 @@
+package org.koitharu.kotatsu.base.ui.list.decor
+
+import android.graphics.Rect
+import android.util.SparseIntArray
+import android.view.View
+import androidx.core.util.getOrDefault
+import androidx.core.util.set
+import androidx.recyclerview.widget.RecyclerView
+
+class TypedSpacingItemDecoration(
+	vararg spacingMapping: Pair<Int, Int>,
+	private val fallbackSpacing: Int = 0,
+) : RecyclerView.ItemDecoration() {
+
+	private val mapping = SparseIntArray(spacingMapping.size)
+	
+	init {
+		spacingMapping.forEach { (k, v) -> mapping[k] = v }
+	}
+
+	override fun getItemOffsets(
+		outRect: Rect,
+		view: View,
+		parent: RecyclerView,
+		state: RecyclerView.State
+	) {
+		val itemType = parent.getChildViewHolder(view)?.itemViewType
+		val spacing = if (itemType == null) {
+			fallbackSpacing
+		} else {
+			mapping.getOrDefault(itemType, fallbackSpacing)
+		}
+		outRect.set(spacing, spacing, spacing, spacing)
+	}
+}

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

@@ -0,0 +1,20 @@
+package org.koitharu.kotatsu.base.ui.util
+
+import androidx.lifecycle.MutableLiveData
+
+class CountedBooleanLiveData : MutableLiveData<Boolean>(false) {
+
+	private var counter = 0
+
+	override fun setValue(value: Boolean) {
+		if (value) {
+			counter++
+		} else {
+			counter--
+		}
+		val newValue = counter > 0
+		if (newValue != this.value) {
+			super.setValue(newValue)
+		}
+	}
+}

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

@@ -13,12 +13,12 @@ import android.graphics.drawable.shapes.RectShape
 import android.util.AttributeSet
 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
+import org.koitharu.kotatsu.utils.ext.getThemeColorStateList
 
 @SuppressLint("RestrictedApi")
 class ListItemTextView @JvmOverloads constructor(
@@ -119,8 +119,7 @@ class ListItemTextView @JvmOverloads constructor(
 	}
 
 	private fun getRippleColorFallback(context: Context): ColorStateList {
-		return context.obtainStyledAttributes(intArrayOf(android.R.attr.colorControlHighlight)).use {
-			it.getColorStateList(0)
-		} ?: ColorStateList.valueOf(Color.TRANSPARENT)
+		return context.getThemeColorStateList(android.R.attr.colorControlHighlight)
+			?: ColorStateList.valueOf(Color.TRANSPARENT)
 	}
 }

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

@@ -0,0 +1,72 @@
+package org.koitharu.kotatsu.base.ui.widgets
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.util.AttributeSet
+import android.view.Gravity
+import android.view.View
+import android.view.WindowInsets
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import androidx.annotation.AttrRes
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.view.WindowInsetsCompat
+
+class WindowInsetHolder @JvmOverloads constructor(
+	context: Context,
+	attrs: AttributeSet? = null,
+	@AttrRes defStyleAttr: Int = 0,
+) : View(context, attrs, defStyleAttr) {
+
+	private var desiredHeight = 0
+	private var desiredWidth = 0
+
+	@SuppressLint("RtlHardcoded")
+	override fun dispatchApplyWindowInsets(insets: WindowInsets): WindowInsets {
+		val barsInsets = WindowInsetsCompat.toWindowInsetsCompat(insets, this)
+			.getInsets(WindowInsetsCompat.Type.systemBars())
+		val gravity = getLayoutGravity()
+		val newWidth = when (gravity and Gravity.HORIZONTAL_GRAVITY_MASK) {
+			Gravity.LEFT -> barsInsets.left
+			Gravity.RIGHT -> barsInsets.right
+			else -> 0
+		}
+		val newHeight = when (gravity and Gravity.VERTICAL_GRAVITY_MASK) {
+			Gravity.TOP -> barsInsets.top
+			Gravity.BOTTOM -> barsInsets.bottom
+			else -> 0
+		}
+		if (newWidth != desiredWidth || newHeight != desiredHeight) {
+			desiredWidth = newWidth
+			desiredHeight = newHeight
+			requestLayout()
+		}
+		return super.dispatchApplyWindowInsets(insets)
+	}
+
+	override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+		val widthMode = MeasureSpec.getMode(widthMeasureSpec)
+		val heightMode = MeasureSpec.getMode(heightMeasureSpec)
+		super.onMeasure(
+			if (desiredWidth == 0 || widthMode == MeasureSpec.EXACTLY) {
+				widthMeasureSpec
+			} else {
+				MeasureSpec.makeMeasureSpec(desiredWidth, widthMode)
+			},
+			if (desiredHeight == 0 || heightMode == MeasureSpec.EXACTLY) {
+				heightMeasureSpec
+			} else {
+				MeasureSpec.makeMeasureSpec(desiredHeight, heightMode)
+			},
+		)
+	}
+
+	private fun getLayoutGravity(): Int {
+		return when (val lp = layoutParams) {
+			is FrameLayout.LayoutParams -> lp.gravity
+			is LinearLayout.LayoutParams -> lp.gravity
+			is CoordinatorLayout.LayoutParams -> lp.gravity
+			else -> Gravity.NO_GRAVITY
+		}
+	}
+}

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

@@ -11,10 +11,11 @@ import android.view.MenuItem
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
+import com.google.android.material.R as materialR
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseActivity
+import org.koitharu.kotatsu.core.network.UserAgentInterceptor
 import org.koitharu.kotatsu.databinding.ActivityBrowserBinding
-import com.google.android.material.R as materialR
 
 @SuppressLint("SetJavaScriptEnabled")
 class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback {
@@ -28,6 +29,7 @@ class BrowserActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback
 		}
 		with(binding.webView.settings) {
 			javaScriptEnabled = true
+			userAgentString = UserAgentInterceptor.userAgent
 		}
 		binding.webView.webViewClient = BrowserClient(this)
 		binding.webView.webChromeClient = ProgressChromeClient(binding.progressBar)

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

@@ -2,15 +2,11 @@ package org.koitharu.kotatsu.browser
 
 import android.graphics.Bitmap
 import android.webkit.WebView
-import okhttp3.OkHttpClient
 import org.koin.core.component.KoinComponent
-import org.koin.core.component.inject
 import org.koitharu.kotatsu.core.network.WebViewClientCompat
 
 class BrowserClient(private val callback: BrowserCallback) : WebViewClientCompat(), KoinComponent {
 
-	private val okHttp by inject<OkHttpClient>(mode = LazyThreadSafetyMode.SYNCHRONIZED)
-
 	override fun onPageFinished(webView: WebView, url: String) {
 		super.onPageFinished(webView, url)
 		callback.onLoadingStateChanged(isLoading = false)

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

@@ -1,51 +0,0 @@
-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
-import org.json.JSONArray
-import org.koitharu.kotatsu.R
-import org.koitharu.kotatsu.utils.MutableZipFile
-import org.koitharu.kotatsu.utils.ext.format
-
-class BackupArchive(file: File) : MutableZipFile(file) {
-
-	init {
-		if (!dir.exists()) {
-			dir.mkdirs()
-		}
-	}
-
-	suspend fun put(entry: BackupEntry) {
-		put(entry.name, entry.data.toString(2))
-	}
-
-	suspend fun getEntry(name: String): BackupEntry {
-		val json = withContext(Dispatchers.Default) {
-			JSONArray(getContent(name))
-		}
-		return BackupEntry(name, json)
-	}
-
-	companion object {
-
-		private const val DIR_BACKUPS = "backups"
-
-		suspend fun createNew(context: Context): BackupArchive = runInterruptible(Dispatchers.IO) {
-			val dir = context.run {
-				getExternalFilesDir(DIR_BACKUPS) ?: File(filesDir, DIR_BACKUPS)
-			}
-			dir.mkdirs()
-			val filename = buildString {
-				append(context.getString(R.string.app_name).lowercase(Locale.ROOT))
-				append('_')
-				append(Date().format("ddMMyyyy"))
-				append(".bak")
-			}
-			BackupArchive(File(dir, filename))
-		}
-	}
-}

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

@@ -0,0 +1,25 @@
+package org.koitharu.kotatsu.core.backup
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+import okio.Closeable
+import org.json.JSONArray
+import java.io.File
+import java.util.zip.ZipFile
+
+class BackupZipInput(val file: File) : Closeable {
+
+	private val zipFile = ZipFile(file)
+
+	suspend fun getEntry(name: String): BackupEntry = runInterruptible(Dispatchers.IO) {
+		val entry = zipFile.getEntry(name)
+		val json = zipFile.getInputStream(entry).use {
+			JSONArray(it.bufferedReader().readText())
+		}
+		BackupEntry(name, json)
+	}
+
+	override fun close() {
+		zipFile.close()
+	}
+}

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

@@ -0,0 +1,45 @@
+package org.koitharu.kotatsu.core.backup
+
+import android.content.Context
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+import okio.Closeable
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.zip.ZipOutput
+import org.koitharu.kotatsu.utils.ext.format
+import java.io.File
+import java.util.*
+import java.util.zip.Deflater
+
+class BackupZipOutput(val file: File) : Closeable {
+
+	private val output = ZipOutput(file, Deflater.BEST_COMPRESSION)
+
+	suspend fun put(entry: BackupEntry) {
+		output.put(entry.name, entry.data.toString(2))
+	}
+
+	suspend fun finish() {
+		output.finish()
+	}
+
+	override fun close() {
+		output.close()
+	}
+}
+
+private const val DIR_BACKUPS = "backups"
+
+suspend fun BackupZipOutput(context: Context): BackupZipOutput = runInterruptible(Dispatchers.IO) {
+	val dir = context.run {
+		getExternalFilesDir(DIR_BACKUPS) ?: File(filesDir, DIR_BACKUPS)
+	}
+	dir.mkdirs()
+	val filename = buildString {
+		append(context.getString(R.string.app_name).replace(' ', '_').lowercase(Locale.ROOT))
+		append('_')
+		append(Date().format("ddMMyyyy"))
+		append(".bk.zip")
+	}
+	BackupZipOutput(File(dir, filename))
+}

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

@@ -3,26 +3,4 @@ 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/ParcelableManga.kt

@@ -10,13 +10,18 @@ private const val MAX_SAFE_CHAPTERS_COUNT = 40 // this is 100% safe
 
 class ParcelableManga(
 	val manga: Manga,
+	private val withChapters: Boolean,
 ) : Parcelable {
 
-	constructor(parcel: Parcel) : this(parcel.readManga())
+	constructor(parcel: Parcel) : this(parcel.readManga(), true)
 
 	override fun writeToParcel(parcel: Parcel, flags: Int) {
 		val chapters = manga.chapters
-		if (chapters == null || chapters.size <= MAX_SAFE_CHAPTERS_COUNT) {
+		if (!withChapters || chapters == null) {
+			manga.writeToParcel(parcel, flags, withChapters = false)
+			return
+		}
+		if (chapters.size <= MAX_SAFE_CHAPTERS_COUNT) {
 			// fast path
 			manga.writeToParcel(parcel, flags, withChapters = true)
 			return

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

@@ -1,10 +1,10 @@
 package org.koitharu.kotatsu.core.network
 
 import android.os.Build
+import java.util.*
 import okhttp3.Interceptor
 import okhttp3.Response
 import org.koitharu.kotatsu.BuildConfig
-import java.util.*
 
 class UserAgentInterceptor : Interceptor {
 
@@ -30,5 +30,14 @@ class UserAgentInterceptor : Interceptor {
 				Build.DEVICE,
 				Locale.getDefault().language
 			)
+
+		val userAgentChrome
+			get() = (
+				"Mozilla/5.0 (Linux; Android %s; %s) AppleWebKit/537.36 (KHTML, like Gecko) " +
+					"Chrome/100.0.4896.127 Mobile Safari/537.36"
+				).format(
+				Build.VERSION.RELEASE,
+				Build.MODEL,
+			)
 	}
 }

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

@@ -1,5 +1,7 @@
 package org.koitharu.kotatsu.core.parser
 
+import java.lang.ref.WeakReference
+import java.util.*
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.get
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
@@ -28,11 +30,18 @@ interface MangaRepository {
 
 	companion object : KoinComponent {
 
+		private val cache = EnumMap<MangaSource, WeakReference<RemoteMangaRepository>>(MangaSource::class.java)
+
 		operator fun invoke(source: MangaSource): MangaRepository {
-			return if (source == MangaSource.LOCAL) {
-				get<LocalMangaRepository>()
-			} else {
-				RemoteMangaRepository(source, get())
+			if (source == MangaSource.LOCAL) {
+				return get<LocalMangaRepository>()
+			}
+			cache[source]?.get()?.let { return it }
+			return synchronized(cache) {
+				cache[source]?.get()?.let { return it }
+				val repository = RemoteMangaRepository(MangaParser(source, get()))
+				cache[source] = WeakReference(repository)
+				repository
 			}
 		}
 	}

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

@@ -1,19 +1,15 @@
 package org.koitharu.kotatsu.core.parser
 
 import org.koitharu.kotatsu.core.prefs.SourceSettings
-import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaParser
 import org.koitharu.kotatsu.parsers.MangaParserAuthProvider
 import org.koitharu.kotatsu.parsers.config.ConfigKey
 import org.koitharu.kotatsu.parsers.model.*
-import org.koitharu.kotatsu.parsers.newParser
 
-class RemoteMangaRepository(
-	override val source: MangaSource,
-	loaderContext: MangaLoaderContext,
-) : MangaRepository {
+class RemoteMangaRepository(private val parser: MangaParser) : MangaRepository {
 
-	private val parser: MangaParser = source.newParser(loaderContext)
+	override val source: MangaSource
+		get() = parser.source
 
 	override val sortOrders: Set<SortOrder>
 		get() = parser.sortOrders
@@ -28,7 +24,7 @@ class RemoteMangaRepository(
 		offset: Int,
 		query: String?,
 		tags: Set<MangaTag>?,
-		sortOrder: SortOrder?
+		sortOrder: SortOrder?,
 	): List<Manga> = parser.getList(offset, query, tags, sortOrder)
 
 	override suspend fun getDetails(manga: Manga): Manga = parser.getDetails(manga)
@@ -48,4 +44,4 @@ class RemoteMangaRepository(
 	}
 
 	private fun getConfig() = parser.config as SourceSettings
-}
+}

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

@@ -11,23 +11,34 @@ import androidx.collection.arraySetOf
 import androidx.core.content.edit
 import androidx.preference.PreferenceManager
 import com.google.android.material.color.DynamicColors
+import java.io.File
+import java.text.DateFormat
+import java.text.SimpleDateFormat
+import java.util.*
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.channels.trySendBlocking
 import kotlinx.coroutines.flow.callbackFlow
+import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.core.model.ZoomMode
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.utils.ext.getEnumValue
 import org.koitharu.kotatsu.utils.ext.putEnumValue
 import org.koitharu.kotatsu.utils.ext.toUriOrNull
-import java.io.File
-import java.text.DateFormat
-import java.text.SimpleDateFormat
-import java.util.*
 
 class AppSettings(context: Context) {
 
 	private val prefs = PreferenceManager.getDefaultSharedPreferences(context)
 
+	private val remoteSources = EnumSet.allOf(MangaSource::class.java).apply {
+		remove(MangaSource.LOCAL)
+		if (!BuildConfig.DEBUG) {
+			remove(MangaSource.DUMMY)
+		}
+	}
+
+	val remoteMangaSources: Set<MangaSource>
+		get() = Collections.unmodifiableSet(remoteSources)
+
 	var listMode: ListMode
 		get() = prefs.getEnumValue(KEY_LIST_MODE, ListMode.DETAILED_LIST)
 		set(value) = prefs.edit { putEnumValue(KEY_LIST_MODE, value) }
@@ -104,10 +115,9 @@ class AppSettings(context: Context) {
 		get() = prefs.getString(KEY_APP_PASSWORD, null)
 		set(value) = prefs.edit { if (value != null) putString(KEY_APP_PASSWORD, value) else remove(KEY_APP_PASSWORD) }
 
-	var sourcesOrder: List<Int>
+	var sourcesOrder: List<String>
 		get() = prefs.getString(KEY_SOURCES_ORDER, null)
 			?.split('|')
-			?.mapNotNull(String::toIntOrNull)
 			.orEmpty()
 		set(value) = prefs.edit {
 			putString(KEY_SOURCES_ORDER, value.joinToString("|"))
@@ -141,6 +151,12 @@ class AppSettings(context: Context) {
 			}
 		}
 
+	val isDownloadsSlowdownEnabled: Boolean
+		get() = prefs.getBoolean(KEY_DOWNLOADS_SLOWDOWN, false)
+
+	val downloadsParallelism: Int
+		get() = prefs.getInt(KEY_DOWNLOADS_PARALLELISM, 2)
+
 	val isSuggestionsEnabled: Boolean
 		get() = prefs.getBoolean(KEY_SUGGESTIONS, false)
 
@@ -178,11 +194,10 @@ class AppSettings(context: Context) {
 	}
 
 	fun getMangaSources(includeHidden: Boolean): List<MangaSource> {
-		val list = MangaSource.values().toMutableList()
-		list.remove(MangaSource.LOCAL)
+		val list = remoteSources.toMutableList()
 		val order = sourcesOrder
 		list.sortBy { x ->
-			val e = order.indexOf(x.ordinal)
+			val e = order.indexOf(x.name)
 			if (e == -1) order.size + x.ordinal else e
 		}
 		if (!includeHidden) {
@@ -224,7 +239,7 @@ class AppSettings(context: Context) {
 		const val KEY_DYNAMIC_THEME = "dynamic_theme"
 		const val KEY_THEME_AMOLED = "amoled_theme"
 		const val KEY_DATE_FORMAT = "date_format"
-		const val KEY_SOURCES_ORDER = "sources_order"
+		const val KEY_SOURCES_ORDER = "sources_order_2"
 		const val KEY_SOURCES_HIDDEN = "sources_hidden"
 		const val KEY_TRAFFIC_WARNING = "traffic_warning"
 		const val KEY_PAGES_CACHE_CLEAR = "pages_cache_clear"
@@ -261,6 +276,8 @@ class AppSettings(context: Context) {
 		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"
+		const val KEY_DOWNLOADS_PARALLELISM = "downloads_parallelism"
+		const val KEY_DOWNLOADS_SLOWDOWN = "downloads_slowdown"
 
 		// About
 		const val KEY_APP_UPDATE = "app_update"
@@ -281,4 +298,4 @@ class AppSettings(context: Context) {
 		private val isSamsung
 			get() = Build.MANUFACTURER.equals("samsung", ignoreCase = true)
 	}
-}
+}

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

@@ -3,6 +3,9 @@ package org.koitharu.kotatsu.core.ui
 import android.content.res.Resources
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.utils.ext.daysDiff
+import org.koitharu.kotatsu.utils.ext.format
+import java.util.*
 
 sealed class DateTimeAgo : ListModel {
 
@@ -72,9 +75,33 @@ sealed class DateTimeAgo : ListModel {
 		override fun hashCode(): Int = days
 	}
 
+	class Absolute(private val date: Date) : DateTimeAgo() {
+
+		private val day = date.daysDiff(0)
+
+		override fun format(resources: Resources): String {
+			return date.format("d MMMM")
+		}
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as Absolute
+
+			if (day != other.day) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			return day
+		}
+	}
+
 	object LongAgo : DateTimeAgo() {
 		override fun format(resources: Resources): String {
 			return resources.getString(R.string.long_ago)
 		}
 	}
-}
+}

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

@@ -0,0 +1,118 @@
+package org.koitharu.kotatsu.core.zip
+
+import androidx.annotation.WorkerThread
+import androidx.collection.ArraySet
+import okio.Closeable
+import java.io.File
+import java.io.FileInputStream
+import java.util.zip.Deflater
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+import java.util.zip.ZipOutputStream
+
+class ZipOutput(
+	val file: File,
+	compressionLevel: Int = Deflater.DEFAULT_COMPRESSION,
+) : Closeable {
+
+	private val entryNames = ArraySet<String>()
+	private var isClosed = false
+	private val output = ZipOutputStream(file.outputStream()).apply {
+		setLevel(compressionLevel)
+	}
+
+	@WorkerThread
+	fun put(name: String, file: File): Boolean {
+		return output.appendFile(file, name)
+	}
+
+	@WorkerThread
+	fun put(name: String, content: String): Boolean {
+		return output.appendText(content, name)
+	}
+
+	@WorkerThread
+	fun addDirectory(name: String): Boolean {
+		val entry = if (name.endsWith("/")) {
+			ZipEntry(name)
+		} else {
+			ZipEntry("$name/")
+		}
+		return if (entryNames.add(entry.name)) {
+			output.putNextEntry(entry)
+			output.closeEntry()
+			true
+		} else {
+			false
+		}
+	}
+
+	@WorkerThread
+	fun copyEntryFrom(other: ZipFile, entry: ZipEntry): Boolean {
+		return if (entryNames.add(entry.name)) {
+			val zipEntry = ZipEntry(entry.name)
+			output.putNextEntry(zipEntry)
+			other.getInputStream(entry).use { input ->
+				input.copyTo(output)
+			}
+			output.closeEntry()
+			true
+		} else {
+			false
+		}
+	}
+
+	fun finish() {
+		output.finish()
+		output.flush()
+	}
+
+	override fun close() {
+		if (!isClosed) {
+			output.close()
+			isClosed = true
+		}
+	}
+
+	@WorkerThread
+	private fun ZipOutputStream.appendFile(fileToZip: File, name: String): Boolean {
+		if (fileToZip.isDirectory) {
+			val entry = if (name.endsWith("/")) {
+				ZipEntry(name)
+			} else {
+				ZipEntry("$name/")
+			}
+			if (!entryNames.add(entry.name)) {
+				return false
+			}
+			putNextEntry(entry)
+			closeEntry()
+			fileToZip.listFiles()?.forEach { childFile ->
+				appendFile(childFile, "$name/${childFile.name}")
+			}
+		} else {
+			FileInputStream(fileToZip).use { fis ->
+				if (!entryNames.add(name)) {
+					return false
+				}
+				val zipEntry = ZipEntry(name)
+				putNextEntry(zipEntry)
+				fis.copyTo(this)
+				closeEntry()
+			}
+		}
+		return true
+	}
+
+	@WorkerThread
+	private fun ZipOutputStream.appendText(content: String, name: String): Boolean {
+		if (!entryNames.add(name)) {
+			return false
+		}
+		val zipEntry = ZipEntry(name)
+		putNextEntry(zipEntry)
+		content.byteInputStream().copyTo(this)
+		closeEntry()
+		return true
+	}
+}

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

@@ -9,9 +9,9 @@ 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 com.google.android.material.snackbar.Snackbar
 import org.koin.androidx.viewmodel.ext.android.sharedViewModel
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseFragment
@@ -22,6 +22,7 @@ import org.koitharu.kotatsu.details.ui.adapter.ChaptersAdapter
 import org.koitharu.kotatsu.details.ui.adapter.ChaptersSelectionDecoration
 import org.koitharu.kotatsu.details.ui.model.ChapterListItem
 import org.koitharu.kotatsu.download.ui.service.DownloadService
+import org.koitharu.kotatsu.local.ui.LocalChaptersRemoveService
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.reader.ui.ReaderActivity
 import org.koitharu.kotatsu.reader.ui.ReaderState
@@ -67,8 +68,8 @@ class ChaptersFragment :
 		viewModel.isChaptersReversed.observe(viewLifecycleOwner) {
 			activity?.invalidateOptionsMenu()
 		}
-		viewModel.hasChapters.observe(viewLifecycleOwner) {
-			binding.textViewHolder.isGone = it
+		viewModel.isChaptersEmpty.observe(viewLifecycleOwner) {
+			binding.textViewHolder.isVisible = it
 			activity?.invalidateOptionsMenu()
 		}
 	}
@@ -94,7 +95,7 @@ class ChaptersFragment :
 	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
+		menu.findItem(R.id.action_search).isVisible = viewModel.isChaptersEmpty.value == false
 	}
 
 	override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
@@ -154,11 +155,29 @@ class ChaptersFragment :
 				DownloadService.start(
 					context ?: return false,
 					viewModel.getRemoteManga() ?: viewModel.manga.value ?: return false,
-					selectionDecoration?.checkedItemsIds
+					selectionDecoration?.checkedItemsIds?.toSet()
 				)
 				mode.finish()
 				true
 			}
+			R.id.action_delete -> {
+				val ids = selectionDecoration?.checkedItemsIds
+				val manga = viewModel.manga.value
+				when {
+					ids.isNullOrEmpty() || manga == null -> Unit
+					ids.size == manga.chapters?.size -> viewModel.deleteLocal()
+					else -> {
+						LocalChaptersRemoveService.start(requireContext(), manga, ids)
+						Snackbar.make(
+							binding.recyclerViewChapters,
+							R.string.chapters_will_removed_background,
+							Snackbar.LENGTH_LONG
+						).show()
+					}
+				}
+				mode.finish()
+				true
+			}
 			R.id.action_select_all -> {
 				val ids = chaptersAdapter?.items?.map { it.chapter.id } ?: return false
 				selectionDecoration?.checkAll(ids)
@@ -188,6 +207,9 @@ class ChaptersFragment :
 		menu.findItem(R.id.action_save).isVisible = items.none { x ->
 			x.chapter.source == MangaSource.LOCAL
 		}
+		menu.findItem(R.id.action_delete).isVisible = items.all { x ->
+			x.chapter.source == MangaSource.LOCAL
+		}
 		mode.title = items.size.toString()
 		return true
 	}

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

@@ -41,13 +41,16 @@ import org.koitharu.kotatsu.details.ui.adapter.BranchesAdapter
 import org.koitharu.kotatsu.download.ui.service.DownloadService
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.util.mapNotNullToSet
 import org.koitharu.kotatsu.reader.ui.ReaderActivity
 import org.koitharu.kotatsu.reader.ui.ReaderState
 import org.koitharu.kotatsu.search.ui.global.GlobalSearchActivity
 import org.koitharu.kotatsu.utils.ShareHelper
 import org.koitharu.kotatsu.utils.ext.getDisplayMessage
 
-class DetailsActivity : BaseActivity<ActivityDetailsBinding>(), TabLayoutMediator.TabConfigurationStrategy,
+class DetailsActivity :
+	BaseActivity<ActivityDetailsBinding>(),
+	TabLayoutMediator.TabConfigurationStrategy,
 	AdapterView.OnItemSelectedListener {
 
 	private val viewModel by viewModel<DetailsViewModel> {
@@ -171,38 +174,23 @@ class DetailsActivity : BaseActivity<ActivityDetailsBinding>(), TabLayoutMediato
 			true
 		}
 		R.id.action_delete -> {
-			viewModel.manga.value?.let { m ->
-				MaterialAlertDialogBuilder(this)
-					.setTitle(R.string.delete_manga)
-					.setMessage(getString(R.string.text_delete_local_manga, m.title))
-					.setPositiveButton(R.string.delete) { _, _ ->
-						viewModel.deleteLocal(m)
-					}
-					.setNegativeButton(android.R.string.cancel, null)
-					.show()
-			}
+			val title = viewModel.manga.value?.title.orEmpty()
+			MaterialAlertDialogBuilder(this)
+				.setTitle(R.string.delete_manga)
+				.setMessage(getString(R.string.text_delete_local_manga, title))
+				.setPositiveButton(R.string.delete) { _, _ ->
+					viewModel.deleteLocal()
+				}
+				.setNegativeButton(android.R.string.cancel, null)
+				.show()
 			true
 		}
 		R.id.action_save -> {
 			viewModel.manga.value?.let {
 				val chaptersCount = it.chapters?.size ?: 0
-				if (chaptersCount > 5) {
-					MaterialAlertDialogBuilder(this)
-						.setTitle(R.string.save_manga)
-						.setMessage(
-							getString(
-								R.string.large_manga_save_confirm,
-								resources.getQuantityString(
-									R.plurals.chapters,
-									chaptersCount,
-									chaptersCount
-								)
-							)
-						)
-						.setNegativeButton(android.R.string.cancel, null)
-						.setPositiveButton(R.string.save) { _, _ ->
-							DownloadService.start(this, it)
-						}.show()
+				val branches = viewModel.branches.value.orEmpty()
+				if (chaptersCount > 5 || branches.size > 1) {
+					showSaveConfirmation(it, chaptersCount, branches)
 				} else {
 					DownloadService.start(this, it)
 				}
@@ -262,7 +250,7 @@ class DetailsActivity : BaseActivity<ActivityDetailsBinding>(), TabLayoutMediato
 	fun showChapterMissingDialog(chapterId: Long) {
 		val remoteManga = viewModel.getRemoteManga()
 		if (remoteManga == null) {
-			binding.snackbar.show(getString( R.string.chapter_is_missing))
+			binding.snackbar.show(getString(R.string.chapter_is_missing))
 			return
 		}
 		MaterialAlertDialogBuilder(this).apply {
@@ -328,11 +316,41 @@ class DetailsActivity : BaseActivity<ActivityDetailsBinding>(), TabLayoutMediato
 		}
 	}
 
+	private fun showSaveConfirmation(manga: Manga, chaptersCount: Int, branches: List<String?>) {
+		val dialogBuilder = MaterialAlertDialogBuilder(this)
+			.setTitle(R.string.save_manga)
+			.setNegativeButton(android.R.string.cancel, null)
+		if (branches.size > 1) {
+			val items = Array(branches.size) { i -> branches[i].orEmpty() }
+			val currentBranch = viewModel.selectedBranchIndex.value ?: -1
+			val checkedIndices = BooleanArray(branches.size) { i -> i == currentBranch }
+			dialogBuilder.setMultiChoiceItems(items, checkedIndices) { _, i, checked ->
+				checkedIndices[i] = checked
+			}.setPositiveButton(R.string.save) { _, _ ->
+				val selectedBranches = branches.filterIndexedTo(HashSet()) { i, _ -> checkedIndices[i] }
+				val chaptersIds = manga.chapters?.mapNotNullToSet { c ->
+					if (c.branch in selectedBranches) c.id else null
+				}
+				DownloadService.start(this, manga, chaptersIds)
+			}
+		} else {
+			dialogBuilder.setMessage(
+				getString(
+					R.string.large_manga_save_confirm,
+					resources.getQuantityString(R.plurals.chapters, chaptersCount, chaptersCount)
+				)
+			).setPositiveButton(R.string.save) { _, _ ->
+				DownloadService.start(this, manga)
+			}
+		}
+		dialogBuilder.show()
+	}
+
 	companion object {
 
 		fun newIntent(context: Context, manga: Manga): Intent {
 			return Intent(context, DetailsActivity::class.java)
-				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga))
+				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga, withChapters = true))
 		}
 
 		fun newIntent(context: Context, mangaId: Long): Intent {
@@ -340,4 +358,4 @@ class DetailsActivity : BaseActivity<ActivityDetailsBinding>(), TabLayoutMediato
 				.putExtra(MangaIntent.KEY_ID, mangaId)
 		}
 	}
-}
+}

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

@@ -5,6 +5,7 @@ import android.os.Bundle
 import android.text.Spanned
 import android.text.method.LinkMovementMethod
 import android.view.*
+import androidx.appcompat.widget.PopupMenu
 import androidx.core.content.ContextCompat
 import androidx.core.graphics.Insets
 import androidx.core.net.toUri
@@ -224,14 +225,16 @@ class DetailsFragment :
 				if (viewModel.readingHistory.value == null) {
 					return false
 				}
-				v.showPopupMenu(R.menu.popup_read) {
-					when (it.itemId) {
+				val menu = PopupMenu(v.context, v)
+				menu.inflate(R.menu.popup_read)
+				menu.setOnMenuItemClickListener { menuItem ->
+					when (menuItem.itemId) {
 						R.id.action_read -> {
 							val branch = viewModel.selectedBranchValue
 							startActivity(
 								ReaderActivity.newIntent(
-									context = context ?: return@showPopupMenu false,
-									manga = viewModel.manga.value ?: return@showPopupMenu false,
+									context = context ?: return@setOnMenuItemClickListener false,
+									manga = viewModel.manga.value ?: return@setOnMenuItemClickListener false,
 									state = viewModel.chapters.value?.firstOrNull { c ->
 										c.chapter.branch == branch
 									}?.let { c ->
@@ -244,6 +247,7 @@ class DetailsFragment :
 						else -> false
 					}
 				}
+				menu.show()
 				return true
 			}
 			else -> return false

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

@@ -28,6 +28,7 @@ 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.asLiveDataDistinct
 import org.koitharu.kotatsu.utils.ext.iterator
 import java.io.IOException
 
@@ -88,18 +89,18 @@ class DetailsViewModel(
 
 	val branches = mangaData.map {
 		it?.chapters?.mapToSet { x -> x.branch }?.sortedBy { x -> x }.orEmpty()
-	}.asLiveData(viewModelScope.coroutineContext + Dispatchers.Default)
+	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
 
 	val selectedBranchIndex = combine(
 		branches.asFlow(),
 		selectedBranch
 	) { branches, selected ->
 		branches.indexOf(selected)
-	}.asLiveData(viewModelScope.coroutineContext + Dispatchers.Default)
+	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
 
-	val hasChapters = mangaData.map {
-		!(it?.chapters.isNullOrEmpty())
-	}.asLiveData(viewModelScope.coroutineContext + Dispatchers.Default)
+	val isChaptersEmpty = mangaData.mapNotNull { m ->
+		m?.run { chapters.isNullOrEmpty() }
+	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default, false)
 
 	val chapters = combine(
 		combine(
@@ -134,8 +135,11 @@ class DetailsViewModel(
 		loadingJob = doLoad()
 	}
 
-	fun deleteLocal(manga: Manga) {
+	fun deleteLocal() {
+		val m = mangaData.value ?: return
 		launchLoadingJob(Dispatchers.Default) {
+			val manga = if (m.source == MangaSource.LOCAL) m else localMangaRepository.findSavedManga(m)
+			checkNotNull(manga) { "Cannot find saved manga for ${m.title}" }
 			val original = localMangaRepository.getRemoteManga(manga)
 			localMangaRepository.delete(manga) || throw IOException("Unable to delete file")
 			runCatching {
@@ -191,7 +195,8 @@ class DetailsViewModel(
 		// find default branch
 		val hist = historyRepository.getOne(manga)
 		selectedBranch.value = if (hist != null) {
-			manga.chapters?.find { it.id == hist.chapterId }?.branch
+			val currentChapter = manga.chapters?.find { it.id == hist.chapterId }
+			if (currentChapter != null) currentChapter.branch else predictBranch(manga.chapters)
 		} else {
 			predictBranch(manga.chapters)
 		}
@@ -203,6 +208,8 @@ class DetailsViewModel(
 			} else {
 				localMangaRepository.findSavedManga(manga)
 			}
+		}.onFailure { error ->
+			if (BuildConfig.DEBUG) error.printStackTrace()
 		}.getOrNull()
 	}
 
@@ -249,10 +256,10 @@ class DetailsViewModel(
 		val dateFormat = settings.getDateFormat()
 		for (i in sourceChapters.indices) {
 			val chapter = sourceChapters[i]
+			val localChapter = chaptersMap.remove(chapter.id)
 			if (chapter.branch != branch) {
 				continue
 			}
-			val localChapter = chaptersMap.remove(chapter.id)
 			result += localChapter?.toListItem(
 				isCurrent = i == currentIndex,
 				isUnread = i > currentIndex,
@@ -271,15 +278,19 @@ class DetailsViewModel(
 		}
 		if (chaptersMap.isNotEmpty()) { // some chapters on device but not online source
 			result.ensureCapacity(result.size + chaptersMap.size)
-			chaptersMap.values.mapTo(result) {
-				it.toListItem(
-					isCurrent = false,
-					isUnread = true,
-					isNew = false,
-					isMissing = false,
-					isDownloaded = false,
-					dateFormat = dateFormat,
-				)
+			chaptersMap.values.mapNotNullTo(result) {
+				if (it.branch == branch) {
+					it.toListItem(
+						isCurrent = false,
+						isUnread = true,
+						isNew = false,
+						isMissing = false,
+						isDownloaded = false,
+						dateFormat = dateFormat,
+					)
+				} else {
+					null
+				}
 			}
 			result.sortBy { it.chapter.number }
 		}

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

@@ -40,11 +40,10 @@ class ChapterListItem(
 	override fun hashCode(): Int {
 		var result = chapter.hashCode()
 		result = 31 * result + flags
-		result = 31 * result + uploadDate.hashCode()
+		result = 31 * result + (uploadDate?.hashCode() ?: 0)
 		return result
 	}
 
-
 	companion object {
 
 		const val FLAG_UNREAD = 2

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

@@ -17,10 +17,12 @@ import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.network.CommonHeaders
 import org.koitharu.kotatsu.core.parser.MangaRepository
-import org.koitharu.kotatsu.local.data.MangaZip
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.local.data.PagesCache
+import org.koitharu.kotatsu.local.domain.CbzMangaOutput
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.util.await
 import org.koitharu.kotatsu.utils.ext.deleteAwait
 import org.koitharu.kotatsu.utils.ext.referer
@@ -29,9 +31,8 @@ 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"
+private const val SLOWDOWN_DELAY = 200L
 
 class DownloadManager(
 	private val coroutineScope: CoroutineScope,
@@ -40,9 +41,10 @@ class DownloadManager(
 	private val okHttp: OkHttpClient,
 	private val cache: PagesCache,
 	private val localMangaRepository: LocalMangaRepository,
+	private val settings: AppSettings,
 ) {
 
-	private val connectivityManager = context.applicationContext.getSystemService(
+	private val connectivityManager = context.getSystemService(
 		Context.CONNECTIVITY_SERVICE
 	) as ConnectivityManager
 	private val coverWidth = context.resources.getDimensionPixelSize(
@@ -51,34 +53,40 @@ 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)
+	private val semaphore = Semaphore(settings.downloadsParallelism)
 
 	fun downloadManga(
 		manga: Manga,
-		chaptersIds: Set<Long>?,
+		chaptersIds: LongArray?,
 		startId: Int,
 	): ProgressJob<DownloadState> {
 		val stateFlow = MutableStateFlow<DownloadState>(
 			DownloadState.Queued(startId = startId, manga = manga, cover = null)
 		)
-		val job = downloadMangaImpl(manga, chaptersIds, stateFlow, startId)
+		val job = downloadMangaImpl(manga, chaptersIds?.takeUnless { it.isEmpty() }, stateFlow, startId)
 		return ProgressJob(job, stateFlow)
 	}
 
 	private fun downloadMangaImpl(
 		manga: Manga,
-		chaptersIds: Set<Long>?,
+		chaptersIds: LongArray?,
 		outState: MutableStateFlow<DownloadState>,
 		startId: Int,
 	): Job = coroutineScope.launch(Dispatchers.Default + errorStateHandler(outState)) {
+		@Suppress("NAME_SHADOWING") var manga = manga
+		val chaptersIdsSet = chaptersIds?.toMutableSet()
 		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) }
-		var output: MangaZip? = null
+		val tempFileName = "${manga.id}_$startId.tmp"
+		var output: CbzMangaOutput? = null
 		try {
+			if (manga.source == MangaSource.LOCAL) {
+				manga = localMangaRepository.getRemoteManga(manga) ?: error("Cannot obtain remote manga instance")
+			}
 			val repo = MangaRepository(manga.source)
 			cover = runCatching {
 				imageLoader.execute(
@@ -91,58 +99,71 @@ class DownloadManager(
 				).drawable
 			}.getOrNull()
 			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)
+			val data = if (manga.chapters.isNullOrEmpty()) repo.getDetails(manga) else manga
+			output = CbzMangaOutput.get(destination, data)
 			val coverUrl = data.largeCoverUrl ?: data.coverUrl
-			downloadFile(coverUrl, data.publicUrl, destination).let { file ->
+			downloadFile(coverUrl, data.publicUrl, destination, tempFileName).let { file ->
 				output.addCover(file, MimeTypeMap.getFileExtensionFromUrl(coverUrl))
 			}
-			val chapters = if (chaptersIds == null) {
-				data.chapters.orEmpty()
-			} else {
-				data.chapters.orEmpty().filter { x -> x.id in chaptersIds }
+			val chapters = checkNotNull(
+				if (chaptersIdsSet == null) {
+					data.chapters
+				} else {
+					data.chapters?.filter { x -> chaptersIdsSet.remove(x.id) }
+				}
+			) { "Chapters list must not be null" }
+			check(chapters.isNotEmpty()) { "Chapters list must not be empty" }
+			check(chaptersIdsSet.isNullOrEmpty()) {
+				"${chaptersIdsSet?.size} of ${chaptersIds?.size} requested chapters not found in manga"
 			}
 			for ((chapterIndex, chapter) in chapters.withIndex()) {
-				if (chaptersIds == null || chapter.id in chaptersIds) {
-					val pages = repo.getPages(chapter)
-					for ((pageIndex, page) in pages.withIndex()) {
-						failsafe@ do {
-							try {
-								val url = repo.getPageUrl(page)
-								val file =
-									cache[url] ?: downloadFile(url, page.referer, destination)
-								output.addPage(
-									chapter,
-									file,
-									pageIndex,
-									MimeTypeMap.getFileExtensionFromUrl(url)
-								)
-							} catch (e: IOException) {
+				val pages = repo.getPages(chapter)
+				for ((pageIndex, page) in pages.withIndex()) {
+					var retryCounter = 0
+					failsafe@ while (true) {
+						try {
+							val url = repo.getPageUrl(page)
+							val file = cache[url] ?: downloadFile(url, page.referer, destination, tempFileName)
+							output.addPage(
+								chapter = chapter,
+								file = file,
+								pageNumber = pageIndex,
+								ext = MimeTypeMap.getFileExtensionFromUrl(url),
+							)
+							break@failsafe
+						} catch (e: IOException) {
+							if (retryCounter < MAX_DOWNLOAD_ATTEMPTS) {
 								outState.value = DownloadState.WaitingForNetwork(startId, data, cover)
+								delay(DOWNLOAD_ERROR_DELAY)
 								connectivityManager.waitForNetwork()
-								continue@failsafe
+								retryCounter++
+							} else {
+								throw e
 							}
-						} while (false)
+						}
+					}
 
-						outState.value = DownloadState.Progress(
-							startId, data, cover,
-							totalChapters = chapters.size,
-							currentChapter = chapterIndex,
-							totalPages = pages.size,
-							currentPage = pageIndex,
-						)
+					outState.value = DownloadState.Progress(
+						startId, data, cover,
+						totalChapters = chapters.size,
+						currentChapter = chapterIndex,
+						totalPages = pages.size,
+						currentPage = pageIndex,
+					)
+
+					if (settings.isDownloadsSlowdownEnabled) {
+						delay(SLOWDOWN_DELAY)
 					}
 				}
 			}
 			outState.value = DownloadState.PostProcessing(startId, data, cover)
-			if (!output.compress()) {
-				throw RuntimeException("Cannot create target file")
-			}
+			output.mergeWithExisting()
+			output.finalize()
 			val localManga = localMangaRepository.getFromFile(output.file)
 			outState.value = DownloadState.Done(startId, data, cover, localManga)
-		} catch (_: CancellationException) {
+		} catch (e: CancellationException) {
 			outState.value = DownloadState.Cancelled(startId, manga, cover)
+			throw e
 		} catch (e: Throwable) {
 			if (BuildConfig.DEBUG) {
 				e.printStackTrace()
@@ -151,14 +172,14 @@ class DownloadManager(
 		} finally {
 			withContext(NonCancellable) {
 				output?.cleanup()
-				File(destination, TEMP_PAGE_FILE).deleteAwait()
+				File(destination, tempFileName).deleteAwait()
 			}
 			coroutineContext[WakeLockNode]?.release()
 			semaphore.release()
 		}
 	}
 
-	private suspend fun downloadFile(url: String, referer: String, destination: File): File {
+	private suspend fun downloadFile(url: String, referer: String, destination: File, tempFileName: String): File {
 		val request = Request.Builder()
 			.url(url)
 			.header(CommonHeaders.REFERER, referer)
@@ -166,35 +187,44 @@ class DownloadManager(
 			.get()
 			.build()
 		val call = okHttp.newCall(request)
-		var attempts = MAX_DOWNLOAD_ATTEMPTS
-		val file = File(destination, TEMP_PAGE_FILE)
-		while (true) {
-			try {
-				val response = call.clone().await()
-				runInterruptible(Dispatchers.IO) {
-					file.outputStream().use { out ->
-						checkNotNull(response.body).byteStream().copyTo(out)
-					}
-				}
-				return file
-			} catch (e: IOException) {
-				attempts--
-				if (attempts <= 0) {
-					throw e
-				} else {
-					delay(DOWNLOAD_ERROR_DELAY)
-				}
+		val file = File(destination, tempFileName)
+		val response = call.clone().await()
+		runInterruptible(Dispatchers.IO) {
+			file.outputStream().use { out ->
+				checkNotNull(response.body).byteStream().copyTo(out)
 			}
 		}
+		return file
 	}
 
-	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,
+	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,
+			)
+		}
+
+	class Factory(
+		private val context: Context,
+		private val imageLoader: ImageLoader,
+		private val okHttp: OkHttpClient,
+		private val cache: PagesCache,
+		private val localMangaRepository: LocalMangaRepository,
+		private val settings: AppSettings,
+	) {
+
+		fun create(coroutineScope: CoroutineScope) = DownloadManager(
+			coroutineScope = coroutineScope,
+			context = context,
+			imageLoader = imageLoader,
+			okHttp = okHttp,
+			cache = cache,
+			localMangaRepository = localMangaRepository,
+			settings = settings,
 		)
 	}
 }

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

@@ -6,6 +6,7 @@ import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
 import android.os.Build
+import android.text.format.DateUtils
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.ContextCompat
@@ -49,7 +50,7 @@ class DownloadNotification(private val context: Context, startId: Int) {
 		builder.setSilent(true)
 	}
 
-	fun create(state: DownloadState): Notification {
+	fun create(state: DownloadState, timeLeft: Long): Notification {
 		builder.setContentTitle(state.manga.title)
 		builder.setContentText(context.getString(R.string.manga_downloading_))
 		builder.setProgress(1, 0, true)
@@ -117,7 +118,13 @@ class DownloadNotification(private val context: Context, startId: Int) {
 			}
 			is DownloadState.Progress -> {
 				builder.setProgress(state.max, state.progress, false)
-				builder.setContentText((state.percent * 100).format() + "%")
+				if (timeLeft > 0L) {
+					val eta = DateUtils.getRelativeTimeSpanString(timeLeft, 0L, DateUtils.SECOND_IN_MILLIS)
+					builder.setContentText(eta)
+				} else {
+					val percent = (state.percent * 100).format()
+					builder.setContentText(context.getString(R.string.percent_string_pattern, percent))
+				}
 				builder.setCategory(NotificationCompat.CATEGORY_PROGRESS)
 				builder.setStyle(null)
 				builder.setOngoing(true)

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

@@ -11,10 +11,7 @@ import android.widget.Toast
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.lifecycleScope
 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.flow.transformWhile
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
 import org.koin.android.ext.android.get
@@ -24,7 +21,6 @@ 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
@@ -32,8 +28,8 @@ 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 org.koitharu.kotatsu.utils.progress.TimeLeftEstimator
 import java.util.concurrent.TimeUnit
 
 class DownloadService : BaseService() {
@@ -48,16 +44,12 @@ class DownloadService : BaseService() {
 
 	override fun onCreate() {
 		super.onCreate()
+		isRunning = true
 		notificationSwitcher = ForegroundNotificationSwitcher(this)
 		val wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager)
 			.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "kotatsu:downloading")
-		downloadManager = DownloadManager(
+		downloadManager = get<DownloadManager.Factory>().create(
 			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 +58,7 @@ class DownloadService : BaseService() {
 	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
 		super.onStartCommand(intent, flags, startId)
 		val manga = intent?.getParcelableExtra<ParcelableManga>(EXTRA_MANGA)?.manga
-		val chapters = intent?.getLongArrayExtra(EXTRA_CHAPTERS_IDS)?.toArraySet()
+		val chapters = intent?.getLongArrayExtra(EXTRA_CHAPTERS_IDS)
 		return if (manga != null) {
 			jobs[startId] = downloadManga(startId, manga, chapters)
 			jobCount.value = jobs.size
@@ -90,13 +82,14 @@ class DownloadService : BaseService() {
 	override fun onDestroy() {
 		unregisterReceiver(controlReceiver)
 		binder = null
+		isRunning = false
 		super.onDestroy()
 	}
 
 	private fun downloadManga(
 		startId: Int,
 		manga: Manga,
-		chaptersIds: Set<Long>?,
+		chaptersIds: LongArray?,
 	): ProgressJob<DownloadState> {
 		val job = downloadManager.downloadManga(manga, chaptersIds, startId)
 		listenJob(job)
@@ -106,19 +99,28 @@ class DownloadService : BaseService() {
 	private fun listenJob(job: ProgressJob<DownloadState>) {
 		lifecycleScope.launch {
 			val startId = job.progressValue.startId
+			val timeLeftEstimator = TimeLeftEstimator()
 			val notification = DownloadNotification(this@DownloadService, startId)
-			notificationSwitcher.notify(startId, notification.create(job.progressValue))
+			notificationSwitcher.notify(startId, notification.create(job.progressValue, -1L))
 			job.progressAsFlow()
+				.onEach { state ->
+					if (state is DownloadState.Progress) {
+						timeLeftEstimator.tick(value = state.progress, total = state.max)
+					} else {
+						timeLeftEstimator.emptyTick()
+					}
+				}
 				.throttle { state -> if (state is DownloadState.Progress) 400L else 0L }
 				.whileActive()
 				.collect { state ->
-					notificationSwitcher.notify(startId, notification.create(state))
+					val timeLeft = timeLeftEstimator.getEstimatedTimeLeft()
+					notificationSwitcher.notify(startId, notification.create(state, timeLeft))
 				}
 			job.join()
 			(job.progressValue as? DownloadState.Done)?.let {
 				sendBroadcast(
 					Intent(ACTION_DOWNLOAD_COMPLETE)
-						.putExtra(EXTRA_MANGA, ParcelableManga(it.localManga.withoutChapters()))
+						.putExtra(EXTRA_MANGA, ParcelableManga(it.localManga, withChapters = false))
 				)
 			}
 			notificationSwitcher.detach(
@@ -126,7 +128,7 @@ class DownloadService : BaseService() {
 				if (job.isCancelled) {
 					null
 				} else {
-					notification.create(job.progressValue)
+					notification.create(job.progressValue, -1L)
 				}
 			)
 			stopSelf(startId)
@@ -162,11 +164,12 @@ class DownloadService : BaseService() {
 
 	companion object {
 
-		const val ACTION_DOWNLOAD_COMPLETE =
-			"${BuildConfig.APPLICATION_ID}.action.ACTION_DOWNLOAD_COMPLETE"
+		var isRunning: Boolean = false
+			private set
 
-		private const val ACTION_DOWNLOAD_CANCEL =
-			"${BuildConfig.APPLICATION_ID}.action.ACTION_DOWNLOAD_CANCEL"
+		const val ACTION_DOWNLOAD_COMPLETE = "${BuildConfig.APPLICATION_ID}.action.ACTION_DOWNLOAD_COMPLETE"
+
+		private const val ACTION_DOWNLOAD_CANCEL = "${BuildConfig.APPLICATION_ID}.action.ACTION_DOWNLOAD_CANCEL"
 
 		private const val EXTRA_MANGA = "manga"
 		private const val EXTRA_CHAPTERS_IDS = "chapters_ids"
@@ -178,7 +181,7 @@ class DownloadService : BaseService() {
 			}
 			confirmDataTransfer(context) {
 				val intent = Intent(context, DownloadService::class.java)
-				intent.putExtra(EXTRA_MANGA, ParcelableManga(manga))
+				intent.putExtra(EXTRA_MANGA, ParcelableManga(manga, withChapters = false))
 				if (chaptersIds != null) {
 					intent.putExtra(EXTRA_CHAPTERS_IDS, chaptersIds.toLongArray())
 				}
@@ -194,7 +197,7 @@ class DownloadService : BaseService() {
 			confirmDataTransfer(context) {
 				for (item in manga) {
 					val intent = Intent(context, DownloadService::class.java)
-					intent.putExtra(EXTRA_MANGA, ParcelableManga(item))
+					intent.putExtra(EXTRA_MANGA, ParcelableManga(item, withChapters = false))
 					ContextCompat.startForegroundService(context, intent)
 				}
 			}

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

@@ -24,7 +24,7 @@ class ForegroundNotificationSwitcher(
 	@Synchronized
 	fun notify(startId: Int, notification: Notification) {
 		if (notifications.isEmpty()) {
-			StartForegroundRunnable(startId, notification)
+			service.startForeground(startId, notification)
 		} else {
 			notificationManager.notify(startId, notification)
 		}
@@ -46,16 +46,6 @@ class ForegroundNotificationSwitcher(
 		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?,

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

@@ -3,6 +3,7 @@ package org.koitharu.kotatsu.favourites.ui
 import android.os.Bundle
 import android.view.*
 import androidx.appcompat.view.ActionMode
+import androidx.appcompat.widget.PopupMenu
 import androidx.core.graphics.Insets
 import androidx.core.view.children
 import androidx.core.view.updateLayoutParams
@@ -10,7 +11,6 @@ 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
@@ -25,7 +25,8 @@ import org.koitharu.kotatsu.main.ui.AppBarOwner
 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 org.koitharu.kotatsu.utils.ext.resolveDp
+import java.util.*
 
 class FavouritesContainerFragment :
 	BaseFragment<FragmentFavouritesBinding>(),
@@ -85,7 +86,7 @@ class FavouritesContainerFragment :
 			top = headerHeight - insets.top
 		)
 		binding.pager.updatePadding(
-			top = -headerHeight
+			top = -headerHeight + resources.resolveDp(8) // 8 dp is needed so that the top of the list is not attached to tabs (visible when ActionMode is active)
 		)
 		binding.tabs.apply {
 			updatePadding(
@@ -123,22 +124,24 @@ class FavouritesContainerFragment :
 
 	override fun onTabLongClick(tabView: View, category: FavouriteCategory): Boolean {
 		val menuRes = if (category.id == 0L) R.menu.popup_category_empty else R.menu.popup_category
-		tabView.showPopupMenu(menuRes, { menu ->
-			createOrderSubmenu(menu, category)
-		}) {
+		val menu = PopupMenu(tabView.context, tabView)
+		menu.inflate(menuRes)
+		createOrderSubmenu(menu.menu, category)
+		menu.setOnMenuItemClickListener {
 			when (it.itemId) {
 				R.id.action_remove -> editDelegate.deleteCategory(category)
 				R.id.action_rename -> editDelegate.renameCategory(category)
 				R.id.action_create -> editDelegate.createCategory()
-				R.id.action_order -> return@showPopupMenu false
+				R.id.action_order -> return@setOnMenuItemClickListener false
 				else -> {
 					val order = CategoriesActivity.SORT_ORDERS.getOrNull(it.order)
-						?: return@showPopupMenu false
+						?: return@setOnMenuItemClickListener false
 					viewModel.setCategoryOrder(category.id, order)
 				}
 			}
 			true
 		}
+		menu.show()
 		return true
 	}
 

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

@@ -6,6 +6,7 @@ import android.os.Bundle
 import android.view.Menu
 import android.view.View
 import android.view.ViewGroup
+import androidx.appcompat.widget.PopupMenu
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.core.view.updateLayoutParams
@@ -23,11 +24,12 @@ import org.koitharu.kotatsu.databinding.ActivityCategoriesBinding
 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
 
-class CategoriesActivity : BaseActivity<ActivityCategoriesBinding>(),
+class CategoriesActivity :
+	BaseActivity<ActivityCategoriesBinding>(),
 	OnListItemClickListener<FavouriteCategory>,
-	View.OnClickListener, CategoriesEditDelegate.CategoriesEditCallback {
+	View.OnClickListener,
+	CategoriesEditDelegate.CategoriesEditCallback {
 
 	private val viewModel by viewModel<FavouritesCategoriesViewModel>()
 
@@ -58,26 +60,27 @@ class CategoriesActivity : BaseActivity<ActivityCategoriesBinding>(),
 	}
 
 	override fun onItemClick(item: FavouriteCategory, view: View) {
-		view.showPopupMenu(R.menu.popup_category, { menu ->
-			createOrderSubmenu(menu, item)
-		}) {
-			when (it.itemId) {
+		val menu = PopupMenu(view.context, view)
+		menu.inflate(R.menu.popup_category)
+		createOrderSubmenu(menu.menu, item)
+		menu.setOnMenuItemClickListener { menuItem ->
+			when (menuItem.itemId) {
 				R.id.action_remove -> editDelegate.deleteCategory(item)
 				R.id.action_rename -> editDelegate.renameCategory(item)
-				R.id.action_order -> return@showPopupMenu false
+				R.id.action_order -> return@setOnMenuItemClickListener false
 				else -> {
-					val order = SORT_ORDERS.getOrNull(it.order) ?: return@showPopupMenu false
+					val order = SORT_ORDERS.getOrNull(menuItem.order) ?: return@setOnMenuItemClickListener false
 					viewModel.setCategoryOrder(item.id, order)
 				}
 			}
 			true
 		}
+		menu.show()
 	}
 
 	override fun onItemLongClick(item: FavouriteCategory, view: View): Boolean {
-		reorderHelper.startDrag(
-			binding.recyclerView.findContainingViewHolder(view) ?: return false
-		)
+		val viewHolder = binding.recyclerView.findContainingViewHolder(view) ?: return false
+		reorderHelper.startDrag(viewHolder)
 		return true
 	}
 
@@ -90,7 +93,7 @@ class CategoriesActivity : BaseActivity<ActivityCategoriesBinding>(),
 		binding.recyclerView.updatePadding(
 			left = insets.left,
 			right = insets.right,
-			bottom = 2 * insets.bottom + binding.fabAdd.measureHeight()
+			bottom = 2 * insets.bottom + binding.fabAdd.measureHeight(),
 		)
 	}
 

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

@@ -15,7 +15,6 @@ 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
@@ -99,7 +98,7 @@ class FavouriteCategoriesDialog :
 		fun show(fm: FragmentManager, manga: Collection<Manga>) = FavouriteCategoriesDialog().withArgs(1) {
 			putParcelableArrayList(
 				KEY_MANGA_LIST,
-				manga.mapTo(ArrayList(manga.size)) { ParcelableManga(it.withoutChapters()) }
+				manga.mapTo(ArrayList(manga.size)) { ParcelableManga(it, withChapters = false) }
 			)
 		}.show(fm, TAG)
 	}

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

@@ -7,6 +7,7 @@ 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.MangaSource
 import org.koitharu.kotatsu.utils.ext.withArgs
 
 class FavouritesListFragment : MangaListFragment() {
@@ -27,6 +28,13 @@ class FavouritesListFragment : MangaListFragment() {
 		return super.onCreateActionMode(mode, menu)
 	}
 
+	override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
+		menu.findItem(R.id.action_save)?.isVisible = selectedItems.none {
+			it.source == MangaSource.LOCAL
+		}
+		return super.onPrepareActionMode(mode, menu)
+	}
+
 	override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
 		return when (item.itemId) {
 			R.id.action_remove -> {

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

@@ -10,6 +10,7 @@ import com.google.android.material.dialog.MaterialAlertDialogBuilder
 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.MangaSource
 
 class HistoryListFragment : MangaListFragment() {
 
@@ -61,6 +62,13 @@ class HistoryListFragment : MangaListFragment() {
 		return super.onCreateActionMode(mode, menu)
 	}
 
+	override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
+		menu.findItem(R.id.action_save)?.isVisible = selectedItems.none {
+			it.source == MangaSource.LOCAL
+		}
+		return super.onPrepareActionMode(mode, menu)
+	}
+
 	override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
 		return when (item.itemId) {
 			R.id.action_remove -> {

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

@@ -43,7 +43,7 @@ class ListModeSelectDialog : AlertDialogFragment<DialogListModeBinding>(),
 		binding.textViewGridTitle.isVisible = mode == ListMode.GRID
 		binding.sliderGrid.isVisible = mode == ListMode.GRID
 
-		binding.sliderGrid.setLabelFormatter(IntPercentLabelFormatter())
+		binding.sliderGrid.setLabelFormatter(IntPercentLabelFormatter(view.context))
 		binding.sliderGrid.setValueRounded(settings.gridSize.toFloat())
 		binding.sliderGrid.addOnSliderTouchListener(this)
 

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

@@ -20,6 +20,7 @@ import org.koitharu.kotatsu.base.ui.list.FitHeightGridLayoutManager
 import org.koitharu.kotatsu.base.ui.list.FitHeightLinearLayoutManager
 import org.koitharu.kotatsu.base.ui.list.PaginationScrollListener
 import org.koitharu.kotatsu.base.ui.list.decor.SpacingItemDecoration
+import org.koitharu.kotatsu.base.ui.list.decor.TypedSpacingItemDecoration
 import org.koitharu.kotatsu.browser.cloudflare.CloudFlareDialog
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
 import org.koitharu.kotatsu.core.exceptions.resolve.ExceptionResolver
@@ -243,8 +244,11 @@ abstract class MangaListFragment :
 				ListMode.LIST -> {
 					layoutManager = FitHeightLinearLayoutManager(context)
 					val spacing = resources.getDimensionPixelOffset(R.dimen.list_spacing)
-					addItemDecoration(SpacingItemDecoration(spacing))
-					updatePadding(left = spacing, right = spacing)
+					val decoration = TypedSpacingItemDecoration(
+						MangaListAdapter.ITEM_TYPE_MANGA_LIST to 0,
+						fallbackSpacing = spacing
+					)
+					addItemDecoration(decoration)
 				}
 				ListMode.DETAILED_LIST -> {
 					layoutManager = FitHeightLinearLayoutManager(context)

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

@@ -28,6 +28,7 @@ class MangaSelectionDecoration(context: Context) : AbstractSelectionItemDecorati
 		ColorUtils.blendARGB(strokeColor, context.getThemeColor(materialR.attr.colorSurface), 0.8f),
 		0x74
 	)
+	private val defaultRadius = context.resources.getDimension(R.dimen.list_selector_corner)
 
 	init {
 		hasBackground = false
@@ -40,7 +41,7 @@ class MangaSelectionDecoration(context: Context) : AbstractSelectionItemDecorati
 
 	override fun getItemId(parent: RecyclerView, child: View): Long {
 		val holder = parent.getChildViewHolder(child) ?: return NO_ID
-		val item = holder.getItem<MangaItemModel>() ?: return NO_ID
+		val item = holder.getItem(MangaItemModel::class.java) ?: return NO_ID
 		return item.id
 	}
 
@@ -51,21 +52,24 @@ class MangaSelectionDecoration(context: Context) : AbstractSelectionItemDecorati
 		bounds: RectF,
 		state: RecyclerView.State,
 	) {
-		val radius = (child as? CardView)?.radius ?: 0f
+		val isCard = child is CardView
+		val radius = (child as? CardView)?.radius ?: defaultRadius
 		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)
+		if (isCard) {
+			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/local/LocalModule.kt

@@ -3,6 +3,7 @@ package org.koitharu.kotatsu.local
 import org.koin.android.ext.koin.androidContext
 import org.koin.androidx.viewmodel.dsl.viewModel
 import org.koin.dsl.module
+import org.koitharu.kotatsu.download.domain.DownloadManager
 import org.koitharu.kotatsu.local.data.LocalStorageManager
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.local.ui.LocalListViewModel
@@ -16,5 +17,7 @@ val localModule
 
 		factory { ExternalStorageHelper(androidContext()) }
 
+		factory { DownloadManager.Factory(androidContext(), get(), get(), get(), get(), get()) }
+
 		viewModel { LocalListViewModel(get(), get(), get(), get()) }
 	}

app/src/main/java/org/koitharu/kotatsu/local/data/CbzFetcher.kt

@@ -9,11 +9,11 @@ import coil.fetch.FetchResult
 import coil.fetch.Fetcher
 import coil.fetch.SourceResult
 import coil.size.Size
+import java.util.zip.ZipFile
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import okio.buffer
 import okio.source
-import java.util.zip.ZipFile
 
 class CbzFetcher : Fetcher<Uri> {
 

app/src/main/java/org/koitharu/kotatsu/local/data/CbzFilter.kt

@@ -7,6 +7,10 @@ import java.util.*
 class CbzFilter : FilenameFilter {
 
 	override fun accept(dir: File, name: String): Boolean {
+		return isFileSupported(name)
+	}
+
+	fun isFileSupported(name: String): Boolean {
 		val ext = name.substringAfterLast('.', "").lowercase(Locale.ROOT)
 		return ext == "cbz" || ext == "zip"
 	}

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

@@ -28,14 +28,17 @@ class MangaIndex(source: String?) {
 		json.put("state", manga.state?.name)
 		json.put("source", manga.source.name)
 		json.put("cover_large", manga.largeCoverUrl)
-		json.put("tags", JSONArray().also { a ->
-			for (tag in manga.tags) {
-				val jo = JSONObject()
-				jo.put("key", tag.key)
-				jo.put("title", tag.title)
-				a.put(jo)
+		json.put(
+			"tags",
+			JSONArray().also { a ->
+				for (tag in manga.tags) {
+					val jo = JSONObject()
+					jo.put("key", tag.key)
+					jo.put("title", tag.title)
+					a.put(jo)
+				}
 			}
-		})
+		)
 		if (!append || !json.has("chapters")) {
 			json.put("chapters", JSONObject())
 		}
@@ -84,11 +87,15 @@ class MangaIndex(source: String?) {
 			jo.put("uploadDate", chapter.uploadDate)
 			jo.put("scanlator", chapter.scanlator)
 			jo.put("branch", chapter.branch)
-			jo.put("entries", "%03d\\d{3}".format(chapter.number))
+			jo.put("entries", "%08d_%03d\\d{3}".format(chapter.branch.hashCode(), chapter.number))
 			chapters.put(chapter.id.toString(), jo)
 		}
 	}
 
+	fun removeChapter(id: Long): Boolean {
+		return json.getJSONObject("chapters").remove(id.toString()) != null
+	}
+
 	fun setCoverEntry(name: String) {
 		json.put("cover_entry", name)
 	}

app/src/main/java/org/koitharu/kotatsu/local/data/MangaZip.kt

@@ -1,70 +0,0 @@
-package org.koitharu.kotatsu.local.data
-
-import androidx.annotation.CheckResult
-import androidx.annotation.WorkerThread
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.model.MangaChapter
-import org.koitharu.kotatsu.parsers.util.toFileNameSafe
-import org.koitharu.kotatsu.utils.ext.takeIfReadable
-import java.io.File
-
-@WorkerThread
-class MangaZip(val file: File) {
-
-	private val writableCbz = WritableCbzFile(file)
-
-	private var index = MangaIndex(null)
-
-	suspend fun prepare(manga: Manga) {
-		writableCbz.prepare(overwrite = true)
-		index = MangaIndex(writableCbz[INDEX_ENTRY].takeIfReadable()?.readText())
-		index.setMangaInfo(manga, append = true)
-	}
-
-	suspend fun cleanup() {
-		writableCbz.cleanup()
-	}
-
-	@CheckResult
-	suspend fun compress(): Boolean {
-		writableCbz[INDEX_ENTRY].writeText(index.toString())
-		return writableCbz.flush()
-	}
-
-	suspend fun addCover(file: File, ext: String) {
-		val name = buildString {
-			append(FILENAME_PATTERN.format(0, 0))
-			if (ext.isNotEmpty() && ext.length <= 4) {
-				append('.')
-				append(ext)
-			}
-		}
-		writableCbz.put(name, file)
-		index.setCoverEntry(name)
-	}
-
-	suspend fun addPage(chapter: MangaChapter, file: File, pageNumber: Int, ext: String) {
-		val name = buildString {
-			append(FILENAME_PATTERN.format(chapter.number, pageNumber))
-			if (ext.isNotEmpty() && ext.length <= 4) {
-				append('.')
-				append(ext)
-			}
-		}
-		writableCbz.put(name, file)
-		index.addChapter(chapter)
-	}
-
-	companion object {
-
-		private const val FILENAME_PATTERN = "%03d%03d"
-
-		const val INDEX_ENTRY = "index.json"
-
-		fun findInDir(root: File, manga: Manga): MangaZip {
-			val name = manga.title.toFileNameSafe() + ".cbz"
-			val file = File(root, name)
-			return MangaZip(file)
-		}
-	}
-}

app/src/main/java/org/koitharu/kotatsu/local/data/PagesCache.kt

@@ -2,13 +2,13 @@ package org.koitharu.kotatsu.local.data
 
 import android.content.Context
 import com.tomclaw.cache.DiskLruCache
+import java.io.File
+import java.io.InputStream
 import kotlinx.coroutines.flow.MutableStateFlow
 import org.koitharu.kotatsu.parsers.util.longHashCode
 import org.koitharu.kotatsu.utils.FileSize
 import org.koitharu.kotatsu.utils.ext.subdir
 import org.koitharu.kotatsu.utils.ext.takeIfReadable
-import java.io.File
-import java.io.InputStream
 
 class PagesCache(context: Context) {
 
@@ -60,4 +60,4 @@ class PagesCache(context: Context) {
 			progress.value = (bytesCopied.toDouble() / contentLength.toDouble()).toFloat()
 		}
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/local/data/TempFileFilter.kt

@@ -0,0 +1,11 @@
+package org.koitharu.kotatsu.local.data
+
+import java.io.File
+import java.io.FilenameFilter
+
+class TempFileFilter : FilenameFilter {
+
+	override fun accept(dir: File, name: String): Boolean {
+		return name.endsWith(".tmp", ignoreCase = true)
+	}
+}

app/src/main/java/org/koitharu/kotatsu/local/data/WritableCbzFile.kt

@@ -1,99 +0,0 @@
-package org.koitharu.kotatsu.local.data
-
-import androidx.annotation.CheckResult
-import kotlinx.coroutines.*
-import org.koitharu.kotatsu.utils.ext.deleteAwait
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-import java.util.zip.ZipEntry
-import java.util.zip.ZipInputStream
-import java.util.zip.ZipOutputStream
-
-class WritableCbzFile(private val file: File) {
-
-	private val dir = File(file.parentFile, file.nameWithoutExtension)
-
-	suspend fun prepare(overwrite: Boolean) = withContext(Dispatchers.IO) {
-		if (!dir.list().isNullOrEmpty()) {
-			if (overwrite) {
-				dir.deleteRecursively()
-			} else {
-				throw IllegalStateException("Dir ${dir.name} is not empty")
-			}
-		}
-		if (!dir.exists()) {
-			dir.mkdir()
-		}
-		if (!file.exists()) {
-			return@withContext
-		}
-		ZipInputStream(FileInputStream(file)).use { zip ->
-			var entry = zip.nextEntry
-			while (entry != null && currentCoroutineContext().isActive) {
-				val target = File(dir.path + File.separator + entry.name)
-				runInterruptible {
-					target.parentFile?.mkdirs()
-					target.outputStream().use { out ->
-						zip.copyTo(out)
-					}
-				}
-				zip.closeEntry()
-				entry = zip.nextEntry
-			}
-		}
-	}
-
-	suspend fun cleanup() = withContext(Dispatchers.IO) {
-		dir.deleteRecursively()
-	}
-
-	@CheckResult
-	suspend fun flush() = withContext(Dispatchers.IO) {
-		val tempFile = File(file.path + ".tmp")
-		if (tempFile.exists()) {
-			tempFile.deleteAwait()
-		}
-		try {
-			runInterruptible {
-				ZipOutputStream(FileOutputStream(tempFile)).use { zip ->
-					dir.listFiles()?.forEach {
-						zipFile(it, it.name, zip)
-					}
-					zip.flush()
-				}
-			}
-			tempFile.renameTo(file)
-		} finally {
-			if (tempFile.exists()) {
-				tempFile.deleteAwait()
-			}
-		}
-	}
-
-	operator fun get(name: String) = File(dir, name)
-
-	suspend fun put(name: String, file: File) = runInterruptible(Dispatchers.IO) {
-		file.copyTo(this[name], overwrite = true)
-	}
-
-	private fun zipFile(fileToZip: File, fileName: String, zipOut: ZipOutputStream) {
-		if (fileToZip.isDirectory) {
-			if (fileName.endsWith("/")) {
-				zipOut.putNextEntry(ZipEntry(fileName))
-			} else {
-				zipOut.putNextEntry(ZipEntry("$fileName/"))
-			}
-			zipOut.closeEntry()
-			fileToZip.listFiles()?.forEach { childFile ->
-				zipFile(childFile, "$fileName/${childFile.name}", zipOut)
-			}
-		} else {
-			FileInputStream(fileToZip).use { fis ->
-				val zipEntry = ZipEntry(fileName)
-				zipOut.putNextEntry(zipEntry)
-				fis.copyTo(zipOut)
-			}
-		}
-	}
-}

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

@@ -0,0 +1,153 @@
+package org.koitharu.kotatsu.local.domain
+
+import androidx.annotation.WorkerThread
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+import okio.Closeable
+import org.koitharu.kotatsu.core.zip.ZipOutput
+import org.koitharu.kotatsu.local.data.MangaIndex
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.util.toFileNameSafe
+import org.koitharu.kotatsu.utils.ext.deleteAwait
+import org.koitharu.kotatsu.utils.ext.readText
+import java.io.File
+import java.util.zip.ZipFile
+
+class CbzMangaOutput(
+	val file: File,
+	manga: Manga,
+) : Closeable {
+
+	private val output = ZipOutput(File(file.path + ".tmp"))
+	private val index = MangaIndex(null)
+
+	init {
+		index.setMangaInfo(manga, false)
+	}
+
+	suspend fun mergeWithExisting() {
+		if (file.exists()) {
+			runInterruptible(Dispatchers.IO) {
+				mergeWith(file)
+			}
+		}
+	}
+
+	suspend fun addCover(file: File, ext: String) {
+		val name = buildString {
+			append(FILENAME_PATTERN.format(0, 0, 0))
+			if (ext.isNotEmpty() && ext.length <= 4) {
+				append('.')
+				append(ext)
+			}
+		}
+		runInterruptible(Dispatchers.IO) {
+			output.put(name, file)
+		}
+		index.setCoverEntry(name)
+	}
+
+	suspend fun addPage(chapter: MangaChapter, file: File, pageNumber: Int, ext: String) {
+		val name = buildString {
+			append(FILENAME_PATTERN.format(chapter.branch.hashCode(), chapter.number, pageNumber))
+			if (ext.isNotEmpty() && ext.length <= 4) {
+				append('.')
+				append(ext)
+			}
+		}
+		runInterruptible(Dispatchers.IO) {
+			output.put(name, file)
+		}
+		index.addChapter(chapter)
+	}
+
+	suspend fun finalize() {
+		runInterruptible(Dispatchers.IO) {
+			output.put(ENTRY_NAME_INDEX, index.toString())
+			output.finish()
+			output.close()
+		}
+		file.deleteAwait()
+		output.file.renameTo(file)
+	}
+
+	suspend fun cleanup() {
+		output.file.deleteAwait()
+	}
+
+	override fun close() {
+		output.close()
+	}
+
+	@WorkerThread
+	private fun mergeWith(other: File) {
+		var otherIndex: MangaIndex? = null
+		ZipFile(other).use { zip ->
+			for (entry in zip.entries()) {
+				if (entry.name == ENTRY_NAME_INDEX) {
+					otherIndex = MangaIndex(
+						zip.getInputStream(entry).use {
+							it.reader().readText()
+						}
+					)
+				} else {
+					output.copyEntryFrom(zip, entry)
+				}
+			}
+		}
+		otherIndex?.getMangaInfo()?.chapters?.let { chapters ->
+			for (chapter in chapters) {
+				index.addChapter(chapter)
+			}
+		}
+	}
+
+	companion object {
+
+		private const val FILENAME_PATTERN = "%08d_%03d%03d"
+
+		const val ENTRY_NAME_INDEX = "index.json"
+
+		fun get(root: File, manga: Manga): CbzMangaOutput {
+			val name = manga.title.toFileNameSafe() + ".cbz"
+			val file = File(root, name)
+			return CbzMangaOutput(file, manga)
+		}
+
+		@WorkerThread
+		fun filterChapters(subject: CbzMangaOutput, idsToRemove: Set<Long>) {
+			ZipFile(subject.file).use { zip ->
+				val index = MangaIndex(zip.readText(zip.getEntry(ENTRY_NAME_INDEX)))
+				idsToRemove.forEach { id -> index.removeChapter(id) }
+				val patterns = requireNotNull(index.getMangaInfo()?.chapters).map {
+					index.getChapterNamesPattern(it)
+				}
+				val coverEntryName = index.getCoverEntry()
+				for (entry in zip.entries()) {
+					when {
+						entry.name == ENTRY_NAME_INDEX -> {
+							subject.output.put(ENTRY_NAME_INDEX, index.toString())
+						}
+						entry.isDirectory -> {
+							subject.output.addDirectory(entry.name)
+						}
+						entry.name == coverEntryName -> {
+							subject.output.copyEntryFrom(zip, entry)
+						}
+						else -> {
+							val name = entry.name.substringBefore('.')
+							if (patterns.any { it.matches(name) }) {
+								subject.output.copyEntryFrom(zip, entry)
+							}
+						}
+					}
+				}
+				subject.output.finish()
+				subject.output.close()
+				subject.file.delete()
+				subject.output.file.renameTo(subject.file)
+			}
+		}
+	}
+}

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

@@ -3,18 +3,17 @@ package org.koitharu.kotatsu.local.domain
 import android.annotation.SuppressLint
 import android.net.Uri
 import android.webkit.MimeTypeMap
+import androidx.annotation.WorkerThread
 import androidx.collection.ArraySet
 import androidx.core.net.toFile
 import androidx.core.net.toUri
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runInterruptible
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.*
 import org.koitharu.kotatsu.core.exceptions.UnsupportedFileException
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.local.data.CbzFilter
 import org.koitharu.kotatsu.local.data.LocalStorageManager
 import org.koitharu.kotatsu.local.data.MangaIndex
-import org.koitharu.kotatsu.local.data.MangaZip
+import org.koitharu.kotatsu.local.data.TempFileFilter
 import org.koitharu.kotatsu.parsers.model.*
 import org.koitharu.kotatsu.parsers.util.longHashCode
 import org.koitharu.kotatsu.parsers.util.toCamelCase
@@ -27,6 +26,9 @@ import java.io.IOException
 import java.util.*
 import java.util.zip.ZipEntry
 import java.util.zip.ZipFile
+import kotlin.coroutines.CoroutineContext
+
+private const val MAX_PARALLELISM = 4
 
 class LocalMangaRepository(private val storageManager: LocalStorageManager) : MangaRepository {
 
@@ -39,27 +41,43 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		tags: Set<MangaTag>?,
 		sortOrder: SortOrder?
 	): List<Manga> {
-		require(offset == 0) {
-			"LocalMangaRepository does not support pagination"
+		if (offset > 0) {
+			return emptyList()
 		}
 		val files = getAllFiles()
-		return files.mapNotNull { x -> runCatching { getFromFile(x) }.getOrNull() }
+		val list = coroutineScope {
+			val dispatcher = Dispatchers.IO.limitedParallelism(MAX_PARALLELISM)
+			files.map { file ->
+				getFromFileAsync(file, dispatcher)
+			}.awaitAll()
+		}.filterNotNullTo(ArrayList(files.size))
+		if (!query.isNullOrEmpty()) {
+			list.retainAll { x ->
+				x.title.contains(query, ignoreCase = true) ||
+					x.altTitle?.contains(query, ignoreCase = true) == true
+			}
+		}
+		if (!tags.isNullOrEmpty()) {
+			list.retainAll { x ->
+				x.tags.containsAll(tags)
+			}
+		}
+		return list
 	}
 
 	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
+		else -> getFromFile(Uri.parse(manga.url).toFile())
 	}
 
 	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
-		return runInterruptible(Dispatchers.IO){
+		return runInterruptible(Dispatchers.IO) {
 			val uri = Uri.parse(chapter.url)
 			val file = uri.toFile()
 			val zip = ZipFile(file)
-			val index = zip.getEntry(MangaZip.INDEX_ENTRY)?.let(zip::readText)?.let(::MangaIndex)
+			val index = zip.getEntry(CbzMangaOutput.ENTRY_NAME_INDEX)?.let(zip::readText)?.let(::MangaIndex)
 			var entries = zip.entries().asSequence()
 			entries = if (index != null) {
 				val pattern = index.getChapterNamesPattern(chapter)
@@ -94,10 +112,18 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		return file.deleteAwait()
 	}
 
+	suspend fun deleteChapters(manga: Manga, ids: Set<Long>) = runInterruptible(Dispatchers.IO) {
+		val uri = Uri.parse(manga.url)
+		val file = uri.toFile()
+		val cbz = CbzMangaOutput(file, manga)
+		CbzMangaOutput.filterChapters(cbz, ids)
+	}
+
+	@WorkerThread
 	@SuppressLint("DefaultLocale")
 	fun getFromFile(file: File): Manga = ZipFile(file).use { zip ->
 		val fileUri = file.toUri().toString()
-		val entry = zip.getEntry(MangaZip.INDEX_ENTRY)
+		val entry = zip.getEntry(CbzMangaOutput.ENTRY_NAME_INDEX)
 		val index = entry?.let(zip::readText)?.let(::MangaIndex)
 		val info = index?.getMangaInfo()
 		if (index != null && info != null) {
@@ -158,7 +184,7 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		}.getOrNull() ?: return null
 		return runInterruptible(Dispatchers.IO) {
 			ZipFile(file).use { zip ->
-				val entry = zip.getEntry(MangaZip.INDEX_ENTRY)
+				val entry = zip.getEntry(CbzMangaOutput.ENTRY_NAME_INDEX)
 				val index = entry?.let(zip::readText)?.let(::MangaIndex)
 				index?.getMangaInfo()
 			}
@@ -170,7 +196,7 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		return runInterruptible(Dispatchers.IO) {
 			for (file in files) {
 				val index = ZipFile(file).use { zip ->
-					val entry = zip.getEntry(MangaZip.INDEX_ENTRY)
+					val entry = zip.getEntry(CbzMangaOutput.ENTRY_NAME_INDEX)
 					entry?.let(zip::readText)?.let(::MangaIndex)
 				} ?: continue
 				val info = index.getMangaInfo() ?: continue
@@ -187,6 +213,15 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		}
 	}
 
+	private fun CoroutineScope.getFromFileAsync(
+		file: File,
+		context: CoroutineContext,
+	): Deferred<Manga?> = async(context) {
+		runInterruptible {
+			runCatching { getFromFile(file) }.getOrNull()
+		}
+	}
+
 	private fun zipUri(file: File, entryName: String) = "cbz://${file.path}#$entryName"
 
 	private fun findFirstImageEntry(entries: Enumeration<out ZipEntry>): ZipEntry? {
@@ -211,7 +246,7 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		withContext(Dispatchers.IO) {
 			val name = contentResolver.resolveName(uri)
 				?: throw IOException("Cannot fetch name from uri: $uri")
-			if (!isFileSupported(name)) {
+			if (!filenameFilter.isFileSupported(name)) {
 				throw UnsupportedFileException("Unsupported file on $uri")
 			}
 			val dest = File(
@@ -228,15 +263,21 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		}
 	}
 
-	fun isFileSupported(name: String): Boolean {
-		val ext = name.substringAfterLast('.').lowercase(Locale.ROOT)
-		return ext == "cbz" || ext == "zip"
-	}
-
 	suspend fun getOutputDir(): File? {
 		return storageManager.getDefaultWriteableDir()
 	}
 
+	suspend fun cleanup() {
+		val dirs = storageManager.getWriteableDirs()
+		runInterruptible(Dispatchers.IO) {
+			dirs.flatMap { dir ->
+				dir.listFiles(TempFileFilter())?.toList().orEmpty()
+			}.forEach { file ->
+				file.delete()
+			}
+		}
+	}
+
 	private suspend fun getAllFiles() = storageManager.getReadableDirs().flatMap { dir ->
 		dir.listFiles(filenameFilter)?.toList().orEmpty()
 	}

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

@@ -0,0 +1,80 @@
+package org.koitharu.kotatsu.local.ui
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.ServiceCompat
+import androidx.core.content.ContextCompat
+import org.koin.android.ext.android.inject
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.ui.CoroutineIntentService
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.download.ui.service.DownloadService
+import org.koitharu.kotatsu.local.domain.LocalMangaRepository
+import org.koitharu.kotatsu.parsers.model.Manga
+
+class LocalChaptersRemoveService : CoroutineIntentService() {
+
+	private val localMangaRepository by inject<LocalMangaRepository>()
+
+	override suspend fun processIntent(intent: Intent?) {
+		val manga = intent?.getParcelableExtra<ParcelableManga>(EXTRA_MANGA)?.manga ?: return
+		val chaptersIds = intent.getLongArrayExtra(EXTRA_CHAPTERS_IDS)?.toSet() ?: return
+		startForeground()
+		val mangaWithChapters = localMangaRepository.getDetails(manga)
+		localMangaRepository.deleteChapters(mangaWithChapters, chaptersIds)
+		sendBroadcast(
+			Intent(DownloadService.ACTION_DOWNLOAD_COMPLETE)
+				.putExtra(EXTRA_MANGA, ParcelableManga(manga, withChapters = false))
+		)
+		ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+	}
+
+	private fun startForeground() {
+		val title = getString(R.string.local_manga_processing)
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+			val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+			val channel = NotificationChannel(CHANNEL_ID, title, NotificationManager.IMPORTANCE_LOW)
+			channel.setShowBadge(false)
+			channel.enableVibration(false)
+			channel.setSound(null, null)
+			channel.enableLights(false)
+			manager.createNotificationChannel(channel)
+		}
+
+		val notification = NotificationCompat.Builder(this, CHANNEL_ID)
+			.setContentTitle(title)
+			.setPriority(NotificationCompat.PRIORITY_MIN)
+			.setDefaults(0)
+			.setColor(ContextCompat.getColor(this, R.color.blue_primary_dark))
+			.setSilent(true)
+			.setProgress(0, 0, true)
+			.setSmallIcon(android.R.drawable.stat_notify_sync)
+			.setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_DEFERRED)
+			.setOngoing(true)
+			.build()
+		startForeground(NOTIFICATION_ID, notification)
+	}
+
+	companion object {
+
+		private const val CHANNEL_ID = "local_processing"
+		private const val NOTIFICATION_ID = 21
+
+		private const val EXTRA_MANGA = "manga"
+		private const val EXTRA_CHAPTERS_IDS = "chapters_ids"
+
+		fun start(context: Context, manga: Manga, chaptersIds: Collection<Long>) {
+			if (chaptersIds.isEmpty()) {
+				return
+			}
+			val intent = Intent(context, LocalChaptersRemoveService::class.java)
+			intent.putExtra(EXTRA_MANGA, ParcelableManga(manga, withChapters = false))
+			intent.putExtra(EXTRA_CHAPTERS_IDS, chaptersIds.toLongArray())
+			ContextCompat.startForegroundService(context, intent)
+		}
+	}
+}

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

@@ -3,16 +3,18 @@ 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.launch
 import kotlinx.coroutines.withContext
+import org.koitharu.kotatsu.BuildConfig
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.os.ShortcutsRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.download.ui.service.DownloadService
 import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.list.ui.MangaListViewModel
 import org.koitharu.kotatsu.list.ui.model.*
@@ -21,6 +23,7 @@ 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,
@@ -64,6 +67,7 @@ class LocalListViewModel(
 
 	init {
 		onRefresh()
+		cleanup()
 	}
 
 	override fun onRefresh() {
@@ -116,4 +120,18 @@ class LocalListViewModel(
 			listError.value = e
 		}
 	}
+
+	private fun cleanup() {
+		if (!DownloadService.isRunning) {
+			viewModelScope.launch {
+				runCatching {
+					repository.cleanup()
+				}.onFailure { error ->
+					if (BuildConfig.DEBUG) {
+						error.printStackTrace()
+					}
+				}
+			}
+		}
+	}
 }

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

@@ -387,7 +387,9 @@ class MainActivity :
 		lifecycleScope.launch(Dispatchers.Default) {
 			TrackWorker.setup(applicationContext)
 			SuggestionsWorker.setup(applicationContext)
-			AppUpdateChecker(this@MainActivity).checkIfNeeded()
+			if (AppUpdateChecker.isUpdateSupported(this@MainActivity)) {
+				AppUpdateChecker(this@MainActivity).checkIfNeeded()
+			}
 			if (!get<AppSettings>().isSourcesSelected) {
 				withContext(Dispatchers.Main) {
 					OnboardDialogFragment.showWelcome(supportFragmentManager)

app/src/main/java/org/koitharu/kotatsu/main/ui/protect/AppProtectHelper.kt

@@ -34,7 +34,7 @@ class AppProtectHelper(private val settings: AppSettings) : Application.Activity
 	override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
 
 	override fun onActivityDestroyed(activity: Activity) {
-		if (activity !is ProtectActivity && activity.isTaskRoot) {
+		if (activity !is ProtectActivity && activity.isFinishing && activity.isTaskRoot) {
 			restoreLock()
 		}
 	}

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

@@ -6,10 +6,6 @@ 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
@@ -31,6 +27,10 @@ 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
@@ -115,8 +115,13 @@ class PageLoader : KoinComponent, Closeable {
 
 	private fun onIdle() {
 		synchronized(prefetchQueue) {
-			val page = prefetchQueue.pollFirst() ?: return
-			tasks[page.id] = loadPageAsyncImpl(page)
+			while (prefetchQueue.isNotEmpty()) {
+				val page = prefetchQueue.pollFirst() ?: return
+				if (cache[page.url] == null) {
+					tasks[page.id] = loadPageAsyncImpl(page)
+					return
+				}
+			}
 		}
 	}
 

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

@@ -410,18 +410,18 @@ class ReaderActivity :
 
 		fun newIntent(context: Context, manga: Manga): Intent {
 			return Intent(context, ReaderActivity::class.java)
-				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga))
+				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga, withChapters = true))
 		}
 
 		fun newIntent(context: Context, manga: Manga, branch: String?): Intent {
 			return Intent(context, ReaderActivity::class.java)
-				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga))
+				.putExtra(MangaIntent.KEY_MANGA, ParcelableManga(manga, withChapters = true))
 				.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(MangaIntent.KEY_MANGA, ParcelableManga(manga, withChapters = true))
 				.putExtra(EXTRA_STATE, state)
 		}
 

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

@@ -143,7 +143,8 @@ class ReaderViewModel(
 				val page = getCurrentPage() ?: error("Page not found")
 				externalStorageHelper.savePage(page, destination)
 				onPageSaved.postCall(destination)
-			} catch (_: CancellationException) {
+			} catch (e: CancellationException) {
+				throw e
 			} catch (e: Exception) {
 				if (BuildConfig.DEBUG) {
 					e.printStackTrace()

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

@@ -109,7 +109,7 @@ class PageHolderDelegate(
 			state = State.LOADED
 			callback.onImageReady(file.toUri())
 		} catch (e: CancellationException) {
-			// do nothing
+			throw e
 		} catch (e: Exception) {
 			state = State.ERROR
 			error = e

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

@@ -14,7 +14,7 @@ import org.koitharu.kotatsu.reader.ui.pager.BaseReaderAdapter
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
 import org.koitharu.kotatsu.utils.ext.doOnCurrentItemChanged
 import org.koitharu.kotatsu.utils.ext.findCenterViewPosition
-import org.koitharu.kotatsu.utils.ext.firstItem
+import org.koitharu.kotatsu.utils.ext.firstVisibleItemPosition
 import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
 
 class WebtoonReaderFragment : BaseReader<FragmentReaderWebtoonBinding>() {
@@ -52,7 +52,7 @@ class WebtoonReaderFragment : BaseReader<FragmentReaderWebtoonBinding>() {
 				setItems.await() ?: return@launchWhenCreated
 				if (position != -1) {
 					with(binding.recyclerView) {
-						firstItem = position
+						firstVisibleItemPosition = position
 						post {
 							(findViewHolderForAdapterPosition(position) as? WebtoonHolder)
 								?.restoreScroll(pendingState.scroll)
@@ -91,6 +91,6 @@ class WebtoonReaderFragment : BaseReader<FragmentReaderWebtoonBinding>() {
 	}
 
 	override fun switchPageTo(position: Int, smooth: Boolean) {
-		binding.recyclerView.firstItem = position
+		binding.recyclerView.firstVisibleItemPosition = position
 	}
 }

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

@@ -19,17 +19,20 @@ import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.databinding.SheetPagesBinding
 import org.koitharu.kotatsu.list.ui.MangaListSpanResolver
 import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.reader.domain.PageLoader
 import org.koitharu.kotatsu.reader.ui.thumbnails.adapter.PageThumbnailAdapter
 import org.koitharu.kotatsu.utils.BottomSheetToolbarController
 import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
 import org.koitharu.kotatsu.utils.ext.withArgs
 
-class PagesThumbnailsSheet : BaseBottomSheet<SheetPagesBinding>(),
+class PagesThumbnailsSheet :
+	BaseBottomSheet<SheetPagesBinding>(),
 	OnListItemClickListener<MangaPage> {
 
 	private lateinit var thumbnails: List<PageThumbnail>
 	private val spanResolver = MangaListSpanResolver()
 	private var currentPageIndex = -1
+	private var pageLoader: PageLoader? = null
 
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
@@ -75,11 +78,11 @@ class PagesThumbnailsSheet : BaseBottomSheet<SheetPagesBinding>(),
 				SpacingItemDecoration(resources.getDimensionPixelOffset(R.dimen.grid_spacing))
 			)
 			adapter = PageThumbnailAdapter(
-				thumbnails,
-				get(),
-				viewLifecycleScope,
-				get(),
-				this@PagesThumbnailsSheet
+				dataSet = thumbnails,
+				coil = get(),
+				scope = viewLifecycleScope,
+				loader = PageLoader().also { pageLoader = it },
+				clickListener = this@PagesThumbnailsSheet
 			)
 			addOnLayoutChangeListener(spanResolver)
 			spanResolver.setGridSize(get<AppSettings>().gridSize / 100f, this)
@@ -90,9 +93,17 @@ class PagesThumbnailsSheet : BaseBottomSheet<SheetPagesBinding>(),
 		}
 	}
 
+	override fun onDestroyView() {
+		super.onDestroyView()
+		pageLoader?.close()
+		pageLoader = null
+	}
+
 	override fun onItemClick(item: MangaPage, view: View) {
-		((parentFragment as? OnPageSelectListener)
-			?: (activity as? OnPageSelectListener))?.run {
+		(
+			(parentFragment as? OnPageSelectListener)
+				?: (activity as? OnPageSelectListener)
+			)?.run {
 			onPageSelected(item)
 			dismiss()
 		}
@@ -127,6 +138,5 @@ class PagesThumbnailsSheet : BaseBottomSheet<SheetPagesBinding>(),
 				putString(ARG_TITLE, title)
 				putInt(ARG_CURRENT, currentPage)
 			}.show(fm, TAG)
-
 	}
 }

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

@@ -1,27 +1,26 @@
 package org.koitharu.kotatsu.reader.ui.thumbnails.adapter
 
-import androidx.core.net.toUri
+import android.graphics.drawable.Drawable
 import coil.ImageLoader
 import coil.request.ImageRequest
 import coil.size.PixelSize
+import com.google.android.material.R as materialR
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import kotlinx.coroutines.*
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.databinding.ItemPageThumbBinding
-import org.koitharu.kotatsu.local.data.PagesCache
 import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.reader.domain.PageLoader
 import org.koitharu.kotatsu.reader.ui.thumbnails.PageThumbnail
-import org.koitharu.kotatsu.utils.ext.IgnoreErrors
 import org.koitharu.kotatsu.utils.ext.referer
 import org.koitharu.kotatsu.utils.ext.setTextColorAttr
-import com.google.android.material.R as materialR
 
 fun pageThumbnailAD(
 	coil: ImageLoader,
 	scope: CoroutineScope,
-	cache: PagesCache,
-	clickListener: OnListItemClickListener<MangaPage>
+	loader: PageLoader,
+	clickListener: OnListItemClickListener<MangaPage>,
 ) = adapterDelegateViewBinding<PageThumbnail, PageThumbnail, ItemPageThumbBinding>(
 	{ inflater, parent -> ItemPageThumbBinding.inflate(inflater, parent, false) }
 ) {
@@ -33,6 +32,29 @@ fun pageThumbnailAD(
 		height = (gridWidth * 13f / 18f).toInt()
 	)
 
+	suspend fun loadPageThumbnail(item: PageThumbnail): Drawable? = withContext(Dispatchers.Default) {
+		item.page.preview?.let { url ->
+			coil.execute(
+				ImageRequest.Builder(context)
+					.data(url)
+					.referer(item.page.referer)
+					.size(thumbSize)
+					.allowRgb565(true)
+					.build()
+			).drawable
+		}?.let { drawable ->
+			return@withContext drawable
+		}
+		val file = loader.loadPage(item.page, force = false)
+		coil.execute(
+			ImageRequest.Builder(context)
+				.data(file)
+				.size(thumbSize)
+				.allowRgb565(true)
+				.build()
+		).drawable
+	}
+
 	binding.root.setOnClickListener {
 		clickListener.onItemClick(item.page, itemView)
 	}
@@ -45,22 +67,11 @@ fun pageThumbnailAD(
 			setTextColorAttr(if (item.isCurrent) materialR.attr.colorOnTertiary else android.R.attr.textColorPrimary)
 			text = (item.number).toString()
 		}
-		job = scope.launch(Dispatchers.Default + IgnoreErrors) {
-			val url = item.page.preview ?: item.page.url.let {
-				val pageUrl = item.repository.getPageUrl(item.page)
-				cache[pageUrl]?.toUri()?.toString() ?: pageUrl
-			}
-			val drawable = coil.execute(
-				ImageRequest.Builder(context)
-					.data(url)
-					.referer(item.page.referer)
-					.size(thumbSize)
-					.allowRgb565(true)
-					.build()
-			).drawable
-			withContext(Dispatchers.Main) {
-				binding.imageViewThumb.setImageDrawable(drawable)
-			}
+		job = scope.launch {
+			val drawable = runCatching {
+				loadPageThumbnail(item)
+			}.getOrNull()
+			binding.imageViewThumb.setImageDrawable(drawable)
 		}
 	}
 

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

@@ -4,20 +4,20 @@ import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.ListDelegationAdapter
 import kotlinx.coroutines.CoroutineScope
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
-import org.koitharu.kotatsu.local.data.PagesCache
 import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.reader.domain.PageLoader
 import org.koitharu.kotatsu.reader.ui.thumbnails.PageThumbnail
 
 class PageThumbnailAdapter(
 	dataSet: List<PageThumbnail>,
 	coil: ImageLoader,
 	scope: CoroutineScope,
-	cache: PagesCache,
+	loader: PageLoader,
 	clickListener: OnListItemClickListener<MangaPage>
 ) : ListDelegationAdapter<List<PageThumbnail>>() {
 
 	init {
-		delegatesManager.addDelegate(pageThumbnailAD(coil, scope, cache, clickListener))
+		delegatesManager.addDelegate(pageThumbnailAD(coil, scope, loader, clickListener))
 		setItems(dataSet)
 	}
 }

app/src/main/java/org/koitharu/kotatsu/remotelist/ui/RemoteListViewModel.kt

@@ -137,6 +137,9 @@ class RemoteListViewModel(
 					e.printStackTrace()
 				}
 				listError.value = e
+				if (!mangaList.value.isNullOrEmpty()) {
+					onError.postCall(e)
+				}
 			}
 		}
 	}

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

@@ -31,7 +31,7 @@ class SearchSuggestionItemCallback(
 	): Boolean = false
 
 	override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
-		val item = viewHolder.getItem<SearchSuggestionItem.RecentQuery>() ?: return
+		val item = viewHolder.getItem(SearchSuggestionItem.RecentQuery::class.java) ?: return
 		listener.onRemoveQuery(item.query)
 	}
 

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

@@ -25,9 +25,10 @@ class AppearanceSettingsFragment :
 	override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
 		addPreferencesFromResource(R.xml.pref_appearance)
 		findPreference<SliderPreference>(AppSettings.KEY_GRID_SIZE)?.run {
-			summary = "%d%%".format(value)
+			val pattern = context.getString(R.string.percent_string_pattern)
+			summary = pattern.format(value.toString())
 			setOnPreferenceChangeListener { preference, newValue ->
-				preference.summary = "%d%%".format(newValue)
+				preference.summary = pattern.format(newValue.toString())
 				true
 			}
 		}

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

@@ -12,7 +12,7 @@ import org.koitharu.kotatsu.base.ui.BasePreferenceFragment
 import org.koitharu.kotatsu.base.ui.dialog.StorageSelectDialog
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.local.data.LocalStorageManager
-import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.settings.utils.SliderPreference
 import org.koitharu.kotatsu.utils.ext.getStorageName
 import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
 
@@ -29,6 +29,13 @@ class ContentSettingsFragment :
 		findPreference<Preference>(AppSettings.KEY_SUGGESTIONS)?.setSummary(
 			if (settings.isSuggestionsEnabled) R.string.enabled else R.string.disabled
 		)
+		findPreference<SliderPreference>(AppSettings.KEY_DOWNLOADS_PARALLELISM)?.run {
+			summary = value.toString()
+			setOnPreferenceChangeListener { preference, newValue ->
+				preference.summary = newValue.toString()
+				true
+			}
+		}
 		bindRemoteSourcesSummary()
 	}
 
@@ -87,7 +94,7 @@ class ContentSettingsFragment :
 
 	private fun bindRemoteSourcesSummary() {
 		findPreference<Preference>(AppSettings.KEY_REMOTE_SOURCES)?.run {
-			val total = MangaSource.values().size - 1
+			val total = settings.remoteMangaSources.size
 			summary = getString(
 				R.string.enabled_d_of_d, total - settings.hiddenSources.size, total
 			)

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

@@ -18,7 +18,7 @@ val settingsModule
 
 		single { BackupRepository(get()) }
 		single { RestoreRepository(get()) }
-		single { AppSettings(androidContext()) }
+		single(createdAtStart = true) { AppSettings(androidContext()) }
 
 		viewModel { BackupViewModel(get(), androidContext()) }
 		viewModel { params ->

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

@@ -1,15 +1,15 @@
 package org.koitharu.kotatsu.settings
 
 import android.view.inputmethod.EditorInfo
-import androidx.preference.*
+import androidx.preference.EditTextPreference
+import androidx.preference.Preference
+import androidx.preference.PreferenceFragmentCompat
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.parsers.config.ConfigKey
+import org.koitharu.kotatsu.settings.utils.AutoCompleteTextViewPreference
 import org.koitharu.kotatsu.settings.utils.EditTextBindListener
 import org.koitharu.kotatsu.settings.utils.EditTextDefaultSummaryProvider
-import org.koitharu.kotatsu.utils.ext.setDefaultValueCompat
-
-private const val KEY_DOMAIN = "domain"
 
 fun PreferenceFragmentCompat.addPreferencesFromRepository(repository: RemoteMangaRepository) {
 	val configKeys = repository.getConfigKeys()
@@ -19,23 +19,17 @@ fun PreferenceFragmentCompat.addPreferencesFromRepository(repository: RemoteMang
 			is ConfigKey.Domain -> {
 				val presetValues = key.presetValues
 				if (presetValues.isNullOrEmpty()) {
-					EditTextPreference(requireContext()).apply {
-						summaryProvider = EditTextDefaultSummaryProvider(key.defaultValue)
-						setOnBindEditTextListener(
-							EditTextBindListener(
-								inputType = EditorInfo.TYPE_CLASS_TEXT or EditorInfo.TYPE_TEXT_VARIATION_URI,
-								hint = key.defaultValue,
-							)
-						)
-					}
+					EditTextPreference(requireContext())
 				} else {
-					DropDownPreference(requireContext()).apply {
-						entries = presetValues
-						entryValues = entries
-						summaryProvider = ListPreference.SimpleSummaryProvider.getInstance()
-						setDefaultValueCompat(key.defaultValue)
-					}
+					AutoCompleteTextViewPreference(requireContext()).apply { entries = presetValues }
 				}.apply {
+					summaryProvider = EditTextDefaultSummaryProvider(key.defaultValue)
+					setOnBindEditTextListener(
+						EditTextBindListener(
+							inputType = EditorInfo.TYPE_CLASS_TEXT or EditorInfo.TYPE_TEXT_VARIATION_URI,
+							hint = key.defaultValue,
+						)
+					)
 					setTitle(R.string.domain)
 					setDialogTitle(R.string.domain)
 				}

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

@@ -5,12 +5,8 @@ import android.app.backup.BackupDataInput
 import android.app.backup.BackupDataOutput
 import android.app.backup.FullBackupDataOutput
 import android.os.ParcelFileDescriptor
-import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.runBlocking
-import org.koitharu.kotatsu.core.backup.BackupArchive
-import org.koitharu.kotatsu.core.backup.BackupEntry
-import org.koitharu.kotatsu.core.backup.BackupRepository
-import org.koitharu.kotatsu.core.backup.RestoreRepository
+import org.koitharu.kotatsu.core.backup.*
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import java.io.*
 
@@ -46,7 +42,7 @@ class AppBackupAgent : BackupAgent() {
 		mode: Long,
 		mtime: Long
 	) {
-		if (destination?.name?.endsWith(".bak") == true) {
+		if (destination?.name?.endsWith(".bk.zip") == true) {
 			restoreBackupFile(data.fileDescriptor, size)
 			destination.delete()
 		} else {
@@ -56,14 +52,14 @@ class AppBackupAgent : BackupAgent() {
 
 	private fun createBackupFile() = runBlocking {
 		val repository = BackupRepository(MangaDatabase.create(applicationContext))
-		val backup = BackupArchive.createNew(this@AppBackupAgent)
-		backup.put(repository.createIndex())
-		backup.put(repository.dumpHistory())
-		backup.put(repository.dumpCategories())
-		backup.put(repository.dumpFavourites())
-		backup.flush()
-		backup.cleanup()
-		backup.file
+		BackupZipOutput(this@AppBackupAgent).use { backup ->
+			backup.put(repository.createIndex())
+			backup.put(repository.dumpHistory())
+			backup.put(repository.dumpCategories())
+			backup.put(repository.dumpFavourites())
+			backup.finish()
+			backup.file
+		}
 	}
 
 	private fun restoreBackupFile(fd: FileDescriptor, size: Long) {
@@ -74,18 +70,15 @@ class AppBackupAgent : BackupAgent() {
 				input.copyLimitedTo(output, size)
 			}
 		}
-		val backup = BackupArchive(tempFile)
+		val backup = BackupZipInput(tempFile)
 		try {
 			runBlocking {
-				backup.unpack()
 				repository.upsertHistory(backup.getEntry(BackupEntry.HISTORY))
 				repository.upsertCategories(backup.getEntry(BackupEntry.CATEGORIES))
 				repository.upsertFavourites(backup.getEntry(BackupEntry.FAVOURITES))
 			}
 		} finally {
-			runBlocking(NonCancellable) {
-				backup.cleanup()
-			}
+			backup.close()
 			tempFile.delete()
 		}
 	}

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

@@ -3,8 +3,8 @@ package org.koitharu.kotatsu.settings.backup
 import android.content.Context
 import androidx.lifecycle.MutableLiveData
 import org.koitharu.kotatsu.base.ui.BaseViewModel
-import org.koitharu.kotatsu.core.backup.BackupArchive
 import org.koitharu.kotatsu.core.backup.BackupRepository
+import org.koitharu.kotatsu.core.backup.BackupZipOutput
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.progress.Progress
 import java.io.File
@@ -19,23 +19,25 @@ class BackupViewModel(
 
 	init {
 		launchLoadingJob {
-			val backup = BackupArchive.createNew(context)
-			backup.put(repository.createIndex())
+			val file = BackupZipOutput(context).use { backup ->
+				backup.put(repository.createIndex())
 
-			progress.value = Progress(0, 3)
-			backup.put(repository.dumpHistory())
+				progress.value = Progress(0, 3)
+				backup.put(repository.dumpHistory())
 
-			progress.value = Progress(1, 3)
-			backup.put(repository.dumpCategories())
+				progress.value = Progress(1, 3)
+				backup.put(repository.dumpCategories())
 
-			progress.value = Progress(2, 3)
-			backup.put(repository.dumpFavourites())
+				progress.value = Progress(2, 3)
+				backup.put(repository.dumpFavourites())
 
-			progress.value = Progress(3, 3)
-			backup.flush()
-			progress.value = null
-			backup.cleanup()
-			onBackupDone.call(backup.file)
+				progress.value = Progress(3, 3)
+				backup.finish()
+				progress.value = null
+				backup.close()
+				backup.file
+			}
+			onBackupDone.call(file)
 		}
 	}
 }

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

@@ -3,19 +3,17 @@ package org.koitharu.kotatsu.settings.backup
 import android.content.Context
 import android.net.Uri
 import androidx.lifecycle.MutableLiveData
-import java.io.File
-import java.io.FileNotFoundException
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.runInterruptible
-import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.base.ui.BaseViewModel
-import org.koitharu.kotatsu.core.backup.BackupArchive
 import org.koitharu.kotatsu.core.backup.BackupEntry
+import org.koitharu.kotatsu.core.backup.BackupZipInput
 import org.koitharu.kotatsu.core.backup.CompositeResult
 import org.koitharu.kotatsu.core.backup.RestoreRepository
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.progress.Progress
+import java.io.File
+import java.io.FileNotFoundException
 
 class RestoreViewModel(
 	uri: Uri?,
@@ -40,10 +38,9 @@ class RestoreViewModel(
 						input.copyTo(output)
 					}
 				}
-				BackupArchive(tempFile)
+				BackupZipInput(tempFile)
 			}
 			try {
-				backup.unpack()
 				val result = CompositeResult()
 
 				progress.value = Progress(0, 3)
@@ -58,10 +55,8 @@ class RestoreViewModel(
 				progress.value = Progress(3, 3)
 				onRestoreDone.call(result)
 			} finally {
-				withContext(NonCancellable) {
-					backup.cleanup()
-					backup.file.delete()
-				}
+				backup.close()
+				backup.file.delete()
 			}
 		}
 	}

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

@@ -3,6 +3,7 @@ package org.koitharu.kotatsu.settings.onboard
 import androidx.collection.ArraySet
 import androidx.core.os.LocaleListCompat
 import androidx.lifecycle.MutableLiveData
+import java.util.*
 import org.koitharu.kotatsu.base.ui.BaseViewModel
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.parsers.model.MangaSource
@@ -11,17 +12,14 @@ import org.koitharu.kotatsu.parsers.util.toTitleCase
 import org.koitharu.kotatsu.settings.onboard.model.SourceLocale
 import org.koitharu.kotatsu.utils.ext.map
 import org.koitharu.kotatsu.utils.ext.mapToSet
-import java.util.*
 
 class OnboardViewModel(
 	private val settings: AppSettings,
 ) : BaseViewModel() {
 
-	private val allSources = MangaSource.values().filterNot { x -> x == MangaSource.LOCAL }
+	private val allSources = settings.remoteMangaSources
 
-	private val locales = allSources.mapTo(ArraySet()) {
-			it.locale
-		}
+	private val locales = allSources.mapTo(ArraySet()) { it.locale }
 
 	private val selectedLocales = locales.toMutableSet()
 

app/src/main/java/org/koitharu/kotatsu/settings/sources/SourcesSettingsViewModel.kt

@@ -32,7 +32,7 @@ class SourcesSettingsViewModel(
 		if ((snapshot[newPos] as? SourceConfigItem.SourceItem)?.isEnabled != true) return false
 		snapshot.move(oldPos, newPos)
 		settings.sourcesOrder = snapshot.mapNotNull {
-			(it as? SourceConfigItem.SourceItem)?.source?.ordinal
+			(it as? SourceConfigItem.SourceItem)?.source?.name
 		}
 		buildList()
 		return true
@@ -111,9 +111,6 @@ class SourcesSettingsViewModel(
 		if (enabledSources?.size != sources.size) {
 			result += SourceConfigItem.Header(R.string.available_sources)
 			for ((key, list) in map) {
-				val locale = if (key != null) {
-					Locale(key)
-				} else null
 				list.sortBy { it.ordinal }
 				val isExpanded = key in expandedGroups
 				result += SourceConfigItem.LocaleGroup(

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

@@ -11,18 +11,19 @@ import androidx.activity.result.contract.ActivityResultContract
 import androidx.core.graphics.Insets
 import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
+import com.google.android.material.R as materialR
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseActivity
 import org.koitharu.kotatsu.browser.BrowserCallback
 import org.koitharu.kotatsu.browser.BrowserClient
 import org.koitharu.kotatsu.browser.ProgressChromeClient
+import org.koitharu.kotatsu.core.network.UserAgentInterceptor
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.parser.RemoteMangaRepository
 import org.koitharu.kotatsu.databinding.ActivityBrowserBinding
 import org.koitharu.kotatsu.parsers.MangaParserAuthProvider
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.utils.TaggedActivityResult
-import com.google.android.material.R as materialR
 
 class SourceAuthActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallback {
 
@@ -52,6 +53,7 @@ class SourceAuthActivity : BaseActivity<ActivityBrowserBinding>(), BrowserCallba
 		}
 		with(binding.webView.settings) {
 			javaScriptEnabled = true
+			userAgentString = UserAgentInterceptor.userAgentChrome
 		}
 		binding.webView.webViewClient = BrowserClient(this)
 		binding.webView.webChromeClient = ProgressChromeClient(binding.progressBar)

app/src/main/java/org/koitharu/kotatsu/settings/utils/AutoCompleteTextViewPreference.kt

@@ -0,0 +1,58 @@
+package org.koitharu.kotatsu.settings.utils
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ArrayAdapter
+import android.widget.AutoCompleteTextView
+import android.widget.EditText
+import androidx.annotation.ArrayRes
+import androidx.annotation.AttrRes
+import androidx.annotation.StyleRes
+import androidx.preference.EditTextPreference
+import org.koitharu.kotatsu.R
+
+class AutoCompleteTextViewPreference @JvmOverloads constructor(
+	context: Context,
+	attrs: AttributeSet? = null,
+	@AttrRes defStyleAttr: Int = R.attr.autoCompleteTextViewPreferenceStyle,
+	@StyleRes defStyleRes: Int = R.style.Preference_AutoCompleteTextView,
+) : EditTextPreference(context, attrs, defStyleAttr, defStyleRes) {
+
+	private val autoCompleteBindListener = AutoCompleteBindListener()
+	var entries: Array<String> = emptyArray()
+
+	init {
+		super.setOnBindEditTextListener(autoCompleteBindListener)
+	}
+
+	fun setEntries(@ArrayRes arrayResId: Int) {
+		this.entries = context.resources.getStringArray(arrayResId)
+	}
+
+	fun setEntries(entries: Collection<String>) {
+		this.entries = entries.toTypedArray()
+	}
+
+	override fun setOnBindEditTextListener(onBindEditTextListener: OnBindEditTextListener?) {
+		autoCompleteBindListener.delegate = onBindEditTextListener
+	}
+
+	private inner class AutoCompleteBindListener : OnBindEditTextListener {
+
+		var delegate: OnBindEditTextListener? = null
+
+		override fun onBindEditText(editText: EditText) {
+			delegate?.onBindEditText(editText)
+			if (editText !is AutoCompleteTextView || entries.isEmpty()) {
+				return
+			}
+			editText.threshold = 0
+			editText.setAdapter(ArrayAdapter(editText.context, android.R.layout.simple_spinner_dropdown_item, entries))
+			(editText.parent as? ViewGroup)?.findViewById<View>(R.id.dropdown)?.setOnClickListener {
+				editText.showDropDown()
+			}
+		}
+	}
+}

app/src/main/java/org/koitharu/kotatsu/tracker/ui/FeedFragment.kt

@@ -11,7 +11,7 @@ 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.list.PaginationScrollListener
-import org.koitharu.kotatsu.base.ui.list.decor.SpacingItemDecoration
+import org.koitharu.kotatsu.base.ui.list.decor.TypedSpacingItemDecoration
 import org.koitharu.kotatsu.databinding.FragmentFeedBinding
 import org.koitharu.kotatsu.details.ui.DetailsActivity
 import org.koitharu.kotatsu.list.ui.adapter.MangaListListener
@@ -57,7 +57,11 @@ class FeedFragment :
 			val spacing = resources.getDimensionPixelOffset(R.dimen.list_spacing)
 			paddingHorizontal = spacing
 			paddingVertical = resources.getDimensionPixelOffset(R.dimen.grid_spacing_outer)
-			addItemDecoration(SpacingItemDecoration(spacing))
+			val decoration = TypedSpacingItemDecoration(
+				FeedAdapter.ITEM_TYPE_FEED to 0,
+				fallbackSpacing = spacing
+			)
+			addItemDecoration(decoration)
 		}
 
 		viewModel.content.observe(viewLifecycleOwner, this::onListChanged)

app/src/main/java/org/koitharu/kotatsu/tracker/ui/FeedViewModel.kt

@@ -10,14 +10,15 @@ import kotlinx.coroutines.flow.filterNotNull
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseViewModel
 import org.koitharu.kotatsu.core.model.TrackingLogItem
-import org.koitharu.kotatsu.list.ui.model.EmptyState
-import org.koitharu.kotatsu.list.ui.model.ListHeader
-import org.koitharu.kotatsu.list.ui.model.LoadingFooter
-import org.koitharu.kotatsu.list.ui.model.LoadingState
+import org.koitharu.kotatsu.core.ui.DateTimeAgo
+import org.koitharu.kotatsu.list.ui.model.*
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.tracker.ui.model.toFeedItem
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
+import org.koitharu.kotatsu.utils.ext.daysDiff
+import java.util.*
+import java.util.concurrent.TimeUnit
 
 class FeedViewModel(
 	private val repository: TrackingRepository
@@ -34,8 +35,8 @@ class FeedViewModel(
 		hasNextPage
 	) { list, isHasNextPage ->
 		buildList(list.size + 2) {
-			add(header)
 			if (list.isEmpty()) {
+				add(header)
 				add(
 					EmptyState(
 						icon = R.drawable.ic_feed,
@@ -45,7 +46,7 @@ class FeedViewModel(
 					)
 				)
 			} else {
-				list.mapTo(this) { it.toFeedItem() }
+				list.mapListTo(this)
 				if (isHasNextPage) {
 					add(LoadingFooter)
 				}
@@ -85,4 +86,29 @@ class FeedViewModel(
 			onFeedCleared.postCall(Unit)
 		}
 	}
+
+	private fun List<TrackingLogItem>.mapListTo(destination: MutableList<ListModel>) {
+		var prevDate: DateTimeAgo? = null
+		for (item in this) {
+			val date = timeAgo(item.createdAt)
+			if (prevDate != date) {
+				destination += date
+			}
+			prevDate = date
+			destination += item.toFeedItem()
+		}
+	}
+
+	private fun timeAgo(date: Date): DateTimeAgo {
+		val diff = (System.currentTimeMillis() - date.time).coerceAtLeast(0L)
+		val diffMinutes = TimeUnit.MILLISECONDS.toMinutes(diff).toInt()
+		val diffDays = -date.daysDiff(System.currentTimeMillis())
+		return when {
+			diffMinutes < 3 -> DateTimeAgo.JustNow
+			diffDays < 1 -> DateTimeAgo.Today
+			diffDays == 1 -> DateTimeAgo.Yesterday
+			diffDays < 6 -> DateTimeAgo.DaysAgo(diffDays)
+			else -> DateTimeAgo.Absolute(date)
+		}
+	}
 }

app/src/main/java/org/koitharu/kotatsu/tracker/ui/adapter/FeedAdapter.kt

@@ -4,10 +4,11 @@ import androidx.lifecycle.LifecycleOwner
 import androidx.recyclerview.widget.DiffUtil
 import coil.ImageLoader
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
-import kotlin.jvm.internal.Intrinsics
+import org.koitharu.kotatsu.core.ui.DateTimeAgo
 import org.koitharu.kotatsu.list.ui.adapter.*
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.tracker.ui.model.FeedItem
+import kotlin.jvm.internal.Intrinsics
 
 class FeedAdapter(
 	coil: ImageLoader,
@@ -24,6 +25,7 @@ class FeedAdapter(
 			.addDelegate(ITEM_TYPE_ERROR_STATE, errorStateListAD(listener))
 			.addDelegate(ITEM_TYPE_EMPTY, emptyStateListAD(listener))
 			.addDelegate(ITEM_TYPE_HEADER, listHeaderAD())
+			.addDelegate(ITEM_TYPE_DATE_HEADER, relatedDateItemAD())
 	}
 
 	private class DiffCallback : DiffUtil.ItemCallback<ListModel>() {
@@ -32,6 +34,9 @@ class FeedAdapter(
 			oldItem is FeedItem && newItem is FeedItem -> {
 				oldItem.id == newItem.id
 			}
+			oldItem is DateTimeAgo && newItem is DateTimeAgo -> {
+				oldItem == newItem
+			}
 			else -> oldItem.javaClass == newItem.javaClass
 		}
 
@@ -49,5 +54,6 @@ class FeedAdapter(
 		const val ITEM_TYPE_ERROR_FOOTER = 4
 		const val ITEM_TYPE_EMPTY = 5
 		const val ITEM_TYPE_HEADER = 6
+		const val ITEM_TYPE_DATE_HEADER = 7
 	}
 }

app/src/main/java/org/koitharu/kotatsu/tracker/ui/adapter/FeedItemAD.kt

@@ -6,20 +6,19 @@ import coil.request.Disposable
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
-import org.koitharu.kotatsu.databinding.ItemTracklogBinding
+import org.koitharu.kotatsu.databinding.ItemFeedBinding
 import org.koitharu.kotatsu.list.ui.model.ListModel
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.tracker.ui.model.FeedItem
 import org.koitharu.kotatsu.utils.ext.enqueueWith
 import org.koitharu.kotatsu.utils.ext.newImageRequest
-import org.koitharu.kotatsu.utils.ext.textAndVisible
 
 fun feedItemAD(
 	coil: ImageLoader,
 	lifecycleOwner: LifecycleOwner,
 	clickListener: OnListItemClickListener<Manga>
-) = adapterDelegateViewBinding<FeedItem, ListModel, ItemTracklogBinding>(
-	{ inflater, parent -> ItemTracklogBinding.inflate(inflater, parent, false) }
+) = adapterDelegateViewBinding<FeedItem, ListModel, ItemFeedBinding>(
+	{ inflater, parent -> ItemFeedBinding.inflate(inflater, parent, false) }
 ) {
 
 	var imageRequest: Disposable? = null
@@ -38,13 +37,11 @@ fun feedItemAD(
 			.lifecycle(lifecycleOwner)
 			.enqueueWith(coil)
 		binding.textViewTitle.text = item.title
-		binding.badge.text = item.subtitle
-		binding.textViewChapters.text = item.chapters
-		binding.textViewTruncated.textAndVisible = if (item.truncated > 0) {
-			getString(R.string._and_x_more, item.truncated)
-		} else {
-			null
-		}
+		binding.textViewSummary.text = context.resources.getQuantityString(
+			R.plurals.new_chapters,
+			item.count,
+			item.count,
+		)
 	}
 
 	onViewRecycled {

app/src/main/java/org/koitharu/kotatsu/tracker/ui/model/FeedItem.kt

@@ -7,8 +7,6 @@ data class FeedItem(
 	val id: Long,
 	val imageUrl: String,
 	val title: String,
-	val subtitle: String,
-	val chapters: CharSequence,
 	val manga: Manga,
-	val truncated: Int,
+	val count: Int,
 ) : ListModel

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

@@ -2,26 +2,10 @@ package org.koitharu.kotatsu.tracker.ui.model
 
 import org.koitharu.kotatsu.core.model.TrackingLogItem
 
-fun TrackingLogItem.toFeedItem(): FeedItem {
-	val truncate = chapters.size > MAX_CHAPTERS
-	val chaptersString = if (truncate) {
-		chapters.joinToString(
-			separator = "\n",
-			limit = MAX_CHAPTERS - 1,
-			truncated = "",
-		).trimEnd()
-	} else {
-		chapters.joinToString("\n")
-	}
-	return FeedItem(
-		id = id,
-		imageUrl = manga.coverUrl,
-		title = manga.title,
-		subtitle = chapters.size.toString(),
-		chapters = chaptersString,
-		manga = manga,
-		truncated = chapters.size - MAX_CHAPTERS + 1,
-	)
-}
-
-private const val MAX_CHAPTERS = 6
+fun TrackingLogItem.toFeedItem() = FeedItem(
+	id = id,
+	imageUrl = manga.coverUrl,
+	title = manga.title,
+	count = chapters.size,
+	manga = manga,
+)

app/src/main/java/org/koitharu/kotatsu/utils/BottomSheetToolbarController.kt

@@ -2,8 +2,8 @@ package org.koitharu.kotatsu.utils
 
 import android.view.View
 import androidx.appcompat.widget.Toolbar
-import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.R as materialR
+import com.google.android.material.bottomsheet.BottomSheetBehavior
 
 open class BottomSheetToolbarController(
 	protected val toolbar: Toolbar,
@@ -17,7 +17,5 @@ open class BottomSheetToolbarController(
 		}
 	}
 
-	override fun onSlide(bottomSheet: View, slideOffset: Float) {
-
-	}
+	override fun onSlide(bottomSheet: View, slideOffset: Float) = Unit
 }

app/src/main/java/org/koitharu/kotatsu/utils/FileSize.kt

@@ -32,4 +32,4 @@ enum class FileSize(private val multiplier: Int) {
 			}
 		}
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/utils/GridTouchHelper.kt

@@ -5,8 +5,10 @@ import android.view.GestureDetector
 import android.view.MotionEvent
 import kotlin.math.roundToInt
 
-class GridTouchHelper(context: Context, private val listener: OnGridTouchListener) :
-	GestureDetector.SimpleOnGestureListener() {
+class GridTouchHelper(
+	context: Context,
+	private val listener: OnGridTouchListener
+) : GestureDetector.SimpleOnGestureListener() {
 
 	private val detector = GestureDetector(context, this)
 	private val width = context.resources.displayMetrics.widthPixels

app/src/main/java/org/koitharu/kotatsu/utils/MutableZipFile.kt

@@ -1,103 +0,0 @@
-package org.koitharu.kotatsu.utils
-
-import androidx.annotation.WorkerThread
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runInterruptible
-import kotlinx.coroutines.withContext
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-import java.util.zip.ZipEntry
-import java.util.zip.ZipInputStream
-import java.util.zip.ZipOutputStream
-
-open class MutableZipFile(val file: File) {
-
-	protected val dir = File(file.parentFile, file.nameWithoutExtension)
-
-	suspend fun unpack(): Unit = runInterruptible(Dispatchers.IO) {
-		check(dir.list().isNullOrEmpty()) {
-			"Dir ${dir.name} is not empty"
-		}
-		if (!dir.exists()) {
-			dir.mkdir()
-		}
-		if (!file.exists()) {
-			return@runInterruptible
-		}
-		ZipInputStream(FileInputStream(file)).use { zip ->
-			var entry = zip.nextEntry
-			while (entry != null) {
-				val target = File(dir.path + File.separator + entry.name)
-				target.parentFile?.mkdirs()
-				target.outputStream().use { out ->
-					zip.copyTo(out)
-				}
-				zip.closeEntry()
-				entry = zip.nextEntry
-			}
-		}
-	}
-
-	suspend fun cleanup() = withContext(Dispatchers.IO) {
-		dir.deleteRecursively()
-	}
-
-	suspend fun flush(): Boolean = runInterruptible(Dispatchers.IO) {
-		val tempFile = File(file.path + ".tmp")
-		if (tempFile.exists()) {
-			tempFile.delete()
-		}
-		try {
-			ZipOutputStream(FileOutputStream(tempFile)).use { zip ->
-				dir.listFiles()?.forEach {
-					zipFile(it, it.name, zip)
-				}
-				zip.flush()
-			}
-			tempFile.renameTo(file)
-		} finally {
-			if (tempFile.exists()) {
-				tempFile.delete()
-			}
-		}
-	}
-
-	operator fun get(name: String) = File(dir, name)
-
-	suspend fun put(name: String, file: File): Unit = withContext(Dispatchers.IO) {
-		file.copyTo(this@MutableZipFile[name], overwrite = true)
-	}
-
-	suspend fun put(name: String, data: String): Unit = withContext(Dispatchers.IO) {
-		this@MutableZipFile[name].writeText(data)
-	}
-
-	suspend fun getContent(name: String): String = withContext(Dispatchers.IO) {
-		get(name).readText()
-	}
-
-	companion object {
-
-		@WorkerThread
-		private fun zipFile(fileToZip: File, fileName: String, zipOut: ZipOutputStream) {
-			if (fileToZip.isDirectory) {
-				if (fileName.endsWith("/")) {
-					zipOut.putNextEntry(ZipEntry(fileName))
-				} else {
-					zipOut.putNextEntry(ZipEntry("$fileName/"))
-				}
-				zipOut.closeEntry()
-				fileToZip.listFiles()?.forEach { childFile ->
-					zipFile(childFile, "$fileName/${childFile.name}", zipOut)
-				}
-			} else {
-				FileInputStream(fileToZip).use { fis ->
-					val zipEntry = ZipEntry(fileName)
-					zipOut.putNextEntry(zipEntry)
-					fis.copyTo(zipOut)
-				}
-			}
-		}
-	}
-}

app/src/main/java/org/koitharu/kotatsu/utils/PausingDispatcher.kt

@@ -0,0 +1,50 @@
+package org.koitharu.kotatsu.utils
+
+import androidx.annotation.MainThread
+import java.util.concurrent.ConcurrentLinkedQueue
+import kotlin.coroutines.CoroutineContext
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Runnable
+
+class PausingDispatcher(
+	private val dispatcher: CoroutineDispatcher,
+) : CoroutineDispatcher() {
+
+	@Volatile
+	private var isPaused = false
+	private val queue = ConcurrentLinkedQueue<Task>()
+
+	override fun isDispatchNeeded(context: CoroutineContext): Boolean {
+		return isPaused || super.isDispatchNeeded(context)
+	}
+
+	override fun dispatch(context: CoroutineContext, block: Runnable) {
+		if (isPaused) {
+			queue.add(Task(context, block))
+		} else {
+			dispatcher.dispatch(context, block)
+		}
+	}
+
+	@MainThread
+	fun pause() {
+		isPaused = true
+	}
+
+	@MainThread
+	fun resume() {
+		if (!isPaused) {
+			return
+		}
+		isPaused = false
+		while (true) {
+			val task = queue.poll() ?: break
+			dispatcher.dispatch(task.context, task.block)
+		}
+	}
+
+	private class Task(
+		val context: CoroutineContext,
+		val block: Runnable,
+	)
+}

app/src/main/java/org/koitharu/kotatsu/utils/SelectionController.kt

@@ -1,10 +0,0 @@
-package org.koitharu.kotatsu.utils
-
-import kotlinx.coroutines.flow.MutableStateFlow
-
-class SelectionController {
-
-	private val state = MutableStateFlow(emptySet<Int>())
-
-
-}

app/src/main/java/org/koitharu/kotatsu/utils/WordSet.kt

@@ -1,9 +0,0 @@
-package org.koitharu.kotatsu.utils
-
-class WordSet(private vararg val words: String) {
-
-	fun anyWordIn(dateString: String): Boolean = words.any {
-		dateString.contains(it, ignoreCase = true)
-	}
-
-}

app/src/main/java/org/koitharu/kotatsu/utils/ext/AndroidExt.kt

@@ -5,6 +5,7 @@ import android.net.ConnectivityManager
 import android.net.Network
 import android.net.NetworkRequest
 import android.net.Uri
+import android.os.Build
 import androidx.work.CoroutineWorker
 import kotlin.coroutines.resume
 import kotlinx.coroutines.suspendCancellableCoroutine
@@ -14,9 +15,14 @@ val Context.connectivityManager: ConnectivityManager
 
 suspend fun ConnectivityManager.waitForNetwork(): Network {
 	val request = NetworkRequest.Builder().build()
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+		// fast path
+		activeNetwork?.let { return it }
+	}
 	return suspendCancellableCoroutine { cont ->
 		val callback = object : ConnectivityManager.NetworkCallback() {
 			override fun onAvailable(network: Network) {
+				unregisterNetworkCallback(this)
 				if (cont.isActive) {
 					cont.resume(network)
 				}

app/src/main/java/org/koitharu/kotatsu/utils/ext/CollectionExt.kt

@@ -3,8 +3,6 @@ package org.koitharu.kotatsu.utils.ext
 import androidx.collection.ArraySet
 import java.util.*
 
-fun LongArray.toArraySet(): Set<Long> = createSet(size) { i -> this[i] }
-
 fun <T : Enum<T>> Array<T>.names() = Array(size) { i ->
 	this[i].name
 }

app/src/main/java/org/koitharu/kotatsu/utils/ext/CommonExt.kt

@@ -1,16 +1,14 @@
 package org.koitharu.kotatsu.utils.ext
 
 import android.content.res.Resources
-import android.util.Log
-import java.io.FileNotFoundException
-import java.net.SocketTimeoutException
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
 import org.koitharu.kotatsu.core.exceptions.EmptyHistoryException
 import org.koitharu.kotatsu.core.exceptions.UnsupportedFileException
 import org.koitharu.kotatsu.core.exceptions.WrongPasswordException
 import org.koitharu.kotatsu.parsers.exception.AuthRequiredException
-import org.koitharu.kotatsu.parsers.util.format
+import java.io.FileNotFoundException
+import java.net.SocketTimeoutException
 
 fun Throwable.getDisplayMessage(resources: Resources) = when (this) {
 	is AuthRequiredException -> resources.getString(R.string.auth_required)
@@ -22,12 +20,4 @@ fun Throwable.getDisplayMessage(resources: Resources) = when (this) {
 	is SocketTimeoutException -> resources.getString(R.string.network_error)
 	is WrongPasswordException -> resources.getString(R.string.wrong_password)
 	else -> localizedMessage ?: resources.getString(R.string.error_occurred)
-}
-
-inline fun <T> measured(tag: String, block: () -> T): T {
-	val time = System.currentTimeMillis()
-	val res = block()
-	val spent = System.currentTimeMillis() - time
-	Log.d("measured", "$tag ${spent.format(1)} ms")
-	return res
 }

app/src/main/java/org/koitharu/kotatsu/utils/ext/CoroutineExt.kt

@@ -3,10 +3,8 @@ package org.koitharu.kotatsu.utils.ext
 import androidx.lifecycle.LifecycleCoroutineScope
 import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.lifecycle.lifecycleScope
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineExceptionHandler
 import org.koitharu.kotatsu.BuildConfig
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
 
 val IgnoreErrors
 	get() = CoroutineExceptionHandler { _, e ->