Usuń określone powiadomienie lokalne

Rozwijam aplikację alarmową na iPhone'a w oparciu o lokalne powiadomienia.

Po usunięciu alarmu powiązane powiadomienie lokalne powinno zostać anulowane. Ale jak mogę dokładnie określić, który obiekt z tablicy lokalnych powiadomień ma zostać anulowany?

Znam [[UIApplication sharedApplication] cancelLocalNotification:notification]metodę, ale jak mogę otrzymać to „powiadomienie”, aby je anulować?

Możesz zapisać unikalną wartość klucza w informacjach o użytkowniku lokalnego powiadomienia. Uzyskaj wszystkie powiadomienia lokalne, przejrzyj tablicę i usuń określone powiadomienie.

Kod w następujący sposób,

OBJ-C:

UIApplication *app = [UIApplication sharedApplication];
NSArray *eventArray = [app scheduledLocalNotifications];
for (int i=0; i<[eventArray count]; i++)
{
    UILocalNotification* oneEvent = [eventArray objectAtIndex:i];
    NSDictionary *userInfoCurrent = oneEvent.userInfo;
    NSString *uid=[NSString stringWithFormat:@"%@",[userInfoCurrent valueForKey:@"uid"]];
    if ([uid isEqualToString:uidtodelete])
    {
        //Cancelling local notification
        [app cancelLocalNotification:oneEvent];
        break;
    }
}

SZYBKI:

var app:UIApplication = UIApplication.sharedApplication()
for oneEvent in app.scheduledLocalNotifications {
    var notification = oneEvent as UILocalNotification
    let userInfoCurrent = notification.userInfo! as [String:AnyObject]
    let uid = userInfoCurrent["uid"]! as String
    if uid == uidtodelete {
        //Cancelling local notification
        app.cancelLocalNotification(notification)
        break;
    }
}

Powiadomienie użytkownika:

Jeśli używasz UserNotification (iOS 10+), po prostu wykonaj następujące kroki:

1. Podczas tworzenia treści UserNotification dodaj unikalny identyfikator

2. Usuń konkretne oczekujące powiadomienie za pomocą removePendingNotificationRequests (withIdentifiers :)

3. Usuń określone dostarczone powiadomienie za pomocą removeDeliveredNotifications (withIdentifiers :)

Aby uzyskać więcej informacji, UNUserNotificationCenter

Inna opcja:

Po pierwsze, kiedy tworzysz lokalne powiadomienie, możesz zapisać je w ustawieniach domyślnych użytkownika do przyszłego użytku.Lokalny obiekt powiadomienia nie może być przechowywany bezpośrednio w ustawieniach domyślnych użytkownika.Ten obiekt musi najpierw zostać przekonwertowany na obiekt NSData, a następnie NSDatamoże być przechowywany w User defaults. Poniżej znajduje się kod:

NSData *data = [NSKeyedArchiver archivedDataWithRootObject:localNotif];
[[NSUserDefaults standardUserDefaults] setObject:data forKey:[NSString  stringWithFormat:@"%d",indexPath.row]];

Po zapisaniu i zaplanowaniu powiadomienia lokalnego, w przyszłości może zaistnieć potrzeba anulowania dowolnego powiadomienia, które utworzyłeś wcześniej, aby móc je odzyskać z ustawień domyślnych użytkownika.

NSData *data= [[NSUserDefaults standardUserDefaults] objectForKey:[NSString   stringWithFormat:@"%d",UniqueKey]];

UILocalNotification *localNotif = [NSKeyedUnarchiver unarchiveObjectWithData:data];
NSLog(@"Remove localnotification  are %@", localNotif);
[[UIApplication sharedApplication] cancelLocalNotification:localNotif];
[[NSUserDefaults standardUserDefaults] removeObjectForKey:[NSString stringWithFormat:@"%d",UniqueKey]];

Mam nadzieję że to pomoże

Oto co robię.

Tworząc powiadomienie, wykonaj następujące czynności:

  // Create the notification

UILocalNotification *notification = [[UILocalNotification alloc]  init] ;



notification.fireDate = alertDate;
notification.timeZone = [NSTimeZone localTimeZone] ;
notification.alertAction = NSLocalizedString(@"Start", @"Start");
notification.alertBody = **notificationTitle**;
notification.repeatInterval= NSMinuteCalendarUnit;

notification.soundName=UILocalNotificationDefaultSoundName;
notification.applicationIconBadgeNumber = 1;

[[UIApplication sharedApplication] scheduleLocalNotification:notification] ;

próbując go usunąć, wykonaj następujące czynności:

 NSArray *arrayOfLocalNotifications = [[UIApplication sharedApplication] scheduledLocalNotifications] ;

