Build one Android app while learning the full modern stack.

Project setup and file map

Create a new Android Studio project using Empty Activity, Kotlin, and Jetpack Compose. Name it FieldNotes. Run the default app once before adding architecture, networking, DI, KMP, or ML.

Kotlin fundamentals for Android

Start with the smallest data model. This teaches immutable values, data classes, sealed interfaces, and pure functions.

data class FieldNote(
    val id: Long,
    val title: String,
    val body: String,
    val status: NoteStatus = NoteStatus.Open
)

sealed interface NoteStatus {
    data object Open : NoteStatus
    data object Done : NoteStatus
    data class Blocked(val reason: String) : NoteStatus
}

fun FieldNote.isValid(): Boolean {
    return title.trim().length >= 3 && body.trim().isNotEmpty()
}

Jetpack Compose UI, state, and navigation

Compose is declarative: state goes in, UI comes out. Build a list screen before adding architecture.

@Composable
fun NotesScreen(
    notes: List<FieldNote>,
    title: String,
    onTitleChange: (String) -> Unit,
    onAdd: () -> Unit
) {
    Column(modifier = Modifier.padding(16.dp)) {
        OutlinedTextField(
            value = title,
            onValueChange = onTitleChange,
            label = { Text("Note title") }
        )
        Button(enabled = title.trim().length >= 3, onClick = onAdd) {
            Text("Add note")
        }
        LazyColumn {
            items(notes, key = { it.id }) { note ->
                Text(note.title)
            }
        }
    }
}

Coroutines: async work without blocking UI

Use suspending functions for work that may take time. Keep blocking work away from the main thread.

interface NotesRepository {
    suspend fun loadNotes(): List<FieldNote>
    suspend fun saveNote(note: FieldNote)
}

class FakeNotesRepository : NotesRepository {
    private val notes = mutableListOf<FieldNote>()

    override suspend fun loadNotes(): List<FieldNote> {
        delay(300)
        return notes.toList()
    }

    override suspend fun saveNote(note: FieldNote) {
        delay(100)
        notes += note
    }
}

Flow and StateFlow: reactive app data

Use Flow for streams of values and StateFlow for current UI state. A ViewModel can collect repository changes and expose a stable state object.

class ReactiveNotesRepository {
    private val notes = MutableStateFlow<List<FieldNote>>(emptyList())

    fun observeNotes(): StateFlow<List<FieldNote>> = notes.asStateFlow()

    suspend fun add(note: FieldNote) {
        notes.update { current -> current + note }
    }
}

class NotesViewModel(
    private val repository: ReactiveNotesRepository
) : ViewModel() {
    val notes: StateFlow<List<FieldNote>> = repository.observeNotes()
}

LiveData: lifecycle-aware observable state

Modern Compose apps usually prefer StateFlow, but LiveData still appears in many Android codebases. Learn it so you can work with existing apps.

class LegacyNotesViewModel : ViewModel() {
    private val _title = MutableLiveData("")
    val title: LiveData<String> = _title

    fun updateTitle(value: String) {
        _title.value = value
    }
}

@Composable
fun LegacyTitle(viewModel: LegacyNotesViewModel) {
    val title by viewModel.title.observeAsState("")
    Text("Current title: $title")
}

MVVM: screen state with ViewModel

MVVM keeps UI rendering separate from data decisions. The screen emits events; the ViewModel changes state.

data class NotesUiState(
    val title: String = "",
    val notes: List<FieldNote> = emptyList(),
    val isLoading: Boolean = false,
    val error: String? = null
)

class NotesViewModel(
    private val repository: ReactiveNotesRepository
) : ViewModel() {
    private val _uiState = MutableStateFlow(NotesUiState())
    val uiState = _uiState.asStateFlow()

    fun onTitleChange(value: String) {
        _uiState.update { it.copy(title = value) }
    }
}

MVI: intents, reducer, and one-way state

MVI is useful when screen behavior becomes complex. Define user intents, reduce them into state, and keep side effects explicit.

