Responder Chain: o que é, princípio de funcionamento e cadeia de respondedores

O que é Responder Chain

Responder Chain é uma sequência de objetos UIResponder através dos quais o iOS transmite eventos de entrada, como toques, pressionamentos de teclas e dados do acelerómetro. Cada objeto nesta cadeia tem a capacidade de tratar o evento ou passá-lo para o próximo objeto respondedor através da propriedade next.

O mecanismo baseia-se na hierarquia de views: quando ocorre um toque, o iOS primeiro determina qual view foi tocada (através de hit-testing) e cria uma cadeia começando por essa view até UIApplication. UIApplication é o último elo da cadeia — se um evento chegar até ele e não for tratado, é simplesmente descartado.

Segundo a Apple, este padrão é fundamental para encapsular a lógica de tratamento de eventos. Um programador pode sobrescrever o comportamento de uma view específica sem afetar outros elementos da hierarquia. Por exemplo, UITextField torna-se first responder ao receber foco e recebe eventos de teclado sem necessitar de alterações no UIViewController pai.

Como o Responder Chain trata eventos

O tratamento de eventos através do Responder Chain ocorre em duas etapas: primeiro, o iOS determina qual view recebeu o evento (hit-testing), depois executa a cadeia de respondedores para o tratar. Se um objeto não implementar o método correspondente, o evento é passado adiante.

A cadeia é formada dinamicamente com base no first responder atual e na hierarquia de views. A ordem padrão é: first responder → sua view → superview → UIViewController → root view → UIWindow → UIApplication. Se algum destes objetos implementar, por exemplo, touchesBegan, o evento é tratado nesse nível e não é passado adiante.

import UIKit

class CustomView: UIView {
    override func touchesBegan(
        _ touches: Set<UITouch>,
        with event: UIEvent?
    ) {
        // Toque tratado neste nível de view
        print("CustomView tratou o toque")
        
        // Encaminhar evento ao longo da cadeia
        super.touchesBegan(touches, with: event)
    }
}

Uma característica fundamental é que chamar super.touchesBegan não é obrigatório. Se não for chamado, o evento será tratado apenas no nível atual e não prosseguirá pela Responder Chain. Isto dá ao programador controlo total sobre quais objetos participam no tratamento.

Transmissão de eventos entre objetos respondedores

Quando um objeto recebe um evento mas não o trata (não sobrescreve o método), o iOS transmite automaticamente o evento para o próximo objeto respondedor através da propriedade next. Esta propriedade forma uma lista ligada simples, que é chamada de Responder Chain.

UIViewController encontra-se entre a sua view e UIWindow: se a view não tratar o evento, o controlador tem a oportunidade de o fazer. Isto é especialmente útil para lógica comum — por exemplo, tratar um gesto que deve funcionar em toda a cena, independentemente de qual view está sob o dedo do utilizador.

Hit-Testing: do toque ao primeiro respondedor

Hit-Testing é o processo pelo qual o iOS determina qual view está sob o ponto de toque. O método hitTest:withEvent: percorre a hierarquia de views a partir de UIWindow para baixo, verificando qual view filha contém o ponto de toque e não está oculta.

O algoritmo funciona recursivamente: para cada nível, o iOS verifica as views por ordem inversa de adição (primeiro as superiores). Se uma view não está oculta, não é transparente e o ponto cai dentro dos seus bounds, o hitTest é executado recursivamente para todas as suas subviews. A view mais profunda que satisfaz todas as condições torna-se a hit-test view — o primeiro objeto na Responder Chain.

override func hitTest(
    _ point: CGPoint,
    with event: UIEvent?
) -> UIView? {
    if isUserInteractionEnabled &&
        isHidden == false &&
        alpha > 0.01 &&
        point(inside: point, with: event) {
        return super.hitTest(point, with: event)
    }
    return nil
}

Os programadores podem sobrescrever hitTest para alterar o comportamento padrão. Por exemplo, para expandir a área de toque de um botão pequeno ou redirecionar o evento para outra view que não está fisicamente sob o dedo. Esta é uma ferramenta poderosa para criar elementos interativos personalizados.