for (UILocalNotification *localNotification in arrayOfLocalNotifications) {

    if ([localNotification.alertBody isEqualToString:savedTitle]) {
        NSLog(@"the notification this is canceld is %@", localNotification.alertBody);

        [[UIApplication sharedApplication] cancelLocalNotification:localNotification] ; // delete the notification from the system

    }

}

To rozwiązanie powinno działać w przypadku wielu powiadomień, a Ty nie zarządzasz żadnymi tablicami, słownikami ani domyślnymi ustawieniami użytkownika. Po prostu używasz danych, które już zapisałeś w bazie danych powiadomień systemu.

Mam nadzieję, że pomoże to przyszłym projektantom i programistom.

Miłego kodowania! :RE

Planowanie i usuwanie powiadomień w szybkim:

    static func scheduleNotification(notificationTitle:String, objectId:String) {

    var localNotification = UILocalNotification()
    localNotification.fireDate = NSDate(timeIntervalSinceNow: 24*60*60)
    localNotification.alertBody = notificationTitle
    localNotification.timeZone = NSTimeZone.defaultTimeZone()
    localNotification.applicationIconBadgeNumber = 1
    //play a sound
    localNotification.soundName = UILocalNotificationDefaultSoundName;
    localNotification.alertAction = "View"
    var infoDict :  Dictionary<String,String!> = ["objectId" : objectId]
    localNotification.userInfo = infoDict;

    UIApplication.sharedApplication().scheduleLocalNotification(localNotification)
}
    static func removeNotification(objectId:String) {
    var app:UIApplication = UIApplication.sharedApplication()

    for event in app.scheduledLocalNotifications {
        var notification = event as! UILocalNotification
        var userInfo:Dictionary<String,String!> = notification.userInfo as! Dictionary<String,String!>
        var infoDict :  Dictionary = notification.userInfo as! Dictionary<String,String!>
        var notifcationObjectId : String = infoDict["objectId"]!

        if notifcationObjectId == objectId {
            app.cancelLocalNotification(notification)
        }
    }



}

iMOBDEV za rozwiązanie działa idealnie, aby usunąć powiadomienie specyficzny (np po skasowaniu alarmu), ale to specjalnie przydatna, gdy trzeba, aby selektywnie usunąć powiadomienie, że został już zwolniony i jest nadal w centrum powiadomień.

Możliwy scenariusz to: powiadomienie o pożarze alarmu, ale użytkownik otwiera aplikację bez dotykania tego powiadomienia i ponownie planuje ten alarm. Jeśli chcesz mieć pewność, że w centrum powiadomień dla danego elementu / alarmu może znajdować się tylko jedno powiadomienie, jest to dobre podejście. Dzięki temu nie musisz usuwać wszystkich powiadomień za każdym razem, gdy aplikacja jest otwierana, jeśli to lepiej pasuje do aplikacji.

• Po utworzeniu powiadomienia lokalnego użyj, NSKeyedArchiveraby zapisać je Dataw formacie UserDefaults. Możesz utworzyć klucz równy temu, który zapisujesz w słowniku userInfo powiadomienia. Jeśli jest powiązany z obiektem Core Data, możesz użyć jego unikalnej właściwości objectID.
• Odzyskaj to za pomocą NSKeyedUnarchiver. Teraz możesz go usunąć za pomocą metody cancelLocalNotification.
• Zaktualizuj klucz UserDefaultsodpowiednio.

Oto wersja Swift 3.1 tego rozwiązania (dla celów poniżej iOS 10):

Sklep

// localNotification is the UILocalNotification you've just set up
UIApplication.shared.scheduleLocalNotification(localNotification)
let notificationData = NSKeyedArchiver.archivedData(withRootObject: localNotification)
UserDefaults.standard.set(notificationData, forKey: "someKeyChosenByYou")

Pobierz i usuń

let userDefaults = UserDefaults.standard
if let existingNotificationData = userDefaults.object(forKey: "someKeyChosenByYou") as? Data,
    let existingNotification = NSKeyedUnarchiver.unarchiveObject(with: existingNotificationData) as? UILocalNotification {

    // Cancel notification if scheduled, delete it from notification center if already delivered    
    UIApplication.shared.cancelLocalNotification(existingNotification)

    // Clean up
    userDefaults.removeObject(forKey: "someKeyChosenByYou")
}

Rozwiązanie Swift 4:

UNUserNotificationCenter.current().getPendingNotificationRequests { (requests) in
  for request in requests {
    if request.identifier == "identifier" {
      UNUserNotificationCenter.current().removePendingNotificationRequests(withIdentifiers: ["identifier"])
    }
  }
}   

