Coroutines in Practice

To implement asynchronous logic, many devs use RxJava. But, Kotlin provides us with another toolset called Coroutines. I have been integrating Coroutines at Vimeo. In this talk, I will share with you my journey and the challenges I encountered. We will look at how to handle simple to complex uses cases with Coroutines. Some of these use cases are bridging a callback based SDK to coroutines, using Coroutines with MVP, handling polling and writing tests. I'll also show the usage of actors, channels and supervisor scope in real examples. Please join me to learn about my ongoing journey to introduce coroutines in an app.

Transcript

1. Coroutines in Practice Mohit Sarveiya /heyitsmohit twitter.com
2. Coroutines in Practice • Convert feature from RxJava to Coroutines • Scopes • Context & Dispatchers
3. Why Coroutines? • Language level support • Multiplatform support - In Progress • Scopes
4. Mac OS App
 (VIPER) Android App
 (MVP) Libraries Problem iOS App
 (VIPER) Libraries Libraries
5. Mac OS App
 (VIPER) Android App
 (MVP) Async
 Logic Goal iOS App
 (VIPER)
6. TV App Android App Document
 Feature Document Feature
7. Document Feature • Gets HTML text from API • Privacy policy • TOS • Pull to refresh • Error state
8. Document Feature • Simple feature • Uses Model View Presenter • Playground to show new patterns & libraries
9. Document Feature View Presenter Model
10. Document Feature View Presenter Model Attached
11. Document Feature View Presenter Model Attached getDocument(uri: String)
12. Document Feature View Presenter Model Document
 </html>
13. data class Document( @Json(name = "html") val html: String? = null ) Document Model
14. Document Feature View Presenter Model showHtml(html:String) Document
 </html>
15. Feature in RxJava
16. interface DocumentContract { interface Presenter { fun onViewAttached(view: DocumentContract.View) fun onViewDetached() fun onPullToRefresh() } } MVP Contract
17. interface DocumentContract { interface View { fun showLoadingState() fun showErrorState() fun showRawHtml(rawHtml: String) } } MVP Contract
18. interface Model { fun fetchHtmlDocument(): Single<DocumentResponse> } Model
19. sealed class DocumentResponse { data class Success(val data: String) : DocumentResponse() data class Error(val error: DocumentRequestError) : DocumentResponse() } API Response
20. class DocumentPresenter( val documentModel: DocumentContract.Model, val backgroundScheduler: Scheduler, val foregroundScheduler: Scheduler ) : Presenter<View> { val compositeDisposable = CompositeDisposable() var fetchDocumentDisposable: Disposable? = null } Presenter
21. class DocumentPresenter(…) : Presenter<View> { } Presenter override fun onViewAttached(view: DocumentContract.View) { documentView = view fetchHtmlDocument() } override fun onPullToRefresh() = fetchHtmlDocument()
22. Presenter fun fetchHtmlDocument() { fetchDocumentDisposable = documentModel.fetchHtmlDocument() .subscribeOn(backgroundScheduler) .observeOn(foregroundScheduler) .subscribe { response !-> when (response) { is DocumentResponse.Success !-> 
 documentView!?.showRawHtml(response.data) is DocumentResponse.Error !-> { if (response.documentRequestError !== NoNetwork) { documentView!?.showNoNetworkErrorState() } else { documentView!?.showGenericErrorState() } } } } }
23. Threading fun fetchHtmlDocument() { fetchDocumentDisposable = documentModel.fetchHtmlDocument() .subscribeOn(backgroundScheduler) .observeOn(foregroundScheduler) .subscribe { response !-> when (response) { is DocumentResponse.Success !-> 
 documentView!?.showRawHtml(response.data) is DocumentResponse.Error !-> { if (response.documentRequestError !== NoNetwork) { documentView!?.showNoNetworkErrorState() } else { documentView!?.showGenericErrorState() } } } } }
