Kotlin for Android

What you'll learn

Kotlin's rise is inseparable from Android. Google made it the preferred language for Android in 2017 and "Kotlin-first" in 2019, and today the modern Android toolkit — Jetpack Compose, coroutines, Flow — is built around it. This module is a conceptual map of how everything you've learned powers a real app.

By the end you'll be able to:

• Explain why Kotlin is Android's language
• Recognise the parts of an Android project
• Understand the activity lifecycle at a high level
• Read Jetpack Compose UI and see coroutines/Flow in action

Why Kotlin owns Android

Android was historically Java, which meant verbose code and endless null-pointer crashes. Kotlin fixed exactly those pains: null safety removes a whole class of bugs, concise syntax and data classes cut boilerplate dramatically, coroutines tame asynchronous work, and extension functions make APIs pleasant. Full Java interop meant teams could migrate gradually — and most did.

Project structure

An Android project layers a few familiar and a few new pieces:

• Kotlin source — your activities, view models, and logic
• res/ — resources: layouts, images, strings, and themes
• AndroidManifest.xml — declares the app's screens and permissions
• build.gradle.kts — the Gradle build you met last module, with Android plugins

Activities & lifecycle

An Activity is a single screen. Android drives it through a lifecycle — onCreate, onStart, onResume, onPause, onStop, onDestroy — as the user navigates and the system manages memory. You override the callbacks you care about; onCreate is where a screen is set up:

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {                 // hand the screen over to Compose
            Counter()
        }
    }
}

Jetpack Compose

Jetpack Compose is Android's modern, declarative UI toolkit — you describe the UI as a function of state, and it re-renders ("recomposes") when the state changes. A @Composable function is a piece of UI. Notice how it leans on Kotlin's trailing lambdas and property delegation:

import androidx.compose.foundation.layout.Column
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.*

@Composable
fun Counter() {
    // state that survives recomposition; changing it re-renders the UI
    var count by remember { mutableStateOf(0) }
    Column {
        Text("Count: $count")
        Button(onClick = { count++ }) {
            Text("Increment")
        }
    }
}

Coroutines & Flows in Android

Android forbids blocking the main (UI) thread — do so and the app freezes. Coroutines are the answer: a ViewModel holds UI state as a StateFlow and runs suspend work in viewModelScope, which is automatically cancelled when the screen goes away. Structured concurrency prevents leaks; Compose collects the StateFlow and re-renders on change:

class UserViewModel(private val repo: UserRepo) : ViewModel() {
    private val _user = MutableStateFlow<User?>(null)
    val user: StateFlow<User?> = _user   // expose read-only state to the UI

    fun load(id: Int) {
        viewModelScope.launch {          // scope tied to the ViewModel lifecycle
            _user.value = repo.fetch(id) // suspend call, safely off the UI thread
        }
    }
}

Recap & quick check

Android is one target; Kotlin reaches many more. Next we'll see how one Kotlin codebase can run on iOS, the JVM, the web, and native platforms with Kotlin Multiplatform.