Wersja Swift, w razie potrzeby:

func cancelLocalNotification(UNIQUE_ID: String){

        var notifyCancel = UILocalNotification()
        var notifyArray = UIApplication.sharedApplication().scheduledLocalNotifications

        for notifyCancel in notifyArray as! [UILocalNotification]{

            let info: [String: String] = notifyCancel.userInfo as! [String: String]

            if info[uniqueId] == uniqueId{

                UIApplication.sharedApplication().cancelLocalNotification(notifyCancel)
            }else{

                println("No Local Notification Found!")
            }
        }
    }

Możesz zachować ciąg z identyfikatorem kategorii podczas planowania powiadomienia w ten sposób

        localNotification.category = NotificationHelper.categoryIdentifier

i wyszukaj go i anuluj w razie potrzeby

let  app = UIApplication.sharedApplication()

    for notification in app.scheduledLocalNotifications! {
        if let cat = notification.category{
            if cat==NotificationHelper.categoryIdentifier {
                app.cancelLocalNotification(notification)
                break
            }

        }
    }

szybki 3 styl:

final private func cancelLocalNotificationsIfIOS9(){


//UIApplication.shared.cancelAllLocalNotifications()
let app = UIApplication.shared
guard let notifs = app.scheduledLocalNotifications else{
    return
}

for oneEvent in notifs {
    let notification = oneEvent as UILocalNotification
    if let userInfoCurrent = notification.userInfo as? [String:AnyObject], let uid = userInfoCurrent["uid"] as? String{
        if uid == uidtodelete {
            //Cancelling local notification
            app.cancelLocalNotification(notification)
            break;
        }
    }
}

}

do użytku na iOS 10:

    let center = UNUserNotificationCenter.current()
    center.removePendingNotificationRequests(withIdentifiers: [uidtodelete])

Obiekt UILocalNotification, do którego przekazujesz, cancelLocalNotification:będzie pasował do dowolnego istniejącego obiektu UILocalNotification z pasującymi właściwościami.

Więc:

UILocalNotification *notification = [[UILocalNotification alloc] init];
notification.alertBody = @"foo";
[[UIApplication sharedApplication] presentLocalNotificationNow:notification];

przedstawi lokalne powiadomienie, które można później anulować za pomocą:

UILocalNotification *notification = [[UILocalNotification alloc] init];
notification.alertBody = @"foo";
[[UIApplication sharedApplication] cancelLocalNotification:notification];

Używam tej funkcji w Swift 2.0:

  static func DeleteNotificationByUUID(uidToDelete: String) -> Bool {
    let app:UIApplication = UIApplication.sharedApplication()
    // loop on all the current schedualed notifications
    for schedualedNotif in app.scheduledLocalNotifications! {
      let notification = schedualedNotif as UILocalNotification
      let urrentUi = notification.userInfo! as! [String:AnyObject]
      let currentUid = urrentUi["uid"]! as! String
      if currentUid == uidToDelete {
        app.cancelLocalNotification(notification)
        return true
      }
    }
    return false
  }

Zainspirowany odpowiedzią @ KingofBliss

W przypadku powtarzających się przypomnień (na przykład chcesz, aby alarm był uruchamiany w niedziele, sobotę i środę o 16:00, a następnie musisz ustawić 3 alarmy i ustawić parametr RepeInterval na NSWeekCalendarUnit).

Aby zrobić jednorazowe przypomnienie:

UILocalNotification *aNotification = [[UILocalNotification alloc] init];
                aNotification.timeZone = [NSTimeZone defaultTimeZone];
                aNotification.alertBody = _reminderTitle.text;
                aNotification.alertAction = @"Show me!";
                aNotification.soundName = UILocalNotificationDefaultSoundName;
                aNotification.applicationIconBadgeNumber += 1;

                NSCalendar *calendar = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];
                NSDateComponents *componentsForFireDate = [calendar components:(NSYearCalendarUnit | NSWeekCalendarUnit|  NSHourCalendarUnit | NSMinuteCalendarUnit| NSSecondCalendarUnit | NSWeekdayCalendarUnit) fromDate: _reminderDate];

                [componentsForFireDate setHour: [componentsForFireDate hour]] ; //for fixing 8PM hour
                [componentsForFireDate setMinute:[componentsForFireDate minute]];

                [componentsForFireDate setSecond:0] ;
                NSDate *fireDateOfNotification = [calendar dateFromComponents: componentsForFireDate];
                aNotification.fireDate = fireDateOfNotification;
                NSDictionary *infoDict = [NSDictionary dictionaryWithObject:_reminderTitle.text forKey:kRemindMeNotificationDataKey];
                aNotification.userInfo = infoDict;

                [[UIApplication sharedApplication] scheduleLocalNotification:aNotification];