Métodos UIResponder para a cadeia de respondedores

UIResponder é a classe base para todos os objetos que podem tratar eventos no iOS. UIView, UIViewController, UIApplication e UIWindow herdam de UIResponder. A classe fornece um conjunto de métodos que podem ser sobrescritos para tratar diferentes tipos de eventos.

Os principais grupos de métodos incluem touchesBegan, touchesMoved, touchesEnded, touchesCancelled para toques; pressesBegan, pressesEnded para botões físicos; e motionBegan, motionEnded para eventos do acelerómetro. Cada método recebe um conjunto de objetos UITouch ou UIPress e uma referência a UIEvent contendo metadados adicionais sobre o evento.

É importante entender que o iOS chama estes métodos apenas para o first responder e objetos subsequentes na cadeia. Se nenhum objeto sobrescreveu o método, o evento não gera erro — é simplesmente ignorado. Para depurar o tratamento de eventos, use um Symbolic Breakpoint em UIResponder touchEvent.

Responder Chain e elementos UIKit

Os componentes UIKit padrão utilizam ativamente a Responder Chain para o seu funcionamento. UITextField torna-se first responder ao receber foco, o que abre automaticamente o teclado. UIButton trata toques através do mecanismo UIControl, que também depende da responder chain.

UITableView e UICollectionView usam a cadeia de respondedores para tratar a seleção de células e gestos de scroll. Se um utilizador tocar numa célula, o evento primeiro chega à própria célula, depois à UITableView, e só depois ao UIViewController. UIGestureRecognizer tem prioridade mais alta que touchesBegan — se um reconhecedor de gestos for adicionado a uma view, ele receberá o evento primeiro.

Segundo a Apple, o uso correto da Responder Chain é fundamental para a acessibilidade da aplicação. VoiceOver e outras tecnologias assistivas usam a cadeia de respondedores para navegar entre elementos da interface. Se a cadeia estiver quebrada, utilizadores com deficiência não conseguirão interagir com a aplicação.

UIMenuController e Responder Chain

UIMenuController para exibir menus contextuais também usa a Responder Chain. Quando um utilizador invoca o menu, o sistema procura um first responder que implemente os métodos canPerformAction e os métodos de ação correspondentes. O menu é exibido apenas para as ações que o respondedor atual suporta.

Isto permite, por exemplo, mostrar os comandos Cortar, Copiar, Colar apenas quando UITextField está em foco, e ocultá-los ao trabalhar com UILabel. Um programador pode adicionar ações personalizadas ao menu contextual implementando-as numa subclasse de UIResponder e retornando true de canPerformAction.

Objetos respondedores personalizados no iOS

Criar um objeto respondedor personalizado dá ao programador controlo total sobre o tratamento de eventos. Para tal, é necessário criar uma subclasse de UIResponder (ou UIView/UIViewController) e sobrescrever os métodos necessários de tratamento de eventos.

Objetos respondedores personalizados são frequentemente usados para tratar gestos específicos que não são cobertos pelo UIGestureRecognizer padrão. Por exemplo, reconhecer desenho de formas, combinações multi-toque complexas ou padrões de entrada proprietários. Um respondedor personalizado pode agregar eventos de vários dedos e tomar decisões com base na sua combinação.

class DrawingResponder: UIResponder {
    private var activeTouches: [UITouch: CGPoint] = [:]
    
    override func touchesBegan(
        _ touches: Set<UITouch>,
        with event: UIEvent?
    ) {
        for touch in touches {
            activeTouches[touch] = touch.location(in: self)
        }
    }
    
    override func touchesMoved(
        _ touches: Set<UITouch>,
        with event: UIEvent?
    ) {
        for touch in touches {
            let currentPoint = touch.location(in: self)
            activeTouches[touch] = currentPoint
            drawLine(from: activeTouches[touch]!, to: currentPoint)
        }
    }
}

Ao criar um respondedor personalizado, é importante configurar corretamente a cadeia next. Se o seu objeto não fizer parte da hierarquia padrão do UIKit, deve especificar explicitamente qual objeto será o seu next responder. Isto garante que os eventos não tratados continuem a mover-se ao longo da Responder Chain.