Merge branch 'devel' into feature/sync

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

@@ -5,6 +5,7 @@ import android.os.Parcel
 import android.os.Parcelable
 import android.os.Parcelable.Creator
 import android.util.AttributeSet
+import android.view.View
 import android.widget.Checkable
 import androidx.annotation.AttrRes
 import androidx.appcompat.widget.AppCompatImageView
@@ -61,6 +62,12 @@ class CheckableImageView @JvmOverloads constructor(
 		}
 	}
 
+	class ToggleOnClickListener : OnClickListener {
+		override fun onClick(view: View) {
+			(view as? Checkable)?.toggle()
+		}
+	}
+
 	fun interface OnCheckedChangeListener {
 
 		fun onCheckedChanged(view: CheckableImageView, isChecked: Boolean)

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

@@ -11,10 +11,6 @@ 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
@@ -24,6 +20,10 @@ 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) {
 
@@ -67,6 +67,10 @@ class AppSettings(context: Context) {
 		get() = prefs.getBoolean(KEY_TRAFFIC_WARNING, true)
 		set(value) = prefs.edit { putBoolean(KEY_TRAFFIC_WARNING, value) }
 
+	var isAllFavouritesVisible: Boolean
+		get() = prefs.getBoolean(KEY_ALL_FAVOURITES_VISIBLE, true)
+		set(value) = prefs.edit { putBoolean(KEY_ALL_FAVOURITES_VISIBLE, value) }
+
 	val isUpdateCheckingEnabled: Boolean
 		get() = prefs.getBoolean(KEY_APP_UPDATE_AUTO, true)
 
@@ -130,6 +134,20 @@ class AppSettings(context: Context) {
 	val isSourcesSelected: Boolean
 		get() = KEY_SOURCES_HIDDEN in prefs
 
+	val newSources: Set<MangaSource>
+		get() {
+			val known = sourcesOrder.toSet()
+			val hidden = hiddenSources
+			return remoteMangaSources
+				.filterNotTo(EnumSet.noneOf(MangaSource::class.java)) { x ->
+					x.name in known || x.name in hidden
+				}
+		}
+
+	fun markKnownSources(sources: Collection<MangaSource>) {
+		sourcesOrder = sourcesOrder + sources.map { it.name }
+	}
+
 	val isPagesNumbersEnabled: Boolean
 		get() = prefs.getBoolean(KEY_PAGES_NUMBERS, false)
 
@@ -278,6 +296,7 @@ class AppSettings(context: Context) {
 		const val KEY_SEARCH_SINGLE_SOURCE = "search_single_source"
 		const val KEY_DOWNLOADS_PARALLELISM = "downloads_parallelism"
 		const val KEY_DOWNLOADS_SLOWDOWN = "downloads_slowdown"
+		const val KEY_ALL_FAVOURITES_VISIBLE = "all_favourites_visible"
 
 		// About
 		const val KEY_APP_UPDATE = "app_update"

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

@@ -1,7 +1,6 @@
 package org.koitharu.kotatsu.download.domain
 
 import android.content.Context
-import android.graphics.drawable.Drawable
 import android.net.ConnectivityManager
 import android.webkit.MimeTypeMap
 import coil.ImageLoader
@@ -75,10 +74,12 @@ class DownloadManager(
 	): Job = coroutineScope.launch(Dispatchers.Default + errorStateHandler(outState)) {
 		@Suppress("NAME_SHADOWING") var manga = manga
 		val chaptersIdsSet = chaptersIds?.toMutableSet()
+		val cover = loadCover(manga)
+		outState.value = DownloadState.Queued(startId, manga, cover)
+		localMangaRepository.lockManga(manga.id)
 		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) }
 		val tempFileName = "${manga.id}_$startId.tmp"
@@ -88,16 +89,6 @@ class DownloadManager(
 				manga = localMangaRepository.getRemoteManga(manga) ?: error("Cannot obtain remote manga instance")
 			}
 			val repo = MangaRepository(manga.source)
-			cover = runCatching {
-				imageLoader.execute(
-					ImageRequest.Builder(context)
-						.data(manga.coverUrl)
-						.referer(manga.publicUrl)
-						.size(coverWidth, coverHeight)
-						.scale(Scale.FILL)
-						.build()
-				).drawable
-			}.getOrNull()
 			outState.value = DownloadState.Preparing(startId, manga, cover)
 			val data = if (manga.chapters.isNullOrEmpty()) repo.getDetails(manga) else manga
 			output = CbzMangaOutput.get(destination, data)
@@ -176,6 +167,7 @@ class DownloadManager(
 			}
 			coroutineContext[WakeLockNode]?.release()
 			semaphore.release()
+			localMangaRepository.unlockManga(manga.id)
 		}
 	}
 
@@ -208,6 +200,17 @@ class DownloadManager(
 			)
 		}
 
