Kotlin Coroutines for Android Masterclass

Kotlin Coroutines for Android Masterclass, available at $64.99, has an average rating of 4.61, with 84 lectures, based on 1335 reviews, and has 6796 subscribers.

You will learn about Understand the importance of concurrency in Android applications Use Kotlin Coroutines to implement simple and complex concurrent flows Handle cancellations and errors inside Coroutines Write unit tests for Coroutines-based code Find out the most common Coroutines-related issues and pitfalls Learn what Structured Concurrency is and how it helps you This course is ideal for individuals who are Professional Android developers It is particularly useful for Professional Android developers.

Enroll now: Kotlin Coroutines for Android Masterclass

Summary

Title: Kotlin Coroutines for Android Masterclass

Price: $64.99

Average Rating: 4.61

Number of Lectures: 84

Number of Published Lectures: 84

Number of Curriculum Items: 84

Number of Published Curriculum Objects: 84

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will Learn

Understand the importance of concurrency in Android applications
Use Kotlin Coroutines to implement simple and complex concurrent flows
Handle cancellations and errors inside Coroutines
Write unit tests for Coroutines-based code
Find out the most common Coroutines-related issues and pitfalls
Learn what Structured Concurrency is and how it helps you

Who Should Attend

Professional Android developers

Target Audiences

Professional Android developers

This course is your complete guide into the world of Kotlin Coroutines in Android. By the end of this course, you’ll know how to use Coroutines to write reliable, maintainable and responsive Android applications.

The philosophy of this course is “learn by coding”, so you’ll be asked to solve a series of carefully designed, hands-on exercises. These exercises are built into a tutorial Android application, so they accurately reflect the “real world” use cases that you’ll encounter in real Android apps.

Even though the main goal of this course is to give you practical skills, it also covers the theory behind Kotlin Coroutines framework at a more conceptual level. In particular, you’re going to learn what Structured Concurrency is, what benefits it provides and how Coroutines support this powerful paradigm.

These aspects of Kotlin Coroutines framework are covered in this course:

Coroutines as concurrency framework
Suspending vs blocking functions
Coroutine Scope, Context and Jobs hierarchy
Coroutines cancellation
Exceptions handling inside Coroutines
Structured Concurrency
Unit testing with Coroutines
and more…

In this course we go beyond the functionality of Kotlin Coroutines framework itself and also discuss important design considerations that will help you write clean and maintainable code.

Knowledge of Kotlin Coroutines is an essential skill for Android developers. After completing this course, you’ll be able to use Coroutines in real-world Android projects, and you’ll be ready to answer even the trickiest questions about this framework in job interviews.

So, if you’re serious about Android development and you want to master Kotlin Coroutines, this course is perfect for you!

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: Tutorial Application

Lecture 3: Udemy Course Review System

Chapter 2: Coroutines Intuition

Lecture 1: UI Thread Blocking

Lecture 2: Concurrency

Lecture 3: Background Threads

Lecture 4: Coroutines Basics

Lecture 5: Coroutines Basics Nuances

Lecture 6: Exercise 1

Lecture 7: Exercise 1 Solution

Lecture 8: Coroutines Cancellation Basics

Lecture 9: Exercise 2

Lecture 10: Exercise 2 Solution

Lecture 11: Concurrent Coroutines

Lecture 12: Suspension vs Blocking

Lecture 13: Coroutine Scope's Children Cancellation

Lecture 14: Exercise 3

Lecture 15: Exercise 3 Solution

Lecture 16: Coroutines Intuition Summary

Chapter 3: Coroutine Scope Cancellation

Lecture 1: Coroutine Scope Cancellation

Lecture 2: Scope Cancellation vs Scope's Children Cancellation

Lecture 3: Coroutine Scope Inside ViewModel

Lecture 4: Coroutine Scope From Kotlin Extensions for ViewModel

Lecture 5: Coroutine Scope Cancellation Summary

Chapter 4: Structured Concurrency

Lecture 1: Structured Concurrency Intro

Lecture 2: Fibonacci Computation

Lecture 3: Concurrent Fibonacci Computation

Lecture 4: Concurrent Fibonacci Computation with Callback on UI Thread

Lecture 5: Concurrent Fibonacci Computation Using ThreadPoster Library

Lecture 6: Structured Concurrency

Lecture 7: Concurrent Fibonacci Computation Using Coroutines (Callback)

Lecture 8: Concurrent Fibonacci Computation Using Coroutines (Suspending)

Lecture 9: Exercise 4

Lecture 10: Exercise 4 Solution

Lecture 11: Structured Concurrency Summary

Chapter 5: Design with Coroutines

Lecture 1: The Main Rule of Concurrency in Android

Lecture 2: Encapsulating Concurrency in Use Cases

Lecture 3: Exercise 5

Lecture 4: Exercise 5 Solution

Lecture 5: Design with Coroutines Summary

Chapter 6: Coroutine Dispatchers

Lecture 1: Coroutine Dispatchers

Lecture 2: Main Dispatcher

Lecture 3: Background Dispatchers

Lecture 4: Unconfined Dispatcher

Lecture 5: The Best Dispatching Strategy for Android Applications

Chapter 7: Coroutines Cancellation

Lecture 1: Coroutines Cancellation Intro

Lecture 2: Cooperative Cancellation

Lecture 3: The Importance of Cancellation Exception

Lecture 4: Fragment Lifecycle Bug on Coroutine Cancellation

Lecture 5: Exercise 6

Lecture 6: Exercise 6 Solution

Lecture 7: NonCancellable

Lecture 8: Coroutines Cancellation Summary

Chapter 8: Coroutines Mechanics

Lecture 1: Main Coroutines Building Blocks

Lecture 2: Coroutines Mechanics Part 1: CoroutineScope and CoroutineContext

Lecture 3: Coroutines Mechanics Part 2: CoroutineContext Elements

Lecture 4: Coroutines Mechanics Part 3: withContext Function

Lecture 5: Coroutines Mechanics Part 4: Jobs Hierarchy

Lecture 6: Coroutines Mechanics Part 5: Cancellation Propagation

Lecture 7: Coroutines Mechanics Part 6: NonCancellable vs Job()

Lecture 8: Exercise 7

Lecture 9: Exercise 7 Solution

Lecture 10: Exercise 7 Solution Amendment

Lecture 11: Coroutines Mechanics Summary

Chapter 9: Parallel Decomposition

Lecture 1: Parallel Decomposition

Lecture 2: Exercise 8

Lecture 3: Exercise 8 Solution

Lecture 4: Shared Mutable State

Lecture 5: Async Coroutine Builder

Lecture 6: Exercise 9

Lecture 7: Exercise 9 Solution

Lecture 8: Parallel Decomposition Summary

Chapter 10: Exceptions Handling

Lecture 1: Exceptions Handling Intro

Lecture 2: Uncaught Exception in a Coroutine

Lecture 3: CoroutineExceptionHandler

Lecture 4: Cancellation Chain on Uncaught Exception

Lecture 5: SupervisorJob

Lecture 6: Exercise 10

Lecture 7: Exercise 10 Solution

Lecture 8: Uncaught Exception in Async Coroutine

Lecture 9: The Best Way to Handle Exceptions in Coroutines

Lecture 10: Exceptions Handling Summary

Chapter 11: Course Summary

Lecture 1: Course Summary

Lecture 2: Bonus Lecture

Instructors

Vasiliy Zukanov
Professional Android developer, Blogger, Educator

Rating Distribution

1 stars: 6 votes
2 stars: 10 votes
3 stars: 66 votes
4 stars: 348 votes
5 stars: 905 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!

Menu