Kotlin Coroutines: In Depth
Learn how to implement coroutines in a real-world example of an Android application, with structured layers and decoupled dependencies. You'll see how to test coroutines, handle errors, and structure concurrency in a clean and stable way. By Filip Babić.
Learning path
This is part of the Advanced Android Data & Networking learning path. View path.
Who is this for?
This course is for Android developers who have heard about coroutines, or have tried writing concurrency code using coroutines, but want to learn more about advanced usage in real-world examples. This is also for people who understand coroutines but want to learn the best practices of using coroutines.
It expects you to be familiar with Android Studio, Kotlin, and the basics of using Retrofit and Room in Android. Familiarity with architectural patterns such as the MVP, or MVVM is helpful, but not crucial to this course. Knowledge about Mockito and JUnit4 is required, for the second part of the course.
Covered concepts
- The theoretical computer science background behind coroutines.
- Implementing coroutines to replace callbacks.
- Coroutine Jobs and their lifecycle.
- CoroutineScope and binding coroutines to lifecycle-aware components.
- Writing explicit and idiomatic concurrency code.
- Context switching in coroutines in a clean way, decoupling and keeping implementation details from high-level components.
- Basic and custom exception handling in coroutines.
- Wrapping data and exceptions from coroutines to a state-machine result.
- Logging coroutine threads and information.
- Testing coroutines using the JUnit framework.
- Dealing with delays and time logic in coroutine tests.
Part 1: Dive Into Coroutines
Take a tour around asynchronous programming mechanisms in Android, and learn what coroutines are, how they work, and why you should consider using them instead.
In this episode, start your first coroutine Job, and see what its lifecycle is.
Understand what the CoroutineContext is, and how it influences coroutines.
Explore some advanced Job relations and functionality, and how to communicate the lifecycle of coroutines to the rest of the project.
Part 2: Implement Coroutines In Android
Learn the structure and the features of the project you'll be working on, and how to use the best practices of Kotlin Coroutines.
Launch the basic Kotlin Coroutine functions, to simplify background work in the project.
Learn how to bind your coroutines to the lifecycle of your app's components, such as Activities or Fragments.
Learn what context switching means, and how to bridge the gap between asynchronous and synchronous worlds. Dive into the concept of suspendability.
Separate business logic from context switching and threading by abstracting away implementation details. Decouple dependencies for context providing to support testing.
Part 3: Debug & Test Coroutines
Handle errors that occur within coroutines with custom error handlers or manual exception catching. Or, instead of working with exceptions, wrap your data with a Result.
Apply needed changes to have a clear log of information, about which coroutines are running and in which threads.
Learn how to set up the testing environment, so you can easily run and test coroutines using JUnit 4 and Mockito, and verify the functionality of your code.
Part 4: Coroutines With Libraries
Instead of awaiting a Response from Retrofit, use the suspend function approach to expect an entity model directly from the API.
Remove async calls and wrappers, and rely on the internal Room logic to fetch data without blocking.
Find out how to connect the Android Lifecycle and the CoroutineScope to handle cancellation automatically using ViewModels.