+	private suspend fun loadCover(manga: Manga) = runCatching {
+		imageLoader.execute(
+			ImageRequest.Builder(context)
+				.data(manga.coverUrl)
+				.referer(manga.publicUrl)
+				.size(coverWidth, coverHeight)
+				.scale(Scale.FILL)
+				.build()
+		).drawable
+	}.getOrNull()
+
 	class Factory(
 		private val context: Context,
 		private val imageLoader: ImageLoader,

app/src/main/java/org/koitharu/kotatsu/favourites/FavouritesModule.kt

@@ -15,7 +15,7 @@ val favouritesModule
 		viewModel { categoryId ->
 			FavouritesListViewModel(categoryId.get(), get(), get(), get())
 		}
-		viewModel { FavouritesCategoriesViewModel(get()) }
+		viewModel { FavouritesCategoriesViewModel(get(), get()) }
 		viewModel { manga ->
 			MangaCategoriesViewModel(manga.get(), get())
 		}

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

@@ -64,7 +64,7 @@ class FavouritesRepository(private val db: MangaDatabase) {
 			createdAt = System.currentTimeMillis(),
 			sortKey = db.favouriteCategoriesDao.getNextSortKey(),
 			categoryId = 0,
-			order = SortOrder.UPDATED.name,
+			order = SortOrder.NEWEST.name,
 		)
 		val id = db.favouriteCategoriesDao.insert(entity)
 		return entity.toFavouriteCategory(id)

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

@@ -21,12 +21,11 @@ import org.koitharu.kotatsu.databinding.FragmentFavouritesBinding
 import org.koitharu.kotatsu.favourites.ui.categories.CategoriesActivity
 import org.koitharu.kotatsu.favourites.ui.categories.CategoriesEditDelegate
 import org.koitharu.kotatsu.favourites.ui.categories.FavouritesCategoriesViewModel
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.CategoryListModel
 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.resolveDp
-import java.util.*
 
 class FavouritesContainerFragment :
 	BaseFragment<FragmentFavouritesBinding>(),
@@ -53,15 +52,15 @@ class FavouritesContainerFragment :
 	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 		super.onViewCreated(view, savedInstanceState)
 		val adapter = FavouritesPagerAdapter(this, this)
-		viewModel.categories.value?.let {
-			adapter.replaceData(wrapCategories(it))
+		viewModel.visibleCategories.value?.let {
+			adapter.replaceData(it)
 		}
 		binding.pager.adapter = adapter
 		pagerAdapter = adapter
 		TabLayoutMediator(binding.tabs, binding.pager, adapter).attach()
 		actionModeDelegate.addListener(this, viewLifecycleOwner)
 
-		viewModel.categories.observe(viewLifecycleOwner, ::onCategoriesChanged)
+		viewModel.visibleCategories.observe(viewLifecycleOwner, ::onCategoriesChanged)
 		viewModel.onError.observe(viewLifecycleOwner, ::onError)
 	}
 
@@ -86,7 +85,8 @@ class FavouritesContainerFragment :
 			top = headerHeight - insets.top
 		)
 		binding.pager.updatePadding(
-			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)
+			// 8 dp is needed so that the top of the list is not attached to tabs (visible when ActionMode is active)
+			top = -headerHeight + resources.resolveDp(8)
 		)
 		binding.tabs.apply {
 			updatePadding(
@@ -99,8 +99,8 @@ class FavouritesContainerFragment :
 		}
 	}
 
-	private fun onCategoriesChanged(categories: List<FavouriteCategory>) {
-		pagerAdapter?.replaceData(wrapCategories(categories))
+	private fun onCategoriesChanged(categories: List<CategoryListModel>) {
+		pagerAdapter?.replaceData(categories)
 	}
 
 	override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
@@ -122,26 +122,11 @@ class FavouritesContainerFragment :
 		Snackbar.make(binding.pager, e.getDisplayMessage(resources), Snackbar.LENGTH_LONG).show()
 	}
 
-	override fun onTabLongClick(tabView: View, category: FavouriteCategory): Boolean {
-		val menuRes = if (category.id == 0L) R.menu.popup_category_empty else R.menu.popup_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@setOnMenuItemClickListener false
-				else -> {
-					val order = CategoriesActivity.SORT_ORDERS.getOrNull(it.order)
-						?: return@setOnMenuItemClickListener false
-					viewModel.setCategoryOrder(category.id, order)
-				}
-			}
-			true
+	override fun onTabLongClick(tabView: View, item: CategoryListModel): Boolean {
+		when (item) {
+			is CategoryListModel.All -> showAllCategoriesMenu(tabView)
+			is CategoryListModel.CategoryItem -> showCategoryMenu(tabView, item.category)
 		}
-		menu.show()
 		return true
 	}
 
@@ -157,13 +142,6 @@ class FavouritesContainerFragment :
 		viewModel.createCategory(name)
 	}
 
-	private fun wrapCategories(categories: List<FavouriteCategory>): List<FavouriteCategory> {
-		val data = ArrayList<FavouriteCategory>(categories.size + 1)
-		data += FavouriteCategory(0L, getString(R.string.all_favourites), -1, SortOrder.NEWEST, Date())
-		data += categories
-		return data
-	}
-
 	private fun createOrderSubmenu(menu: Menu, category: FavouriteCategory) {
 		val submenu = menu.findItem(R.id.action_order)?.subMenu ?: return
 		for ((i, item) in CategoriesActivity.SORT_ORDERS.withIndex()) {
@@ -181,6 +159,40 @@ class FavouritesContainerFragment :
 		}
 	}
 
