The slides from my presentation from Droidcon Transylvania 2018 Abstract: RxJava was the hype in the last couple of years, when it came to asynchronous operations in an Android app. I felt it, I adopted it, as I’m sure a lot of people did. But with the advent of Kotlin, is RxJava still the most robust and efficient solution, or should we, as Android developers feel safe enough to rely on Coroutines? In this talk, I will take attendees on a deep dive through the magical world of Coroutines, whilst trying to offer a comparison to everyone’s favorite reactive programming library.

1. Should it be routine to use
Coroutines?
Stefan Brosteanu

2. Agenda
• Styles of writing code
• Deep dive into the inner workings of coroutines
• Integration with other libraries
• Short comparison to RxJava

3. Prologue

4. Refresh token
Post item using refreshed token

5. Refresh token
Post item using refreshed token

6. Refresh token
Post item using refreshed token

7. Refresh token
Post item using refreshed token

8. fun updateAccount(updatedUser: User) {
val token = refreshToken()
postUpdate(token, updatedUser)
}

9. fun updateAccount(updatedUser: User) {
val token = refreshToken()
postUpdate(token, updatedUser)
}
Refresh token
Post Item with refreshed
token

10. fun updateAccount(updatedUser: User) {
val token = refreshToken()
postUpdate(token, updatedUser)
}
Direct style

11. fun updateAccount(updatedUser: User) {
val token = refreshToken()
postUpdate(token, updatedUser)
}
Direct style
Action

12. fun updateAccount(updatedUser: User) {
val token = refreshToken()
postUpdate(token, updatedUser)
}
Direct style
Continuation

13. fun updateAccount(updatedUser: User) {
val token = refreshToken()
postUpdate(token, updatedUser)
}
Direct style

14. fun updateAccount(updatedUser: User) {
refreshToken { token ->
postUpdate(token, updatedUser)
}
}

15. fun updateAccount(updatedUser: User) {
refreshToken { token ->
postUpdate(token, updatedUser)
}
}
Continuation Passing Style

16. Asynchronous programming

17. Asynchronous Programming
• Async tasks
• Loaders
• Callbacks
• Promises
• Futures
• Reactive Extensions

18. Async tasks
• Labeled as “Painless Threading”
• Async Tasks don’t work well with orientations changes or might have
problems with the Lifecycle
• Limited to 138 concurrent tasks

19. Loaders
• Never really caught on
• Trying to solve the problem of running asynchronous operations within the
Activity or Fragments

20. Callbacks
• Error handling is cumbersome
• The dreaded Callback Hell

21. Promises/Futures
• introduce concept of operators
• relies on introspecting the value that needs to be returned

22. fun updateAccount(updatedUser: User) {
refreshToken()
.thenCompose { token ->
postUpdate(token, updatedUser)
}
}

23. fun refreshToken(): Promise<Token> {
...
return promise
}

24. Reactive Extensions
• simplifies the way you do async/threaded work
• simple to compose streams of data
• avoid callback hell
• a downside is that you shift from the normal programming model

25. Coroutines

26. What are coroutines?
• basically lightweight threads
• provide the same way of writing code both for async and sync
• exceptions handling, loops, etc. work like in synchronous code

27. What are coroutines?
suspend fun updateAccount(updatedUser: User) {
val token = refreshToken()
postUpdate(token, updatedUser)
}

28. How do coroutines work?
suspend fun refreshToken(): Token {
...
}
Object refreshToken(Continuation<Token> cont) {
...
}
Callback
interface Continuation<in T> {
val context: CoroutineContext
fun resume(value: T)
fun resumeWithException(exception: Throwable)
}

29. Is that really it?
suspend fun updateAccount(updatedUser: User) {
0 val token = refreshToken()
1 postUpdate(token, updatedUser)
2 }
class StateMachine(val updatedUser: User,
val updateAccountCallback: Continuation<Unit>)
: Continuation<Any?> {
var label: Int = 0
var token: String? = null
}

30. Deeper
suspend fun updateAccount(updatedUser: User) {
0 val token = refreshToken()
1 postUpdate(token, updatedUser)
2 }
when (sm.label) {
0 -> { sm.label = 1; refreshToken(sm) }
1 -> { sm.label = 2;
sm.token = value as String;
postUpdate(sm.token!!, updatedUser, sm)
}
2 -> { sm.updateAccountCallback.resume(Unit) }
}
Label is set to 0

