UIKit — o que é, conceitos-chave e arquitetura

O que é UIKit?

UIKit é um framework da Apple que fornece classes para criar e gerir interfaces de utilizador em iOS, iPadOS e macOS (através do Mac Catalyst). Funciona sobre Core Animation, Core Graphics e Quartz Core, abstraindo a renderização de baixo nível em objetos de alto nível — botões, etiquetas, imagens e contentores. A UIKit estreou com o iPhone OS 1 em 2007 e continua a ser o framework principal para desenvolvimento iOS juntamente com o SwiftUI.

O framework segue uma abordagem imperativa: o programador cria instâncias das classes UIButton, UILabel, UIImageView, define as suas propriedades (cor, fonte, posição) e adiciona-as à hierarquia de vistas através de addSubview. Cada alteração na interface é feita explicitamente — sem atualizações mágicas nos bastidores. Isto distingue a UIKit dos frameworks declarativos como o SwiftUI, onde a descrição do estado redesenha automaticamente a interface.

Classes principais da UIKit

O framework inclui várias categorias de classes. UIView é o elemento base do qual todos os componentes visuais herdam. UIWindow é o contentor de topo através do qual as vistas são exibidas no ecrã. UIViewController gere um conjunto de vistas e responde a rotações do ecrã, aparecimento do teclado e notificações do sistema. UIApplication é o ponto de entrada que processa eventos de toque e pressões de botões.

Para texto, são usados UILabel (texto estático), UITextField (entrada de uma linha), UITextView (entrada multilinha). Para botões — UIButton, incluindo botões de sistema, personalizados e com iconografia SF Symbols. Para navegação — UINavigationController, UITabBarController e UISplitViewController. No total, a UIKit tem mais de 200 classes públicas.

Arquitetura da UIKit: camadas e hierarquia de vistas

A arquitetura da UIKit é construída em camadas: cada camada é responsável por um aspeto da exibição. No nível mais baixo está o Core Graphics — o motor de renderização de caminhos, texto e imagens. Acima está o Core Animation, que gere a composição de camadas (CALayer) e animações entre estados. A UIKit constrói uma API orientada a objetos sobre eles: UIView, UIViewController e UIResponder.

Cada aplicação tem uma hierarquia de vistas — uma árvore cuja raiz é a UIWindow. Abaixo está o UIViewController raiz, a sua vista e as subvistas aninhadas no seu interior. Os eventos de toque propagam-se ao longo da cadeia de resposta: desde a vista mais aninhada até aos seus pais e até UIApplication. Se nenhum objeto tratar o toque, este é ignorado.

UIView e CALayer

Cada UIView contém uma CALayer que trata da renderização de pixéis no ecrã. A vista gere os toques e a acessibilidade; a camada trata dos gráficos — sombra, cornerRadius, borda, transform. Esta separação permite descarregar gráficos pesados para uma thread separada (servidor de renderização) sem bloquear a thread principal. A Apple recomenda trabalhar diretamente com CALayer se houver mais de 200 vistas no ecrã — isto reduz a carga da CPU.

Cadeia de resposta em detalhe

A cadeia de resposta começa com o objeto que recebe primeiro um evento de toque. Se não tratar o evento (o método touchesBegan não foi sobrescrito), o evento passa para o próximo respondedor na cadeia: next, superview, next responder, UIViewController, UIWindow, UIApplication, App Delegate. Isto permite intercetar gestos globais e eventos de teclado ao nível da cena sem adicionar um manipulador a cada vista.

Ciclo de vida do UIViewController

Cada UIViewController passa por uma sequência de eventos estritamente definida. O ciclo de vida inclui fases: inicialização, carregamento da vista, aparecimento no ecrã, atualização do layout ao rodar, ocultação, saída do ecrã e libertação de memória. O programador sobrescreve os métodos correspondentes para executar código personalizado em cada fase.

class ProfileViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
    }

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        loadUserProfile()
    }

    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        clearCache()
    }
}

Em viewDidLoad, a interface é configurada — as subvistas são criadas, as restrições são definidas, os delegados são subscritos. Em viewWillAppear, são realizadas operações antes da exibição: carregar dados frescos da rede, atualizar valores. viewDidDisappear é o local para cancelar a subscrição de notificações e limpar dados temporários. A chamada a super é obrigatória em todas as sobrescrições, caso contrário a cadeia de eventos quebra.

Gestão de memória e viewDidUnload

Nas versões antigas do iOS, existia o método viewDidUnload, chamado quando faltava memória. Desde o iOS 6, o método foi removido — agora a UIKit descarrega automaticamente as vistas dos controladores quando não estão visíveis. O programador só precisa de declarar todas as referências a vistas como weak para que o ARC possa libertar memória corretamente ao receber um aviso do sistema.

Transições entre controladores

A UIKit suporta dois tipos de transições: segue (através do Storyboard) e navegação programática através de UINavigationController. Uma transição programática tem este aspeto: navigationController?.pushViewController(detailVC, animated: true). Neste caso, o ciclo de vida do detailVC prossegue normalmente — viewDidLoad é chamado uma vez, viewWillAppear é chamado sempre que aparece.

Auto Layout e layout adaptativo

