23.11.2024

Aula 113: Técnicas Avançadas de Gerenciamento de Estado

Nesta aula, vamos nos aprofundar em técnicas avançadas de gerenciamento de estado em Swift, focando em cenários frequentemente encontrados em aplicações complexas. Vamos abordar padrões como o padrão Observer, o framework Combine e o gerenciamento de estado no SwiftUI. Esses métodos ajudam a criar um código mais manutenível e escalável, especialmente em projetos maiores.

Padrão Observer

O padrão Observer permite criar uma dependência de um-para-muitos entre objetos. Quando um objeto muda de estado, todos os seus dependentes são notificados e atualizados automaticamente. Isso é útil em situações onde várias partes da interface do usuário precisam responder a mudanças de estado.

Aqui está uma implementação simples:

import Foundation

class PublicadorDeEvento {
    var observadores: [Observador] = []

    func inscrever(observador: Observador) {
        observadores.append(observador)
    }

    func cancelarInscricao(observador: Observador) {
        observadores.removeAll { $0 === observador }
    }

    func notificar() {
        for observador in observadores {
            observador.atualizar()
        }
    }
}

protocol Observador: AnyObject {
    func atualizar()
}

class ObservadorConcreto: Observador {
    func atualizar() {
        print("Observador foi notificado!")
    }
}

let publicador = PublicadorDeEvento()
let observador = ObservadorConcreto()

publicador.inscrever(observador: observador)

// Dispara uma mudança de estado
publicador.notificar()

Neste exemplo, PublicadorDeEvento é o sujeito e ObservadorConcreto é o observador. Sempre que chamamos notificar(), todos os observadores inscritos são atualizados.

Usando Combine para Gerenciamento de Estado

O framework Combine em Swift oferece uma maneira mais sofisticada de gerenciar estado e agilizar o fluxo de dados em sua aplicação. Ele permite que você crie e gerencie publicadores que qualquer parte de sua aplicação pode se inscrever.

Aqui está um exemplo:

import Combine
import Foundation

class ModeloDeVisualizacao: ObservableObject {
    @Published var contagem: Int = 0
}

class Assinante {
    var cancelavel: AnyCancellable?

    init(modeloDeVisualizacao: ModeloDeVisualizacao) {
        cancelavel = modeloDeVisualizacao.$contagem
            .sink { novaContagem in
                print("Contagem atualizada para \(novaContagem)")
            }
    }
}

let modeloDeVisualizacao = ModeloDeVisualizacao()
let assinante = Assinante(modeloDeVisualizacao: modeloDeVisualizacao)

modeloDeVisualizacao.contagem += 1   // Isso vai acionar a instrução de impressão e notificar o assinante

Neste exemplo, usamos @Published para marcar a propriedade contagem no Modelo de Visualização. Quando a contagem muda, isso aciona automaticamente o fechamento sink no assinante. Isso cria um fluxo de dados reativo, facilitando o gerenciamento e a resposta às mudanças de estado.

Gerenciamento de Estado no SwiftUI

O SwiftUI adota uma abordagem declarativa para a construção de interfaces de usuário. O gerenciamento de estado é tratado de maneira integrada usando propriedades como @State, @Binding e @EnvironmentObject.

Aqui está um exemplo demonstrando como gerenciar estado no SwiftUI:

import SwiftUI

struct ContentView: View {
    @State private var contagem: Int = 0

    var body: some View {
        VStack {
            Text("Contagem: \(contagem)")
                .font(.largeTitle)
            Button(action: { contagem += 1 }) {
                Text("Aumentar Contagem")
            }
        }
        .padding()
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

Neste simples exemplo de SwiftUI, o wrapper de propriedade @State permite que o SwiftUI monitore mudanças na contagem. Quando o botão é pressionado e a contagem é atualizada, a visualização é automaticamente atualizada para refletir o novo estado.

Conclusão

Nesta aula, exploramos técnicas avançadas de gerenciamento de estado em Swift, variando do padrão Observer ao framework Combine e ao tratamento de estado no SwiftUI. Compreender essas técnicas permite que você construa aplicações responsivas e manuteníveis.

Seja trabalhando em um projeto simples ou em uma aplicação de grande escala, o gerenciamento eficiente de estado é crucial para oferecer uma experiência do usuário fluida. Experimente os exemplos fornecidos e adapte-os às suas necessidades específicas!

Video

Navigation