Android, Kotlin and Compose Quick Reference and Learning Roadmap

adb devices # list connected devices and emulators
adb install -r app/build/outputs/apk/debug/app-debug.apk # install/replace an APK
adb uninstall com.example.marketmate # remove an app
adb shell pm clear com.example.marketmate # wipe app data (reset to first run)
adb shell am start -n com.example.marketmate/.MainActivity # launch an activity
adb shell am force-stop com.example.marketmate # kill the app
adb shell dumpsys activity activities | grep mResumed # which activity is in front?
adb shell input text "hello" # type text; adb shell input keyevent 66 = Enter
adb shell screencap /sdcard/s.png && adb pull /sdcard/s.png # screenshot
adb shell screenrecord /sdcard/demo.mp4 # record the screen (Ctrl+C to stop; adb pull to copy)
adb pull /sdcard/Download/file.txt . # copy from device to computer
adb push local.txt /sdcard/Download/ # copy to device
adb tcpip 5555 # restart adb in TCP mode (wireless debugging legacy)
adb pair <ip:port> # pair for Wireless debugging (Android 11+)
adb connect <ip:port> # connect after pairing
adb reverse tcp:8080 tcp:8080 # device reaches your laptop's localhost:8080
adb logcat -c # clear the log

adb logcat # everything (very noisy)
adb logcat -s MyTag # only the tag "MyTag"
adb logcat *:E # errors and above
adb logcat --pid=$(adb shell pidof -s com.example.marketmate) # one app only
adb logcat -d > log.txt # dump current log to a file and exit

Log.d("Prices", "loaded ${list.size} items") // debug
Log.e("Prices", "failed to load", exception) // error with stack trace

./gradlew assembleDebug # build a debug APK
./gradlew assembleRelease # build a release APK (signing config required)
./gradlew bundleRelease # build a release AAB for Play
./gradlew installDebug # build and install on the connected device
./gradlew test # local unit tests (JVM)
./gradlew connectedAndroidTest # instrumented tests on a device
./gradlew lint # Android Lint
./gradlew clean # delete build outputs
./gradlew app:dependencies # print the dependency tree
./gradlew --stop # stop Gradle daemons
./gradlew build --scan # build with a Build Scan (shareable report)

// Variables and types
val name = "Ada" // read-only
var count = 0 // mutable
val age: Int = 17 // explicit type
val price = 2_500L // Long literal
val rate = 0.05f // Float
val text = "Hello, $name! ${count + 1}" // string templates
val multi = """line one
line two""" // raw string
// Null safety
var nickname: String? = null
val length = nickname?.length // safe call -> Int?
val safe = nickname ?: "none" // Elvis default
nickname?.let { println(it) } // run only if not null
// nickname!!.length                      // throws if null: avoid
// Functions
fun add(a: Int, b: Int = 0): Int = a + b // default argument, expression body
fun greet(name: String) = "Hi $name"
val double = { x: Int -> x * 2 } // lambda
fun apply(n: Int, f: (Int) -> Int) = f(n) // higher-order function
apply(4) { it * it } // trailing lambda, 'it'
// Conditions
val grade = when {
 score >= 70 -> "A"
 score >= 50 -> "C"
 else -> "F"
}
if (a > b) "a" else "b" // if is an expression
// Collections
val list = listOf(1, 2, 3) // read-only
val mutable = mutableListOf(1, 2)
val map = mapOf("a" to 1, "b" to 2)
list.map { it * 2 }.filter { it > 2 }.sum()
list.groupBy { it % 2 }
list.sortedByDescending { it }
list.firstOrNull { it > 5 }
list.associateBy { it } // Map keyed by lambda
for ((index, value) in list.withIndex()) { }
for (i in 1..5) { } // 1,2,3,4,5
for (i in 5 downTo 1 step 2) { } // 5,3,1

// Classes
class Student(val name: String, var score: Int) {
 val passed: Boolean get() = score >= 50 // computed property
 fun bonus(points: Int) { score += points }
}
data class Item(val id: Int, val name: String) // equals, hashCode, toString, copy, componentN
val copy = item.copy(name = "New")
object Settings { val tag = "app" } // singleton
class Config { companion object { const val URL = "https://..." } }
enum class Form { SS1, SS2, SS3 }
sealed interface Result { data class Ok(val v: Int) : Result; data object Fail : Result }
interface Repo { suspend fun load(): List<Item> }
abstract class Base { abstract fun run() }
class Impl : Base() { override fun run() {} }
// Extension function and property
fun String.initials() = split(" ").map { it.first() }.joinToString("")
val Int.naira get() = "₦$this"
// Scope functions: let, run, with, apply, also
Student("Ada", 60).apply { bonus(5) } // configure and return the object
value?.let { use(it) } // transform / null check

