Kickstart Modern Android Development with Jetpack and Kotlin: Enhance your applications by integrating Jetpack and applying modern app architectural concepts

Highly recommended, not only for juniors but also for intermediate level Android developers looking to update their skills. Teaching method is amazing and concepts are explained in a very easy to understand way.

This book told me exactly what needed to do to parse a JSON object to get the png image file. This will help with my project for Udacity Thank you!!

I own 5 books on the Jetpack API and Kotlin, this is the most up to date of them, of course the language is moving fast, and there’s already some dated info in this lengthy tutorial.Also appreciate how it’s wholly compose based, no making fragments to use Navigation here! So if you want to dive deep and see how Compose is supposed to work, this is probably the book for you

Kickstart Modern Android Development with Jetpack and Kotlin is a book that I picked up to improve my skills as an Android developer. I'm a fairly new Android developer, having picked up Android in December 2021 and starting working on professional projects for the platform in February 2022. My Android development journey started with Android Programming - The Big Nerd Ranch Guide, which did a great job at teaching most of the basic things you see when developing Android apps. Working in a professional capacity with the platform, however, I quickly learned about the existence of a lot of nuance to working with the Android platform. In particular, things like dependency injection, navigation, testing, and presentation patterns play a large part in creating a enterprise-level Android application. Luckily, Kickstart Modern Android Development with Jetpack and Kotlin addresses all of these points and more, which can help take you from an Android novice or intermediate, and help improve you into an Android professional.One of the biggest things that comes up when creating an application, be it on desktop, mobile or web, is the idea of presentation patterns. These presentation patterns include fairly common ones like Model-View-Controller (MVC), Model-View-Presenter (MVP), and Model-View-ViewModel (MVVM). This book does a good job at describing the differences between these three common presentation patterns, and teaching you quite a bit about Jetpack ViewModel, which is a library I work with regularly. Going into a deeper dive on these presentation patterns and learning more about Jetpack ViewModel has been very helpful to me, and I'm sure my Android development skills in my own projects and professionally will improve from leveraging the presentation patterns properly.This book also starts by teaching Jetpack Compose, which is the modern UI system for creating Android apps. Jetpack Compose augments the traditional way to develop UI in Android, and helps remove a lot of the guesswork and error-prone development practices that developers have run into in the past. Jetpack Compose is also fairly young so getting resources on the topic has been a bit of a challenge for me. One of the major reasons why I picked up this book to begin with was to learn more about Jetpack Compose, in an effort to improve my personal Android projects. I think that this book does a good job of covering Jetpack Compose, and I feel like I can leverage this in my personal projects in the future.Kickstart Modern Android Development with Jetpack and Kotlin also does a good job of explaining how to consume REST APIs using Retrofit. One of the very, very common tasks you have to do when developing any application is consume an API, so learning more about how to do this properly in Android has been good to learn. I have yet to use an API in my personal applications, but we use APIs quite a lot at work. I don't believe that we use Retrofit as our API client in my work projects, but I feel that knowing more libraries is better than the alternative. I may use this in my personal projects as I start developing more personal apps.One aspect that this book covers is Kotlin Coroutines, which is a somewhat tricky concept, but it's important to get right. Android has a rule that you can't issue API requests from the main application thread, because it would lock up the UI. As a result, you must leverage coroutines to make API calls, which makes coroutines important to learn. This book does a good job of explaining coroutines, but I have already learned coroutines, so I mostly just reviewed through this section.One major point of confusion for me in my work has been working with the navigation componets versus the other ways that you can spawn activities and different UI flows in Android apps. There seems to be a couple differernt ways that you can initialize a class and start up a UI flow. Jetpack Navigation is a pretty commonly-used library, particularly in complex apps with various UI flows, in order to manage the navigation of an application. Going through this section has been a good way to review and learn more about UI navigation. I work with this quite a bit in my work, so this section is one that I appreciate quite a bit.Another major thing that I work with is dependency injection in Android apps. This is a fairly complex topic, so it was very good to have a detailed write-up about dependency injection. I am also familiar with Dagger for dependency injection from my job, but I have been very confused when working with it in the past. I have not seen a lot of good write-ups about Dagger and Hilt for dependency injection in Android, so this is another section that I greatly appreciate and I see myself using moving forward.There's also a good section in the book about testing, particularly unit testing ViewModels. This comes up a lot at my work, so it was nice to go through testing in this book to see another lense on how to write these tests effectively. This book also includes a section on UI testing for the Compose UIs, which is not something I have worked with before. Learning this means that when I write Compose UIs for my apps, I will be able to test them, independent of other UI testing like you might find with Appium or other automated testing solutions.Overall, I think that this book has been a great tool to allow me to learn Android at a deeper level. I have read several different books on the subject this year in order to get comfortable with the platform more quickly, but this book is by far one of the best ones for people hoping to go from novice to advanced with the Android platform fairly quickly.

TL;DR: Recommended for Android devs looking to bring their knowledge up to date with current best practices without reading 100s of pages of documentation. If you learn best by example, this is for you. Just beware some refactor will be needed to build with the latest tooling.As an Android developer with 12 years experience, this has proved a valuable resource in bringing my knowledge of Jetpack and the latest best practices (mostly) up to date."Best practice" in the Android world has come to mean whatever Google decides it does this week. The book's focus on Clean Architecture is refreshing to see.Having built and maintained many apps using the "old ways", I've seen plenty of best practice changes and done many a refactor to bring legacy code up to date. But adoption of MVVM and declarative UI has been the single biggest change, the latter being something I was resistant to until I was confident the tooling had matured to the point that there wasn't going to be the frequent rug-pulling, breaking changes necessitating extensive refactor, that we have seen in the past.As far as Compose is concerned, that time seems to be now.The book is well-written and concise, I would say approachable even for those with limited Android development experience. Devs already familiar with MVVM, coroutines and libraries like Retrofit will find find themsleves skimming and skipping ahead in some sections.The only caution I would add is that some of the information contained within is now out of date (through no fault of the author, things have just moved on in the last 2+ years) and libraries now deprecated. I found myself reading the Compose docs and refactoring the code to Material 3 as I proceeded through the examples, as I wanted to build with a current AS/Gradle/AGP and target API level 34. If you're not prepared to do that, I'd strongly recommend sticking with the tooling recommended by the author. Once you're familiar with the APIs, you can then undertake the refactor necessary to bring things up to date.