24. Handle Response fun fetchHtmlDocument() { fetchDocumentDisposable = documentModel.fetchHtmlDocument() .subscribeOn(backgroundScheduler) .observeOn(foregroundScheduler) .subscribe { response !-> when (response) { is DocumentResponse.Success !-> 
 documentView!?.showRawHtml(response.data) is DocumentResponse.Error !-> { if (response.documentRequestError !== NoNetwork) { documentView!?.showNoNetworkErrorState() } else { documentView!?.showGenericErrorState() } } } } }
25. Cancellation val compositeDisposable = CompositeDisposable() override fun onViewDetached() { compositeDisposable.clear() }
26. View class HtmlDocumentActivity : DocumentContract.View { swiperefreshlayout!?.setOnRefreshListener(documentPresenter!::onPullToRefresh) override fun onCreate() { documentPresenter.onViewAttached(this) } override fun onStop() { documentPresenter.onViewDetached() } … }
27. Convert to Coroutines
28. Basics Concepts • Scopes • Context • Job • Dispatchers
29. Coroutine GlobalScope.launch { val document: Document = model.getDocument(uri) view.showHtml(document.html) }
30. interface Model { suspend fun getDocument(): Document } Model
31. Suspend keyword • Allows method to suspend and resume computation • Non blocking
32. Using Suspend Method fun onCreate() { val document: Document = model.getDocument(uri) }
33. Where could you call suspending functions? • Other suspend functions • Coroutine builders Using Suspend Method fun onCreate() { val document: Document = model.getDocument(uri) }
34. Coroutine Builders • Launch • Async • RunBlocking • Actor
35. How to use coroutine builders 1. Need to create a scope
 2. Call any of the builder methods on the scope.
36. What is a Scope? • Specify the lifetime of async operations • Group together async operations
37. Global Scope GlobalScope.launch { val document: Document = model.getDocument(uri) } Depends on app’s life time
38. Job val job: Job = GlobalScope.launch { val document: Document = model.getDocument(uri) } job.cancel()
39. Job States • Active • Completing • Cancelling • Completed
40. Job val job: Job = GlobalScope.launch { val document: Document = model.getDocument(uri) } job.isActive job.isCompleted job.isCancelled
41. Threading val job: Job = GlobalScope.launch { val document: Document = model.getDocument(uri) } Which thread will it run on?
42. Context object GlobalScope : CoroutineScope { val coroutineContext: CoroutineContext }
43. Context Set of elements contains • Job • Dispatcher
44. Dispatcher Specifies which thread the coroutines will run on. • Default Dispatcher • IO • Main • Unconfined
45. Threading GlobalScope.launch { val document: Document = model.getDocument(uri) } Default Dispatcher Thread Pool
46. Threading GlobalScope(Dispatchers.IO).launch { val document: Document = model.getDocument(uri) }
47. Main Thread val scope = CoroutineScope(Dispatchers.Main) scope.launch { }
48. Main Thread val scope = CoroutineScope(Dispatchers.Main) scope.launch { val document = model.getDocument(uri) } Network On Main Thread Exception
49. Switch Threads val scope = CoroutineScope(Dispatchers.Main) scope.launch { val document = withContext(Dispatchers.IO) { 
 return model.getDocument(uri) } }
50. Document Feature View Presenter Model
51. Document Feature View Presenter Model
52. Updating Model 1. Bridge callback to coroutines in the app
 2. Update SDK to use Coroutines with Retrofit • Suspend function • Deferred type
53. Updating Model 1. Bridge callback to coroutines in the app
 2. Update SDK to use Coroutines with Retrofit • Suspend function • Deferred type
54. SDK Model API Networking Library
56. class VimeoClient { Call<Document> getDocument(String uri, VimeoCallback<Document> callback) { Call<Document> call = vimeoService.getDocument(uri); call.enqueue(callback); return call; } … } Getting data from the API
57. suspend fun <T> suspendCancellableCoroutine( block: (CancellableContinuation<T>) !-> Unit ): T Bridge Callbacks to Coroutines
58. interface CancellableContinuation<in T> { fun resumeWith(result: Result<T>) fun resume(value: T)
 fun resumeWithException(exception: Throwable) } Bridge Callbacks to Coroutines
