确定 iPhone 上用户是否启用了推送通知

Question

我正在寻找一种方法来确定用户是否通过设置启用或禁用了我的应用程序的推送通知。

Answer 1

调用enabledRemoteNotificationsTypes并检查掩码。

例如：

UIRemoteNotificationType types = [[UIApplication sharedApplication] enabledRemoteNotificationTypes];
if (types == UIRemoteNotificationTypeNone) 
   // blah blah blah

iOS8及以上版本：

[[UIApplication sharedApplication] isRegisteredForRemoteNotifications]

Answer 2

Quantumpotato 的问题：

其中 types 是由

UIRemoteNotificationType types = [[UIApplication sharedApplication] enabledRemoteNotificationTypes];

一个可以使用的

if (types & UIRemoteNotificationTypeAlert)

代替

if (types == UIRemoteNotificationTypeNone) 

的给出的，它允许您仅检查通知是否已启用（并且不用担心声音、徽章、通知中心等）。如果“Alert Style”设置为“Banners”或“Alerts”，第一行代码 (types & UIRemoteNotificationTypeAlert) 将返回 YES，并且 NO< /code> 如果“警报样式”设置为“无”，无论其他设置如何。

Answer 3

更新了 swift4.0、iOS11 的代码

import UserNotifications

UNUserNotificationCenter.current().getNotificationSettings { (settings) in
   print("Notification settings: \(settings)")
   guard settings.authorizationStatus == .authorized else { return }

   //Not authorised 
   UIApplication.shared.registerForRemoteNotifications()
}

更新了 swift3.0、iOS10 的代码

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

从 iOS9 开始，swift 2.0 UIRemoteNotificationType 已弃用，请使用以下代码

let notificationType = UIApplication.shared.currentUserNotificationSettings!.types
if notificationType == UIUserNotificationType.none {
        // Push notifications are disabled in setting by user.
    }else{
  // Push notifications are enabled in setting by user.

}

只需检查是否启用推送通知

    if notificationType == UIUserNotificationType.badge {
        // the application may badge its icon upon a notification being received
    }
    if notificationType == UIUserNotificationType.sound {
        // the application may play a sound upon a notification being received

    }
    if notificationType == UIUserNotificationType.alert {
        // the application may display an alert upon a notification being received
    }

Answer 4

在最新版本的 iOS 中，此方法现已弃用。要同时支持 iOS 7 和 iOS 8，请使用：

UIApplication *application = [UIApplication sharedApplication];

BOOL enabled;

// Try to use the newer isRegisteredForRemoteNotifications otherwise use the enabledRemoteNotificationTypes.
if ([application respondsToSelector:@selector(isRegisteredForRemoteNotifications)])
{
    enabled = [application isRegisteredForRemoteNotifications];
}
else
{
    UIRemoteNotificationType types = [application enabledRemoteNotificationTypes];
    enabled = types & UIRemoteNotificationTypeAlert;
}

Answer 5

您将在下面找到涵盖 iOS8 和 iOS7（及更低版本）的完整示例。请注意，在 iOS8 之前，您无法区分“远程通知已禁用”和“仅在锁定屏幕中查看启用”。

BOOL remoteNotificationsEnabled = false, noneEnabled,alertsEnabled, badgesEnabled, soundsEnabled;

if ([[UIApplication sharedApplication] respondsToSelector:@selector(registerUserNotificationSettings:)]) {
    // iOS8+
    remoteNotificationsEnabled = [UIApplication sharedApplication].isRegisteredForRemoteNotifications;

    UIUserNotificationSettings *userNotificationSettings = [UIApplication sharedApplication].currentUserNotificationSettings;

    noneEnabled = userNotificationSettings.types == UIUserNotificationTypeNone;
    alertsEnabled = userNotificationSettings.types & UIUserNotificationTypeAlert;
    badgesEnabled = userNotificationSettings.types & UIUserNotificationTypeBadge;
    soundsEnabled = userNotificationSettings.types & UIUserNotificationTypeSound;

} else {
    // iOS7 and below
    UIRemoteNotificationType enabledRemoteNotificationTypes = [UIApplication sharedApplication].enabledRemoteNotificationTypes;

    noneEnabled = enabledRemoteNotificationTypes == UIRemoteNotificationTypeNone;
    alertsEnabled = enabledRemoteNotificationTypes & UIRemoteNotificationTypeAlert;
    badgesEnabled = enabledRemoteNotificationTypes & UIRemoteNotificationTypeBadge;
    soundsEnabled = enabledRemoteNotificationTypes & UIRemoteNotificationTypeSound;
}

