Come si aggiunge un osservatore in Swift al centro di notifica predefinito? Sto provando a portare questa riga di codice che invia una notifica quando il livello della batteria cambia.

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

È uguale all'API Objective-C, ma utilizza la sintassi di Swift.

Swift 4.2 e Swift 5:

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

Se il tuo osservatore non eredita da un oggetto Objective-C, devi @objcusare il prefisso del tuo metodo per usarlo come selettore.

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

Vedere Riferimento alla classe NSNotificationCenter , Interazione con le API Objective-C

Swift 4.0 e Xcode 9.0+:

Invia notifica (posta):

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

O

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

Ricevi (ricevi) notifica:

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

Gestore del metodo di funzione per la notifica ricevuta:

@objc func methodOfReceivedNotification(notification: Notification) {}

Swift 3.0 e Xcode 8.0+:

Invia notifica (posta):

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

Ricevi (ricevi) notifica:

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

Gestore del metodo per la notifica ricevuta:

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

Rimuovi notifica:

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

Swift 2.3 e Xcode 7:

Invia notifica (posta)

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

Ricevi (ricevi) notifica

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

Gestore del metodo per la notifica ricevuta

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

Per le versioni storiche di Xcode ...

Invia notifica (posta)

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

Ricevi (ricevi) notifica

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

Rimuovi notifica

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

Gestore del metodo per la notifica ricevuta

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

Annota la classe o il metodo target con @objc

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

// Or

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

Un buon modo per farlo è usare il addObserver(forName:object:queue:using:)metodo piuttosto che il addObserver(_:selector:name:object:)metodo che viene spesso usato dal codice Objective-C. Il vantaggio della prima variante è che non è necessario utilizzare l' @objcattributo sul metodo:

    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)

e puoi anche usare una chiusura anziché un metodo se vuoi:

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

È possibile utilizzare il valore restituito per interrompere l'ascolto della notifica in un secondo momento:

    NotificationCenter.default.removeObserver(observer)

C'era un altro vantaggio nell'uso di questo metodo, che consisteva nel fatto che non richiedeva l'uso di stringhe di selezione che non potevano essere controllate staticamente dal compilatore e quindi fragili da rompersi se il metodo è stato rinominato, ma Swift 2.2 e in seguito includono #selectorespressioni che risolvono quel problema.

Swift 3.0 in Xcode 8

Swift 3.0 ha sostituito molte API "tipicamente stringa" con struct"tipi di wrapper", come nel caso di NotificationCenter. Le notifiche sono ora identificate da un struct Notfication.Nameanziché da String. Consulta la guida alla migrazione a Swift 3 .

Utilizzo precedente :

// 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)

Nuovo utilizzo di 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)

Tutti i tipi di notifica del sistema sono ora definiti come costanti statiche attive Notification.Name; cioè .UIDeviceBatteryLevelDidChange, .UIApplicationDidFinishLaunching,.UITextFieldTextDidChange , etc.

Puoi estenderti Notification.Namecon le tue notifiche personalizzate per rimanere coerente con le notifiche di sistema:

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

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

1. Dichiara un nome di notifica

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

2. Puoi aggiungere l'osservatore in due modi:

   utilizzando 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"]
   }

   o usando 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. Pubblica la tua notifica

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

da iOS 9 e OS X 10.11. Non è più necessario che un osservatore NSNotificationCenter si annulli la sua registrazione quando viene deallocato. Ulteriori informazioni

Per blockun'implementazione basata è necessario eseguire una danza debole e forte se si desidera utilizzare selfall'interno del blocco. Ulteriori informazioni

È necessario rimuovere più informazioni dagli osservatori basati su blocchi

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

Passare i dati utilizzando NSNotificationCenter

Puoi anche passare i dati utilizzando NotificationCentre in swift 3.0 e NSNotificationCenter in swift 2.0.

Versione Swift 2.0

Passare informazioni utilizzando userInfo che è un dizionario facoltativo di tipo [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   
  }
}

Versione Swift 3.0

L'utenteInfo ora prende [AnyHashable: Any]? come argomento, che forniamo come dizionario letterale in 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   
  }
}

Dati di passaggio sorgente utilizzando NotificationCentre (swift 3.0) e NSNotificationCenter (swift 2.0)

In Swift 5

Diciamo se si desidera ricevere dati da ViewControllerB a ViewControllerA

ViewControllerA (Ricevitore)

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 (mittente)

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)
    }

}

Sono in grado di eseguire una delle seguenti operazioni per utilizzare correttamente un selettore, senza annotare nulla con @objc:

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

O

let notificationSelector: Selector = "batteryLevelChanged:"

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

La mia versione di xcrun mostra Swift 1.2, e questo funziona su Xcode 6.4 e Xcode 7 beta 2 (che pensavo avrebbe usato Swift 2.0):

$xcrun swift --version

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

In rapido 2.2 - XCode 7.3, usiamo #selectorperNSNotificationCenter

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

Dovremmo rimuovere anche la notifica.

Ex.

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

}

In swift 3, Xcode 8.2: - verifica del livello di stato della batteria

//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 aggiunge la sintassi dell'osservatore in Swift 4.0 per iOS 11

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

Questo è per il tipo di nome di notifica keyboardWillShow. Altro tipo può essere selezionato dall'opzione disponibile

il Selettore è di tipo @objc func che gestisce la modalità di visualizzazione della tastiera (questa è la tua funzione utente)

Swift 5 e Xcode 10.2:

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

Swift 5 Notification Observer

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)

}