Aby dokonać ponownego przypomnienia:

for (int i = 0 ; i <reminderDaysArr.count; i++)
                {

                    UILocalNotification *aNotification = [[UILocalNotification alloc] init];
                    aNotification.timeZone = [NSTimeZone defaultTimeZone];
                    aNotification.alertBody = _reminderTitle.text;
                    aNotification.alertAction = @"Show me!";
                    aNotification.soundName = UILocalNotificationDefaultSoundName;
                    aNotification.applicationIconBadgeNumber += 1;

                    NSCalendar *calendar = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];
                    NSDateComponents *componentsForFireDate = [calendar components:(NSYearCalendarUnit | NSWeekCalendarUnit|  NSHourCalendarUnit | NSMinuteCalendarUnit| NSSecondCalendarUnit | NSWeekdayCalendarUnit) fromDate: _reminderDate];


                    [componentsForFireDate setWeekday: [[reminderDaysArr objectAtIndex:i]integerValue]];

                    [componentsForFireDate setHour: [componentsForFireDate hour]] ; // Setup Your Own Time.
                    [componentsForFireDate setMinute:[componentsForFireDate minute]];

                    [componentsForFireDate setSecond:0] ;
                    NSDate *fireDateOfNotification = [calendar dateFromComponents: componentsForFireDate];
                    aNotification.fireDate = fireDateOfNotification;
                    aNotification.repeatInterval = NSWeekCalendarUnit;
                    NSDictionary *infoDict = [NSDictionary dictionaryWithObject:_reminderTitle.text forKey:kRemindMeNotificationDataKey];
                    aNotification.userInfo = infoDict;

                    [[UIApplication sharedApplication] scheduleLocalNotification:aNotification];
                }
            }

Do filtrowania macierz, aby ją wyświetlić.

-(void)filterNotficationsArray:(NSMutableArray*) notificationArray{

    _dataArray = [[NSMutableArray alloc]initWithArray:[[UIApplication sharedApplication] scheduledLocalNotifications]];
    NSMutableArray *uniqueArray = [NSMutableArray array];
    NSMutableSet *names = [NSMutableSet set];

    for (int i = 0 ; i<_dataArray.count; i++) {
        UILocalNotification *localNotification = [_dataArray objectAtIndex:i];
        NSString * infoDict = [localNotification.userInfo objectForKey:@"kRemindMeNotificationDataKey"];

        if (![names containsObject:infoDict]) {
            [uniqueArray addObject:localNotification];
            [names addObject:infoDict];
        }
    }
    _dataArray = uniqueArray;
}

Aby usunąć przypomnienie, nawet jeśli było to tylko raz lub powtórzone:

- (void) removereminder:(UILocalNotification*)notification
{
    _dataArray = [[NSMutableArray alloc]initWithArray:[[UIApplication sharedApplication]scheduledLocalNotifications]];

    NSString * idToDelete = [notification.userInfo objectForKey:@"kRemindMeNotificationDataKey"];
    for (int i = 0 ; i<_dataArray.count; i++)
    {
        UILocalNotification *currentLocalNotification = [_dataArray objectAtIndex:i];
        NSString * notificationId = [currentLocalNotification.userInfo objectForKey:@"kRemindMeNotificationDataKey"];

        if ([notificationId isEqualToString:idToDelete])
            [[UIApplication sharedApplication]cancelLocalNotification:currentLocalNotification];
    }

    _dataArray = [[NSMutableArray alloc]initWithArray:[[UIApplication sharedApplication]scheduledLocalNotifications]];
    [self filterNotficationsArray:_dataArray];
    [_remindersTV reloadData];

}

Rozwinąłem nieco odpowiedź KingofBliss, napisałem to trochę bardziej w stylu Swift2, usunąłem trochę niepotrzebnego kodu i dodałem kilka zabezpieczeń.

Aby rozpocząć, podczas tworzenia powiadomienia musisz upewnić się, że ustawiłeś uid (lub naprawdę dowolną niestandardową właściwość) powiadomienia userInfo:

notification.userInfo = ["uid": uniqueid]

Następnie podczas usuwania możesz zrobić:

guard
    let app: UIApplication = UIApplication.sharedApplication(),
    let notifications = app.scheduledLocalNotifications else { return }
for notification in notifications {
    if
        let userInfo = notification.userInfo,
        let uid: String = userInfo["uid"] as? String where uid == uidtodelete {
            app.cancelLocalNotification(notification)
            print("Deleted local notification for '\(uidtodelete)'")
    }
}