What is Key-Value Observing (KVO)?
Key-Value Observing is a pattern used in Cocoa frameworks to allow objects to be notified of changes to specified properties of another object. This mechanism is particularly handy when dealing with dynamic data changes in iOS applications.
KVO establishes a dependency between an observer and an observed object. The observer registers its interest in specific properties of the observed object. Whenever the observed property’s value changes, the observer is notified. This allows the observer to react accordingly, often by updating its state.
Observing an attribute of AVPlayer object in Swift:
internal class AudioPlayerImpl: NSObject, AudioPlayer {
private let player = AVPlayer()
private var observation: NSKeyValueObservation?
override init() {
super.init()
addObserver(self, forKeyPath: "timeControlStatus", options: [.new], context: nil)
}
override func observeValue(
forKeyPath keyPath: String?,
of: Any?,
change: [NSKeyValueChangeKey: Any]?,
context: UnsafeMutableRawPointer?
) {
print("\(keyPath!) has been updated to: \(change![.newKey]!)")
}
}
KVO in KMP iOS
Using KVO in the KMP iOS source set might seem like a straightforward approach, but it comes with limitations:
- Inheriting from
NSObjectis not possible if you are already inheriting from/implementing any Kotlin class/interface:
- Overriding a function to observe changes is also not possible because
observeValueForKeyPathis imported as Kotlin extension, which can’t be overridden: -
‘observeValueForKeyPath’ overrides nothing
Job Offers
OUR VIDEO RECOMMENDATION
Jobs
🛟 Cinterops for the rescue!
The KMP plugin provides a DSL to define a custom definition file where we can declare our Objective-C protocol (interface) to be available in the Kotlin iOS source set.
- Declare a protocol as per the NSObject observing protocol in a
nskeyvalueobserving.deffile:
package = platform.foundation
language = Objective-C
---
#import <Foundation/Foundation.h>
@protocol NSKeyValueObserving
@required
- (void) observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary<NSKeyValueChangeKey, id> *)change
context:(void *)context;
@end;
- Define the interoperability using the KMP plugin DSL
kotlin {
androidTarget()
listOf(
iosX64(),
iosArm64(),
iosSimulatorArm64()
).forEach { target ->
target.binaries.framework {
baseName = "shared"
isStatic = true
}
target.compilations.getByName("main") {
// The default file path is src/nativeInterop/cinterop/<interop-name>.def
val nskeyvalueobserving by cinterops.creating
}
}
}
- After compiling the KMP module, we have an interface where we can implement and observe
NSObjectchanges:
internal class AudioPlayerImpl: AudioPlayer {
private val player = AVPlayer()
init {
player.addObserver(
observer = timeControlObserver,
forKeyPath = "timeControlStatus",
options = NSKeyValueObservingOptionNew,
context = null
)
}
private val timeControlObserver: NSObject = object : NSObject(), NSKeyValueObservingProtocol {
override fun observeValueForKeyPath(
keyPath: String?,
ofObject: Any?,
change: Map<Any?, *>?,
context: COpaquePointer?
) {
println("${keyPath} has been updated to: ${change!![NSKeyValueChangeNewKey]!!}")
}
}
}
}
💡 Remember to properly stop observing a property when you no longer need it to avoid memory leaks.
player.removeObserver(timeControlObserver, "timeControlStatus")
KVO provides a robust mechanism for monitoring property changes in iOS development. By understanding how to utilize KVO effectively within your KMP iOS source set, you can harness the full potential of this approach while leveraging the power of Kotlin Multiplatform.
Take a look at https://github.com/andremion/RetroBeat to see how KVO was used to listen for AVPlayerItem status updates.
Happy coding! 🤓
This article is previously published on proandroiddev.com
