Registrierung für Push-Benachrichtigungen in Xcode 8 / Swift 3.0?

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

    if #available(iOS 10, *) {

        //Notifications get posted to the function (delegate):  func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: () -> Void)"


        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { (granted, error) in

            guard error == nil else {
                //Display Error.. Handle Error.. etc..
                return
            }

            if granted {
                //Do stuff here..

                //Register for RemoteNotifications. Your Remote Notifications can display alerts now :)
                DispatchQueue.main.async {
                    application.registerForRemoteNotifications()
                }
            }
            else {
                //Handle user denying permissions..
            }
        }

        //Register for remote notifications.. If permission above is NOT granted, all notifications are delivered silently to AppDelegate.
        application.registerForRemoteNotifications()
    }
    else {
        let settings = UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)
        application.registerUserNotificationSettings(settings)
        application.registerForRemoteNotifications()
    }

    return true
}

InformationsquelleAutor der Antwort Brandon

In iOS10 anstelle des Codes, sollten Sie einen Antrag auf eine Bewilligung für die Benachrichtigung mit der folgenden: (vergessen Sie nicht, fügen Sie die UserNotifications Framework)

if #available(iOS 10.0, *) {
        UNUserNotificationCenter.current().requestAuthorization([.alert, .sound, .badge]) { (granted: Bool, error: NSError?) in
            //Do something here
        }
    }

Auch der richtige code für dich ist (Verwendung in der else von den früheren Zustand, zum Beispiel):

let setting = UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)
UIApplication.shared().registerUserNotificationSettings(setting)
UIApplication.shared().registerForRemoteNotifications()

Schließlich, stellen Sie sicher, dass Push Notification aktiviert ist unter target-> Capabilities -> Push notification. (setzen Sie ihn auf On)

InformationsquelleAutor der Antwort tsnkff

Gut diese Arbeit für mich.
Zuerst in AppDelegate

import UserNotifications

Dann:

   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        //Override point for customization after application launch.
        registerForRemoteNotification()
        return true
    }

    func registerForRemoteNotification() {
        if #available(iOS 10.0, *) {
            let center  = UNUserNotificationCenter.current()
            center.delegate = self
            center.requestAuthorization(options: [.sound, .alert, .badge]) { (granted, error) in
                if error == nil{
                    UIApplication.shared.registerForRemoteNotifications()
                }
            }
        }
        else {
            UIApplication.shared.registerUserNotificationSettings(UIUserNotificationSettings(types: [.sound, .alert, .badge], categories: nil))
            UIApplication.shared.registerForRemoteNotifications()
        }
    }

Bekommen devicetoken:

  func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {

       let deviceTokenString = deviceToken.reduce("", {$0 + String(format: "%02X", $1)})

}

InformationsquelleAutor der Antwort GoIn Su

Ersten, hören Benachrichtigung des Benutzers, status, D. H., registerForRemoteNotifications() zu bekommen APNs-device-token;

Zweiten, Antrag auf Genehmigung. Wenn die Genehmigung von dem Benutzer, deviceToken gesendet, um die Hörer, die AppDelegate;

Dritten, Bericht der device-token an Ihren server.

extension AppDelegate {
    ///1. 监听 deviceToken
    UIApplication.shared.registerForRemoteNotifications()

    ///2. 向操作系统索要推送权限（并获取推送 token）
    static func registerRemoteNotifications() {
        if #available(iOS 10, *) {
            let uc = UNUserNotificationCenter.current()
            uc.delegate = UIApplication.shared.delegate as? AppDelegate
            uc.requestAuthorization(options: [.alert, .badge, .sound]) { (granted, error) in
                if let error = error { //无论是拒绝推送，还是不提供 aps-certificate，此 error 始终为 nil
                    print("UNUserNotificationCenter 注册通知失败, \(error)")
                }
                DispatchQueue.main.async {
                    onAuthorization(granted: granted)
                }
            }
        } else {
            let app = UIApplication.shared
            app.registerUserNotificationSettings(UIUserNotificationSettings(types: [.badge, .sound, .alert], categories: nil)) //获取用户授权
        }
    }

    //在 app.registerUserNotificationSettings() 之后收到用户接受或拒绝及默拒后，此委托方法被调用
    func application(_ app: UIApplication, didRegister notificationSettings: UIUserNotificationSettings) {
        //已申请推送权限，所作的检测才有效
        //a 征询推送许可时，用户把app切到后台，就等价于默拒了推送
        //b 在系统设置里打开推送，但关掉所有形式的提醒，等价于拒绝推送，得不token，也收不推送
        //c 关掉badge, alert和sound 时，notificationSettings.types.rawValue 等于 0 和 app.isRegisteredForRemoteNotifications 成立，但能得到token，也能收到推送（锁屏和通知中心也能看到推送），这说明types涵盖并不全面
        //对于模拟器来说，由于不能接收推送，所以 isRegisteredForRemoteNotifications 始终为 false
       onAuthorization(granted: app.isRegisteredForRemoteNotifications)
    }

    static func onAuthorization(granted: Bool) {
        guard granted else { return }
        //do something
    }
}

