Android App Development with Kotlin: 2026 Best Practices

📋 Table of Contents

• 1. Jetpack Compose in Production
• 2. Architecture: MVVM + Clean Architecture
• 3. Dependency Injection with Hilt and Koin
• 4. Kotlin Multiplatform for Shared Logic
• 5. Networking and Data Layer
• 6. Performance Optimization
• 7. Testing Strategy
• 8. The 2026 Android Toolchain
• 9. FAQ

@Composable
fun OrdersScreen(
    viewModel: OrdersViewModel = hiltViewModel()
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text("Orders") },
                actions = {
                    FilterChip(
                        selected = uiState.filter != OrderFilter.ALL,
                        onClick = { viewModel.toggleFilter() },
                        label = { Text(uiState.filter.label) }
                    )
                }
            )
        }
    ) { padding ->
        when (val state = uiState) {
            is OrdersUiState.Loading -> LoadingIndicator(Modifier.padding(padding))
            is OrdersUiState.Error -> ErrorMessage(
                message = state.message,
                onRetry = viewModel::retry,
                modifier = Modifier.padding(padding)
            )
            is OrdersUiState.Success -> OrdersList(
                orders = state.orders,
                onOrderClick = viewModel::onOrderSelected,
                modifier = Modifier.padding(padding)
            )
        }
    }
}

@Composable
private fun OrdersList(
    orders: List<Order>,
    onOrderClick: (String) -> Unit,
    modifier: Modifier = Modifier
) {
    LazyColumn(
        modifier = modifier,
        contentPadding = PaddingValues(16.dp),
        verticalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        items(orders, key = { it.id }) { order ->
            OrderCard(
                order = order,
                onClick = { onOrderClick(order.id) },
                modifier = Modifier.animateItem()
            )
        }
    }
}

// ViewModel — UI state management
@HiltViewModel
class OrdersViewModel @Inject constructor(
    private val getOrdersUseCase: GetOrdersUseCase
) : ViewModel() {

    private val filter = MutableStateFlow(OrderFilter.ALL)

    val uiState: StateFlow<OrdersUiState> = filter
        .flatMapLatest { f -> getOrdersUseCase(f) }
        .map { orders -> OrdersUiState.Success(orders) as OrdersUiState }
        .catch { e -> emit(OrdersUiState.Error(e.message ?: "Unknown error")) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), OrdersUiState.Loading)

    fun toggleFilter() {
        filter.update { current ->
            when (current) {
                OrderFilter.ALL -> OrderFilter.PENDING
                OrderFilter.PENDING -> OrderFilter.COMPLETED
                OrderFilter.COMPLETED -> OrderFilter.ALL
            }
        }
    }
}

// Use case — business logic
class GetOrdersUseCase @Inject constructor(
    private val orderRepository: OrderRepository
) {
    operator fun invoke(filter: OrderFilter): Flow<List<Order>> {
        return orderRepository.observeOrders()
            .map { orders ->
                when (filter) {
                    OrderFilter.ALL -> orders
                    OrderFilter.PENDING -> orders.filter { it.status == Status.PENDING }
                    OrderFilter.COMPLETED -> orders.filter { it.status == Status.COMPLETED }
                }
            }
    }
}

// Repository — data access abstraction
class OrderRepositoryImpl @Inject constructor(
    private val api: OrderApi,
    private val dao: OrderDao
) : OrderRepository {

    override fun observeOrders(): Flow<List<Order>> = dao.observeAll()
        .onStart { refreshFromNetwork() }

    private suspend fun refreshFromNetwork() {
        try {
            val remote = api.getOrders()
            dao.upsertAll(remote.map { it.toEntity() })
        } catch (e: IOException) {
            // Offline — use cached data
        }
    }
}

// Shared KMP module — used by Android (Compose) and iOS (SwiftUI)

// commonMain/src
class OrderRepository(
    private val api: OrderApi,
    private val database: OrderDatabase
) {
    fun getOrders(): Flow<List<Order>> = database.observeOrders()
        .onStart { syncFromServer() }

    suspend fun syncFromServer() {
        val remote = api.fetchOrders()
        database.upsert(remote)
    }
}