if ([[UIApplication sharedApplication] respondsToSelector:@selector(registerUserNotificationSettings:)]) {
    NSLog(@"Remote notifications enabled: %@", remoteNotificationsEnabled ? @"YES" : @"NO");
}

NSLog(@"Notification type status:");
NSLog(@"  None: %@", noneEnabled ? @"enabled" : @"disabled");
NSLog(@"  Alerts: %@", alertsEnabled ? @"enabled" : @"disabled");
NSLog(@"  Badges: %@", badgesEnabled ? @"enabled" : @"disabled");
NSLog(@"  Sounds: %@", soundsEnabled ? @"enabled" : @"disabled");

Answer 6

Swift 3+

    if #available(iOS 10.0, *) {
        UNUserNotificationCenter.current().getNotificationSettings(completionHandler: { (settings: UNNotificationSettings) in
            // settings.authorizationStatus == .authorized
        })
    } else {
        return UIApplication.shared.currentUserNotificationSettings?.types.contains(UIUserNotificationType.alert) ?? false
    }

iOS10+ 的 RxSwift Observable 版本：

import UserNotifications
extension UNUserNotificationCenter {
    static var isAuthorized: Observable<Bool> {
        return Observable.create { observer in
            DispatchQueue.main.async {
                current().getNotificationSettings(completionHandler: { (settings: UNNotificationSettings) in
                    if settings.authorizationStatus == .authorized {
                        observer.onNext(true)
                        observer.onCompleted()
                    } else {
                        current().requestAuthorization(options: [.badge, .alert, .sound]) { (granted, error) in
                            observer.onNext(granted)
                            observer.onCompleted()
                        }
                    }
                })
            }
            return Disposables.create()
        }
    }
}

Answer 7

在尝试支持 iOS8 及更低版本时，我没有按照 Kevin 建议的那样使用 isRegisteredForRemoteNotifications 。相反，我使用了 currentUserNotificationSettings，它在我的测试中效果很好。

+ (BOOL)notificationServicesEnabled {
    BOOL isEnabled = NO;

    if ([[UIApplication sharedApplication] respondsToSelector:@selector(currentUserNotificationSettings)]){
        UIUserNotificationSettings *notificationSettings = [[UIApplication sharedApplication] currentUserNotificationSettings];

        if (!notificationSettings || (notificationSettings.types == UIUserNotificationTypeNone)) {
            isEnabled = NO;
        } else {
            isEnabled = YES;
        }
    } else {
        UIRemoteNotificationType types = [[UIApplication sharedApplication] enabledRemoteNotificationTypes];
        if (types & UIRemoteNotificationTypeAlert) {
            isEnabled = YES;
        } else{
            isEnabled = NO;
        }
    }

    return isEnabled;
}

Answer 8

不幸的是，这些解决方案都没有真正解决问题，因为归根结底，API 在提供相关信息方面严重缺乏。您可以做出一些猜测，但是使用 currentUserNotificationSettings (iOS8+) 在当前形式下不足以真正回答问题。尽管这里的许多解决方案似乎表明要么 isRegisteredForRemoteNotifications 要么是更明确的答案，但实际上并非如此。

考虑一下：

isRegisteredForRemoteNotifications 文档指出：

如果应用程序当前已注册远程通知，则返回 YES，并考虑所有系统范围的设置...

但是，如果您将一个简单的 NSLog 放入您的应用程序委托中来观察行为，很明显这不会表现出来我们预期它会如何运作。它实际上直接与已为此应用程序/设备激活的远程通知相关。第一次激活后，将始终返回 YES。即使在设置（通知）中关闭它们仍然会导致返回 YES 这是因为，从 iOS8 开始，应用程序可能会注册远程通知，甚至在用户未启用通知的情况下发送到设备，如果用户没有打开警报、徽章和声音，他们可能不会执行这些操作。无声通知是一个很好的例子，说明即使通知关闭，您也可以继续执行某些操作。

就 currentUserNotificationSettings 而言，它指示以下四件事之一：

警报已开启
徽章已开启
声音已打开
没有一个打开。

这绝对不会向您提供有关其他因素或通知开关本身的任何指示。

用户实际上可以关闭徽章、声音和警报，但仍然在锁屏或通知中心显示。该用户应该仍然可以接收推送通知，并且能够在锁定屏幕和通知中心看到它们。他们打开了通知开关。但在这种情况下，currentUserNotificationSettings 将返回：UIUserNotificationTypeNone。这并不真正代表用户的实际设置。

人们可以做出一些猜测：

