Learn Modern Android Development

Coroutines & Dispatchers

Asynchronous execution without blocking the main UI thread. Always choose the correct dispatcher:

viewModelScope.launch {
    // 1. Heavy Network/Disk I/O on background thread
    val data = withContext(Dispatchers.IO) {
        apiService.fetchUserData()
    }
    // 2. Automatically resumes on Dispatchers.Main for UI update
    _uiState.value = UserUiState.Success(data)
}

• Dispatchers.Main • UI interactions & Compose state updates
• Dispatchers.IO • Network requests, Room database queries, disk files
• Dispatchers.Default • Heavy CPU calculations, JSON parsing, sorting

StateFlow vs SharedFlow

Reactive data streams designed for Android lifecycle awareness:

// Holds current state, emits last known value to new collectors
private val _count = MutableStateFlow(0)
val count: StateFlow<Int> = _count.asStateFlow()

// For one-off events (Navigation, Toasts, Snackbars)
private val _event = MutableSharedFlow<UiEvent>()
val event: SharedFlow<UiEvent> = _event.asSharedFlow()

Use StateFlow for persistent UI state and SharedFlow for one-off events.

State Hoisting & Recomposition

In Compose, UI components are pure functions. Pass state down, send events up:

// Stateless Composable (Re-usable & Testable)
@Composable
fun CounterButton(count: Int, onIncrement: () -> Unit) {
    Button(onClick = onIncrement) {
        Text("Count: $count")
    }
}

// Stateful Parent (Owns the State)
@Composable
fun CounterContainer() {
    var count by rememberSaveable { mutableStateOf(0) }
    CounterButton(count = count, onIncrement = { count++ })
}

LazyColumn Performance

Efficiently rendering millions of items with stable keys to avoid jank:

LazyColumn(
    contentPadding = PaddingValues(16.dp),
    verticalArrangement = Arrangement.spacedBy(8.dp)
) {
    // ALWAYS provide a unique stable key!
    items(items = appsList, key = { app -> app.packageId }) { app ->
        AppRowItem(app = app)
    }
}

Providing key = { it.id } allows Compose to reposition items during sorting without recomposing unchanged elements.

Flutter vs Jetpack Compose

State Management Choice

Popular state management architectures for production Flutter applications:

• Riverpod: Compile-safe, testable provider replacement without BuildContext requirements.
• Bloc / Cubit: Strict separation of business events and UI states, ideal for enterprise projects.
• Provider: Lightweight inherited widget wrapper suitable for simple to medium utilities.

Cordova vs Capacitor Architecture

Direct Plugin Equivalents

Drop-in modern TypeScript replacements for classic Cordova plugins:

• cordova-plugin-camera → @capacitor/camera
• phonegap-plugin-push → @capacitor/push-notifications
• cordova-plugin-file → @capacitor/filesystem
• cordova-sqlite-storage → @capacitor-community/sqlite

WebView vs Real Native Primitives

Top Performance Advantages

• No DOM Reflow Jank: Native views calculate layouts through Yoga C++ engine without browser reflow bottlenecks.
• Hermes Bytecode Engine: Pre-compiled bytecode with instant app startup and tiny memory footprints.
• Recycled FlatLists: Handles 10,000+ items smoothly using native Android view recycling.
• Expo EAS Build: One-command cloud or local native builds without complex local SDK installations.

Speed Up Gradle Build Times

Add these flags into your gradle.properties file to decrease compilation time by up to 60%:

# Enable Gradle build caching across tasks
org.gradle.caching=true

# Parallel execution across multi-module projects
org.gradle.parallel=true

# Configuration on demand
org.gradle.configureondemand=true

# Allocate JVM memory heap
org.gradle.jvmargs=-Xmx4096m -XX:+UseParallelGC

Top Productivity Shortcuts

• Search Everywhere (Files, Classes, Symbols) Shift + Shift
• Reformat Code & Optimize Imports Ctrl + Alt + L
• Extract Composable / Method Ctrl + Alt + M
• Inspect Call Hierarchy Ctrl + Alt + H