Move sources from java to kotlin dir

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

@@ -0,0 +1,22 @@
+package org.koitharu.kotatsu.favourites.data
+
+import org.koitharu.kotatsu.core.db.entity.SortOrder
+import org.koitharu.kotatsu.core.db.entity.toManga
+import org.koitharu.kotatsu.core.db.entity.toMangaTags
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import java.util.Date
+
+fun FavouriteCategoryEntity.toFavouriteCategory(id: Long = categoryId.toLong()) = FavouriteCategory(
+	id = id,
+	title = title,
+	sortKey = sortKey,
+	order = SortOrder(order, SortOrder.NEWEST),
+	createdAt = Date(createdAt),
+	isTrackingEnabled = track,
+	isVisibleInLibrary = isVisibleInLibrary,
+)
+
+fun FavouriteManga.toManga() = manga.toManga(tags.toMangaTags())
+
+fun Collection<FavouriteManga>.toMangaList() = map { it.toManga() }

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

@@ -0,0 +1,56 @@
+package org.koitharu.kotatsu.favourites.data
+
+import androidx.room.*
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+abstract class FavouriteCategoriesDao {
+
+	@Query("SELECT * FROM favourite_categories WHERE category_id = :id AND deleted_at = 0")
+	abstract suspend fun find(id: Int): FavouriteCategoryEntity
+
+	@Query("SELECT * FROM favourite_categories WHERE deleted_at = 0 ORDER BY sort_key")
+	abstract suspend fun findAll(): List<FavouriteCategoryEntity>
+
+	@Query("SELECT * FROM favourite_categories WHERE deleted_at = 0 ORDER BY sort_key")
+	abstract fun observeAll(): Flow<List<FavouriteCategoryEntity>>
+
+	@Query("SELECT * FROM favourite_categories WHERE category_id = :id AND deleted_at = 0")
+	abstract fun observe(id: Long): Flow<FavouriteCategoryEntity?>
+
+	@Insert(onConflict = OnConflictStrategy.ABORT)
+	abstract suspend fun insert(category: FavouriteCategoryEntity): Long
+
+	suspend fun delete(id: Long) = setDeletedAt(id, System.currentTimeMillis())
+
+	@Query("UPDATE favourite_categories SET title = :title, `order` = :order, `track` = :tracker, `show_in_lib` = :onShelf WHERE category_id = :id")
+	abstract suspend fun update(id: Long, title: String, order: String, tracker: Boolean, onShelf: Boolean)
+
+	@Query("UPDATE favourite_categories SET `order` = :order WHERE category_id = :id")
+	abstract suspend fun updateOrder(id: Long, order: String)
+
+	@Query("UPDATE favourite_categories SET `track` = :isEnabled WHERE category_id = :id")
+	abstract suspend fun updateTracking(id: Long, isEnabled: Boolean)
+
+	@Query("UPDATE favourite_categories SET `show_in_lib` = :isEnabled WHERE category_id = :id")
+	abstract suspend fun updateLibVisibility(id: Long, isEnabled: Boolean)
+
+	@Query("UPDATE favourite_categories SET sort_key = :sortKey WHERE category_id = :id")
+	abstract suspend fun updateSortKey(id: Long, sortKey: Int)
+
+	@Query("DELETE FROM favourite_categories WHERE deleted_at != 0 AND deleted_at < :maxDeletionTime")
+	abstract suspend fun gc(maxDeletionTime: Long)
+
+	@Query("SELECT MAX(sort_key) FROM favourite_categories WHERE deleted_at = 0")
+	protected abstract suspend fun getMaxSortKey(): Int?
+
+	suspend fun getNextSortKey(): Int {
+		return (getMaxSortKey() ?: 0) + 1
+	}
+
+	@Upsert
+	abstract suspend fun upsert(entity: FavouriteCategoryEntity)
+
+	@Query("UPDATE favourite_categories SET deleted_at = :deletedAt WHERE category_id = :id")
+	protected abstract suspend fun setDeletedAt(id: Long, deletedAt: Long)
+}

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

@@ -0,0 +1,48 @@
+package org.koitharu.kotatsu.favourites.data
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import org.koitharu.kotatsu.core.db.TABLE_FAVOURITE_CATEGORIES
+
+@Entity(tableName = TABLE_FAVOURITE_CATEGORIES)
+data class FavouriteCategoryEntity(
+	@PrimaryKey(autoGenerate = true)
+	@ColumnInfo(name = "category_id") val categoryId: Int,
+	@ColumnInfo(name = "created_at") val createdAt: Long,
+	@ColumnInfo(name = "sort_key") val sortKey: Int,
+	@ColumnInfo(name = "title") val title: String,
+	@ColumnInfo(name = "order") val order: String,
+	@ColumnInfo(name = "track") val track: Boolean,
+	@ColumnInfo(name = "show_in_lib") val isVisibleInLibrary: Boolean,
+	@ColumnInfo(name = "deleted_at") val deletedAt: Long,
+) {
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as FavouriteCategoryEntity
+
+		if (categoryId != other.categoryId) return false
+		if (createdAt != other.createdAt) return false
+		if (sortKey != other.sortKey) return false
+		if (title != other.title) return false
+		if (order != other.order) return false
+		if (track != other.track) return false
+		if (isVisibleInLibrary != other.isVisibleInLibrary) return false
+
+		return true
+	}
+
+	override fun hashCode(): Int {
+		var result = categoryId
+		result = 31 * result + createdAt.hashCode()
+		result = 31 * result + sortKey
+		result = 31 * result + title.hashCode()
+		result = 31 * result + order.hashCode()
+		result = 31 * result + track.hashCode()
+		result = 31 * result + isVisibleInLibrary.hashCode()
+		return result
+	}
+}

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

@@ -0,0 +1,33 @@
+package org.koitharu.kotatsu.favourites.data
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import org.koitharu.kotatsu.core.db.TABLE_FAVOURITES
+import org.koitharu.kotatsu.core.db.entity.MangaEntity
+
+@Entity(
+	tableName = TABLE_FAVOURITES,
+	primaryKeys = ["manga_id", "category_id"],
+	foreignKeys = [
+		ForeignKey(
+			entity = MangaEntity::class,
+			parentColumns = ["manga_id"],
+			childColumns = ["manga_id"],
+			onDelete = ForeignKey.CASCADE
+		),
+		ForeignKey(
+			entity = FavouriteCategoryEntity::class,
+			parentColumns = ["category_id"],
+			childColumns = ["category_id"],
+			onDelete = ForeignKey.CASCADE
+		)
+	]
+)
+data class FavouriteEntity(
+	@ColumnInfo(name = "manga_id", index = true) val mangaId: Long,
+	@ColumnInfo(name = "category_id", index = true) val categoryId: Long,
+	@ColumnInfo(name = "sort_key") val sortKey: Int,
+	@ColumnInfo(name = "created_at") val createdAt: Long,
+	@ColumnInfo(name = "deleted_at") val deletedAt: Long,
+)

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

@@ -0,0 +1,28 @@
+package org.koitharu.kotatsu.favourites.data
+
+import androidx.room.Embedded
+import androidx.room.Junction
+import androidx.room.Relation
+import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.core.db.entity.MangaTagsEntity
+import org.koitharu.kotatsu.core.db.entity.TagEntity
+
+class FavouriteManga(
+	@Embedded val favourite: FavouriteEntity,
+	@Relation(
+		parentColumn = "manga_id",
+		entityColumn = "manga_id"
+	)
+	val manga: MangaEntity,
+	@Relation(
+		parentColumn = "category_id",
+		entityColumn = "category_id"
+	)
+	val categories: List<FavouriteCategoryEntity>,
+	@Relation(
+		parentColumn = "manga_id",
+		entityColumn = "tag_id",
+		associateBy = Junction(MangaTagsEntity::class)
+	)
+	val tags: List<TagEntity>
+)

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

