Kotlin Context Parameters: Eliminating Boilerplate in Android Architecture Layers

interface AppLogger {
    fun i(message: String)
    fun e(message: String, throwable: Throwable? = null)
}

// Declares a dependency on whatever AppLogger is in context
context(logger: AppLogger)
fun syncUsers(repository: UserRepository) {
    logger.i("Starting user sync")
    repository.sync()
}

// The caller declares the same context, so nothing is passed by hand
context(logger: AppLogger)
fun performFullSync(users: UserRepository, orders: OrderRepository) {
    syncUsers(users)
    syncOrders(orders)
    logger.i("Full sync complete")
}

// Anonymous: satisfies callees, not accessible by name
context(_: AppLogger)
fun logWelcome() {
    contextOf<AppLogger>().i("Welcome")
}

// At the edge, provide the value
fun runSync(logger: AppLogger, users: UserRepository, orders: OrderRepository) {
    context(logger) {
        performFullSync(users, orders)
    }
}

interface AppAnalytics {
    fun track(event: String, properties: Map<String, Any> = emptyMap())
}

interface TimeProvider {
    fun now(): Instant
}

// The constructor holds what the class owns
class OrderRepository(
    private val api: OrderApi,
    private val database: OrderDao
) {
    // The cross-cutting values arrive with the call
    context(logger: AppLogger, analytics: AppAnalytics, time: TimeProvider)
    suspend fun placeOrder(cart: Cart): OrderResult {
        logger.i("Placing order")
        val order = Order(items = cart.items, createdAt = time.now())

        return try {
            val confirmed = api.submitOrder(order)
            database.insert(confirmed)
            analytics.track("order_confirmed", mapOf("order_id" to confirmed.id))
            OrderResult.Success(confirmed)
        } catch (e: IOException) {
            logger.e("Order failed", e)
            analytics.track("order_failed")
            OrderResult.Failure(e)
        }
    }
}

@HiltViewModel
class OrderViewModel @Inject constructor(
    private val orderRepository: OrderRepository,
    private val cartRepository: CartRepository,
    // Injected once, provided as context below
    private val logger: AppLogger,
    private val analytics: AppAnalytics,
    private val timeProvider: TimeProvider
) : ViewModel() {

    private val _uiState = MutableStateFlow(OrderUiState())
    val uiState: StateFlow<OrderUiState> = _uiState.asStateFlow()

    fun placeOrder() {
        viewModelScope.launch {
            _uiState.update { it.copy(isPlacingOrder = true) }
            val cart = cartRepository.getActiveCart()

            // One call provides all three context values
            val result = context(logger, analytics, timeProvider) {
                orderRepository.placeOrder(cart)
            }

            _uiState.update {
                when (result) {
                    is OrderResult.Success ->
                        it.copy(isPlacingOrder = false, confirmedOrder = result.order)
                    is OrderResult.Failure ->
                        it.copy(isPlacingOrder = false, error = result.exception.message)
                }
            }
        }
    }
}

class RecordingLogger : AppLogger {
    val errors = mutableListOf<String>()
    override fun i(message: String) = Unit
    override fun e(message: String, throwable: Throwable?) {
        errors += message
    }
}

class RecordingAnalytics : AppAnalytics {
    val events = mutableListOf<String>()
    override fun track(event: String, properties: Map<String, Any>) {
        events += event
    }
}

class FixedTime(private val instant: Instant) : TimeProvider {
    override fun now() = instant
}

class OrderRepositoryTest {
    private val logger = RecordingLogger()
    private val analytics = RecordingAnalytics()
    private val time = FixedTime(Instant.parse("2026-10-11T00:00:00Z"))
    private val api = FakeOrderApi()
    private val repo = OrderRepository(api, FakeOrderDao())

    @Test
    fun `placeOrder tracks the confirmation`() = runTest {
        context(logger, analytics, time) {
            repo.placeOrder(cartOf("A", "B"))
        }

        assertEquals(listOf("order_confirmed"), analytics.events)
    }

    @Test
    fun `placeOrder logs and tracks a network failure`() = runTest {
        api.failWith(IOException("offline"))

        context(logger, analytics, time) {
            repo.placeOrder(cartOf("A"))
        }

        assertEquals(listOf("Order failed"), logger.errors)
        assertEquals(listOf("order_failed"), analytics.events)
    }
}