Swift ios check if remote push notifications are enabled in ios9 and ios10

Question

How can I check if the user has enabled remote notifications on ios 9 or ios 10?

If the user has not allowed or clicked No I want to toggle a message asking if they want to enable notifications.

score 165 · Answer 1 · edited Sep 07 '18 at 09:00

165

Apple recommends to use UserNotifications framework instead of shared instances. So, do not forget to import UserNotifications framework. As this framework is new in iOS 10 it's really only safe to use this code in apps building for 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
    }
})

You may check official documentation for further information: https://developer.apple.com/documentation/usernotifications

edited Sep 07 '18 at 09:00

Kunal Gupta

2,984
31
34

answered Jun 07 '17 at 08:33

Ogulcan Orhan

5,170
6
33
49

2

Seems to me this is the right answer as of July 2017. – Christian Brink Jul 26 '17 at 17:29
2

why isn't this `if` `if else` and `if else`? – Jeremy Bader Oct 13 '17 at 21:28
@OgulcanOrhan yeah I know it works - I used your code and upvoted your answer just so you know :) - I just wanted to know why all three conditionals need to be called? I'm being a little pedantic I suppose – Jeremy Bader Oct 15 '17 at 17:35
22

Yeah, I personally would choose to use a switch statement. – C. Bess Feb 02 '18 at 05:24
Apart from using `else if` use `switch statements` for avoiding any confusion – Paul.V Nov 29 '18 at 10:19
15

It's amazing how they guys at apple always achieve to make something so simple as accessing two booleans to become a mess of async request. I am really curious to know the reasons behind such choices. – jalone Dec 05 '18 at 11:23
This only works with iOS 10+. If you need to support both iOS 9 and iOS 10+ you will need to use a combination of the methods found in this post. – Slowbro Jan 24 '19 at 17:14
what if notifications was enabled and then switched out in the phone settings? – Artemis Shlesberg Oct 16 '20 at 18:25
@jalone but it's not a bool, it's potentially one of many states (currently 5). Also, even if you had a helper that turned it into a bool, it probably wouldn't be too useful as your product would most likely have different behavior depending on if it's .notDetermined or .denied anyways. – Vadoff Feb 04 '21 at 08:25
@Vadoff it was an hyperbole, I meant more in general why don't they provide a callback for the changed values forcing to create wrappers and handle states internally, why (at least at time this was written) documentation was very lacking, too many cases to handle (especially as of today with approximate location, temporary permission), behaviours changing depending on app state, etc. – jalone Feb 04 '21 at 16:00

score 74 · Accepted Answer · edited Dec 13 '22 at 18:48

74

Updated answer after iOS 10 is using UNUserNotificationCenter .

First you need to import UserNotifications then

let current = UNUserNotificationCenter.current()
current.getNotificationSettings(completionHandler: { permission in
    switch permission.authorizationStatus  {
    case .authorized:
        print("User granted permission for notification")
    case .denied:
        print("User denied notification permission")
    case .notDetermined:
        print("Notification permission haven't been asked yet")
    case .provisional:
        // @available(iOS 12.0, *)
        print("The application is authorized to post non-interruptive user notifications.")
    case .ephemeral:
        // @available(iOS 14.0, *)
        print("The application is temporarily authorized to post notifications. Only available to app clips.")
    @unknown default:
        print("Unknow Status")
    }
})

this code will work till iOS 9, for iOS 10 use the above code snippet.

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

edited Dec 13 '22 at 18:48

joshuakcockrell

5,200
2
34
47

answered Nov 10 '16 at 15:32

Rajat

10,977
3
38
55

2

This doesn't appear to work for iOS 10. In the simulator I clicked "Don't Allow" and this code still said user is registered for remote notifications. – tylerSF Jan 28 '17 at 15:27
Works for me on iOS 10. Try using an actual device instead of the simulator. – Justin Vallely Aug 10 '17 at 16:44
8

It tells you only if the token was ever generated (the device was registered), not if the notifications were blocked. – KlimczakM Feb 01 '18 at 14:23
1

Remote Notifications are not supported in the iOS simulator. Only local notifications – Mike Carpenter Jun 17 '18 at 21:00
`isRegisteredForRemoteNotifications` works agin on iOS 12, not iOS 10-11. – BB9z Nov 09 '18 at 10:25
2

