Remove unused Rx/Coroutines converters

app/src/main/java/eu/kanade/core/util/RxJavaExtensions.kt

@@ -1,61 +0,0 @@
-package eu.kanade.core.util
-
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
-import kotlinx.coroutines.launch
-import rx.Emitter
-import rx.Observable
-import rx.Observer
-import kotlin.coroutines.CoroutineContext
-
-fun <T : Any> Observable<T>.asFlow(): Flow<T> = callbackFlow {
-    val observer = object : Observer<T> {
-        override fun onNext(t: T) {
-            trySend(t)
-        }
-
-        override fun onError(e: Throwable) {
-            close(e)
-        }
-
-        override fun onCompleted() {
-            close()
-        }
-    }
-    val subscription = subscribe(observer)
-    awaitClose { subscription.unsubscribe() }
-}
-
-fun <T : Any> Flow<T>.asObservable(
-    context: CoroutineContext = Dispatchers.Unconfined,
-    backpressureMode: Emitter.BackpressureMode = Emitter.BackpressureMode.NONE,
-): Observable<T> {
-    return Observable.create(
-        { emitter ->
-            /*
-             * ATOMIC is used here to provide stable behaviour of subscribe+dispose pair even if
-             * asObservable is already invoked from unconfined
-             */
-            val job = GlobalScope.launch(context = context, start = CoroutineStart.ATOMIC) {
-                try {
-                    collect { emitter.onNext(it) }
-                    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,
-    )
-}

app/src/main/java/eu/kanade/tachiyomi/data/download/Downloader.kt

@@ -20,7 +20,6 @@ import eu.kanade.tachiyomi.source.model.Page
 import eu.kanade.tachiyomi.source.online.HttpSource
 import eu.kanade.tachiyomi.source.online.fetchAllImageUrlsFromPageList
 import eu.kanade.tachiyomi.util.lang.RetryWithDelay
-import eu.kanade.tachiyomi.util.lang.plusAssign
 import eu.kanade.tachiyomi.util.storage.DiskUtil
 import eu.kanade.tachiyomi.util.storage.DiskUtil.NOMEDIA_FILE
 import eu.kanade.tachiyomi.util.storage.saveTo
@@ -30,6 +29,7 @@ import logcat.LogPriority
 import nl.adaptivity.xmlutil.serialization.XML
 import okhttp3.Response
 import rx.Observable
+import rx.Subscription
 import rx.android.schedulers.AndroidSchedulers
 import rx.schedulers.Schedulers
 import rx.subscriptions.CompositeSubscription
@@ -637,6 +637,8 @@ class Downloader(
         return queue.none { it.status.value <= Download.State.DOWNLOADING.value }
     }
 
+    private operator fun CompositeSubscription.plusAssign(subscription: Subscription) = add(subscription)
+
     companion object {
         const val TMP_DIR_SUFFIX = "_tmp"
         const val WARNING_NOTIF_TIMEOUT_MS = 30_000L

app/src/main/java/eu/kanade/tachiyomi/util/lang/RxExtensions.kt

@@ -1,6 +0,0 @@
-package eu.kanade.tachiyomi.util.lang
-
-import rx.Subscription
-import rx.subscriptions.CompositeSubscription
-
-operator fun CompositeSubscription.plusAssign(subscription: Subscription) = add(subscription)

core/src/main/java/tachiyomi/core/util/lang/RxCoroutineBridge.kt

@@ -1,15 +1,8 @@
 package tachiyomi.core.util.lang
 
 import kotlinx.coroutines.CancellableContinuation
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.InternalCoroutinesApi
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
-import rx.Emitter
 import rx.Observable
 import rx.Subscriber
 import rx.Subscription
@@ -61,31 +54,5 @@ private suspend fun <T> Observable<T>.awaitOne(): T = suspendCancellableCoroutin
     )
 }
 
-internal fun <T> CancellableContinuation<T>.unsubscribeOnCancellation(sub: Subscription) =
+private fun <T> CancellableContinuation<T>.unsubscribeOnCancellation(sub: Subscription) =
     invokeOnCancellation { sub.unsubscribe() }
-
-@OptIn(ExperimentalCoroutinesApi::class)
-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,
-    )
-}