Arquitetura orientada a eventos em Swift: transformando código em uma orquestra de eventos

Por que seu aplicativo Swift precisa de uma arquitetura orientada a eventos?

Imagine que você é o maestro de uma orquestra. Cada músico espera sua parte para entrar no momento certo. Se os violinistas tocassem tudo de uma vez — resultaria em caos. É mais ou menos assim que funciona a arquitetura orientada a eventos em Swift: cada módulo reage apenas a eventos específicos, em vez de puxar os fios de outros módulos diretamente.

Quando me deparei pela primeira vez com a programação orientada a eventos em Swift em um projeto comercial, percebi o quão poderosa essa ferramenta é. Um aplicativo de entrega de comida: o usuário clicou no botão "Pedir" — isso é um evento. O carrinho foi atualizado — evento. Chegou um push com o entregador — evento. Cada módulo (UI, rede, BD local) simplesmente se inscreve nos eventos necessários e funciona de forma independente. Isso é a arquitetura orientada a eventos.

Neste artigo, vamos analisar três abordagens para implementar a arquitetura de eventos em Swift: delegates clássicos, NotificationCenter e um barramento de eventos personalizado. Você verá código real, entenderá quando usar cada um e poderá aplicar imediatamente no seu projeto. Vamos lá!

Fundamentos da abordagem orientada a eventos em Swift

O que é um evento no contexto do Swift?

Um evento é um sinal de que algo aconteceu. Pode ser:

• Entrada do usuário (botão pressionado, texto alterado)
• Alteração de dados (dados recebidos do servidor, BD atualizado)
• Notificações do sistema (aplicativo foi para segundo plano, teclado apareceu)

O princípio principal da arquitetura orientada a eventos em Swift é o acoplamento fraco (loose coupling). O emissor do evento não sabe quem irá processá-lo. O receptor não sabe quem o enviou. Eles se comunicam através de um barramento de eventos — isso torna o código flexível e testável.

Padrão Observer — a base dos eventos

O padrão Observer em Swift está na base de qualquer sistema orientado a eventos. Temos um objeto editor (Publisher) e vários assinantes (Subscribers). Quando o editor muda de estado, ele notifica todos os assinantes.

Em Swift, existem vários mecanismos integrados para isso:

• NotificationCenter — barramento de eventos global no iOS SDK
• Delegates — um-para-um, mas com controle
• Combine — framework reativo da Apple (iOS 13+)
• Implementações personalizadas — controle total sobre o comportamento

Vamos analisar cada abordagem com exemplos.

Método 1. Delegates: o clássico do gênero

Delegates em Swift são a maneira mais simples de implementar um evento. É adequado para relações "um-para-um", quando um objeto informa outro sobre seu estado.

Exemplo: imagine que temos um carregador de imagens que deve notificar o controlador sobre a conclusão.

// 1. Definimos o protocolo do delegateprotocol ImageLoaderDelegate: AnyObject {    func imageLoader(_ loader: ImageLoader, didLoad image: UIImage)    func imageLoader(_ loader: ImageLoader, didFailWith error: Error)}

// 2. Classe editoraclass ImageLoader {    weak var delegate: ImageLoaderDelegate?

    func loadImage(from url: URL) {        URLSession.shared.dataTask(with: url) { [weak self] data, _, error in            DispatchQueue.main.async {                if let error = error {                    self?.delegate?.imageLoader(self!, didFailWith: error)                } else if let data = data, let image = UIImage(data: data) {                    self?.delegate?.imageLoader(self!, didLoad: image)                }            }        }.resume()    }}

// 3. Controlador assinanteclass ViewController: UIViewController, ImageLoaderDelegate {    let loader = ImageLoader()    @IBOutlet weak var imageView: UIImageView!

    override func viewDidLoad() {        super.viewDidLoad()        lo