The builder track

This track exists because Android internals are easier to believe when you have made them happen. Each project is small, each one targets a specific mechanism, and each one links back to the concept page that explains what you are seeing.

The five beginner projects (B01–B05) are real Gradle projects in this repository, and all five compile: each produces a debug APK on AGP 9.4.1, Gradle 9.8.2, JDK 21 and compileSdk 36. The nerd guides go further and modify the platform itself; they are marked as not tested in this run, because they need an AOSP checkout and a great deal of disk.

Build one yourself

cd builder/b01-hello-lifecycle
./gradlew assembleDebug

You need a JDK 17+ and an Android SDK with platform 36 installed. The project uses the Gradle wrapper, so you do not need Gradle itself.

TL;DR#

Three foundations (B01–B03) cover lifecycle, intents and storage.
Two applied builds (B04, B05) cover permissions and performance, with a measurable before and after.
Six internals builds (I01–I06) cover AIDL, content providers, custom views, WorkManager, foreground services and the Looper.
Three system builds (I07, I08 and the nerd guides) touch the launcher, native code and the platform.
Every project is small enough to finish and links to the page that explains why it works.

Mental model#

Think of a flight simulator.

The concept pages are the ground school: aerodynamics, instruments, procedures. The builder track is the simulator: you fly, and the instruments respond. You do not learn to fly by reading about lift, and you do not learn Android by reading about Binder — but you cannot fly without the ground school either.

The projects are the simulator sessions. Each one isolates a single instrument so you can see what it does when you move a control.

Where the analogy breaks#

A simulator is a faithful copy of one aircraft. The projects are deliberately simplified: each one isolates a mechanism and ignores the rest of the app architecture. A production app combines all of them, and the simplification is the point — you learn one thing per project.

The big picture#

The track has a shape: foundations, then applied work, then internals, then the platform.

Project	You build	The mechanism it exposes
B01	An activity that logs its lifecycle	The activity lifecycle and configuration changes
B02	An app that resolves intents	Intent resolution and the package manager
B03	A notes app with a database	Room, the data layer, and process death
B04	A permission demo	Grants, AppOps and target levels
B05	A list, then a fixed list	Frame time, recycling and baseline profiles
I01	A Binder service	AIDL, parcels and cross-process calls
I02	A provider	ContentProvider, URIs and permissions
I03	A drawn gauge	Measure, layout, draw and invalidation
I04	A sync job	WorkManager constraints and retries
I05	A music service	Foreground services and notification channels
I06	A message loop	Looper, Handler and the message queue
I07	A tiny launcher	The home category and the app model
I08	A native call	JNI and the NDK

Loading diagram…

Text description of this diagram

The seven-layer Android stack with each block labelled. The builder projects attach to specific blocks: B01 and B02 to Activity and Intent in the apps layer, I01 to the Binder boundary between the framework and apps, I02 to ContentProvider, I03 to the native graphics path through SurfaceFlinger, I04 and I05 to the framework services that schedule background work, I06 to the runtime and Looper, I08 to JNI and the native layer, and the nerd guides to init, the HAL, SystemUI and the kernel. Use it to see which layer each project touches before you start.

Deep dive#

What you need#

For the app projects:

A current Android Studio, which brings the Android SDK and an emulator.
A device or emulator running a recent API level.
The source for the current stable AndroidX libraries, resolved by Gradle.

The projects use Kotlin, Jetpack Compose where UI is involved, and Gradle with a version catalog. They are deliberately small: one module, a handful of classes, no dependency injection framework except where the point is to show one.¹

For the nerd guides:

A Linux host with a large disk and a lot of RAM.
An AOSP checkout, following N01.
Patience: a full build is hours.

The house style#

Every project follows the same shape, so you can skim one and know where to look:

What you are building — one paragraph and a sketch of the screen.
Steps — five to ten, each with a command or a file to create.
Verification — how to see that it works.
What you learned — the mechanism, with links to the concept pages.
Extend it — three ways to go further.

The code is Kotlin unless history matters. The manifest is minimal. The UI is Compose unless the point is the View system.

How each project maps to a concept#

The mapping is the reason the track exists:

B01 makes the lifecycle real: you see onCreate, onStart, onResume in logcat and you see what a rotation does.
B02 makes resolution real: you send an implicit intent and watch which app answers.
I01 makes Binder real: you write the interface, the service and the client, and you see the generated code.
I06 makes the Looper real: you post messages and watch them drain.

A project you have built is a reference you can return to. That is the difference between reading about MessageQueue and having watched one drain.

How it evolved#

The track targets modern Android: Compose, Kotlin, AndroidX, and a target level that reflects current behaviour changes. The platform has changed enough that older tutorial patterns are actively misleading: AsyncTask, unbound background services and unscoped storage are all deprecated or restricted.

Interface changes5 releases

API	Version	What changed
29	10	System-wide dark theme
30	11	Conversation notifications and bubbles Media controls in Quick Settings
31	12	Material You dynamic colour
33	13 Tiramisu	Themed app icons Runtime notification permission
36	16 Baklava	Material 3 Expressive Live Updates notifications

Under the hood#

Activity.javathe lifecycle that B01 makes visible
Intent.javathe intent model that B02 explores
Looper.javathe loop that I06 rebuilds by hand

Curiosity corner#

The projects are deliberately small. A 300-line app can demonstrate a mechanism that a production app buries under architecture.
The nerd guides are the only part of the site that modifies the platform, and they are marked as unverified for exactly that reason.
A built project is a better reference than a read page. The code you wrote is searchable, runnable and yours.

Try it#

Toolchain check

$ adb devices -l
adb shell getprop ro.build.version.sdk
ls $ANDROID_HOME

Example output

Illustrative output — your SDK and emulator will differ.

Start here#

B01 — Hello lifecycle is the smallest project that makes a platform mechanism visible.