// Shared ViewModel (using KMP-friendly approach)
class OrdersSharedViewModel(
    private val repository: OrderRepository
) {
    val orders: StateFlow<List<Order>> = repository.getOrders()
        .stateIn(CoroutineScope(Dispatchers.Default), SharingStarted.Lazily, emptyList())
}

// Android consumes it with Compose
@Composable
fun OrdersScreen(viewModel: OrdersSharedViewModel = koinViewModel()) {
    val orders by viewModel.orders.collectAsStateWithLifecycle()
    // ... Compose UI
}

// iOS consumes it with SwiftUI
// struct OrdersView: View {
//     @StateObject var viewModel = OrdersSharedViewModel()
//     var body: some View { List(viewModel.orders) { ... } }
// }

// Offline-first repository pattern with Room
@Dao
interface OrderDao {
    @Query("SELECT * FROM orders ORDER BY created_at DESC")
    fun observeAll(): Flow<List<OrderEntity>>

    @Upsert
    suspend fun upsertAll(orders: List<OrderEntity>)
}

class OrderRepositoryImpl @Inject constructor(
    private val api: OrderApi,
    private val dao: OrderDao,
    private val dispatcher: CoroutineDispatcher = Dispatchers.IO
) : OrderRepository {

    // Single source of truth: always read from local DB
    override fun observeOrders(): Flow<List<Order>> =
        dao.observeAll().map { entities -> entities.map { it.toDomain() } }

    // Sync from network — update local DB, observers get notified
    override suspend fun sync(): Result<Unit> = withContext(dispatcher) {
        runCatching {
            val response = api.getOrders()
            dao.upsertAll(response.map { it.toEntity() })
        }
    }
}

// ❌ Bad — lambda recreated every recomposition
@Composable
fun ParentScreen(viewModel: ParentViewModel) {
    val items by viewModel.items.collectAsStateWithLifecycle()

    LazyColumn {
        items(items) { item ->
            // This lambda is recreated on every recomposition of ParentScreen
            ItemCard(item = item, onClick = { viewModel.onItemClick(item.id) })
        }
    }
}

// ✅ Better — stable lambda reference
@Composable
fun ParentScreen(viewModel: ParentViewModel) {
    val items by viewModel.items.collectAsStateWithLifecycle()
    val onItemClick = viewModel::onItemClick  // stable reference

    LazyColumn {
        items(items, key = { it.id }) { item ->
            ItemCard(item = item, onClick = { onItemClick(item.id) })
        }
    }
}

// Unit test — ViewModel logic
class OrdersViewModelTest {
    private val fakeRepository = FakeOrderRepository()
    private lateinit var viewModel: OrdersViewModel

    @Before
    fun setup() {
        viewModel = OrdersViewModel(GetOrdersUseCase(fakeRepository))
    }

    @Test
    fun `initial state is loading`() = runTest {
        val state = viewModel.uiState.first()
        assertThat(state).isInstanceOf(OrdersUiState.Loading::class.java)
    }

    @Test
    fun `orders loaded successfully`() = runTest {
        fakeRepository.emit(listOf(Order(id = "1", total = 99.0)))
        val state = viewModel.uiState.first { it is OrdersUiState.Success }
        assertThat((state as OrdersUiState.Success).orders).hasSize(1)
    }
}

// Compose UI test
class OrdersScreenTest {
    @get:Rule
    val composeTestRule = createComposeRule()

    @Test
    fun `displays order list when loaded`() {
        val orders = listOf(Order(id = "1", title = "Order #1001", total = 49.99))

        composeTestRule.setContent {
            OrdersList(orders = orders, onOrderClick = {})
        }

        composeTestRule.onNodeWithText("Order #1001").assertIsDisplayed()
        composeTestRule.onNodeWithText("$49.99").assertIsDisplayed()
    }
}

Related Articles