web-dev-qa-db-fra.com

Swift ios vérifie si les notifications Push à distance sont activées dans ios9 et ios10

Comment puis-je vérifier si l'utilisateur a activé les notifications à distance sur ios 9 ou ios 10?

Si l'utilisateur n'a pas autorisé ou cliqué sur Non, je souhaite basculer un message lui demandant s'il souhaite activer les notifications.

iosswiftxcodepush-notification
47
user2636197

Cette réponse est obsolète et ne supporte pas sur iOS 10, vous pouvez vérifier this answer.

Utilisez ce code

let isRegisteredForRemoteNotifications = UIApplication.shared.isRegisteredForRemoteNotifications
if isRegisteredForRemoteNotifications {
     // User is registered for notification
} else {
     // Show alert user is not registered for notification
}
22
Rajat

Apple recommande d'utiliser la structure UserNotifications au lieu d'instances partagées. Alors, n'oubliez pas d'importer UserNotifications framework. Comme ce cadre est nouveau dans iOS 10, il est vraiment prudent d’utiliser ce code dans la création d’applications pour iOS10 +.

let current = UNUserNotificationCenter.current()

current.getNotificationSettings(completionHandler: { (settings) in
    if settings.authorizationStatus == .notDetermined {
        // Notification permission has not been asked yet, go for it!
    } else if settings.authorizationStatus == .denied {
        // Notification permission was previously denied, go to settings & privacy to re-enable
    } else if settings.authorizationStatus == .authorized {
        // Notification permission was already granted
    }
})

Vous pouvez consulter la documentation officielle pour plus d'informations: https://developer.Apple.com/documentation/usernotifications

93
Ogulcan Orhan

J'ai essayé la solution de Rajat, mais cela n'a pas fonctionné pour moi sur iOS 10 (Swift 3). Il a toujours dit que les notifications Push étaient activées. Voici comment j'ai résolu le problème. Ceci dit "non activé" si l'utilisateur a tapé sur "Ne pas autoriser" ou si vous ne l'avez pas encore demandé à l'utilisateur.

let notificationType = UIApplication.shared.currentUserNotificationSettings!.types
    if notificationType == [] {
        print("notifications are NOT enabled")
    } else {
        print("notifications are enabled")
    }

PS: La méthode currentUserNotificationSettings était obsolète dans iOS 10.0 mais elle fonctionne toujours.

37
tylerSF

Si votre application prend en charge iOS 10 et iOS 8, 9 utilisez le code ci-dessous.

// At the top, import UserNotifications 
// to use UNUserNotificationCenter
import UserNotifications

Ensuite,

if #available(iOS 10.0, *) {
    let current = UNUserNotificationCenter.current()
    current.getNotificationSettings(completionHandler: { settings in

        switch settings.authorizationStatus {

        case .notDetermined:
            // Authorization request has not been made yet
        case .denied:
            // User has denied authorization.
            // You could tell them to change this in Settings
        case .authorized:
            // User has given authorization.
        }
    })
 } else {
     // Fallback on earlier versions
     if UIApplication.shared.isRegisteredForRemoteNotifications {
         print("APNS-YES")
     } else {
         print("APNS-NO")
     }
 }
28
Imtee

dans iOS11, Swift 4 ...

 UNUserNotificationCenter.current().getNotificationSettings { (settings) in
        if settings.authorizationStatus == .authorized {
            // Already authorized
        }
        else {
            // Either denied or notDetermined
            UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) {
                (granted, error) in
                  // add your own 
                UNUserNotificationCenter.current().delegate = self
                let alertController = UIAlertController(title: "Notification Alert", message: "please enable notifications", preferredStyle: .alert)
                let settingsAction = UIAlertAction(title: "Settings", style: .default) { (_) -> Void in
                    guard let settingsUrl = URL(string: UIApplicationOpenSettingsURLString) else {
                        return
                    }
                    if UIApplication.shared.canOpenURL(settingsUrl) {
                        UIApplication.shared.open(settingsUrl, completionHandler: { (success) in
                        })
                    }
                }
                let cancelAction = UIAlertAction(title: "Cancel", style: .default, handler: nil)
                alertController.addAction(cancelAction)
                alertController.addAction(settingsAction)
                DispatchQueue.main.async {
                    self.window?.rootViewController?.present(alertController, animated: true, completion: nil)

                }
            }
        }
    }
