Comment ajouter un observateur dans Swift au centre de notification par défaut? J'essaie de porter cette ligne de code qui envoie une notification lorsque le niveau de la batterie change.

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(batteryLevelChanged:) name:UIDeviceBatteryLevelDidChangeNotification object:nil];

C'est la même chose que l'API Objective-C, mais utilise la syntaxe de Swift.

Swift 4.2 et Swift 5:

NotificationCenter.default.addObserver(
    self,
    selector: #selector(self.batteryLevelChanged),
    name: UIDevice.batteryLevelDidChangeNotification,
    object: nil)

Si votre observateur n'hérite pas d'un objet Objective-C, vous devez préfixer votre méthode @objcafin de l'utiliser comme sélecteur.

@objc private func batteryLevelChanged(notification: NSNotification){     
    //do stuff using the userInfo property of the notification object
}

Voir Référence de classe NSNotificationCenter , Interaction avec les API Objective-C

Swift 4.0 et Xcode 9.0+:

Envoyer une notification (post):

NotificationCenter.default.post(name: Notification.Name("NotificationIdentifier"), object: nil)

OU

NotificationCenter.default.post(name: Notification.Name("NotificationIdentifier"), object: nil, userInfo: ["Renish":"Dadhaniya"])

Recevoir (obtenir) une notification:

NotificationCenter.default.addObserver(self, selector: #selector(self.methodOfReceivedNotification(notification:)), name: Notification.Name("NotificationIdentifier"), object: nil)

Gestionnaire de méthode de fonction pour la notification reçue:

@objc func methodOfReceivedNotification(notification: Notification) {}

Swift 3.0 et Xcode 8.0+:

Envoyer une notification (post):

NotificationCenter.default.post(name: Notification.Name("NotificationIdentifier"), object: nil)

Recevoir (obtenir) une notification:

NotificationCenter.default.addObserver(self, selector: #selector(YourClassName.methodOfReceivedNotification(notification:)), name: Notification.Name("NotificationIdentifier"), object: nil)

Gestionnaire de méthode pour la notification reçue:

func methodOfReceivedNotification(notification: Notification) {
  // Take Action on Notification
}

Supprimer la notification:

deinit {
  NotificationCenter.default.removeObserver(self, name: Notification.Name("NotificationIdentifier"), object: nil)
}

Swift 2.3 et Xcode 7:

Envoyer une notification (post)

NSNotificationCenter.defaultCenter().postNotificationName("NotificationIdentifier", object: nil)

Recevoir (obtenir) une notification

NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(YourClassName.methodOfReceivedNotification(_:)), name:"NotificationIdentifier", object: nil)

Gestionnaire de méthode pour la notification reçue

func methodOfReceivedNotification(notification: NSNotification){
  // Take Action on Notification
}

Pour les versions Xcode historiques ...

Envoyer une notification (post)

NSNotificationCenter.defaultCenter().postNotificationName("NotificationIdentifier", object: nil)

Recevoir (obtenir) une notification

NSNotificationCenter.defaultCenter().addObserver(self, selector: "methodOfReceivedNotification:", name:"NotificationIdentifier", object: nil)

Supprimer la notification

NSNotificationCenter.defaultCenter().removeObserver(self, name: "NotificationIdentifier", object: nil)
NSNotificationCenter.defaultCenter().removeObserver(self) // Remove from all notifications being observed

Gestionnaire de méthode pour la notification reçue

func methodOfReceivedNotification(notification: NSNotification) {
  // Take Action on Notification
}

Annotez la classe ou la méthode cible avec @objc

@objc private func methodOfReceivedNotification(notification: NSNotification) {
  // Take Action on Notification
}

// Or

dynamic private func methodOfReceivedNotification(notification: NSNotification) {
  // Take Action on Notification
}

Une bonne façon de le faire est d'utiliser la addObserver(forName:object:queue:using:)méthode plutôt que la addObserver(_:selector:name:object:)méthode qui est souvent utilisée à partir du code Objective-C. L'avantage de la première variante est que vous n'avez pas à utiliser l' @objcattribut sur votre méthode:

    func batteryLevelChanged(notification: Notification) {
        // do something useful with this information
    }

    let observer = NotificationCenter.default.addObserver(
        forName: NSNotification.Name.UIDeviceBatteryLevelDidChange,
        object: nil, queue: nil,
        using: batteryLevelChanged)

et vous pouvez même simplement utiliser une fermeture au lieu d'une méthode si vous le souhaitez:

    let observer = NotificationCenter.default.addObserver(
        forName: NSNotification.Name.UIDeviceBatteryLevelDidChange,
        object: nil, queue: nil) { _ in print("🔋") }

Vous pouvez utiliser la valeur renvoyée pour arrêter d'écouter la notification ultérieurement:

    NotificationCenter.default.removeObserver(observer)

Il y avait un autre avantage à utiliser cette méthode, à savoir qu'elle ne vous oblige pas à utiliser des chaînes de sélection qui ne pouvaient pas être vérifiées statiquement par le compilateur et étaient donc fragiles à casser si la méthode était renommée, mais Swift 2.2 et inclure plus tard des #selectorexpressions qui résolvent ce problème.

Swift 3.0 dans Xcode 8

Swift 3.0 a remplacé de nombreuses API "typées en chaîne" par des struct"types d'encapsuleur", comme c'est le cas avec NotificationCenter. Les notifications sont désormais identifiées par un struct Notfication.Nameplutôt que par String. Consultez le guide Migration vers Swift 3 .

Utilisation précédente :

// Define identifier
let notificationIdentifier: String = "NotificationIdentifier"

// Register to receive notification
NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(YourClassName.methodOfReceivedNotification(_:)), name: notificationIdentifier, object: nil)

