web-dev-qa-db-fra.com

Lancer une notification locale à une heure précise dans iOS

J'essaie de créer un minuteur qui déclenche une notification locale qui se déclenche à une heure définie par l'utilisateur. Le problème que je suis, c'est que je ne peux pas trouver un moyen de pouvoir configurer la notification locale pour qu'elle disparaisse à 19 heures. Presque toutes les méthodes trouvées lors de la recherche de ce problème impliquaient la désactivation de la notification locale à une certaine heure à partir de la date du jour. J'essaie de permettre à l'utilisateur de sélectionner 19h00, puis de laisser la notification disparaître à ce moment-là. Logiquement, il est logique que cela soit possible en indiquant l'heure finale (valeur sélectionnée par l'utilisateur) - l'heure actuelle, qui vous donnerait le décalage horaire. Je ne suis cependant pas tout à fait sûr de savoir comment faire cela.

Toute aide sur le sujet sera très appréciée, merci. Vous trouverez ci-dessous le code que j'utilise actuellement pour déclencher une notification locale.

let center = UNUserNotificationCenter.current()

content.title = storedMessage
content.body = "Drag down to reset or disable alarm"
content.categoryIdentifier = "alarm"
content.userInfo = ["customData": "fizzbuzz"]
content.sound = UNNotificationSound.init(named: "1.mp3")
content.badge = 1

let trigger = UNTimeIntervalNotificationTrigger(timeInterval: timeAmount, repeats: false)
let request = UNNotificationRequest(identifier: "requestAlarm", content: content, trigger: trigger)
    center.add(request)


center.delegate = self
iosswifttimetimeruilocalnotification
13
imjonu

Eh bien dans iOS 10, Apple a déconseillé d'utiliser UILocalNotification, ce qui signifie qu'il est temps de se familiariser avec un nouveau cadre de notifications.

Setup Ceci est un article long, commençons donc facilement en important le nouveau framework de notifications:

// Swift
import UserNotifications

// Objective-C (with modules enabled)
@import UserNotifications;

Vous gérez les notifications via un objet UNUserNotificationCenter partagé:

// Swift
let center = UNUserNotificationCenter.current()

// Objective-C
UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];

AutorisationComme dans l’ancien framework de notifications, vous devez disposer de l’autorisation de l’utilisateur pour les types de notification que votre application utilisera. Faites la demande tôt dans le cycle de vie de votre application, comme dans application: didFinishLaunchingWithOptions :. La première fois que votre application demande une autorisation, le système envoie à l'utilisateur une alerte, après quoi il peut gérer les autorisations à partir des paramètres:

// Swift
let options: UNAuthorizationOptions = [.alert, .sound];

// Objective-C
UNAuthorizationOptions options = UNAuthorizationOptionAlert + UNAuthorizationOptionSound;

Vous effectuez la demande d'autorisation à l'aide du centre de notification partagé:

// Swift
center.requestAuthorization(options: options) { (granted, error) in
    if !granted {
        print("Something went wrong")
    }
}

// Objective-C
[center requestAuthorizationWithOptions:options
completionHandler:^(BOOL granted, NSError * _Nullable error) {
if (!granted) {
NSLog(@"Something went wrong");
}
}];

La structure appelle le gestionnaire d'achèvement avec un booléen indiquant si l'accès a été accordé et un objet d'erreur qui sera nul si aucune erreur ne survient.

Remarque: l'utilisateur peut modifier les paramètres de notification de votre application à tout moment. Vous pouvez vérifier les paramètres autorisés avec getNotificationSettings. Cela appelle un bloc d'achèvement de manière asynchrone avec un objet UNNotificationSettings que vous pouvez utiliser pour vérifier l'état de l'autorisation ou les paramètres de notification individuels:

 // Swift
 center.getNotificationSettings { (settings) in
     if settings.authorizationStatus != .authorized {
         // Notifications not allowed
     }
 }

 // Objective-C
 [center getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings * _Nonnull settings) {
 if (settings.authorizationStatus != UNAuthorizationStatusAuthorized) {
// Notifications not allowed
 }
 }];

