Android Development with Kotlin on Software Engineering Learning Paths

Kotlin Fundamentals

Mon, 01 Jan 0001 00:00:00 +0000

Kotlin Fundamentals#

Kotlin is a statically-typed language that runs on the JVM, designed to be concise, safe, and fully interoperable with Java. It eliminates entire categories of bugs through its type system, particularly its handling of null references through nullable types.

Variables: val and var#

Kotlin distinguishes between immutable and mutable bindings at the declaration site:

val maximumAttempts = 3 // Immutable — cannot be reassigned
var currentAttempt = 0 // Mutable — can be reassigned

currentAttempt += 1 // OK
// maximumAttempts = 5 // Compile error: Val cannot be reassigned

Prefer val over var whenever possible. The compiler enforces immutability, making code easier to reason about and safer in concurrent contexts.

Functions and Lambdas

Mon, 01 Jan 0001 00:00:00 +0000

Functions and Lambdas#

Kotlin’s function system combines concise syntax with powerful features like default parameters, extension functions, and first-class lambdas. Functions are the primary building blocks for organising logic, and Kotlin makes them flexible enough to serve as both simple utilities and composable abstractions.

Function Syntax#

Functions are declared with the fun keyword. The return type follows the parameter list:

fun greet(name: String): String {
 return "Hello, $name!"
}

// Single-expression functions omit braces and return
fun greet(name: String): String = "Hello, $name!"

// Return type can be inferred for single-expression functions
fun greet(name: String) = "Hello, $name!"

Functions that return nothing meaningful use Unit (equivalent to void). The return type and return statement can be omitted:

Collections and Sequences

Mon, 01 Jan 0001 00:00:00 +0000

Collections and Sequences#

Kotlin’s collections API is one of the language’s strongest features. It provides a rich set of operations for transforming, filtering, and aggregating data, while making a clear distinction between read-only and mutable collections. Sequences extend this model with lazy evaluation for processing large datasets efficiently.

Collection Hierarchy#

Kotlin separates read-only interfaces from mutable ones at the type level:

Read-Only	Mutable	Factory function
`List<T>`	`MutableList<T>`	`listOf()` / `mutableListOf()`
`Set<T>`	`MutableSet<T>`	`setOf()` / `mutableSetOf()`
`Map<K, V>`	`MutableMap<K, V>`	`mapOf()` / `mutableMapOf()`

Read-only collections have no add, remove, or put methods. This is enforced at the interface level, not by creating defensive copies:

Object-Oriented Kotlin

Mon, 01 Jan 0001 00:00:00 +0000

Object-Oriented Kotlin#

Kotlin builds on Java’s object-oriented foundation but strips away ceremony and adds powerful features like data classes, sealed hierarchies, object declarations, and delegation. The result is a concise, expressive class system that favours composition over inheritance.

Classes and Constructors#

Kotlin classes have a primary constructor in the class header and can have secondary constructors in the body:

class User(val name: String, val email: String, var isActive: Boolean = true) {
 // Properties declared in the primary constructor
 // val = read-only, var = mutable

 init {
 require(name.isNotBlank()) { "Name must not be blank" }
 require(email.contains("@")) { "Invalid email" }
 }

 // Secondary constructor
 constructor(name: String) : this(name, "$name@example.com")
}

val user = User("Alice", "alice@example.com")
println(user.name) // Alice
println(user.isActive) // true

Properties and Accessors#

Properties can have custom getters and setters:

Coroutines and Concurrency

Mon, 01 Jan 0001 00:00:00 +0000

Coroutines and Concurrency#

Kotlin coroutines provide a structured, lightweight model for asynchronous and concurrent programming. Unlike threads, coroutines are cheap to create (thousands can run simultaneously), and structured concurrency ensures that work is properly scoped and cancelled.

Suspend Functions#

A suspend function can be paused and resumed without blocking a thread. Suspension is the fundamental building block of coroutines:

suspend fun fetchUser(id: Long): User {
 // This call suspends the coroutine, freeing the thread
 val response = httpClient.get("https://api.example.com/users/$id")
 return response.body()
}

suspend fun fetchUserWithPosts(id: Long): UserWithPosts {
 val user = fetchUser(id) // Sequential
 val posts = fetchPosts(user.id) // Sequential — waits for user first
 return UserWithPosts(user, posts)
}

Suspend functions can only be called from other suspend functions or from a coroutine builder.

Kotlin Patterns and Ecosystem

Mon, 01 Jan 0001 00:00:00 +0000

Kotlin Patterns and Ecosystem#