+	private fun showCategoryMenu(tabView: View, category: FavouriteCategory) {
+		val menu = PopupMenu(tabView.context, tabView)
+		menu.inflate(R.menu.popup_category)
+		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@setOnMenuItemClickListener false
+				else -> {
+					val order = CategoriesActivity.SORT_ORDERS.getOrNull(it.order)
+						?: return@setOnMenuItemClickListener false
+					viewModel.setCategoryOrder(category.id, order)
+				}
+			}
+			true
+		}
+		menu.show()
+	}
+
+	private fun showAllCategoriesMenu(tabView: View) {
+		val menu = PopupMenu(tabView.context, tabView)
+		menu.inflate(R.menu.popup_category_all)
+		menu.setOnMenuItemClickListener {
+			when (it.itemId) {
+				R.id.action_create -> editDelegate.createCategory()
+				R.id.action_hide -> viewModel.setAllCategoriesVisible(false)
+			}
+			true
+		}
+		menu.show()
+	}
+
 	companion object {
 
 		fun newInstance() = FavouritesContainerFragment()

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

@@ -7,14 +7,16 @@ import androidx.recyclerview.widget.DiffUtil
 import androidx.viewpager2.adapter.FragmentStateAdapter
 import com.google.android.material.tabs.TabLayout
 import com.google.android.material.tabs.TabLayoutMediator
-import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.CategoryListModel
 import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment
 
 class FavouritesPagerAdapter(
 	fragment: Fragment,
 	private val longClickListener: FavouritesTabLongClickListener
 ) : FragmentStateAdapter(fragment.childFragmentManager, fragment.viewLifecycleOwner.lifecycle),
-	TabLayoutMediator.TabConfigurationStrategy, View.OnLongClickListener {
+	TabLayoutMediator.TabConfigurationStrategy,
+	View.OnLongClickListener {
 
 	private val differ = AsyncListDiffer(this, DiffCallback())
 
@@ -35,12 +37,15 @@ class FavouritesPagerAdapter(
 
 	override fun onConfigureTab(tab: TabLayout.Tab, position: Int) {
 		val item = differ.currentList[position]
-		tab.text = item.title
+		tab.text = when (item) {
+			is CategoryListModel.All -> tab.view.context.getString(R.string.all_favourites)
+			is CategoryListModel.CategoryItem -> item.category.title
+		}
 		tab.view.tag = item.id
 		tab.view.setOnLongClickListener(this)
 	}
 
-	fun replaceData(data: List<FavouriteCategory>) {
+	fun replaceData(data: List<CategoryListModel>) {
 		differ.submitList(data)
 	}
 
@@ -50,16 +55,22 @@ class FavouritesPagerAdapter(
 		return longClickListener.onTabLongClick(v, item)
 	}
 
-	private class DiffCallback : DiffUtil.ItemCallback<FavouriteCategory>() {
+	private class DiffCallback : DiffUtil.ItemCallback<CategoryListModel>() {
 
 		override fun areItemsTheSame(
-			oldItem: FavouriteCategory,
-			newItem: FavouriteCategory
-		): Boolean = oldItem.id == newItem.id
+			oldItem: CategoryListModel,
+			newItem: CategoryListModel
+		): Boolean = when {
+			oldItem is CategoryListModel.All && newItem is CategoryListModel.All -> true
+			oldItem is CategoryListModel.CategoryItem && newItem is CategoryListModel.CategoryItem -> {
+				oldItem.category.id == newItem.category.id
+			}
+			else -> false
+		}
 
 		override fun areContentsTheSame(
-			oldItem: FavouriteCategory,
-			newItem: FavouriteCategory
-		): Boolean = oldItem.id == newItem.id && oldItem.title == newItem.title
+			oldItem: CategoryListModel,
+			newItem: CategoryListModel
+		): Boolean = oldItem == newItem
 	}
 }

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

@@ -1,9 +1,9 @@
 package org.koitharu.kotatsu.favourites.ui
 
 import android.view.View
-import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.CategoryListModel
 
 fun interface FavouritesTabLongClickListener {
 
-	fun onTabLongClick(tabView: View, category: FavouriteCategory): Boolean
+	fun onTabLongClick(tabView: View, item: CategoryListModel): Boolean
 }

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

@@ -0,0 +1,6 @@
+package org.koitharu.kotatsu.favourites.ui.categories
+
+interface AllCategoriesToggleListener {
+
+	fun onAllCategoriesToggle(isVisible: Boolean)
+}

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

@@ -21,6 +21,7 @@ import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.model.FavouriteCategory
 import org.koitharu.kotatsu.core.ui.titleRes
 import org.koitharu.kotatsu.databinding.ActivityCategoriesBinding
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.CategoryListModel
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.utils.ext.getDisplayMessage
 import org.koitharu.kotatsu.utils.ext.measureHeight
@@ -29,7 +30,7 @@ class CategoriesActivity :
 	BaseActivity<ActivityCategoriesBinding>(),
 	OnListItemClickListener<FavouriteCategory>,
 	View.OnClickListener,
-	CategoriesEditDelegate.CategoriesEditCallback {
+	CategoriesEditDelegate.CategoriesEditCallback, AllCategoriesToggleListener {
 
 	private val viewModel by viewModel<FavouritesCategoriesViewModel>()
 
@@ -41,7 +42,7 @@ class CategoriesActivity :
 		super.onCreate(savedInstanceState)
 		setContentView(ActivityCategoriesBinding.inflate(layoutInflater))
 		supportActionBar?.setDisplayHomeAsUpEnabled(true)
-		adapter = CategoriesAdapter(this)
+		adapter = CategoriesAdapter(this, this)
 		editDelegate = CategoriesEditDelegate(this, this)
 		binding.recyclerView.setHasFixedSize(true)
 		binding.recyclerView.adapter = adapter
@@ -49,7 +50,7 @@ class CategoriesActivity :
 		reorderHelper = ItemTouchHelper(ReorderHelperCallback())
 		reorderHelper.attachToRecyclerView(binding.recyclerView)
 
-		viewModel.categories.observe(this, ::onCategoriesChanged)
+		viewModel.allCategories.observe(this, ::onCategoriesChanged)
 		viewModel.onError.observe(this, ::onError)
 	}
 
@@ -84,6 +85,10 @@ class CategoriesActivity :
 		return true
 	}
 
+	override fun onAllCategoriesToggle(isVisible: Boolean) {
+		viewModel.setAllCategoriesVisible(isVisible)
+	}
+
 	override fun onWindowInsetsChanged(insets: Insets) {
 		binding.fabAdd.updateLayoutParams<ViewGroup.MarginLayoutParams> {
 			rightMargin = topMargin + insets.right
@@ -97,7 +102,7 @@ class CategoriesActivity :
 		)
 	}
 
-	private fun onCategoriesChanged(categories: List<FavouriteCategory>) {
+	private fun onCategoriesChanged(categories: List<CategoryListModel>) {
 		adapter.items = categories
 		binding.textViewHolder.isVisible = categories.isEmpty()
 	}
@@ -138,13 +143,19 @@ class CategoriesActivity :
 		ItemTouchHelper.DOWN or ItemTouchHelper.UP, 0
 	) {
 
+		override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) = Unit
+
 		override fun onMove(
 			recyclerView: RecyclerView,
 			viewHolder: RecyclerView.ViewHolder,
 			target: RecyclerView.ViewHolder,
-		): Boolean = true
+		): Boolean = viewHolder.itemViewType == target.itemViewType
 
-		override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) = Unit
+		override fun canDropOver(
+			recyclerView: RecyclerView,
+			current: RecyclerView.ViewHolder,
+			target: RecyclerView.ViewHolder,
+		): Boolean = current.itemViewType == target.itemViewType
 
 		override fun onMoved(
 			recyclerView: RecyclerView,
@@ -158,6 +169,8 @@ class CategoriesActivity :
 			super.onMoved(recyclerView, viewHolder, fromPos, target, toPos, x, y)
 			viewModel.reorderCategories(fromPos, toPos)
 		}
+
+		override fun isLongPressDragEnabled(): Boolean = false
 	}
 
 	companion object {

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

@@ -4,13 +4,18 @@ import androidx.recyclerview.widget.DiffUtil
 import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
 import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.CategoryListModel
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.allCategoriesAD
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.categoryAD
 
 class CategoriesAdapter(
 	onItemClickListener: OnListItemClickListener<FavouriteCategory>,
-) : AsyncListDifferDelegationAdapter<FavouriteCategory>(DiffCallback()) {
+	allCategoriesToggleListener: AllCategoriesToggleListener,
+) : AsyncListDifferDelegationAdapter<CategoryListModel>(DiffCallback()) {
 
 	init {
 		delegatesManager.addDelegate(categoryAD(onItemClickListener))
+			.addDelegate(allCategoriesAD(allCategoriesToggleListener))
 		setHasStableIds(true)
 	}
 
@@ -18,28 +23,23 @@ class CategoriesAdapter(
 		return items[position].id
 	}
 
-	private class DiffCallback : DiffUtil.ItemCallback<FavouriteCategory>() {
+	private class DiffCallback : DiffUtil.ItemCallback<CategoryListModel>() {
 
 		override fun areItemsTheSame(
-			oldItem: FavouriteCategory,
-			newItem: FavouriteCategory,
-		): Boolean {
-			return oldItem.id == newItem.id
-		}
+			oldItem: CategoryListModel,
+			newItem: CategoryListModel,
+		): Boolean = oldItem.id == newItem.id
 
 		override fun areContentsTheSame(
-			oldItem: FavouriteCategory,
-			newItem: FavouriteCategory,
-		): Boolean {
-			return oldItem.id == newItem.id && oldItem.title == newItem.title
-					&& oldItem.order == newItem.order
-		}
+			oldItem: CategoryListModel,
+			newItem: CategoryListModel,
+		): Boolean = oldItem == newItem
 
 		override fun getChangePayload(
-			oldItem: FavouriteCategory,
-			newItem: FavouriteCategory,
+			oldItem: CategoryListModel,
+			newItem: CategoryListModel,
 		): Any? = when {
-			oldItem.title == newItem.title && oldItem.order != newItem.order -> newItem.order
+			oldItem is CategoryListModel.All && newItem is CategoryListModel.All -> Unit
 			else -> super.getChangePayload(oldItem, newItem)
 		}
 	}

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

@@ -3,20 +3,36 @@ package org.koitharu.kotatsu.favourites.ui.categories
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.*
 import org.koitharu.kotatsu.base.ui.BaseViewModel
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.CategoryListModel
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
 import java.util.*
 
 class FavouritesCategoriesViewModel(
-	private val repository: FavouritesRepository
+	private val repository: FavouritesRepository,
+	private val settings: AppSettings,
 ) : BaseViewModel() {
 
 	private var reorderJob: Job? = null
 
-	val categories = repository.observeCategories()
-		.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
+	val allCategories = combine(
+		repository.observeCategories(),
+		observeAllCategoriesVisible(),
+	) { list, showAll ->
+		mapCategories(list, showAll, true)
+	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
+	
+	val visibleCategories = combine(
+		repository.observeCategories(),
+		observeAllCategoriesVisible(),
+	) { list, showAll ->
+		mapCategories(list, showAll, showAll)
+	}.asLiveDataDistinct(viewModelScope.coroutineContext + Dispatchers.Default)
 
 	fun createCategory(name: String) {
 		launchJob {
@@ -42,14 +58,40 @@ class FavouritesCategoriesViewModel(
 		}
 	}
 
+	fun setAllCategoriesVisible(isVisible: Boolean) {
+		settings.isAllFavouritesVisible = isVisible
+	}
+
 	fun reorderCategories(oldPos: Int, newPos: Int) {
 		val prevJob = reorderJob
 		reorderJob = launchJob(Dispatchers.Default) {
 			prevJob?.join()
-			val items = categories.value ?: error("This should not happen")
+			val items = allCategories.value ?: error("This should not happen")
 			val ids = items.mapTo(ArrayList(items.size)) { it.id }
 			Collections.swap(ids, oldPos, newPos)
+			ids.remove(0L)
 			repository.reorderCategories(ids)
 		}
 	}
+
+	private fun mapCategories(
+		categories: List<FavouriteCategory>,
+		isAllCategoriesVisible: Boolean,
+		withAllCategoriesItem: Boolean,
+	): List<CategoryListModel> {
+		val result = ArrayList<CategoryListModel>(categories.size + 1)
+		if (withAllCategoriesItem) {
+			result.add(CategoryListModel.All(isAllCategoriesVisible))
+		}
+		categories.mapTo(result) {
+			CategoryListModel.CategoryItem(it)
+		}
+		return result
+	}
+
+	private fun observeAllCategoriesVisible() = settings.observe()
+		.filter { it == AppSettings.KEY_ALL_FAVOURITES_VISIBLE }
+		.map { settings.isAllFavouritesVisible }
+		.onStart { emit(settings.isAllFavouritesVisible) }
+		.distinctUntilChanged()
 }

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

@@ -0,0 +1,20 @@
+package org.koitharu.kotatsu.favourites.ui.categories.adapter
+
+import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
+import org.koitharu.kotatsu.databinding.ItemCategoriesAllBinding
+import org.koitharu.kotatsu.favourites.ui.categories.AllCategoriesToggleListener
+
+fun allCategoriesAD(
+	allCategoriesToggleListener: AllCategoriesToggleListener,
+) = adapterDelegateViewBinding<CategoryListModel.All, CategoryListModel, ItemCategoriesAllBinding>(
+	{ inflater, parent -> ItemCategoriesAllBinding.inflate(inflater, parent, false) }
+) {
+
+	binding.imageViewToggle.setOnClickListener {
+		allCategoriesToggleListener.onAllCategoriesToggle(!item.isVisible)
+	}
+
+	bind {
+		binding.imageViewToggle.isChecked = item.isVisible
+	}
+}

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

@@ -1,4 +1,4 @@
-package org.koitharu.kotatsu.favourites.ui.categories
+package org.koitharu.kotatsu.favourites.ui.categories.adapter
 
 import android.view.MotionEvent
 import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
@@ -8,23 +8,23 @@ import org.koitharu.kotatsu.databinding.ItemCategoryBinding
 
 fun categoryAD(
 	clickListener: OnListItemClickListener<FavouriteCategory>
-) = adapterDelegateViewBinding<FavouriteCategory, FavouriteCategory, ItemCategoryBinding>(
+) = adapterDelegateViewBinding<CategoryListModel.CategoryItem, CategoryListModel, ItemCategoryBinding>(
 	{ inflater, parent -> ItemCategoryBinding.inflate(inflater, parent, false) }
 ) {
 
 	binding.imageViewMore.setOnClickListener {
-		clickListener.onItemClick(item, it)
+		clickListener.onItemClick(item.category, it)
 	}
 	@Suppress("ClickableViewAccessibility")
 	binding.imageViewHandle.setOnTouchListener { v, event ->
 		if (event.actionMasked == MotionEvent.ACTION_DOWN) {
-			clickListener.onItemLongClick(item, itemView)
+			clickListener.onItemLongClick(item.category, itemView)
 		} else {
 			false
 		}
 	}
 
 	bind {
-		binding.textViewTitle.text = item.title
+		binding.textViewTitle.text = item.category.title
 	}
 }

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

@@ -0,0 +1,59 @@
+package org.koitharu.kotatsu.favourites.ui.categories.adapter
+
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.list.ui.model.ListModel
+
+sealed interface CategoryListModel : ListModel {
+
+	val id: Long
+
+	class All(
+		val isVisible: Boolean,
+	) : CategoryListModel {
+
+		override val id: Long = 0L
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as All
+
+			if (isVisible != other.isVisible) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			return isVisible.hashCode()
+		}
+	}
+
+	class CategoryItem(
+		val category: FavouriteCategory,
+	) : CategoryListModel {
+
+		override val id: Long
+			get() = category.id
+
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (javaClass != other?.javaClass) return false
+
+			other as CategoryItem
+
+			if (category.id != other.category.id) return false
+			if (category.title != other.category.title) return false
+			if (category.order != other.category.order) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = category.id.hashCode()
+			result = 31 * result + category.title.hashCode()
+			result = 31 * result + category.order.hashCode()
+			return result
+		}
+	}
+}

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

@@ -7,7 +7,6 @@ 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
-import org.koitharu.kotatsu.utils.ExternalStorageHelper
 
 val localModule
 	get() = module {
@@ -15,8 +14,6 @@ val localModule
 		single { LocalStorageManager(androidContext(), get()) }
 		single { LocalMangaRepository(get()) }
 
-		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/LocalStorageManager.kt

@@ -4,6 +4,7 @@ import android.content.ContentResolver
 import android.content.Context
 import android.os.StatFs
 import androidx.annotation.WorkerThread
+import java.io.File
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.withContext
@@ -11,7 +12,6 @@ import okhttp3.Cache
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.utils.ext.computeSize
 import org.koitharu.kotatsu.utils.ext.getStorageName
-import java.io.File
 
 private const val DIR_NAME = "manga"
 private const val CACHE_DISK_PERCENTAGE = 0.02
@@ -71,7 +71,7 @@ class LocalStorageManager(
 	private fun getAvailableStorageDirs(): MutableSet<File> {
 		val result = LinkedHashSet<File>()
 		result += File(context.filesDir, DIR_NAME)
-		result += context.getExternalFilesDirs(DIR_NAME)
+		context.getExternalFilesDirs(DIR_NAME).filterNotNullTo(result)
 		result.retainAll { it.exists() || it.mkdirs() }
 		return result
 	}
@@ -87,8 +87,8 @@ class LocalStorageManager(
 	private fun getCacheDirs(subDir: String): MutableSet<File> {
 		val result = LinkedHashSet<File>()
 		result += File(context.cacheDir, subDir)
-		context.externalCacheDirs.mapTo(result) {
-			File(it, subDir)
+		context.externalCacheDirs.mapNotNullTo(result) {
+			File(it ?: return@mapNotNullTo null, subDir)
 		}
 		return result
 	}
@@ -110,4 +110,4 @@ class LocalStorageManager(
 	private fun File.isWriteable() = runCatching {
 		canWrite()
 	}.getOrDefault(false)
-}
+}

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

@@ -18,6 +18,7 @@ import org.koitharu.kotatsu.parsers.model.*
 import org.koitharu.kotatsu.parsers.util.longHashCode
 import org.koitharu.kotatsu.parsers.util.toCamelCase
 import org.koitharu.kotatsu.utils.AlphanumComparator
+import org.koitharu.kotatsu.utils.CompositeMutex
 import org.koitharu.kotatsu.utils.ext.deleteAwait
 import org.koitharu.kotatsu.utils.ext.readText
 import org.koitharu.kotatsu.utils.ext.resolveName
@@ -34,6 +35,7 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 
 	override val source = MangaSource.LOCAL
 	private val filenameFilter = CbzFilter()
+	private val locks = CompositeMutex<Long>()
 
 	override suspend fun getList(
 		offset: Int,
@@ -112,11 +114,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)
+	suspend fun deleteChapters(manga: Manga, ids: Set<Long>) {
+		lockManga(manga.id)
+		try {
+			runInterruptible(Dispatchers.IO) {
+				val uri = Uri.parse(manga.url)
+				val file = uri.toFile()
+				val cbz = CbzMangaOutput(file, manga)
+				CbzMangaOutput.filterChapters(cbz, ids)
+			}
+		} finally {
+			unlockManga(manga.id)
+		}
 	}
 
 	@WorkerThread
@@ -278,6 +287,14 @@ class LocalMangaRepository(private val storageManager: LocalStorageManager) : Ma
 		}
 	}
 
+	suspend fun lockManga(id: Long) {
+		locks.lock(id)
+	}
+
+	suspend fun unlockManga(id: Long) {
+		locks.unlock(id)
+	}
+
 	private suspend fun getAllFiles() = storageManager.getReadableDirs().flatMap { dir ->
 		dir.listFiles(filenameFilter)?.toList().orEmpty()
 	}

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

@@ -49,6 +49,7 @@ import org.koitharu.kotatsu.search.ui.suggestion.SearchSuggestionListener
 import org.koitharu.kotatsu.search.ui.suggestion.SearchSuggestionViewModel
 import org.koitharu.kotatsu.settings.AppUpdateChecker
 import org.koitharu.kotatsu.settings.SettingsActivity
+import org.koitharu.kotatsu.settings.newsources.NewSourcesDialogFragment
 import org.koitharu.kotatsu.settings.onboard.OnboardDialogFragment
 import org.koitharu.kotatsu.suggestions.ui.SuggestionsFragment
 import org.koitharu.kotatsu.suggestions.ui.SuggestionsWorker
@@ -390,10 +391,14 @@ class MainActivity :
 			if (AppUpdateChecker.isUpdateSupported(this@MainActivity)) {
 				AppUpdateChecker(this@MainActivity).checkIfNeeded()
 			}
-			if (!get<AppSettings>().isSourcesSelected) {
-				withContext(Dispatchers.Main) {
+			val settings = get<AppSettings>()
+			when {
+				!settings.isSourcesSelected -> withContext(Dispatchers.Main) {
 					OnboardDialogFragment.showWelcome(supportFragmentManager)
 				}
+				settings.newSources.isNotEmpty() -> withContext(Dispatchers.Main) {
+					NewSourcesDialogFragment.show(supportFragmentManager)
+				}
 			}
 		}
 	}

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

@@ -1,9 +1,11 @@
 package org.koitharu.kotatsu.reader
 
+import org.koin.android.ext.koin.androidContext
 import org.koin.androidx.viewmodel.dsl.viewModel
 import org.koin.dsl.module
 import org.koitharu.kotatsu.base.domain.MangaDataRepository
 import org.koitharu.kotatsu.local.data.PagesCache
+import org.koitharu.kotatsu.reader.ui.PageSaveHelper
 import org.koitharu.kotatsu.reader.ui.ReaderViewModel
 
 val readerModule
@@ -12,6 +14,8 @@ val readerModule
 		single { MangaDataRepository(get()) }
 		single { PagesCache(get()) }
 
+		factory { PageSaveHelper(get(), androidContext()) }
+
 		viewModel { params ->
 			ReaderViewModel(
 				intent = params[0],
@@ -21,7 +25,7 @@ val readerModule
 				historyRepository = get(),
 				shortcutsRepository = get(),
 				settings = get(),
-				externalStorageHelper = get(),
+				pageSaveHelper = get(),
 			)
 		}
 	}

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

@@ -113,6 +113,10 @@ class PageLoader : KoinComponent, Closeable {
 		}
 	}
 