59. suspend fun getDocument(uri: String): DocumentResponse<Document> { return suspendCancellableCoroutine<Result<Document!>> { cont !-> } } Bridge Callbacks to Coroutines
60. suspend fun getDocument(uri: String): DocumentResponse<Document> { return suspendCancellableCoroutine<Result<Document!>> { cont !-> } } Bridge Callbacks to Coroutines How do we resume on success and failure?
61. suspend fun getDocument(uri: String): DocumentResponse<Document> { return suspendCancellableCoroutine<Result<Document!>> { cont !-> val call = vimeoClient.getDocument(uri, object :VimeoCallback<Document>() { override fun success(document: Document) { cont.resume(Success(document)) } override fun failure(error: VimeoError) { cont.resume(Error(error)) } }) } Bridge Callbacks to Coroutines
62. Problems • Boiler plate code • Repetitive
63. Factory Callback Function Suspend Function Improvement
64. Creating a Factory class VimeoClient { Call<Document> getDocument(String uri, VimeoCallback<Document> callback) Call<Comment> comment(String uri, String comment, String password, VimeoCallback<Comment> callback) }
65. Creating a Factory interface SuspendFunctionFactory { fun <A, T> convertToSuspendFunction ( fn: (A, VimeoCallback<T>) !-> Call<T> ): suspend (A)!-> Result<T> }
66. Creating a Factory fun <A, T> convertToSuspendFunction ( fn: (A, VimeoCallback<T>) !-> Call<T> ): suspend (A)!-> Result<T> = { a !-> } Function Reference
67. Creating a Factory fun <A, T> convertToSuspendFunction ( fn: (A, VimeoCallback<T>) !-> Call<T> ): suspend (A)!-> Result<T> = { a !-> } Suspending Function
68. Creating a Factory fun <A, T> convertToSuspendFunction ( fn: (A, VimeoCallback<T>) !-> Call<T> ): suspend (A)!-> Result<T> = { a !-> suspendCancellableCoroutine { cont !-> val call = fn(a, object : VimeoCallback<T>() { override fun success(t: T) { cont.resume(Success(t)) } override fun failure(error: VimeoError) { cont.resume(Error(error)) } }) }
 }
69. Factory Callback Function Suspend Function Reusable Factory
70. Updating Model class DocumentModel( val vimeoClient: VimeoClient, val factory: SuspendFunctionFactory ) { suspend fun getDocument(): Result<Document> = }
71. Updating Model class DocumentModel(
 val vimeoClient: VimeoClient, val factory: SuspendFunctionFactory, val requestDispatcher: CoroutineDispatcher = Dispatchers.IO ) { suspend fun getDocument(): Result<Document> = 
 
 } }
72. Updating Model class DocumentModel(
 val vimeoClient: VimeoClient, val factory: SuspendFunctionFactory, val requestDispatcher: CoroutineDispatcher = Dispatchers.IO ) { suspend fun getDocument() = withContext(requestDispatcher) {
 
 } }
73. Updating Model suspend fun getDocument() = withContext(requestDispatcher) {
 result = factory.convertToSuspendFunction(vimeoClient!::getDocument)(uri) return when (result) { is VimeoApiResponse.Success !-> result.data.html.let { Success(it) } is VimeoApiResponse.Failure !-> Error() 
 } }
74. Updating Model 1. Bridge callback to coroutines in the app
 2. Update SDK to use Coroutines with Retrofit • Suspend function • Deferred type
