How Android Works: From Code to App

Learning goals

The text in your editor and the app on your phone are connected by a build pipeline. Follow one small app through that pipeline, then see how Android turns its installed code into a running screen.

• Separate the jobs of Android Studio, Gradle, the compiler, and the Android Runtime.
• Trace Kotlin source, resources, and the manifest into a signed application.
• Explain which artifact a device installs and how an Activity displays Compose UI.

Watch code become an app

Press Play to follow the journey. Pause at a stage, inspect its input and output, or move one step at a time. The diagram is a teaching model: a real build has many dependent tasks and can reuse cached results.

Text("Hello, Android!")

Editor, compiler & build system

Android Studio is the development environment: its editor helps you write code, its debugger helps inspect a running app, and its device tools let you test. Pressing Run asks the build system to prepare an application and then deploy it to the selected device.

Gradle can also run from a terminal without opening the IDE. That is why the same project can be built on your laptop or a build server. See the Android build guide for the underlying configuration.

Inside the build

Start with three inputs: Kotlin files contain behavior, res/ holds resources such as strings and icons, and AndroidManifest.xml declares app components and other platform information. Libraries contribute code and may contribute resources and manifest entries too.

The Kotlin compiler produces JVM bytecode. The Android build then needs DEX, the managed bytecode format used on Android. D8handles this conversion in a typical debug build. When release optimization is enabled, R8also shrinks and optimizes code while producing DEX output. A release build does not automatically mean every optimization is enabled.

Alongside code processing, AAPT2 compiles and links Android resources. The build merges manifest information and packages the required outputs. These are related task paths; resources do not pass through the Kotlin compiler as Kotlin source.

APK, AAB & installation

Debug builds are signed with a development key so you can install and test them. Distribution uses a deliberate release signing setup. With Google Play App Signing, an upload key signs the uploaded bundle and the app signing key signs the APKs delivered to users. See the app signing guide and App Bundle guide for these delivery details.

What happens on the device

After installation, tapping a launcher icon asks Android to open the declared launcher Activity. Android starts the app process if needed and creates that Activity. ART executes managed DEX code, using interpretation and compiled code as appropriate; your phone is not opening the original Kotlin file.

// Keep the package declaration generated for your project.
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                Text(text = "Hello from my Android app!")
            }
        }
    }
}

Android calls onCreate. The Activity calls setContent to host Compose, and composable functions describe the interface. Compose manages composition, layout, and drawing as needed. Later state changes can update the UI without rebuilding or reinstalling the application.

Follow your own build

1. Open your Compose project. Find MainActivity.kt, AndroidManifest.xml, and res/.
2. Change the greeting to a phrase you will recognize, then run the app on an emulator.
3. Inspect the Build output. Identify a Kotlin compilation task and Android packaging tasks; exact task names vary by plugin and variant.
4. Build a debug APK and inspect it with Android Studio's APK Analyzer. Look for DEX files and the packaged manifest.
5. Explain the journey aloud: source inputs → build tasks → signed APK → installation → Activity → visible UI.

Quick check & references

Continue with the Android build guide, APK Analyzer documentation, and Android Runtime overview. In the callback lesson, follow the framework calls that bring an Activity to life.