Auto Layout é um sistema de posicionamento baseado em relações matemáticas (restrições). Em vez de coordenadas X e Y fixas, o programador descreve regras: “o botão está à direita da etiqueta com um espaçamento de 16pt” ou “a vista estica-se pela largura do ecrã com margens de 20pt à esquerda e à direita.” O sistema resolve o sistema de equações resultante em tempo de execução, adaptando a interface a qualquer tamanho de ecrã.

As restrições podem ser definidas no Interface Builder (através de arrastar e largar) ou programaticamente em Swift. Cada restrição é uma instância da classe NSLayoutConstraint com parâmetros: firstItem, firstAttribute, relation, secondItem, secondAttribute, multiplier, constant. As restrições são ativadas através de isActive = true ou em massa através de NSLayoutConstraint.activate().

Safe Area e Layout Margins

Com a introdução do iPhone X (2017), a Apple introduziu a Safe Area — a área do ecrã livre do notch, cantos arredondados e indicador da barra de início. As restrições devem ser ligadas a view.safeAreaLayoutGuide, não a view. Layout Margins adicionam preenchimento interno à vista, por defeito 8pt ou 16pt dependendo do contexto. O uso de safeAreaLayoutGuide garante a exibição correta em todas as gerações de iPhone e iPad.

Animação de restrições

O Auto Layout suporta animação através da alteração de constantes das restrições. Basta atualizar a constant de uma restrição e chamar UIView.animate com layoutIfNeeded dentro do bloco de animação. O sistema recalcula suavemente a posição de todas as vistas na hierarquia. Esta técnica é usada para blocos expansíveis, painéis de teclado adaptativos e mudanças de orientação do ecrã.

Trabalhar com tabelas e coleções

UITableView e UICollectionView são duas ferramentas poderosas da UIKit para exibir listas e grelhas. UITableView é adequada para listas verticais de coluna única (chat, definições, feed de notícias). UICollectionView é para grelhas, listas horizontais, carrosséis e layouts personalizados (galeria, produtos, calendário). Ambas as classes usam o padrão de delegação para separar os dados da aparência.

A fonte de dados é o protocolo UITableViewDataSource com os métodos obrigatórios numberOfRowsInSection e cellForRowAt. O UITableViewDelegate trata dos toques nas células, alturas das linhas e eventos de scroll. O mecanismo de reuse identifier reutiliza as células que saíram do ecrã, o que é crítico para o desempenho em listas grandes.

class ContactsViewController: UITableViewController {

    private let contacts = ["Ana", "Boris", "Vítor"]

    override func viewDidLoad() {
        super.viewDidLoad()
        tableView.register(UITableViewCell.self,
                           forCellReuseIdentifier: "cell")
    }

    override func tableView(_ tableView: UITableView,
                          numberOfRowsInSection section: Int) -> Int {
        return contacts.count
    }

    override func tableView(_ tableView: UITableView,
                          cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "cell",
                                                 for: indexPath)
        var content = cell.defaultContentConfiguration()
        content.text = contacts[indexPath.row]
        cell.contentConfiguration = content
        return cell
    }
}

O exemplo mostra um controlador mínimo para exibir um array de strings. A célula é configurada através de UIListContentConfiguration — uma API moderna (iOS 14+) que substituiu os obsoletos textLabel e detailTextLabel. O registo da classe da célula em viewDidLoad é obrigatório, caso contrário a aplicação falha com uma exceção em tempo de execução.

UICollectionView e Compositional Layout

A partir do iOS 13, a Apple recomenda UICollectionViewCompositionalLayout para construir layouts complexos. O programador descreve a secção, o grupo, o item e os seus tamanhos de forma declarativa — resultando numa grelha com geometria arbitrária: uma tira, grelha 2x2, carrossel ornamento. O Compositional Layout substituiu o obsoleto UICollectionViewFlowLayout para todos os novos projetos. Combinado com DiffableDataSource, atualizar uma coleção reduz-se a uma única chamada apply(snapshot), e as animações de alteração são executadas automaticamente.

Exemplos de código em Swift

Abaixo estão dois exemplos práticos de uso da UIKit em tarefas reais: criar uma vista personalizada com sombra e cantos arredondados, e manipular um gesto de deslize para eliminar um item de uma lista.

extension UIView {
    func applyCardStyle() {
        layer.cornerRadius = 12
        layer.shadowOpacity = 0.15
        layer.shadowRadius = 8
        layer.shadowOffset = CGSize(width: 0, height: 2)
        layer.masksToBounds = false
    }
}

@objc private func handleSwipe(_ gesture: UISwipeGestureRecognizer) {
    guard let swipedView = gesture.view else { return }
    UIView.animate(withDuration: 0.3) {
        swipedView.alpha = 0
        swipedView.transform = CGAffineTransform(translationX: 300, y: 0)
    } completion: { _ in
        swipedView.removeFromSuperview()
    }
}

A extensão applyCardStyle adiciona sombra e cantos arredondados a qualquer vista — útil para cartões de produto, perfis e notificações. O método handleSwipe com animação elimina um item quando o utilizador desliza para a direita sobre ele. O manipulador é adicionado à vista através de addGestureRecognizer com uma configuração UISwipeGestureRecognizer(direction: .right). Definir masksToBounds = false é importante para evitar que a sombra seja cortada pelos limites da vista.

Para interfaces mais complexas, use UIStackView — um contentor que distribui automaticamente as vistas aninhadas horizontal ou verticalmente. O Stack View simplifica o layout: não é necessário definir restrições para cada elemento, basta uma restrição para o próprio stack.