This is not the correct way of determining this. When notifications are disabled by the user this property continues to return true even across application restarts. This is odd as it goes against the documentation that states, "The value returned by this method takes into account the user’s preferences for receiving remote notifications." You need to check if notifications are allowed by the user as well. – masterwok Jan 24 '19 at 16:04
I noticed that you did not add break statements in the switch statement. Are these not required? – Abdullah Umer Sep 06 '21 at 19:18
@AbdullahUmer yeah, `break` statement is not required here. The reason is if a switch case has any statement in it, it will automatically end the execution at the end, it will not go to another case. – Rajat Sep 07 '21 at 05:43

score 40 · Answer 3 · edited Dec 21 '17 at 17:29

40

I tried Rajat's solution, but it didn't work for me on iOS 10 (Swift 3). It always said that push notifications were enabled. Below is how I solved the problem. This says "not enabled" if the user has tapped "Don't Allow" or if you have not asked the user yet.

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

PS: The method currentUserNotificationSettings was deprecated in iOS 10.0 but it's still working.

edited Dec 21 '17 at 17:29

Alessandro Francucci

1,528
17
25

answered Jan 28 '17 at 15:44

tylerSF

1,479
2
16
25

Will this work on iOS 9,8,7,etc...or do I need separate code? – Cam Connor Feb 16 '17 at 06:26
I'm not sure, I've only checked it on iOS 10. – tylerSF Feb 17 '17 at 14:24
3

Cam, I just tested this code on 10.2 (on a phone) and on 9.3 (on the simulator) and it worked on both. tylerSF, thanks for the solution. – KeithB Feb 27 '17 at 06:09
1

This solution is better since it also managed the case where user goes in settings, able / disable notifications and goes back in application – Aximem Mar 24 '17 at 14:43
Thanks , what about if i need to change the status for notification from the application , could you please help me in this situation? – wod Aug 19 '17 at 19:27
Not sure what you mean @wod... what are you trying to change? – tylerSF Aug 20 '17 at 20:05
@wod its not possible yet. – vntstudy Oct 30 '17 at 07:03
6

'currentUserNotificationSettings' was deprecated in iOS 10.0: Use UserNotifications Framework's -[UNUserNotificationCenter getNotificationSettingsWithCompletionHandler:] and -[UNUserNotificationCenter getNotificationCategoriesWithCompletionHandler:] – Dot Freelancer Nov 16 '17 at 13:57

score 33 · Answer 4 · edited Mar 25 '18 at 18:30

If your app supports iOS 10 and iOS 8, 9 use below code

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

Then,

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

score 21 · Answer 5 · answered Nov 09 '17 at 05:34

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

                }
            }
        }
    }

I'm getting an error with this `Use of unresolved identifier 'UNUserNotificationCenter'; did you mean 'NSNotificationCenter'?` — ChrisO, Apr 10 '19 at 13:11

onmyway133 · Answer 6 · 2019-01-30T12:47:39.183

@Rajat's answer is not enough.

isRegisteredForRemoteNotifications is that your app has connected to APNS and get device token, this can be for silent push notification
currentUserNotificationSettings is for user permissions, without this, there is no alert, banner or sound push notification delivered to the app

Here is the check

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

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

For iOS 10, instead of checking for currentUserNotificationSettings, you should use 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")
  }
})

Push notification can be delivered to our apps in many ways, and we can ask for that

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

User can go to Settings app and turn off any of those at any time, so it's best to check for that in the settings object

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

Notice that this is deprecated starting iOS 10 – Yuchen Apr 27 '18 at 20:36 — Yuchen, Apr 27 '18 at 20:36

score 8 · Answer 7 · edited May 19 '21 at 08:45

for iOS12 and Swift 4 also support iOS13 and Swift5 I also created a git for this you can check here

just add this singleton file in your XCode Project

import Foundation
import UserNotifications
import UIKit

class NotificaionStatusCheck {
    
    
    var window: UIWindow?
    
    private var currentViewController : UIViewController? = nil
    
    
     static let shared = NotificaionStatusCheck()
    
