Расскажи, как событие нажатия доходит до обработчика

Цепочка событий UIKit/UIKit и Responder Chain

В iOS, до появления SwiftUI, основным фреймворком для построения пользовательского интерфейса был UIKit. Механизм доставки событий касания (touch events) в UIKit — это фундаментальная концепция, основанная на паттерне Цепочка ответственности (Chain of Responsibility). Весь процесс можно разделить на несколько ключевых этапов.

1. Генерация и захват события системой

Когда пользователь касается экрана, система iOS генерирует объект UITouch, который инкапсулирует информацию о касании (координаты, силу нажатия, время и т.д.). Это событие помещается в очередь приложения (UIApplication). Далее UIApplication отправляет событие в UIWindow, с которого начинается основная фаза доставки.

2. Поиск "просматриваемого" (Hit-Tested) представления

UIWindow использует метод hitTest(_:with:) для определения конкретного UIView, который должен получить событие. Этот процесс называется хит-тестинг.

• Алгоритм работает рекурсивно, начиная с корневого окна и проходя вглубь иерархии вью.
• Для каждой вью проверяется:

    1.   `isUserInteractionEnabled = true`
    2.   `isHidden = false`
    3.   `alpha > 0.01`
    4.   Точка касания находится внутри границ вью (`point(inside:with:)`).

• Возвращается самая глубокая (последняя в иерархии) вью, удовлетворяющая условиям. Эта вью становится first responder для событий касания.

Пример иерархии:

UIWindow
└── MainView (синяя область)
    └── ContainerView (зеленая область, userInteractionEnabled = false)
        └── Button (красная кнопка)

Если ContainerView отключен для взаимодействия, то при касании кнопки hitTest вернет nil, и кнопка событие не получит, даже если касание было в ее пределах.

3. Путь события через Responder Chain

Если hitTest нашел целевую вью (initial view), система пытается доставить ей событие. Если эта вью не может обработать событие (например, она не переопределила методы touchesBegan), оно начинает движение вверх по цепочке ответчиков (Responder Chain).

Цепочка ответчиков — это динамически строимая последовательность объектов, наследующих от UIResponder:

1. Initial View (вью, найденная через hitTest)
2. Родительская UIView (если это UIViewController.view, то далее идет UIViewController)
3. UIViewController (если он управляет этой вью)
4. Родительское UIView супервью (если контроллера нет)
5. UIWindow
6. UIApplication
7. UIApplicationDelegate

Событие последовательно передается от одного ответчика к следующему, пока не найдет объект, готовый его обработать, или цепочка не закончится.

// Пример обработки в кастомной вью
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    // 1. Пытаемся обработать касание самостоятельно
    if self.shouldHandleTouch(with: touches) {
        self.handleTouch()
    } else {
        // 2. Если не можем - передаем следующему в цепочке
        super.touchesBegan(touches, with: event)
        // Это вызовет touchesBegan у супервью или контроллера
    }
}

4. Роль Gesture Recognizers

Перед началом движения по цепочке ответчиков система проверяет наличие распознавателей жестов (UIGestureRecognizer), прикрепленных к вью и ее супервью. Они имеют наивысший приоритет.

1. Событие сначала предлагается всем UIGestureRecognizer в иерархии.
2. Если распознаватель определил свой жест (например, тап), он может "захватить" событие (cancelsTouchesInView = true), и исходная вью получит лишь touchesCancelled.
3. Если ни один распознаватель не распознал жест или они отменены, событие продолжает путь к целевому UIView и далее по Responder Chain.

let tapRecognizer = UITapGestureRecognizer(target: self, action: #selector(handleTap))
button.addGestureRecognizer(tapRecognizer)
// При тапе на кнопку сначала сработает handleTap,
// и только потом (если распознаватель не отменил) - стандартные touchesBegan кнопки.

5. Особенности работы с UIControl

Стандартные элементы (UIButton, UISlider и т.д.) используют механизм Target-Action. Они перехватывают события касания внутри своей реализации методов touchesBegan, touchesEnded, и, если касание завершилось внутри их границ, отправляют соответствующее действие (action) заранее зарегистрированным целям (target). Это происходит параллельно с Responder Chain, но для пользователя выглядит как прямой вызов метода.

---

Ключевые отличия в SwiftUI

В SwiftUI декларативная модель полностью абстрагирует разработчика от императивной цепочки. Система сама решает, как доставить событие.

• Модификаторы жестов: Вместо UIGestureRecognizer используются модификаторы .gesture().
• Обработчики действий: Кнопки (Button) напрямую принимают замыкание action.
• SwiftUI автоматически определяет, какое представление должно реагировать, на основе состояния и модификаторов. Аналогом Responder Chain можно считать цепочку среды (Environment), по которой распространяются контекстные значения, но не сами события.

// Пример в SwiftUI: событие нажатия связывается напрямую с действием
Button("Нажми меня") {
    // Это действие будет вызвано при успешном нажатии
    viewModel.buttonTapped()
}
.gesture(
    LongPressGesture()
        .onEnded { _ in
            // Дополнительный жест
        }
)

Таким образом, в UIKit путь события — это четкий, императивный процесс с детальным контролем на каждом этапе (хит-тестинг, цепочка ответчиков, распознаватели жестов). В SwiftUI этот процесс инкапсулирован, и разработчик работает на более высоком уровне абстракции, описывая что должно произойти в ответ на взаимодействие, а не как система должна это взаимодействие доставить.