If I Were Starting Over, Here is How I Would Do It

Learning Android from scratch is no easy feat.

There is rarely a straightforward path that covers nearly every topic you'll need to cover to become competent in it. I've been giving this idea considerable thought over the past few months.

I've distilled the entirety of what it took for me to become an Android expert into 25 unique concepts spanning two generations of development patterns.

Today, I'm going to share that list with you.

The Modern Age

The first generation is essentially characterized by Jetpack Compose, Android's newest declarative UI framework.

With this change in how UIs are built and the practices that follow, Google ushered in a new era of Android development.

We'll start with this.

1. Startup

Sometimes, the best way to start is to jump into a cold pool and get it over with. The same goes for beginning this journey.

I like to take this opportunity to create a new, blank project and customize it to the point where I have a blank screen with most of my essential tools ready to go, such as:

• DI
• Routing
• App icon
• Brand colors and typography
• Unit testing framework in place
• Cleaning up the irrelevant parts

I'll dive into these more later, but the essentials are already out of the way.

Adopting this firehose approach gives an excellent idea of what's to come later in our journey.

2. Planning

Perhaps it seems strange to start work only to pause and plan, but we only have a blank slate right now.

Before diving into how to build an app, you need to understand Google Play's policies and what they expect from you.

Additionally, this presents an excellent opportunity to explore how you can generate interest in your app. There's nothing worse than spending time building an app, only to find that no one cares.

3. Kotlin

You won't get very far without knowing how to write code in Android's first-class programming language, Kotlin.

If you've programmed before, this process will likely be straightforward. The only parts I would recommend covering are the concepts that are unique to Kotlin or less common in other programming languages.

For instance:

• DSLs
• Coroutines
• Null safety
• Extension functions
• Data and sealed classes
• Functional programming

Even if you only cover a fraction of those ideas, you'll be well on your way.

4. Architecture

