CF

Kotlin Coroutines for Android Masterclass

11h 57m 28s
English
Paid

Kotlin Coroutines for Android Masterclass is a 82-lesson 11 hours 57 minutes self-paced course by Udemy. This course is your complete guide into the world of Kotlin Coroutines in Android.

Course facts

Lessons
82
Duration
11 hours 57 minutes
Level
All levels
Language
English
Updated
Instructor
Udemy
Price
Premium

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

The philosophy of this course is "learn by coding", so you're going to master Coroutines by solving a series of carefully designed, hands-on exercises. These exercises are built into a tutorial Android application to make them as similar to the "real world" as possible. Therefore, you'll gain practical experience with Coroutines in various typical scenarios that you'll surely encounter in your own Android apps.

All aspects of 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...

Even though the main goal of this course is to give you practical skills, it also covers all the theory required to understand 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 implement this advanced paradigm.

We will go beyond the functionality of Coroutines framework itself and discuss important design considerations that you need to be aware of to write code that both works right now, and will also be maintainable in the long term.

Given the ever-increasing adoption of Kotlin, it's evident that Coroutines are the future of concurrency in Android world. Therefore, knowledge of this framework is going to become a mandatory skill for Android developers going forward. After completing this course, you'll be able to write reliable and maintainable concurrent code in Android projects using Coroutines framework, and you'll be able to answer even the most tricky questions about this framework at job interviews.

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

Who teaches Kotlin Coroutines for Android Masterclass? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in Kotlin Coroutines for Android Masterclass?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 82 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (82)
#Lesson TitleDurationAccess
1
Introduction Demo
03:50
2
Tutorial Application
02:51
3
Udemy Course Review System
01:20
4
UI Thread Blocking
09:04
5
Concurrency
07:08
6
Background Threads
10:48
7
Coroutines Basics
26:47
8
Coroutines Basics Nuances
05:33
9
Exercise 1
08:48
10
Exercise 1 Solution
07:47
11
Coroutines Cancellation Basics
15:19
12
Exercise 2
05:45
13
Exercise 2 Solution
05:20
14
Concurrent Coroutines
18:23
15
Suspension vs Blocking
07:54
16
Coroutine Scope's Children Cancellation
04:59
17
Exercise 3
04:02
18
Exercise 3 Solution
07:29
19
Coroutines Intuition Summary
09:11
20
Coroutine Scope Cancellation
01:12
21
Scope Cancellation vs Scope's Children Cancellation
08:01
22
Coroutine Scope Inside ViewModel
14:34
23
Coroutine Scope From Kotlin Extensions for ViewModel
03:56
24
Coroutine Scope Cancellation Summary
01:47
25
Structured Concurrency Intro
01:28
26
Fibonacci Computation
05:09
27
Concurrent Fibonacci Computation
15:34
28
Concurrent Fibonacci Computation with Callback on UI Thread
08:20
29
Concurrent Fibonacci Computation Using ThreadPoster Library
10:18
30
Structured Concurrency
18:15
31
Concurrent Fibonacci Computation Using Coroutines (Callback)
24:53
32
Concurrent Fibonacci Computation Using Coroutines (Suspending)
17:30
33
Exercise 4
06:48
34
Exercise 4 Solution
06:29
35
Structured Concurrency Summary
07:18
36
The Main Rule of Concurrency in Android
05:22
37
Encapsulating Concurrency in Use Cases
10:28
38
Exercise 5
02:21
39
Exercise 5 Solution
05:25
40
Design with Coroutines Summary
04:24
41
Coroutine Dispatchers
01:50
42
Main Dispatcher
11:10
43
Background Dispatchers
06:02
44
Unconfined Dispatcher
07:36
45
The Best Dispatching Strategy for Android Applications
13:49
46
Coroutines Cancellation Intro
01:46
47
Cooperative Cancellation
19:22
48
The Importance of Cancellation Exception
17:40
49
Exercise 6
02:42
50
Exercise 6 Solution
06:06
51
NonCancellable
12:14
52
Coroutines Cancellation Summary
04:31
53
Main Coroutines Building Blocks
03:00
54
Coroutines Mechanics Part 1: CoroutineScope and CoroutineContext
17:29
55
Coroutines Mechanics Part 2: CoroutineContext Elements
09:04
56
Coroutines Mechanics Part 3: withContext Function
08:41
57
Coroutines Mechanics Part 4: Jobs Hierarchy
10:21
58
Coroutines Mechanics Part 5: Cancellation Propagation
13:34
59
Coroutines Mechanics Part 6: NonCancellable vs Job()
13:15
60
Exercise 7
05:25
61
Exercise 7 Solution
22:52
62
Exercise 7 Solution Amendment
03:35
63
Coroutines Mechanics Summary
10:45
64
Parallel Decomposition
03:11
65
Exercise 8
11:45
66
Exercise 8 Solution
11:24
67
Shared Mutable State
15:52
68
Async Coroutine Builder
19:03
69
Exercise 9
02:48
70
Exercise 9 Solution
04:45
71
Parallel Decomposition Summary
04:40
72
Exceptions Handling Intro
02:21
73
Uncaught Exception in a Coroutine
10:50
74
CoroutineExceptionHandler
07:26
75
Cancellation Chain on Uncaught Exception
10:09
76
SupervisorJob
05:49
77
Exercise 10
03:08
78
Exercise 10 Solution
09:23
79
Uncaught Exception in Async Coroutine
10:07
80
The Best Way to Handle Exceptions in Coroutines
10:16
81
Exceptions Handling Summary
05:34
82
Course Summary
04:18
Unlock unlimited learning

Get instant access to all 81 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Kotlin Coroutines for Android Masterclass?

Frequently asked questions

What are the prerequisites for enrolling in this course?
Prospective students should have a basic understanding of Kotlin and Android development before enrolling in this course. Familiarity with Android app architecture and experience with threading or concurrency concepts will be beneficial, as the course delves into advanced topics like coroutine scope and concurrency.
What will I build or achieve by the end of this course?
By the end of this course, students will be able to confidently use Kotlin Coroutines to build reliable, maintainable, and responsive Android applications. The course includes practical exercises such as implementing concurrent Fibonacci computations and managing coroutine scope within ViewModels.
Who is the target audience for this course?
This course is designed for Android developers who are looking to deepen their understanding of concurrency and learn how to effectively implement Kotlin Coroutines in their applications. It's ideal for those who want to improve app performance and responsiveness through modern concurrency techniques.
How does this course compare in depth and scope to other courses on Kotlin and Android concurrency?
This course provides a comprehensive guide to Kotlin Coroutines specifically for Android applications, covering topics such as coroutine cancellation, structured concurrency, and various dispatcher strategies. It goes beyond basic coroutine usage to explore nuances and practical applications in Android development, which may not be covered in general Kotlin courses.
What specific tools or libraries are covered in this course?
The course covers the ThreadPoster library for handling concurrent computations with callbacks on the UI thread. It also explores Kotlin extensions for managing coroutine scope within ViewModels, providing students with practical tools to enhance their Android applications.
What topics are not covered in this course?
This course focuses specifically on Kotlin Coroutines in the context of Android development. It does not cover general Android development techniques, other concurrency models, or programming languages outside of Kotlin. Students looking for a broader overview of Android architecture may need to supplement their learning with additional resources.
What is the expected time commitment to complete this course?
The course consists of 82 lessons, with a runtime yet to be specified. Given the depth of the material and the inclusion of practical exercises, students should be prepared to spend several weeks working through the lessons and exercises, depending on their prior experience with Kotlin and Android development.