+	suspend fun getPageUrl(page: MangaPage): String {
+		return getRepository(page.source).getPageUrl(page)
+	}
+
 	private fun onIdle() {
 		synchronized(prefetchQueue) {
 			while (prefetchQueue.isNotEmpty()) {
@@ -151,7 +155,7 @@ class PageLoader : KoinComponent, Closeable {
 	}
 
 	private suspend fun loadPageImpl(page: MangaPage, progress: MutableStateFlow<Float>): File {
-		val pageUrl = getRepository(page.source).getPageUrl(page)
+		val pageUrl = getPageUrl(page)
 		check(pageUrl.isNotBlank()) { "Cannot obtain full image url" }
 		val uri = Uri.parse(pageUrl)
 		return if (uri.scheme == "cbz") {

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

@@ -0,0 +1,60 @@
+package org.koitharu.kotatsu.reader.ui
+
+import android.content.Context
+import android.net.Uri
+import androidx.activity.result.ActivityResultLauncher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+import kotlinx.coroutines.suspendCancellableCoroutine
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okio.IOException
+import org.koitharu.kotatsu.local.data.PagesCache
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.reader.domain.PageLoader
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.coroutineContext
+import kotlin.coroutines.resume
+
+class PageSaveHelper(
+	private val cache: PagesCache,
+	context: Context,
+) {
+
+	private var continuation: Continuation<Uri>? = null
+	private val contentResolver = context.contentResolver
+
+	suspend fun savePage(
+		pageLoader: PageLoader,
+		page: MangaPage,
+		saveLauncher: ActivityResultLauncher<String>,
+	): Uri {
+		var pageFile = cache[page.url]
+		var fileName = pageFile?.name
+		if (fileName == null) {
+			fileName = pageLoader.getPageUrl(page).toHttpUrl().pathSegments.last()
+		}
+		val cc = coroutineContext
+		val destination = suspendCancellableCoroutine<Uri> { cont ->
+			continuation = cont
+			Dispatchers.Main.dispatch(cc) {
+				saveLauncher.launch(fileName)
+			}
+		}
+		continuation = null
+		if (pageFile == null) {
+			pageFile = pageLoader.loadPage(page, force = false)
+		}
+		runInterruptible(Dispatchers.IO) {
+			contentResolver.openOutputStream(destination)?.use { output ->
+				pageFile.inputStream().use { input ->
+					input.copyTo(output)
+				}
+			} ?: throw IOException("Output stream is null")
+		}
+		return destination
+	}
+
+	fun onActivityResult(uri: Uri): Boolean = continuation?.apply {
+		resume(uri)
+	} != null
+}

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

@@ -9,7 +9,6 @@ import android.view.*
 import android.widget.Toast
 import androidx.activity.result.ActivityResultCallback
 import androidx.core.graphics.Insets
-import androidx.core.net.toUri
 import androidx.core.view.*
 import androidx.fragment.app.commit
 import androidx.lifecycle.lifecycleScope
@@ -187,10 +186,7 @@ class ReaderActivity :
 			R.id.action_save_page -> {
 				viewModel.getCurrentPage()?.also { page ->
 					viewModel.saveCurrentState(reader?.getCurrentState())
-					val name = page.url.toUri().run {
-						fragment ?: lastPathSegment ?: ""
-					}
-					savePageRequest.launch(name)
+					viewModel.saveCurrentPage(page, savePageRequest)
 				} ?: showWaitWhileLoading()
 			}
 			else -> return super.onOptionsItemSelected(item)
@@ -199,9 +195,7 @@ class ReaderActivity :
 	}
 
 	override fun onActivityResult(uri: Uri?) {
-		if (uri != null) {
-			viewModel.saveCurrentPage(uri)
-		}
+		viewModel.onActivityResult(uri)
 	}
 
 	private fun onLoadingStateChanged(isLoading: Boolean) {

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

@@ -2,6 +2,7 @@ package org.koitharu.kotatsu.reader.ui
 
 import android.net.Uri
 import android.util.LongSparseArray
+import androidx.activity.result.ActivityResultLauncher
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.*
@@ -26,7 +27,6 @@ import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.reader.domain.PageLoader
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
 import org.koitharu.kotatsu.reader.ui.pager.ReaderUiState
-import org.koitharu.kotatsu.utils.ExternalStorageHelper
 import org.koitharu.kotatsu.utils.SingleLiveEvent
 import org.koitharu.kotatsu.utils.ext.IgnoreErrors
 import org.koitharu.kotatsu.utils.ext.asLiveDataDistinct
@@ -40,10 +40,11 @@ class ReaderViewModel(
 	private val historyRepository: HistoryRepository,
 	private val shortcutsRepository: ShortcutsRepository,
 	private val settings: AppSettings,
-	private val externalStorageHelper: ExternalStorageHelper,
+	private val pageSaveHelper: PageSaveHelper,
 ) : BaseViewModel() {
 
 	private var loadingJob: Job? = null
+	private var pageSaveJob: Job? = null
 	private val currentState = MutableStateFlow(initialState)
 	private val mangaData = MutableStateFlow(intent.manga)
 	private val chapters = LongSparseArray<MangaChapter>()
@@ -54,7 +55,7 @@ class ReaderViewModel(
 	val onPageSaved = SingleLiveEvent<Uri?>()
 	val uiState = combine(
 		mangaData,
-		currentState
+		currentState,
 	) { manga, state ->
 		val chapter = state?.chapterId?.let(chapters::get)
 		ReaderUiState(
@@ -137,12 +138,16 @@ class ReaderViewModel(
 		return pages.filter { it.chapterId == chapterId }.map { it.toMangaPage() }
 	}
 
-	fun saveCurrentPage(destination: Uri) {
-		launchJob(Dispatchers.Default) {
+	fun saveCurrentPage(
+		page: MangaPage,
+		saveLauncher: ActivityResultLauncher<String>,
+	) {
+		val prevJob = pageSaveJob
+		pageSaveJob = launchLoadingJob(Dispatchers.Default) {
+			prevJob?.cancelAndJoin()
 			try {
-				val page = getCurrentPage() ?: error("Page not found")
-				externalStorageHelper.savePage(page, destination)
-				onPageSaved.postCall(destination)
+				val dest = pageSaveHelper.savePage(pageLoader, page, saveLauncher)
+				onPageSaved.postCall(dest)
 			} catch (e: CancellationException) {
 				throw e
 			} catch (e: Exception) {
@@ -154,6 +159,15 @@ class ReaderViewModel(
 		}
 	}
 
+	fun onActivityResult(uri: Uri?) {
+		if (uri != null) {
+			pageSaveHelper.onActivityResult(uri)
+		} else {
+			pageSaveJob?.cancel()
+			pageSaveJob = null
+		}
+	}
+
 	fun getCurrentPage(): MangaPage? {
 		val state = currentState.value ?: return null
 		return content.value?.pages?.find {

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

@@ -9,6 +9,7 @@ import androidx.fragment.app.FragmentManager
 import androidx.recyclerview.widget.GridLayoutManager
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import org.koin.android.ext.android.get
+import org.koin.androidx.viewmodel.ext.android.getViewModel
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.base.ui.BaseBottomSheet
 import org.koitharu.kotatsu.base.ui.list.OnListItemClickListener
@@ -20,6 +21,8 @@ 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.ReaderActivity
+import org.koitharu.kotatsu.reader.ui.ReaderViewModel
 import org.koitharu.kotatsu.reader.ui.thumbnails.adapter.PageThumbnailAdapter
 import org.koitharu.kotatsu.utils.BottomSheetToolbarController
 import org.koitharu.kotatsu.utils.ext.viewLifecycleScope
@@ -81,7 +84,7 @@ class PagesThumbnailsSheet :
 				dataSet = thumbnails,
 				coil = get(),
 				scope = viewLifecycleScope,
-				loader = PageLoader().also { pageLoader = it },
+				loader = getPageLoader(),
 				clickListener = this@PagesThumbnailsSheet
 			)
 			addOnLayoutChangeListener(spanResolver)
@@ -109,6 +112,11 @@ class PagesThumbnailsSheet :
 		}
 	}
 
+	private fun getPageLoader(): PageLoader {
+		val viewModel = (activity as? ReaderActivity)?.getViewModel<ReaderViewModel>()
+		return viewModel?.pageLoader ?: PageLoader().also { pageLoader = it }
+	}
+
 	private inner class ToolbarController(toolbar: Toolbar) : BottomSheetToolbarController(toolbar) {
 		override fun onStateChanged(bottomSheet: View, newState: Int) {
 			super.onStateChanged(bottomSheet, newState)

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

@@ -9,6 +9,7 @@ import org.koitharu.kotatsu.core.backup.RestoreRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.settings.backup.BackupViewModel
 import org.koitharu.kotatsu.settings.backup.RestoreViewModel
+import org.koitharu.kotatsu.settings.newsources.NewSourcesViewModel
 import org.koitharu.kotatsu.settings.onboard.OnboardViewModel
 import org.koitharu.kotatsu.settings.protect.ProtectSetupViewModel
 import org.koitharu.kotatsu.settings.sources.SourcesSettingsViewModel
@@ -27,4 +28,5 @@ val settingsModule
 		viewModel { ProtectSetupViewModel(get()) }
 		viewModel { OnboardViewModel(get()) }
 		viewModel { SourcesSettingsViewModel(get()) }
+		viewModel { NewSourcesViewModel(get()) }
 	}

app/src/main/java/org/koitharu/kotatsu/settings/newsources/NewSourcesDialogFragment.kt

@@ -0,0 +1,68 @@
+package org.koitharu.kotatsu.settings.newsources
+
+import android.content.DialogInterface
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.FragmentManager
+import androidx.recyclerview.widget.RecyclerView
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import org.koin.android.ext.android.get
+import org.koin.androidx.viewmodel.ext.android.viewModel
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.base.ui.AlertDialogFragment
+import org.koitharu.kotatsu.databinding.DialogOnboardBinding
+import org.koitharu.kotatsu.settings.sources.adapter.SourceConfigAdapter
+import org.koitharu.kotatsu.settings.sources.adapter.SourceConfigListener
+import org.koitharu.kotatsu.settings.sources.model.SourceConfigItem
+
+class NewSourcesDialogFragment :
+	AlertDialogFragment<DialogOnboardBinding>(),
+	SourceConfigListener,
+	DialogInterface.OnClickListener {
+
+	private val viewModel by viewModel<NewSourcesViewModel>()
+
+	override fun onInflateView(inflater: LayoutInflater, container: ViewGroup?): DialogOnboardBinding {
+		return DialogOnboardBinding.inflate(inflater, container, false)
+	}
+
+	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+		super.onViewCreated(view, savedInstanceState)
+		val adapter = SourceConfigAdapter(this, get(), viewLifecycleOwner)
+		binding.recyclerView.adapter = adapter
+		binding.textViewTitle.setText(R.string.new_sources_text)
+
+		viewModel.sources.observe(viewLifecycleOwner) { adapter.items = it }
+	}
+
+	override fun onBuildDialog(builder: MaterialAlertDialogBuilder) {
+		builder
+			.setPositiveButton(R.string.done, this)
+			.setCancelable(true)
+			.setTitle(R.string.remote_sources)
+	}
+
+	override fun onClick(dialog: DialogInterface, which: Int) {
+		viewModel.apply()
+		dialog.dismiss()
+	}
+
+	override fun onItemSettingsClick(item: SourceConfigItem.SourceItem) = Unit
+
+	override fun onItemEnabledChanged(item: SourceConfigItem.SourceItem, isEnabled: Boolean) {
+		viewModel.onItemEnabledChanged(item, isEnabled)
+	}
+
+	override fun onDragHandleTouch(holder: RecyclerView.ViewHolder) = Unit
+
+	override fun onHeaderClick(header: SourceConfigItem.LocaleGroup) = Unit
+
+	companion object {
+
+		private const val TAG = "NewSources"
+
+		fun show(fm: FragmentManager) = NewSourcesDialogFragment().show(fm, TAG)
+	}
+}

app/src/main/java/org/koitharu/kotatsu/settings/newsources/NewSourcesViewModel.kt

@@ -0,0 +1,42 @@
+package org.koitharu.kotatsu.settings.newsources
+
+import androidx.lifecycle.MutableLiveData
+import org.koitharu.kotatsu.base.ui.BaseViewModel
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.settings.sources.model.SourceConfigItem
+
+class NewSourcesViewModel(
+	private val settings: AppSettings,
+) : BaseViewModel() {
+
+	val sources = MutableLiveData<List<SourceConfigItem>>()
+	private val initialList = settings.newSources
+
+	init {
+		buildList()
+	}
+
+	fun onItemEnabledChanged(item: SourceConfigItem.SourceItem, isEnabled: Boolean) {
+		if (isEnabled) {
+			settings.hiddenSources -= item.source.name
+		} else {
+			settings.hiddenSources += item.source.name
+		}
+	}
+
+	fun apply() {
+		settings.markKnownSources(initialList)
+	}
+
+	private fun buildList() {
+		val hidden = settings.hiddenSources
+		sources.value = initialList.map {
+			SourceConfigItem.SourceItem(
+				source = it,
+				summary = null,
+				isEnabled = it.name !in hidden,
+				isDraggable = false,
+			)
+		}
+	}
+}

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

@@ -53,6 +53,7 @@ class OnboardDialogFragment : AlertDialogFragment<DialogOnboardBinding>(),
 		super.onViewCreated(view, savedInstanceState)
 		val adapter = SourceLocalesAdapter(this)
 		binding.recyclerView.adapter = adapter
+		binding.textViewTitle.setText(R.string.onboard_text)
 		viewModel.list.observeNotNull(viewLifecycleOwner) {
 			adapter.items = it
 		}

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

@@ -83,7 +83,9 @@ fun sourceConfigDraggableItemDelegate(
 	on = { item, _, _ -> item is SourceConfigItem.SourceItem && item.isDraggable }
 ) {
 
-	val eventListener = object : View.OnClickListener, View.OnTouchListener,
+	val eventListener = object :
+		View.OnClickListener,
+		View.OnTouchListener,
 		CompoundButton.OnCheckedChangeListener {
 		override fun onClick(v: View?) = listener.onItemSettingsClick(item)
 

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

@@ -0,0 +1,66 @@
+package org.koitharu.kotatsu.utils
+
+import kotlinx.coroutines.CancellableContinuation
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.util.*
+import kotlin.coroutines.resume
+
+class CompositeMutex<T : Any> : Set<T> {
+
+	private val data = HashMap<T, MutableList<CancellableContinuation<Unit>>>()
+	private val mutex = Mutex()
+
+	override val size: Int
+		get() = data.size
+
+	override fun contains(element: T): Boolean {
+		return data.containsKey(element)
+	}
+
+	override fun containsAll(elements: Collection<T>): Boolean {
+		return elements.all { x -> data.containsKey(x) }
+	}
+
+	override fun isEmpty(): Boolean {
+		return data.isEmpty()
+	}
+
+	override fun iterator(): Iterator<T> {
+		return data.keys.iterator()
+	}
+
+	suspend fun lock(element: T) {
+		waitForRemoval(element)
+		mutex.withLock {
+			val lastValue = data.put(element, LinkedList<CancellableContinuation<Unit>>())
+			check(lastValue == null) {
+				"CompositeMutex is double-locked for $element"
+			}
+		}
+	}
+
+	suspend fun unlock(element: T) {
+		val continuations = mutex.withLock {
+			checkNotNull(data.remove(element)) {
+				"CompositeMutex is not locked for $element"
+			}
+		}
+		continuations.forEach { c ->
+			if (c.isActive) {
+				c.resume(Unit)
+			}
+		}
+	}
+
+	private suspend fun waitForRemoval(element: T) {
+		val list = data[element] ?: return
+		suspendCancellableCoroutine<Unit> { continuation ->
+			list.add(continuation)
+			continuation.invokeOnCancellation {
+				list.remove(continuation)
+			}
+		}
+	}
+}

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

@@ -1,26 +0,0 @@
-package org.koitharu.kotatsu.utils
-
-import android.content.Context
-import android.net.Uri
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runInterruptible
-import okio.IOException
-import org.koitharu.kotatsu.parsers.model.MangaPage
-import org.koitharu.kotatsu.reader.domain.PageLoader
-
-class ExternalStorageHelper(context: Context) {
-
-	private val contentResolver = context.contentResolver
-
-	suspend fun savePage(page: MangaPage, destination: Uri) {
-		val pageLoader = PageLoader()
-		val pageFile = pageLoader.loadPage(page, force = false)
-		runInterruptible(Dispatchers.IO) {
-			contentResolver.openOutputStream(destination)?.use { output ->
-				pageFile.inputStream().use { input ->
-					input.copyTo(output)
-				}
-			} ?: throw IOException("Output stream is null")
-		}
-	}
-}

app/src/main/java/org/koitharu/kotatsu/utils/progress/TimeLeftEstimator.kt

@@ -1,6 +1,7 @@
 package org.koitharu.kotatsu.utils.progress
 
 import android.os.SystemClock
+import java.util.concurrent.TimeUnit
 import kotlin.math.roundToInt
 import kotlin.math.roundToLong
 
@@ -11,6 +12,7 @@ class TimeLeftEstimator {
 
 	private var times = ArrayList<Int>()
 	private var lastTick: Tick? = null
+	private val tooLargeTime = TimeUnit.DAYS.toMillis(1)
 
 	fun tick(value: Int, total: Int) {
 		if (total < 0) {
@@ -36,7 +38,8 @@ class TimeLeftEstimator {
 		}
 		val timePerTick = times.average()
 		val ticksLeft = progress.total - progress.value
-		return (ticksLeft * timePerTick).roundToLong()
+		val eta = (ticksLeft * timePerTick).roundToLong()
+		return if (eta < tooLargeTime) eta else NO_TIME
 	}
 
 	private class Tick(