Création d'une demande de notification Une demande de notification UNNotificationRequest contient un contenu et une condition de déclencheur:

Contenu de la notification

Le contenu d'une notification est une instance du UNMutableNotificationContent avec les propriétés suivantes définies comme requis:

title: chaîne contenant la raison principale de l'alerte.

sous-titre: Chaîne contenant un sous-titre d'alerte (si nécessaire)

body: chaîne contenant le texte du message d'alerte

badge: numéro à afficher sur l’icône de l’application.

son: son à jouer lorsque l'alerte est émise. Utilisez UNNotificationSound.default () ou créez un son personnalisé à partir d'un fichier . LaunchImageName: nom d'une image de lancement à utiliser si votre application est lancée en réponse à une notification.

userInfo: un dictionnaire d'informations personnalisées à transmettre dans la notification attachments: un tableau d'objets UNNotificationAttachment. Utilisez-le pour inclure du contenu audio, image ou vidéo.

Notez que lors de la localisation des chaînes d'alerte telles que le titre, il est préférable d'utiliser localizedUserNotificationString (forKey: arguments :), ce qui retarde le chargement de la localisation jusqu'à la livraison de la notification.

Un exemple rapide:

 // Swift
 let content = UNMutableNotificationContent()
 content.title = "Don't forget"
 content.body = "Buy some milk"
 content.sound = UNNotificationSound.default()

 // Objective-C
 UNMutableNotificationContent *content = [UNMutableNotificationContent new];
 content.title = @"Don't forget";
 content.body = @"Buy some milk";
 content.sound = [UNNotificationSound defaultSound];

Déclencheur de notification

Déclenche une notification en fonction de l'heure, du calendrier ou du lieu. Le déclencheur peut être répété:

Intervalle de temps: Planifiez une notification quelques secondes plus tard. Par exemple pour déclencher en cinq minutes:

 // Swift
 let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 300, repeats: false)

 // Objective-C
 UNTimeIntervalNotificationTrigger *trigger =     [UNTimeIntervalNotificationTrigger triggerWithTimeInterval:300
                              repeats:NO];

Calendrier: déclencher à une date et une heure spécifiques. Le déclencheur est créé à l'aide d'un objet de composants de date, ce qui facilite la répétition de certains intervalles. Pour convertir une date en composants de date, utilisez le calendrier actuel. Par exemple:

 // Swift
 let date = Date(timeIntervalSinceNow: 3600)
 let triggerDate = Calendar.current.dateComponents([.year, .month, .day, .hour, .minute, .second], from: date)

 // Objective-C
 NSDate *date = [NSDate dateWithTimeIntervalSinceNow:3600];
 NSDateComponents *triggerDate = [[NSCalendar currentCalendar]   
          components:NSCalendarUnitYear +
          NSCalendarUnitMonth + NSCalendarUnitDay +
          NSCalendarUnitHour + NSCalendarUnitMinute +
          NSCalendarUnitSecond fromDate:date];

Pour créer le déclencheur à partir des composants de date:

 // Swift
 let trigger = UNCalendarNotificationTrigger(dateMatching: triggerDate, repeats: false)

 // Objective-C
 UNCalendarNotificationTrigger *trigger = [UNCalendarNotificationTrigger triggerWithDateMatchingComponents:triggerDate
                                     repeats:NO];

Pour créer un déclencheur qui se répète à un certain intervalle, utilisez le bon ensemble de composants de date. Par exemple, pour que la notification se répète tous les jours à la même heure, il suffit d’indiquer les heures, les minutes et les secondes:

 let triggerDaily = Calendar.current.dateComponents([hour, .minute, .second], from: date)
 let trigger = UNCalendarNotificationTrigger(dateMatching: triggerDaily, repeats: true)

Pour le répéter chaque semaine à la même heure, nous avons également besoin du jour de la semaine:

 let triggerWeekly = Calendar.current.dateComponents([.weekday, .hour, .minute, .second], from: date)
 let trigger = UNCalendarNotificationTrigger(dateMatching: triggerWeekly, repeats: true)