The planning section (#2) covered the practical, big picture of what you'll need to do to build a successful app.

This section outlines the steps you will take to achieve that.

In particular, I divide this into two major sections: a presentation layer with an MVVM architecture and a business layer with the Clean Architecture.

Each of these two parts serves a very well-defined purpose that is important to distinguish and organize in a way that can grow with your app's codebase.

5. Jetpack Compose

The new darling of the Android world.

There is a great deal to cover with this topic, but it is an apparent first step toward getting content on-screen.

Here, you would learn the basics of layouts, IDE previews, state management, and debugging.

6. Material Design

Jetpack Compose assumes you are using the Material Design language by default.

Now that you know how to lay out a UI, this step teaches you how to make it beautiful, easy on the eyes, and feel uniquely like your app.

7. Networking

This is perhaps the most essential part of many applications' business layer. Without the internet, most apps would be useless.

Here, it would be fair game to cover how to make effective network calls, handling errors gracefully, using offline mode, and maintaining a user's session.

8. Gradle

Gradle is the build system of choice for Android.

While it is easy to use it for your most basic needs, understanding how it works at a deeper level is extremely important to clear up future confusion and firmly establish what you can expect from it as your usage of this tool grows.

9. Firebase

This is Google's first-class platform-as-a-service for both iOS and Android apps.

Nearly 100% of the apps on the Google Play Store, as well as many on the App Store, use Firebase.

It's such a vast topic to cover that Google has its own certification for those who use it regularly. However, starting with basics such as Analytics and Firebase Cloud Messaging for push notifications is a great place to start.

10. Storage

Regarding your business layer, networking and storage go hand in hand, like bread and butter. You'll need both.

This is a great place to learn about key-value storage, databases, encrypted storage, caching, and Android's rules regarding file access.

11. Manifest

The manifest file is Android's way of reading your app to determine its capabilities.

In short, this is where the magic happens.

From here, you'll unlock the ability to request permissions to things like location services, app shortcuts, and deep linking.

Doing this properly is extremely important, so you can ensure a graceful way of handling devices that don't offer certain capabilities.

12. API Levels

With each new iteration of Android comes new features and new challenges.

Every once in a while, it is good to look back at older versions of Android and see how the developer requirements have changed, and to look ahead so you can prepare for the future.

Google usually announces significant changes to Android's requirements 1 to 2 years before they are enforced.

13. Services

Services are like magic on Android.

They enable you to run your application in the background, allowing you to perform various tasks, such as playing music and capturing push notifications. All of this can happen without the user needing to open up your app.

In most cases, services are like building a conventional app, but without a UI and a few special rules.

14. R8

Whenever an app goes to production, you'll likely want to protect your intellectual property.

R8 is Android's code ofcuscator and shrinker. It'll make your decompiled code much more difficult to read and can ensure that your app binary does not include code or resources that you never use.

15. Accessibility

UIs should be both useful and beautiful.

Learning how to build accessible UIs ensures that your app can clearly explain each screen to the OS, allowing it to navigate, interact with, and describe it to a user who needs to use Android's accessibility tools.

16. DI & Dagger Hilt

DI is excellent for ensuring that you don't misuse dependencies, and, as we'll see later, for automated testing.

Tools such as Dagger Hilt are relatively easy to get started with and cover most of your dependency management needs with relative ease.

17. Unit Testing

Unit testing is essentially a rinse-and-repeat process.

However, having the proper tools, such as Kotest for testing and asserting, and MockK for mocking, can make your testing experience much smoother.

Couple that with taking the time to properly set up these tools, and you can eliminate much of the boilerplate that would typically be written with each test.

18. Instrumentation & Automated Tests

These kinds of tests are often regarded as difficult and easy to neglect.

However, with a proper setup from your DI tooling and a bit of knowledge on state management and proper ways to divide up your tests, you can add considerable value to your testing suite with automated tests.

19. Snapshots

Sometimes, unit tests and automated tests just aren't enough. You need to know what your UI looks like.

Snapshot tests are straightforward to capture with Jetpack Compose and serve as the last resort whenever you need to verify that your app is working correctly.

20. Publication

Finally, we get to publication and the delivery of your hard work to Google Play.

Most of the work is already done. From here, you'll need to know how to package, sign, and upload your binary. From there, it's just a matter of playing Google's game to get your app listed.

The Legacy Age

For most modern applications, you can stop at step 20. However, if you work on a project that has an older codebase, rounding off your knowledge with some of the legacy tooling would be to your advantage.

This era is largely characterized by UIs built with XML code.

21. XML Views

This is the UI framework that is still alive and well, that Jetpack Compose is trying to replace.

Since Views are so fundamentally different from Compose, this is an opportunity to explore how to build a layout in XML, theme it, push data and pull events from it, and the lifecycle paradigm.

22. Modernizing Views

Going from XML Views to Jetpack Compose is no easy feat and is often done in stages.

Effectively, this process works like the layers of an onion, where smaller screens and components are converted to Compose, and each layer is progressively transformed from the inside out until the top-level of the app is migrated.

23. RxJava

RxJava was initially developed by Netflix as a framework for reactive programming.

While Kotlin's Coroutines have largely replaced the need for this framework, many older apps still rely on it as their primary driver for threading and concurrency. It is helpful to understand the basics of how it works.

24. Espresso

If your app is built with XML Views and has automated tests, then it likely uses Google's first-party Espresso testing framework.

You'll find certain aspects of this library are similar to Compose's instrumentation framework, but different enough to learn separately.

25. Paparazzi

Like RxJava, Paparazzi is another third-party library that took the Android community by storm. It is a UI snapshotting library.

While technically useful for both Views and Compose, most of its historical usage centers around Views. Google has its own modern snapshotting library for Compose.

If your older app has snapshot tests, there is a good chance it uses Paparazzi.

And that's it.

The 25 topics to Android mastery, all in one place.

These are the topics I discuss in detail in the AndroidX Masterclass, which opens its next cohort on November 17th. 

Next time, we'll talk about converting legacy XML Views into modern Jetpack Compose.

That's all for this time,
Oliver from AndroidX.