Android-CleanArchitecture is a sample project demonstrating the implementation of Clean Architecture principles in Android app development. It showcases a layered architecture approach, separating concerns and promoting testability and maintainability in Android applications.

Pros

• Promotes separation of concerns and modularity
• Enhances testability of individual components
• Facilitates easier maintenance and scalability of the codebase
• Provides a clear structure for organizing code and dependencies

Cons

• Steeper learning curve for developers unfamiliar with Clean Architecture
• May introduce additional complexity for smaller projects
• Requires more initial setup and boilerplate code
• Can lead to over-engineering if not applied judiciously

Code Examples

1. Domain layer - Use case implementation:

class GetUserList(
    private val userRepository: UserRepository
) : UseCase<List<User>, Void?>() {

    override suspend fun run(params: Void?): Either<Failure, List<User>> =
        userRepository.users()
}

This code defines a use case for retrieving a list of users, demonstrating the separation of business logic from other layers.

2. Data layer - Repository implementation:

class UserDataRepository(
    private val mapper: UserMapper,
    private val networkHandler: NetworkHandler,
    private val service: UserService
) : UserRepository {

    override fun users(): Either<Failure, List<User>> {
        return when (networkHandler.isNetworkAvailable()) {
            true -> request(
                service.users(),
                { it.map { mapper.mapFromEntity(it) } },
                emptyList()
            )
            false, null -> Left(NetworkConnection)
        }
    }
}

This code shows a repository implementation that handles data retrieval and mapping between different layers.

3. Presentation layer - ViewModel implementation:

class UsersViewModel(
    private val getUserList: GetUserList
) : BaseViewModel() {

    private val _users = MutableLiveData<List<UserView>>()
    val users: LiveData<List<UserView>> = _users

    fun loadUsers() = launch {
        _users.value = getUserList(None()).fold(
            { emptyList() },
            { it.map { UserView(it.id, it.name, it.email) } }
        )
    }
}

This code demonstrates a ViewModel that interacts with the use case to load and present user data to the UI.

Getting Started

1. Clone the repository:

   git clone https://github.com/android10/Android-CleanArchitecture.git
   

2. Open the project in Android Studio.

3. Build and run the app on an emulator or physical device.

4. Explore the codebase to understand the Clean Architecture implementation.