Entendendo e Implementando o Design Pattern Clean Architecture em SwiftUI com Modularização

Neste artigo, iremos mergulhar no universo da programação com SwiftUI, compreendendo um dos principais Design Patterns de arquitetura de software: a Clean Architecture. Nosso foco será na sua aplicação em um contexto modularizado, utilizando como exemplo um aplicativo de futebol.

1. Introdução à Clean Architecture

Antes de partirmos para a prática, é crucial entendermos os fundamentos da Clean Architecture. Esse padrão, concebido por Robert C. Martin, também conhecido como Uncle Bob, propõe uma organização de código em camadas com dependências unidirecionais, de maneira que o núcleo do software - a regra de negócio - não dependa de frameworks, interfaces, banco de dados ou quaisquer agentes externos.

A Clean Architecture é composta, em geral, por três camadas:

• Entities: São os objetos que contém as regras de negócio essenciais, desprovidos de detalhes específicos da aplicação.
• Use Cases: Definem as ações que podem ser realizadas na aplicação. Eles orquestram o fluxo de dados até as entidades.
• Interface Adapters: Esta camada converte os dados de um formato utilizável pelos casos de uso e entidades para um formato apropriado para coisas como a web, o banco de dados, a interface do usuário, etc.

2. A Modularização em SwiftUI

Na prática, a modularização envolve a separação do código em módulos independentes, o que facilita a manutenção, a compreensão e o reuso. Em SwiftUI, um módulo pode ser um pacote Swift independente, uma framework ou até mesmo um componente de interface gráfica.

3. Aplicação Prática: Aplicativo de Futebol

Agora que temos uma compreensão básica dos conceitos, vamos criar um aplicativo de futebol utilizando a Clean Architecture e a modularização em SwiftUI.

Por questões de simplicidade, vamos assumir um módulo chamado FootballApp e dentro dele teremos uma estrutura similar à seguinte:

/FootballApp
|-- /Entities
|   |-- Player.swift
|   |-- Team.swift
|-- /UseCases
|   |-- ListTeams.swift
|   |-- GetTeamDetails.swift
|-- /InterfaceAdapters
|   |-- TeamListView.swift
|   |-- TeamDetailsView.swift

Nesse exemplo, Player e Team são as entidades, ListTeams e GetTeamDetails são os casos de uso, e TeamListView e TeamDetailsView são os adaptadores de interface.

Vamos considerar um exemplo do código para a entidade Player:

struct Player {
    let name: String
    let position: String
    let number: Int
}

Nessa estrutura simples, temos o nome do jogador, a posição em campo e o número da camisa. Isso é o que a Clean Architecture denomina de regra de negócio.

Agora, um exemplo de caso de uso poderia ser o ListTeams:

struct ListTeams {
    let teams: [Team]
    
    func execute() -> [Team] {
        return teams
    }
}

Por fim, TeamListView como adaptador de interface:

struct TeamListView: View {
    @ObservedObject var viewModel: TeamListViewModel

    var body: some View {
        List(viewModel.teams, id: \.id) { team in
            Text(team.name)
        }.onAppear(perform: viewModel.loadTeams)
    }
}

Perceba que cada parte do nosso código tem uma responsabilidade específica, facilitando a manutenção e o entendimento do sistema como um todo.

4. Conclusão

A Clean Architecture, quando bem aplicada, pode trazer uma série de benefícios para o desenvolvimento de software, facilitando a compreensão, manutenção e expansão do seu projeto. A modularização em SwiftUI reforça esses benefícios, permitindo que você construa aplicativos robustos e bem organizados.