• 如果 isRegisteredForRemoteNotifications 为 NO 那么您可以假设该设备从未成功注册远程通知。
• 第一次注册远程通知后，会对 application:didRegisterUserNotificationSettings: 进行回调，此时包含用户通知设置，因为这是用户第一次注册，设置应该< /em> 指示用户在权限请求方面选择的内容。如果设置等于 UIUserNotificationTypeNone 以外的任何内容，则授予推送权限，否则将被拒绝。原因是，从您开始远程注册过程的那一刻起，用户只能接受或拒绝，接受的初始设置是您在注册过程中设置的设置。

Answer 9

为了完成答案，它可以像这样工作......

UIRemoteNotificationType types = [[UIApplication sharedApplication] enabledRemoteNotificationTypes];
switch (types) {
   case UIRemoteNotificationTypeAlert:
   case UIRemoteNotificationTypeBadge:
       // For enabled code
       break;
   case UIRemoteNotificationTypeSound:
   case UIRemoteNotificationTypeNone:
   default:
       // For disabled code
       break;
}

编辑：这是不对的。因为这些是按位的东西，所以它不能与开关一起使用，所以我最终使用了这个：

UIRemoteNotificationType types = [[UIApplication sharedApplication] enabledRemoteNotificationTypes];
UIRemoteNotificationType typesset = (UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeBadge);
if((types & typesset) == typesset)
{
    CeldaSwitch.chkSwitch.on = true;
}
else
{
    CeldaSwitch.chkSwitch.on = false;
}

Answer 10

iOS8+（目标C）

#import <UserNotifications/UserNotifications.h>


[[UNUserNotificationCenter currentNotificationCenter]getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings * _Nonnull settings) {

    switch (settings.authorizationStatus) {
          case UNAuthorizationStatusNotDetermined:{

            break;
        }
        case UNAuthorizationStatusDenied:{

            break;
        }
        case UNAuthorizationStatusAuthorized:{

            break;
        }
        default:
            break;
    }
}];

Answer 11

对于 iOS7 及之前的版本，您确实应该使用 enabledRemoteNotificationTypes 并检查它是否等于（或不等于，具体取决于您想要的）UIRemoteNotificationTypeNone。

然而，对于 iOS8，仅使用上述许多状态的 isRegisteredForRemoteNotifications 检查并不总是足够的。您还应该检查 application.currentUserNotificationSettings.types 是否等于（或不等于，具体取决于您想要的）UIUserNotificationTypeNone！

即使 currentUserNotificationSettings.types 返回 UIUserNotificationTypeNone，isRegisteredForRemoteNotifications 也可能返回 true。

Answer 12

UIRemoteNotificationType types = [[UIApplication sharedApplication] enabledRemoteNotificationTypes];
if (types & UIRemoteNotificationTypeAlert)
    // blah blah blah
{
    NSLog(@"Notification Enabled");
}
else
{
    NSLog(@"Notification not enabled");
}

这里我们从 UIApplication 获取 UIRemoteNotificationType。它代表了该应用程序在设置中的推送通知状态，您可以轻松查看其类型

Answer 13

我尝试使用 @Shaheen Ghiassy 提供的解决方案支持 iOS 10 及更高版本，但发现剥夺问题 enabledRemoteNotificationTypes。因此，我找到的解决方案是使用 isRegisteredForRemoteNotifications 而不是 iOS 8 中已弃用的 enabledRemoteNotificationTypes。下面是我的更新后的解决方案，非常适合我：

- (BOOL)notificationServicesEnabled {
    BOOL isEnabled = NO;
    if ([[UIApplication sharedApplication] respondsToSelector:@selector(currentUserNotificationSettings)]){
        UIUserNotificationSettings *notificationSettings = [[UIApplication sharedApplication] currentUserNotificationSettings];

        if (!notificationSettings || (notificationSettings.types == UIUserNotificationTypeNone)) {
            isEnabled = NO;
        } else {
            isEnabled = YES;
        }
    } else {

        if ([[UIApplication sharedApplication] isRegisteredForRemoteNotifications]) {
            isEnabled = YES;
        } else{
            isEnabled = NO;
        }
    }
    return isEnabled;
}

我们可以轻松调用此函数并访问其 Bool 值，并可以通过以下方式将其转换为字符串值：

NSString *str = [self notificationServicesEnabled] ? @"YES" : @"NO";

希望它也能帮助其他人:)
快乐编码。

Answer 14

尽管 Zac 的答案在 iOS 7 之前是完全正确的，但自从 iOS 8 出现以来，情况发生了变化。因为从 iOS 8 开始，enabledRemoteNotificationTypes 已被弃用。对于 iOS 8 及更高版本，您需要使用 isRegisteredForRemoteNotifications。

• 适用于 iOS 7 及之前版本 --> 使用enabledRemoteNotificationTypes
• 对于 iOS 8 及更高版本， -->使用 isRegisteredForRemoteNotifications。

Answer 15

