यदि उपयोगकर्ता ने पुश सूचनाओं को सक्षम किया है, तो iPhone पर निर्धारित करें

Question

मैं यह निर्धारित करने के लिए एक तरीका खोज रहा हूं कि क्या उपयोगकर्ता ने सेटिंग्स के माध्यम से, मेरे आवेदन के लिए अपनी पुश सूचनाओं को सक्षम या अक्षम किया है।

Answer 1

बुलाओ enabledRemoteNotificationsTypesऔर नकाब चेक करो।

उदाहरण के लिए:

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

iOS8 और ऊपर:

[[UIApplication sharedApplication] isRegisteredForRemoteNotifications]

Comments

iOS 5: यह इस बात की जाँच करता है कि मौसम की परवाह किए बिना ऐप किस तरह के पुश नोटिफिकेशन का इस्तेमाल करता है, ऐप आपके फोन के नोटिफिकेशन सेंटर में है या नहीं। मैंने अपने ऐप के लिए पुश नोटिफिकेशन को निष्क्रिय कर दिया और अभी भी टाइप = = 6. ध्वनि और चेतावनी शैली को अक्षम करने पर, मुझे टाइप == UIRemoteNotificationTypeNone मिला है।

— क्वांटम्पोटेटो

जैसा कि क्वांटम्पोटेटो ने कहा, यह उत्तर अब सभी मामलों को नहीं संभालता है और एक पूर्ण समाधान नहीं है।

— DBD

Apple के साथ क्या हो रहा है? काश मैं इस मुद्दे पर उनकी प्रतिक्रिया सुन पाता। हम इस तरह की बुनियादी जानकारी को जाने बिना महान ऐप कैसे विकसित कर सकते हैं ??

— ओग्ड रेगेव

@ZacBowling - iOS 8उच्चतर के लिए समाधान गलत है क्योंकि यह केवल तभी जांचता है जब उपयोगकर्ता दूरस्थ अधिसूचना के लिए पंजीकृत हो। प्रलेखन के अनुसार:This method reflects only the successful completion of the remote registration process that begins when you call the registerForRemoteNotifications method. This method does not reflect whether remote notifications are actually available due to connectivity issues. The value returned by this method takes into account the user’s preferences for receiving remote notifications.

— अपान

तो मेरी राय में आपको भी जांच करनी चाहिए[[UIApplication sharedApplication] currentUserNotificationSettings];

— अपान

Answer 2

क्वांटम्पोटेटो का मुद्दा:

कहां typesसे दिया गया है

UIRemoteNotificationType types = [[UIApplication sharedApplication] enabledRemoteNotificationTypes];

एक का उपयोग कर सकते हैं

if (types & UIRemoteNotificationTypeAlert)

के बजाय

if (types == UIRemoteNotificationTypeNone) 

आपको केवल यह देखने की अनुमति देगा कि क्या सूचनाएं सक्षम हैं (और ध्वनियों, बैज, सूचना केंद्र, आदि के बारे में चिंता न करें)। कोड की पहली पंक्ति ( types & UIRemoteNotificationTypeAlert) वापस आ जाएगी YESयदि "अलर्ट स्टाइल" "बैनर्स" या "अलर्ट NO" पर सेट है , और अगर "अलर्ट स्टाइल" अन्य सेटिंग्स के बावजूद, "कोई नहीं" पर सेट है।

Comments

यह क्वांटम्पोटेटो के मुद्दे को संबोधित नहीं करता है। वह केवल अलर्ट से चिंतित नहीं है लेकिन यह इंगित करता है कि आप enableRemoteNotifications के माध्यम से विचार नहीं कर सकते हैं कि क्या उपयोगकर्ता ने अधिसूचना केंद्र सेटिंग को चालू या बंद किया है।

— जॉय

