1 / 18

🏛️ Android Clean Architecture

A Complete Beginner's Guide

🎯 What You'll Master:

  • Understanding Clean Architecture principles
  • Layer separation and responsibilities
  • Dependency rules and flow
  • Real Android implementation examples
  • Best practices and common patterns

🤔 What is Clean Architecture?

Clean Architecture is a software design approach that separates concerns into independent layers.

Created by: Robert C. Martin (Uncle Bob)

Goal: Make software independent of frameworks, UI, databases, and external agencies

🧪

Testable

Easy to write unit tests

🔧

Maintainable

Easy to modify and extend

🔒

Independent

Not tied to specific frameworks

😵 Problems Without Clean Architecture

❌ Traditional Approach

  • UI mixed with business logic
  • Hard to test components
  • Tightly coupled code
  • Database changes break everything
  • Difficult to add new features

✅ Clean Architecture

  • Clear separation of concerns
  • Easy unit testing
  • Loosely coupled components
  • Database independence
  • Feature additions are simple

🏗️ The Three Main Layers

📱 PRESENTATION LAYER

UI, Activities, Fragments, ViewModels

⬇️

💼 DOMAIN LAYER

Business Logic, Use Cases, Entities

⬇️

💾 DATA LAYER

Repositories, Data Sources, APIs, Database

📏 The Dependency Rule

Most Important Rule: Dependencies can only point inward!

Presentation
→
Domain
→
Data

✅ Allowed:

  • Presentation → Domain
  • Data → Domain

❌ Not Allowed:

  • Domain → Presentation
  • Domain → Data

💾 Data Layer - Deep Dive

Responsibilities:

// Data Layer Components 
interface UserRepository {
    suspend fun getUsers(): List<User>
    suspend fun getUserById(id: Int): User?
}

class UserRepositoryImpl(
    private val apiService: UserApiService,
    private val userDao: UserDao
) : UserRepository {
    
    override suspend fun getUsers(): List<User> {
        return try {
            val users = apiService.getUsers()
            userDao.insertUsers(users)
            users
        } catch (e: Exception) {
            userDao.getAllUsers()
        }
    }
}

💼 Domain Layer - Deep Dive

The Heart of Your App:

// Domain Layer Components
data class User(
    val id: Int,
    val name: String,
    val email: String
)

