As an Android developer, how to master kotlin and coroutine for android?

I would highly recommend NOT studying advanced syntax features, but rather what architecture ideas can be used and what are Android best practices:

https://developer.android.com/topic/architecture

https://developer.android.com/topic/architecture/recommendations

Hands on learning is also great. If you build an app with a networking library connected to a public API that uses Room for a local database you will learn a lot about coroutines. If you use layered architecture like the docs describe you will learn even more and it will not be too easy. There are great Google tutorials that are hands on and walk through the libraries:

https://developer.android.com/courses/pathways/android-coroutines

https://developer.android.com/codelabs/android-room-with-a-view-kotlin

Another idea is instead of researching “Advanced Tutorial for xyz” try searching “Best practices for xyz” and see what resources you find. I did that with coroutines and got some pretty detailed docs:

https://developer.android.com/kotlin/coroutines/coroutines-best-practices

Lots of people publish on Medium their latest experimentations and findings, and if you make sure it’s a reputable author like a Google Developer Expert you can learn a lot there too.

Your goal with any tech stack isn't to use its most complicated syntax or exhaust its feature pool: It's to build quality software for users at as large a scale as possible.

You can't really do this with tutorials and courses: Those are just meant to teach you how to get stuff working. Getting stuff working is just the first step - Once you get to mid-level, these resources aren't very useful anymore. Once you get to senior, your returns with these will drop to pretty much 0.

I'm an Android engineer, and I've been an Android lead for almost 10 years. In 2021, I was making $750k per year doing Android development. I also don't really know what a coroutine is.

Coroutines, like everything else in Kotlin and Android, is just one way of many to build features and get stuff working. This doesn't make it inherently it a "high-level" Android technique or a requirement to be a stellar Android engineer.

If you really want to get better at Android, you should care about these metrics instead:

• Number of users (maximize this) - Go to a company or build a side project that is fast-growing. More users = More complexity = More learning
• Number and average score of ratings (maximize this) - Build good software that covers all edge cases, works across all screen types/API levels, and is smooth.
• Crash rate (minimize this) - Keep it to 1% or lower.
• ANR rate (minimize this) - Learn what to run on main thread and what not to. Understand the lagginess and heaviness of certain operations.
• Binary size (minimize this) - Understand how tools like ProGuard and Redex work. Use them without stripping so much stuff in the release build that it dies.
• Latency (minimize this) - Learn how to reduce layout nesting and optimize for performance on older API levels.

I go extremely in-depth about what it takes to write high-quality code and how to get better at it here: "How to Learn/Practice Clean Code, particularly by oneself?"

I also highly recommend these if you haven't watch them already:

• [Masterclass] How To Write Better Code Faster As A Software Engineer
• [Masterclass] How To Stop Writing Messy Code As A Software Engineer
• [Masterclass] How To Become A Debugging Master And Fix Issues Faster

Just like any topic: use them. Then realize all these are just ways of writing things.

The way to improve isn't by writing code but realizing how they work, why they work, and why they're used, and how things can be done better.

You should not be focusing on language and features. You should be focusing on understanding what you're writing, why, and most importantly, how to be as efficient as possible at figuring out what you need to write.

That's the difference between coding and engineering.