Split library preferences from PreferencesHelper (#8036)

2022-09-20 05:55:07 +02:00
parent 0e3176a77c
commit c740558327
31 changed files with 234 additions and 193 deletions
@@ -22,6 +22,9 @@ import eu.kanade.domain.category.model.Category
 import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
 import eu.kanade.domain.chapter.interactor.SetReadStatus
 import eu.kanade.domain.chapter.model.toDbChapter
+import eu.kanade.domain.library.model.LibrarySort
+import eu.kanade.domain.library.model.sort
+import eu.kanade.domain.library.service.LibraryPreferences
 import eu.kanade.domain.manga.interactor.GetLibraryManga
 import eu.kanade.domain.manga.interactor.UpdateManga
 import eu.kanade.domain.manga.model.Manga
@@ -43,8 +46,6 @@ import eu.kanade.tachiyomi.source.SourceManager
 import eu.kanade.tachiyomi.source.model.SManga
 import eu.kanade.tachiyomi.source.online.HttpSource
 import eu.kanade.tachiyomi.ui.base.presenter.BasePresenter
-import eu.kanade.tachiyomi.ui.library.setting.LibrarySort
-import eu.kanade.tachiyomi.ui.library.setting.sort
 import eu.kanade.tachiyomi.util.lang.combineLatest
 import eu.kanade.tachiyomi.util.lang.launchIO
 import eu.kanade.tachiyomi.util.lang.launchNonCancellableIO
@@ -90,6 +91,7 @@ class LibraryPresenter(
    private val updateManga: UpdateManga = Injekt.get(),
    private val setMangaCategories: SetMangaCategories = Injekt.get(),
    private val preferences: PreferencesHelper = Injekt.get(),
+    private val libraryPreferences: LibraryPreferences = Injekt.get(),
    private val coverCache: CoverCache = Injekt.get(),
    private val sourceManager: SourceManager = Injekt.get(),
    private val downloadManager: DownloadManager = Injekt.get(),
@@ -100,10 +102,10 @@ class LibraryPresenter(

    val isLibraryEmpty by derivedStateOf { loadedManga.isEmpty() }

-    val tabVisibility by preferences.categoryTabs().asState()
-    val mangaCountVisibility by preferences.categoryNumberOfItems().asState()
+    val tabVisibility by libraryPreferences.categoryTabs().asState()
+    val mangaCountVisibility by libraryPreferences.categoryNumberOfItems().asState()

-    var activeCategory: Int by preferences.lastUsedCategory().asState()
+    var activeCategory: Int by libraryPreferences.lastUsedCategory().asState()

    val isDownloadOnly: Boolean by preferences.downloadedOnly().asState()
    val isIncognitoMode: Boolean by preferences.incognitoMode().asState()
@@ -170,13 +172,13 @@ class LibraryPresenter(
     */
    private fun applyFilters(map: LibraryMap, trackMap: Map<Long, Map<Long, Boolean>>): LibraryMap {
        val downloadedOnly = preferences.downloadedOnly().get()
-        val filterDownloaded = preferences.filterDownloaded().get()
-        val filterUnread = preferences.filterUnread().get()
-        val filterStarted = preferences.filterStarted().get()
-        val filterCompleted = preferences.filterCompleted().get()
+        val filterDownloaded = libraryPreferences.filterDownloaded().get()
+        val filterUnread = libraryPreferences.filterUnread().get()
+        val filterStarted = libraryPreferences.filterStarted().get()
+        val filterCompleted = libraryPreferences.filterCompleted().get()
        val loggedInServices = trackManager.services.filter { trackService -> trackService.isLogged }
            .associate { trackService ->
-                Pair(trackService.id, preferences.filterTracking(trackService.id.toInt()).get())
+                Pair(trackService.id, libraryPreferences.filterTracking(trackService.id.toInt()).get())
            }
        val isNotAnyLoggedIn = !loggedInServices.values.any()

@@ -271,10 +273,10 @@ class LibraryPresenter(
     * @param map the map of manga.
     */
    private fun setBadges(map: LibraryMap) {
-        val showDownloadBadges = preferences.downloadBadge().get()
-        val showUnreadBadges = preferences.unreadBadge().get()
-        val showLocalBadges = preferences.localBadge().get()
-        val showLanguageBadges = preferences.languageBadge().get()
+        val showDownloadBadges = libraryPreferences.downloadBadge().get()
+        val showUnreadBadges = libraryPreferences.unreadBadge().get()
+        val showLocalBadges = libraryPreferences.localBadge().get()
+        val showLanguageBadges = libraryPreferences.languageBadge().get()

        for ((_, itemList) in map) {
            for (item in itemList) {
@@ -611,7 +613,7 @@ class LibraryPresenter(
    }

    fun getColumnsPreferenceForCurrentOrientation(isLandscape: Boolean): PreferenceMutableState<Int> {
-        return (if (isLandscape) preferences.landscapeColumns() else preferences.portraitColumns()).asState()
+        return (if (isLandscape) libraryPreferences.landscapeColumns() else libraryPreferences.portraitColumns()).asState()
    }

    // TODO: This is good but should we separate title from count or get categories with count from db
@@ -7,14 +7,15 @@ import com.bluelinelabs.conductor.Router
 import eu.kanade.domain.category.interactor.SetDisplayModeForCategory
 import eu.kanade.domain.category.interactor.SetSortModeForCategory
 import eu.kanade.domain.category.model.Category
+import eu.kanade.domain.library.model.LibraryDisplayMode
+import eu.kanade.domain.library.model.LibrarySort
+import eu.kanade.domain.library.model.display
+import eu.kanade.domain.library.model.sort
+import eu.kanade.domain.library.service.LibraryPreferences
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.data.track.TrackManager
 import eu.kanade.tachiyomi.data.track.TrackService
-import eu.kanade.tachiyomi.ui.library.setting.LibraryDisplayMode
-import eu.kanade.tachiyomi.ui.library.setting.LibrarySort
-import eu.kanade.tachiyomi.ui.library.setting.display
-import eu.kanade.tachiyomi.ui.library.setting.sort
 import eu.kanade.tachiyomi.util.lang.launchIO
 import eu.kanade.tachiyomi.widget.ExtendedNavigationView
 import eu.kanade.tachiyomi.widget.ExtendedNavigationView.Item.TriStateGroup.State
@@ -129,14 +130,14 @@ class LibrarySettingsSheet(
                    downloaded.state = State.INCLUDE.value
                    downloaded.enabled = false
                } else {
-                    downloaded.state = preferences.filterDownloaded().get()
+                    downloaded.state = libraryPreferences.filterDownloaded().get()
                }
-                unread.state = preferences.filterUnread().get()
-                started.state = preferences.filterStarted().get()
-                completed.state = preferences.filterCompleted().get()
+                unread.state = libraryPreferences.filterUnread().get()
+                started.state = libraryPreferences.filterStarted().get()
+                completed.state = libraryPreferences.filterCompleted().get()

                trackFilters.forEach { trackFilter ->
-                    trackFilter.value.state = preferences.filterTracking(trackFilter.key.toInt()).get()
+                    trackFilter.value.state = libraryPreferences.filterTracking(trackFilter.key.toInt()).get()
                }
            }

@@ -150,14 +151,14 @@ class LibrarySettingsSheet(
                }
                item.state = newState
                when (item) {
-                    downloaded -> preferences.filterDownloaded().set(newState)
-                    unread -> preferences.filterUnread().set(newState)
-                    started -> preferences.filterStarted().set(newState)
-                    completed -> preferences.filterCompleted().set(newState)
+                    downloaded -> libraryPreferences.filterDownloaded().set(newState)
+                    unread -> libraryPreferences.filterUnread().set(newState)
+                    started -> libraryPreferences.filterStarted().set(newState)
+                    completed -> libraryPreferences.filterCompleted().set(newState)
                    else -> {
                        trackFilters.forEach { trackFilter ->
                            if (trackFilter.value == item) {
-                                preferences.filterTracking(trackFilter.key.toInt()).set(newState)
+                                libraryPreferences.filterTracking(trackFilter.key.toInt()).set(newState)
                            }
                        }
                    }
@@ -360,20 +361,20 @@ class LibrarySettingsSheet(
            override val footer = null

            override fun initModels() {
-                downloadBadge.checked = preferences.downloadBadge().get()
-                unreadBadge.checked = preferences.unreadBadge().get()
-                localBadge.checked = preferences.localBadge().get()
-                languageBadge.checked = preferences.languageBadge().get()
+                downloadBadge.checked = libraryPreferences.downloadBadge().get()
+                unreadBadge.checked = libraryPreferences.unreadBadge().get()
+                localBadge.checked = libraryPreferences.localBadge().get()
+                languageBadge.checked = libraryPreferences.languageBadge().get()
            }

            override fun onItemClicked(item: Item) {
                item as Item.CheckboxGroup
                item.checked = !item.checked
                when (item) {
-                    downloadBadge -> preferences.downloadBadge().set((item.checked))
-                    unreadBadge -> preferences.unreadBadge().set((item.checked))
-                    localBadge -> preferences.localBadge().set((item.checked))
-                    languageBadge -> preferences.languageBadge().set((item.checked))
+                    downloadBadge -> libraryPreferences.downloadBadge().set((item.checked))
+                    unreadBadge -> libraryPreferences.unreadBadge().set((item.checked))
+                    localBadge -> libraryPreferences.localBadge().set((item.checked))
+                    languageBadge -> libraryPreferences.languageBadge().set((item.checked))
                    else -> {}
                }
                adapter.notifyItemChanged(item)
@@ -389,16 +390,16 @@ class LibrarySettingsSheet(
            override val footer = null

            override fun initModels() {
-                showTabs.checked = preferences.categoryTabs().get()
-                showNumberOfItems.checked = preferences.categoryNumberOfItems().get()
+                showTabs.checked = libraryPreferences.categoryTabs().get()
+                showNumberOfItems.checked = libraryPreferences.categoryNumberOfItems().get()
            }

            override fun onItemClicked(item: Item) {
                item as Item.CheckboxGroup
                item.checked = !item.checked
                when (item) {
-                    showTabs -> preferences.categoryTabs().set(item.checked)
-                    showNumberOfItems -> preferences.categoryNumberOfItems().set(item.checked)
+                    showTabs -> libraryPreferences.categoryTabs().set(item.checked)
+                    showNumberOfItems -> libraryPreferences.categoryNumberOfItems().set(item.checked)
                    else -> {}
                }
                adapter.notifyItemChanged(item)
@@ -410,6 +411,7 @@ class LibrarySettingsSheet(
        ExtendedNavigationView(context, attrs) {

        val preferences: PreferencesHelper by injectLazy()
+        val libraryPreferences: LibraryPreferences by injectLazy()
        lateinit var adapter: Adapter

        /**
@@ -1,35 +0,0 @@
-package eu.kanade.tachiyomi.ui.library.setting
-
-interface Flag {
-    val flag: Long
-}
-
-interface Mask {
-    val mask: Long
-}
-
-interface FlagWithMask : Flag, Mask
-
-operator fun Long.contains(other: Flag): Boolean {
-    return if (other is Mask) {
-        other.flag == this and other.mask
-    } else {
-        other.flag == this
-    }
-}
-
-operator fun Long.plus(other: Flag): Long {
-    return if (other is Mask) {
-        this and other.mask.inv() or (other.flag and other.mask)
-    } else {
-        this or other.flag
-    }
-}
-
-operator fun Flag.plus(other: Flag): Long {
-    return if (other is Mask) {
-        this.flag and other.mask.inv() or (other.flag and other.mask)
-    } else {
-        this.flag or other.flag
-    }
-}
@@ -1,59 +0,0 @@
-package eu.kanade.tachiyomi.ui.library.setting
-
-import eu.kanade.domain.category.model.Category
-
-sealed class LibraryDisplayMode(
-    override val flag: Long,
-) : FlagWithMask {
-
-    override val mask: Long = 0b00000011L
-
-    object CompactGrid : LibraryDisplayMode(0b00000000)
-    object ComfortableGrid : LibraryDisplayMode(0b00000001)
-    object List : LibraryDisplayMode(0b00000010)
-    object CoverOnlyGrid : LibraryDisplayMode(0b00000011)
-
-    object Serializer {
-        fun deserialize(serialized: String): LibraryDisplayMode {
-            return LibraryDisplayMode.deserialize(serialized)
-        }
-
-        fun serialize(value: LibraryDisplayMode): String {
-            return value.serialize()
-        }
-    }
-
-    companion object {
-        val values = setOf(CompactGrid, ComfortableGrid, List, CoverOnlyGrid)
-        val default = CompactGrid
-
-        fun valueOf(flag: Long?): LibraryDisplayMode {
-            if (flag == null) return default
-            return values
-                .find { mode -> mode.flag == flag and mode.mask }
-                ?: default
-        }
-
-        fun deserialize(serialized: String): LibraryDisplayMode {
-            return when (serialized) {
-                "COMFORTABLE_GRID" -> ComfortableGrid
-                "COMPACT_GRID" -> CompactGrid
-                "COVER_ONLY_GRID" -> CoverOnlyGrid
-                "LIST" -> List
-                else -> default
-            }
-        }
-    }
-
-    fun serialize(): String {
-        return when (this) {
-            ComfortableGrid -> "COMFORTABLE_GRID"
-            CompactGrid -> "COMPACT_GRID"
-            CoverOnlyGrid -> "COVER_ONLY_GRID"
-            List -> "LIST"
-        }
-    }
-}
-
-val Category.display: LibraryDisplayMode
-    get() = LibraryDisplayMode.valueOf(flags)
@@ -1,121 +0,0 @@
-package eu.kanade.tachiyomi.ui.library.setting
-
-import eu.kanade.domain.category.model.Category
-
-data class LibrarySort(
-    val type: Type,
-    val direction: Direction,
-) : FlagWithMask {
-
-    override val flag: Long
-        get() = type + direction
-
-    override val mask: Long
-        get() = type.mask or direction.mask
-
-    val isAscending: Boolean
-        get() = direction == Direction.Ascending
-
-    sealed class Type(
-        override val flag: Long,
-    ) : FlagWithMask {
-
-        override val mask: Long = 0b00111100L
-
-        object Alphabetical : Type(0b00000000)
-        object LastRead : Type(0b00000100)
-        object LastUpdate : Type(0b00001000)
-        object UnreadCount : Type(0b00001100)
-        object TotalChapters : Type(0b00010000)
-        object LatestChapter : Type(0b00010100)
-        object ChapterFetchDate : Type(0b00011000)
-        object DateAdded : Type(0b00011100)
-
-        companion object {
-
-            fun valueOf(flag: Long): Type {
-                return types.find { type -> type.flag == flag and type.mask } ?: default.type
-            }
-        }
-    }
-
-    sealed class Direction(
-        override val flag: Long,
-    ) : FlagWithMask {
-
-        override val mask: Long = 0b01000000L
-
-        object Ascending : Direction(0b01000000)
-        object Descending : Direction(0b00000000)
-
-        companion object {
-
-            fun valueOf(flag: Long): Direction {
-                return directions.find { direction -> direction.flag == flag and direction.mask } ?: default.direction
-            }
-        }
-    }
-
-    object Serializer {
-        fun deserialize(serialized: String): LibrarySort {
-            return LibrarySort.deserialize(serialized)
-        }
-
-        fun serialize(value: LibrarySort): String {
-            return value.serialize()
-        }
-    }
-
-    companion object {
-        val types = setOf(Type.Alphabetical, Type.LastRead, Type.LastUpdate, Type.UnreadCount, Type.TotalChapters, Type.LatestChapter, Type.ChapterFetchDate, Type.DateAdded)
-        val directions = setOf(Direction.Ascending, Direction.Descending)
-        val default = LibrarySort(Type.Alphabetical, Direction.Ascending)
-
-        fun valueOf(flag: Long): LibrarySort {
-            return LibrarySort(
-                Type.valueOf(flag),
-                Direction.valueOf(flag),
-            )
-        }
-
-        fun deserialize(serialized: String): LibrarySort {
-            if (serialized.isEmpty()) return default
-            return try {
-                val values = serialized.split(",")
-                val type = when (values[0]) {
-                    "ALPHABETICAL" -> Type.Alphabetical
-                    "LAST_READ" -> Type.LastRead
-                    "LAST_MANGA_UPDATE" -> Type.LastUpdate
-                    "UNREAD_COUNT" -> Type.UnreadCount
-                    "TOTAL_CHAPTERS" -> Type.TotalChapters
-                    "LATEST_CHAPTER" -> Type.LatestChapter
-                    "CHAPTER_FETCH_DATE" -> Type.ChapterFetchDate
-                    "DATE_ADDED" -> Type.DateAdded
-                    else -> Type.Alphabetical
-                }
-                val ascending = if (values[1] == "ASCENDING") Direction.Ascending else Direction.Descending
-                LibrarySort(type, ascending)
-            } catch (e: Exception) {
-                default
-            }
-        }
-    }
-
-    fun serialize(): String {
-        val type = when (type) {
-            Type.Alphabetical -> "ALPHABETICAL"
-            Type.LastRead -> "LAST_READ"
-            Type.LastUpdate -> "LAST_MANGA_UPDATE"
-            Type.UnreadCount -> "UNREAD_COUNT"
-            Type.TotalChapters -> "TOTAL_CHAPTERS"
-            Type.LatestChapter -> "LATEST_CHAPTER"
-            Type.ChapterFetchDate -> "CHAPTER_FETCH_DATE"
-            Type.DateAdded -> "DATE_ADDED"
-        }
-        val direction = if (direction == Direction.Ascending) "ASCENDING" else "DESCENDING"
-        return "$type,$direction"
-    }
-}
-
-val Category.sort: LibrarySort
-    get() = LibrarySort.valueOf(flags)