Clean Architecture in Android: Why It Matters and How to Apply It

┌─────────────────────────────────┐
│  Presentation (UI, ViewModel)   │  ← Depends on Domain
├─────────────────────────────────┤
│  Domain (Use Cases, Models)     │  ← Depends on nothing
├─────────────────────────────────┤
│  Data (Repository, DB, API)     │  ← Depends on Domain
└─────────────────────────────────┘

data class Task(
    val id: String,
    val title: String,
    val completed: Boolean,
    val dueDate: LocalDate?,
    val priority: Priority
) {
    // Business rules live here
    val isOverdue: Boolean get() = dueDate?.let { it < LocalDate.now() } ?: false
    
    fun complete(): Task = copy(completed = true)
}

// Domain defines the contract
interface TaskRepository {
    suspend fun getTasks(): List<Task>
    suspend fun getTask(id: String): Task?
    suspend fun createTask(task: Task)
    suspend fun updateTask(task: Task)
    suspend fun deleteTask(id: String)
    fun observeTasks(): Flow<List<Task>>
}

class CompleteTaskUseCase(private val repository: TaskRepository) {
    suspend operator fun invoke(taskId: String): Result<Task> {
        val task = repository.getTask(taskId)
            ?: return Result.failure(TaskNotFoundException(taskId))
        
        val completedTask = task.complete()
        repository.updateTask(completedTask)
        
        return Result.success(completedTask)
    }
}

class TaskRepositoryImpl(
    private val dao: TaskDao,
    private val apiService: TaskApiService,
    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
) : TaskRepository {
    
    override suspend fun getTasks(): List<Task> = withContext(ioDispatcher) {
        dao.getAllTasks().map { it.toDomain() }
    }
    
    override suspend fun createTask(task: Task) = withContext(ioDispatcher) {
        dao.insert(task.toEntity())
        // Also sync to API if online
        try {
            apiService.createTask(task.toDto())
        } catch (e: Exception) {
            // Queue for later sync
            pendingSyncDao.enqueue(SyncOperation.Create(task))
        }
    }
    
    override fun observeTasks(): Flow<List<Task>> =
        dao.observeAllTasks().map { entities -> entities.map { it.toDomain() } }
}

// Room entity → Domain model
fun TaskEntity.toDomain() = Task(
    id = id,
    title = title,
    completed = completed,
    dueDate = dueDate?.let { LocalDate.parse(it) },
    priority = Priority.valueOf(priority)
)

// Domain model → Room entity
fun Task.toEntity() = TaskEntity(
    id = id,
    title = title,
    completed = completed,
    dueDate = dueDate?.toString(),
    priority = priority.name
)

@HiltViewModel
class TaskViewModel @Inject constructor(
    private val getTasksUseCase: GetTasksUseCase,
    private val completeTaskUseCase: CompleteTaskUseCase,
    private val deleteTaskUseCase: DeleteTaskUseCase
) : ViewModel() {
    
    private val _uiState = MutableStateFlow<TaskUiState>(TaskUiState.Loading)
    val uiState: StateFlow<TaskUiState> = _uiState.asStateFlow()
    
    init {
        loadTasks()
    }
    
    private fun loadTasks() {
        viewModelScope.launch {
            getTasksUseCase()
                .onStart { _uiState.value = TaskUiState.Loading }
                .catch { e -> _uiState.value = TaskUiState.Error(e.message ?: "Unknown error") }
                .collect { tasks -> _uiState.value = TaskUiState.Success(tasks) }
        }
    }
    
    fun completeTask(taskId: String) {
        viewModelScope.launch {
            completeTaskUseCase(taskId)
                .onFailure { e -> /* show error snackbar */ }
        }
    }
}