Navegando pelo VIPER em SwiftUI: Construa seu próprio aplicativo de tarefas

Olá, leitores! Neste artigo, iremos abordar um dos Design Patterns mais interessantes para desenvolvimento em SwiftUI: o VIPER. O nosso objetivo é entender a sua essência e aplicá-lo na criação de um aplicativo de tarefas.

1. O que é VIPER?

VIPER é um acrônimo para View, Interactor, Presenter, Entity e Router. É um padrão de design que busca melhorar a organização do código por meio da responsabilidade única, onde cada módulo tem uma tarefa específica.

• View: A responsabilidade da View é exibir o que é dito pelo Presenter e transmitir as interações do usuário de volta para ele.
• Interactor: O Interactor contém a lógica de negócios específica de um módulo.
• Presenter: O Presenter atua sobre a View e o Interactor.
• Entity: As Entities são os objetos básicos que são usados pelo Interactor.
• Router: O Router lida com a navegação entre módulos.

2. Criando um aplicativo de tarefas com VIPER e SwiftUI

Agora que compreendemos o que cada componente faz em VIPER, vamos criar um aplicativo de tarefas. Vamos supor que temos um módulo chamado TasksModule, a estrutura seria assim:

/TasksModule
|-- /Entities
|   |-- Task.swift
|-- /Interactors
|   |-- FetchTasks.swift
|-- /Presenters
|   |-- TasksPresenter.swift
|-- /Views
|   |-- TasksView.swift
|-- /Routers
|   |-- TasksRouter.swift

Para o exemplo do nosso aplicativo, a entidade Task poderia ser algo como:

struct Task {
    let id: String
    let title: String
    let completed: Bool
}

Neste exemplo simples, Task é a entidade central do nosso aplicativo de tarefas, com um id, um título e uma propriedade booleana para verificar se a tarefa foi concluída.

Em seguida, temos o Interactor FetchTasks:

class FetchTasks {
    func execute() -> [Task] {
        // Aqui iríamos buscar as tarefas, possivelmente de um banco de dados ou serviço
    }
}

Na sequência, o TasksPresenter:

class TasksPresenter {
    let fetchTasks: FetchTasks
    weak var view: TasksView?

    init(fetchTasks: FetchTasks) {
        self.fetchTasks = fetchTasks
    }
    
    func viewDidLoad() {
        let tasks = fetchTasks.execute()
        view?.displayTasks(tasks)
    }
}

E então temos a TasksView:

struct TasksView: View {
    @ObservedObject var presenter: TasksPresenter

    var body: some View {
        List(presenter.tasks, id: \.id) { task in
            Text(task.title)
        }.onAppear(perform: presenter.viewDidLoad)
    }
}

Por último, o TasksRouter:

class TasksRouter {
    weak var currentView: TasksView?

    static func createModule() -> TasksView {
        let view = TasksView()
        
        let fetchTasks = FetchTasks()
        let presenter: TasksPresenter = TasksPresenter(fetchTasks: fetchTasks)
        
        fetchTasks.presenter = presenter
        presenter.view = view
        view.presenter = presenter
        
        return view
    }
}

Com este exemplo, demonstramos como a arquitetura VIPER pode ser utilizada em SwiftUI.

3. Conclusão

O padrão VIPER, quando aplicado corretamente, proporciona um alto nível de modularidade, tornando o código fácil de ler, manter e testar. Esperamos que este exemplo simples de um aplicativo de tarefas possa servir como ponto de partida para seus próprios projetos em SwiftUI.