这个Swifty解决方案对我来说效果很好（iOS8+），

方法：

func isNotificationEnabled(completion:@escaping (_ enabled:Bool)->()){
    if #available(iOS 10.0, *) {
        UNUserNotificationCenter.current().getNotificationSettings(completionHandler: { (settings: UNNotificationSettings) in
            let status =  (settings.authorizationStatus == .authorized)
            completion(status)
        })
    } else {
        if let status = UIApplication.shared.currentUserNotificationSettings?.types{
            let status = status.rawValue != UIUserNotificationType(rawValue: 0).rawValue
            completion(status)
        }else{
            completion(false)
        }
    }
}

用法：

isNotificationEnabled { (isEnabled) in
            if isEnabled{
                print("Push notification enabled")
            }else{
                print("Push notification not enabled")
            }
        }

参考

Answer 16

回复：

这是正确的

if (types & UIRemoteNotificationTypeAlert)

，但以下也是正确的！ （因为 UIRemoteNotificationTypeNone 是 0 ）

if (types == UIRemoteNotificationTypeNone) 

请参阅以下内容

NSLog(@"log:%d",0 & 0); ///false
NSLog(@"log:%d",1 & 1); ///true
NSLog(@"log:%d",1<<1 & 1<<1); ///true
NSLog(@"log:%d",1<<2 & 1<<2); ///true
NSLog(@"log:%d",(0 & 0) && YES); ///false
NSLog(@"log:%d",(1 & 1) && YES); ///true
NSLog(@"log:%d",(1<<1 & 1<<1) && YES); ///true
NSLog(@"log:%d",(1<<2 & 1<<2) && YES); ///true

Answer 17

以下是如何在 Xamarin.ios 中执行此操作。

public class NotificationUtils
{
    public static bool AreNotificationsEnabled ()
    {
        var settings = UIApplication.SharedApplication.CurrentUserNotificationSettings;
        var types = settings.Types;
        return types != UIUserNotificationType.None;
    }
}

如果您支持 iOS 10+，则仅使用 UNUserNotificationCenter 方法。

Answer 18

在 Xamarin 中，上述所有解决方案都不适合我。
这就是我使用的：

public static bool IsRemoteNotificationsEnabled() {
    return UIApplication.SharedApplication.CurrentUserNotificationSettings.Types != UIUserNotificationType.None;
}

在您更改“设置”中的通知状态后，它也会获得实时更新。

Answer 19

从 @ZacBowling 的解决方案构建的完整轻松复制和粘贴代码 (https://stackoverflow.com/a/1535427/2298002)

这也将使用户进入您的应用程序设置并允许他们立即启用

我还添加了一个解决方案来检查位置服务是否已启用（并且也进入设置）

// check if notification service is enabled
+ (void)checkNotificationServicesEnabled
{
    if (![[UIApplication sharedApplication] isRegisteredForRemoteNotifications])
    {
        UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Notification Services Disabled!"
                                                            message:@"Yo don't mess around bro! Enabling your Notifications allows you to receive important updates"
                                                           delegate:self
                                                  cancelButtonTitle:@"Cancel"
                                                  otherButtonTitles:@"Settings", nil];

        alertView.tag = 300;

        [alertView show];

        return;
    }
}

// check if location service is enabled (ref: https://stackoverflow.com/a/35982887/2298002)
+ (void)checkLocationServicesEnabled
{
    //Checking authorization status
    if (![CLLocationManager locationServicesEnabled] || [CLLocationManager authorizationStatus] == kCLAuthorizationStatusDenied)
    {

        UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Location Services Disabled!"
                                                            message:@"You need to enable your GPS location right now!!"
                                                           delegate:self
                                                  cancelButtonTitle:@"Cancel"
                                                  otherButtonTitles:@"Settings", nil];

        //TODO if user has not given permission to device
        if (![CLLocationManager locationServicesEnabled])
        {
            alertView.tag = 100;
        }
        //TODO if user has not given permission to particular app
        else
        {
            alertView.tag = 200;
        }

        [alertView show];

        return;
    }
}

// handle bringing user to settings for each
+ (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex
{

    if(buttonIndex == 0)// Cancel button pressed
    {
        //TODO for cancel
    }
    else if(buttonIndex == 1)// Settings button pressed.
    {
        if (alertView.tag == 100)
        {
            //This will open ios devices location settings
            [[UIApplication sharedApplication] openURL:[NSURL URLWithString:@"prefs:root=LOCATION_SERVICES"]];
        }
        else if (alertView.tag == 200)
        {
            //This will open particular app location settings
            [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
        }
        else if (alertView.tag == 300)
        {
            //This will open particular app location settings
            [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
        }
    }
}

GLHF！