sealed interface NotesIntent {
    data class TitleChanged(val value: String) : NotesIntent
    data object AddClicked : NotesIntent
    data class NoteClicked(val id: Long) : NotesIntent
}

fun reduce(state: NotesUiState, intent: NotesIntent): NotesUiState {
    return when (intent) {
        is NotesIntent.TitleChanged -> state.copy(title = intent.value)
        NotesIntent.AddClicked -> state.copy(isLoading = true)
        is NotesIntent.NoteClicked -> state
    }
}

Dagger 2 and Hilt: dependency injection

Dagger 2 teaches the underlying dependency graph. Hilt is the recommended Android integration for most apps because it reduces manual component wiring.

// Dagger-style concept
@Module
class RepositoryModule {
    @Provides
    fun provideRepository(): NotesRepository {
        return FakeNotesRepository()
    }
}

@Component(modules = [RepositoryModule::class])
interface AppComponent {
    fun repository(): NotesRepository
}

// Hilt-style Android implementation
@HiltAndroidApp
class FieldNotesApp : Application()

@Module
@InstallIn(SingletonComponent::class)
object AppModule {
    @Provides
    fun provideRepository(): NotesRepository = FakeNotesRepository()
}

@HiltViewModel
class NotesViewModel @Inject constructor(
    private val repository: NotesRepository
) : ViewModel()

Testing: Kotlin, coroutines, ViewModel, Compose, DI

Test the behavior that can break product flows. Do not test every line mechanically.

@Test
fun titleChangeUpdatesUiState() = runTest {
    val viewModel = NotesViewModel(FakeNotesRepository())

    viewModel.onTitleChange("Visit clinic")

    assertEquals("Visit clinic", viewModel.uiState.value.title)
}

@Test
fun invalidShortTitleIsRejected() {
    val note = FieldNote(1, "No", "Body")

    assertFalse(note.isValid())
}

@Test
fun addButtonIsDisabledForShortTitle() {
    composeTestRule.setContent {
        NotesScreen(notes = emptyList(), title = "No", onTitleChange = {}, onAdd = {})
    }

    composeTestRule.onNodeWithText("Add note").assertIsNotEnabled()
}

KMP: share business rules, not Android UI

Kotlin Multiplatform is strongest when shared code is stable business logic. Do not start by sharing Compose UI unless the product and team are ready for that complexity.

// shared/src/commonMain/kotlin/NoteRules.kt
object NoteRules {
    fun validateTitle(value: String): ValidationResult {
        return when {
            value.trim().isEmpty() -> ValidationResult.Invalid("Title is required")
            value.trim().length < 3 -> ValidationResult.Invalid("Use at least 3 characters")
            else -> ValidationResult.Valid
        }
    }
}

sealed interface ValidationResult {
    data object Valid : ValidationResult
    data class Invalid(val reason: String) : ValidationResult
}

TensorFlow / LiteRT: on-device note classification

For Android apps, TensorFlow Lite is now presented through Google AI Edge LiteRT docs. Keep ML behind an interface so the rest of the app does not depend on model runtime details.

interface NoteClassifier {
    suspend fun classify(text: String): NoteLabel
}

enum class NoteLabel { Health, Education, Finance, General }

class FakeNoteClassifier : NoteClassifier {
    override suspend fun classify(text: String): NoteLabel {
        return when {
            "clinic" in text.lowercase() -> NoteLabel.Health
            "school" in text.lowercase() -> NoteLabel.Education
            "tax" in text.lowercase() -> NoteLabel.Finance
            else -> NoteLabel.General
        }
    }
}

CI/CD: build and test every change

A basic CI pipeline should compile, run unit tests, and upload reports. Release signing and Play deployment come later after the quality gate is stable.

name: Android CI

on:
  pull_request:
  push:
    branches: [ main, master ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          distribution: temurin
          java-version: 17
      - uses: gradle/actions/setup-gradle@v4
      - run: ./gradlew testDebugUnitTest
      - run: ./gradlew assembleDebug

Quizzes and drag-and-drop code ordering

Primary sources used for factual grounding