Как подписаться на свойство alpha?

Подписка на изменения свойства alpha в iOS

В iOS подписаться на изменения свойства alpha можно несколькими способами, в зависимости от контекста и требуемого подхода. Самый распространенный и современный способ — использование KVO (Key-Value Observing), но также существуют другие подходы.

1. Key-Value Observing (KVO)

KVO — это механизм Cocoa, позволяющий объектам наблюдать за изменениями свойств других объектов. Для alpha (наследуемого от UIView) это работает следующим образом:

class ViewController: UIViewController {
    let observedView = UIView()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Добавляем наблюдателя
        observedView.addObserver(
            self,
            forKeyPath: "alpha",
            options: [.new, .old],
            context: nil
        )
        
        // Изменяем alpha для теста
        observedView.alpha = 0.5
    }
    
    // Метод обработки изменений
    override func observeValue(
        forKeyPath keyPath: String?,
        of object: Any?,
        change: [NSKeyValueChangeKey : Any]?,
        context: UnsafeMutableRawPointer?
    ) {
        if keyPath == "alpha", let view = object as? UIView {
            let oldValue = change?[.oldKey] as? CGFloat
            let newValue = change?[.newKey] as? CGFloat
            print("Alpha changed from \(oldValue ?? 0) to \(newValue ?? 0)")
        }
    }
    
    // Не забываем удалить наблюдателя
    deinit {
        observedView.removeObserver(self, forKeyPath: "alpha")
    }
}

Важные моменты KVO:

• Требует явной регистрации и удаления наблюдателя
• Метод observeValue может стать перегруженным при наблюдении за несколькими свойствами
• Работает только с Objective-C runtime (классы должны наследоваться от NSObject)

2. Блоки на основе KVO (более современный подход)

В Swift можно использовать более удобный API через блоки:

import Foundation

class ViewController: UIViewController {
    let observedView = UIView()
    var observation: NSKeyValueObservation?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Создаем наблюдение с использованием блока
        observation = observedView.observe(\.alpha, options: [.new, .old]) { 
            [weak self] view, change in
            guard let self = self else { return }
            print("Alpha changed from \(change.oldValue ?? 0) to \(change.newValue ?? 0)")
            self.handleAlphaChange(newValue: view.alpha)
        }
        
        // Тестовое изменение
        UIView.animate(withDuration: 0.3) {
            self.observedView.alpha = 0.7
        }
    }
    
    private func handleAlphaChange(newValue: CGFloat) {
        // Дополнительная обработка
        print("New alpha value: \(newValue)")
    }
    
    // Наблюдение удалится автоматически при деинициализации observation
}

Преимущества этого подхода:

• Автоматическое управление памятью
• Более чистый и безопасный код
• Не требует переопределения метода observeValue
• Легко комбинируется с другими наблюдениями

3. Кастомные обертки и Property Observers

Если вы контролируете изменение alpha, можно использовать собственные обертки:

// Кастомный UIView с дополнительными коллбеками
class ObservableView: UIView {
    var onAlphaChange: ((CGFloat) -> Void)?
    
    override var alpha: CGFloat {
        didSet {
            if alpha != oldValue {
                onAlphaChange?(alpha)
            }
        }
    }
}

// Использование
class ViewController: UIViewController {
    let customView = ObservableView()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        customView.onAlphaChange = { [weak self] newAlpha in
            print("Custom view alpha changed to: \(newAlpha)")
            self?.updateLayout(forAlpha: newAlpha)
        }
    }
    
    private func updateLayout(forAlpha alpha: CGFloat) {
        // Обновление UI в зависимости от alpha
    }
}

4. Combine Framework (для iOS 13+)

Для современных приложений можно использовать Combine:

import Combine
import UIKit

class ViewController: UIViewController {
    let observedView = UIView()
    private var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Создаем publisher для наблюдения за alpha
        let alphaPublisher = observedView
            .publisher(for: \.alpha)
            .removeDuplicates()
        
        // Подписываемся на изменения
        alphaPublisher
            .sink { [weak self] newAlpha in
                print("Alpha updated via Combine: \(newAlpha)")
                self?.handleAlphaUpdate(newAlpha)
            }
            .store(in: &cancellables)
    }
    
    private func handleAlphaUpdate(_ alpha: CGFloat) {
        // Обработка изменения
    }
}

Рекомендации по выбору подхода

Когда использовать каждый метод:

1. Блоки KVO (NSKeyValueObservation) — универсальный выбор для большинства случаев
2. Combine — для современных приложений с реактивным подходом
3. Кастомные обертки — когда нужен полный контроль над логикой изменений
4. Классический KVO — для совместимости с legacy кодом

Критические замечания:

• Изменения alpha через анимации могут генерировать множество промежуточных значений
• Наблюдение за системными представлениями (например, UINavigationBar) может быть ненадежным
• Всегда проверяйте циклы удержания при использовании замыканий

Наиболее современным и безопасным подходом для iOS 13+ является Combine, а для поддержки более старых версий — блоки на основе KVO.