    public func currentViewController(_ vc: UIViewController?) {
        self.currentViewController = vc
        checkNotificationsAuthorizationStatus()
    }
    
    
    private func checkNotificationsAuthorizationStatus() {
        let userNotificationCenter = UNUserNotificationCenter.current()
        userNotificationCenter.getNotificationSettings { (notificationSettings) in
            switch notificationSettings.authorizationStatus {
            case .authorized:
                print("The app is authorized to schedule or receive notifications.")
                
            case .denied:
                print("The app isn't authorized to schedule or receive notifications.")
                self.NotificationPopup()
            case .notDetermined:
                print("The user hasn't yet made a choice about whether the app is allowed to schedule notifications.")
                self.NotificationPopup()
            case .provisional:
                print("The application is provisionally authorized to post noninterruptive user notifications.")
                self.NotificationPopup()
            }
        }
        
    }
    
    private func NotificationPopup(){
        let alertController = UIAlertController(title: "Notification Alert", message: "Please Turn on the Notification to get update every time the Show Starts", preferredStyle: .alert)
        let settingsAction = UIAlertAction(title: "Settings", style: .default) { (_) -> Void in
            guard let settingsUrl = URL(string: UIApplication.openSettingsURLString) 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.currentViewController?.present(alertController, animated: true, completion: nil)
            
        }
        
    }
    
    
}

to access this code on ViewController user this on viewDidLoad

NotificaionStatusCheck.shared.currentViewController(self)

for case `notDetermined` the permission wasn't requested yet, so whats the point of send the user to settings? It should ask for the permission is this case. — jzeferino, Feb 17 '20 at 15:30
"import UIKit" must be added to use all the UI components in the code. — Pravalika, Jan 20 '21 at 23:45

Oscar Apeland · Answer 8 · 2017-11-20T15:13:49.987

Here's a solution for getting a string describing the current permission that works with iOS 9 trough iOS 11, with Swift 4. This implementation uses When for promises.

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
}

score 5 · Answer 9 · edited Sep 14 '18 at 11:39

5

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

edited Sep 14 '18 at 11:39

Rageofflames

35
1
12

answered Jun 26 '18 at 22:22

Debaprio B

503
7
9

3

please don't do this to make a async operation appear sync -> _ = semaphore.wait(timeout: .now() + 5) – Augie Aug 02 '18 at 20:44
@Augie Is there any specific reason except that async operation might take more than 5 seconds in some rare cases? – ViruMax Feb 12 '20 at 10:52

score 5 · Answer 10 · answered Oct 15 '18 at 22:27

Even though user doesn't allow the push notifications, the device token is available. So it would be also a good idea to check if it's allowed to receive the push notifications.

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

score 4 · Answer 11 · answered Dec 09 '19 at 11:58

All answers above are almost correct BUT if you have push notifications enabled and all options disabled (alertSetting, lockScreenSetting etc.), authorizationStatus will be authorized and you won't receive any push notifications.

The most appropriate way to find out if you user can receive remote notifications is to check all these setting values. You can achieve it using extensions.

Note: This solution works for iOS 10+. If you support older versions, please read previous answers.

extension UNNotificationSettings {

    func isAuthorized() -> Bool {
        guard authorizationStatus == .authorized else {
            return false
        }

        return alertSetting == .enabled ||
            soundSetting == .enabled ||
            badgeSetting == .enabled ||
            notificationCenterSetting == .enabled ||
            lockScreenSetting == .enabled
    }
}

extension UNUserNotificationCenter {

    func checkPushNotificationStatus(onAuthorized: @escaping () -> Void, onDenied: @escaping () -> Void) {
        getNotificationSettings { settings in
            DispatchQueue.main.async {
                guard settings.isAuthorized() {
                    onDenied()
                    return
                }

                onAuthorized()
            }
        }
    }
}

In second snippet there is no else in guard. – CrackIt Mar 29 '23 at 05:15 — CrackIt, Mar 29 '23 at 05:15

score 3 · Answer 12 · answered Apr 29 '22 at 08:55

The new style with async await

 static func getPermissionState() async throws  { 
        let current = UNUserNotificationCenter.current()
        
            let result = await current.notificationSettings()
            switch result.authorizationStatus {
            case .notDetermined:
                //
            case .denied:
                //
            case .authorized:
                //
            case .provisional:
                //
            case .ephemeral:
                //
            @unknown default:
                //
            }
       
    }

Swift ios check if remote push notifications are enabled in ios9 and ios10

12 Answers12

Linked