Better Async With Kotlin Coroutines

Android application development is inherently asynchronous. Even the simplest Android application requires the developer to track asynchronous callbacks of the activity, often leading to the infamous callback hell. In this talk, we will have a look at the latest addition to the solutions for dealing with asynchronous programming on Android; Kotlin Coroutines. We'll learn about what coroutines are, how they differ from other models and how to use it with Kotlin on Android.

Transcript

1. BETTER ASYNC ON ANDROID WITH KOTLIN COROUTINES Erik Hellman - @ErikHellman https://speakerdeck.com/erikhellman/better-async-with-kotlin-coroutines
2. –Developers “Async is hard.”
3. We all suck at multi tasking!
4. // This must run on a background thread @WorkerThread fun loadTweets(query: String): List<Tweet> { // Load tweets matching the search query } // This must run on the main thread @MainThread fun showTweets(tweets: List<Tweet>) { // Display tweets }
5. inner class LoadTweetAsyncTask : AsyncTask<String, Unit, List<Tweet>>() { override fun doInBackground(vararg params: String): List<Tweet> { return loadTweets(params[0]) } override fun onPostExecute(result: List<Tweet>?) { showTweets(result) } }
6. val disposable = Single_ .fromCallable { loadTweets("#AndroidMakers") }_ .subscribeOn(Schedulers.io())_ .observeOn(AndroidSchedulers.mainThread())_ .subscribe { tweets ->_ showTweets(tweets)_ }_ _ disposable.dispose()_
7. val disposable = Single_ .fromCallable { loadTweets("#AndroidMakers") }_ .subscribeOn(Schedulers.io())_ .observeOn(AndroidSchedulers.mainThread())_ .subscribe(_ {_tweets -> showTweets(tweets)_}_ {_error -> showError(error)_})_ _ disposable.dispose()_
8. val disposable = Single_ .fromCallable { loadTweets("#AndroidMakers") }_ .subscribeOn(Schedulers.io())_ .observeOn(AndroidSchedulers.mainThread())_ .subscribe(_ {_tweets -> showTweets(tweets)_}_ {_error -> showError(error)_})_ _ disposable.dispose()_
9. val disposable = Single_ .fromCallable { loadTweets("#AndroidMakers") }_ .subscribeOn(Schedulers.io())_ .observeOn(AndroidSchedulers.mainThread())_ .subscribe(_ {_tweets -> showTweets(tweets)_}_ {_error -> showError(error)_})_ _ disposable.dispose()_
10. val disposable = Single_ .fromCallable { loadTweets("#AndroidMakers") }_ .subscribeOn(Schedulers.io())_ .observeOn(AndroidSchedulers.mainThread())_ .subscribe(_ {_tweets -> showTweets(tweets)_}_ {_error -> showError(error)_})_ _ disposable.dispose()_
11. val disposable = Single_ .fromCallable { loadTweets("#AndroidMakers") }_ .subscribeOn(Schedulers.io())_ .observeOn(AndroidSchedulers.mainThread())_ .subscribe(_ {_tweets -> showTweets(tweets)_}_ {_error -> showError(error)_})_ _ disposable.dispose()_
12. WHAT WE WANT val tweets = loadTweets(”#AndroidMakers”) showTweets(tweets)
13. WHAT WE CAN HAVE load { loadTweets(“#AndroidMakers”) } then { showTweets(it) } STAY TUNED!
14. Coroutines = State Machine + Queue
15. WAT?
16. LET’S TRY A DIFFERENT ANALOGY!
18. class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // Restore state from savedInstanceState } override fun onSaveInstanceState(outState: Bundle?) { super.onSaveInstanceState(outState) // Save the state of your app } }
19. Activity Bundle The “process” of the user The state of the process
20. Activity Bundle Coroutine Continuation
21. CONTINUATION? interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) fun resumeWithException(exception: Throwable) }
22. BUT WHAT IS A COROUTINE, REALLY?
23. –Donald Knuth “Subroutines are special cases of ... coroutines.”
24. Pause d'eau…
25. launch {. val tweets = loadTweets("#AndroidMakers") }.
26. launch(context = CommonPool) {. val tweets = loadTweets("#AndroidMakers") }. CoroutineContext - How to run this coroutine, including which thread
27. override fun onCreate(savedInstanceState: Bundle?) {. super.onCreate(savedInstanceState). setContentView(R.layout.activity_main). launch(context = CommonPool) {. val tweets = loadTweets("#AndroidMakers"). }. }.
28. val job = launch(context = CommonPool) {. val tweets = loadTweets("#AndroidMakers"). }. job.cancel().
29. val job = launch(context = CommonPool) {. val tweets = loadTweets("#AndroidMakers"). launch(context = UI) {. showTweets(tweets). }. }. . job.cancel(). Cancelled with parent! Switch context (and thread)
30. public actual fun launch(. context: CoroutineContext = DefaultDispatcher,. start: CoroutineStart = CoroutineStart.DEFAULT,. parent: Job? = null,. block: suspend CoroutineScope.() -> Unit. ): Job.
31. public actual fun launch( context: CoroutineContext = DefaultDispatcher,. start: CoroutineStart = CoroutineStart.DEFAULT, parent: Job? = null, block: suspend CoroutineScope.() -> Unit ): Job WHAT THREAD TO RUN ON
32. public actual fun launch( context: CoroutineContext = DefaultDispatcher, start: CoroutineStart = CoroutineStart.DEFAULT,. parent: Job? = null, block: suspend CoroutineScope.() -> Unit ): Job. START NOW OR LAZILY?
33. public actual fun launch( context: CoroutineContext = DefaultDispatcher, start: CoroutineStart = CoroutineStart.DEFAULT, parent: Job? = null, block: suspend CoroutineScope.() -> Unit ): Job SPECIFY A PARENT COROUTINE
34. public actual fun launch( context: CoroutineContext = DefaultDispatcher, start: CoroutineStart = CoroutineStart.DEFAULT, parent: Job? = null, block: suspend CoroutineScope.() -> Unit. ): Job THE FUNCTION TO RUN
35. val deferred = async(context = CommonPool) {. loadTweets("#AndroidMakers"). }. launch(context = UI) {. showTweets(deferred.await()). }. deferred.cancel(). Will throw CancellationException!
36. // Launch a coroutine that returns a deferred value val deferred: Deferred<List<Tweet>> = async { loadTweets("#AndroidMakers") } // Fire and forget! val job: Job = launch { loadTweets("#AndroidMakers") }
37. SUSPENDED FUNCTION interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) fun resumeWithException(exception: Throwable) }
38. SUSPENDED FUNCTION suspend fun <T> CompletableFuture<T>.await(): T = suspendCoroutine<T> { cont: Continuation<T> -> whenComplete { result, exception -> if (exception == null) // the future has been completed normally cont.resume(result) else // the future has completed with an exception cont.resumeWithException(exception) } }
39. Pause d'eau…
40. LET’S MAKE A DSL*! * Domain Specific Language
41. fun <T> Activity.load(loadFunction: () -> T) {. // TODO perform background loading here. }.
42. fun <T> Activity.load(loadFunction: () -> T): T {. return loadFunction(). }.
43. fun <T> Activity.load(loadFunction: () -> T): Deferred<T> {. return async { loadFunction() }. }.
44. fun <T> Activity.load(loadFunction: () -> T): Deferred<T> {. return async { loadFunction() }. }. . fun <T> Deferred<T>.then(uiFunction: (T) -> Unit) {. launch(UI) { uiFunction(this@then.await()) }. }.
45. fun <T> Activity.load(loadFunction: () -> T): Deferred<T> {. return async { loadFunction() }. }. . infix fun <T> Deferred<T>.then(uiFunction: (T) -> Unit) {. launch(UI) { uiFunction(this@then.await()) }. }.
46. override fun onStart() { super.onStart() load { loadTweets("#AndroidMakers") } then { showTweets(it) } } ALMOST THERE!
47. LIFECYCLE OBSERVER class CoroutineLifecycleListener : LifecycleObserver {. @OnLifecycleEvent(Lifecycle.Event.ON_STOP). fun onStop() {. // Called at onStop() }. }.
48. LIFECYCLE OBSERVER class CoroutineLifecycleListener(val job: Job) : LifecycleObserver { @OnLifecycleEvent(Lifecycle.Event.ON_STOP) fun onStop() { if(!job.isCancelled) job.cancel() } }
49. fun <T> Activity.load(loadFunction: () -> T): Deferred<T> {. return asynco{oloadFunction()o}o }. . infix fun <T> Deferred<T>.then(uiFunction: (T) -> Unit) {. launch(context = UI) {. uiFunction(this@then.await()). }. }.
50. fun <T> LifecycleOwner.load(loadFunction: () -> T): Deferred<T> {. val deferred = asynco{oloadFunction()o}o lifecycle.addObserver(CoroutineLifecycleListener(deferred)). return deferred. }. . infix fun <T> Deferred<T>.then(uiFunction: (T) -> Unit) {. launch(context = UI) {. uiFunction(this@then.await()). }. }.
51. val loaderContext: CoroutineContext = newFixedThreadPoolContext(2, "loader") fun <T> LifecycleOwner.load(context: CoroutineContext = loaderContext, loadFunction: () -> T): Deferred<T> { val deferred = async(context = context, start = CoroutineStart.LAZY) { loadFunction() } lifecycle.addObserver(CoroutineLifecycleListener(deferred)) return deferred } infix fun <T> Deferred<T>.then(uiFunction: (T) -> Unit) { launch(context = UI) { uiFunction(this@then.await()) } } MORE CONTROL
52. val loaderContext: CoroutineContext = newFixedThreadPoolContext(2, "loader") fun <T> LifecycleOwner.load(context: CoroutineContext = loaderContext, loadFunction: () -> T): Deferred<T> { val deferred = async(context = context, start = CoroutineStart.LAZY) { loadFunction() } lifecycle.addObserver(CoroutineLifecycleListener(deferred)) return deferred } infix fun <T> Deferred<T>.then(uiFunction: (T) -> Unit) { launch(context = UI) { uiFunction(this@then.await()) } } MORE CONTROL
53. val loaderContext: CoroutineContext = newFixedThreadPoolContext(2, "loader") fun <T> LifecycleOwner.load(context: CoroutineContext = loaderContext, loadFunction: () -> T): Deferred<T> { val deferred = async(context = context, start = CoroutineStart.LAZY) { loadFunction() } lifecycle.addObserver(CoroutineLifecycleListener(deferred)) return deferred } infix fun <T> Deferred<T>.then(uiFunction: (T) -> Unit) { launch(context = UI) { uiFunction(this@then.await()) } } MORE CONTROL
54. override fun onStart() { super.onStart() load { loadTweets("#AndroidMakers") } then { showTweets(it) } } DONE!
55. WHAT ABOUT ERRORS?
56. interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) funoresumeWithException(exception: Throwable) }
57. interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) funoresumeWithException(exception: Throwable) }
58. override fun onStart() {. super.onStart(). . load.{. loadTweets("#AndroidMakers"). }.then {. showTweets(it). }. }.
59. override fun onStart() {. super.onStart(). . load.{. loadTweets("#AndroidMakers"). }.then {. try {. showTweets(it). } catch (e: Exception) {. showErrorMessage(e). }. }. }.
60. BUT WAIT! THERE IS MORE!
61. // Create a channel for reading and writing numbers val channel = Channel<Int>() // Send 10 integers to the channel on a background thread launch(CommonPool) { for (x in 1..10) channel.send(x) } // Read the numbers from the channel launch(UI) { for (number in channel) println(number) } CHANNELS!
62. CAN BE USED LIKE A SEQUENCE! launch(UI) { channel.filter { it % 2 == 0 } .map(CommonPool) { it * 2 } .consumeEach { updateUI(it) } } Operators can take a coroutine context!
63. CAN HAVE MULTIPLE CONSUMERS val clickChannel = Channel<View>() button.setOnClickListener { view -> launch { clickChannel.send(view) } } repeat(10)_{_ launch(CommonPool)_{_ clickChannel.consumeEach_{_ val result = doHeavyWork()_ }_ }_ }_
64. …OR MULTIPLE PRODUCERS val resultChannel = Channel<Int>()_ _ repeat(10)_{_ launch(CommonPool)_{_ clickChannel.consumeEach_{_ val_result_=_doHeavyWork()_ resultChannel.send(result)_ }_ }_ }_ _ launch(UI)_{ resultChannel.consumeEach { updateUI(it) } }
65. button.setOnClickListener { load { loadTweets(“#AndroidMakers") } then { showTweets(it) } } How can I throttle the click callbacks? Launches a new coroutine on every click!
66. ACTORS
67. val clickActor = actor<View>(UI) { channel.map(CommonPool) { loadTweets("#AndroidMakers") } .consumeEach { showTweets(it) } } button.setOnClickListener { clickActor.offer(it) } ... clickActor.close() Drop this event if the receiver is busy!
68. CONFUSED?
69. LET’S EXTEND OUR DSL!
70. class LoadingChannel<out T>(val lifecycle: Lifecycle,_ val view: View,_ val loadFunction: () -> T) {_ _ }_
71. class LoadingChannel<out T>(val lifecycle: Lifecycle,_ val view: View,_ val loadFunction: () -> T) {_ infix fun then(uiFunction: (T) -> Unit) {_ val job = Job() val actor = actor<Unit>(context = UI, parent = job) { }_ _ lifecycle.addObserver(CoroutineLifecycleListener(job))_ _ view.setOnClickListener { actor.offer(Unit) }_ }_ }_
72. class LoadingChannel<out T>(val lifecycle: Lifecycle,_ val view: View,_ val loadFunction: () -> T) {_ infix fun then(uiFunction: (T) -> Unit) {_ val job = Job() val actor = actor<Unit>(context = UI, parent = job) { channel.map(CommonPool) { loadFunction() }_ .consumeEach { uiFunction(it) }_ }_ _ lifecycle.addObserver(CoroutineLifecycleListener(job))_ _ view.setOnClickListener { actor.offer(Unit) }_ }_ }_
73. class LoadingChannel<out T>(val lifecycle: Lifecycle,_ val view: View,_ val loadFunction: () -> T) {_ infix fun then(uiFunction: (T) -> Unit) {_ val job = Job() val actor = actor<Unit>(context = UI, parent = job) { channel.map(CommonPool) { loadFunction() }_ .consumeEach { uiFunction(it) }_ }_ _ lifecycle.addObserver(ActorLifecycleListener(job))_ _ view.setOnClickListener { actor.offer(Unit) }_ }_ }_
74. fun <T> LifecycleOwner.whenClicking(view: View, loadFunction: () -> T) : LoadingChannel<T> { return LoadingChannel<T>(lifecycle, view, loadFunction) }
75. override fun onCreate(savedInstanceState: Bundle?) {_ super.onCreate(savedInstanceState)_ setContentView(R.layout.activity_main)_ _ whenClicking(button) {_ loadTweets("#AndroidMakers")_ }_ }_
76. override fun onCreate(savedInstanceState: Bundle?) {_ super.onCreate(savedInstanceState)_ setContentView(R.layout.activity_main)_ _ whenClicking(button) {_ loadTweets("#AndroidMakers")_ }_then {_ showTweets(it)_ }_ }_
77. DOES THIS REPLACE RXJAVA? NO!
78. COROUTINE LIBRARIES
79. RETROFIT ADAPTER https://github.com/JakeWharton/retrofit2-kotlin-coroutines-adapter val retrofit = Retrofit.Builder() .baseUrl("https://example.com/") .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build() interface MyService { @GET("/user") fun getUser(): Deferred<User> // or @GET("/user") fun getUser(): Deferred<Response<User>> }
80. GRADLE STUFF kotlin { experimental { coroutines "enable" } } dependencies { implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.22.5" implementation “org.jetbrains.kotlinx:kotlinx-coroutines-android:0.22.5" }
81. RESOURCES • https://github.com/Kotlin/kotlinx.coroutines/ • https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md • https://github.com/Kotlin/kotlinx.coroutines/blob/master/ui/coroutines-guide-ui.md • https://github.com/JakeWharton/retrofit2-kotlin-coroutines-adapter • https://hellsoft.se/simple-asynchronous-loading-with-kotlin-coroutines-f26408f97f46 • https://github.com/ErikHellman/KotlinAsyncWithCoroutines
82. THANK YOU FOR LISTENING! https://speakerdeck.com/erikhellman/better-async-with-kotlin-coroutines