31. Deeper
suspend fun updateAccount(updatedUser: User) {
0 val token = refreshToken()
1 postUpdate(token, updatedUser)
2 }
when (sm.label) {
0 -> { sm.label = 1; refreshToken(sm) }
1 -> { sm.label = 2;
sm.token = value as String;
postUpdate(sm.token!!, updatedUser, sm)
}
2 -> { sm.updateAccountCallback.resume(Unit) }
}
Label is set to 1

32. Deeper
suspend fun updateAccount(updatedUser: User) {
0 val token = refreshToken()
1 postUpdate(token, updatedUser)
2 }
when (sm.label) {
0 -> { sm.label = 1; refreshToken(sm) }
1 -> { sm.label = 2;
sm.token = value as String;
postUpdate(sm.token!!, updatedUser, sm)
}
2 -> { sm.updateAccountCallback.resume(Unit) }
}
Label is set to 2

33. Coroutine builders
suspend fun updateAccount(updatedUser: User) {
val token = refreshToken()
postUpdate(token, updatedUser)
}

34. Coroutine builders
fun updateAccount(updatedUser: User) {
launch {
val token = refreshToken()
postUpdate(token, updatedUser)
}
}

35. Coroutine builders
• launch
• async
• withContext
• runBlocking

36. Coroutine context
fun updateAccount(updatedUser: User) {
launch {
val token = refreshToken()
postUpdate(token, updatedUser)
withContext (UI) {
// update UI
}
}
}

37. Coroutine context
• Unconfined
• CommonPool
• UI

38. Can they play well with others?
• Short answer: YES
• Long answer: with most or all libraries that use some sort of Future or
expose some kind of callback
• basically you need to create and/or apply a await extension function

39. How?
interface ApiService {
fun postUpdate(token: Token, updatedUser: User): Call<User>
}

40. How?
interface ApiService {
fun postUpdate(token: Token, updatedUser: User): Call<User>
}
suspend fun updateAccount(token: Token, updatedUser: User): User {
apiServiceInstance.updateAccount(token, updatedUser).await()
}

41. How?
suspend fun <T> Call.<T>.await(): T {
...
}

42. How?
suspend fun <T> Call<T>.await(): T {
enqueue(object : Callback<T> {
override fun onFailure(call: Call<T>, t: Throwable) {
TODO("not implemented")
}
override fun onResponse(call: Call<T>, response: Response<T>) {
TODO("not implemented")
}
})
}

43. How?
public suspend inline fun <T> suspendCoroutine(crossinline block: (Continuation<T>) -> Unit): T =
suspendCoroutineOrReturn { c: Continuation<T> ->
val safe = SafeContinuation(c)
block(safe)
safe.getResult()
}

44. How?
suspend fun <T> Call<T>.await(): T = suspendCoroutine { continuation ->
enqueue(object : Callback<T> {
override fun onFailure(call: Call<T>, t: Throwable) {
continuation.resumeWithException(t)
}
override fun onResponse(call: Call<T>, response: Response<T>) {
if (response.isSuccessful) {
continuation.resume(response.body()!!)
} else {
continuation.resumeWithException(Error(response.errorBody()!!))
}
}
})
}

45. How? - Sidenote
• JetBrains provides some out of the box integrations

46. How does it stack up against RxJava?
• Does it replace Rx?
• Is it better than Rx?

47. Why shouldn’t you use Rx?
• fluent API, but it leads to hard to read code and changing it might be
complex
• creating modular code that can be composed and still be readable is a
pain
• it’s overkill, most of the times

48. Why shouldn’t you use coroutines?
• if you’ve already learned Rx and the codebase is heavily relying on it
• sometimes composing and pub/sub-ing is easier with Rx
• if you’re codebase is written in Java
• community of developers using Rx is a tad larger (more questions on SO)

49. What else is there?

50. What else is there?
• Cancellation
• Composition
• Channels
• Actors
• Coroutine scope

51. Epilogue

52. Epilogue
• Direct Style and Continuation Passing Style ✅
• Deep dive into the inner workings of coroutines ✅
• Integration with other libraries ✅
• Short comparison to RxJava ✅

53. Should it be routine to use
coroutines?

54. Resources
• https://kotlinlang.org/docs/reference/coroutines.html
• https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-
informal.md
• https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-
guide.md
• KotlinConf 2017 - Deep Dive into Coroutines on JVM by Roman Elizarov

55. Thank you!
Stefan Brosteanu
@stef.brosteanu
sbrosteanu