मेरा उत्तर सीधे उत्तर नहीं दे सकता है "यह निर्धारित करने के लिए कि ऐप अधिसूचना केंद्र में कैसे है", लेकिन यह यह जांचने का एक तरीका है कि उपयोगकर्ता आपके ऐप के लिए सूचनाएं प्राप्त करेगा या नहीं , जो मुझे लगता है कि प्रश्न की भावना में एक उत्तर है । मुझे नहीं लगता कि पूर्व की जांच करना संभव है।

— टिम कैमर

"अगर (प्रकार और UIRemoteNotificationTypeAlert)" की चाल बहुत अच्छी है।

— nembleton

सुनिश्चित करें कि आप समझते हैं कि चाल क्यों काम करती है! बिटकॉइन ऑपरेटर बहुत उपयोगी हैं, और कोको में बिटमास्क आम हैं। बाहर की जाँच करें stackoverflow.com/a/3427633/1148702

— टिम कैमर

Swift2 / XCode7 में द्विआधारी ऑपरेटर के साथ बिटवाइज ऑपरेशन विफल हो जाता है 'और' दो 'UIUserNotificationType' ऑपरेंड पर लागू नहीं किया जा सकता । आप इसके बजाय शामिल कर सकते हैंgrantedSettings.types.contains(notificationType)

— फिलिप ओटो

Answer 3

आईओएस के नवीनतम संस्करण में यह विधि अब पदावनत हो गई है। 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;
}

Comments

स्थानीय सूचनाओं के बारे में क्या? iOS 8 को अब उपयोगकर्ता को उन्हें अनुमति देने की आवश्यकता है। लेकिन फिर बाद में कैसे जांचें कि ये अनुमति दी गई थी या नहीं?

— Frédéric Adda

@FredA। जाँच करें UserNotifications। मेरे पास अब पूर्ण उत्तर नहीं है, दुर्भाग्य से।

— माजिद

@FredA। यहाँ मेरा विषय पर ले रहा है ।

— माजिद

स्विफ्ट में मैं सक्षम नहीं कर सकता = प्रकार और UIRemoteNotificationTypeAlert। त्रुटि: प्रकार बूल नहीं है

— दादा

Answer 4

स्विफ्ट 4.0, iOS11 के लिए अपडेट किया गया कोड

import UserNotifications

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

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

स्विफ्ट 3.0, आईओएस 10 के लिए कोड

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

IOS9 से, स्विफ्ट 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 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");

Comments

userNotificationSettings.types और UIUserNotificationTypeNone हमेशा गलत होगा, क्योंकि UIUserNotificationTypeNone एक खाली बिट मास्क है, यह अन्य बिट्स की अनुपस्थिति है। किसी के लिए भी आप सिर्फ समानता की जांच करना चाहते हैं।

— dberwick

Answer 6

स्विफ्ट 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 वेधशाला संस्करण:

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

Comments

तुम मेरा दिन बचाओ :)

— चेतन डोबरिया

धन्यवाद मैं एक घंटे के लिए यह खोज रहा था।

— चंचल वार्डे

getNotificationSettings(...)अतुल्यकालिक है इसलिए अंदर की वापसी को नजरअंदाज कर दिया जाएगा

— shelll

Answer 7

IOS8 और लोअर दोनों को सपोर्ट करने की कोशिश में, 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;
}

Comments

यह तब लागू नहीं होता है जब आवेदन नए सिरे से स्थापित किया जाता है। विधि हमेशा NO लौटेगी, और पुश सूचनाओं के लिए पॉप अप अनुमति कभी नहीं दिखाई देगी। इस प्रकार, डिवाइस की सेटिंग्स पर, ऐप दिखाई नहीं देगा यदि आप उस ऐप के लिए अधिसूचना सेटिंग्स बदलना चाहते हैं (अनुमति / अस्वीकार करें)। किसी को भी इस समस्या के आसपास काम करने के लिए कोई विचार है?

— tyegah123

