Jetpack Compose: Modern Android UI Development
Master Jetpack Compose, Android's modern toolkit for building native UI with less code and powerful tools.

Jetpack Compose is transforming Android development with a modern, declarative approach to building user interfaces.
What is Jetpack Compose?
Jetpack Compose is Android's modern toolkit for building native UI, completely replacing XML layouts with Kotlin code.
Why Compose?
#
Benefits- Less code: 40% fewer lines than XML
- Intuitive: Declarative paradigm
- Accelerated development: Live preview and instant iteration
- Powerful: Everything is code
Getting Started
#
- Intuitive: Declarative paradigm
- Accelerated development: Live preview and instant iteration
- Powerful: Everything is code
Getting Started
#
Setup ```gradle // app/build.gradle android { buildFeatures { compose true } composeOptions { kotlinCompilerExtensionVersion = "1.5.8" } }
dependencies { implementation "androidx.compose.ui:ui:1.6.0" implementation "androidx.compose.material3:material3:1.2.0" implementation "androidx.compose.ui:ui-tooling-preview:1.6.0" } ```
#
Your First Composable ```kotlin @Composable fun Greeting(name: String) { Text(text = "Hello, $name!") }
@Preview @Composable fun PreviewGreeting() { Greeting("Android") } ```
Core Concepts
#
1. Composable Functions Building blocks of Compose UI: ```kotlin @Composable fun MessageCard(name: String, message: String) { Column { Text(text = name, style = MaterialTheme.typography.titleMedium) Spacer(modifier = Modifier.height(4.dp)) Text(text = message, style = MaterialTheme.typography.bodyMedium) } } ```
#
2. State Management ```kotlin @Composable fun Counter() { var count by remember { mutableStateOf(0) } Column { Text(text = "Count: $count") Button(onClick = { count++ }) { Text("Increment") } } } ```
#
3. Modifiers Style and behavior: ```kotlin Text( text = "Styled Text", modifier = Modifier .padding(16.dp) .background(Color.Blue) .clickable { /* Handle click */ } .fillMaxWidth() ) ```
#
4. Layouts ```kotlin @Composable fun LayoutExample() { Column { Row { Text("Item 1") Text("Item 2") } Box { Text("Overlaid content") } } } ```
Material Design 3
```kotlin @Composable fun App() { MaterialTheme( colorScheme = lightColorScheme( primary = Color(0xFF6200EE), secondary = Color(0xFF03DAC6) ) ) { Surface( modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background ) { MainScreen() } } } ```
Navigation
```kotlin @Composable fun AppNavigation() { val navController = rememberNavController() NavHost(navController, startDestination = "home") { composable("home") { HomeScreen(navController) } composable("details/{id}") { backStackEntry -> DetailsScreen( id = backStackEntry.arguments?.getString("id") ) } } } ```
Lists
#
LazyColumn (RecyclerView equivalent)
```kotlin
@Composable
fun ItemList(items: List) {
LazyColumn {
items(items) { item ->
Text(
text = item,
modifier = Modifier.padding(16.dp)
)
}
}
}
```#
LazyGrid
```kotlin
@Composable
fun PhotoGrid(photos: List) {
LazyVerticalGrid(
columns = GridCells.Fixed(2),
contentPadding = PaddingValues(8.dp)
) {
items(photos) { photo ->
PhotoItem(photo)
}
}
}
```Animations
```kotlin
@Composable
fun AnimatedButton() {
var expanded by remember { mutableStateOf(false) }
val size by animateDpAsState(
targetValue = if (expanded) 200.dp else 100.dp,
animationSpec = spring(
dampingRatio = Spring.DampingRatioMediumBouncy,
stiffness = Spring.StiffnessLow
)
)
Box(
modifier = Modifier
.size(size)
.background(Color.Blue)
.clickable { expanded = !expanded }
)
}
```
ViewModel Integration
```kotlin
class MainViewModel : ViewModel() {
private val _uiState = MutableStateFlow(UiState())
val uiState: StateFlow = _uiState.asStateFlow()
fun updateData() {
_uiState.value = _uiState.value.copy(data = "New data")
}
}
@Composable
fun MainScreen(viewModel: MainViewModel = viewModel()) {
val uiState by viewModel.uiState.collectAsState()
Text(text = uiState.data)
}
```
#
LazyGrid
```kotlin
@Composable
fun PhotoGrid(photos: List) {
LazyVerticalGrid(
columns = GridCells.Fixed(2),
contentPadding = PaddingValues(8.dp)
) {
items(photos) { photo ->
PhotoItem(photo)
}
}
}
```Animations
```kotlin
@Composable
fun AnimatedButton() {
var expanded by remember { mutableStateOf(false) }
val size by animateDpAsState(
targetValue = if (expanded) 200.dp else 100.dp,
animationSpec = spring(
dampingRatio = Spring.DampingRatioMediumBouncy,
stiffness = Spring.StiffnessLow
)
)
Box(
modifier = Modifier
.size(size)
.background(Color.Blue)
.clickable { expanded = !expanded }
)
}
```
Animations
```kotlin @Composable fun AnimatedButton() { var expanded by remember { mutableStateOf(false) } val size by animateDpAsState( targetValue = if (expanded) 200.dp else 100.dp, animationSpec = spring( dampingRatio = Spring.DampingRatioMediumBouncy, stiffness = Spring.StiffnessLow ) ) Box( modifier = Modifier .size(size) .background(Color.Blue) .clickable { expanded = !expanded } ) } ```
ViewModel Integration
```kotlin
class MainViewModel : ViewModel() {
private val _uiState = MutableStateFlow(UiState())
val uiState: StateFlow
@Composable fun MainScreen(viewModel: MainViewModel = viewModel()) { val uiState by viewModel.uiState.collectAsState() Text(text = uiState.data) } ```
Side Effects
#
LaunchedEffect
```kotlin
@Composable
fun LoadDataScreen(id: String) {
var data by remember { mutableStateOf(null) }
LaunchedEffect(id) {
data = loadData(id)
}
data?.let { DisplayData(it) }
}
```#
DisposableEffect
```kotlin
@Composable
fun LifecycleEventHandler(onResume: () -> Unit) {
DisposableEffect(Unit) {
// Setup
onResume()
onDispose {
// Cleanup
}
}
}
```
Testing
```kotlin @Test fun counterIncrements() { composeTestRule.setContent { Counter() } composeTestRule .onNodeWithText("Count: 0") .assertIsDisplayed() composeTestRule .onNodeWithText("Increment") .performClick() composeTestRule .onNodeWithText("Count: 1") .assertIsDisplayed() } ```
Performance Tips
1. Use remember: Cache expensive calculations ```kotlin val expensiveValue = remember(key) { computeExpensiveValue() } ```
2. Avoid unnecessary recomposition ```kotlin @Composable fun Stable(data: StableData) { // Only recomposes when data changes } ```
3. Use derivedStateOf ```kotlin val filteredList by remember { derivedStateOf { items.filter { it.isActive } } } ```
4. Keys in lists ```kotlin LazyColumn { items(items, key = { it.id }) { item -> ItemRow(item) } } ```
Compose vs XML Views
#
Advantages
- Less boilerplate
- Type-safe
- Better tooling
- Easier to maintain
- Preview in IDE
#
Migration ```kotlin // Use XML views in Compose @Composable fun AndroidViewBinding() { AndroidView( factory = { context -> LayoutInflater.from(context) .inflate(R.layout.legacy_layout, null, false) } ) }
// Use Compose in XML val composeView = findViewById
(R.id.compose_view) composeView.setContent { MyComposable() } ``` Best Practices
1. Keep composables pure: No side effects in body 2. Use preview annotations: Test different states 3. Extract reusable components: DRY principle 4. Hoist state: Pass state down, events up 5. Use material components: Consistent design
Common Patterns
#
Stateful vs Stateless ```kotlin // Stateful @Composable fun StatefulCounter() { var count by remember { mutableStateOf(0) } StatelessCounter(count, onIncrement = { count++ }) }
// Stateless (reusable) @Composable fun StatelessCounter(count: Int, onIncrement: () -> Unit) { Button(onClick = onIncrement) { Text("Count: $count") } } ```
Resources
- [Official Compose Docs](https://developer.android.com/jetpack/compose)
- [Compose Samples](https://github.com/android/compose-samples)
- [Jetpack Compose Playground](https://foso.github.io/Jetpack-Compose-Playground/)
- [Compose Academy](https://compose.academy/)
Conclusion
Jetpack Compose represents the future of Android UI development. It's:
- More intuitive
- Less code
- Better tooling
- Actively developed
For new projects, start with Compose. For existing projects, gradually migrate screen by screen.
The Android UI future is declarative, and it's here now.