Key Value Observer

Key-Value Observing (KVO) is a mechanism in Swift and Objective-C that allows an object to observe changes to a property of another object. When a property is observed, the observing object is notified whenever the property’s value changes. This is particularly useful for keeping parts of your app in sync without manually checking for changes.

How KVO Works:
- Observable Object: An object that has properties you want to observe.
- Observer: An object that listens for changes to a property on the observable object.
- Key Path: A string or KeyPath specifies which property to observe.

KVO Example in Swift:
Let’s say you have a Person class, and you want to observe changes to its name property.

import Foundation
// Observable class
class Person: NSObject {
  @objc dynamic var name: String
 
  init(name: String) {
    self.name = name
  }
}

// Observer class
class NameObserver: NSObject {
 private var observation: NSKeyValueObservation?
 
 func startObserving(person: Person) {
   observation = person.observe(\.name, options: [.new, .old]) { [weak self] observedPerson, change in
     if let newName = change.newValue, let oldName = change.oldValue {
       print("Name changed from \(oldName) to \(newName)")
     }
   }
 }
 
 func stopObserving() {
   observation = nil
 }

}

// Usage
let person = Person(name: "John")
let nameObserver = NameObserver()
nameObserver.startObserving(person: person)
person.name = "Jane" // This will trigger the observer and print "Name changed from John to Jane"
// When you no longer need to observe, you can stop observing:
nameObserver.stopObserving()

Explanation:

1. Observable Property:
— The Person class has a name property that is marked with @objc dynamic. This makes the property observable using KVO.

2. Observer Setup:
— The NameObserver class starts observing the name property of a Person instance using the observe method. It listens for changes and provides both the old and new values when a change occurs.

3. Notification of Changes:
— When person.name is changed from “John” to “Jane”, the observer is notified, and the closure passed to observe is executed, printing the change.

4. Stopping Observation:
— When you no longer need to observe changes, you can stop observing by setting the observation to nil.

Key Points:
- @objc dynamic: Required for the property to be observable via KVO.
- Memory Management: Ensure that the observer is properly cleaned up to avoid memory leaks or crashes.
- Thread Safety: KVO notifications are delivered on the same thread that made the change. Be cautious of this when updating UI or performing thread-sensitive operations.

KVO is a powerful tool, but it’s also somewhat lower-level and can be error-prone if not used carefully. Swift’s property observers (willSet, didSet) and Combine framework provide more modern alternatives in many cases.