जब कोई ऐप हटा दिया जाता है तब भी अधिसूचना सेटिंग्स को बनाए रखा जाता है। इसलिए यदि आप ऐप पूरी तरह से नए हैं, तो यह तरीका काम करेगा। यदि आपका ऐप हटा दिया गया था, लेकिन फिर पुनर्स्थापित किया गया है, तो अनुमतियाँ अभी भी सिस्टम में हैं और Apple आपको अनुमति के लिए फिर से पूछने का अवसर प्रदान नहीं करेगा।

— शाहीन घिसे

मुझे कुछ निरर्थक कोड दिखाई दे रहे हैं: isEnabled = NO;आपके ifमामलों में इसकी आवश्यकता नहीं है क्योंकि इसे आरंभीकृत किया गया हैNO

— जैस्पर

Answer 8

दुर्भाग्य से, इनमें से कोई भी समाधान वास्तव में समस्या को हल नहीं करता है क्योंकि दिन के अंत में एपीआई की गंभीरता से कमी होती है जब यह प्रासंगिक जानकारी प्रदान करने की बात आती है। आप हालांकि currentUserNotificationSettings(iOS8 +) का उपयोग करके कुछ अनुमान लगा सकते हैं कि वास्तव में इस सवाल का जवाब देने के लिए अपने वर्तमान रूप में पर्याप्त नहीं है। यद्यपि यहाँ बहुत सारे समाधान यह प्रतीत करते हैं कि या तो isRegisteredForRemoteNotificationsयह निश्चित उत्तर है या अधिक है या नहीं।

इस पर विचार करो:

isRegisteredForRemoteNotificationsप्रलेखन राज्यों के साथ :

यदि आवेदन वर्तमान में दूरस्थ सूचनाओं के लिए पंजीकृत है, तो किसी भी प्रणालीगत सेटिंग्स को ध्यान में रखते हुए हाँ लौटाता है ...

हालाँकि, यदि आप NSLogव्यवहार को देखने के लिए अपने एप्लिकेशन प्रतिनिधि में बस फेंकते हैं तो यह स्पष्ट है कि यह उस तरीके का व्यवहार नहीं करता है जिससे हम अनुमान लगा रहे हैं कि यह काम करेगा। यह वास्तव में इस ऐप / डिवाइस के लिए सक्रिय होने वाली दूरस्थ सूचनाओं से सीधे संबंधित है। पहली बार सक्रिय होने के बाद यह हमेशा वापस आ जाएगा YES। यहां तक ​​कि उन्हें सेटिंग्स (सूचनाओं) में बंद करने के बावजूद भी यह वापस आ जाएगा YES, क्योंकि iOS8 के रूप में, एक ऐप दूरस्थ सूचनाओं के लिए पंजीकरण कर सकता है और यहां तक ​​कि उपयोगकर्ता को सक्षम किए बिना डिवाइस पर एक डिवाइस भेज सकता है, वे सिर्फ अलर्ट नहीं कर सकते हैं, उपयोगकर्ता के बिना बैज और ध्वनि को चालू किए बिना। साइलेंट नोटिफिकेशन कुछ ऐसी अच्छी मिसालें हैं जिन्हें आप नोटिफिकेशन को बंद करने के बाद भी जारी रख सकते हैं।

जहां तक currentUserNotificationSettingsयह चार चीजों में से एक को इंगित करता है:

बैड पर अलर्ट जारी हैं, साउंड चालू है और कोई भी चालू नहीं है।

यह आपको अन्य कारकों या अधिसूचना स्विच के बारे में पूरी तरह से कोई संकेत नहीं देता है।

एक उपयोगकर्ता वास्तव में बैज, ध्वनि और अलर्ट बंद कर सकता है लेकिन फिर भी लॉकस्क्रीन या सूचना केंद्र में शो हो सकता है। इस उपयोगकर्ता को अभी भी पुश सूचनाएँ मिल रही हैं और लॉक स्क्रीन पर और सूचना केंद्र में दोनों को देखने में सक्षम होना चाहिए। उनके पास अधिसूचना स्विच ऑन है। BUT currentUserNotificationSettingsलौट आएगा: UIUserNotificationTypeNoneउस स्थिति में। यह वास्तव में उपयोगकर्ताओं की वास्तविक सेटिंग्स का संकेत नहीं है।

