Replace RxJava3 code with coroutines (#4290)

This pull request removes the remaining RxJava code and replaces it with
coroutine-equivalent implementations.

- Remove all duplicate methods in `MastodonApi`:
- Methods returning a RxJava `Single` have been replaced by suspending
methods returning a `NetworkResult` in order to be consistent with the
new code.
- _sync_/_async_ method variants are replaced with the _async_ version
only (suspending method), and `runBlocking{}` is used to make the async
variant synchronous.
- Create a custom coroutine-based implementation of `Single` for usage
in Java code where launching a coroutine is not possible. This class can
be deleted after remaining Java code has been converted to Kotlin.
- `NotificationsFragment.java` can subscribe to `EventHub` events by
calling the new lifecycle-aware `EventHub.subscribe()` method. This
allows using the `SharedFlow` as single source of truth for all events.
- Rx Autodispose is replaced by `lifecycleScope.launch()` which will
automatically cancel the coroutine when the Fragment view/Activity is
destroyed.
- Background work is launched in the existing injectable
`externalScope`, since using `GlobalScope` is discouraged.
`externalScope` has been changed to be a `@Singleton` and to use the
main dispatcher by default.
- Transform `ShareShortcutHelper` to an injectable utility class so it
can use the application `Context` and `externalScope` as provided
dependencies to launch a background coroutine.
- Implement a custom Glide extension method
`RequestBuilder.submitAsync()` to do the same thing as
`RequestBuilder.submit().get()` in a non-blocking way. This way there is
no need to switch to a background dispatcher and block a background
thread, and cancellation is supported out-of-the-box.
- An utility method `Fragment.updateRelativeTimePeriodically()` has been
added to remove duplicate logic in `TimelineFragment` and
`NotificationsFragment`, and the logic is now implemented using a simple
coroutine instead of `Observable.interval()`. Note that the periodic
update now happens between onStart and onStop instead of between
onResume and onPause, since the Fragment is not interactive but is still
visible in the started state.
- Rewrite `BottomSheetActivityTest` using coroutines tests.
- Remove all RxJava library dependencies.

app/src/main/java/com/keylesspalace/tusky/usecase/TimelineCases.kt

@@ -20,6 +20,7 @@ import at.connyduck.calladapter.networkresult.NetworkResult
 import at.connyduck.calladapter.networkresult.fold
 import at.connyduck.calladapter.networkresult.onFailure
 import at.connyduck.calladapter.networkresult.onSuccess
+import at.connyduck.calladapter.networkresult.runCatching
 import com.keylesspalace.tusky.appstore.BlockEvent
 import com.keylesspalace.tusky.appstore.EventHub
 import com.keylesspalace.tusky.appstore.MuteConversationEvent
@@ -28,13 +29,16 @@ import com.keylesspalace.tusky.appstore.PollVoteEvent
 import com.keylesspalace.tusky.appstore.StatusChangedEvent
 import com.keylesspalace.tusky.appstore.StatusDeletedEvent
 import com.keylesspalace.tusky.entity.DeletedStatus
+import com.keylesspalace.tusky.entity.Notification
 import com.keylesspalace.tusky.entity.Poll
 import com.keylesspalace.tusky.entity.Relationship
 import com.keylesspalace.tusky.entity.Status
 import com.keylesspalace.tusky.network.MastodonApi
+import com.keylesspalace.tusky.util.Single
 import com.keylesspalace.tusky.util.getServerErrorMessage
-import io.reactivex.rxjava3.core.Single
 import javax.inject.Inject
+import okhttp3.ResponseBody
+import retrofit2.Response
 
 /**
  * Created by charlag on 3/24/18.
@@ -61,6 +65,10 @@ class TimelineCases @Inject constructor(
         }
     }
 
+    fun reblogOld(statusId: String, reblog: Boolean): Single<Status> {
+        return Single { reblog(statusId, reblog) }
+    }
+
     suspend fun favourite(statusId: String, favourite: Boolean): NetworkResult<Status> {
         return if (favourite) {
             mastodonApi.favouriteStatus(statusId)
@@ -71,6 +79,10 @@ class TimelineCases @Inject constructor(
         }
     }
 
+    fun favouriteOld(statusId: String, favourite: Boolean): Single<Status> {
+        return Single { favourite(statusId, favourite) }
+    }
+
     suspend fun bookmark(statusId: String, bookmark: Boolean): NetworkResult<Status> {
         return if (bookmark) {
             mastodonApi.bookmarkStatus(statusId)
@@ -81,6 +93,10 @@ class TimelineCases @Inject constructor(
         }
     }
 
+    fun bookmarkOld(statusId: String, bookmark: Boolean): Single<Status> {
+        return Single { bookmark(statusId, bookmark) }
+    }
+
     suspend fun muteConversation(statusId: String, mute: Boolean): NetworkResult<Status> {
         return if (mute) {
             mastodonApi.muteConversation(statusId)
@@ -91,50 +107,6 @@ class TimelineCases @Inject constructor(
         }
     }
 
-    fun reblogOld(statusId: String, reblog: Boolean): Single<Status> {
-        val call = if (reblog) {
-            mastodonApi.reblogStatusOld(statusId)
-        } else {
-            mastodonApi.unreblogStatusOld(statusId)
-        }
-        return call.doAfterSuccess { status ->
-            eventHub.dispatchOld(StatusChangedEvent(status))
-        }
-    }
-
-    fun favouriteOld(statusId: String, favourite: Boolean): Single<Status> {
-        val call = if (favourite) {
-            mastodonApi.favouriteStatusOld(statusId)
-        } else {
-            mastodonApi.unfavouriteStatusOld(statusId)
-        }
-        return call.doAfterSuccess { status ->
-            eventHub.dispatchOld(StatusChangedEvent(status))
-        }
-    }
-
-    fun bookmarkOld(statusId: String, bookmark: Boolean): Single<Status> {
-        val call = if (bookmark) {
-            mastodonApi.bookmarkStatusOld(statusId)
-        } else {
-            mastodonApi.unbookmarkStatusOld(statusId)
-        }
-        return call.doAfterSuccess { status ->
-            eventHub.dispatchOld(StatusChangedEvent(status))
-        }
-    }
-
-    fun muteConversationOld(statusId: String, mute: Boolean): Single<Status> {
-        val call = if (mute) {
-            mastodonApi.muteConversationOld(statusId)
-        } else {
-            mastodonApi.unmuteConversationOld(statusId)
-        }
-        return call.doAfterSuccess {
-            eventHub.dispatchOld(MuteConversationEvent(statusId, mute))
-        }
-    }
-
     suspend fun mute(statusId: String, notifications: Boolean, duration: Int?) {
         try {
             mastodonApi.muteAccount(statusId, notifications, duration)
@@ -188,21 +160,28 @@ class TimelineCases @Inject constructor(
     }
 
     fun voteInPollOld(statusId: String, pollId: String, choices: List<Int>): Single<Poll> {
-        if (choices.isEmpty()) {
-            return Single.error(IllegalStateException())
-        }
-
-        return mastodonApi.voteInPollOld(pollId, choices).doAfterSuccess {
-            eventHub.dispatchOld(PollVoteEvent(statusId, it))
-        }
+        return Single { voteInPoll(statusId, pollId, choices) }
     }
 
-    fun acceptFollowRequest(accountId: String): Single<Relationship> {
-        return mastodonApi.authorizeFollowRequest(accountId)
+    fun acceptFollowRequestOld(accountId: String): Single<Relationship> {
+        return Single { mastodonApi.authorizeFollowRequest(accountId) }
     }
 
-    fun rejectFollowRequest(accountId: String): Single<Relationship> {
-        return mastodonApi.rejectFollowRequest(accountId)
+    fun rejectFollowRequestOld(accountId: String): Single<Relationship> {
+        return Single { mastodonApi.rejectFollowRequest(accountId) }
+    }
+
+    fun notificationsOld(
+        maxId: String?,
+        sinceId: String?,
+        limit: Int?,
+        excludes: Set<Notification.Type>?
+    ): Single<Response<List<Notification>>> {
+        return Single { runCatching { mastodonApi.notifications(maxId, sinceId, limit, excludes) } }
+    }
+
+    fun clearNotificationsOld(): Single<ResponseBody> {
+        return Single { mastodonApi.clearNotifications() }
     }
 
     companion object {