@@ -0,0 +1,168 @@
+package org.koitharu.kotatsu.favourites.data
+
+import androidx.room.*
+import androidx.sqlite.db.SimpleSQLiteQuery
+import androidx.sqlite.db.SupportSQLiteQuery
+import kotlinx.coroutines.flow.Flow
+import org.intellij.lang.annotations.Language
+import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.parsers.model.SortOrder
+
+@Dao
+abstract class FavouritesDao {
+
+	/** SELECT **/
+
+	@Transaction
+	@Query("SELECT * FROM favourites WHERE deleted_at = 0 GROUP BY manga_id ORDER BY created_at DESC")
+	abstract suspend fun findAll(): List<FavouriteManga>
+
+	@Transaction
+	@Query("SELECT * FROM favourites WHERE deleted_at = 0 GROUP BY manga_id ORDER BY created_at DESC LIMIT :limit")
+	abstract suspend fun findLast(limit: Int): List<FavouriteManga>
+
+	fun observeAll(order: SortOrder): Flow<List<FavouriteManga>> {
+		val orderBy = getOrderBy(order)
+
+		@Language("RoomSql")
+		val query = SimpleSQLiteQuery(
+			"SELECT * FROM favourites LEFT JOIN manga ON favourites.manga_id = manga.manga_id " +
+				"WHERE favourites.deleted_at = 0 GROUP BY favourites.manga_id ORDER BY $orderBy",
+		)
+		return observeAllImpl(query)
+	}
+
+	@Transaction
+	@Query(
+		"SELECT * FROM favourites WHERE deleted_at = 0 " +
+			"GROUP BY manga_id ORDER BY created_at DESC LIMIT :limit OFFSET :offset",
+	)
+	abstract suspend fun findAll(offset: Int, limit: Int): List<FavouriteManga>
+
+	@Transaction
+	@Query(
+		"SELECT * FROM favourites WHERE category_id = :categoryId AND deleted_at = 0 " +
+			"GROUP BY manga_id ORDER BY created_at DESC",
+	)
+	abstract suspend fun findAll(categoryId: Long): List<FavouriteManga>
+
+	fun observeAll(categoryId: Long, order: SortOrder): Flow<List<FavouriteManga>> {
+		val orderBy = getOrderBy(order)
+
+		@Language("RoomSql")
+		val query = SimpleSQLiteQuery(
+			"SELECT * FROM favourites LEFT JOIN manga ON favourites.manga_id = manga.manga_id " +
+				"WHERE category_id = ? AND deleted_at = 0 GROUP BY favourites.manga_id ORDER BY $orderBy",
+			arrayOf<Any>(categoryId),
+		)
+		return observeAllImpl(query)
+	}
+
+	@Transaction
+	@Query(
+		"SELECT * FROM favourites WHERE category_id = :categoryId AND deleted_at = 0 " +
+			"GROUP BY manga_id ORDER BY created_at DESC LIMIT :limit OFFSET :offset",
+	)
+	abstract suspend fun findAll(categoryId: Long, offset: Int, limit: Int): List<FavouriteManga>
+
+	@Query(
+		"SELECT * FROM manga WHERE manga_id IN " +
+			"(SELECT manga_id FROM favourites WHERE category_id = :categoryId AND deleted_at = 0)",
+	)
+	abstract suspend fun findAllManga(categoryId: Int): List<MangaEntity>
+
+	suspend fun findCovers(categoryId: Long, order: SortOrder): List<String> {
+		val orderBy = getOrderBy(order)
+
+		@Language("RoomSql")
+		val query = SimpleSQLiteQuery(
+			"SELECT m.cover_url FROM favourites AS f LEFT JOIN manga AS m ON f.manga_id = m.manga_id " +
+				"WHERE f.category_id = ? AND deleted_at = 0 ORDER BY $orderBy",
+			arrayOf<Any>(categoryId),
+		)
+		return findCoversImpl(query)
+	}
+
+	@Query("SELECT * FROM manga WHERE manga_id IN (SELECT manga_id FROM favourites WHERE deleted_at = 0)")
+	abstract suspend fun findAllManga(): List<MangaEntity>
+
+	@Transaction
+	@Query("SELECT * FROM favourites WHERE manga_id = :id AND deleted_at = 0 GROUP BY manga_id")
+	abstract suspend fun find(id: Long): FavouriteManga?
+
+	@Transaction
+	@Deprecated("Ignores order")
+	@Query("SELECT * FROM favourites WHERE manga_id = :id AND deleted_at = 0 GROUP BY manga_id")
+	abstract fun observe(id: Long): Flow<FavouriteManga?>
+
+	@Query("SELECT DISTINCT category_id FROM favourites WHERE manga_id = :id AND deleted_at = 0")
+	abstract fun observeIds(id: Long): Flow<List<Long>>
+
+	/** INSERT **/
+
+	@Insert(onConflict = OnConflictStrategy.REPLACE)
+	abstract suspend fun insert(favourite: FavouriteEntity)
+
+	/** DELETE **/
+
+	suspend fun delete(mangaId: Long) = setDeletedAt(
+		mangaId = mangaId,
+		deletedAt = System.currentTimeMillis(),
+	)
+
+	suspend fun delete(mangaId: Long, categoryId: Long) = setDeletedAt(
+		categoryId = categoryId,
+		mangaId = mangaId,
+		deletedAt = System.currentTimeMillis(),
+	)
+
+	suspend fun deleteAll(categoryId: Long) = setDeletedAtAll(
+		categoryId = categoryId,
+		deletedAt = System.currentTimeMillis(),
+	)
+
+	suspend fun recover(mangaId: Long) = setDeletedAt(
+		mangaId = mangaId,
+		deletedAt = 0L,
+	)
+
+	suspend fun recover(categoryId: Long, mangaId: Long) = setDeletedAt(
+		categoryId = categoryId,
+		mangaId = mangaId,
+		deletedAt = 0L,
+	)
+
+	@Query("DELETE FROM favourites WHERE deleted_at != 0 AND deleted_at < :maxDeletionTime")
+	abstract suspend fun gc(maxDeletionTime: Long)
+
+	/** TOOLS **/
+
+	@Upsert
+	abstract suspend fun upsert(entity: FavouriteEntity)
+
+	@Transaction
+	@RawQuery(observedEntities = [FavouriteEntity::class])
+	protected abstract fun observeAllImpl(query: SupportSQLiteQuery): Flow<List<FavouriteManga>>
+
+	@RawQuery
+	protected abstract suspend fun findCoversImpl(query: SupportSQLiteQuery): List<String>
+
+	@Query("UPDATE favourites SET deleted_at = :deletedAt WHERE manga_id = :mangaId")
+	protected abstract suspend fun setDeletedAt(mangaId: Long, deletedAt: Long)
+
+	@Query("UPDATE favourites SET deleted_at = :deletedAt WHERE manga_id = :mangaId AND category_id = :categoryId")
+	abstract suspend fun setDeletedAt(categoryId: Long, mangaId: Long, deletedAt: Long)
+
+	@Query("UPDATE favourites SET deleted_at = :deletedAt WHERE category_id = :categoryId AND deleted_at = 0")
+	protected abstract suspend fun setDeletedAtAll(categoryId: Long, deletedAt: Long)
+
+	private fun getOrderBy(sortOrder: SortOrder) = when (sortOrder) {
+		SortOrder.RATING -> "rating DESC"
+		SortOrder.NEWEST,
+		SortOrder.UPDATED,
+		-> "created_at DESC"
+
+		SortOrder.ALPHABETICAL -> "title ASC"
+		else -> throw IllegalArgumentException("Sort order $sortOrder is not supported")
+	}
+}

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

