Async_with__Kotlin_Coroutines.pdf

Asynchronous programming using Kotlin Coroutine in Android.

Transcript

1. Async with Kotlin Coroutines Lead Software Engineer(Android) @Augmedix Inc. Search me on google: 0xAliHn
3. ➢ Preemptively multitasking ➢ Managed by OS ➢ A thread is directly linked to the native thread in the corresponding OS ➢ It consumes a lot of memory for its stack. That’s why you cannot just create 100k threads ➢ Cooperatively multitasking ➢ Managed by a user ➢ It doesn't map on a native thread, it doesn't require context switching on a processor ➢ Coroutine in Kotlin doesn't have its own stack. So, you can create thousand of threads Thread vs Coroutines
4. Blocking...
5. Non-Blocking
6. What we want? val user = fetchUserData() textView.text = user.name This is our dream code right? NetworkOnMainThreadException
7. thread { val user = fetchUserData() textView.text = user.name } Call From WrongThread Exception
8. This is OK code... fetchUserData() { user -> //Callback textView.text = user.name } OutofMemoryError
9. Finally working code val subscription = fetchUserData() { user -> //Callback textView.text = user.name } override fun onStop() { subscription.cancel() }
10. And eventually you end up with something like this :) override fun onStop() { subscription1.cancel() subscription2.cancel() subscription3.cancel() subscription4.cancel() subscription5.cancel() }
11. Some old way to solve async... • Asynctask • Service/IntentService • Handlers • Thread
12. Solution -> Rx way... fun fetchUser() : Observable<User> {... } fetchUser() .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe { user -> textView.text = user.name }
13. LiveData way.... fun fetchUser() : LiveData<User> {... } fetchUser() .observe(viewLifecycleOwner) { textView.text = user.name }
14. So, problem is solved then why we need another solution?
15. 3 solutions LiveData Observable Data Holder RxJava Observabe + Schedulers + Observer Coroutines Suspendable Computations
16. What developer says…. LiveData Love it, But want a complete solution RxJava Powerful, highly adopted but often misused and perceived as an overkill solution to concurrency. Coroutines Seems like a great solution but there is a need for maturation of the extensions and developer feel that a steeve learning curve awaits....
17. What are Coroutines? ➢ The first language to explore using coroutines was Simula in 1967. ➢ A lightweight thread that can run a computation ➢ Non blocking code ➢ Simplify asynchronous programming by replacing callbacks ➢ It can be suspended and resume at later time
18. Coroutines are a great solution for two problems: 1. Long running tasks are tasks that take too long to block the main thread. 2. Main-safety allows you to ensure that any suspend function can be called from the main thread.
19. Coroutines Key concepts... ❏ Suspend Function ❏ Coroutine Context ❏ Coroutine Dispatchers ❏ Coroutine Builders
20. Suspend Function • A function that can be started, paused and resume at a later time • Can only be called from a coroutine or from another suspending function • Can take parameters and have return types
21. suspend fun doComputation (params: Int): Int { // Do some computation here }
22. Coroutine Context • Every coroutine in Kotlin has a context that is represented by an instance of CoroutineContext interface. • A coroutine itself is represented by a Job. It is responsible for coroutine’s lifecycle, cancellation, and parent-child relations. • There is also an interface called CoroutineScope that consists of a sole property — val coroutineContext: CoroutineContext
23. val uiContext: CoroutineContext = UI val bgContext: CoroutineContext = CommonPool
24. Coroutine Dispatchers Dispatchers.Main • Main thread on Android • Interact with the UI and perform light work • Calling suspend functions • Call UI functions • Updating LiveData Dispatchers.IO • Optimized for disk and network IO • off the main thread • Database • Reading/writing files • Networking Dispatchers.Default • Optimized for CPU intensive work • off the main thread • Sorting a list • Parsing JSON • DiffUtils
25. Coroutine Builders 1. launch - builder will start a new coroutine that is “fire and forget” — that means it won’t return the result to the caller. 2. async - builder will start a new coroutine, and it allows you to return a result with a suspend function called await. 3. runBlocking - Runs new coroutine and blocks current thread interruptible until it’s completed
26. Code example... scope.launch { // This block starts a new coroutine // "in" the scope. // It can call suspend functions fetchUser() } val deferredUser = GlobalScope.async { fetchUser() } try { val user = deferredUser.await() } catch (exception: Exception) { // Handle your exception }
27. Let’s understand how it works really...
28. Retrofit with Coroutines... @GET() fun getUser(): Call<User> @GET() fun getUser(): Observable<User> @GET() fun getUser(): Deferred<User> interface ApiService { } //From retrofit 2.6.0 @GET() suspend fun getUser(): User
29. Coroutines in Android Repository class... override suspend fun fetchUser() { withContext(Dispatchers.IO) { val user = remoteDataSource.getUser().await() localDataSource.saveUser(user) } }
30. Coroutines in Android ViewModel private var viewModelJob = Job() private val coroutineScope = CoroutineScope(viewModelJob + Dispatchers.Main) coroutineScope.launch { val user = repository.fetchUser() try { _userLiveData.value = user } catch (e: Exception) { _userLiveData.value = ArrayList() } }
31. RxJava to Coroutines • if you are already using RxJava and it works for you, then use RxJava • if the architecture is based on reactive stream, then use RxJava • if the codebase is contains lots of Rx operator, then use RxJava • else, use coroutines
32. Coroutines in Android Jetpack ➢ Workmanager - CoroutineWorker ➢ Retrofit - suspend function ➢ Room - suspend function ➢ livedata Builder - Make livedata with coroutines ➢ viewModelScope - Launch in ViewModel ➢ lifecycleScope - UI related coroutines ➢ Kotlinx-coroutines-test - Testing coroutines
33. Further Reading... ❏ https://medium.com/androiddevelopers/coroutines-on-android-part- i-getting-the-background-3e0e54d20bb ❏ https://codelabs.developers.google.com/codelabs/kotlin-coroutines/ #9 ❏ https://kotlinlang.org/docs/reference/coroutines/coroutines-guide.ht ml ❏ https://blog.mindorks.com/mastering-kotlin-coroutines-in-android-st ep-by-step-guide ❏ https://www.youtube.com/watch?v=BOHK_w09pVA