// Post a notification
NSNotificationCenter.defaultCenter().postNotificationName(notificationIdentifier, object: nil)

Nouvelle utilisation de Swift 3.0:

// Define identifier
let notificationName = Notification.Name("NotificationIdentifier")

// Register to receive notification
NotificationCenter.default.addObserver(self, selector: #selector(YourClassName.methodOfReceivedNotification), name: notificationName, object: nil)

// Post notification
NotificationCenter.default.post(name: notificationName, object: nil)

Tous les types de notification système sont désormais définis comme des constantes statiques sur Notification.Name; à savoir .UIDeviceBatteryLevelDidChange, .UIApplicationDidFinishLaunching, .UITextFieldTextDidChange, etc.

Vous pouvez étendre Notification.Namevos propres notifications personnalisées afin de rester cohérent avec les notifications système:

// Definition:
extension Notification.Name {
    static let yourCustomNotificationName = Notification.Name("yourCustomNotificationName")
}

// Usage:
NotificationCenter.default.post(name: .yourCustomNotificationName, object: nil)

1. Déclarez un nom de notification

   extension Notification.Name {
       static let purchaseDidFinish = Notification.Name("purchaseDidFinish")
   }

2. Vous pouvez ajouter un observateur de deux manières:

   En utilisant Selector

   NotificationCenter.default.addObserver(self, selector: #selector(myFunction), name: .purchaseDidFinish, object: nil)
   
   @objc func myFunction(notification: Notification) {
       print(notification.object ?? "") //myObject
       print(notification.userInfo ?? "") //[AnyHashable("key"): "Value"]
   }

   ou en utilisant block

   NotificationCenter.default.addObserver(forName: .purchaseDidFinish, object: nil, queue: nil) { [weak self] (notification) in
       guard let strongSelf = self else {
           return
       }
   
       strongSelf.myFunction(notification: notification)
   }
   
   func myFunction(notification: Notification) {
       print(notification.object ?? "") //myObject
       print(notification.userInfo ?? "") //[AnyHashable("key"): "Value"]
   }

3. Postez votre notification

   NotificationCenter.default.post(name: .purchaseDidFinish, object: "myObject", userInfo: ["key": "Value"])

depuis iOS 9 et OS X 10.11. Il n'est plus nécessaire pour un observateur NSNotificationCenter de se désinscrire lorsqu'il est désalloué.Plus d'informations

Pour une blockimplémentation basée, vous devez faire une danse faible-forte si vous voulez utiliserself à l'intérieur du bloc. Plus d'informations

Les observateurs basés sur des blocs doivent être supprimés plus d'informations

let center = NSNotificationCenter.defaultCenter()
center.removeObserver(self.localeChangeObserver)

Passer des données à l'aide de NSNotificationCenter

Vous pouvez également transmettre des données à l'aide de NotificationCentre dans swift 3.0 et NSNotificationCenter dans swift 2.0.

Version Swift 2.0

Passer des informations en utilisant userInfo qui est un dictionnaire facultatif de type [NSObject: AnyObject]?

let imageDataDict:[String: UIImage] = ["image": image]

// Post a notification
 NSNotificationCenter.defaultCenter().postNotificationName(notificationName, object: nil, userInfo: imageDataDict)

// Register to receive notification in your class
NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(self.showSpinningWheel(_:)), name: notificationName, object: nil)

// handle notification
func showSpinningWheel(notification: NSNotification) {
  if let image = notification.userInfo?["image"] as? UIImage {
  // do something with your image   
  }
}

Version Swift 3.0

L'utilisateur info prend maintenant [AnyHashable: Any]? comme argument, que nous fournissons comme un littéral de dictionnaire dans Swift

let imageDataDict:[String: UIImage] = ["image": image]

// post a notification
 NotificationCenter.default.post(name: NSNotification.Name(rawValue: "notificationName"), object: nil, userInfo: imageDataDict) 
// `default` is now a property, not a method call

// Register to receive notification in your class
NotificationCenter.default.addObserver(self, selector: #selector(self.showSpinningWheel(_:)), name: NSNotification.Name(rawValue: "notificationName"), object: nil)

// handle notification
func showSpinningWheel(_ notification: NSNotification) {

  if let image = notification.userInfo?["image"] as? UIImage {
  // do something with your image   
  }
}

Données de passe source à l'aide de NotificationCentre (swift 3.0) et NSNotificationCenter (swift 2.0)

Dans Swift 5

Disons que si vous souhaitez recevoir des données de ViewControllerB vers ViewControllerA

ViewControllerA (récepteur)

import UIKit

class ViewControllerA: UIViewController  {

    override func viewDidLoad() {
        super.viewDidLoad()

        //MARK: - - - - - Code for Passing Data through Notification Observer - - - - -
        // add observer in controller(s) where you want to receive data
        NotificationCenter.default.addObserver(self, selector: #selector(self.methodOfReceivedNotification(notification:)), name: Notification.Name("NotificationIdentifier"), object: nil)
    }

    //MARK: - - - - - Method for receiving Data through Post Notificaiton - - - - -
    @objc func methodOfReceivedNotification(notification: Notification) {
        print("Value of notification : ", notification.object ?? "")
    }
}

ViewControllerB (expéditeur)

import UIKit

class ViewControllerB: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        //MARK: - - - - - Set data for Passing Data Post Notification - - - - -
        let objToBeSent = "Test Message from Notification"
        NotificationCenter.default.post(name: Notification.Name("NotificationIdentifier"), object: objToBeSent)
    }

}

Je peux faire l'une des choses suivantes pour utiliser avec succès un sélecteur - sans rien annoter avec @objc:

NSNotificationCenter.defaultCenter().addObserver(self,
    selector:"batteryLevelChanged:" as Selector,
    name:"UIDeviceBatteryLevelDidChangeNotification",
    object:nil)    

OU

let notificationSelector: Selector = "batteryLevelChanged:"

NSNotificationCenter.defaultCenter().addObserver(self,
    selector: notificationSelector,
    name:"UIDeviceBatteryLevelDidChangeNotification",
    object:nil)    

Ma version xcrun montre Swift 1.2, et cela fonctionne sur Xcode 6.4 et Xcode 7 beta 2 (que je pensais utiliser Swift 2.0):

$xcrun swift --version

Apple Swift version 1.2 (swiftlang-602.0.53.1 clang-602.0.53)

Dans swift 2.2 - XCode 7.3, nous utilisons #selectorpourNSNotificationCenter

 NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(rotate), name: UIDeviceOrientationDidChangeNotification, object: nil)

