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
+}