@@ -0,0 +1,231 @@
+package org.koitharu.kotatsu.favourites.domain
+
+import androidx.room.withTransaction
+import dagger.Reusable
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.map
+import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.db.entity.SortOrder
+import org.koitharu.kotatsu.core.db.entity.toEntities
+import org.koitharu.kotatsu.core.db.entity.toEntity
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.core.ui.util.ReversibleHandle
+import org.koitharu.kotatsu.core.util.ext.mapItems
+import org.koitharu.kotatsu.favourites.data.FavouriteCategoryEntity
+import org.koitharu.kotatsu.favourites.data.FavouriteEntity
+import org.koitharu.kotatsu.favourites.data.toFavouriteCategory
+import org.koitharu.kotatsu.favourites.data.toManga
+import org.koitharu.kotatsu.favourites.data.toMangaList
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.tracker.work.TrackerNotificationChannels
+import javax.inject.Inject
+
+@Reusable
+class FavouritesRepository @Inject constructor(
+	private val db: MangaDatabase,
+	private val channels: TrackerNotificationChannels,
+) {
+
+	suspend fun getAllManga(): List<Manga> {
+		val entities = db.favouritesDao.findAll()
+		return entities.toMangaList()
+	}
+
+	suspend fun getLastManga(limit: Int): List<Manga> {
+		val entities = db.favouritesDao.findLast(limit)
+		return entities.toMangaList()
+	}
+
+	fun observeAll(order: SortOrder): Flow<List<Manga>> {
+		return db.favouritesDao.observeAll(order)
+			.mapItems { it.toManga() }
+	}
+
+	suspend fun getManga(categoryId: Long): List<Manga> {
+		val entities = db.favouritesDao.findAll(categoryId)
+		return entities.toMangaList()
+	}
+
+	fun observeAll(categoryId: Long, order: SortOrder): Flow<List<Manga>> {
+		return db.favouritesDao.observeAll(categoryId, order)
+			.mapItems { it.toManga() }
+	}
+
+	fun observeAll(categoryId: Long): Flow<List<Manga>> {
+		return observeOrder(categoryId)
+			.flatMapLatest { order -> observeAll(categoryId, order) }
+	}
+
+	fun observeCategories(): Flow<List<FavouriteCategory>> {
+		return db.favouriteCategoriesDao.observeAll().mapItems {
+			it.toFavouriteCategory()
+		}.distinctUntilChanged()
+	}
+
+	fun observeCategoriesWithCovers(): Flow<Map<FavouriteCategory, List<String>>> {
+		return db.favouriteCategoriesDao.observeAll()
+			.map {
+				db.withTransaction {
+					val res = LinkedHashMap<FavouriteCategory, List<String>>()
+					for (entity in it) {
+						val cat = entity.toFavouriteCategory()
+						res[cat] = db.favouritesDao.findCovers(
+							categoryId = cat.id,
+							order = cat.order,
+						)
+					}
+					res
+				}
+			}
+	}
+
+	fun observeCategory(id: Long): Flow<FavouriteCategory?> {
+		return db.favouriteCategoriesDao.observe(id)
+			.map { it?.toFavouriteCategory() }
+	}
+
+	fun observeCategoriesIds(mangaId: Long): Flow<Set<Long>> {
+		return db.favouritesDao.observeIds(mangaId).map { it.toSet() }
+	}
+
+	suspend fun getCategory(id: Long): FavouriteCategory {
+		return db.favouriteCategoriesDao.find(id.toInt()).toFavouriteCategory()
+	}
+
+	suspend fun createCategory(
+		title: String,
+		sortOrder: SortOrder,
+		isTrackerEnabled: Boolean,
+		isVisibleOnShelf: Boolean,
+	): FavouriteCategory {
+		val entity = FavouriteCategoryEntity(
+			title = title,
+			createdAt = System.currentTimeMillis(),
+			sortKey = db.favouriteCategoriesDao.getNextSortKey(),
+			categoryId = 0,
+			order = sortOrder.name,
+			track = isTrackerEnabled,
+			deletedAt = 0L,
+			isVisibleInLibrary = isVisibleOnShelf,
+		)
+		val id = db.favouriteCategoriesDao.insert(entity)
+		val category = entity.toFavouriteCategory(id)
+		channels.createChannel(category)
+		return category
+	}
+
+	suspend fun updateCategory(
+		id: Long,
+		title: String,
+		sortOrder: SortOrder,
+		isTrackerEnabled: Boolean,
+		isVisibleOnShelf: Boolean,
+	) {
+		db.favouriteCategoriesDao.update(id, title, sortOrder.name, isTrackerEnabled, isVisibleOnShelf)
+	}
+
+	suspend fun updateCategory(id: Long, isVisibleInLibrary: Boolean) {
+		db.favouriteCategoriesDao.updateLibVisibility(id, isVisibleInLibrary)
+	}
+
+	suspend fun updateCategoryTracking(id: Long, isTrackingEnabled: Boolean) {
+		db.favouriteCategoriesDao.updateTracking(id, isTrackingEnabled)
+	}
+
+	suspend fun removeCategory(id: Long) {
+		db.withTransaction {
+			db.favouriteCategoriesDao.delete(id)
+			db.favouritesDao.deleteAll(id)
+		}
+		channels.deleteChannel(id)
+	}
+
+	suspend fun removeCategories(ids: Collection<Long>) {
+		db.withTransaction {
+			for (id in ids) {
+				db.favouritesDao.deleteAll(id)
+				db.favouriteCategoriesDao.delete(id)
+			}
+		}
+		// run after transaction success
+		for (id in ids) {
+			channels.deleteChannel(id)
+		}
+	}
+
+	suspend fun setCategoryOrder(id: Long, order: SortOrder) {
+		db.favouriteCategoriesDao.updateOrder(id, order.name)
+	}
+
+	suspend fun reorderCategories(orderedIds: List<Long>) {
+		val dao = db.favouriteCategoriesDao
+		db.withTransaction {
+			for ((i, id) in orderedIds.withIndex()) {
+				dao.updateSortKey(id, i)
+			}
+		}
+	}
+
+	suspend fun addToCategory(categoryId: Long, mangas: Collection<Manga>) {
+		db.withTransaction {
+			for (manga in mangas) {
+				val tags = manga.tags.toEntities()
+				db.tagsDao.upsert(tags)
+				db.mangaDao.upsert(manga.toEntity(), tags)
+				val entity = FavouriteEntity(
+					mangaId = manga.id,
+					categoryId = categoryId,
+					createdAt = System.currentTimeMillis(),
+					sortKey = 0,
+					deletedAt = 0L,
+				)
+				db.favouritesDao.insert(entity)
+			}
+		}
+	}
+
+	suspend fun removeFromFavourites(ids: Collection<Long>): ReversibleHandle {
+		db.withTransaction {
+			for (id in ids) {
+				db.favouritesDao.delete(mangaId = id)
+			}
+		}
+		return ReversibleHandle { recoverToFavourites(ids) }
+	}
+
+	suspend fun removeFromCategory(categoryId: Long, ids: Collection<Long>): ReversibleHandle {
+		db.withTransaction {
+			for (id in ids) {
+				db.favouritesDao.delete(categoryId = categoryId, mangaId = id)
+			}
+		}
+		return ReversibleHandle { recoverToCategory(categoryId, ids) }
+	}
+
+	private fun observeOrder(categoryId: Long): Flow<SortOrder> {
+		return db.favouriteCategoriesDao.observe(categoryId)
+			.filterNotNull()
+			.map { x -> SortOrder(x.order, SortOrder.NEWEST) }
+			.distinctUntilChanged()
+	}
+
+	private suspend fun recoverToFavourites(ids: Collection<Long>) {
+		db.withTransaction {
+			for (id in ids) {
+				db.favouritesDao.recover(mangaId = id)
+			}
+		}
+	}
+
+	private suspend fun recoverToCategory(categoryId: Long, ids: Collection<Long>) {
+		db.withTransaction {
+			for (id in ids) {
+				db.favouritesDao.recover(mangaId = id, categoryId = categoryId)
+			}
+		}
+	}
+}

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

@@ -0,0 +1,56 @@
+package org.koitharu.kotatsu.favourites.ui
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import androidx.core.graphics.Insets
+import androidx.core.view.updatePadding
+import androidx.fragment.app.commit
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.core.ui.BaseActivity
+import org.koitharu.kotatsu.databinding.ActivityContainerBinding
+import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment
+import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment.Companion.NO_ID
+
+@AndroidEntryPoint
+class FavouritesActivity : BaseActivity<ActivityContainerBinding>() {
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		setContentView(ActivityContainerBinding.inflate(layoutInflater))
+		supportActionBar?.setDisplayHomeAsUpEnabled(true)
+		val categoryTitle = intent.getStringExtra(EXTRA_TITLE)
+		if (categoryTitle != null) {
+			title = categoryTitle
+		}
+		val fm = supportFragmentManager
+		if (fm.findFragmentById(R.id.container) == null) {
+			fm.commit {
+				setReorderingAllowed(true)
+				val fragment = FavouritesListFragment.newInstance(intent.getLongExtra(EXTRA_CATEGORY_ID, NO_ID))
+				replace(R.id.container, fragment)
+			}
+		}
+	}
+
+	override fun onWindowInsetsChanged(insets: Insets) {
+		viewBinding.root.updatePadding(
+			left = insets.left,
+			right = insets.right,
+		)
+	}
+
+	companion object {
+
+		private const val EXTRA_CATEGORY_ID = "cat_id"
+		private const val EXTRA_TITLE = "title"
+
+		fun newIntent(context: Context) = Intent(context, FavouritesActivity::class.java)
+
+		fun newIntent(context: Context, category: FavouriteCategory) = Intent(context, FavouritesActivity::class.java)
+			.putExtra(EXTRA_CATEGORY_ID, category.id)
+			.putExtra(EXTRA_TITLE, category.title)
+	}
+}

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

@@ -0,0 +1,66 @@
+package org.koitharu.kotatsu.favourites.ui.categories
+
+import android.view.Menu
+import android.view.MenuItem
+import androidx.appcompat.view.ActionMode
+import androidx.recyclerview.widget.RecyclerView
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.list.ListSelectionController
+import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity
+import com.google.android.material.R as materialR
+
+class CategoriesSelectionCallback(
+	private val recyclerView: RecyclerView,
+	private val viewModel: FavouritesCategoriesViewModel,
+) : ListSelectionController.Callback2 {
+
+	override fun onSelectionChanged(controller: ListSelectionController, count: Int) {
+		recyclerView.invalidateItemDecorations()
+	}
+
+	override fun onCreateActionMode(controller: ListSelectionController, mode: ActionMode, menu: Menu): Boolean {
+		mode.menuInflater.inflate(R.menu.mode_category, menu)
+		return true
+	}
+
+	override fun onPrepareActionMode(controller: ListSelectionController, mode: ActionMode, menu: Menu): Boolean {
+		val isOneItem = controller.count == 1
+		menu.findItem(R.id.action_edit)?.isVisible = isOneItem
+		mode.title = controller.count.toString()
+		return true
+	}
+
+	override fun onActionItemClicked(controller: ListSelectionController, mode: ActionMode, item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.action_edit -> {
+				val id = controller.peekCheckedIds().singleOrNull() ?: return false
+				val context = recyclerView.context
+				val intent = FavouritesCategoryEditActivity.newIntent(context, id)
+				context.startActivity(intent)
+				mode.finish()
+				true
+			}
+
+			R.id.action_remove -> {
+				confirmDeleteCategories(controller.snapshot(), mode)
+				true
+			}
+
+			else -> false
+		}
+	}
+
+	private fun confirmDeleteCategories(ids: Set<Long>, mode: ActionMode) {
+		val context = recyclerView.context
+		MaterialAlertDialogBuilder(context, materialR.style.ThemeOverlay_Material3_MaterialAlertDialog_Centered)
+			.setMessage(R.string.categories_delete_confirm)
+			.setTitle(R.string.remove_category)
+			.setIcon(R.drawable.ic_delete)
+			.setNegativeButton(android.R.string.cancel, null)
+			.setPositiveButton(R.string.remove) { _, _ ->
+				viewModel.deleteCategories(ids)
+				mode.finish()
+			}.show()
+	}
+}

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

