Określ na iPhonie, czy użytkownik włączył powiadomienia push

Nie mogę skomentować (za mało reputacji), ale Re: Problem quantumpotato:

Gdzie types jest podane przez

UIRemoteNotificationType types = [[UIApplication sharedApplication] enabledRemoteNotificationTypes];

Można użyć

if (types & UIRemoteNotificationTypeAlert)

Zamiast

if (types == UIRemoteNotificationTypeNone) 

Pozwoli Ci sprawdzić tylko, czy powiadomienia są włączone (i nie martw się o Dźwięki, odznaki, Centrum powiadomień itp.). Pierwsza linia kodu (types & UIRemoteNotificationTypeAlert) zwróci YES Jeśli "styl alertu" jest ustawiony na" Banery " lub "Alerty", a NO Jeśli" styl alertu "jest ustawiony na" brak", niezależnie od innych ustawienia.

W najnowszej wersji iOS ta metoda jest teraz przestarzała. Aby obsługiwać iOS 7 i iOS 8, Użyj:

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

Zaktualizowany kod 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()
}

Kod dla swift3. 0, iOS10

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

Z iOS9 , Swift 2.0 UIRemoteNotificationType jest przestarzały, użyj następującego kodu

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.

}

Po prostu sprawdź, czy powiadomienia Push są włączone

    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
    }

Poniżej znajdziesz pełny przykład, który obejmuje zarówno iOS8, jak i iOS7 (oraz niższe wersje). Należy pamiętać, że przed iOS8 nie można odróżnić "powiadomienia zdalne wyłączone" i "tylko widok w lockscreen włączone".

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

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
    }

Rxswift obserwowalna wersja dla iOS10+:

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

Próbując wspierać zarówno iOS8, jak i lower, nie miałem zbyt wiele szczęścia używając isRegisteredForRemoteNotifications, Jak zasugerował Kevin. Zamiast tego użyłem currentUserNotificationSettings, który świetnie sprawdzał się w moich testach.

+ (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;
}

Niestety żadne z tych rozwiązań nie zapewniło naprawdę rozwiąże problem, ponieważ na koniec dnia interfejsy API są poważnie pozbawione, jeśli chodzi o dostarczanie istotnych informacji. Możesz jednak zgadnąć, że użycie currentUserNotificationSettings (iOS8+) nie wystarczy w obecnej formie, aby odpowiedzieć na to pytanie. Chociaż wiele rozwiązań tutaj wydaje się sugerować, że albo To albo isRegisteredForRemoteNotifications jest bardziej ostateczną odpowiedzią, tak naprawdę nie jest.

Rozważ to:

Z isRegisteredForRemoteNotifications dokumentacją stwierdza:

Zwraca Yes, jeśli aplikacja jest obecnie zarejestrowana do powiadomień zdalnych, biorąc pod uwagę dowolne ustawienia systemowe...

Jednak jeśli wrzucisz po prostu NSLog do delegata aplikacji, aby obserwować zachowanie, jest jasne, że nie zachowuje się to tak, jak przewidujemy, że zadziała. Dotyczy to bezpośrednio powiadomień zdalnych, które zostały aktywowane dla tej aplikacji / urządzenia. Po aktywacji dla za pierwszym razem zawsze zwróci YES. Nawet wyłączenie ich w Ustawieniach (powiadomienia) nadal spowoduje powrót YES dzieje się tak dlatego, że od iOS8 aplikacja może rejestrować powiadomienia zdalne, a nawet wysyłać do urządzenia bez włączania powiadomień przez użytkownika, po prostu może nie wykonywać alertów, odznak i dźwięków bez włączania tego przez użytkownika. Ciche powiadomienia są dobrym przykładem czegoś, co możesz nadal robić nawet po wyłączeniu powiadomień.

As far jako currentUserNotificationSettings wskazuje jedną z czterech rzeczy:

Alarmy są włączone Odznaki są na Sound is on Żaden nie jest włączony.

Daje to absolutnie żadnych wskazówek na temat innych czynników lub samego przełącznika powiadomień.

Użytkownik może w rzeczywistości wyłączyć odznaki, dźwięk i alerty, ale nadal mają Pokaż na lockscreen lub w centrum powiadomień. Ten użytkownik powinien nadal otrzymywać powiadomienia push i widzieć je zarówno na ekranie blokady, jak i w centrum powiadomień. Oni Włącz powiadomienia. Ale currentUserNotificationSettings zwróci: UIUserNotificationTypeNone W takim przypadku. Nie jest to tak naprawdę wskaźnikiem rzeczywistych ustawień użytkowników.

Kilka domysłów można zrobić:

