Extract source api from app module (#8014)

* Extract source api from app module * Extract source online api from app module
2022-09-16 00:12:27 +02:00
parent 30ac94181b
commit 86fe850794
53 changed files with 219 additions and 106 deletions
@@ -1,57 +0,0 @@
-package eu.kanade.tachiyomi.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.launchNonCancellableIO(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)
@@ -1,87 +0,0 @@
-package eu.kanade.tachiyomi.util.lang
-
-import kotlinx.coroutines.CancellableContinuation
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.suspendCancellableCoroutine
-import rx.Emitter
-import rx.Observable
-import rx.Subscriber
-import rx.Subscription
-import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
-
-/*
- * Util functions for bridging RxJava and coroutines. Taken from TachiyomiEH/SY.
- */
-
-suspend fun <T> Observable<T>.awaitSingle(): T = single().awaitOne()
-
-private suspend fun <T> Observable<T>.awaitOne(): T = suspendCancellableCoroutine { cont ->
-    cont.unsubscribeOnCancellation(
-        subscribe(
-            object : Subscriber<T>() {
-                override fun onStart() {
-                    request(1)
-                }
-
-                override fun onNext(t: T) {
-                    cont.resume(t)
-                }
-
-                override fun onCompleted() {
-                    if (cont.isActive) {
-                        cont.resumeWithException(
-                            IllegalStateException(
-                                "Should have invoked onNext",
-                            ),
-                        )
-                    }
-                }
-
-                override fun onError(e: Throwable) {
-                    /*
-                     * Rx1 observable throws NoSuchElementException if cancellation happened before
-                     * element emission. To mitigate this we try to atomically resume continuation with exception:
-                     * if resume failed, then we know that continuation successfully cancelled itself
-                     */
-                    val token = cont.tryResumeWithException(e)
-                    if (token != null) {
-                        cont.completeResume(token)
-                    }
-                }
-            },
-        ),
-    )
-}
-
-internal fun <T> CancellableContinuation<T>.unsubscribeOnCancellation(sub: Subscription) =
-    invokeOnCancellation { sub.unsubscribe() }
-
-fun <T> runAsObservable(
-    backpressureMode: Emitter.BackpressureMode = Emitter.BackpressureMode.NONE,
-    block: suspend () -> T,
-): Observable<T> {
-    return Observable.create(
-        { emitter ->
-            val job = GlobalScope.launch(Dispatchers.Unconfined, start = CoroutineStart.ATOMIC) {
-                try {
-                    emitter.onNext(block())
-                    emitter.onCompleted()
-                } catch (e: Throwable) {
-                    // Ignore `CancellationException` as error, since it indicates "normal cancellation"
-                    if (e !is CancellationException) {
-                        emitter.onError(e)
-                    } else {
-                        emitter.onCompleted()
-                    }
-                }
-            }
-            emitter.setCancellation { job.cancel() }
-        },
-        backpressureMode,
-    )
-}