@@ -0,0 +1,57 @@
+package org.koitharu.kotatsu.favourites.ui.categories
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.RectF
+import android.view.View
+import androidx.core.graphics.ColorUtils
+import androidx.recyclerview.widget.RecyclerView
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.list.decor.AbstractSelectionItemDecoration
+import org.koitharu.kotatsu.core.util.ext.getItem
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.CategoryListModel
+import com.google.android.material.R as materialR
+
+class CategoriesSelectionDecoration(context: Context) : AbstractSelectionItemDecoration() {
+
+	private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+	private val radius = context.resources.getDimension(R.dimen.list_selector_corner)
+	private val strokeColor = context.getThemeColor(materialR.attr.colorPrimary, Color.RED)
+	private val fillColor = ColorUtils.setAlphaComponent(
+		ColorUtils.blendARGB(strokeColor, context.getThemeColor(materialR.attr.colorSurface), 0.8f),
+		0x74,
+	)
+	private val padding = context.resources.getDimension(R.dimen.grid_spacing_outer)
+
+	init {
+		paint.strokeWidth = context.resources.getDimension(R.dimen.selection_stroke_width)
+		hasForeground = true
+		hasBackground = false
+		isIncludeDecorAndMargins = false
+	}
+
+	override fun getItemId(parent: RecyclerView, child: View): Long {
+		val holder = parent.getChildViewHolder(child) ?: return RecyclerView.NO_ID
+		val item = holder.getItem(CategoryListModel::class.java) ?: return RecyclerView.NO_ID
+		return item.category.id
+	}
+
+	override fun onDrawForeground(
+		canvas: Canvas,
+		parent: RecyclerView,
+		child: View,
+		bounds: RectF,
+		state: RecyclerView.State,
+	) {
+		bounds.inset(padding, padding)
+		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)
+	}
+}

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

@@ -0,0 +1,224 @@
+package org.koitharu.kotatsu.favourites.ui.categories
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.transition.Fade
+import android.transition.TransitionManager
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.viewModels
+import androidx.core.graphics.Insets
+import androidx.core.view.isVisible
+import androidx.core.view.updateLayoutParams
+import androidx.core.view.updatePadding
+import androidx.recyclerview.widget.ItemTouchHelper
+import androidx.recyclerview.widget.RecyclerView
+import coil.ImageLoader
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.exceptions.resolve.SnackbarErrorObserver
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.core.ui.BaseActivity
+import org.koitharu.kotatsu.core.ui.list.ListSelectionController
+import org.koitharu.kotatsu.core.util.ext.scaleUpActivityOptionsOf
+import org.koitharu.kotatsu.databinding.ActivityCategoriesBinding
+import org.koitharu.kotatsu.favourites.ui.FavouritesActivity
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.CategoriesAdapter
+import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity
+import org.koitharu.kotatsu.list.ui.adapter.ListStateHolderListener
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class FavouriteCategoriesActivity :
+	BaseActivity<ActivityCategoriesBinding>(),
+	FavouriteCategoriesListListener,
+	View.OnClickListener,
+	ListStateHolderListener {
+
+	@Inject
+	lateinit var coil: ImageLoader
+
+	private val viewModel by viewModels<FavouritesCategoriesViewModel>()
+
+	private lateinit var exitReorderModeCallback: ExitReorderModeCallback
+	private lateinit var adapter: CategoriesAdapter
+	private lateinit var selectionController: ListSelectionController
+	private var reorderHelper: ItemTouchHelper? = null
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		setContentView(ActivityCategoriesBinding.inflate(layoutInflater))
+		supportActionBar?.setDisplayHomeAsUpEnabled(true)
+		exitReorderModeCallback = ExitReorderModeCallback(viewModel)
+		adapter = CategoriesAdapter(coil, this, this, this)
+		selectionController = ListSelectionController(
+			activity = this,
+			decoration = CategoriesSelectionDecoration(this),
+			registryOwner = this,
+			callback = CategoriesSelectionCallback(viewBinding.recyclerView, viewModel),
+		)
+		viewBinding.buttonDone.setOnClickListener(this)
+		selectionController.attachToRecyclerView(viewBinding.recyclerView)
+		viewBinding.recyclerView.setHasFixedSize(true)
+		viewBinding.recyclerView.adapter = adapter
+		viewBinding.fabAdd.setOnClickListener(this)
+		onBackPressedDispatcher.addCallback(exitReorderModeCallback)
+
+		viewModel.detalizedCategories.observe(this, ::onCategoriesChanged)
+		viewModel.onError.observe(this, SnackbarErrorObserver(viewBinding.recyclerView, null))
+		viewModel.isInReorderMode.observe(this, ::onReorderModeChanged)
+	}
+
+	override fun onCreateOptionsMenu(menu: Menu): Boolean {
+		super.onCreateOptionsMenu(menu)
+		menuInflater.inflate(R.menu.opt_categories, menu)
+		return true
+	}
+
+	override fun onPrepareOptionsMenu(menu: Menu): Boolean {
+		menu.findItem(R.id.action_reorder)?.isVisible = !viewModel.isInReorderMode() && !viewModel.isEmpty()
+		return super.onPrepareOptionsMenu(menu)
+	}
+
+	override fun onOptionsItemSelected(item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.action_reorder -> {
+				viewModel.setReorderMode(true)
+				true
+			}
+
+			else -> super.onOptionsItemSelected(item)
+		}
+	}
+
+	override fun onClick(v: View) {
+		when (v.id) {
+			R.id.button_done -> viewModel.setReorderMode(false)
+			R.id.fab_add -> startActivity(FavouritesCategoryEditActivity.newIntent(this))
+		}
+	}
+
+	override fun onItemClick(item: FavouriteCategory, view: View) {
+		if (viewModel.isInReorderMode() || selectionController.onItemClick(item.id)) {
+			return
+		}
+		val intent = FavouritesActivity.newIntent(this, item)
+		val options = scaleUpActivityOptionsOf(view)
+		startActivity(intent, options.toBundle())
+	}
+
+	override fun onItemLongClick(item: FavouriteCategory, view: View): Boolean {
+		return !viewModel.isInReorderMode() && selectionController.onItemLongClick(item.id)
+	}
+
+	override fun onDragHandleTouch(holder: RecyclerView.ViewHolder): Boolean {
+		return reorderHelper?.startDrag(holder) != null
+	}
+
+	override fun onRetryClick(error: Throwable) = Unit
+
+	override fun onEmptyActionClick() = Unit
+
+	override fun onWindowInsetsChanged(insets: Insets) {
+		viewBinding.fabAdd.updateLayoutParams<ViewGroup.MarginLayoutParams> {
+			rightMargin = topMargin + insets.right
+			leftMargin = topMargin + insets.left
+			bottomMargin = topMargin + insets.bottom
+		}
+		viewBinding.root.updatePadding(
+			left = insets.left,
+			right = insets.right,
+		)
+		viewBinding.recyclerView.updatePadding(
+			bottom = insets.bottom,
+		)
+	}
+
+	private fun onCategoriesChanged(categories: List<ListModel>) {
+		adapter.items = categories
+		invalidateOptionsMenu()
+	}
+
+	private fun onReorderModeChanged(isReorderMode: Boolean) {
+		val transition = Fade().apply {
+			duration = resources.getInteger(android.R.integer.config_shortAnimTime).toLong()
+		}
+		TransitionManager.beginDelayedTransition(viewBinding.toolbar, transition)
+		reorderHelper?.attachToRecyclerView(null)
+		reorderHelper = if (isReorderMode) {
+			selectionController.clear()
+			viewBinding.fabAdd.hide()
+			ItemTouchHelper(ReorderHelperCallback()).apply {
+				attachToRecyclerView(viewBinding.recyclerView)
+			}
+		} else {
+			viewBinding.fabAdd.show()
+			null
+		}
+		viewBinding.recyclerView.isNestedScrollingEnabled = !isReorderMode
+		invalidateOptionsMenu()
+		viewBinding.buttonDone.isVisible = isReorderMode
+		exitReorderModeCallback.isEnabled = isReorderMode
+	}
+
+	private inner class ReorderHelperCallback : ItemTouchHelper.SimpleCallback(
+		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 = viewHolder.itemViewType == target.itemViewType
+
+		override fun canDropOver(
+			recyclerView: RecyclerView,
+			current: RecyclerView.ViewHolder,
+			target: RecyclerView.ViewHolder,
+		): Boolean = current.itemViewType == target.itemViewType
+
+		override fun onMoved(
+			recyclerView: RecyclerView,
+			viewHolder: RecyclerView.ViewHolder,
+			fromPos: Int,
+			target: RecyclerView.ViewHolder,
+			toPos: Int,
+			x: Int,
+			y: Int,
+		) {
+			super.onMoved(recyclerView, viewHolder, fromPos, target, toPos, x, y)
+			viewModel.reorderCategories(fromPos, toPos)
+		}
+
+		override fun isLongPressDragEnabled(): Boolean = false
+	}
+
+	private class ExitReorderModeCallback(
+		private val viewModel: FavouritesCategoriesViewModel,
+	) : OnBackPressedCallback(viewModel.isInReorderMode()) {
+
+		override fun handleOnBackPressed() {
+			viewModel.setReorderMode(false)
+		}
+	}
+
+	companion object {
+
+		val SORT_ORDERS = arrayOf(
+			SortOrder.ALPHABETICAL,
+			SortOrder.NEWEST,
+			SortOrder.RATING,
+		)
+
+		fun newIntent(context: Context) = Intent(context, FavouriteCategoriesActivity::class.java)
+	}
+}

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

