是否可以在应用程序未运行时通过本地通知增加应用程序徽章？
我知道如何设置徽章，但还没有找到任何方法来增加这个值。
localNotification.applicationIconBadgeNumber = 23;
更新：我找到了一个（远非完美的）解决方案。如果用户不打开应用并为每个 +1 事件添加通知，您可以预测会发生什么。
一个例子：
==> 将这些通知放在一个数组中，并在应用程序退出之前设置它们。
但是，我正在寻找比这种解决方法更好的解决方案。
我已经找到、实施并测试了一个“解决方法”，用于（显然）自动增加应用程序图标的徽章编号，该方法适用于非重复的本地通知
UILocalNotifications 确实不可能让 iOS 在触发多个本地通知时“自动”更新/增加徽章编号，并且用户“忽略”它们或不立即处理它们，因此它们“堆积”在通知中中心。
此外，向您的应用程序“添加一些回调方法”无法处理“自动增量”，因为整个通知事情是由 iOS 在您的应用程序“外部”处理的，您的应用程序甚至不需要运行。
但是有一些解决方法，这是基于我通过实验发现的知识，因为 XCode 文档对徽章属性过于模糊。
因此，对于“解决方法”，您的应用程序必须已经为它新创建的每个通知提供正确的、递增的徽章编号，并在“待处理通知之上”注册。
由于您的应用程序无法查看未来，并且知道您将立即处理哪些事件，以及哪些事件您将“等待”一段时间，因此有一些技巧可以做：
当您的应用程序处理通知时（通过点击通知、图标等），您必须：
此外，当您的应用注册新通知时，它必须首先检查有多少通知处于待处理状态，然后使用 with 注册新通知：
badgeNbr = nbrOfPendingNotifications + 1;
查看我的代码，它会变得更清晰。我对此进行了测试，它肯定有效：
在您的“registerLocalNotification”方法中，您应该这样做：
NSUInteger nextBadgeNumber = [[[UIApplication sharedApplication] scheduledLocalNotifications] count] + 1;
localNotification.applicationIconBadgeNumber = nextBadgeNumber;
当您处理通知（appDelegate）时，您应该调用下面的方法，该方法清除图标上的标记并重新编号待处理通知的标记（如果有）
请注意，下一个代码适用于“顺序”注册事件。如果您要在未决事件之间“添加”事件，则必须首先“重新排序”这些事件。我没有走那么远，但我认为这是可能的。
- (void)renumberBadgesOfPendingNotifications
{
// clear the badge on the icon
[[UIApplication sharedApplication] setApplicationIconBadgeNumber:0];
// first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
NSArray *pendingNotifications = [[UIApplication sharedApplication] scheduledLocalNotifications];
// if there are any pending notifications -> adjust their badge number
if (pendingNotifications.count != 0)
{
// clear all pending notifications
[[UIApplication sharedApplication] cancelAllLocalNotifications];
// the for loop will 'restore' the pending notifications, but with corrected badge numbers
// note : a more advanced method could 'sort' the notifications first !!!
NSUInteger badgeNbr = 1;
for (UILocalNotification *notification in pendingNotifications)
{
// modify the badgeNumber
notification.applicationIconBadgeNumber = badgeNbr++;
// schedule 'again'
[[UIApplication sharedApplication] scheduleLocalNotification:notification];
}
}
}
要真正做到“防弹”，此方法应该是“原子”（内核）代码，防止 iOS 在此方法执行期间触发通知。我们必须在这里冒这个险，发生这种情况的可能性很小。
这是我对 Stackoverflow 的第一个贡献，因此如果我不遵守此处的“规则”，您也可以发表评论
当您的应用程序未运行时，您能够动态设置徽章编号的唯一方法是使用推送通知。您必须在服务器端跟踪更新。
根据文档，我相信当您的应用程序未运行时，您无法增加徽章的值。您在安排通知时设置了徽章编号，因此无法增加它。
应用程序负责管理其图标上显示的徽章编号。例如，如果文本消息应用程序在收到本地通知后处理所有传入消息，它应该通过将 UIApplication 对象的 applicationIconBadgeNumber 属性设置为 0 来删除图标标记。
Whasssaaahhh 的回答对我很有帮助。我还需要根据通知的 fireDates 对通知进行排序。这是 Whasssaaahhh 的代码和我的代码，用于使用 NSArray 的委托方法对通知进行排序 -[NSArray sortedArrayUsingComparator:^(id obj1, id obj2) {}];
- (void)renumberBadgesOfPendingNotifications
{
// clear the badge on the icon
[[UIApplication sharedApplication] setApplicationIconBadgeNumber:0];
// first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
// Sort the pending notifications first by their fireDate
NSArray *pendingNotifications = [[[UIApplication sharedApplication] scheduledLocalNotifications] sortedArrayUsingComparator:^(id obj1, id obj2) {
if ([obj1 isKindOfClass:[UILocalNotification class]] && [obj2 isKindOfClass:[UILocalNotification class]])
{
UILocalNotification *notif1 = (UILocalNotification *)obj1;
UILocalNotification *notif2 = (UILocalNotification *)obj2;
return [notif1.fireDate compare:notif2.fireDate];
}
return NSOrderedSame;
}];
// if there are any pending notifications -> adjust their badge number
if (pendingNotifications.count != 0)
{
// clear all pending notifications
[[UIApplication sharedApplication] cancelAllLocalNotifications];
// the for loop will 'restore' the pending notifications, but with corrected badge numbers
// note : a more advanced method could 'sort' the notifications first !!!
NSUInteger badgeNbr = 1;
for (UILocalNotification *notification in pendingNotifications)
{
// modify the badgeNumber
notification.applicationIconBadgeNumber = badgeNbr++;
// schedule 'again'
[[UIApplication sharedApplication] scheduleLocalNotification:notification];
}
}
}
一段时间后，我需要在 Swift 上实现这一点，但还需要支持重复本地通知。我想出了一个关于 Swift 的解决方案。
Swift 2.3 的解决方案
func renumberBadgesOfPendingNotifications() {
let app = UIApplication.sharedApplication()
let pendingNotifications = app.scheduledLocalNotifications
// clear the badge on the icon
app.applicationIconBadgeNumber = 0
// first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
// if there are any pending notifications -> adjust their badge number
if let pendings = pendingNotifications where pendings.count > 0 {
// Reassign firedate.
var notifications = pendings
var i = 0
for notif in notifications {
if notif.fireDate?.compare(NSDate()) == NSComparisonResult.OrderedAscending &&
notif.repeatInterval.rawValue == NSCalendarUnit.init(rawValue:0).rawValue {
// Skip notification scheduled earlier than current date time
// and if it is has NO REPEAT INTERVAL
}
else {
notif.fireDate = getFireDate(notif)
}
i+=1
}
// sorted by fire date.
notifications = pendings.sort({ p1, p2 in p1.fireDate!.compare(p2.fireDate!) == .OrderedAscending })
// clear all pending notifications
app.cancelAllLocalNotifications()
// the for loop will 'restore' the pending notifications, but with corrected badge numbers
var badgeNumber: Int = 1
for n in notifications {
// modify the badgeNumber
n.applicationIconBadgeNumber = badgeNumber
badgeNumber+=1
// schedule 'again'
app.scheduleLocalNotification(n)
}
}
}
private func getFireDate(notification:UILocalNotification?) -> NSDate? {
if notification == nil {
return nil
}
let currentDate: NSDate = NSDate().dateByRemovingSeconds()
let originalDate: NSDate = notification!.fireDate!
var fireDate: NSDate? = originalDate
if originalDate.compare(currentDate) == NSComparisonResult.OrderedAscending ||
originalDate.compare(currentDate) == NSComparisonResult.OrderedSame {
let currentDateTimeInterval = currentDate.timeIntervalSinceReferenceDate
let originalDateTimeInterval = originalDate.timeIntervalSinceReferenceDate
var frequency:NSTimeInterval = 0
switch notification?.repeatInterval {
case NSCalendarUnit.Hour?:
frequency = currentDate.dateByAddingHours(1).timeIntervalSinceDate(currentDate)
print(frequency)
break
case NSCalendarUnit.Day?:
frequency = currentDate.dateByAddingDays(1).timeIntervalSinceDate(currentDate)
print(frequency)
break
case NSCalendarUnit.WeekOfYear?:
frequency = currentDate.dateByAddingDays(7).timeIntervalSinceDate(currentDate)
print(frequency)
break
case NSCalendarUnit.Month?:
frequency = currentDate.dateByAddingMonths(1).timeIntervalSinceDate(currentDate)
print(frequency)
break
case NSCalendarUnit.Year?:
frequency = currentDate.dateByAddingYears(1).timeIntervalSinceDate(currentDate)
print(frequency)
break
default:
originalDate
}
let timeIntervalDiff = (((currentDateTimeInterval - originalDateTimeInterval) / frequency) + frequency) + originalDateTimeInterval
fireDate = NSDate(timeIntervalSinceReferenceDate: timeIntervalDiff)
}
return fireDate?.dateByRemovingSeconds()
}
注意：dateByAddingHours、dateByAddingHours、dateByAddingMonths、dateByAddingYears、dateByRemovingSeconds 是我正在使用的 DateExtension 中的方法，是您可以自行实现的自描述方法。
在您的项目委托中添加以下代码。
- (void)applicationDidEnterBackground:(UIApplication *)application
{
NSLog(@"%s",__FUNCTION__);
NSArray *arrayOfLocalNotifications = [[UIApplication sharedApplication] scheduledLocalNotifications] ;
for (UILocalNotification *localNotification in arrayOfLocalNotifications) {
NSLog(@"the notification: %@", localNotification);
localNotification.applicationIconBadgeNumber= application.applicationIconBadgeNumber+1;
}
}
这对我有用。:-)
Whasssaabhhh 在 Swift 2.1 中的回答，带有排序
func renumberBadgesOfPendingNotifications() {
let app = UIApplication.sharedApplication()
let pendingNotifications = app.scheduledLocalNotifications
// clear the badge on the icon
app.applicationIconBadgeNumber = 0
// first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
// if there are any pending notifications -> adjust their badge number
if let pendings = pendingNotifications where pendings.count > 0 {
// sorted by fire date.
let notifications = pendings.sort({ p1, p2 in p1.fireDate!.compare(p2.fireDate!) == .OrderedAscending })
// clear all pending notifications
app.cancelAllLocalNotifications()
// the for loop will 'restore' the pending notifications, but with corrected badge numbers
var badgeNumber = 1
for n in notifications {
// modify the badgeNumber
n.applicationIconBadgeNumber = badgeNumber++
// schedule 'again'
app.scheduleLocalNotification(n)
}
}
}
从 iOS10 开始，可以直接在 UNMutableNotificationContent 上定义徽章编号。
这对我有用：
我正在开发一个基于日期（使用 CalendarComponents）添加通知的应用程序，我的触发器是 UNCalendarNotificationTrigger。我的代码很简单：
let content = UNMutableNotificationContent()
content.title = "Title"
content.body = "Your message"
content.sound = .default()
content.badge = NSNumber(value: UIApplication.shared.applicationIconBadgeNumber + 1)
关于content.badge，医生说：
var 徽章：NSNumber？{ get set }
描述 应用于应用程序图标的数字。
使用此属性指定通知到达时应用到应用程序图标的数字。如果您的应用无权显示基于徽章的通知，则忽略此属性。
指定数字 0 以移除当前徽章（如果存在）。指定一个大于 0 的数字以显示带有该数字的徽章。指定 nil 以保持当前徽章不变。
SDK iOS 10.0+、tvOS 10.0+、watchOS 3.0+
添加通知时，即使应用程序未运行，徽章也会自行增加。您可以在应用程序中的任何位置清除徽章编号：
UIApplication.shared.applicationIconBadgeNumber = 0
作为 Bionicle 解决方案的替代方案，可以使用 NSSortDescriptor 来处理基于 fireDate 字段的排序。同样，此解决方案提供了 Whasssaaahhh 原始答案的所有好处，但也意味着它可以处理以非时间顺序添加的通知，例如在 30 秒内添加通知，然后在 20 秒内添加通知。添加本地通知时以及返回应用程序时，我调用以下函数。
// When we add/remove local notifications, if we call this function, it will ensure each notification
// will have an ascending badge number specified.
- (void)renumberBadgesOfPendingNotifications
{
// Clear the badge on the icon
[[UIApplication sharedApplication] setApplicationIconBadgeNumber:0];
// First get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
NSMutableArray * pendingNotifications = [[[UIApplication sharedApplication] scheduledLocalNotifications] mutableCopy];
// Sorted by fire date.
NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"fireDate" ascending:TRUE];
[pendingNotifications sortUsingDescriptors:[NSArray arrayWithObject:sortDescriptor]];
[sortDescriptor release];
// if there are any pending notifications -> adjust their badge number
if (pendingNotifications.count != 0)
{
// clear all pending notifications
[[UIApplication sharedApplication] cancelAllLocalNotifications];
// the for loop will 'restore' the pending notifications, but with corrected badge numbers
// note : a more advanced method could 'sort' the notifications first !!!
NSUInteger badgeNbr = 1;
for (UILocalNotification *notification in pendingNotifications)
{
// modify the badgeNumber
notification.applicationIconBadgeNumber = badgeNbr++;
// schedule 'again'
[[UIApplication sharedApplication] scheduleLocalNotification:notification];
}
}
// Release our copy.
[pendingNotifications release];
}
这是一个棘手的问题。由于 iOS 不会为您跟踪本地通知的徽章编号，因此您可以自行维护每个通知的编号并及时更新它们。
更复杂的是，类中nextTriggerDate提供的功能UNTimeIntervalNotificationTrigger无法正常工作。因此，如果您依靠它来订购发送通知的待处理通知，将会出现混乱。
我设法找到的一个实用且简化的解决方案是首先删除所有通知，然后在您需要发送新通知时根据您的逻辑重新发送它们。这样他们的徽章编号就可以保证都是正确的。
总之，您应该至少在以下条目中执行此类操作：
userNotificationCenter(_:didReceive:withCompletionHandler:)userNotificationCenter(_:willPresent:withCompletionHandler:)Based on Wassaahbbs and Bionicles answers above, for Swift 3.0 this seems to be working for Repeating Local Notifications. I have it working for setting 4 local notifications, each of which can be turned on and off independently.
The renumberBadgesOfPendingNotifications function is called in AppDelegate applicationDidBecomeActive so badges are updated if user opens the app after being notified. And also in a settingsVC where a setNotification function sets the notifications in the first place and In case user turns a notification on or off thus needing a badge update.
Also the badge is set to 0 in applicationDidBecomeActive with UIApplication.shared.applicationIconBadgeNumber = 0.
func renumberBadgesOfPendingNotifications() {
// first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
let pendingNotifications = UIApplication.shared.scheduledLocalNotifications
print("AppDel there are \(pendingNotifications?.count) pending notifs now")
// if there are any pending notifications -> adjust their badge number
if var pendings = pendingNotifications, pendings.count > 0 {
// sort into earlier and later pendings
var notifications = pendings
var earlierNotifs = [UILocalNotification]()
var laterNotifs = [UILocalNotification]()
for pending in pendings {
// Skip notification scheduled earlier than current date time
if pending.fireDate?.compare(NSDate() as Date) == ComparisonResult.orderedAscending {
// and use this if it has NO REPEAT INTERVAL && notif.repeatInterval.rawValue == NSCalendar.Unit.init(rawValue:0).rawValue {
// track earlier and later pendings
earlierNotifs.append(pending)
}
else {
laterNotifs.append(pending)
}
}
print("AppDel there are \(earlierNotifs.count) earlier notifications")
print("AppDel there are \(laterNotifs.count) later notifications")
// change the badge on the notifications due later
pendings = laterNotifs
// sorted by fireDate.
notifications = pendings.sorted(by: { p1, p2 in p1.fireDate!.compare(p2.fireDate!) == .orderedAscending })
// clear all pending notifications. i.e the laterNotifs
for pending in pendings {
UIApplication.shared.cancelLocalNotification(pending)
}
// the for loop will 'restore' the pending notifications, but with corrected badge numbers
var laterBadgeNumber = 0
for n in notifications {
// modify the badgeNumber
laterBadgeNumber += 1
n.applicationIconBadgeNumber = laterBadgeNumber
// schedule 'again'
UIApplication.shared.scheduleLocalNotification(n)
print("AppDel later notif scheduled with badgenumber \(n.applicationIconBadgeNumber)")
}
// change the badge on the notifications due earlier
pendings = earlierNotifs
// sorted by fireDate.
notifications = pendings.sorted(by: { p1, p2 in p1.fireDate!.compare(p2.fireDate!) == .orderedAscending })
// clear all pending notifications. i.e the laterNotifs
for pending in pendings {
UIApplication.shared.cancelLocalNotification(pending)
}
// the for loop will 'restore' the pending notifications, but with corrected badge numbers
var earlierBadgeNumber = laterBadgeNumber
for n in notifications {
// modify the badgeNumber
earlierBadgeNumber += 1
n.applicationIconBadgeNumber = earlierBadgeNumber
// schedule 'again'
UIApplication.shared.scheduleLocalNotification(n)
print("AppDel earlier notif scheduled with badgenumber \(n.applicationIconBadgeNumber)")
}
}
}
基于以上 Wassaahbbs 和 Bionicles 的答案。Swift 4.0，适用于所有 iOS 版本。在 中调用此函数func applicationDidBecomeActive(_ application: UIApplication)。
func renumberBadgesOfPendingNotifications() {
if #available(iOS 10.0, *) {
UNUserNotificationCenter.current().getPendingNotificationRequests { pendingNotificationRequests in
if pendingNotificationRequests.count > 0 {
let notificationRequests = pendingNotificationRequests
.filter { $0.trigger is UNCalendarNotificationTrigger }
.sorted(by: { (r1, r2) -> Bool in
let r1Trigger = r1.trigger as! UNCalendarNotificationTrigger
let r2Trigger = r2.trigger as! UNCalendarNotificationTrigger
let r1Date = r1Trigger.nextTriggerDate()!
let r2Date = r2Trigger.nextTriggerDate()!
return r1Date.compare(r2Date) == .orderedAscending
})
let identifiers = notificationRequests.map { $0.identifier }
UNUserNotificationCenter.current().removePendingNotificationRequests(withIdentifiers: identifiers)
notificationRequests.enumerated().forEach { (index, request) in
if let trigger = request.trigger {
let content = UNMutableNotificationContent()
content.body = request.content.body
content.sound = .default()
content.badge = (index + 1) as NSNumber
let request = UNNotificationRequest(identifier: request.identifier, content: content, trigger: trigger)
UNUserNotificationCenter.current().add(request)
}
}
}
}
} else if let pendingNotifications = UIApplication.shared.scheduledLocalNotifications, pendingNotifications.count > 0 {
let notifications = pendingNotifications
.filter { $0.fireDate != nil }
.sorted(by: { n1, n2 in n1.fireDate!.compare(n2.fireDate!) == .orderedAscending })
notifications.forEach { UIApplication.shared.cancelLocalNotification($0) }
notifications.enumerated().forEach { (index, notification) in
notification.applicationIconBadgeNumber = index + 1
UIApplication.shared.scheduleLocalNotification(notification)
}
}
}