Android & Jetpack Compose Quick Reference
This reference condenses the Jetpack Compose APIs and Android architecture building blocks you reach for most often into one page, organized by concern: layout, state, lists, navigation, and async data. It is meant to be skimmed while coding, not read start to finish — use it to confirm the exact right API or signature rather than to learn a concept from scratch, since each linked topic in this course covers the underlying reasoning in depth.
Cricket analogy: This page is like a cricket coach's laminated field-placement card: you don't read it cover to cover before the match, you glance at it mid-over to confirm exactly where third man should stand.
Layout and Modifiers
Row, Column, and Box are the three foundational layout composables — Row arranges children horizontally, Column vertically, and Box stacks them on top of each other. Every composable accepts an optional modifier: Modifier chains configure size, padding, click handling, and more, and are applied in the order they're chained, which affects the resulting layout (e.g. padding before size versus size before padding produce different results). Alignment and arrangement parameters (horizontalAlignment, verticalArrangement, contentAlignment) control how children are positioned within the available space.
Cricket analogy: Row and Column are like arranging fielders across the boundary versus stacking slip cordon players behind the keeper, while Box overlays a short leg directly on top of the batsman's eyeline; the order you apply padding versus size modifiers is like deciding whether the field restrictions apply before or after players take position.
@Composable
fun QuickReferenceCard(title: String, subtitle: String, onClick: () -> Unit) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp)
.clickable(onClick = onClick),
verticalAlignment = Alignment.CenterVertically
) {
Column(modifier = Modifier.weight(1f)) {
Text(title, style = MaterialTheme.typography.titleMedium)
Text(subtitle, style = MaterialTheme.typography.bodySmall)
}
Icon(Icons.Default.ChevronRight, contentDescription = null)
}
}State Cheat Sheet
remember { mutableStateOf(x) } keeps a value alive across recompositions of the same composition instance; rememberSaveable additionally survives configuration change and process death by writing to the saved-instance-state Bundle. derivedStateOf recomputes a value from other State reads only when those inputs change, avoiding redundant work. For flows exposed from a ViewModel, collectAsStateWithLifecycle() is the recommended collector in UI code because it automatically stops collecting when the lifecycle drops below STARTED, avoiding wasted work in the background.
Cricket analogy: remember is like a batsman's guard mark on the crease that stays put through an over, rememberSaveable is that same guard mark surviving a rain-delay stoppage, and derivedStateOf is the scoreboard's run-rate that only updates when runs actually change, not every ball.
For lists, navigation, and async data: LazyColumn/LazyRow render only the items currently visible (plus a small buffer), and should always supply a key = { item.id } lambda to preserve item identity across reordering. NavHost paired with a NavController and composable(route) { ... } destinations forms the standard single-Activity navigation setup; navController.navigate(route) pushes a destination, and popBackStack() or navigateUp() pop it. For asynchronous data, expose a StateFlow from the ViewModel via viewModelScope, and prefer stateIn(scope, SharingStarted.WhileSubscribed(5000), initialValue) to convert a cold Flow into a shared, lifecycle-friendly hot stream.
Cricket analogy: LazyColumn is like a stadium only rendering seats currently in the TV camera's frame plus a small buffer, key={item.id} keeps a specific fan's seat assignment stable even if the stand reshuffles, and NavHost is the tunnel system routing a player from dressing room to pitch and back via popBackStack.
Treat this page as a lookup table: if a code review comment says 'use rememberSaveable here' or 'add a key to that LazyColumn,' this reference tells you the exact fix, while the dedicated topic pages (linked below) explain why the rule exists.
This reference intentionally omits nuance for brevity — for example it doesn't cover Saver customization for rememberSaveable, or the tuning of WhileSubscribed's timeout. Don't copy snippets from here into production code without understanding the trade-offs covered in the full topic pages.
- Row/Column/Box are the three core layout primitives; Modifier order affects the resulting layout.
- remember survives recomposition only; rememberSaveable also survives configuration change and process death.
- derivedStateOf avoids redundant recomposition by recomputing only when its underlying State inputs change.
- collectAsStateWithLifecycle() is the recommended way to collect a ViewModel's StateFlow in Compose UI.
- LazyColumn/LazyRow should always use a stable key per item to preserve identity across list changes.
- NavHost + NavController + composable(route) is the standard single-Activity navigation pattern; navigate()/popBackStack() move between destinations.
Practice what you learned
1. What determines the resulting layout when chaining multiple Modifier functions?
2. What is the key functional difference between remember and rememberSaveable?
3. Why is collectAsStateWithLifecycle() preferred over collectAsState() for collecting a ViewModel's StateFlow in Compose UI?
4. Why should every LazyColumn item specify a key?
5. What is the standard trio of APIs for single-Activity Compose navigation?
Was this page helpful?
You May Also Like
Common Android & Compose Pitfalls
The recurring mistakes developers make with recomposition, state, coroutines, and lists in Jetpack Compose, and the concrete fixes for each.
Android & Jetpack Compose Interview Questions
A curated set of frequently asked Android and Jetpack Compose interview questions with precise, technically grounded answers spanning composition, state, and architecture.
Layouts: Row, Column, and Box
Row, Column, and Box are Compose's three foundational layout composables for arranging children horizontally, vertically, or stacked, forming the basis of nearly every screen.
Navigation Compose Basics
An introduction to the Navigation component's Compose integration — NavController, NavHost, and route-based destinations for moving between screens.