@@ -0,0 +1,10 @@
+package org.koitharu.kotatsu.favourites.ui.categories
+
+import androidx.recyclerview.widget.RecyclerView
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+
+interface FavouriteCategoriesListListener : OnListItemClickListener<FavouriteCategory> {
+
+	fun onDragHandleTouch(holder: RecyclerView.ViewHolder): Boolean
+}

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

@@ -0,0 +1,104 @@
+package org.koitharu.kotatsu.favourites.ui.categories
+
+import androidx.lifecycle.asLiveData
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.combine
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.ui.BaseViewModel
+import org.koitharu.kotatsu.core.util.asFlowLiveData
+import org.koitharu.kotatsu.core.util.ext.mapItems
+import org.koitharu.kotatsu.core.util.ext.requireValue
+import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
+import org.koitharu.kotatsu.favourites.ui.categories.adapter.CategoryListModel
+import org.koitharu.kotatsu.list.ui.model.EmptyState
+import org.koitharu.kotatsu.list.ui.model.LoadingState
+import java.util.Collections
+import javax.inject.Inject
+
+@HiltViewModel
+class FavouritesCategoriesViewModel @Inject constructor(
+	private val repository: FavouritesRepository,
+	private val settings: AppSettings,
+) : BaseViewModel() {
+
+	private var reorderJob: Job? = null
+	private val isReorder = MutableStateFlow(false)
+
+	val isInReorderMode = isReorder.asLiveData(viewModelScope.coroutineContext)
+
+	val allCategories = repository.observeCategories()
+		.mapItems {
+			CategoryListModel(
+				mangaCount = 0,
+				covers = listOf(),
+				category = it,
+				isReorderMode = false,
+			)
+		}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, emptyList())
+
+	val detalizedCategories = combine(
+		repository.observeCategoriesWithCovers(),
+		isReorder,
+	) { list, reordering ->
+		list.map { (category, covers) ->
+			CategoryListModel(
+				mangaCount = covers.size,
+				covers = covers.take(3),
+				category = category,
+				isReorderMode = reordering,
+			)
+		}.ifEmpty {
+			listOf(
+				EmptyState(
+					icon = R.drawable.ic_empty_favourites,
+					textPrimary = R.string.text_empty_holder_primary,
+					textSecondary = R.string.empty_favourite_categories,
+					actionStringRes = 0,
+				),
+			)
+		}
+	}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, listOf(LoadingState))
+
+	fun deleteCategory(id: Long) {
+		launchJob {
+			repository.removeCategory(id)
+		}
+	}
+
+	fun deleteCategories(ids: Set<Long>) {
+		launchJob {
+			repository.removeCategories(ids)
+		}
+	}
+
+	fun setAllCategoriesVisible(isVisible: Boolean) {
+		settings.isAllFavouritesVisible = isVisible
+	}
+
+	fun isInReorderMode(): Boolean = isReorder.value
+
+	fun isEmpty(): Boolean = detalizedCategories.value?.none { it is CategoryListModel } ?: true
+
+	fun setReorderMode(isReorderMode: Boolean) {
+		isReorder.value = isReorderMode
+	}
+
+	fun reorderCategories(oldPos: Int, newPos: Int) {
+		val prevJob = reorderJob
+		reorderJob = launchJob(Dispatchers.Default) {
+			prevJob?.join()
+			val items = detalizedCategories.requireValue()
+			val ids = items.mapNotNullTo(ArrayList(items.size)) {
+				(it as? CategoryListModel)?.category?.id
+			}
+			Collections.swap(ids, oldPos, newPos)
+			ids.remove(0L)
+			repository.reorderCategories(ids)
+		}
+	}
+}

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

@@ -0,0 +1,61 @@
+package org.koitharu.kotatsu.favourites.ui.categories.adapter
+
+import androidx.lifecycle.LifecycleOwner
+import androidx.recyclerview.widget.DiffUtil
+import coil.ImageLoader
+import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
+import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesListListener
+import org.koitharu.kotatsu.list.ui.adapter.ListStateHolderListener
+import org.koitharu.kotatsu.list.ui.adapter.emptyStateListAD
+import org.koitharu.kotatsu.list.ui.adapter.loadingStateAD
+import org.koitharu.kotatsu.list.ui.model.ListModel
+import kotlin.jvm.internal.Intrinsics
+
+class CategoriesAdapter(
+	coil: ImageLoader,
+	lifecycleOwner: LifecycleOwner,
+	onItemClickListener: FavouriteCategoriesListListener,
+	listListener: ListStateHolderListener,
+) : AsyncListDifferDelegationAdapter<ListModel>(DiffCallback()) {
+
+	init {
+		delegatesManager.addDelegate(categoryAD(coil, lifecycleOwner, onItemClickListener))
+			.addDelegate(emptyStateListAD(coil, lifecycleOwner, listListener))
+			.addDelegate(loadingStateAD())
+	}
+
+	private class DiffCallback : DiffUtil.ItemCallback<ListModel>() {
+
+		override fun areItemsTheSame(oldItem: ListModel, newItem: ListModel): Boolean {
+			return when {
+				oldItem is CategoryListModel && newItem is CategoryListModel -> {
+					oldItem.category.id == newItem.category.id
+				}
+
+				else -> oldItem.javaClass == newItem.javaClass
+			}
+		}
+
+		override fun areContentsTheSame(oldItem: ListModel, newItem: ListModel): Boolean {
+			return Intrinsics.areEqual(oldItem, newItem)
+		}
+
+		override fun getChangePayload(oldItem: ListModel, newItem: ListModel): Any? {
+			return when {
+				oldItem is CategoryListModel && newItem is CategoryListModel -> {
+					if (oldItem.category == newItem.category &&
+						oldItem.mangaCount == newItem.mangaCount &&
+						oldItem.covers == newItem.covers &&
+						oldItem.isReorderMode != newItem.isReorderMode
+					) {
+						Unit
+					} else {
+						super.getChangePayload(oldItem, newItem)
+					}
+				}
+
+				else -> super.getChangePayload(oldItem, newItem)
+			}
+		}
+	}
+}

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

