Clean Architecture in Android

March 13, 2023 Adam Gardner

As an Android developer, one of the most critical challenges is to create an architecture that is scalable, maintainable, and easy to understand. Clean Architecture is an architectural approach that solves this problem by separating the application into layers that are loosely coupled, highly cohesive, and easily testable. In this blog post, we will explore how to implement Clean Architecture in Android with MVVM, Hilt, and Use Cases. We will also provide Kotlin code examples to help you understand each component better.

Clean Architecture:

Clean Architecture is an architectural approach that focuses on separating the application into layers, where each layer has a specific responsibility. The main principles of Clean Architecture are:

Separation of Concerns: Each layer of an application should have a specific responsibility.
Testability: Each layer should be testable in isolation.

Clean Architecture defines four layers, each with its own set of responsibilities:

Data: Entities represent the business logic of the application. Entities are the most abstract layer of the application and contain no platform-specific code. They are often represented as Kotlin data classes.
Use Cases: Use Cases contain single responsibility of business logic of the application. They act as intermediaries between the Presentation layer and the Domain layer. Use Cases are responsible for processing the input data, invoking the appropriate methods in the Domain layer, and returning the output to the Presentation layer.
Domain: Defines the core business entities and rules of the application, as well as any interfaces required to interact with external systems. Domain is where the most critical part of the application resides. It defines the use cases and the rules that govern the business logic. The Domain layer is independent of the platform and contains no platform-specific code.
Presentation: Presentation is the layer responsible for the user interface of the application. It interacts with the user and provides the necessary feedback to the user. Presentation is the most platform-specific layer of the application and contains all the UI-related code.

MVVM:

MVVM (Model-View-ViewModel) is a design pattern that separates the UI logic from the business logic of the application. MVVM consists of three components:

Model: The model contains the data and the business logic of the application.
View: The view is responsible for displaying the data to the user and receiving input from the user.
ViewModel: The ViewModel acts as an intermediary between the Model and the View. It is responsible for providing the data to the View and updating the Model when the user interacts with the View.

Hilt:

Hilt is a dependency injection library for Android that makes it easy to manage dependencies in your application. Hilt is built on top of Dagger, a popular dependency injection library for Java and Kotlin. Hilt provides several benefits, such as reducing boilerplate code, improving testability, and making it easier to refactor your code.

Flow of Clean Architecture

UI ──────────▶ Use Cases ──────────▶ Repository

◀─────────── Use Cases ◀─────────── Repository
                 ▲
                 │
           Entities

Kotlin Code Examples:

Let's take a look at some Kotlin code examples to understand how to implement Clean Architecture in Android with MVVM, Hilt, and Use Cases.

Use Cases

interface GetUserUseCase {
    suspend fun getUser(userId: String): User
}

class GetUserUseCaseImpl @Inject constructor(
    private val userRepository: UserRepository
) : GetUserUseCase {
    override suspend fun getUser(userId: String): User {
        return userRepository.getUser(userId)
    }
}

Repository

interface UserRepository {
    suspend fun getUser(userId: String): User
}

class UserRepositoryImpl @Inject constructor(
    private val userService: UserService
) : UserRepository {
    override suspend fun getUser(userId: String): User {
        val userResponse = userService.getUser(userId)
        return User(userResponse.id, userResponse.name, userResponse.email)
    }
}

Presentation

class UserViewModel @Inject constructor(
    private val getUserUseCase: GetUserUseCase
) : ViewModel() {
    private val _user = MutableLiveData<User>()
    val user: LiveData<User> = _user

    fun getUser(userId: String) {
        viewModelScope.launch {
            val user = getUserUseCase.getUser(userId)
            _user.value = user
        }
    }
}

Domain

data class User(
    val id: String,
    val name: String,
    val email: String
)

interface UserRepository {
    suspend fun getUser(userId: String): User
}

class UserRepositoryImpl @Inject constructor(
    private val userService: UserService
) : UserRepository {
    override suspend fun getUser(userId: String): User {
        val userResponse = userService.getUser(userId)
        return User(userResponse.id, userResponse.name, userResponse.email)
    }
}