SwiftUI no desenvolvimento móvel: o que é, conceitos-chave e como funciona

Fundamentos (View Protocol, body, some View, @ViewBuilder)

View Protocol é o protocolo central do SwiftUI. Requer uma única propriedade: var body: some View. body é uma propriedade computada que retorna a descrição da UI. O SwiftUI chama body em cada mudança de estado e renderiza o resultado na GPU.

@ViewBuilder

@ViewBuilder é um Result Builder para Views. Permite escrever múltiplas Views dentro de um closure sem return e sem TupleView. Suporta if/else, switch, ForEach. Todos os contêineres (VStack, HStack, ZStack, Group) usam @ViewBuilder. Uma alternativa é Group { … } para agrupar sem layout. some View é um Opaque Type. O compilador sabe o tipo concreto da View (Text, Button, VStack, etc.), mas retorna externamente como some View. Isso permite alterar o tipo do body sem mudar a assinatura. ViewModifier — modificador de View: .font(), .padding(), .background(). Modificador personalizado via ViewModifier protocol e .modifier().

// Exemplo de View com @ViewBuilder e NavigationStack
struct ContentView: View {
    @State private var items = ["Item 1", "Item 2"]

    var body: some View {
        NavigationStack {
            List(items, id: .self) { item in
                NavigationLink(item) {
                    DetailView(item: item)
                }
            }
            .navigationTitle("Items")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button("Add") {
                        items.append("New Item")
                    }
                }
            }
        }
    }
}

// DetailView com @StateObject
struct DetailView: View {
    let item: String
    @StateObject private var viewModel = DetailViewModel()

    var body: some View {
        Text(item)
            .task {
                await viewModel.loadDetails(for: item)
            }
    }
}

Modificadores e contêineres (ViewModifier, NavigationStack, List, Form)

NavigationStack (iOS 16+) — navegação baseada em dados. Recebe um caminho (array de valores hashable) e exibe o destino via navigationDestination. Substitui NavigationLink com views de destino. NavigationLink — botão para navegar pela pilha. List — lista vertical com seções, deslizes, exclusão e arrastar e soltar. Form — um List especializado para configurações: seções, seletores, interruptores, campos de texto. Section — agrupamento em List/Form com cabeçalho e rodapé. ViewModifier — modificadores personalizados para reutilizar estilos. .modifier(CustomModifier()) — aplicação.

List e Form em detalhes

List no SwiftUI é o equivalente ao UITableView. Suporta .onDelete, .onMove, .refreshable. SwipeActions — .swipeActions { Button("Excluir", role: .destructive) { } }. Form — otimizado para configurações: DatePicker, Toggle, Stepper, Picker. Section com header/footer — para agrupar. OutlineGroup — listas hierárquicas (equivalente ao UITableView com seções). DisclosureGroup — seção recolhível com conteúdo. A IT Sectr recomenda List para dados e Form para configurações.

PreviewProvider — protocolo para pré-visualizações no Xcode Canvas. Canvas — pré-visualização interativa do SwiftUI (requer @main e Swift 5.9+). @ScaledMetric — tamanho adaptável que escala com Dynamic Type.

Gerenciamento de estado (@StateObject, @ObservedObject, @EnvironmentObject, @FocusState)

Property Wrappers são a base do gerenciamento de estado no SwiftUI. @State — estado local (value type). @Binding — conexão com o estado pai. @StateObject — cria um ObservableObject. O SwiftUI gerencia o ciclo de vida do objeto. @ObservedObject — observa um ObservableObject externo. @EnvironmentObject — objeto do ambiente (injeção de dependência via .environmentObject()). @Environment — valores do sistema (.colorScheme, .locale). @AppStorage — UserDefaults. @FetchRequest — consulta do Core Data. @FocusState — foco de entrada.

@StateObject vs @ObservedObject: @StateObject cria um objeto, @ObservedObject o observa. Use @StateObject para a criação inicial do modelo na hierarquia, @ObservedObject para passar para views filhas. @FocusState — gerenciamento de foco: .focused($field, equals: .email). Suporta enum para vários campos.

Environment Values e DI

@Environment — valores do sistema: colorScheme, locale, sizeCategory, layoutDirection, managedObjectContext. Custom Environment Values — valor personalizado via EnvironmentKey. Usado para injeção de dependência: passar serviços sem parâmetros explícitos. Modificador .environment() — define um valor na hierarquia. @EnvironmentObject — ObservableObject de .environmentObject(). Difere do @Environment por passar um tipo por referência. A IT Sectr recomenda @Environment para valores do sistema e @EnvironmentObject para serviços.

Ciclo de vida (.task, .onAppear, .onDisappear)

.task{} — operação assíncrona ao aparecer a view. Cancelamento automático ao desaparecer. Substitui .onAppear para async/await. .onAppear{} — operação síncrona ao aparecer. .onDisappear{} — operação ao desaparecer. .onChange(of:) — reação a mudanças de valor. .onReceive(Publisher) — reação ao publicador do Combine. Ciclo de vida da View no SwiftUI: init → onAppear → body (renderização) → onDisappear. Ao mudar o estado: body → diff → re-renderização. A IT Sectr recomenda .task para carregamento assíncrono e .onAppear para analytics.