• Jeśli isRegisteredForRemoteNotifications jest NO, możesz założyć, że to urządzenie nigdy nie zostało pomyślnie zarejestrowane do zdalnych powiadomień.
• po pierwszej rejestracji do powiadomień zdalnych wywołanie zwrotne do application:didRegisterUserNotificationSettings: jest wykonane zawierające ustawienia powiadomień użytkownika w tym czasie, ponieważ jest to pierwszy raz a użytkownik został zarejestrowany ustawienia powinny wskazywać, co użytkownik wybrał w zakresie żądania uprawnień. Jeśli ustawienia są równoważne z czymkolwiek innym niż: UIUserNotificationTypeNone, wtedy pozwolenie push zostało udzielone, w przeciwnym razie zostało odrzucone. Powodem tego jest to, że od momentu rozpoczęcia procesu zdalnej rejestracji użytkownik ma tylko możliwość zaakceptowania lub odrzucenia, przy czym początkowe ustawienia akceptacji są ustawieniami ustawionymi podczas procesu rejestracji.

Aby uzupełnić odpowiedź, może zadziałać coś takiego...

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

Edit: to nie w porządku. ponieważ są to bitowe rzeczy, nie będzie działać z przełącznikiem, więc skończyłem z tym: {]}

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

Dla iOS7 i przed powinieneś rzeczywiście użyć enabledRemoteNotificationTypes i sprawdzić, czy jest równe (lub nie jest równe w zależności od tego, co chcesz) do UIRemoteNotificationTypeNone.

Jednak dla iOS8 jest to nie zawsze wystarczy sprawdzić tylko isRegisteredForRemoteNotifications Jak wiele stanów powyżej. Należy również sprawdzić, czy application.currentUserNotificationSettings.types jest równe (lub nie jest równe w zależności od tego, co chcesz) UIUserNotificationTypeNone!

isRegisteredForRemoteNotifications może zwrócić true, nawet jeśli currentUserNotificationSettings.types zwraca UIUserNotificationTypeNone.

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

Tutaj otrzymujemy Typ UIRemoteNotificationType z UIApplication. Reprezentuje stan powiadomienia push tej aplikacji w ustawieniu, niż można łatwo sprawdzić jej typ

Staram się wspierać iOS 10 i nowsze za pomocą rozwiązania dostarczonego przez @ Shaheen Ghiassy, ale znaleźć problem deprywacji enabledRemoteNotificationTypes. Tak więc rozwiązanie znajduję za pomocą isRegisteredForRemoteNotifications zamiast enabledRemoteNotificationTypes, który jest przestarzały w iOS 8. Poniżej znajduje się moje zaktualizowane rozwiązanie, które działało idealnie dla mnie:

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

I możemy łatwo wywołać tę funkcję i uzyskać dostęp do jej wartości Bool i możemy przekonwertować ją na wartość ciągu znaków następująco:

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

Mam nadzieję, że pomoże to również innym :) Szczęśliwego kodowania.

IOS8+ (OBJECTIVE 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;
    }
}];

Chociaż odpowiedź Zaca była idealnie poprawna do iOS 7, zmieniła się od czasu przybycia iOS 8. Ponieważ enabledRemoteNotificationTypes jest przestarzały od iOS 8. W przypadku iOS 8 i nowszych, musisz użyć isregistered forremotenotifications.

• dla iOS 7 i wcześniej -- > użyj enabledRemoteNotificationTypes
• dla iOS 8 i nowszych -- > Use isregistered forremotenotifications.

To Swiftyrozwiązanie działało dobrze dla mnie ( iOS8+),

Metoda :

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

Użycie :

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

Ref

Re:

To jest poprawne

if (types & UIRemoteNotificationTypeAlert)

Ale podążanie też jest poprawne ! (jak UIRemoteNotificationTypeNone jest 0)

if (types == UIRemoteNotificationTypeNone) 

Zobacz następujące

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

Oto Jak to zrobić w Xamarin.ios.

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

Jeśli obsługujesz iOS 10+, skorzystaj tylko z metody UNUserNotificationCenter.

W Xamarin wszystkie powyższe rozwiązania nie działają dla mnie. To jest to, czego używam zamiast:

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

To dostaje aktualizację na żywo również po zmianie statusu powiadomienia w Ustawieniach.

Pełny, łatwy do kopiowania i wklejania kod zbudowany z rozwiązania @ ZacBowling ( https://stackoverflow.com/a/1535427/2298002 )

Spowoduje to również przeniesienie użytkownika do ustawień aplikacji i umożliwienie mu natychmiastowego włączenia

Dodałem również rozwiązanie do sprawdzania, czy usługi lokalizacji są włączone (i przynosi do ustawień, jak również)

// 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!