// Coroutines and Flow (lessons 28, 33)
viewModelScope.launch { val data = repo.load() } // fire and forget
val result = withContext(Dispatchers.IO) { readFile() } // switch thread, return value
coroutineScope { val a = async { f1() }; val b = async { f2() }; a.await() + b.await() }
val flow: Flow<Int> = flow { emit(1); delay(100); emit(2) }
flow.map { it * 2 }.filter { it > 1 }.collect { println(it) }
val state = MutableStateFlow(0); state.update { it + 1 }
combine(flowA, flowB) { a, b -> a + b }
flow.stateIn(scope, SharingStarted.WhileSubscribed(5_000), initial)

// A composable with state hoisting (lessons 15, 19, 37)
@Composable
fun Counter(count: Int, onIncrement: () -> Unit, modifier: Modifier = Modifier) {
 Button(onClick = onIncrement, modifier = modifier) { Text("Clicked $count") }
}
@Composable
fun CounterScreen() {
 var count by rememberSaveable { mutableIntStateOf(0) } // survives rotation
 Counter(count, onIncrement = { count++ })
}

// Layouts (lessons 16, 38)
Column(verticalArrangement = Arrangement.spacedBy(8.dp), horizontalAlignment = Alignment.CenterHorizontally) { }
Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) { }
Box(Modifier.size(100.dp), contentAlignment = Alignment.Center) { }
Spacer(Modifier.height(16.dp))
LazyColumn(contentPadding = PaddingValues(16.dp)) { items(list, key = { it.id }) { Row(it) } }
LazyVerticalGrid(columns = GridCells.Adaptive(160.dp)) { items(list) { Card(it) } }
Scaffold(topBar = { }, floatingActionButton = { }) { padding -> Content(Modifier.padding(padding)) }
// Modifiers (order matters)
Modifier.fillMaxWidth().padding(16.dp).background(Color.White).clickable { }.semantics { contentDescription = "..." }

// State patterns (lessons 19, 25, 33, 61)
var text by remember { mutableStateOf("") } // local state
val state by viewModel.uiState.collectAsStateWithLifecycle() // from a ViewModel
val derived by remember { derivedStateOf { list.size > 3 } } // computed, cached
LaunchedEffect(key) { /* suspending work when key changes */ }
DisposableEffect(key) { onDispose { /* cleanup */ } }
rememberCoroutineScope() // launch from event handlers

// Navigation, type-safe (lesson 55)
@Serializable object Home
@Serializable data class Detail(val id: Int)
NavHost(navController, startDestination = Home) {
 composable<Home> { HomeScreen(onOpen = { navController.navigate(Detail(it)) }) }
 composable<Detail> { entry -> val args = entry.toRoute<Detail>(); DetailScreen(args.id) }
}
navController.popBackStack()

// Theming (lesson 40)
MaterialTheme.colorScheme.primary
MaterialTheme.typography.titleLarge
MaterialTheme.shapes.medium
val dark = isSystemInDarkTheme()

// Testing (lesson 45)
@get:Rule val rule = createComposeRule()
rule.setContent { MyScreen() }
rule.onNodeWithText("Save").performClick()
rule.onNodeWithContentDescription("Delete").assertIsDisplayed()
rule.onNodeWithTag("list").performScrollToIndex(20)

// build.gradle.kts (module)
plugins {
 alias(libs.plugins.android.application)
 alias(libs.plugins.kotlin.android)
 alias(libs.plugins.kotlin.compose)
 alias(libs.plugins.ksp)
}
android {
 namespace = "com.example.app"
 compileSdk = 36
 defaultConfig { applicationId = "com.example.app"; minSdk = 24; targetSdk = 36; versionCode = 1; versionName = "1.0" }
 buildTypes { release { isMinifyEnabled = true; proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro") } }
 buildFeatures { compose = true }
}
dependencies {
 implementation(platform(libs.androidx.compose.bom)) // BOM keeps Compose versions aligned
 implementation(libs.androidx.compose.material3)
 ksp(libs.androidx.room.compiler)
 testImplementation(libs.junit)
 androidTestImplementation(libs.androidx.compose.ui.test.junit4)
 debugImplementation(libs.androidx.compose.ui.tooling)
}

UI layer       Composable (stateless) ◄── UiState (immutable) ◄── ViewModel / state holder
                    │ events up                                       ▲
Domain layer   Use cases (optional, plain Kotlin)                     │ state down
Data layer     Repository (interface) ─► Local source (Room) / Remote source (Retrofit / Ktor)

Rules: state flows down, events flow up (UDF) | one source of truth (database) |
       dependencies point down | inject dependencies (Hilt) | fakes over mocks | main-safe suspend functions