@@ -0,0 +1,96 @@
+package org.koitharu.kotatsu.favourites.ui.categories.adapter
+
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.view.MotionEvent
+import android.view.View
+import android.view.View.OnClickListener
+import android.view.View.OnLongClickListener
+import android.view.View.OnTouchListener
+import androidx.core.graphics.ColorUtils
+import androidx.core.view.isVisible
+import androidx.core.widget.ImageViewCompat
+import androidx.lifecycle.LifecycleOwner
+import coil.ImageLoader
+import com.hannesdorfmann.adapterdelegates4.dsl.adapterDelegateViewBinding
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.util.ext.animatorDurationScale
+import org.koitharu.kotatsu.core.util.ext.disposeImageRequest
+import org.koitharu.kotatsu.core.util.ext.enqueueWith
+import org.koitharu.kotatsu.core.util.ext.getThemeColor
+import org.koitharu.kotatsu.core.util.ext.newImageRequest
+import org.koitharu.kotatsu.databinding.ItemCategoryBinding
+import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesListListener
+import org.koitharu.kotatsu.list.ui.model.ListModel
+
+fun categoryAD(
+	coil: ImageLoader,
+	lifecycleOwner: LifecycleOwner,
+	clickListener: FavouriteCategoriesListListener,
+) = adapterDelegateViewBinding<CategoryListModel, ListModel, ItemCategoryBinding>(
+	{ inflater, parent -> ItemCategoryBinding.inflate(inflater, parent, false) },
+) {
+	val eventListener = object : OnClickListener, OnLongClickListener, OnTouchListener {
+		override fun onClick(v: View) = clickListener.onItemClick(item.category, binding.imageViewCover1)
+		override fun onLongClick(v: View) = clickListener.onItemLongClick(item.category, binding.imageViewCover1)
+		override fun onTouch(v: View?, event: MotionEvent): Boolean = item.isReorderMode &&
+			event.actionMasked == MotionEvent.ACTION_DOWN &&
+			clickListener.onDragHandleTouch(this@adapterDelegateViewBinding)
+	}
+	val backgroundColor = context.getThemeColor(android.R.attr.colorBackground)
+	ImageViewCompat.setImageTintList(
+		binding.imageViewCover3,
+		ColorStateList.valueOf(ColorUtils.setAlphaComponent(backgroundColor, 153)),
+	)
+	ImageViewCompat.setImageTintList(
+		binding.imageViewCover2,
+		ColorStateList.valueOf(ColorUtils.setAlphaComponent(backgroundColor, 76)),
+	)
+	binding.imageViewCover2.backgroundTintList =
+		ColorStateList.valueOf(ColorUtils.setAlphaComponent(backgroundColor, 76))
+	binding.imageViewCover3.backgroundTintList =
+		ColorStateList.valueOf(ColorUtils.setAlphaComponent(backgroundColor, 153))
+	val fallback = ColorDrawable(Color.TRANSPARENT)
+	val coverViews = arrayOf(binding.imageViewCover1, binding.imageViewCover2, binding.imageViewCover3)
+	val crossFadeDuration = (
+		context.resources.getInteger(R.integer.config_defaultAnimTime) *
+			context.animatorDurationScale
+		).toInt()
+	itemView.setOnClickListener(eventListener)
+	itemView.setOnLongClickListener(eventListener)
+	itemView.setOnTouchListener(eventListener)
+
+	bind { payloads ->
+		binding.imageViewHandle.isVisible = item.isReorderMode
+		if (payloads.isNotEmpty()) {
+			return@bind
+		}
+		binding.textViewTitle.text = item.category.title
+		binding.textViewSubtitle.text = if (item.mangaCount == 0) {
+			getString(R.string.empty)
+		} else {
+			context.resources.getQuantityString(
+				R.plurals.items,
+				item.mangaCount,
+				item.mangaCount,
+			)
+		}
+		repeat(coverViews.size) { i ->
+			coverViews[i].newImageRequest(lifecycleOwner, item.covers.getOrNull(i))?.run {
+				placeholder(R.drawable.ic_placeholder)
+				fallback(fallback)
+				crossfade(crossFadeDuration * (i + 1))
+				error(R.drawable.ic_error_placeholder)
+				allowRgb565(true)
+				enqueueWith(coil)
+			}
+		}
+	}
+
+	onViewRecycled {
+		coverViews.forEach {
+			it.disposeImageRequest()
+		}
+	}
+}

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

@@ -0,0 +1,38 @@
+package org.koitharu.kotatsu.favourites.ui.categories.adapter
+
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.list.ui.model.ListModel
+
+class CategoryListModel(
+	val mangaCount: Int,
+	val covers: List<String>,
+	val category: FavouriteCategory,
+	val isReorderMode: Boolean,
+) : ListModel {
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as CategoryListModel
+
+		if (mangaCount != other.mangaCount) return false
+		if (isReorderMode != other.isReorderMode) return false
+		if (covers != other.covers) return false
+		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 = mangaCount
+		result = 31 * result + isReorderMode.hashCode()
+		result = 31 * result + covers.hashCode()
+		result = 31 * result + category.id.hashCode()
+		result = 31 * result + category.title.hashCode()
+		result = 31 * result + category.order.hashCode()
+		return result
+	}
+}

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

@@ -0,0 +1,173 @@
+package org.koitharu.kotatsu.favourites.ui.categories.edit
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.text.Editable
+import android.view.View
+import android.view.ViewGroup
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import android.widget.Filter
+import androidx.activity.viewModels
+import androidx.core.graphics.Insets
+import androidx.core.view.isVisible
+import androidx.core.view.updateLayoutParams
+import androidx.core.view.updatePadding
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.core.ui.BaseActivity
+import org.koitharu.kotatsu.core.ui.model.titleRes
+import org.koitharu.kotatsu.core.ui.util.DefaultTextWatcher
+import org.koitharu.kotatsu.core.util.ext.getDisplayMessage
+import org.koitharu.kotatsu.core.util.ext.getSerializableCompat
+import org.koitharu.kotatsu.core.util.ext.setChecked
+import org.koitharu.kotatsu.databinding.ActivityCategoryEditBinding
+import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesActivity
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import com.google.android.material.R as materialR
+
+@AndroidEntryPoint
+class FavouritesCategoryEditActivity :
+	BaseActivity<ActivityCategoryEditBinding>(),
+	AdapterView.OnItemClickListener,
+	View.OnClickListener,
+	DefaultTextWatcher {
+
+	private val viewModel by viewModels<FavouritesCategoryEditViewModel>()
+	private var selectedSortOrder: SortOrder? = null
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		setContentView(ActivityCategoryEditBinding.inflate(layoutInflater))
+		supportActionBar?.run {
+			setDisplayHomeAsUpEnabled(true)
+			setHomeAsUpIndicator(materialR.drawable.abc_ic_clear_material)
+		}
+		initSortSpinner()
+		viewBinding.buttonDone.setOnClickListener(this)
+		viewBinding.editName.addTextChangedListener(this)
+		afterTextChanged(viewBinding.editName.text)
+
+		viewModel.onSaved.observe(this) { finishAfterTransition() }
+		viewModel.category.observe(this, ::onCategoryChanged)
+		viewModel.isLoading.observe(this, ::onLoadingStateChanged)
+		viewModel.onError.observe(this, ::onError)
+		viewModel.isTrackerEnabled.observe(this) {
+			viewBinding.switchTracker.isVisible = it
+		}
+	}
+
+	override fun onSaveInstanceState(outState: Bundle) {
+		super.onSaveInstanceState(outState)
+		outState.putSerializable(KEY_SORT_ORDER, selectedSortOrder)
+	}
+
+	override fun onRestoreInstanceState(savedInstanceState: Bundle) {
+		super.onRestoreInstanceState(savedInstanceState)
+		val order = savedInstanceState.getSerializableCompat<SortOrder>(KEY_SORT_ORDER)
+		if (order != null) {
+			selectedSortOrder = order
+		}
+	}
+
+	override fun onClick(v: View) {
+		when (v.id) {
+			R.id.button_done -> viewModel.save(
+				title = viewBinding.editName.text?.toString()?.trim().orEmpty(),
+				sortOrder = getSelectedSortOrder(),
+				isTrackerEnabled = viewBinding.switchTracker.isChecked,
+				isVisibleOnShelf = viewBinding.switchShelf.isChecked,
+			)
+		}
+	}
+
+	override fun afterTextChanged(s: Editable?) {
+		viewBinding.buttonDone.isEnabled = !s.isNullOrBlank()
+	}
+
+	override fun onWindowInsetsChanged(insets: Insets) {
+		viewBinding.root.updatePadding(
+			left = insets.left,
+			right = insets.right,
+		)
+		viewBinding.scrollView.updatePadding(
+			bottom = insets.bottom,
+		)
+		viewBinding.toolbar.updateLayoutParams<ViewGroup.MarginLayoutParams> {
+			topMargin = insets.top
+		}
+	}
+
+	override fun onItemClick(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
+		selectedSortOrder = FavouriteCategoriesActivity.SORT_ORDERS.getOrNull(position)
+	}
+
+	private fun onCategoryChanged(category: FavouriteCategory?) {
+		setTitle(if (category == null) R.string.create_category else R.string.edit_category)
+		if (selectedSortOrder != null) {
+			return
+		}
+		viewBinding.editName.setText(category?.title)
+		selectedSortOrder = category?.order
+		val sortText = getString((category?.order ?: SortOrder.NEWEST).titleRes)
+		viewBinding.editSort.setText(sortText, false)
+		viewBinding.switchTracker.setChecked(category?.isTrackingEnabled ?: true, false)
+		viewBinding.switchShelf.setChecked(category?.isVisibleInLibrary ?: true, false)
+	}
+
+	private fun onError(e: Throwable) {
+		viewBinding.textViewError.text = e.getDisplayMessage(resources)
+		viewBinding.textViewError.isVisible = true
+	}
+
+	private fun onLoadingStateChanged(isLoading: Boolean) {
+		viewBinding.editSort.isEnabled = !isLoading
+		viewBinding.editName.isEnabled = !isLoading
+		viewBinding.switchTracker.isEnabled = !isLoading
+		viewBinding.switchShelf.isEnabled = !isLoading
+		if (isLoading) {
+			viewBinding.textViewError.isVisible = false
+		}
+	}
+
+	private fun initSortSpinner() {
+		val entries = FavouriteCategoriesActivity.SORT_ORDERS.map { getString(it.titleRes) }
+		val adapter = SortAdapter(this, entries)
+		viewBinding.editSort.setAdapter(adapter)
+		viewBinding.editSort.onItemClickListener = this
+	}
+
+	private fun getSelectedSortOrder(): SortOrder {
+		selectedSortOrder?.let { return it }
+		val entries = FavouriteCategoriesActivity.SORT_ORDERS.map { getString(it.titleRes) }
+		val index = entries.indexOf(viewBinding.editSort.text.toString())
+		return FavouriteCategoriesActivity.SORT_ORDERS.getOrNull(index) ?: SortOrder.NEWEST
+	}
+
+	private class SortAdapter(
+		context: Context,
+		entries: List<String>,
+	) : ArrayAdapter<String>(context, android.R.layout.simple_spinner_dropdown_item, entries) {
+
+		override fun getFilter(): Filter = EmptyFilter
+
+		private object EmptyFilter : Filter() {
+			override fun performFiltering(constraint: CharSequence?) = FilterResults()
+			override fun publishResults(constraint: CharSequence?, results: FilterResults?) = Unit
+		}
+	}
+
+	companion object {
+
+		const val EXTRA_ID = "id"
+		const val NO_ID = -1L
+		private const val KEY_SORT_ORDER = "sort"
+
+		fun newIntent(context: Context, id: Long = NO_ID): Intent {
+			return Intent(context, FavouritesCategoryEditActivity::class.java)
+				.putExtra(EXTRA_ID, id)
+		}
+	}
+}

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