कुछ अनुमान लगा सकते हैं:

• अगर isRegisteredForRemoteNotificationsहै NOतो आप मान सकते हैं कि इस उपकरण को सफलतापूर्वक दूरस्थ सूचनाओं के लिए कभी नहीं दर्ज की है।
• दूरस्थ सूचनाओं के लिए पंजीकरण करने के बाद पहली बार application:didRegisterUserNotificationSettings:इस समय उपयोगकर्ता अधिसूचना सेटिंग्स वाले कॉलबैक को बनाया जाता है क्योंकि यह पहली बार है जब उपयोगकर्ता पंजीकृत किया गया है सेटिंग्स को यह इंगित करना चाहिए कि उपयोगकर्ता ने अनुमति अनुरोध के संदर्भ में क्या चुना है। यदि सेटिंग्स को इसके अलावा किसी और चीज के बराबर किया जाता है: 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;
}

Comments

मैंने (मेरी स्थिति के लिए) ध्वनि सूचनाओं को सक्षम नहीं माना (क्योंकि मुझे अपने ऐप की कार्यक्षमता के लिए उन्हें सक्षम करने के लिए पाठ की आवश्यकता है)

— pojomx

Answer 10

IOS7 के लिए और इससे पहले कि आप वास्तव में उपयोग करें enabledRemoteNotificationTypesऔर जांचें कि क्या यह बराबर है (या जो आप चाहते हैं उसके आधार पर बराबर नहीं है) UIRemoteNotificationTypeNone।

हालांकि iOS8 के लिए यह हमेशा केवल ऊपर कई राज्यों के साथ जाँच करने के लिए पर्याप्त नहींisRegisteredForRemoteNotifications है। आपको यह भी देखना चाहिए कि क्या application.currentUserNotificationSettings.typesबराबर है (या जो आप चाहते हैं उसके आधार पर बराबर नहीं है) UIUserNotificationTypeNone!

isRegisteredForRemoteNotificationsभले ही currentUserNotificationSettings.typesरिटर्न सही हो UIUserNotificationTypeNone।

Answer 11

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

Answer 12

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

यहाँ हम UIRemoteNotificationType को UIApplication से प्राप्त करते हैं। यह सेटिंग में इस ऐप के पुश नोटिफिकेशन की स्थिति का प्रतिनिधित्व करता है, जबकि आप इसके प्रकार को आसानी से देख सकते हैं

Comments

कृपया बताएं कि यह कोड क्या करता है, कोड लिखना केवल सवाल का जवाब नहीं देता है।

— बटी

Answer 13

मैं @Shaheen Ghiassy द्वारा प्रदान किए गए समाधान का उपयोग करके iOS 10 और इसके बाद के संस्करण का समर्थन करने की कोशिश करता हूं, लेकिन वंचितता का मुद्दा ढूंढता हूं enabledRemoteNotificationTypes। इसलिए, आईओएस 8 में पदावनत isRegisteredForRemoteNotificationsकरने के बजाय इसका उपयोग करके मैं जो समाधान 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 के आने के बाद से यह बदल गया है। क्योंकि enableRemoteNotificationTypes को iOS 8 के बाद से हटा दिया गया है। IOS 8 और उसके बाद के लिए, आपको isRegisteredForRemoteNotifications का उपयोग करने की आवश्यकता है ।

• iOS 7 और उससे पहले के लिए -> enableRemoteNotificationTypes का उपयोग करें
• iOS 8 और बाद के लिए -> isRegisteredForRemoteNotifications का उपयोग करें।

Answer 15

इस स्विफ्ट्टी समाधान ने मेरे ( 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

ज़मारिन में, उपरोक्त सभी समाधान मेरे लिए काम नहीं करते हैं। इसके बजाय मैं इसका उपयोग करता हूं:

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!