13
joel prithivi

Voici une solution pour obtenir une chaîne décrivant l'autorisation actuelle qui fonctionne avec iOS 9 via iOS 11, avec Swift 4. Cette implémentation utilise When pour les promesses.

import UserNotifications

private static func getNotificationPermissionString() -> Promise<String> {
    let promise = Promise<String>()

    if #available(iOS 10.0, *) {
        let notificationCenter = UNUserNotificationCenter.current()
        notificationCenter.getNotificationSettings { (settings) in
            switch settings.authorizationStatus {
            case .notDetermined: promise.resolve("not_determined")
            case .denied: promise.resolve("denied")
            case .authorized: promise.resolve("authorized")
            }
        }
    } else {
        let status = UIApplication.shared.isRegisteredForRemoteNotifications ? "authorized" : "not_determined"
        promise.resolve(status)
    }

    return promise
}
7
Oscar Apeland

@ La réponse de Rajat ne suffit pas.

  • isRegisteredForRemoteNotifications c'est que votre application s'est connectée à APNS et obtient un jeton de périphérique, cela peut être pour une notification Push silencieuse
  • currentUserNotificationSettings est destiné aux autorisations des utilisateurs. Sans cela, il n'y a pas d'alerte, de bannière ou de son. Notification Push envoyée à l'application.

Voici le chèque

static var isPushNotificationEnabled: Bool {
  guard let settings = UIApplication.shared.currentUserNotificationSettings
    else {
      return false
  }

  return UIApplication.shared.isRegisteredForRemoteNotifications
    && !settings.types.isEmpty
}

Pour iOS 10, au lieu de rechercher currentUserNotificationSettings, vous devez utiliser UserNotifications framework.

center.getNotificationSettings(completionHandler: { settings in
  switch settings.authorizationStatus {
  case .authorized, .provisional:
    print("authorized")
  case .denied:
    print("denied")
  case .notDetermined:
    print("not determined, ask user for permission now")
  }
})

La notification push peut être transmise à nos applications de nombreuses façons, et nous pouvons le demander.

UNUserNotificationCenter.current()
  .requestAuthorization(options: [.alert, .sound, .badge])

L'utilisateur peut aller dans l'application Paramètres et désactiver n'importe lequel d'entre eux à tout moment. Il est donc préférable de vérifier cela dans l'objet settings.

open class UNNotificationSettings : NSObject, NSCopying, NSSecureCoding {


    open var authorizationStatus: UNAuthorizationStatus { get }


    open var soundSetting: UNNotificationSetting { get }

    open var badgeSetting: UNNotificationSetting { get }

    open var alertSetting: UNNotificationSetting { get }


    open var notificationCenterSetting: UNNotificationSetting { get }
}
7
onmyway133
class func isRegisteredForRemoteNotifications() -> Bool {
    if #available(iOS 10.0, *) {
        var isRegistered = false
        let semaphore = DispatchSemaphore(value: 0)
        let current = UNUserNotificationCenter.current()
        current.getNotificationSettings(completionHandler: { settings in
            if settings.authorizationStatus != .authorized {
                isRegistered = false
            } else {
                isRegistered = true
            }
            semaphore.signal()
        })
        _ = semaphore.wait(timeout: .now() + 5)
        return isRegistered
    } else {
        return UIApplication.shared.isRegisteredForRemoteNotifications
    }
}
2
Debaprio B

Même si l'utilisateur n'autorise pas les notifications Push, le jeton de périphérique est disponible. Il serait donc judicieux de vérifier si autorisé reçoit les notifications Push.

private func checkPushNotificationAllowed(completionHandler: @escaping (Bool) -> Void) {
    if #available(iOS 10.0, *) {
        UNUserNotificationCenter.current().getNotificationSettings { (settings) in
            if settings.authorizationStatus == .notDetermined || settings.authorizationStatus == .denied {
                completionHandler(false)
            }
            else {
                completionHandler(true)
            }
        }
    }
    else {
        if let settings = UIApplication.shared.currentUserNotificationSettings {
            if settings.types.isEmpty {
                completionHandler(false)
            }
            else {
                completionHandler(true)
            }
        }
        else {
            completionHandler(false)
        }
    }
}
2
Joey