@@ -0,0 +1,64 @@
+package org.koitharu.kotatsu.favourites.ui.categories.edit
+
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.liveData
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.ui.BaseViewModel
+import org.koitharu.kotatsu.core.util.SingleLiveEvent
+import org.koitharu.kotatsu.core.util.ext.emitValue
+import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
+import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity.Companion.EXTRA_ID
+import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity.Companion.NO_ID
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import javax.inject.Inject
+
+@HiltViewModel
+class FavouritesCategoryEditViewModel @Inject constructor(
+	savedStateHandle: SavedStateHandle,
+	private val repository: FavouritesRepository,
+	private val settings: AppSettings,
+) : BaseViewModel() {
+
+	private val categoryId = savedStateHandle[EXTRA_ID] ?: NO_ID
+
+	val onSaved = SingleLiveEvent<Unit>()
+	val category = MutableLiveData<FavouriteCategory?>()
+
+	val isTrackerEnabled = liveData(viewModelScope.coroutineContext + Dispatchers.Default) {
+		emit(settings.isTrackerEnabled && AppSettings.TRACK_FAVOURITES in settings.trackSources)
+	}
+
+	init {
+		launchLoadingJob(Dispatchers.Default) {
+			category.emitValue(
+				if (categoryId != NO_ID) {
+					repository.getCategory(categoryId)
+				} else {
+					null
+				},
+			)
+		}
+	}
+
+	fun save(
+		title: String,
+		sortOrder: SortOrder,
+		isTrackerEnabled: Boolean,
+		isVisibleOnShelf: Boolean,
+	) {
+		launchLoadingJob(Dispatchers.Default) {
+			check(title.isNotEmpty())
+			if (categoryId == NO_ID) {
+				repository.createCategory(title, sortOrder, isTrackerEnabled, isVisibleOnShelf)
+			} else {
+				repository.updateCategory(categoryId, title, sortOrder, isTrackerEnabled, isVisibleOnShelf)
+			}
+			onSaved.emitCall(Unit)
+		}
+	}
+}

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

@@ -0,0 +1,97 @@
+package org.koitharu.kotatsu.favourites.ui.categories.select
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Toast
+import androidx.appcompat.widget.Toolbar
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.viewModels
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.ui.BaseBottomSheet
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.core.util.ext.getDisplayMessage
+import org.koitharu.kotatsu.core.util.ext.withArgs
+import org.koitharu.kotatsu.databinding.SheetFavoriteCategoriesBinding
+import org.koitharu.kotatsu.favourites.ui.categories.edit.FavouritesCategoryEditActivity
+import org.koitharu.kotatsu.favourites.ui.categories.select.adapter.MangaCategoriesAdapter
+import org.koitharu.kotatsu.favourites.ui.categories.select.model.MangaCategoryItem
+import org.koitharu.kotatsu.parsers.model.Manga
+
+@AndroidEntryPoint
+class FavouriteCategoriesBottomSheet :
+	BaseBottomSheet<SheetFavoriteCategoriesBinding>(),
+	OnListItemClickListener<MangaCategoryItem>,
+	View.OnClickListener,
+	Toolbar.OnMenuItemClickListener {
+
+	private val viewModel: MangaCategoriesViewModel by viewModels()
+
+	private var adapter: MangaCategoriesAdapter? = null
+
+	override fun onCreateViewBinding(
+		inflater: LayoutInflater,
+		container: ViewGroup?,
+	) = SheetFavoriteCategoriesBinding.inflate(inflater, container, false)
+
+	override fun onViewBindingCreated(binding: SheetFavoriteCategoriesBinding, savedInstanceState: Bundle?) {
+		super.onViewBindingCreated(binding, savedInstanceState)
+		adapter = MangaCategoriesAdapter(this)
+		binding.recyclerViewCategories.adapter = adapter
+		binding.buttonDone.setOnClickListener(this)
+		binding.headerBar.toolbar.setOnMenuItemClickListener(this)
+
+		viewModel.content.observe(viewLifecycleOwner, this::onContentChanged)
+		viewModel.onError.observe(viewLifecycleOwner, ::onError)
+	}
+
+	override fun onDestroyView() {
+		adapter = null
+		super.onDestroyView()
+	}
+
+	override fun onClick(v: View) {
+		when (v.id) {
+			R.id.button_done -> dismiss()
+		}
+	}
+
+	override fun onMenuItemClick(item: MenuItem): Boolean {
+		when (item.itemId) {
+			R.id.action_create -> startActivity(FavouritesCategoryEditActivity.newIntent(requireContext()))
+			else -> return false
+		}
+		return true
+	}
+
+	override fun onItemClick(item: MangaCategoryItem, view: View) {
+		viewModel.setChecked(item.id, !item.isChecked)
+	}
+
+	private fun onContentChanged(categories: List<MangaCategoryItem>) {
+		adapter?.items = categories
+	}
+
+	private fun onError(e: Throwable) {
+		Toast.makeText(context ?: return, e.getDisplayMessage(resources), Toast.LENGTH_SHORT).show()
+	}
+
+	companion object {
+
+		private const val TAG = "FavouriteCategoriesDialog"
+		const val KEY_MANGA_LIST = "manga_list"
+
+		fun show(fm: FragmentManager, manga: Manga) = Companion.show(fm, listOf(manga))
+
+		fun show(fm: FragmentManager, manga: Collection<Manga>) = FavouriteCategoriesBottomSheet().withArgs(1) {
+			putParcelableArrayList(
+				KEY_MANGA_LIST,
+				manga.mapTo(ArrayList(manga.size)) { ParcelableManga(it, withChapters = false) },
+			)
+		}.show(fm, TAG)
+	}
+}

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

