Async Operations with Kotlin Coroutines

Explains how we currently do async operations in Android and how kotlin coroutines helps to write asynchronous code in a synchronous manner.

Transcript

1. ASYNC OPERATIONS WITH KOTLIN COROUTINES By MAYOWA ADEGEYE
2. • AsyncTask
3. • AsyncTask • Service/IntentService
4. • AsyncTask • Service/IntentService • Handlers
5. • AsyncTask • Service/IntentService • Handlers • Thread
6. • AsyncTask • Service/IntentService • Handlers • Thread • RxJava
7. fun login(username: String, password: String): User
8. fun login(username: String, password: String): User fun getOrders(userId: String): List<Orders>
9. fun login(username: String, password: String): User fun getOrders(userId: String): List<Orders> fun fetchUserOrders() { val user = login(username, password) val orders = getOrders(user.userId) showUserOrders(orders) }
10. fun fetchUserOrders(username: String, password: String) { login(username, password) { user -> getOrders(user.userId) { orders -> showUserOrders(orders) } } } Callbacks
11. RxJava Example fun fetchUserOrders(username: String, password: String) { login(username, password) .flatMap { user → getOrders(user.userId) } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.main()) .subscribe({orders -> showUserOrders(orders)}) }
12. What we actually want fun fetchUserOrders() { val user = login(username, password) val orders = getOrders(user.userId) showUserOrders(orders) }
13. What is a coroutine A lightweight thread that can run a computation without blocking. It can be suspended and resumed at a later time.
16. KEY CONCEPTS
17. KEY CONCEPTS • SUSPENDING FUNCTIONS
18. KEY CONCEPTS • SUSPENDING FUNCTIONS • COROUTINE CONTEXT / COROUTINE DISPATCHER
19. KEY CONCEPTS • SUSPENDING FUNCTIONS • COROUTINE CONTEXT / COROUTINE DISPATCHER • COROUTINE BUILDERS
20. SUSPENDING FUNCTION
21. SUSPENDING FUNCTION A function that can be started, paused and resumed at a later time.
22. SUSPENDING FUNCTION A function that can be started, paused and resumed at a later time. • Can only be called from a coroutine and from another suspending function
23. SUSPENDING FUNCTION A function that can be started, paused and resumed at a later time. • Can only be called from a coroutine and from another suspending function • Can take parameters and have return types.
24. Suspending function syntax suspend fun doHeavyComputation(param: Int): Int { //heavy computation body }
25. fun doHeavyComputation(param: Int, callback:Continuation<Int>)
26. fun doHeavyComputation(param: Int, callback:Continuation<Int>) interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) { } fun resumeWithException(exception: Throwable) }
27. COROUTINE CONTEXT
28. COROUTINE CONTEXT Coroutine Context: A map from CoroutineContext.Key to CoroutineContext.Element
29. COROUTINE CONTEXT Coroutine Context: A map from CoroutineContext.Key to CoroutineContext.Element • Job
30. COROUTINE CONTEXT Coroutine Context: A map from CoroutineContext.Key to CoroutineContext.Element • Job • ContinuationInterceptor
31. COROUTINE CONTEXT Coroutine Context: A map from CoroutineContext.Key to CoroutineContext.Element • Job • ContinuationInterceptor • CoroutineName
32. COROUTINE CONTEXT Coroutine Context: A map from CoroutineContext.Key to CoroutineContext.Element • Job • ContinuationInterceptor • CoroutineName • CoroutineExceptionHandler
33. COROUTINE DISPATCHERS Determines which thread or threads the coroutine uses for its execution. It can confine a coroutine to specific thread, a thread pool or let it run unconfined.
34. Coroutine Dispatchers • Dispatchers.DEFAULT
35. Coroutine Dispatchers • Dispatchers.DEFAULT • Dispatchers.UNCONFINED
36. Coroutine Dispatchers • Dispatchers.DEFAULT • Dispatchers.UNCONFINED • Dispatchers.IO
37. Coroutine Dispatchers • Dispatchers.DEFAULT • Dispatchers.UNCONFINED • Dispatchers.IO • Dispatchers.MAIN
38. Coroutine Dispatchers • Dispatchers.DEFAULT • Dispatchers.UNCONFINED • Dispatchers.IO • Dispatchers.MAIN • newFixedThreadPoolContext / newSingleThreadContext
39. Coroutine Builders
40. Launch fun CoroutineScope.launch( context: CoroutineContext = EmptyCoroutineContext, Start: CoroutineStart = CoroutineStart.DEFAULT, onCompletion: CompletionHandler? = null, block: suspend CoroutineScope.() -> Unit ): Job
41. Example suspend fun fibonacciN(n: Int): Int {...}
42. Example suspend fun fibonacciN(n: Int): Int {...} val job = GlobalScope.launch { val fib = fibonacciN(20) println(“20th fibonacci is $fib”) }
43. Job • isActive
44. Job • isActive • isCompleted
45. Job • isActive • isCompleted • isCancelled
46. fun <T> CoroutineScope.async( context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, onCompletion: CompletionHandler? = null block: suspend CoroutineScope.() -> T ): Deferred<T> Async
47. Async... • You need to call await() on the returned Deferred<T> object to get the eventual result.
48. Async... • You need to call await() on the returned Deferred<T> object to get the actual result. • Async..await be used to run tasks in parallel.
49. Async... • You need to call await() on the returned Deferred<T> object to get the actual result. • Async..await be used to run tasks in parallel. • Deferred<T> is also a job.
50. Parallel operations example suspend fun loadImage(url: String): Bitmap
51. Parallel operations example suspend fun loadImage(url: String): Bitmap fun combineImages()= GlobalScope.launch(Dispatchers.MAIN) { val image1 = async(Dispatchers.DEFAULT) { loadImage(“..”) } val image2 = async(Dispatchers.DEFAULT) { loadImage(“..”) } imageView.setImageBitmap( combine(image1.await(), image2.await()) ) }
52. Parallel operations example suspend fun loadImage(url: String): Bitmap fun combineImages()= GlobalScope.launch(Dispatchers.MAIN) { val image1 = async(Dispatchers.DEFAULT) { loadImage(“..”) } val image2 = async(Dispatchers.DEFAULT) { loadImage(“..”) } imageView.setImageBitmap( combine(image1.await(), image2.await()) ) }
53. private fun loadData() = GlobalScope.launch(Dispatchers.MAIN) { }
54. private fun loadData() = GlobalScope.launch(Dispatchers.MAIN) { view.showLoading() }
55. private fun loadData() = GlobalScope.launch(Dispatchers.MAIN) { view.showLoading() val result = withContext(Dispatcher.IO) { dataRepository.loadData() } }
56. private fun loadData() = GlobalScope.launch(Dispatchers.MAIN) { view.showLoading() val result = withContext(Dispatcher.IO) { dataRepository.loadData() } }
57. private fun loadData() = GlobalScope.launch(Dispatchers.MAIN) { view.showLoading() val result = withContext(Dispatcher.IO) { dataRepository.loadData() } view.hideLoading() }
58. private fun loadData() = GlobalScope.launch(Dispatchers.MAIN) { view.showLoading() val result = withContext(Dispatcher.IO) { dataRepository.loadData() } view.hideLoading() view.showData(result) }
59. get user orders revisited fun fetchUserOrders() = GlobalScope.launch(Dispatchers.MAIN){ val user = withContext(Dispatchers.IO) { login(username, password) } val orders = withContext(Dispatchers.IO) { getOrders(user.userId) } showUserOrders(orders) }
60. CANCELLING A JOB Call cancel() on the Job object returned from a single coroutine
61. CANCELLING A JOB Call cancel() on the Job object returned from a single coroutine val job = GlobalScope.launch { // background operation } job.cancel()
62. Child Coroutines inherits the context of parent coroutines
63. Child Coroutines inherits the context of parent coroutines val job = GlobalScope.launch { val task1 = async {...} val task2 = async {...} val result = task1.await() + task2.await() }
64. Child Coroutines inherits the context of parent coroutines val job = GlobalScope.launch { val task1 = async {...} val task2 = async {...} val result = task1.await() + task2.await() } job.cancel() //cancels the execution of parent and child coroutines
65. class MainActivity: AppCompatActivity() { private fun loadData() { } private fun doAnimations() { } }
66. class MainActivity: AppCompatActivity(), CoroutineScope { private fun loadData() { } private fun doAnimations() { } }
67. class MainActivity: AppCompatActivity(), CoroutineScope { override val coroutineContext: CoroutineContext get() = Dispatchers.DEFAULT private fun loadData() { } private fun doAnimations() { } }
68. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.DEFAULT private fun loadData() { } private fun doAnimations() { } }
69. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.DEFAULT override fun onCreate(savedInstanceState: Bundle?) { job = Job() } private fun loadData() { } }
70. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.DEFAULT override fun onCreate(savedInstanceState: Bundle?) { job = Job() } override fun onDestroy() { job.cancel() } }
71. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.DEFAULT + job override fun onCreate(savedInstanceState: Bundle?) { job = Job() } override fun onDestroy() { job.cancel() } }
72. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.DEFAULT + job override fun onCreate(savedInstanceState: Bundle?) { job = Job() } override fun onDestroy() { job.cancel() } }
73. HANDLING EXCEPTIONS Exceptions can be handled in the conventional way by wrapping code in try..catch block.
74. HANDLING EXCEPTIONS Exceptions can be handled in the conventional way by wrapping code in try..catch block. Coroutine builders either propagate exceptions automatically or expose it to the user
75. fun main(args: Array<String>) = runBlocking { val job = GlobalScope.launch { println("Throwing exception from launch") throw IndexOutOfBoundsException() } job.join() println("Joined failed job") val deferred = GlobalScope.async { println("Throwing exception from async") throw ArithmeticException() } try { deferred.await() println("Unreached") } catch (e: ArithmeticException) { println("Caught ArithmeticException") } }
76. fun main(args: Array<String>) = runBlocking { val job = GlobalScope.launch { println("Throwing exception from launch") throw IndexOutOfBoundsException() } job.join() println("Joined failed job") val deferred = GlobalScope.async { println("Throwing exception from async") throw ArithmeticException() } try { deferred.await() println("Unreached") } catch (e: ArithmeticException) { println("Caught ArithmeticException") } }
77. fun main(args: Array<String>) = runBlocking { val job = GlobalScope.launch { println("Throwing exception from launch") throw IndexOutOfBoundsException() // exception printed out to the console } job.join() println("Joined failed job") val deferred = GlobalScope.async { println("Throwing exception from async") throw ArithmeticException() //nothing happens, waits for user to call await } try { deferred.await() println("Unreached") } catch (e: ArithmeticException) { println("Caught ArithmeticException") } }
78. fun main(args: Array<String>) = runBlocking { val job = GlobalScope.launch { println("Throwing exception from launch") throw IndexOutOfBoundsException() // exception printed out to the console } job.join() println("Joined failed job") val deferred = GlobalScope.async { println("Throwing exception from async") throw ArithmeticException() //nothing happens, waits for user to call await } try { deferred.await() println("Unreached") // will not be printed } catch (e: ArithmeticException) { println("Caught ArithmeticException") } }
79. CoroutineExceptionHandler val exceptionHandler = CoroutineExceptionHandler { _, exception -> print(“Caught: $exception") }
80. CoroutineExceptionHandler val exceptionHandler = CoroutineExceptionHandler { _, exception -> print(“Caught: $exception") } runBlocking { val job = GlobalScope.launch(exceptionHandler) { throw IOException(“error occurred) } job.join() } //prints: caught: java.io.IOException: error occurred
81. CHANNELS
82. • Provides a way to transfer a stream of values
83. • Provides a way to transfer a stream of values • They can be shared between different coroutines and have default capacity of 1.
84. • Provides a way to transfer a stream of values • They can be shared between different coroutines and have default capacity of 1. • Channels implements two interfaces, the SendChannel<E> and the ReceiveChannel<E>
85. public interface SendChannel<E> { suspend fun send(element: E) fun offer(element: E) fun close(cause: Throwable? = null) : Boolean }
86. public interface SendChannel<E> { suspend fun send(element: E) fun offer(element: E) fun close(cause: Throwable? = null) : Boolean } public interface ReceiveChannel<E> { suspend fun receive(): E fun close(throwable? = null): Boolean }
87. USAGE val channel = Channel<Int>() //default size is 1
88. USAGE val channel = Channel<Int>() //default size is 1 GlobalScope.launch { for (i in 1..5) { delay(100) channel.send(i) } channel.close() }
89. USAGE val channel = Channel<Int>() //default size is 1 GlobalScope.launch { for (i in 1..5) { delay(100) channel.send(i) } channel.close() }
90. USAGE val channel = Channel<Int>() //default size is 1 GlobalScope.launch { for (i in 1..5) { delay(100) channel.send(i) } channel.close() } GlobalScope.launch { for (i in channel) println(“received: $i”) }
91. Producer, Publisher and Actor
92. Producer, Publisher and Actor • produce<E> {} - streams of event
93. Producer, Publisher and Actor • produce<E> {} - streams of event • publish<E> {} - becomes a stream of event upon subscription
94. Producer, Publisher and Actor • produce<E> {} - streams of event • publish<E> {} - becomes a stream of event upon subscription • actor<E> - implements SendChannel<E>
95. Sending a message to multiple listeners • BroadCastChannel<E>
96. Sending a message to multiple listeners • BroadCastChannel<E> • ConflatedBroadCastChannel<E>
97. RxJava InterOp Call `openForSubscription` extension function on Observable / Flowable
98. RxJava InterOp Call `openForSubscription` extension function on Observable / Flowable Flowable.range(1, 5).openForSubscription().consume { for (i in this) println(i) // ReceiveChannel<Int> }
99. RxJava InterOp Call `openForSubscription` extension function on Observable / Flowable Flowable.range(1, 5).openForSubscription().consume { for (i in this) println(i) // ReceiveChannel<Int> } Or Flowable.range(1, 5).consumeEach{ println($it) }
100. Convert Job to Rx Completable val job = GlobalScope.launch { heavyComputation() }
101. Convert Job to Rx Completable val job = GlobalScope.launch { heavyComputation() } job.asCompletable(Dispatchers.Default)
102. Convert Job to Rx Completable val job = GlobalScope.launch { heavyComputation() } job.asCompletable(Dispatchers.Default).subscribe({..},{.. })
103. Convert Deferred to Rx Single suspend fun loadData(): List<Item> { } val deferred = GlobalScope.async { loadData() } deferred.asSingle(Dispatcher.DEFAULT).subscribe({ //on success }, { //on error })
104. RxJava Coroutine Builders rxObservable { } rxFlowable { } rxCompletable { } rxSingle { } rxMaybe { }
105. ANDROID INTEGRATION kotlin { experimental { coroutines ‘enable’ } }
106. ANDROID INTEGRATION kotlin { experimental { coroutines ‘enable’ } } implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-core:0.26.1’
107. ANDROID INTEGRATION kotlin { experimental { coroutines ‘enable’ } } implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-core:0.26.1’ implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-android:0.26.1’
108. ANDROID INTEGRATION kotlin { experimental { coroutines ‘enable’ } } implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-core:0.26.1’ implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-android:0.26.1’ implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-rx2:0.26.1’
109. Retrofit Integration val retrofit = Retrofit.Builder() .baseUrl(“http://apiurl.com/”) .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build();
110. Retrofit Integration val retrofit = Retrofit.Builder() .baseUrl(“http://apiurl.com/”) .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build(); //gradle implementation “com.jakewharton.retrofit:retrofit2-kotlin-coroutine-experimental-adapter:1.0.0” implementation “com.jakewharton.retrofit:retrofit2-kotlin-coroutine-adapter:0.9.2”
111. interface MyService { @GET(“/user”) fun getUser(): Deferred<User> or @GET(“/user”) fun getUser(): Deferred<Response<User>> }
112. FURTHER READING https://codelabs.developers.google.com/codelabs/kotlin-corou tines/index.html#0 https://github.com/Kotlin/kotlinx.coroutines/blob/master/cor outines-guide.md https://github.com/Kotlin/kotlinx.coroutines/blob/master/rea ctive/coroutines-guide-reactive.md