extension AppDelegate {
    func application(_ app: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        //
    }

    //模拟器得不到 token，没配置 aps-certificate 的项目也得不到 token，网络原因也可能导致得不到 token
    func application(_ app: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
        //
    }
}

InformationsquelleAutor der Antwort Dawn Song

Die Antwort von ast1 ist sehr einfach und nützlich. Es funktioniert für mich, ich danke Ihnen so sehr.
Ich will einfach nur, um poin es hier so Menschen, die brauchen diese Antwort kann es leicht finden. So, hier ist mein code von der Registrierung von lokalen und remote - (push -) Benachrichtigung.

    //1. In Appdelegate: didFinishLaunchingWithOptions add these line of codes
    let mynotif = UNUserNotificationCenter.current()
    mynotif.requestAuthorization(options: [.alert, .sound, .badge]) {(granted, error) in }//register and ask user's permission for local notification

    //2. Add these functions at the bottom of your AppDelegate before the last "}"
    func application(_ application: UIApplication, didRegister notificationSettings: UNNotificationSettings) {
        application.registerForRemoteNotifications()//register for push notif after users granted their permission for showing notification
}
    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let tokenString = deviceToken.reduce("", {$0 + String(format: "%02X", $1)})
    print("Device Token: \(tokenString)")//print device token in debugger console
}
    func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
    print("Failed to register: \(error)")//print error in debugger console
}

InformationsquelleAutor der Antwort Luthfi Rahman

Hier ist der code in Swift 4.1 und Xcode 9.3

1. Aktivieren von Push-Benachrichtigungen - gehen Sie Einfach auf der Projekt-editor, um Ihr Ziel, und klicken Sie dann auf die Registerkarte Funktionen. Suchen Sie für Push-Benachrichtigungen und setzen Sie seinen Wert AUF.

2. In iOS 10, ein neues framework namens UserNotifications eingeführt wurde und importiert werden müssen, um Zugriff auf die UNUserNotificationCenter Klasse.
   Fügen Sie die folgende import-Anweisung am Anfang des AppDelegate.swift

   import UserNotifications

Nächste, gehen Sie zu den Projekt-editor, um Ihr Ziel, und in der Registerkarte allgemein, suchen Sie die Verlinkten Frameworks und Bibliotheken Abschnitt.

Klicken Sie auf +, und wählen Sie UserNotifications.Rahmen

Benutzer folgenden Methoden, um registrieren und behandeln APNS

    //MARK: - Remote Notificaton
extension AppDelegate: UNUserNotificationCenterDelegate {

    func registerForPushNotifications(application: UIApplication) {
        if #available(iOS 10.0, *) {
            UNUserNotificationCenter.current().requestAuthorization(options: [.badge, .sound, .alert], completionHandler: { (granted, _) in
                if granted {
                    UIApplication.shared.registerForRemoteNotifications()
                } else { }
            })
        } else {
            let notificationSettings = UIUserNotificationSettings(
                types: [.badge, .sound, .alert], categories: nil)
            UIApplication.shared.registerUserNotificationSettings(notificationSettings)
        }
    }

    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        let deviceToken = deviceToken.hexString()
        Debug.Log(message: "Device Token - \(deviceToken.hexString())")
    }

    func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
        Debug.Log(message: "Failed to register for RemoteNotifications")
    }

    @available(iOS 10.0, *)
    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        //Handle the notification
        if UIApplication.shared.applicationState == .inactive {
            let seconds = 1.0
            let delay = seconds * Double(NSEC_PER_SEC)  //nanoseconds per seconds
            let dispatchTime = DispatchTime.now() + Double(Int64(delay)) / Double(NSEC_PER_SEC)
            DispatchQueue.main.asyncAfter(deadline: dispatchTime, execute: {
                self.handlerRemoteNotification(response.notification.request.content.userInfo)
            })
        } else {
            handlerRemoteNotification(response.notification.request.content.userInfo)
        }
    }

    func handlerRemoteNotification(_ userInfo: [AnyHashable: Any]) {
        if #available(iOS 10.0, *) {
        } else {
            if UIApplication.shared.applicationState != .active { return }
        }
        if let jsonString: String = userInfo["parameters"] as? String {
            let data = jsonString.data(using: String.Encoding.utf8, allowLossyConversion: false)!
            do {
                let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: AnyObject]
                if let json = json {
                  //handle Json
                }
            } catch let error as NSError {
                Debug.Log(message: "Failed to load: \(error.localizedDescription)")
            }
        }
    }

    func application( _ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any], fetchCompletionHandler handler: @escaping (UIBackgroundFetchResult) -> Void) {

        if UIApplication.shared.applicationState != .active {
            if let cId = userInfo["Number"] as? Int64 {
              //Push your ViewController
          }
        } else {
        }
  }
}

//Here extension for data
extension Data {
  func hexString() -> String {
    return self.reduce("") { string, byte in
      string + String(format: "%02X", byte)
    }
  }
}

InformationsquelleAutor der Antwort Gurjinder Singh Khalsa