{"id":255,"date":"2020-08-13T11:50:00","date_gmt":"2020-08-13T09:50:00","guid":{"rendered":"https:\/\/www.codemotion.com\/magazine\/async-code-on-kotlin-coroutines-vs-rxjava\/"},"modified":"2020-09-01T16:28:15","modified_gmt":"2020-09-01T14:28:15","slug":"async-code-on-kotlin-coroutines-vs-rxjava","status":"publish","type":"post","link":"https:\/\/www.codemotion.com\/magazine\/frontend\/mobile-dev\/async-code-on-kotlin-coroutines-vs-rxjava\/","title":{"rendered":"Async code on Kotlin: coroutines VS RxJava"},"content":{"rendered":"\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\tTable Of Contents\t\t\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t
  1. What are coroutines?<\/a>
  2. What is RxJava?<\/a>
  3. A sample service in Kotlin<\/a>
  4. Using service methods<\/a>
  5. Coroutines or RxJava?<\/a>
  6. Conclusions<\/a><\/ol>\t\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\n\n\n

    A<\/span> lot of Android<\/a> programmers are now exploring Kotlin<\/span><\/strong>, a programming language<\/span> based on Java<\/span> and the JVM<\/span> that is used to develop Android<\/span> applications. As is often the case with Java-based Android<\/span> apps<\/span>, one of the main problems when approaching Android<\/span> development in Kotlin<\/span><\/a> is the management<\/span> of asynchronous<\/span> code<\/strong>. In Java<\/span>, this has been solved by the AsyncTask<\/code> class<\/span>, or the runOnUiThread<\/code> method. In Kotlin<\/span>, something different is required.<\/p>\n\n\n\n

    At Codemotion Milan 2018, Fabio Collini<\/a>, Google<\/span> Developer Expert and Senior Android<\/span> Developer, delivered a speech on how to implement asynchronous<\/span> code in Kotlin<\/span>. Specifically, he described two different approaches: the first using coroutines<\/strong>, the second based on a library named ReactiveX Java<\/strong> (or RxJava<\/strong> in short). Both of these approaches allow users to implement and support asynchronous<\/span> operations, and can be also used both together and interchangeably.
    This post provides a quick overview on how these approaches differ from each other.<\/p>\n\n\n\n

    Before starting, let’s try to understand more clearly the main differences between RxJava and coroutines, and how they can help Kotlin programmers<\/span>.<\/p>\n\n\n\n

    What are coroutines?<\/h2>\n\n\n\n

    The concept of coroutine is not strictly related to Kotlin. Coroutines<\/span> are in fact components<\/span> that generalize subroutines<\/span> for non-preemptive<\/span> multitasking<\/span>, which allows tasks to suspend and resume their own execution. These components<\/span> are therefore particularly useful for multi-thread programming, and are also found in other languages such as Python<\/span> or C#<\/span>.<\/p>\n\n\n\n

    In Kotlin<\/span>, coroutines are implemented within the kotlinx.coroutines<\/code> library, originally developed<\/span> by JetBrains. The Kotlin<\/span> official documentation provides an extensive ‘how to’ guide that is available at this link<\/a>.<\/p>\n\n\n\n

    What is RxJava?<\/h2>\n\n\n\n

    RxJava, shorthand for ‘ReactiveX for Java<\/span>‘, was created by Ben Christensen and David Karnok, with the first version<\/span> released in November 2014. RxJava has found several applications<\/span> in the Android world, thanks to its unique features. Indeed, this library allows easy termination of subscription when an activity is ending, thus avoiding memory leaks and the waste of resources<\/span> derived from working on UI elements that are no longer visible.<\/p>\n\n\n\n

    Moreover, RxJava is considered one of the most fruitful methods for enabling Reactive<\/span> Programming<\/span><\/strong> in Android<\/span> development. As we’ll see below, the result is simplified implementation<\/span> of concurrency<\/span> and the asynchronous tasks inherent in mobile programming<\/span>.<\/p>\n\n\n\n

    Although it is also available for Java<\/span>,this article will focus on how to use RxJava to implement mobile apps<\/span> in Kotlin<\/span>.<\/p>\n\n\n\n

    A sample service in Kotlin<\/h2>\n\n\n\n

    Fabio Collini started the discussion about using<\/span> RxJava or coroutines by showing a sample interface for a service aimed at obtaining information from StackOverflow<\/span>. Since such a service is made up of asynchronous<\/span> methods<\/span>, it is perfect for our purposes.<\/p>\n\n\n\n

    The first question is therefore how to define methods<\/span> that are asynchronous<\/span>? With RxJava, we need to use a Single<\/code> class<\/span> as type for the return value:<\/p>\n\n\n\n

    \n
    interface<\/span> StackOverflowService {\n\t@GET<\/span>(\"\/users<\/span>\"<\/span>)\n\tfun<\/span> getTopUsers<\/span>(): Single<List<User<\/span>>>\n    \n\t@GET<\/span>(\"\/users<\/span>\/{userId}\/badges\"<\/span>)\n\tfun<\/span> getBadges<\/span>(\n    \t\t@Path(\"userId\"<\/span>) userId: Int<\/span>\n\t): Single<List<Badge>>\n    \n\t@GET<\/span>(\"\/users<\/span>\/{userId}\/top-tags\"<\/span>)\n\tfun<\/span> getTags<\/span>(\n   \t\t@Path(\"userId\"<\/span>) userId: Int<\/span>\n\t): Single<List<Tag>>\n}\n<\/pre>\n<\/div>\n\n\n\n
    This allows use of the subscribe<\/code> method<\/span> in order to wait for the response.
    With coroutines, there are two possibilities: the first is similar to the above, but uses the Deferred<\/code> class<\/span>:<\/p>\n\n\n\n
    \n
    interface<\/span> StackOverflowService {\n\t@GET<\/span>(\"\/users<\/span>\"<\/span>)\n\tfun<\/span> getTopUsers<\/span>(): Deferred<List<User<\/span>>>\n    \n\t@GET<\/span>(\"\/users<\/span>\/{userId}\/badges\"<\/span>)\n\tfun<\/span> getBadges<\/span>(\n    \t\t@Path(\"userId\"<\/span>) userId: Int<\/span>\n\t): Deferred<List<Badge>>\n    \n\t@GET<\/span>(\"\/users<\/span>\/{userId}\/top-tags\"<\/span>)\n\tfun<\/span> getTags<\/span>(\n   \t\t@Path(\"userId\"<\/span>) userId: Int<\/span>\n\t): Deferred<List<Tag>>\n}\n<\/pre>\n<\/div>\n\n\n\n
    However, a recent upgrade of Kotlin<\/span> allows for declaration of suspending functions<\/span><\/strong>, which in practice makes the code appears synchronous, even it is actually the opposite:<\/p>\n\n\n\n
    \n
    interface<\/span> StackOverflowService {\n\t@GET<\/span>(\"\/users<\/span>\"<\/span>)\n\tsuspend fun<\/span> getTopUsers<\/span>(): List<User<\/span>>\n    \n\t@GET<\/span>(\"\/users<\/span>\/{userId}\/badges\"<\/span>)\n\tsuspend fun<\/span> getBadges<\/span>(\n    \t\t@Path(\"userId\"<\/span>) userId: Int<\/span>\n\t): List<Badge>\n    \n\t@GET<\/span>(\"\/users<\/span>\/{userId}\/top-tags\"<\/span>)\n\tsuspend fun<\/span> getTags<\/span>(\n   \t\t@Path(\"userId\"<\/span>) userId: Int<\/span>\n\t): List<Tag>\n}\n<\/pre>\n<\/div>\n\n\n\n
    In what follows, we will consider the latter approach, which makes the code cleaner.<\/p>\n\n\n\n
    Using service methods<\/h2>\n\n\n\n
    Now, if we want to use the aforementioned service, RxJava<\/span> and coroutines require different approaches. As mentioned above, RxJava requires using the subscribe<\/code> method<\/span>:<\/p>\n\n\n\n
    \n
    class<\/span><\/span> MyViewModel<\/span>(\n\tprivate<\/span> val<\/span> service: StackOverflowService\n) : ViewModel() {\n\n\tprivate<\/span> val<\/span> disposable = CompositeDisposable()\n\n\tfun<\/span> load<\/span>() {\n\t\tdisposable +=\n\t\t\tservice.getTopUsers()\n\t\t\t\t.subscribeOn(io())\n\t\t\t\t.observeOn(mainThread())\n\t\t\t\t.subscribe(\n\t\t\t\t\t{ users<\/span> -> updateUi(users<\/span>) },\n\t\t\t\t\t{ e -> updateUi(e) }\n\t\t\t\t)\n\t}\n    \n\tprivate<\/span> fun<\/span> updateUi<\/span>(s: Any) {\n\t\t\/\/...<\/span>\n\t}\n    \n\toverride<\/span> fun<\/span> onCleared<\/span>() {\n\t\tdisposable.clear()\n\t}\n}\n<\/pre>\n<\/div>\n\n\n\n
    The subscribe method<\/span> accepts two parameters: the first is the one we want to execute, while the second (e -> updateUi(e)<\/code>) is used in case of errors.<\/p>\n\n\n\n
    While RxJava is synchronous by default (one consequence of this is that we resorted to subscribe), using coroutines and suspending functions<\/span> allows us to write code<\/span> that is automatically interpreted as asynchronous<\/span>, even if it appears synchronous. To understand this difference, compare the following snippet with the previous one: they are equivalent in functionality.<\/p>\n\n\n\n
    \n
    class<\/span><\/span> MyViewModel<\/span>(\n\tprivate<\/span> val<\/span> service: StackOverflowService\n) : ViewModel() {\n\n\tfun<\/span> load<\/span>() {\n\t\tviewModelScope.launch {\n\t\t\ttry<\/span> {\n\t\t\t\tval<\/span> users<\/span> = service.getTopUsers()\n\t\t\t\tupdateUi(users<\/span>)\n\t\t\t} catch<\/span> (e: Exception) {\n\t\t\t\tupdateUi(e)\n\t\t\t}\n\t\t}\n\t}\n    \n\tprivate<\/span> fun<\/span> updateUi<\/span>(s: Any) {\n\t\t\/\/...<\/span>\n\t}\n}\n<\/pre>\n<\/div>\n\n\n\n
    Here, viewModelScope<\/code> simplifies the code, even if it is not available yet using Kotlin<\/span>. However, an implementation<\/span> is provided in this link<\/a>.<\/p>\n\n\n\n
    In general, even more complicated things are made possible by using coroutines or RxJava. Additional code examples by Fabio Collini are available on GitHub<\/span><\/a>.<\/p>\n\n\n\n
    Coroutines or RxJava?<\/h2>\n\n\n\n
    Having read this quick overview of coroutines and RxJava, one might ask which solution is the best. In terms of number of methods<\/span>, RxJava is bigger than a solution based on coroutines only. However, this difference can be eliminated by using Proguard<\/strong> and its code optimization. The following graphs taken from Fabio Collini\u2019s slides show this.<\/p>\n\n\n\n
    \"\"<\/a><\/figure><\/div>\n\n\n\n
    Conclusions<\/h2>\n\n\n\n
    So, which approach should we use for production code?
    In order to answer such a question, Fabio Collini proposed the following ‘algorithm’:<\/p>\n\n\n\n