class GetUsersUseCase(
    private val userRepository: UserRepository
) {
    suspend operator fun invoke(): Result<List<User>> {
        return try {
            val users = userRepository.getUsers()
            Result.success(users)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

📱 Presentation Layer - Deep Dive

User Interface Components:

// Presentation Layer Components
class UserViewModel(
    private val getUsersUseCase: GetUsersUseCase
) : ViewModel() {
    
    private val _uiState = MutableStateFlow(UserUiState())
    val uiState = _uiState.asStateFlow()
    
    fun loadUsers() {
        viewModelScope.launch {
            _uiState.value = _uiState.value.copy(isLoading = true)
            
            getUsersUseCase().fold(
                onSuccess = { users ->
                    _uiState.value = _uiState.value.copy(
                        users = users,
                        isLoading = false
                    )
                },
                onFailure = { error ->
                    _uiState.value = _uiState.value.copy(
                        error = error.message,
                        isLoading = false
                    )
                }
            )
        }
    }
}

🎯 Use Cases Explained

Use Cases represent specific business operations

One Use Case = One Business Operation

Examples: Login User, Get User Profile, Update Settings, Send Message

🎯

Single Responsibility

Each use case has one clear purpose

🔄

Reusable

Can be used from multiple UI components

🧪

Testable

Easy to test business logic in isolation

💉 Dependency Injection

DI helps us follow the dependency rule

// Without DI (Bad)
class UserViewModel {
    private val repository = UserRepositoryImpl() // Hard dependency
}

// With DI (Good)
class UserViewModel(
    private val getUsersUseCase: GetUsersUseCase // Injected dependency
) : ViewModel()

// DI Module (using Hilt)
@Module
@InstallIn(ViewModelComponent::class)
object DomainModule {
    
    @Provides
    fun provideGetUsersUseCase(
        userRepository: UserRepository
    ): GetUsersUseCase {
        return GetUsersUseCase(userRepository)
    }
}

🔄 Complete Data Flow Example

1. User Action: User taps "Load Users" button in Activity
2. Presentation: Activity calls ViewModel.loadUsers()
3. Domain: ViewModel calls GetUsersUseCase.invoke()
4. Data: Use case calls UserRepository.getUsers()
5. Network/DB: Repository fetches data from API/Database
6. Return Data: Data flows back through the layers
7. Update UI: ViewModel updates UI state, Activity observes and updates UI

📚 Repository Pattern

Repository abstracts data access logic

Benefits: Single source of truth, caching logic, data source switching

interface UserRepository {
    suspend fun getUsers(): List<User>
    suspend fun getUserById(id: Int): User?
    suspend fun saveUser(user: User)
}

class UserRepositoryImpl(
    private val remoteDataSource: UserRemoteDataSource,
    private val localDataSource: UserLocalDataSource
) : UserRepository {
    
    override suspend fun getUsers(): List<User> {
        return if (isNetworkAvailable()) {
            val users = remoteDataSource.getUsers()
            localDataSource.cacheUsers(users)
            users
        } else {
            localDataSource.getCachedUsers()
        }
    }
}

⚠️ Error Handling in Clean Architecture

Each layer handles errors appropriately

// Domain Layer - Use Case with Result wrapper
class GetUsersUseCase(
    private val userRepository: UserRepository
) {
    suspend operator fun invoke(): Result<List<User>> {
        return try {
            val users = userRepository.getUsers()
            if (users.isEmpty()) {
                Result.failure(EmptyDataException())
            } else {
                Result.success(users)
            }
        } catch (e: NetworkException) {
            Result.failure(NetworkErrorException())
        } catch (e: Exception) {
            Result.failure(UnknownErrorException())
        }
    }
}

Best Practice: Use sealed classes or Result wrappers to handle success/error states

🧪 Testing Made Easy

Clean Architecture makes testing straightforward

🎯

Unit Tests

Test use cases and business logic independently

🔧

Integration Tests

Test repository implementations with mock data sources

📱

UI Tests

Test presentation layer with mocked use cases

// Testing Use Case
@Test
fun `when getUsersUseCase is called, then return users list`() = runTest {
    // Given
    val mockUsers = listOf(User(1, "John", "john@email.com"))
    val mockRepository = mockk<UserRepository>()
    coEvery { mockRepository.getUsers() } returns mockUsers
    
    val useCase = GetUsersUseCase(mockRepository)
    
    // When
    val result = useCase()
    
    // Then
    assertTrue(result.isSuccess)
    assertEquals(mockUsers, result.getOrNull())
}

📁 Project Structure

app/
├── presentation/
│   ├── ui/
│   │   ├── activities/
│   │   ├── fragments/
│   │   └── adapters/
│   ├── viewmodels/
│   └── di/
├── domain/
│   ├── entities/
│   ├── usecases/
│   └── repositories/ (interfaces)
└── data/
    ├── repositories/ (implementations)
    ├── datasources/
    │   ├── remote/
    │   └── local/
    ├── database/
    └── network/

Alternative: You can also organize by features (user/, product/, order/) with each having its own presentation/domain/data folders

❌ Common Mistakes to Avoid

❌ Don't Do This

  • Put Android dependencies in Domain layer
  • Let Domain layer know about UI
  • Create "God" use cases
  • Skip dependency injection
  • Mix business logic in ViewModels

✅ Do This Instead

  • Keep Domain layer pure Kotlin
  • Use abstractions and interfaces
  • Create focused, single-purpose use cases
  • Implement proper DI
  • Keep ViewModels as thin coordinators

🎉 Clean Architecture Benefits

🧪

Testability

Easy to write and maintain tests at all levels

🔧

Maintainability

Changes in one layer don't affect others

🚀

Scalability

Easy to add new features and team members

🔄

Flexibility

Easy to change databases, APIs, or UI frameworks

👥

Team Collaboration

Multiple developers can work on different layers

📚

Code Reuse

Use cases can be shared across different UIs

🚀 Ready to Get Started?

1. Start Small: Begin with a simple feature like user login
2. Create Layers: Set up your folder structure first
3. Define Entities: Start with your domain models
4. Create Use Cases: Implement your business logic
5. Build Repository: Abstract your data access
6. Setup DI: Use Hilt or Dagger for dependency injection
7. Connect UI: Wire everything together in your ViewModels

🎯 Pro Tips:

  • Don't over-engineer - start simple and refactor
  • Focus on the dependency rule above all
  • Write tests as you go
  • Use existing libraries that follow Clean Architecture

Happy Clean Coding! 🎉