Jak utworzyć niestandardowe powiadomienia w Swift 3?

Question

W Objective-C niestandardowe powiadomienie to zwykły NSString, ale nie jest to oczywiste w wersji WWDC Swift 3, jak to powinno być.

Answer 1

Można również użyć protokołu do tego

protocol NotificationName { 
    var name: Notification.Name { get } 
} 

extension RawRepresentable where RawValue == String, Self: NotificationName { 
    var name: Notification.Name { 
     get { 
      return Notification.Name(self.rawValue) 
     } 
    } 
} 

a następnie zdefiniować swoje nazwiska powiadomień jako enum gdziekolwiek chcesz . Na przykład:

class MyClass { 
    enum Notifications: String, NotificationName { 
     case myNotification 
    } 
} 

i używać go jak

NotificationCenter.default.post(name: Notifications.myNotification.name, object: nil) 

ten sposób nazwy powiadomień zostanie oddzielona od Fundacji Notification.Name. I będziesz musiał tylko zmodyfikować swój protokół w przypadku zmiany implementacji dla Notification.Name.

Answer 2

Notification.post jest zdefiniowany jako:

public func post(name aName: NSNotification.Name, object anObject: AnyObject?) 

W celu C nazwa zgłoszenie jest zwykły NSString. W Swift jest zdefiniowany jako NSNotification.Name.

NSNotification.Name jest zdefiniowany jako:

public struct Name : RawRepresentable, Equatable, Hashable, Comparable { 
    public init(_ rawValue: String) 
    public init(rawValue: String) 
} 

To jest trochę dziwne, ponieważ chciałbym oczekiwać, że będzie wyliczenia, a nie jakąś niestandardową struct z pozoru nie więcej korzyści.

Jest typealias w powiadamianiu o NSNotification.Name:

public typealias Name = NSNotification.Name 

Mylące jest to, że zarówno Powiadamianie i NSNotification istnieć w Swift

Więc w celu zdefiniowania swój własny powiadomienia zrobić somethine jak:

public class MyClass { 
    static let myNotification = Notification.Name("myNotification") 
} 

Wtedy to nazwać:

NotificationCenter.default().post(name: MyClass.myNotification, object: self) 

Answer 3

Jest czystszy (chyba) sposób to osiągnąć

extension Notification.Name { 

    static let onSelectedSkin = Notification.Name("on-selected-skin") 
} 

I wtedy można go używać jak to

NotificationCenter.default.post(name: .onSelectedSkin, object: selectedSkin) 

Answer 4

To jest po prostu odwołać

// Add observer: 
NotificationCenter.default.addObserver(self, 
    selector: #selector(notificationCallback), 
    name: MyClass.myNotification, 
    object: nil) 

    // Post notification: 
    let userInfo = ["foo": 1, "bar": "baz"] as [String: Any] 
    NotificationCenter.default.post(name: MyClass.myNotification, 
     object: nil, 
     userInfo: userInfo) 

Answer 5

You można dodać niestandardowy inicjator do NSNotification.Name

extension NSNotification.Name { 
    enum Notifications: String { 
     case foo, bar 
    } 
    init(_ value: Notifications) { 
     self = NSNotification.Name(value.rawValue) 
    } 
} 

Zastosowanie:

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

Answer 6

Prostszy sposób:

let name:NSNotification.Name = NSNotification.Name("notificationName") 
NotificationCenter.default.post(name: name, object: nil) 

Answer 7

NSNotification.Name(rawValue: "myNotificationName") 

Answer 8

Zrobiłem własną implementację miksowania rzeczy tam i tam i uważam to za najwygodniejsze. Dzielenie na który każdy że może być zainteresowany:

public extension Notification { 
    public class MyApp { 
     public static let Something = Notification.Name("Notification.MyApp.Something") 
    } 
} 

class ViewController: UIViewController { 
    override func viewDidLoad() { 
     super.viewDidLoad() 
     NotificationCenter.default.addObserver(self, 
               selector: #selector(self.onSomethingChange(notification:)), 
               name: Notification.MyApp.Something, 
               object: nil) 
    } 

    deinit { 
     NotificationCenter.default.removeObserver(self) 
    } 

    @IBAction func btnTapped(_ sender: UIButton) { 
     NotificationCenter.default.post(name: Notification.MyApp.Something, 
             object: self, 
            userInfo: [Notification.MyApp.Something:"foo"]) 
    } 

    func onSomethingChange(notification:NSNotification) { 
     print("notification received") 
     let userInfo = notification.userInfo! 
     let key = Notification.MyApp.Something 
     let something = userInfo[key]! as! String //Yes, this works :) 
     print(something) 
    } 
} 

Answer 9

Zaletą korzystania teksty stałe jest to, że możemy uzyskać kompilator, by sprawdzić, czy nazwa jest prawidłowa. Zmniejsza potencjalne problemy i ułatwia refaktoryzację.

Dla tych, którzy lubią za pomocą teksty stałe zamiast cudzysłowami w nazwach powiadomień, kod ten załatwia sprawę:

enum MyNotification: String { 
    case somethingHappened 
    case somethingElseHappened 
    case anotherNotification 
    case oneMore 
} 

extension NotificationCenter { 
    func add(observer: Any, selector: Selector, 
      notification: MyNotification, object: Any? = nil) { 
     addObserver(observer, selector: selector, 
        name: Notification.Name(notification.rawValue), 
        object: object) 
    } 
    func post(notification: MyNotification, 
       object: Any? = nil, userInfo: [AnyHashable: Any]? = nil) { 
     post(name: NSNotification.Name(rawValue: notification.rawValue), 
      object: object, userInfo: userInfo) 
    } 
} 

Wtedy można go używać tak:

NotificationCenter.default.post(.somethingHappened) 

choć niezwiązany do pytanie, to samo można zrobić z sekwencjami scenariusza, aby uniknąć pisania cytowanych ciągów znaków:

enum StoryboardSegue: String { 
    case toHere 
    case toThere 
    case unwindToX 
} 

extension UIViewController { 
    func perform(segue: StoryboardSegue) { 
     performSegue(withIdentifier: segue.rawValue, sender: self) 
    } 
} 

Następnie na kontrolerze widoku, nazywają to lubią:

perform(segue: .unwindToX) 

Answer 10

jeśli używasz niestandardowych powiadomień String-tylko, że nie ma żadnych powodów, by przedłużyć klas ale String

extension String { 
     var notificationName : Notification.Name{ 
      return Notification.Name.init(self) 
     } 
    }