Kotlin Coroutines for Android Masterclass

Learn Kotlin Coroutines in depth and practice advanced Coroutines use cases in Android application
Kotlin Coroutines for Android Masterclass
File Size :
5.19 GB
Total length :
12h 3m

Category

Instructor

Vasiliy Zukanov

Language

Last update

2/2023

Ratings

4.6/5

Kotlin Coroutines for Android Masterclass

What you’ll learn

Use Kotlin Coroutines to implement the most common flows in Android applications
Learn the best practices of software design with Coroutines
Understand Coroutines cancellation and error handling in details
Write unit tests using Coroutines
Debug the most common issues in Coroutines-based code
Grasp the bigger picture of Structured Concurrency

Kotlin Coroutines for Android Masterclass

Requirements

Basic experience with Android and Kotlin

Description

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 frameworkSuspending vs blocking functionsCoroutine scope, context and jobs hierarchyCoroutines cancellationExceptions handling inside CoroutinesStructured ConcurrencyUnit testing with Coroutinesand 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!

Overview

Section 1: Introduction

Lecture 1 Introduction

Lecture 2 Tutorial Application

Lecture 3 Udemy Course Review System

Section 2: Coroutines Intuition

Lecture 4 UI Thread Blocking

Lecture 5 Concurrency

Lecture 6 Background Threads

Lecture 7 Coroutines Basics

Lecture 8 Coroutines Basics Nuances

Lecture 9 Exercise 1

Lecture 10 Exercise 1 Solution

Lecture 11 Coroutines Cancellation Basics

Lecture 12 Exercise 2

Lecture 13 Exercise 2 Solution

Lecture 14 Concurrent Coroutines

Lecture 15 Suspension vs Blocking

Lecture 16 Coroutine Scope’s Children Cancellation

Lecture 17 Exercise 3

Lecture 18 Exercise 3 Solution

Lecture 19 Coroutines Intuition Summary

Section 3: Coroutine Scope Cancellation

Lecture 20 Coroutine Scope Cancellation

Lecture 21 Scope Cancellation vs Scope’s Children Cancellation

Lecture 22 Coroutine Scope Inside ViewModel

Lecture 23 Coroutine Scope From Kotlin Extensions for ViewModel

Lecture 24 Coroutine Scope Cancellation Summary

Section 4: Structured Concurrency

Lecture 25 Structured Concurrency Intro

Lecture 26 Fibonacci Computation

Lecture 27 Concurrent Fibonacci Computation

Lecture 28 Concurrent Fibonacci Computation with Callback on UI Thread

Lecture 29 Concurrent Fibonacci Computation Using ThreadPoster Library

Lecture 30 Structured Concurrency

Lecture 31 Concurrent Fibonacci Computation Using Coroutines (Callback)

Lecture 32 Concurrent Fibonacci Computation Using Coroutines (Suspending)

Lecture 33 Exercise 4

Lecture 34 Exercise 4 Solution

Lecture 35 Structured Concurrency Summary

Section 5: Design with Coroutines

Lecture 36 The Main Rule of Concurrency in Android

Lecture 37 Encapsulating Concurrency in Use Cases

Lecture 38 Exercise 5

Lecture 39 Exercise 5 Solution

Lecture 40 Design with Coroutines Summary

Section 6: Coroutine Dispatchers

Lecture 41 Coroutine Dispatchers

Lecture 42 Main Dispatcher

Lecture 43 Background Dispatchers

Lecture 44 Unconfined Dispatcher

Lecture 45 The Best Dispatching Strategy for Android Applications

Section 7: Coroutines Cancellation

Lecture 46 Coroutines Cancellation Intro

Lecture 47 Cooperative Cancellation

Lecture 48 The Importance of Cancellation Exception

Lecture 49 Fragment Lifecycle Bug on Coroutine Cancellation

Lecture 50 Exercise 6

Lecture 51 Exercise 6 Solution

Lecture 52 NonCancellable

Lecture 53 Coroutines Cancellation Summary

Section 8: Coroutines Mechanics

Lecture 54 Main Coroutines Building Blocks

Lecture 55 Coroutines Mechanics Part 1: CoroutineScope and CoroutineContext

Lecture 56 Coroutines Mechanics Part 2: CoroutineContext Elements

Lecture 57 Coroutines Mechanics Part 3: withContext Function

Lecture 58 Coroutines Mechanics Part 4: Jobs Hierarchy

Lecture 59 Coroutines Mechanics Part 5: Cancellation Propagation

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

Lecture 61 Exercise 7

Lecture 62 Exercise 7 Solution

Lecture 63 Exercise 7 Solution Amendment

Lecture 64 Coroutines Mechanics Summary

Section 9: Parallel Decomposition

Lecture 65 Parallel Decomposition

Lecture 66 Exercise 8

Lecture 67 Exercise 8 Solution

Lecture 68 Shared Mutable State

Lecture 69 Async Coroutine Builder

Lecture 70 Exercise 9

Lecture 71 Exercise 9 Solution

Lecture 72 Parallel Decomposition Summary

Section 10: Exceptions Handling

Lecture 73 Exceptions Handling Intro

Lecture 74 Uncaught Exception in a Coroutine

Lecture 75 CoroutineExceptionHandler

Lecture 76 Cancellation Chain on Uncaught Exception

Lecture 77 SupervisorJob

Lecture 78 Exercise 10

Lecture 79 Exercise 10 Solution

Lecture 80 Uncaught Exception in Async Coroutine

Lecture 81 The Best Way to Handle Exceptions in Coroutines

Lecture 82 Exceptions Handling Summary

Section 11: Course Summary

Lecture 83 Course Summary

Professional Android developers

Course Information:

Udemy | English | 12h 3m | 5.19 GB
Created by: Vasiliy Zukanov

You Can See More Courses in the Developer >> Greetings from CourseDown.com

New Courses

Scroll to Top