android10/Android-CleanArchitecture
Android CleanArchitecture
This is a reference implementation of Uncle Bob's clean architecture for Android, structured into distinct domain, data, and presentation layers. The project demonstrates how to organize an Android application around business use cases, keeping domain logic and entities free from framework dependencies.
The architecture enforces dependency inversion through layered separation, where inner domain layers define interfaces that outer layers implement. This approach enables repository abstractions for data source switching, presenter-view separation for testable UI logic, and use-case composition for handling complex business scenarios while maintaining single-responsibility boundaries.
The implementation supports testing each layer in isolation, with unit tests for domain and data layers that run without an emulator, and acceptance tests for the presentation layer. The project serves as a practical guide for structuring Android applications with clean architecture principles.
Features
- Repository Patterns - A pattern that decouples data sources from business logic by defining repository interfaces in the domain layer and implementing them in the data layer.
- Switching Mechanisms - Allows runtime or compile-time swapping of data sources (e.g., remote API vs. local cache) through repository implementations behind a common interface.
- Domain Models - Encapsulates core business rules and data structures in plain Java/Kotlin objects within the domain layer, free from framework dependencies.
- Android Implementations - Structuring an Android app into domain, data, and presentation layers following Uncle Bob's clean architecture principles for maintainable and testable code.
- Android Samples - A reference implementation of Uncle Bob's clean architecture for Android, with separated domain, data, and presentation layers.
- Reference Implementations - A reference implementation for structuring Android applications using clean architecture principles and layer separation.
- Domain Data Presentation Layers - Separate an application into domain, data, and presentation layers to enforce dependency inversion and isolate business logic.
- Presenter Patterns - A pattern that separates UI logic into presenters transforming domain data into view-ready state, enabling testability without Android framework coupling.
- Dependency Inversion Patterns - Enforces a strict dependency rule where inner layers define interfaces implemented by outer layers, keeping domain logic framework-agnostic.
- Android Implementations - An app structure that enforces dependency inversion by isolating business logic into distinct domain, data, and presentation layers.
- Logic Decoupling - Keep use cases and domain models free of framework dependencies to make them reusable and testable in pure code.
- Composed Use Case Flows - Combines multiple use cases within a single presentation flow to handle complex business scenarios while maintaining single-responsibility boundaries.
- Use Case Driven Architectures - An architecture that organizes application logic around business use cases orchestrating data flow between domain entities and external layers.
- Isolated Layer Testing - Run unit tests on domain and data layers without an emulator, and acceptance tests on the UI layer with a testing framework.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