Nous devons également supprimer la notification.

Ex.

deinit 
{
  NotificationCenter.default.removeObserver(self, name:NSNotification.Name(rawValue: "notify"), object: nil)

}

Dans swift 3, Xcode 8.2: - vérification du niveau d'état de la batterie

//Add observer
NotificationCenter.default.addObserver(self, selector: #selector(batteryStateDidChange), name: NSNotification.Name.UIDeviceBatteryStateDidChange, object: nil)


 //Fired when battery level changes

 func batteryStateDidChange(notification: NSNotification){
        //perform manipulation here
    }

NSNotificationCenter ajoute une syntaxe d'observateur dans Swift 4.0 pour iOS 11

  NotificationCenter.default.addObserver(self, selector: #selector(keyboardShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)

Il s'agit du type de nom de notification keyboardWillShow. Un autre type peut être sélectionné parmi les options disponibles

le sélecteur est de type @objc func qui gère la façon dont le clavier s'affichera (c'est votre fonction utilisateur)

Swift 5 et Xcode 10.2:

NotificationCenter.default.addObserver(
            self,
            selector: #selector(batteryLevelDidChangeNotification),
            name: UIDevice.batteryLevelDidChangeNotification,
            object: nil)

Observateur de notification Swift 5

override func viewDidLoad() {
    super.viewDidLoad() 
    NotificationCenter.default.addObserver(self, selector: #selector(batteryLevelChanged), name: UIDevice.batteryLevelDidChangeNotification, object: nil)
}

@objc func batteryLevelChanged(notification : NSNotification){
    //do here code
}

override func viewWillDisappear(_ animated: Bool) {
    NotificationCenter.default.removeObserver(self, name: UIDevice.batteryLevelDidChangeNotification, object: nil)

}