@@ -0,0 +1,68 @@
+package org.koitharu.kotatsu.favourites.ui.categories.select
+
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.combine
+import org.koitharu.kotatsu.core.model.ids
+import org.koitharu.kotatsu.core.model.parcelable.ParcelableManga
+import org.koitharu.kotatsu.core.ui.BaseViewModel
+import org.koitharu.kotatsu.core.util.asFlowLiveData
+import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
+import org.koitharu.kotatsu.favourites.ui.categories.select.FavouriteCategoriesBottomSheet.Companion.KEY_MANGA_LIST
+import org.koitharu.kotatsu.favourites.ui.categories.select.model.MangaCategoryItem
+import javax.inject.Inject
+
+@HiltViewModel
+class MangaCategoriesViewModel @Inject constructor(
+	savedStateHandle: SavedStateHandle,
+	private val favouritesRepository: FavouritesRepository,
+) : BaseViewModel() {
+
+	private val manga = requireNotNull(savedStateHandle.get<List<ParcelableManga>>(KEY_MANGA_LIST)).map { it.manga }
+
+	val content = combine(
+		favouritesRepository.observeCategories(),
+		observeCategoriesIds(),
+	) { all, checked ->
+		all.map {
+			MangaCategoryItem(
+				id = it.id,
+				name = it.title,
+				isChecked = it.id in checked,
+			)
+		}
+	}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, emptyList())
+
+	fun setChecked(categoryId: Long, isChecked: Boolean) {
+		launchJob(Dispatchers.Default) {
+			if (isChecked) {
+				favouritesRepository.addToCategory(categoryId, manga)
+			} else {
+				favouritesRepository.removeFromCategory(categoryId, manga.ids())
+			}
+		}
+	}
+
+	private fun observeCategoriesIds() = if (manga.size == 1) {
+		// Fast path
+		favouritesRepository.observeCategoriesIds(manga[0].id)
+	} else {
+		combine(
+			manga.map { favouritesRepository.observeCategoriesIds(it.id) },
+		) { array ->
+			val result = HashSet<Long>()
+			var isFirst = true
+			for (ids in array) {
+				if (isFirst) {
+					result.addAll(ids)
+					isFirst = false
+				} else {
+					result.retainAll(ids.toSet())
+				}
+			}
+			result
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/categories/select/adapter/MangaCategoriesAdapter.kt

@@ -0,0 +1,37 @@
+package org.koitharu.kotatsu.favourites.ui.categories.select.adapter
+
+import androidx.recyclerview.widget.DiffUtil
+import com.hannesdorfmann.adapterdelegates4.AsyncListDifferDelegationAdapter
+import org.koitharu.kotatsu.core.ui.list.OnListItemClickListener
+import org.koitharu.kotatsu.favourites.ui.categories.select.model.MangaCategoryItem
+
+class MangaCategoriesAdapter(
+	clickListener: OnListItemClickListener<MangaCategoryItem>
+) : AsyncListDifferDelegationAdapter<MangaCategoryItem>(DiffCallback()) {
+
+	init {
+		delegatesManager.addDelegate(mangaCategoryAD(clickListener))
+	}
+
+	private class DiffCallback : DiffUtil.ItemCallback<MangaCategoryItem>() {
+		override fun areItemsTheSame(
+			oldItem: MangaCategoryItem,
+			newItem: MangaCategoryItem
+		): Boolean = oldItem.id == newItem.id
+
+		override fun areContentsTheSame(
+			oldItem: MangaCategoryItem,
+			newItem: MangaCategoryItem
+		): Boolean = oldItem == newItem
+
+		override fun getChangePayload(
+			oldItem: MangaCategoryItem,
+			newItem: MangaCategoryItem
+		): Any? {
+			if (oldItem.isChecked != newItem.isChecked) {
+				return newItem.isChecked
+			}
+			return super.getChangePayload(oldItem, newItem)
+		}
+	}
+}

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/categories/select/adapter/MangaCategoryAD.kt

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

app/src/main/kotlin/org/koitharu/kotatsu/favourites/ui/categories/select/model/MangaCategoryItem.kt

@@ -0,0 +1,7 @@
+package org.koitharu.kotatsu.favourites.ui.categories.select.model
+
+data class MangaCategoryItem(
+	val id: Long,
+	val name: String,
+	val isChecked: Boolean
+)

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

@@ -0,0 +1,86 @@
+package org.koitharu.kotatsu.favourites.ui.list
+
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import androidx.appcompat.view.ActionMode
+import androidx.appcompat.widget.PopupMenu
+import androidx.fragment.app.viewModels
+import dagger.hilt.android.AndroidEntryPoint
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.ui.list.ListSelectionController
+import org.koitharu.kotatsu.core.ui.model.titleRes
+import org.koitharu.kotatsu.core.util.ext.addMenuProvider
+import org.koitharu.kotatsu.core.util.ext.withArgs
+import org.koitharu.kotatsu.databinding.FragmentListBinding
+import org.koitharu.kotatsu.favourites.ui.categories.FavouriteCategoriesActivity
+import org.koitharu.kotatsu.list.ui.MangaListFragment
+import org.koitharu.kotatsu.parsers.model.MangaSource
+
+@AndroidEntryPoint
+class FavouritesListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickListener {
+
+	override val viewModel by viewModels<FavouritesListViewModel>()
+
+	override val isSwipeRefreshEnabled = false
+
+	override fun onViewBindingCreated(binding: FragmentListBinding, savedInstanceState: Bundle?) {
+		super.onViewBindingCreated(binding, savedInstanceState)
+		if (viewModel.categoryId != NO_ID) {
+			addMenuProvider(FavouritesListMenuProvider(binding.root.context, viewModel))
+		}
+		viewModel.sortOrder.observe(viewLifecycleOwner) { activity?.invalidateOptionsMenu() }
+	}
+
+	override fun onScrolledToEnd() = Unit
+
+	override fun onFilterClick(view: View?) {
+		val menu = PopupMenu(view?.context ?: return, view)
+		menu.setOnMenuItemClickListener(this)
+		for ((i, item) in FavouriteCategoriesActivity.SORT_ORDERS.withIndex()) {
+			menu.menu.add(Menu.NONE, Menu.NONE, i, item.titleRes)
+		}
+		menu.show()
+	}
+
+	override fun onMenuItemClick(item: MenuItem): Boolean {
+		val order = FavouriteCategoriesActivity.SORT_ORDERS.getOrNull(item.order) ?: return false
+		viewModel.setSortOrder(order)
+		return true
+	}
+
+	override fun onCreateActionMode(controller: ListSelectionController, mode: ActionMode, menu: Menu): Boolean {
+		mode.menuInflater.inflate(R.menu.mode_favourites, menu)
+		return super.onCreateActionMode(controller, mode, menu)
+	}
+
+	override fun onPrepareActionMode(controller: ListSelectionController, mode: ActionMode, menu: Menu): Boolean {
+		menu.findItem(R.id.action_save)?.isVisible = selectedItems.none {
+			it.source == MangaSource.LOCAL
+		}
+		return super.onPrepareActionMode(controller, mode, menu)
+	}
+
+	override fun onActionItemClicked(controller: ListSelectionController, mode: ActionMode, item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.action_remove -> {
+				viewModel.removeFromFavourites(selectedItemsIds)
+				mode.finish()
+				true
+			}
+
+			else -> super.onActionItemClicked(controller, mode, item)
+		}
+	}
+
+	companion object {
+
+		const val NO_ID = 0L
+		const val ARG_CATEGORY_ID = "category_id"
+
+		fun newInstance(categoryId: Long) = FavouritesListFragment().withArgs(1) {
+			putLong(ARG_CATEGORY_ID, categoryId)
+		}
+	}
+}

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

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

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

@@ -0,0 +1,124 @@
+package org.koitharu.kotatsu.favourites.ui.list
+
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.parser.MangaTagHighlighter
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.core.ui.util.ReversibleAction
+import org.koitharu.kotatsu.core.util.asFlowLiveData
+import org.koitharu.kotatsu.download.ui.worker.DownloadWorker
+import org.koitharu.kotatsu.favourites.domain.FavouritesRepository
+import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment.Companion.ARG_CATEGORY_ID
+import org.koitharu.kotatsu.favourites.ui.list.FavouritesListFragment.Companion.NO_ID
+import org.koitharu.kotatsu.history.domain.HistoryRepository
+import org.koitharu.kotatsu.history.domain.PROGRESS_NONE
+import org.koitharu.kotatsu.list.domain.ListExtraProvider
+import org.koitharu.kotatsu.list.ui.MangaListViewModel
+import org.koitharu.kotatsu.list.ui.model.EmptyState
+import org.koitharu.kotatsu.list.ui.model.LoadingState
+import org.koitharu.kotatsu.list.ui.model.toErrorState
+import org.koitharu.kotatsu.list.ui.model.toUi
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.tracker.domain.TrackingRepository
+import javax.inject.Inject
+
+@HiltViewModel
+class FavouritesListViewModel @Inject constructor(
+	savedStateHandle: SavedStateHandle,
+	private val repository: FavouritesRepository,
+	private val trackingRepository: TrackingRepository,
+	private val historyRepository: HistoryRepository,
+	private val settings: AppSettings,
+	private val tagHighlighter: MangaTagHighlighter,
+	downloadScheduler: DownloadWorker.Scheduler,
+) : MangaListViewModel(settings, downloadScheduler), ListExtraProvider {
+
+	val categoryId: Long = savedStateHandle[ARG_CATEGORY_ID] ?: NO_ID
+
+	val sortOrder: LiveData<SortOrder?> = if (categoryId == NO_ID) {
+		MutableLiveData(null)
+	} else {
+		repository.observeCategory(categoryId)
+			.map { it?.order }
+			.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, null)
+	}
+
+	override val content = combine(
+		if (categoryId == NO_ID) {
+			repository.observeAll(SortOrder.NEWEST)
+		} else {
+			repository.observeAll(categoryId)
+		},
+		listModeFlow,
+	) { list, mode ->
+		when {
+			list.isEmpty() -> listOf(
+				EmptyState(
+					icon = R.drawable.ic_empty_favourites,
+					textPrimary = R.string.text_empty_holder_primary,
+					textSecondary = if (categoryId == NO_ID) {
+						R.string.you_have_not_favourites_yet
+					} else {
+						R.string.favourites_category_empty
+					},
+					actionStringRes = 0,
+				),
+			)
+
+			else -> list.toUi(mode, this, tagHighlighter)
+		}
+	}.catch {
+		emit(listOf(it.toErrorState(canRetry = false)))
+	}.asFlowLiveData(viewModelScope.coroutineContext + Dispatchers.Default, listOf(LoadingState))
+
+	override fun onRefresh() = Unit
+
+	override fun onRetry() = Unit
+
+	fun removeFromFavourites(ids: Set<Long>) {
+		if (ids.isEmpty()) {
+			return
+		}
+		launchJob(Dispatchers.Default) {
+			val handle = if (categoryId == NO_ID) {
+				repository.removeFromFavourites(ids)
+			} else {
+				repository.removeFromCategory(categoryId, ids)
+			}
+			onActionDone.emitCall(ReversibleAction(R.string.removed_from_favourites, handle))
+		}
+	}
+
+	fun setSortOrder(order: SortOrder) {
+		if (categoryId == NO_ID) {
+			return
+		}
+		launchJob {
+			repository.setCategoryOrder(categoryId, order)
+		}
+	}
+
+	override suspend fun getCounter(mangaId: Long): Int {
+		return if (settings.isTrackerEnabled) {
+			trackingRepository.getNewChaptersCount(mangaId)
+		} else {
+			0
+		}
+	}
+
+	override suspend fun getProgress(mangaId: Long): Float {
+		return if (settings.isReadingIndicatorsEnabled) {
+			historyRepository.getProgress(mangaId)
+		} else {
+			PROGRESS_NONE
+		}
+	}
+}