Beyond the core language, Kotlin offers powerful patterns for building domain-specific languages, handling errors gracefully, and sharing code across platforms. This section covers DSLs, type-safe builders, the Result type, value classes, Kotlin Multiplatform, and kotlinx.serialization.

Domain-Specific Languages (DSLs)#

Kotlin’s combination of extension functions, lambdas with receivers, and operator overloading makes it ideal for building DSLs — small, specialised languages embedded in Kotlin:

// A simple HTML DSL
fun html(block: HtmlBuilder.() -> Unit): String {
 val builder = HtmlBuilder()
 builder.block()
 return builder.build()
}

class HtmlBuilder {
 private val elements = mutableListOf<String>()

 fun head(block: HeadBuilder.() -> Unit) {
 val head = HeadBuilder()
 head.block()
 elements.add("<head>${head.build()}</head>")
 }

 fun body(block: BodyBuilder.() -> Unit) {
 val body = BodyBuilder()
 body.block()
 elements.add("<body>${body.build()}</body>")
 }

 fun build() = "<html>${elements.joinToString("")}</html>"
}

Usage reads like a declarative specification:

Jetpack Compose Fundamentals

Mon, 01 Jan 0001 00:00:00 +0000

Jetpack Compose Fundamentals#

Jetpack Compose is Android’s modern declarative UI toolkit. Instead of building views imperatively through XML layouts and findViewById, you describe what the UI should look like as a function of state, and the framework handles rendering and updates.

Declarative vs Imperative UI#

Aspect	Imperative (XML + View)	Declarative (Compose)
UI definition	XML layouts + code wiring	Kotlin functions
State updates	Find view, call setters	Recompose with new state
View hierarchy	Mutable, held in memory	Immutable descriptions, rebuilt on change
Reusability	Custom views, includes	Composable functions
Preview	Layout editor	`@Preview` annotation

In Compose, the UI is a function of state. When state changes, the framework re-executes (recomposes) only the affected composable functions.

Compose State Management

Mon, 01 Jan 0001 00:00:00 +0000

Compose State Management#

State management is the central challenge in Compose. The framework re-executes composable functions whenever state changes (recomposition), so understanding how to hold, hoist, and observe state determines whether your UI is correct, performant, and testable.

remember and mutableStateOf#

mutableStateOf creates an observable state holder. When its value changes, Compose recomposes any composable that reads it. remember preserves the value across recompositions:

@Composable
fun Counter() {
 var count by remember { mutableStateOf(0) }

 Column(horizontalAlignment = Alignment.CenterHorizontally) {
 Text("Count: $count", style = MaterialTheme.typography.headlineMedium)
 Button(onClick = { count++ }) {
 Text("Increment")
 }
 }
}

remember vs rememberSaveable#

Function	Survives recomposition	Survives configuration change	Survives process death
`remember`	Yes	No	No
`rememberSaveable`	Yes	Yes	Yes (if using Saver)

// Survives screen rotation
var text by rememberSaveable { mutableStateOf("") }

// Custom saver for complex types
data class SearchState(val query: String, val page: Int)

val SearchStateSaver = Saver<SearchState, List<Any>>(
 save = { listOf(it.query, it.page) },
 restore = { SearchState(it[0] as String, it[1] as Int) }
)

var searchState by rememberSaveable(stateSaver = SearchStateSaver) {
 mutableStateOf(SearchState("", 1))
}

State Delegation Patterns#

// Delegation with 'by' — read/write directly
var name by remember { mutableStateOf("") }
name = "Alice" // Direct assignment
println(name) // Direct read

// Without delegation — explicit .value
val nameState = remember { mutableStateOf("") }
nameState.value = "Alice"
println(nameState.value)

// Destructuring
val (name, setName) = remember { mutableStateOf("") }
setName("Alice") // Setter function

State Hoisting#

State hoisting moves state up to a caller, making the composable stateless and reusable. The pattern is: state goes down as parameters, events go up as callbacks:

Compose Navigation

Mon, 01 Jan 0001 00:00:00 +0000

Navigation in Jetpack Compose is handled by the Navigation component, which manages the back stack, argument passing, deep links, and transitions between screens. The type-safe navigation API (introduced with Navigation 2.8+) uses serializable route objects instead of raw strings.

Navigation in Compose centres on three elements: NavController, NavHost, and route definitions.

