Using Kotlin Coroutines on Android

Transcript

1. Using Kotlin Coroutines on Android June 8th, 2019
2. Hi, I’m Adora Software Engineer Creator of AdoraHack Women Techmakers Ajah Ambassador FSDLagos & Android Ngr Co-organizer Twitter, @theadoranwodo
3. What we want to do val order = fetchOrderDetails() textView.text = order.code Never block the main thread
4. The Reality val order = fetchOrderDetails() // NetworkOnMainThreadException textView.text = order.code
5. The Reality thread{ val order = fetchOrderDetails() textView.text = order.code // CalledFromWrongThreadException }
6. A Solution fetchOrderDetails{ order -> textView.text = order.code } Lots of memory leaks Also very difficult to read. We don’t want callback hell :(
7. A Nightmare fetchOrderDetails{ order -> textView.text = order.code someDbTransaction{ db_res -> anotherCallback{ res -> saveToFile{ res -> // and it continues ... } } } }
9. Introducing Coroutines
10. Let’s try Coroutines Coroutines are lightweight threads. Anti callbacks. Write code sequentially. Makes code easier to read. We can have much more coroutines as opposed to threads. Coroutine mechanism: suspend and resume. Declare a very heavy task as a suspend function
11. Let’s try Coroutines - suspend function suspend fun fetchOrderDetails(): Order { … } suspend fun doSomething() { val order = fetchOrderDetails() textView.text = order.code }
12. Where can I call a suspend function? In another suspend function’ In coroutine builders (e,g, async, launch) In suspend lambdas In coroutine scopes
13. Coroutines with WorkManager
14. WorkManager WorkManager provides a unified API for background work taking battery and compatibility across Android versions to account. - Worker - CoroutineWorker - RxWorker - ListenableWorker
15. WorkManager & Coroutines dependencies { def work_version = "2.0.1" // Kotlin + coroutines implementation "androidx.work:work-runtime-ktx:$work_version" } Snippet from: https://developer.android.com/topic/libraries/architecture/workmanager/advanced/coroutineworker.html
16. WorkManager & Coroutines class CoroutineDownloadWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) { override val coroutineContext = Dispatchers.IO override suspend fun doWork(): Result = coroutineScope { val jobs = (0 until 100).map { async { downloadSynchronously("https://www.google.com") } } // awaitAll will throw an exception if a download fails, which CoroutineWorker will treat as a failure jobs.awaitAll() Result.success() } } Snippet from: https://developer.android.com/topic/libraries/architecture/workmanager/advanced/coroutineworker.html
17. Coroutines with Architecture components + Coroutine Leaks
18. Coroutine leaks To deal with Coroutine leaks, Kotlin introduced Coroutine scopes. A scope is a way to keep track of coroutines. Coroutines run in a scope and the scope has the ability to cancel all the coroutines inside it. Use scopes to avoid leaks. Structured concurrency.
19. Coroutine Scopes //viewmodel scope implementation “androidx.lifecycle:lifecycle-viewmodel-ktx:$view_model_scope_version” //lifecycle scope implementation “androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_scope_version” //livedata implementation “androidx.lifecycle:lifecycle-livedata-ktx:$livedata_scope_version”
20. viewModelScope Coroutines are useful here when there is work that should be done only when the ViewModel is active. class MyViewModel: ViewModel() { init { viewModelScope.launch { // Coroutine that will be canceled when the ViewModel is cleared. } } }
21. LifecycleScope A LifecycleScope is defined for each Lifecycle object. Any coroutine launched in this scope is canceled when the Lifecycle is destroyed. You can access the Lifecycle’s CoroutineScope either via lifecycle.coroutineScope or lifecycleOwner.lifecycleScope properties. LifecycleOwner could be an Activity or a Fragment.
22. liveData LiveData is an observable value holder for UI It is now interoperable with Coroutines Compute value in Coroutine and serve as LiveData
23. liveData val user = liveData { val data = database.loadUser() // loadUser is a suspend function. emit(data) } - Use the liveData builder function to call a suspend function asynchronously, - use emit() to emit the result:
24. Testing Coroutines
25. Testing Coroutines kotlinx-coroutines-test : Experimental coroutines API It’s not coupled to any testing libraries, you can use any library.
26. Testing Coroutines val testDispatcher = TestCoroutineDispatcher() val testScope = TestCoroutineScope(testDispatcher) @Before fun setup(){ Dispatchers.setMain(testDispatcher) } @After fun tearDown(){ Dispatchers.resetMain() testScope.cleanupTestCoroutines() }
27. Testing Coroutines @get: Rule val testCoroutineRule = TestCoroutineRule() @Test fun testSomething() = testCoroutineRule.runBlockingTest { // test code here }
28. Resources https://kotlinlang.org/docs/reference/coroutines-overview.html https://codelabs.developers.google.com/codelabs/kotlin-coroutines/ https://developer.android.com/kotlin/coroutines
29. Thanks! www.adoranwodo.com www.adorahack.com Twitter: @theadoranwodo GitHub: adoranwodo