Is key-value observation KVO available in Swift

Question

If so  are there any key differences that weren t otherwise present when using key-value observation in Objective-C

User · Answer

Another example for anyone who runs into a problem with types such as Int  and CGFloat   You simply set you class as a subclass of NSObject and declare your variables as follows e g   class Theme   NSObject      dynamic var min images   Int   0    dynamic var moreTextSize   CGFloat   0 0     func myMethod           self setValue value  forKey     min images

User · Answer

Overview  It is possible using Combine without using NSObject or Objective-C  Availability  iOS 13 0   macOS 10 15   tvOS 13 0   watchOS 6 0   Mac Catalyst 13 0   Xcode 11 0   Note  Needs to be used only with classes not with value types   Code   Swift Version  5 1 2  import Combine   Combine Framework    Needs to be a class doesn t work with struct and other value types class Car         Published var price   Int   10    let car   Car      Option 1  Automatically Subscribes to the publisher  let cancellable1   car  price sink       print  Option 1  value changed to    0         Option 2  Manually Subscribe to the publisher   Using this option multiple subscribers can subscribe to the same publisher  let publisher   car  price  let subscriber2   Subscribers Sink lt Int  Never gt   subscriber2   Subscribers Sink receiveCompletion    print  completion    0            print  Option 2  value changed to    0       publisher subscribe subscriber2     Assign a new value  car price   20    Output   Option 1  value changed to 10 Option 2  value changed to 10 Option 1  value changed to 20 Option 2  value changed to 20   Refer    https   developer apple com documentation combine https   developer apple com documentation combine receiving and handling events with combine https   developer apple com documentation combine published

User · Answer

Both yes and no    Yes  you can use the same old KVO APIs in Swift to observe Objective-C objects  You can also observe dynamic properties of Swift objects inheriting from NSObject  But    No it s not strongly typed as you could expect Swift native observation system to be  Using Swift with Cocoa and Objective-C   Key Value Observing   No  currently there is no builtin value observation system for arbitrary Swift objects  Yes  there are builtin Property Observers  which are strongly typed  But    No they are not KVO  since they allow only for observing of objects own properties  don t support nested observations   key paths    and you have to explicitly implement them  The Swift Programming Language   Property Observers Yes  you can implement explicit value observing  which will be strongly typed  and allow for adding multiple handlers from other objects  and even support nesting    key paths   But    No it will not be KVO since it will only work for properties which you implement as observable  You can find a library for implementing such value observing here  Observable-Swift - KVO for Swift - Value Observing and Events

User · Answer

One important thing to mention is that after updating your Xcode to 7 beta you might be getting the following message   Method does not override any method from its superclass   That s because of the arguments  optionality  Make sure that your observation handler looks exactly as follows   override func observeValueForKeyPath keyPath  String   ofObject object  AnyObject   change   NSObject   AnyObject    context  UnsafeMutablePointer lt Void gt

User · Answer

Yes   KVO requires dynamic dispatch  so you simply need to add the dynamic modifier to a method  property  subscript  or initializer   dynamic var foo   0  The dynamic modifier ensures that references to the declaration will be dynamically dispatched and accessed through objc msgSend

User · Answer

Edited to add new info   consider whether using the Combine framework can help you accomplish what you wanted  rather than using KVO  Yes and no  KVO works on NSObject subclasses much as it always has  It does not work for classes that don t subclass NSObject  Swift does not  currently at least  have its own native observation system    See comments for how to expose other properties as ObjC so KVO works on them   See the Apple Documentation for a full example

User · Answer

This may be prove helpful to few people -      MARK  - KVO  var observedPaths   String        func observeKVO keyPath  String        observedPaths append keyPath      addObserver self  forKeyPath  keyPath  options    old   new   context  nil     func unObserveKVO keyPath  String        if let index   observedPaths index of  keyPath            observedPaths remove at  index            removeObserver self  forKeyPath  keyPath     func unObserveAllKVO         for keyPath in observedPaths           removeObserver self  forKeyPath  keyPath           override func observeValue forKeyPath keyPath  String   of object  Any   change   NSKeyValueChangeKey   Any    context  UnsafeMutableRawPointer         if let keyPath   keyPath           switch keyPath           case  keyPath camera iso               slider value   camera iso         default              break                     I had used KVO in this way in Swift 3  You can use this code with few changes

User · Answer