@Composable
fun MyApp() {
 val navController = rememberNavController()

 NavHost(
 navController = navController,
 startDestination = Home
 ) {
 composable<Home> {
 HomeScreen(
 onNavigateToProfile = { navController.navigate(Profile) },
 onNavigateToDetail = { id -> navController.navigate(Detail(id)) }
 )
 }
 composable<Profile> {
 ProfileScreen(onBack = { navController.popBackStack() })
 }
 composable<Detail> { backStackEntry ->
 val detail: Detail = backStackEntry.toRoute()
 DetailScreen(itemId = detail.id)
 }
 }
}

NavController#

The NavController manages the navigation back stack:

Lists and Data Loading

Mon, 01 Jan 0001 00:00:00 +0000

Lists and Data Loading#

Most Android apps revolve around fetching data, storing it locally, and displaying it in scrollable lists. This section covers efficient list rendering with LazyColumn and LazyGrid, pagination with Paging 3, networking with Retrofit, local persistence with Room, and the repository pattern that ties everything together.

LazyColumn and LazyGrid#

LazyColumn Patterns#

LazyColumn only composes and lays out items currently visible on screen. Always provide stable keys for correct recomposition and animation:

Animations and Gestures

Mon, 01 Jan 0001 00:00:00 +0000

Animations and Gestures#

Compose provides a layered animation system ranging from simple one-shot animations to complex choreographed transitions. Gestures are handled declaratively through modifier functions, making touch interactions composable and testable.

animate*AsState#

The simplest animation API. It animates a single value toward a target, recomposing smoothly as the value transitions:

@Composable
fun ExpandableCard(expanded: Boolean) {
 val height by animateDpAsState(
 targetValue = if (expanded) 200.dp else 80.dp,
 animationSpec = tween(durationMillis = 300),
 label = "card height"
 )
 val alpha by animateFloatAsState(
 targetValue = if (expanded) 1f else 0.6f,
 animationSpec = tween(durationMillis = 300),
 label = "card alpha"
 )
 val backgroundColor by animateColorAsState(
 targetValue = if (expanded) MaterialTheme.colorScheme.primaryContainer
 else MaterialTheme.colorScheme.surface,
 label = "card background"
 )

 Card(
 modifier = Modifier
 .fillMaxWidth()
 .height(height)
 .alpha(alpha),
 colors = CardDefaults.cardColors(containerColor = backgroundColor)
 ) {
 // Content
 }
}

Available animate*AsState Functions#

Function	Animates
`animateFloatAsState`	Float values (alpha, scale, rotation)
`animateDpAsState`	Dp values (size, padding, offset)
`animateColorAsState`	Color transitions
`animateIntAsState`	Integer values
`animateOffsetAsState`	Offset (x, y) position
`animateSizeAsState`	Size (width, height)
`animateIntOffsetAsState`	IntOffset position

Animation Specs#

Animation specs control the timing and easing of animations:

App Architecture

Mon, 01 Jan 0001 00:00:00 +0000

App Architecture#

Building a production Android app requires more than individual features — it requires a coherent architecture that separates concerns, manages dependencies, supports testing, and handles the Android lifecycle gracefully. This section covers MVVM with Compose, Hilt dependency injection, multi-module project structure, testing strategies, lifecycle management, and release configuration.

MVVM with Compose#

The Model-View-ViewModel pattern is the standard architecture for Compose apps. The ViewModel holds UI state and business logic; the Composable renders that state and forwards user events.

Android Development with Kotlin on Software Engineering Learning Paths

Kotlin Fundamentals

Kotlin Fundamentals#

Variables: val and var#

Functions and Lambdas

Functions and Lambdas#

Function Syntax#

Collections and Sequences

Collections and Sequences#

Collection Hierarchy#

Object-Oriented Kotlin

Object-Oriented Kotlin#

Classes and Constructors#

Properties and Accessors#

Coroutines and Concurrency

Coroutines and Concurrency#

Suspend Functions#

Kotlin Patterns and Ecosystem

Kotlin Patterns and Ecosystem#

Domain-Specific Languages (DSLs)#

Jetpack Compose Fundamentals

Jetpack Compose Fundamentals#

Declarative vs Imperative UI#

Compose State Management

Compose State Management#

remember and mutableStateOf#

remember vs rememberSaveable#

State Delegation Patterns#

State Hoisting#

Compose Navigation

Compose Navigation#

Navigation Component Setup#

NavController#

Lists and Data Loading

Lists and Data Loading#

LazyColumn and LazyGrid#

LazyColumn Patterns#

Animations and Gestures

Animations and Gestures#

animate*AsState#

Available animate*AsState Functions#

Animation Specs#

App Architecture

App Architecture#

MVVM with Compose#