O que pode contar-me sobre arquitetura limpa?

A arquitetura limpa (Clean Architecture), popularizada por Robert Martin ("Tio Bob"), é um conjunto de princípios para organizar o código, visando criar um sistema flexível, testável e fácil de manter.

Ideias principais:

Separação em camadas: O código é dividido em círculos concêntricos, onde os círculos internos contêm a lógica de negócio, e os externos, os detalhes de implementação (UI, bases de dados, APIs externas).
Dependência das camadas internas: As camadas externas dependem das internas, mas não ao contrário. Isso é alcançado pelo princípio de inversão de dependências.
Encapsulamento: Cada camada oculta os detalhes de sua implementação das camadas externas.
Testabilidade: A lógica de negócio, localizada nas camadas centrais, não depende de detalhes externos, tornando-a facilmente testável em isolamento.
Independência de frameworks: As regras principais de negócio não estão atadas a frameworks específicos, UI ou bases de dados.

Exemplo de camadas:

Entidades: Contêm objetos de negócio e regras (por exemplo, a classe User com lógica de negócio relacionada ao usuário).
Casos de uso (Interactors): Contêm lógica de negócio específica da aplicação (por exemplo, GetUserUseCase). Orquestram a interação entre Entidades e Interfaces de Gateway.
Adaptadores de interface: Adaptam dados de fontes externas para um formato compreensível para os Casos de Uso e Entidades (por exemplo, Presenters para UI, Implementações de Gateway para bases de dados).
Frameworks e controladores: Camada externa que contém frameworks (UI, bases de dados, serviços web).

O princípio de inversão de dependências desempenha um papel fundamental. As camadas internas definem interfaces (Interfaces de Gateway), e as camadas externas implementam essas interfaces. Isso é ilustrado no esquema a seguir:

+-----------------+      +-------------------+      +--------------------+      +------------------------+
| Frameworks &    |----->|   Interface       |<-----|    Casos de Uso    |<-----|        Entidades     |
| Controladores (UI, DB)|  |   Adaptadores     |      |  (Interactors)     |      |  (Regras de negócio) |
+-----------------+      |  (Presentadores,  |      |                    |      +------------------------+
                         |  Implementações de Gateway|  |                    |
                         +-------------------+      +--------------------+

As setas indicam a direção das dependências. Todas apontam para dentro, para a camada de Entidades.

No desenvolvimento Android, a Clean Architecture é frequentemente implementada usando componentes como:

Camada UI (Apresentação): Activity, Fragment, ViewModel, lógica de UI. Depende da Camada de Domínio.
Camada de Domínio (Casos de Uso): Lógica de negócio da aplicação. Não depende de outras camadas.
Camada de Dados: Fontes de dados (redes, bases de dados), repositórios. Implementa interfaces definidas na Camada de Domínio.

Exemplo de estrutura:

raiz
├── app
│   ├── src
│   │   └── main
│   │       └── java
│   │           └── com
│   │               └── exemplo
│   │                   └── minhaapp
│   │                       ├── apresentação  // Camada UI (ViewModel, Activities, Fragments)
│   │                       │   ├── ui
│   │                       │   └── viewmodel
│   │                       ├── domínio      // Camada de Domínio (Casos de Uso, Entidades, Interfaces)
│   │                       │   ├── entidade
│   │                       │   ├── repositório  // Interfaces de Domínio
│   │                       │   └── usecase
│   │                       └── dados        // Camada de Dados (Repositórios, Fontes de Dados, Mappers)
│   │                           ├── local       // Fonte de Dados Local (Room)
│   │                           ├── remoto      // Fonte de Dados Remota (Retrofit)
│   │                           ├── mapeador
│   │                           └── repositório  // Implementações de Dados que estendem Interfaces de Domínio
│   └── build.gradle
└── build.gradle

Vantagens:

Testabilidade: A lógica de negócio é isolada e facilmente testável.
Flexibilidade: É fácil substituir dependências externas (por exemplo, trocar Room por Realm).
Manutenção: A clara separação de responsabilidades torna o código mais fácil de entender e manter.
Independência tecnológica: A lógica de negócio não está atada a frameworks ou bibliotecas específicas do Android.

Desvantagens:

Complexidade: Pode ser inicialmente mais difícil de entender e implementar, especialmente para projetos pequenos.
Mais código: Requer escrever mais classes e interfaces em comparação com arquiteturas mais simples.

No geral, a Clean Architecture é uma abordagem poderosa para criar aplicações Android escaláveis e fáceis de manter, especialmente para projetos de média e grande complexidade. Ela promove o desenvolvimento em torno da lógica de negócio, e não dos detalhes técnicos.