lots of background work for manga extensions

app/src/main/java/tachiyomi/core/preference/Preference.kt

@@ -0,0 +1,26 @@
+package tachiyomi.core.preference
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+
+interface Preference<T> {
+
+    fun key(): String
+
+    fun get(): T
+
+    fun set(value: T)
+
+    fun isSet(): Boolean
+
+    fun delete()
+
+    fun defaultValue(): T
+
+    fun changes(): Flow<T>
+
+    fun stateIn(scope: CoroutineScope): StateFlow<T>
+}
+
+inline fun <reified T, R : T> Preference<T>.getAndSet(crossinline block: (T) -> R) = set(block(get()))

app/src/main/java/tachiyomi/core/preference/PreferenceStore.kt

@@ -0,0 +1,41 @@
+package tachiyomi.core.preference
+
+interface PreferenceStore {
+
+    fun getString(key: String, defaultValue: String = ""): Preference<String>
+
+    fun getLong(key: String, defaultValue: Long = 0): Preference<Long>
+
+    fun getInt(key: String, defaultValue: Int = 0): Preference<Int>
+
+    fun getFloat(key: String, defaultValue: Float = 0f): Preference<Float>
+
+    fun getBoolean(key: String, defaultValue: Boolean = false): Preference<Boolean>
+
+    fun getStringSet(key: String, defaultValue: Set<String> = emptySet()): Preference<Set<String>>
+
+    fun <T> getObject(
+        key: String,
+        defaultValue: T,
+        serializer: (T) -> String,
+        deserializer: (String) -> T,
+    ): Preference<T>
+}
+
+inline fun <reified T : Enum<T>> PreferenceStore.getEnum(
+    key: String,
+    defaultValue: T,
+): Preference<T> {
+    return getObject(
+        key = key,
+        defaultValue = defaultValue,
+        serializer = { it.name },
+        deserializer = {
+            try {
+                enumValueOf(it)
+            } catch (e: IllegalArgumentException) {
+                defaultValue
+            }
+        },
+    )
+}

app/src/main/java/tachiyomi/core/util/lang/CoroutinesExtensions.kt

@@ -0,0 +1,60 @@
+package tachiyomi.core.util.lang
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/**
+ * Think twice before using this. This is a delicate API. It is easy to accidentally create resource or memory leaks when GlobalScope is used.
+ *
+ * **Possible replacements**
+ * - suspend function
+ * - custom scope like view or presenter scope
+ */
+@DelicateCoroutinesApi
+fun launchUI(block: suspend CoroutineScope.() -> Unit): Job =
+    GlobalScope.launch(Dispatchers.Main, CoroutineStart.DEFAULT, block)
+
+/**
+ * Think twice before using this. This is a delicate API. It is easy to accidentally create resource or memory leaks when GlobalScope is used.
+ *
+ * **Possible replacements**
+ * - suspend function
+ * - custom scope like view or presenter scope
+ */
+@DelicateCoroutinesApi
+fun launchIO(block: suspend CoroutineScope.() -> Unit): Job =
+    GlobalScope.launch(Dispatchers.IO, CoroutineStart.DEFAULT, block)
+
+/**
+ * Think twice before using this. This is a delicate API. It is easy to accidentally create resource or memory leaks when GlobalScope is used.
+ *
+ * **Possible replacements**
+ * - suspend function
+ * - custom scope like view or presenter scope
+ */
+@DelicateCoroutinesApi
+fun launchNow(block: suspend CoroutineScope.() -> Unit): Job =
+    GlobalScope.launch(Dispatchers.Main, CoroutineStart.UNDISPATCHED, block)
+
+fun CoroutineScope.launchUI(block: suspend CoroutineScope.() -> Unit): Job =
+    launch(Dispatchers.Main, block = block)
+
+fun CoroutineScope.launchIO(block: suspend CoroutineScope.() -> Unit): Job =
+    launch(Dispatchers.IO, block = block)
+
+fun CoroutineScope.launchNonCancellable(block: suspend CoroutineScope.() -> Unit): Job =
+    launchIO { withContext(NonCancellable, block) }
+
+suspend fun <T> withUIContext(block: suspend CoroutineScope.() -> T) = withContext(Dispatchers.Main, block)
+
+suspend fun <T> withIOContext(block: suspend CoroutineScope.() -> T) = withContext(Dispatchers.IO, block)
+
+suspend fun <T> withNonCancellableContext(block: suspend CoroutineScope.() -> T) =
+    withContext(NonCancellable, block)

app/src/main/java/tachiyomi/core/util/system/LogcatExtensions.kt

@@ -0,0 +1,18 @@
+package tachiyomi.core.util.system
+
+import logcat.LogPriority
+import logcat.asLog
+import logcat.logcat
+
+inline fun Any.logcat(
+    priority: LogPriority = LogPriority.DEBUG,
+    throwable: Throwable? = null,
+    message: () -> String = { "" },
+) = logcat(priority = priority) {
+    var msg = message()
+    if (throwable != null) {
+        if (msg.isNotBlank()) msg += "\n"
+        msg += throwable.asLog()
+    }
+    msg
+}

app/src/main/java/tachiyomi/domain/category/model/Category.kt

@@ -0,0 +1,18 @@
+package tachiyomi.domain.category.model
+
+import java.io.Serializable
+
+data class Category(
+    val id: Long,
+    val name: String,
+    val order: Long,
+    val flags: Long,
+    val hidden: Boolean,
+) : Serializable {
+
+    val isSystemCategory: Boolean = id == UNCATEGORIZED_ID
+
+    companion object {
+        const val UNCATEGORIZED_ID = 0L
+    }
+}

app/src/main/java/tachiyomi/domain/library/model/Flag.kt

@@ -0,0 +1,35 @@
+package tachiyomi.domain.library.model
+
+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
+    }
+}

app/src/main/java/tachiyomi/domain/library/model/LibraryDisplayMode.kt

@@ -0,0 +1,59 @@
+package tachiyomi.domain.library.model
+
+import tachiyomi.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 Companion.deserialize(serialized)
+        }
+
+        fun serialize(value: LibraryDisplayMode): String {
+            return value.serialize()
+        }
+    }
+
+    companion object {
+        val values by lazy { 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(this?.flags)

app/src/main/java/tachiyomi/domain/source/anime/model/AnimeSourceData.kt

@@ -0,0 +1,10 @@
+package tachiyomi.domain.source.anime.model
+
+data class AnimeSourceData(
+    val id: Long,
+    val lang: String,
+    val name: String,
+) {
+
+    val isMissingInfo: Boolean = name.isBlank() || lang.isBlank()
+}

app/src/main/java/tachiyomi/domain/source/manga/model/MangaSourceData.kt

@@ -0,0 +1,10 @@
+package tachiyomi.domain.source.manga.model
+
+data class MangaSourceData(
+    val id: Long,
+    val lang: String,
+    val name: String,
+) {
+
+    val isMissingInfo: Boolean = name.isBlank() || lang.isBlank()
+}