76. repositories { maven { url 'https:!//oss.sonatype.org/content/repositories/snapshots/' } google() jcenter() } Using Coroutines with Retrofit build.gradle
77. !// Retrofit version 2.6.0 SNAPSHOT implementation 'com.squareup.retrofit2:retrofit:2.6.0-SNAPSHOT' implementation ‘com.squareup.retrofit2:converter-moshi:2.6.0-SNAPSHOT' !// Coroutines implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.2.0' implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.2.0' Using Coroutines with Retrofit build.gradle
78. interface VimeoService { @GET fun getDocument(@Url uri: String): Call<Document> … } Using Coroutines with Retrofit
79. interface VimeoService { @GET fun getDocument(@Url uri: String): Call<Document> … } Using Coroutines with Retrofit
80. interface VimeoService { @GET fun getDocument(@Url uri: String): Document … } Using Coroutines with Retrofit
81. interface VimeoService { @GET suspend getDocument(@Url uri: String): Call<Document> … } Using Coroutines with Retrofit
82. Using Coroutines with Retrofit class VimeoClient { suspend fun getDocument(uri: String): Document … }
83. Updating Model 1. Bridge callback to coroutines in the app
 2. Update SDK to use Coroutines with Retrofit • Suspend function • Deferred type
84. Using Deferred Type • Kotlin’s future type • It has a associated type
86. Using Deferred Type val retrofit = Retrofit.Builder() .baseUrl(baseUrl) .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build()
87. Using Deferred Type interface VimeoService { @GET fun getDocument(@Url uri: String): Deferred<Document> … }
88. Using Deferred Type val vimeoClient = VimeoClient() val deferred: Deferred<Document> = vimeoClient.getDocument(uri) val document = deferred.await()
89. Update Presenter View Presenter Model
90. Update Presenter Approach • Create custom scope in presenter • Launch it on the main thread • Do context switch to make request
91. Inject Dispatcher class DocumentPresenter( val documentModel: DocumentContract.Model, val uiDispatcher: CoroutineDispatcher ) { }
92. Create scope class DocumentPresenter( val documentModel: DocumentContract.Model, val uiDispatcher: CoroutineDispatcher ) { var uiScope: CoroutineScope = CoroutineScope(uiDispatcher) }
93. Update Presenter class DocumentPresenter( val documentModel: DocumentContract.Model, val uiDispatcher: CoroutineDispatcher, ) { var uiScope: CoroutineScope = CoroutineScope(uiDispatcher) var fetchDocumentJob: Job? = null override fun onViewAttached(view: DocumentContract.View) { documentView = view fetchHtmlDocument() } }
94. Launch Coroutine fun fetchHtmlDocument() { fetchDocumentJob = uiScope.launch { } }
95. Launch Coroutine fun fetchHtmlDocument() { fetchDocumentJob = uiScope.launch { val result: Result<Document> = documentModel.getDocument() when (result) { is DocumentRequestResult.Success !-> 
 documentView!?.showRawHtml(result.document) is DocumentRequestResult.DocumentRequestError !-> { documentView!?.showGenericErrorState() } } }
96. Cancellation class DocumentPresenter( val documentModel: DocumentContract.Model, val uiDispatcher: CoroutineDispatcher, ) { … override fun onViewDetached() { uiScope.coroutineContext[Job]!?.cancel() } }
97. MVVM - Arch Comp Activity 
 
 ViewModel LiveData Repository
99. Coroutine Extensions val ViewModel.viewModelScope: CoroutineScope get() { val scope: CoroutineScope? = this.getTag(JOB_KEY) if (scope !!= null) { return scope } return setTagIfAbsent(JOB_KEY, CloseableCoroutineScope(Job() + Dispatchers.Main)) }
100. View Model class DocumentModel(): ViewModel() { fun fetchHtmlDocument() { viewModelScope.launch { val result = documentModel.fetchHtmlDocument() } } }
101. Resources
102. https://bit.ly/2GrDMDG
103. https://speakerdeck.com/heyitsmohit/dissecting-coroutines
107. Resources • https://medium.com/vimeo-engineering-blog/kotlin-coroutines- vimeo-a-case-study-part-1-555e78aee8b9 • https://www.capitalone.com/tech/software-engineering/ coroutines-and-rxjava-asynchronous-programming • https://medium.com/androiddevelopers/rxjava-to-kotlin- coroutines-1204c896a700
108. Thank you! twitter.com/heyitsmohit