Kotlin / Android Development
Project Setup
Gradle Kotlin DSL
// settings.gradle.kts
pluginManagement {
repositories {
google()
mavenCentral()
gradlePluginPortal()
}
}
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
google()
mavenCentral()
}
}
rootProject.name = "MyApp"
include(":app")
build.gradle.kts (app)
plugins {
alias(libs.plugins.android.application)
alias(libs.plugins.kotlin.android)
alias(libs.plugins.kotlin.compose)
}
android {
namespace = "com.example.myapp"
compileSdk = 35
defaultConfig {
applicationId = "com.example.myapp"
minSdk = 26
targetSdk = 35
versionCode = 1
versionName = "1.0"
}
buildFeatures {
compose = true
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
kotlinOptions {
jvmTarget = "17"
}
}
dependencies {
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.runtime.ktx)
implementation(libs.androidx.activity.compose)
implementation(platform(libs.androidx.compose.bom))
implementation(libs.androidx.ui)
implementation(libs.androidx.material3)
testImplementation(libs.junit)
androidTestImplementation(libs.androidx.junit)
androidTestImplementation(libs.androidx.espresso.core)
}
Version Catalog (libs.versions.toml)
[versions]
kotlin = "2.0.0"
compose-bom = "2024.06.00"
lifecycle = "2.8.0"
[libraries]
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version = "1.13.1" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "compose-bom" }
[plugins]
android-application = { id = "com.android.application", version = "8.5.0" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
Type Patterns
Null Safety
// Safe call operator
val length = name?.length
// Elvis operator
val displayName = user?.name ?: "Guest"
// Safe cast
val number = value as? Int
// Not-null assertion (use sparingly)
val name = user!!.name
// let for null checks
user?.let { safeUser ->
println(safeUser.name)
}
Sealed Classes
sealed class Result<out T> {
data class Success<T>(val data: T) : Result<T>()
data class Error(val exception: Throwable) : Result<Nothing>()
data object Loading : Result<Nothing>()
}
// Exhaustive when
fun handleResult(result: Result<User>) = when (result) {
is Result.Success -> showUser(result.data)
is Result.Error -> showError(result.exception)
Result.Loading -> showLoading()
}
Data Classes
data class User(
val id: String,
val email: String,
val name: String,
val createdAt: Instant = Instant.now()
)
// Copy with modifications
val updatedUser = user.copy(name = "New Name")
// Destructuring
val (id, email, name) = user
Value Classes
@JvmInline
value class UserId(val value: String)
@JvmInline
value class Email(val value: String) {
init {
require(value.contains("@")) { "Invalid email" }
}
}
Error Handling
Result Type
fun parseNumber(input: String): Result<Int> {
return try {
Result.success(input.toInt())
} catch (e: NumberFormatException) {
Result.failure(e)
}
}
// Usage
parseNumber("123")
.onSuccess { number -> println("Parsed: $number") }
.onFailure { error -> println("Error: ${error.message}") }
// Transform
val doubled = parseNumber("42")
.map { it * 2 }
.getOrDefault(0)
runCatching
val result = runCatching {
riskyOperation()
}.getOrElse { error ->
logError(error)
defaultValue
}
// Chain operations
runCatching { fetchUser(id) }
.mapCatching { user -> processUser(user) }
.onSuccess { result -> display(result) }
.onFailure { error -> showError(error) }
Coroutines
Basic Coroutines
// Suspend function
suspend fun fetchUser(id: String): User {
return withContext(Dispatchers.IO) {
api.getUser(id)
}
}
// Launch coroutine
viewModelScope.launch {
try {
val user = fetchUser("123")
_uiState.value = UiState.Success(user)
} catch (e: Exception) {
_uiState.value = UiState.Error(e.message)
}
}
Flow
// Create flow
fun observeUsers(): Flow<List<User>> = flow {
while (true) {
emit(repository.getUsers())
delay(5000)
}
}.flowOn(Dispatchers.IO)
// Collect flow
viewModelScope.launch {
observeUsers()
.catch { e -> emit(emptyList()) }
.collect { users ->
_users.value = users
}
}
StateFlow
class UserViewModel : ViewModel() {
private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
val uiState: StateFlow<UiState> = _uiState.asStateFlow()
fun loadUser(id: String) {
viewModelScope.launch {
_uiState.value = UiState.Loading
try {
val user = repository.getUser(id)
_uiState.value = UiState.Success(user)
} catch (e: Exception) {
_uiState.value = UiState.Error(e.message ?: "Unknown error")
}
}
}
}
Jetpack Compose
Basic Composable
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
Text(
text = "Hello, $name!",
modifier = modifier.padding(16.dp),
style = MaterialTheme.typography.headlineMedium
)
}
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
MyAppTheme {
Greeting("Android")
}
}
State Management
@Composable
fun Counter() {
var count by remember { mutableIntStateOf(0) }
Column(
modifier = Modifier.padding(16.dp),
horizontalAlignment = Alignment.CenterHorizontally
) {
Text(
text = "Count: $count",
style = MaterialTheme.typography.headlineMedium
)
Spacer(modifier = Modifier.height(8.dp))
Button(onClick = { count++ }) {
Text("Increment")
}
}
}
ViewModel Integration
@Composable
fun UserScreen(
viewModel: UserViewModel = hiltViewModel()
) {
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
when (val state = uiState) {
is UiState.Loading -> CircularProgressIndicator()
is UiState.Success -> UserContent(state.user)
is UiState.Error -> ErrorMessage(state.message)
}
}
@Composable
fun UserContent(user: User) {
Column(modifier = Modifier.padding(16.dp)) {
Text(user.name, style = MaterialTheme.typography.titleLarge)
Text(user.email, style = MaterialTheme.typography.bodyMedium)
}
}
Side Effects
@Composable
fun UserDetailScreen(userId: String, viewModel: UserViewModel = hiltViewModel()) {
// Run once when userId changes
LaunchedEffect(userId) {
viewModel.loadUser(userId)
}
// Run on every recomposition
SideEffect {
analytics.trackScreen("UserDetail")
}
// Cleanup when leaving composition
DisposableEffect(Unit) {
val listener = viewModel.addListener()
onDispose {
listener.remove()
}
}
}
Testing
Unit Tests (JUnit 5)
class UserViewModelTest {
@Test
fun `loadUser updates state to success`() = runTest {
val repository = mockk<UserRepository>()
coEvery { repository.getUser("123") } returns User("123", "test@example.com")
val viewModel = UserViewModel(repository)
viewModel.loadUser("123")
assertEquals(
UiState.Success(User("123", "test@example.com")),
viewModel.uiState.value
)
}
@Test
fun `loadUser updates state to error on failure`() = runTest {
val repository = mockk<UserRepository>()
coEvery { repository.getUser(any()) } throws IOException("Network error")
val viewModel = UserViewModel(repository)
viewModel.loadUser("123")
assertTrue(viewModel.uiState.value is UiState.Error)
}
}
Compose UI Tests
class UserScreenTest {
@get:Rule
val composeTestRule = createComposeRule()
@Test
fun displaysUserName() {
val user = User("1", "test@example.com", "John Doe")
composeTestRule.setContent {
MyAppTheme {
UserContent(user = user)
}
}
composeTestRule.onNodeWithText("John Doe").assertIsDisplayed()
composeTestRule.onNodeWithText("test@example.com").assertIsDisplayed()
}
@Test
fun buttonClickIncrementsCounter() {
composeTestRule.setContent {
MyAppTheme {
Counter()
}
}
composeTestRule.onNodeWithText("Count: 0").assertIsDisplayed()
composeTestRule.onNodeWithText("Increment").performClick()
composeTestRule.onNodeWithText("Count: 1").assertIsDisplayed()
}
}
Tooling
# Build
./gradlew build
./gradlew assembleDebug
./gradlew assembleRelease
# Run tests
./gradlew test # Unit tests
./gradlew connectedAndroidTest # Instrumented tests
# Linting
./gradlew detekt # Code smells
./gradlew ktlintCheck # Style check
./gradlew ktlintFormat # Auto-fix style
# Code analysis
./gradlew lint # Android Lint
# Clean
./gradlew clean
detekt.yml
build:
maxIssues: 0
complexity:
LongMethod:
threshold: 30
ComplexCondition:
threshold: 4
style:
MaxLineLength:
maxLineLength: 120
WildcardImport:
active: true
naming:
FunctionNaming:
functionPattern: '[a-z][a-zA-Z0-9]*'
.editorconfig (ktlint)
[*.{kt,kts}]
indent_size = 4
max_line_length = 120
ktlint_code_style = android_studio
