Kotlin Coroutines and Flow for Android Development 2023
Updated 1/2023
MP4 | Video: h264, 1280×720 | Audio: AAC, 44.1 KHz
The Complete Guide! Get a deep understanding of Kotlin Coroutines and Flow to use them successfully in your Android Apps
What you’ll learn
Implement the most common use cases for Kotlin Coroutines and Flow on Android
Get a deep understanding of Kotlin Coroutines and Flows
Learn advanced Coroutine Concepts (Structured Concurrency, Coroutine Scopes and Contexts, internal workings, )
Learn how to create Flows using different Flow builders
Learn about Flow operators (lifecycle operators, intermediate operators, terminal operators)
Learn about different kind of Flows (regular Flows, SharedFlows, StateFlows)
Create a stock live-tracking app with Flows
Learn when to use Channels in Android Development
Understand the advantages of using Coroutines over Callbacks or RxJava.
How to perform network requests with Retrofit sequentially and concurrently.
How to use Room together with Coroutines.
Background processing with Coroutines.
Exception Handling and Cancellation in Coroutines and Flows.
How to write Unit Tests for coroutine-based implementations
Requirements
No prior knowledge about Kotlin Coroutines or Flow needed, however you should be familiar with the Basics of Kotlin and Android, as well as some Android Jetpack Components (ViewModels, LiveData, Room) and Retrofit.
Description
Google recommends Kotlin Coroutines and Flow as the preferred solution for asynchronous programming on Android. Sooner or later, probably every Android developer will get in touch with these topics.
This course will give you a deep understanding of Kotlin Coroutines and Flow and show how to implement the most common use cases for Android applications.
Then, we will talk about some theoretical fundamentals. These include:
Routines vs. Coroutines
Suspend Functions
Coroutines vs. Threads
Blocking vs. Suspending
Multithreaded Coroutines
Internal workings
Next, we will implement some of the most common use cases for Kotlin Coroutines in Android applications. These include:
Performing network requests with Retrofit sequentially and concurrently
Implementing Timeouts and Retries
Using Room with Coroutines
Performing background processing with Coroutines
Continuing Coroutine execution even when the user leaves the screen.
To improve your learning experience, this course also challenges you with several exercises.
Coroutine Builders (launch, async, runBlocking)
Coroutine Context
Coroutine Dispatchers
Structured Concurrency
Coroutine Scopes (viewModelScope, lifecycleScope, GlobalScope)
Jobs and SupervisorJobs
scoping functions (coroutineScope{ and supervisorScope{)
Cooperative Cancellation
Non-Cancellable Code
We will also make a deep dive into Exception Handling and discuss concepts like:
exception handling with try/catch
exception handling with CoroutineExceptionHandlers
when to use try/catch and when to use a CoroutineExceptionHandler
exception handling specifics of scoping functions coroutineScope{ and supervisorScope{
Unit Tests are very important for every codebase. In the course’s final section, we will write unit tests for most of the coroutine-based use cases we implemented earlier. We will discuss concepts like
TestCoroutineDispatcher
creating a JUnit4 Rule for testing coroutine-based code
runBlockingTest{ Coroutine Builder
virtual time
Testing sequential and concurrent execution
TestCoroutineScope
Afterward, we are going to have a look at different Flow builders and operators:
basic flow builders
terminal operators
terminal operator “launchIn()”
terminal operator “asLiveData()”
lifecycle operators
intermediate operators
In our first real Flow use case, we use a Flow to create a live stock-tracking feature, that uses all the available basic flow components.
In the next module, we will take a look at Exception Handling and Cancellation with Kotlin Flow.
In the following module, you will learn about StateFlow and SharedFlow and the following concepts:
how to make Coroutines lifecycle-aware with the “repeatOnLifecycle()” suspend function
Hot Flows VS Cold Flows
Converting Flows to SharedFlows with the “shareIn()” operator
Converting Flows to StateFlows with the “stateIn()” operator
When to use SharedFlow and when to use StateFlow
Next, you will learn about Channels, how they differ from hot flows, and when they are useful in Android Applications.
By the end of this course, you will have a fundamental understanding of Kotlin Coroutines and Flows and be able to write readable and maintainable, asynchronous, and multithreaded Android Applications.
Who this course is for:
Android Developers who want to get a deep understanding of Kotlin Coroutines and Flow and want to know how to implement the most common use cases on Android.