Do you have experience working with projects implemented using clean architecture?

Yes, there is.

When developing with clean architecture, I used the following layers:

• Domain Layer: Contains business logic and entities. It does not depend on other layers. Use Cases (interactors) and repository interfaces are defined.
• Data Layer: Implements repository interfaces from the Data Layer. Includes working with data (network, databases, SharedPreferences). Repositories are often used to transform data from external sources into domain entities.
• Presentation Layer: Contains View (Fragment, Activity) and Presenter/ViewModel. Responsible for displaying data and user interaction. Calls Use Cases from the Domain Layer.

Dependencies between layers:

• Presentation Layer depends on Domain Layer.
• Data Layer depends on Domain Layer.

Patterns and principles used in clean architecture:

• SOLID: Especially the Dependency Inversion Principle.
• Dependency Injection: To simplify testing and dependency management (e.g., using Dagger, Koin).
• Repository Pattern: Abstraction over data sources.
• Use Cases (Interactors): Represent specific operations in business logic.

Example project structure:

├── app
│   ├── build.gradle
│   └── src
│       └── main
│           ├── java
│           │   └── com
│           │       └── example
│           │           └── myapp
│           │               ├── data // Repository implementations, data sources
│           │               │   ├── datasource
│           │               │   └── repository
│           │               ├── domain // Business logic, Use Cases, entities, repository interfaces
│           │               │   ├── entity
│           │               │   ├── repository
│           │               │   └── usecase
│           │               └── presentation // View layer, ViewModel/Presenter
│           │                   ├── ui
│           │                   └── viewmodel
│           └── res

Interaction between layers:

1. View calls ViewModel method.
2. ViewModel calls the corresponding Use Case (business logic).
3. Use Case interacts with repository interfaces from the Domain Layer.
4. Repository implementations (in Data Layer) fetch data from sources (network, database).
5. Repositories transform data into domain entities and return them to the Use Case.
6. Use Case processes data and returns the result to ViewModel.
7. ViewModel updates data, which is displayed on the View.

Using clean architecture allows:

• Improved testability: Each layer can be tested in isolation.
• Increased maintainability: Changes in one layer minimally affect others.
• Greater flexibility: Easier to replace data source implementations or UI presentation.
• Reduced coupling: Separation of business logic from implementation details.