Какой структурой данных можно описать обработку нажатия?

Паттерны обработки нажатий в iOS

В iOS разработке существует несколько уровней и структур для обработки пользовательских взаимодействий, но ключевой абстракцией является UIControl и связанная с ним система Target-Action.

Иерархия обработки событий

1. Responder Chain (Цепочка ответчиков)

Базовый механизм iOS для распределения событий:

class CustomView: UIView {
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        // Обработка начала касания
        super.touchesBegan(touches, with: event)
    }
    
    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
        // Обработка завершения касания
        super.touchesEnded(touches, with: event)
    }
}

2. UIControl и Target-Action Pattern

Основная структура для интерактивных элементов:

// Создание кнопки и привязка обработчика
let button = UIButton(type: .system)
button.addTarget(self, 
                action: #selector(buttonTapped(_:)), 
                for: .touchUpInside)

@objc func buttonTapped(_ sender: UIButton) {
    // Обработка нажатия
}

Архитектурные подходы

Делегирование (Delegate Pattern)

protocol ButtonHandlerDelegate: AnyObject {
    func didTapButton(_ button: CustomButton)
}

class ViewController: UIViewController, ButtonHandlerDelegate {
    func setupButton() {
        let button = CustomButton()
        button.delegate = self
    }
    
    func didTapButton(_ button: CustomButton) {
        // Реакция на нажатие
    }
}

Замыкания (Closures)

Современный подход, особенно с UIKit и SwiftUI:

class ActionButton: UIButton {
    var onTap: (() -> Void)?
    
    @objc private func handleTap() {
        onTap?()
    }
}

// Использование
let button = ActionButton()
button.onTap = {
    print("Button tapped!")
}

RxSwift/Combine для реактивного программирования

// Использование Combine
button.publisher(for: .touchUpInside)
    .sink { [weak self] _ in
        self?.handleButtonTap()
    }
    .store(in: &cancellables)

Современные подходы в SwiftUI

@GestureState и Gesture Modifiers

struct CustomButtonView: View {
    @State private var isPressed = false
    
    var body: some View {
        Button("Tap me") {
            handleTap()
        }
        .gesture(
            LongPressGesture(minimumDuration: 0.5)
                .onChanged { _ in isPressed = true }
                .onEnded { _ in 
                    isPressed = false
                    handleLongPress()
                }
        )
    }
}

Пример комплексной обработки

class SmartButtonHandler {
    private var tapActions: [UIGestureRecognizer: () -> Void] = [:]
    private var gestureRecognizers: [UIGestureRecognizer] = []
    
    func configureButton(_ button: UIButton) {
        // Одиночное нажатие
        let tap = UITapGestureRecognizer(target: self, 
                                       action: #selector(handleTap))
        tapActions[tap] = { print("Single tap") }
        button.addGestureRecognizer(tap)
        
        // Двойное нажатие
        let doubleTap = UITapGestureRecognizer(target: self, 
                                             action: #selector(handleTap))
        doubleTap.numberOfTapsRequired = 2
        tapActions[doubleTap] = { print("Double tap") }
        button.addGestureRecognizer(doubleTap)
        
        tap.require(toFail: doubleTap) // Предотвращение конфликтов
    }
    
    @objc private func handleTap(_ gesture: UITapGestureRecognizer) {
        tapActions[gesture]?()
    }
}

Ключевые принципы

1. Инкапсуляция логики: Каждый обработчик должен иметь четкую ответственность
2. Управление памятью: Использование [weak self] для предотвращения retain cycles
3. Приоритизация событий: Правильная обработка конфликтующих жестов
4. Доступность: Учет потребностей пользователей с ограниченными возможностями
5. Анимация обратной связи: Визуальный отклик на действия пользователя

Выбор подхода зависит от:

• Сложности обработки: Простые действия → замыкания, сложные → делегирование
• Масштабируемости: Большие проекты → реактивное программирование
• Платформы: UIKit vs SwiftUI
• Требований к тестируемости: Изолированные обработчики проще тестировать

Наиболее универсальной структурой в UIKit остается Target-Action, дополненная современными практиками вроде замыканий и реактивного программирования для создания отзывчивых и поддерживаемых интерфейсов.