How to update custom classes properties properly?

Question

I have custom classes for labels, buttons, views etc.

Example class:

class PopupButton: UIButton {
    override func awakeFromNib() {
        self.layer.borderWidth = 1.3
        self.layer.borderColor = fadedTextColor.cgColor
        self.layer.cornerRadius = 10
        self.layer.backgroundColor = whiteColor.cgColor
        self.setTitleColor(textHeaderColor, for: .normal)
    }
}

When I change the colors ie.: fadedTextColor I want this PopupButton class to reflect that change immediately.

How can I achieve this?

Thank you for your time.

Answer 1

First you create a singleton class to hold all your "global" variables. Then add a didSet to the fadedTextColor property to post a notification when its value changes. Next add an observer and a selector at your custom class to change the buttons border color using the color from your singleton class:

class Shared {
    private init() {}
    static let instance = Shared()
    var fadedTextColor: UIColor = .red {
        didSet {
            NotificationCenter.default.post(name: NSNotification.Name(rawValue: "fadedTextColorChanged"), object: nil)
        }
    }
    var textHeaderColor: UIColor = .blue
}

---

class PopupButton: UIButton {
    override func awakeFromNib() {
        super.awakeFromNib()
        layer.borderWidth = 1.3
        layer.borderColor = Shared.instance.fadedTextColor.cgColor
        layer.cornerRadius = 10
        layer.backgroundColor = UIColor.white.cgColor
        setTitleColor(Shared.instance.textHeaderColor, for: .normal)
        NotificationCenter.default.addObserver(self, selector: #selector(colorChanged), name: NSNotification.Name(rawValue: "fadedTextColorChanged"), object: nil)
    }
    @objc func colorChanged(notification: Notification) {
        layer.borderColor = Shared.instance.fadedTextColor.cgColor
    }
}

Answer 2

Swift 3

Note: this answer is for Swift 3. My other answer takes advantage of the much nicer API in Swift 4.

I would use Key Value Observation for this purpose. It has the nice property of using using standardized #keyPath Strings to identify changes, rather than Notifications' arbitrary Strings.

The [.initial, .new] options make it so that observeValue(forKeyPath:of:change:context:) is called for you right away (to set the initial value), and after every change (to be notified of new values).

public final class AppConfig: NSObject {
    static let shared = AppConfig()
    override private init() {}

    @objc dynamic var fadedTextColor: UIColor = .red
    @objc dynamic var textHeaderColor: UIColor = .blue
    // ... add other global config state properties here
    // any pro properties you wish to observe must be `@objc` and ` dynamic`
}

class PopupButton: UIButton {
    override func awakeFromNib() {
        let appconfig = AppConfig.shared

        self.layer.borderWidth = 1.3
        
        appconfig.addObserver(self,
                              forKeyPath: #keyPath(AppConfig.fadedTextColor),
                              options: [.initial, .new], context: nil)
        self.layer.cornerRadius = 10
        self.layer.backgroundColor = UIColor.white.cgColor


        appconfig.addObserver(self,
                              forKeyPath: #keyPath(AppConfig.textHeaderColor),
                              options: [.initial, .new], context: nil)



    }

    override func observeValue(
        forKeyPath keyPath: String?,
        of object: Any?,
        change: [NSKeyValueChangeKey : Any]?,
        context: UnsafeMutableRawPointer?) {
        guard let keyPath = keyPath, let newValue = change?[.newKey] else { return }

        if object as? AppConfig == AppConfig.shared {
            switch (keyPath, newValue) {
            case (#keyPath(AppConfig.fadedTextColor), let fadedTextColor as UIColor):
                self.layer.borderColor = fadedTextColor.cgColor

            case (#keyPath(AppConfig.textHeaderColor), let textHeaderColor as UIColor):
                self.setTitleColor(textHeaderColor, for: .normal)

            // Handle other changes here

            default: break
            }
        }
    }
}

Answer 3

Swift 4

We have a really nice, but poorly documented API, in Swift 4, which uses KeyPath for concise, type safe Key-Value Observation. Gone is the need for a massive observeValue(forKeyPath:of:change:context:) that has to handle all the call backs. Instead, each observation takes a closure, which is called only when event pertaining to it take place. This breaks your observeValue(forKeyPath:of:change:context:) method apart very nicely.

For more information, see the What's New in Foundation video from WWDC 2017, starting around 19:30.

public final class AppConfig: NSObject {
    static let shared = AppConfig()
    override private init() {}

    @objc dynamic var fadedTextColor: UIColor = .red
    @objc dynamic var textHeaderColor: UIColor = .blue
    // ... add other global config state properties here
    // any pro properties you wish to observe must be `@objc` and ` dynamic`
}

import UIKit

class PopupButton: UIButton {
    var observers = [NSKeyValueObservation]()

    override func awakeFromNib() {
        let appconfig = AppConfig.shared

        self.layer.borderWidth = 1.3

        observers.append(appconfig.observe(\.fadedTextColor,  options: [.initial, .new]) { object, change in
            self.layer.borderColor = object.fadedTextColor.cgColor
        })
        self.layer.cornerRadius = 10
        self.layer.backgroundColor = UIColor.white.cgColor


        observers.append(appconfig.observe(\.textHeaderColor,  options: [.initial, .new]) { object, change in
            self.setTitleColor(object.textHeaderColor, for: .normal)
        })
    }
}