Kotlin Coroutines and Flow for Android Development

Kotlin Coroutines and Flow for Android Development, available at $99.99, has an average rating of 4.77, with 156 lectures, based on 1549 reviews, and has 8613 subscribers.

You will learn about 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 This course is ideal for individuals who are 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. It is particularly useful 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.

Enroll now: Kotlin Coroutines and Flow for Android Development

Summary

Title: Kotlin Coroutines and Flow for Android Development

Price: $99.99

Average Rating: 4.77

Number of Lectures: 156

Number of Published Lectures: 156

Number of Curriculum Items: 156

Number of Published Curriculum Objects: 156

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will 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

Who Should Attend

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.

Target Audiences

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.

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.

This course consists of two big parts: The Coroutines part and the Flow part.

Before being able to use Flows in our applications, we first need a solid understanding of Coroutines. That’s why Coroutines are covered first. However, if you already have some experience with Coroutines, then you can also start with the Flow part right away, and jump back to lessons of the Coroutines part whenever needed.

In the part about Coroutines, first, we will take a detailed look at the advantages of Kotlin Coroutines over other approaches for asynchronous programming, like RxJava and Callbacks.

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.

Learning Coroutines can be overwhelming because you need to learn a lot of new concepts. However, we are going to start simple and as our use cases will get more and more complex, we will learn about new concepts step-by-step. These new concepts are:

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 in Coroutines started with launch and async

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

In the part about Kotlin Flow, we first cover all the basics. We will answer the question “What is a Flow?” and then we discuss the benefits and drawbacks of reactive programming.

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.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Extended Course Preview

Lecture 2: Course Structure and Goals

Lecture 3: How to get the source code of the Sample Project

Lecture 4: Basic Setup of Sample Project

Chapter 2: Different Approaches for Asynchronous Programming

Lecture 1: Section Introduction

Lecture 2: What is Asynchronous Programming?

Lecture 3: Use Case Explanation

Lecture 4: Callback Implementation

Lecture 5: RxJava Implementation

Lecture 6: Coroutines Implementation

Lecture 7: Comparing Approaches

Lecture 8: Recap

Chapter 3: Coroutine Fundamentals

Lecture 1: Section Introduction

Lecture 2: Routines and Coroutines

Lecture 3: Suspend Functions

Lecture 4: Coroutines and Threads

Lecture 5: Blocking VS Suspending

Lecture 6: Multithreaded Coroutines

Lecture 7: Internal Workings

Lecture 8: How delay() works

Lecture 9: Section Recap

Chapter 4: Performing Network Requests sequentially

Lecture 1: Introduction

Lecture 2: Adding Coroutines to your project

Lecture 3: Coroutine Builders: Launch and RunBlocking

Lecture 4: Main-safety

Lecture 5: Basic error handling with try-catch

Lecture 6: Exercise 1

Lecture 7: Exercise 1: Solution

Lecture 8: Section Recap

Chapter 5: Performing Network Requests concurrently

Lecture 1: Section Introduction

Lecture 2: UseCase description

Lecture 3: Implementing UseCase#3 in a sequential way

Lecture 4: The async coroutine builder

Lecture 5: Implementing UseCase#3 in a concurrent way

Lecture 6: Implementing UseCase#4 in a sequential way

Lecture 7: Exercise 2: Implementing UseCase#4 in a concurrent way

Lecture 8: Exercise 2: Solution

Lecture 9: Section Recap

Chapter 6: Higher-Order Functions

Lecture 1: Implementing a timeout

Lecture 2: Implementing retries

Lecture 3: Extract retry logic into higher order function

Lecture 4: Add exponential backoff to retry

Lecture 5: Exercise 3: Combining retries and timeout

Lecture 6: Exercise 3: Solution

Lecture 7: Section Recap

Chapter 7: Using Room with Coroutines

Lecture 1: Section Introduction

Lecture 2: UseCase description

Lecture 3: UseCase Implementation

Lecture 4: Section Recap

Chapter 8: Background Processing with Coroutines

Lecture 1: Section Introduction

Lecture 2: UseCase explanation

Lecture 3: Implementation running on Main Thread

Lecture 4: Coroutine Context

Lecture 5: Coroutine Dispatchers

Lecture 6: Using withContext for context switching

Lecture 7: Coroutine Scope VS Coroutine Context

Lecture 8: Exercise4: Perform calculation in several Coroutines

Lecture 9: Exercise 4: Solution

Lecture 10: Performance Analysis

Lecture 11: Section Recap

Chapter 9: Structured Concurrency and Coroutine Scopes

Lecture 1: Section Introduction

Lecture 2: The unhappy path

Lecture 3: Structured Concurrency

Lecture 4: Coroutine Scopes

Lecture 5: Building up the Job Hierarchy

Lecture 6: Parents wait for Children

Lecture 7: Cancellation of parent and child jobs

Lecture 8: Job and SupervisorJob

Lecture 9: Unstructured Concurrency

Lecture 10: GlobalScope

Lecture 11: ViewModelScope

Lecture 12: LifecycleScope

Lecture 13: Scoping Functions coroutineScope{} and supervisorScope{}

Lecture 14: Continue Coroutine execution when the user leaves the screen

Lecture 15: Section Recap

Chapter 10: Coroutines Cancellation

Lecture 1: Cancelling Coroutines

Lecture 2: Cooperative Cancellation

Lecture 3: NonCancellable Code

Lecture 4: Making UseCase10 cooperative regarding cancellation

Lecture 5: Section Recap

Chapter 11: Coroutines Exception Handling

Lecture 1: Section Introduction

Lecture 2: Exception Handling with try-catch

Lecture 3: Coroutine Exception Handler

Lecture 4: Try-Catch VS Coroutine Exception Handler

Lecture 5: launch{} VS async{}

Lecture 6: Exception Handling specifics of coroutineScope{}

Lecture 7: Exception Handling specifics of supervisorScope{}

Lecture 8: Implementation of UseCase13 with try-catch

Lecture 9: Implementation of UseCase13 with CoroutineExceptionHandler

Instructors

Lukas Lechner
Freelance Android Developer

Rating Distribution

1 stars: 7 votes

2 stars: 5 votes

3 stars: 59 votes

4 stars: 357 votes

5 stars: 1121 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!