Animação no SwiftUI

.animation() — modificador de animação. .transition() — animação de aparecimento/desaparecimento. withAnimation — animação explícita de mudanças de estado. matchedGeometryEffect — animação entre diferentes views (hero animation). PhaseAnimator (iOS 17+) — animação multifase baseada em enum. KeyframeAnimator (iOS 17+) — animação quadro a quadro com keyframes. As animações do SwiftUI são executadas na GPU via Core Animation. A IT Sectr recomenda .spring() para animações naturais e .interpolatingSpring para efeitos físicos.

Fluxo de dados (Bindings, @Published, ObservableObject)

ObservableObject — protocolo para objetos com propriedades @Published. O SwiftUI se inscreve no publicador objectWillChange. @Published — publica mudanças de propriedade. @StateObject — cria ObservableObject, gerencia o ciclo de vida. @ObservedObject — observa externo. Combine — framework para programação reativa. @EnvironmentObject — DI via ambiente. .environmentObject() define, @EnvironmentObject lê. MVVM — arquitetura padrão: View (SwiftUI) — ViewModel (ObservableObject) — Model. A IT Sectr recomenda MVVM + @StateObject para ViewModels principais.

class UserViewModel: ObservableObject {
    @Published var users: [User] = []
    @Published var isLoading = false

    func loadUsers() async {
        isLoading = true
        defer { isLoading = false }
        do {
            users = try await api.fetchUsers()
        } catch {
            print("Erro: \(error)")
        }
    }
}

struct UsersView: View {
    @StateObject private var viewModel = UserViewModel()

    var body: some View {
        List(viewModel.users, id: \.id) { user in
            Text(user.name)
        }
        .task { await viewModel.loadUsers() }
        .overlay {
            if viewModel.isLoading { ProgressView() }
        }
    }
}

Acessibilidade e localização

Acessibilidade no SwiftUI: .accessibilityLabel(), .accessibilityHint(), .accessibilityValue(), .accessibilityAddTraits(). O VoiceOver lê os rótulos de acessibilidade. Dynamic Type — @ScaledMetric, @DynamicProperty. Localização: String(localized:) (SwiftUI + String Catalog). LocalizedStringKey — tradução automática. Regras de plural — via String Catalog (one, few, many, other). Right-to-Left (árabe, hebraico) — suportado automaticamente. .environment(.layoutDirection, .rightToLeft). A IT Sectr recomenda rótulos de acessibilidade para todos os elementos interativos.

struct AccessibleButton: View {
    let action: () -> Void

    var body: some View {
        Button(action: action) {
            Label("Settings", systemImage: "gear")
        }
        .accessibilityLabel("Open Settings")
        .accessibilityHint("Double tap to navigate to settings screen")
        .accessibilityAddTraits(.isButton)
    }
}

// Suporte a Dynamic Type
struct ScalableText: View {
    @ScaledMetric private var fontSize: CGFloat = 17

    var body: some View {
        Text("Hello, World!")
            .font(.system(size: fontSize))
    }
}

Gráficos e visualização (Swift Charts)

Swift Charts (iOS 16+) — framework para construir gráficos. Chart { } — contêiner básico. BarMark, LineMark, PointMark, AreaMark, RuleMark — marcas. ForEach para dados. ChartAxis — personalização de eixos. .chartXAxis, .chartYAxis. ChartLegend — legenda. Interpolação — catmullRom, linear, step. Animação — .animation() para Chart. A IT Sectr recomenda Swift Charts para gráficos integrados e Charts (DGCharts) para complexos.

import Charts

struct MonthlySales: Identifiable {
    let id = UUID()
    let month: String
    let sales: Double
}

struct SalesChart: View {
    let data: [MonthlySales]

    var body: some View {
        Chart(data) { item in
            BarMark(
                x: .value("Month", item.month),
                y: .value("Sales", item.sales)
            )
            .foregroundStyle(.blue.gradient)
        }
        .chartXAxisLabel("Month")
        .chartYAxisLabel("Sales")
        .frame(height: 200)
        .padding()
    }
}

Swift Package Manager (SPM) — o gerenciador de dependências da Apple. Integrado ao Xcode. Suporta: pacotes binários, recursos, testes, swift-6 strict concurrency. Publicação de pacotes via GitHub com tag semver. O SPM é o padrão de facto para dependências Swift, substituindo CocoaPods e Carthage. A IT Sectr recomenda SPM para todos os novos projetos.

Swift Concurrency (async/await, TaskGroup, AsyncSequence) — async/await incorporado ao Swift 5.5+. Task — unidade de assincronia. TaskGroup — tarefas paralelas. AsyncSequence — sequência assíncrona (AsyncStream, AsyncAlgorithms). Task Local Values — dados contextuais para Task. O Swift Concurrency substitui completamente o Combine para operações assíncronas.