You can use KVO in Swift  but only for dynamic properties of NSObject subclass  Consider that you wanted to observe the bar property of a Foo class  In Swift 4  specify bar as dynamic property in your NSObject subclass   class Foo  NSObject        objc dynamic var bar   0     You can then register to observe changes to the bar property  In Swift 4 and Swift 3 2  this has been greatly simplified  as outlined in Using Key-Value Observing in Swift   class MyObject       private var token  NSKeyValueObservation      var objectToObserve   Foo        init             token   objectToObserve observe   bar     weak self  object  change in     the   weak self   is to avoid strong reference cycle  obviously  if you don t reference  self  in the closure  then   weak self   is not needed             print  bar property is now   object bar                        Note  in Swift 4  we now have strong typing of keypaths using the backslash character  the   bar is the keypath for the bar property of the object being observed   Also  because it s using the completion closure pattern  we don t have to manually remove observers  when the token falls out of scope  the observer is removed for us  nor do we have to worry about calling the super implementation if the key doesn t match  The closure is called only when this particular observer is invoked  For more information  see WWDC 2017 video  What s New in Foundation   In Swift 3  to observe this  it s a bit more complicated  but very similar to what one does in Objective-C  Namely  you would implement observeValue forKeyPath keyPath   of object   change   context   which  a  makes sure we re dealing with our context  and not something that our super instance had registered to observe   and then  b  either handle it or pass it on to the super implementation  as necessary  And make sure to remove yourself as an observer when appropriate  For example  you might remove the observer when it is deallocated   In Swift 3   class MyObject  NSObject       private var observerContext   0      var objectToObserve   Foo        override init             super init            objectToObserve addObserver self  forKeyPath   keyPath Foo bar   options    new   old   context   amp observerContext             deinit           objectToObserve removeObserver self  forKeyPath   keyPath Foo bar   context   amp observerContext             override func observeValue forKeyPath keyPath  String   of object  Any   change   NSKeyValueChangeKey   Any    context  UnsafeMutableRawPointer             guard context     amp observerContext else               super observeValue forKeyPath  keyPath  of  object  change  change  context  context              return                       do something upon notification of the observed object          print    keyPath     change   newKey                Note  you can only observe properties that can be represented in Objective-C  Thus  you cannot observe generics  Swift struct types  Swift enum types  etc   For a discussion of the Swift 2 implementation  see my original answer  below     Using the dynamic keyword to achieve KVO with NSObject subclasses is described in the Key-Value Observing section of the Adopting Cocoa Design Conventions chapter of the Using Swift with Cocoa and Objective-C guide      Key-value observing is a mechanism that allows objects to be notified of changes to specified properties of other objects  You can use key-value observing with a Swift class  as long as the class inherits from the NSObject class  You can use these three steps to implement key-value observing in Swift          Add the dynamic modifier to any property you want to observe  For more information on dynamic  see Requiring Dynamic Dispatch   class MyObjectToObserve  NSObject       dynamic var myDate   NSDate       func updateDate             myDate   NSDate              Create a global context variable   private var myContext   0    Add an observer for the key-path  and override the observeValueForKeyPath ofObject change context  method  and remove the observer in deinit   class MyObserver  NSObject       var objectToObserve   MyObjectToObserve       override init             super init           objectToObserve addObserver self  forKeyPath   myDate   options   New  context   amp myContext             override func observeValueForKeyPath keyPath  String   ofObject object  AnyObject   change   String   AnyObject    context  UnsafeMutablePointer lt Void gt             if context     amp myContext               if let newValue   change  NSKeyValueChangeNewKey                    print  Date changed    newValue                            else               super observeValueForKeyPath keyPath  ofObject  object  change  change  context  context                       deinit           objectToObserve removeObserver self  forKeyPath   myDate   context   amp myContext                 Note  this KVO discussion has subsequently been removed from the Using Swift with Cocoa and Objective-C guide  which has been adapted for Swift 3  but it still works as outlined at the top of this answer      It s worth noting that Swift has its own native property observer system  but that s for a class specifying its own code that will be performed upon observation of its own properties  KVO  on the other hand  is designed to register to observe changes to some dynamic property of some other class

User · Answer

In addition to Rob s answer  That class must inherit from NSObject  and we have 3 ways to trigger property change  Use setValue value  AnyObject   forKey key  String  from NSKeyValueCoding  class MyObjectToObserve  NSObject       var myDate   NSDate       func updateDate             setValue NSDate    forKey   myDate             Use willChangeValueForKey and didChangeValueForKey from NSKeyValueObserving  class MyObjectToObserve  NSObject       var myDate   NSDate       func updateDate             willChangeValueForKey  myDate           myDate   NSDate           didChangeValueForKey  myDate             Use dynamic  See Swift Type Compatibility     You can also use the dynamic modifier to require that access to members be dynamically dispatched through the Objective-C runtime if you   re using APIs like key   value observing that dynamically replace the implementation of a method    class MyObjectToObserve  NSObject       dynamic var myDate   NSDate       func updateDate             myDate   NSDate             And property getter and setter is called when used  You can verify when working with KVO  This is an example of computed property  class MyObjectToObserve  NSObject       var backing  NSDate   NSDate       dynamic var myDate  NSDate           set               print  setter is called               backing   newValue                   get               print  getter is called               return backing

User · Answer

An example might help a little here   If I have an instance model of class Model with attributes name and state I can observe those attributes with   let options   NSKeyValueObservingOptions   New   Old   Initial   Prior    model addObserver self  forKeyPath   name   options  options  context  nil  model addObserver self  forKeyPath   state   options  options  context  nil    Changes to these properties will trigger a call to   override func observeValueForKeyPath keyPath  String       ofObject object  AnyObject       change  NSDictionary       context  CMutableVoidPointer             println  CHANGE OBSERVED    change

User · Answer

Currently Swift does not support any built in mechanism for observing property changes of objects other than  self   so no  it does not support KVO  However  KVO is such a fundamental part of Objective-C and Cocoa that it seems quite likely that it will be added in the future  The current documentation seems to imply this   Key-Value Observing Information forthcoming   Using Swift with Cocoa and Objective-C

[swift] Is key-value observation (KVO) available in Swift?

Examples related to swift

Examples related to key-value-observing