Planification

Le contenu et le déclencheur étant prêts, nous créons une nouvelle demande de notification et l'ajoutons au centre de notification. Chaque demande de notification nécessite un identifiant de chaîne pour référence future:

 // Swift
 let identifier = "UYLLocalNotification"
 let request = UNNotificationRequest(identifier: identifier, content: content, trigger: trigger)

 center.add(request, withCompletionHandler: { (error) in
     if let error = error {
         // Something went wrong
     }
 })

 // Objective-C
 NSString *identifier = @"UYLLocalNotification";
 UNNotificationRequest *request = [UNNotificationRequest requestWithIdentifier:identifier
                              content:content trigger:trigger]

 [center addNotificationRequest:request withCompletionHandler:^(NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Something went wrong: %@",error);
  }
  }];
46
Vikram Sahu

Pour lancer une notification sur un temps spécifique, utilisez le code ci-dessous.

let content = UNMutableNotificationContent()
                content.title = "Title"
                content.body = "Body"
                content.sound = UNNotificationSound.default()

                let gregorian = Calendar(identifier: .gregorian)
                let now = Date()
                var components = gregorian.dateComponents([.year, .month, .day, .hour, .minute, .second], from: now)

                // Change the time to 7:00:00 in your locale
                components.hour = 7
                components.minute = 0
                components.second = 0

                let date = gregorian.date(from: components)!

                let triggerDaily = Calendar.current.dateComponents([.hour,.minute,.second,], from: date)
                let trigger = UNCalendarNotificationTrigger(dateMatching: triggerDaily, repeats: true)


                let request = UNNotificationRequest(identifier: CommonViewController.Identifier, content: content, trigger: trigger)
                print("INSIDE NOTIFICATION")

                UNUserNotificationCenter.current().add(request, withCompletionHandler: {(error) in
                    if let error = error {
                        print("SOMETHING WENT WRONG")
                    }
                })

Et pour lancer en permanence dans l'intervalle de temps spécifique, par exemple après toutes les 2 minutes, utilisez la ligne ci-dessous pour le déclencheur.

let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 120, repeats: true)
2
Parth Barot

Pour Swift, vous pouvez éventuellement utiliser ce code:

  let calendar = Calendar.current
    let components = DateComponents(year: 2018, month: 05, day: 06, hour: 20, minute: 22) // Set the date here when you want Notification
    let date = calendar.date(from: components)
    let comp2 = calendar.dateComponents([.year,.month,.day,.hour,.minute], from: date!)
    let trigger = UNCalendarNotificationTrigger(dateMatching: comp2, repeats: true)

    let content = UNMutableNotificationContent()
    content.title = "Notification Demo"
    content.subtitle = "Demo"
    content.body = "Notification on specific date!!"

    let request = UNNotificationRequest(
        identifier: "identifier",
        content: content,
        trigger: trigger
    )

    UNUserNotificationCenter.current().add(request, withCompletionHandler: { error in
        if error != nil {
            //handle error
        } else {
            //notification set up successfully
        }
    })

J'espère que cette aide.

2
Abhirajsinh Thakore

essaye ça

    let dateformateer = NSDateFormatter()
    dateformateer.timeStyle = .ShortStyle

    let notification = UILocalNotification()
    var datecomponent = NSDateComponents()

    datecomponent = NSCalendar.currentCalendar().components([NSCalendarUnit.Day,NSCalendarUnit.Month,NSCalendarUnit.Hour,NSCalendarUnit.Year, NSCalendarUnit.Minute],fromDate: Datepicker.date)


    var fixdate = NSDate()
    fixdate = NSCalendar.currentCalendar().dateFromComponents(datecomponent)!
    notification.fireDate = fixdate
    notification.alertTitle = "Title"
    notification.alertBody = "Body"
   UIApplication.sharedApplication().scheduleLocalNotification(notification)`
0
shirish