Usernotification 框架徽章不增加

Question

我在我的应用程序中使用 UserNotification 框架并发送本地通知（不是推送通知），我想将徽章设置为收到的通知数量，所以我所做的是设置收到用户默认通知然后我尝试将值分配给徽章以获得徽章编号但徽章编号不会增加。这是我下面的代码

设置接收通知的值

center.getDeliveredNotifications { notification in

    UserDefaults.standard.set(notification.count, forKey: Constants.NOTIFICATION_COUNT)
    print("notification.count \(notification.count)")
    print(".count noti \(UserDefaults.standard.integer(forKey: Constants.NOTIFICATION_COUNT))")

}

这会准确地打印出收到的通知数量，当我决定将其设置为我的徽章时，它只显示 1

content.badge = NSNumber(value: UserDefaults.standard.integer(forKey: Constants.NOTIFICATION_COUNT))

我不知道为什么这个值每次都没有增加。任何帮助将不胜感激。

或者如果可以始终在应用程序的任何位置更新徽章。

Answer 1

像这样发送本地通知：

func sendNotification(title: String, subtitle: String, body: String, timeInterval: TimeInterval) {
    let center = UNUserNotificationCenter.current()
    center.getPendingNotificationRequests(completionHandler: { pendingNotificationRequests in

        //Use the main thread since we want to access UIApplication.shared.applicationIconBadgeNumber
        DispatchQueue.main.sync {

            //Create the new content
            let content = UNMutableNotificationContent()
            content.title = title
            content.subtitle = subtitle
            content.body = body

            //Let's store the firing date of this notification in content.userInfo
            let firingDate = Date().timeIntervalSince1970 + timeInterval
            content.userInfo = ["timeInterval": firingDate]

            //get the count of pending notification that will be fired earlier than this one
            let earlierNotificationsCount: Int = pendingNotificationRequests.filter { request in

                let userInfo = request.content.userInfo
                if let time = userInfo["timeInterval"] as? Double {
                    if time < firingDate {
                        return true
                    } else {

                        //Here we update the notofication that have been created earlier, BUT have a later firing date
                        let newContent: UNMutableNotificationContent = request.content.mutableCopy() as! UNMutableNotificationContent
                        newContent.badge = (Int(truncating: request.content.badge ?? 0) + 1) as NSNumber
                        let newRequest: UNNotificationRequest =
                            UNNotificationRequest(identifier: request.identifier,
                                                  content: newContent,
                                                  trigger: request.trigger)
                        center.add(newRequest, withCompletionHandler: { (error) in
                            // Handle error
                        })
                        return false
                    }
                }
                return false
            }.count

            //Set the badge
            content.badge =  NSNumber(integerLiteral: UIApplication.shared.applicationIconBadgeNumber + earlierNotificationsCount + 1)
            let trigger = UNTimeIntervalNotificationTrigger(timeInterval: timeInterval,
                                                            repeats: false)

            let requestIdentifier = UUID().uuidString  //You probably want to save these request identifiers if you want to remove the corresponding notifications later
            let request = UNNotificationRequest(identifier: requestIdentifier,
                                                content: content, trigger: trigger)

            center.add(request, withCompletionHandler: { (error) in
                // Handle error
            })
        }
    })
}

（您可能需要保存请求的标识符（如果您想更新它们，可以保存在用户默认值或核心数据中，甚至可以通过 removePendingNotificationRequests(withIdentifiers:) 取消它们）

你可以这样调用上面的函数：

sendNotification(title: "Meeting Reminder",
                 subtitle: "Staff Meeting in 20 minutes",
                 body: "Don't forget to bring coffee.",
                 timeInterval: 10)

将您的视图控制器声明为 UNUserNotificationCenterDelegate:

class ViewController: UIViewController, UNUserNotificationCenterDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        UNUserNotificationCenter.current().delegate = self
    }
    //...
}

并处理与通知的交互，更新应用的徽章，以及即将到来的通知的徽章：

func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {

    //UI updates are done in the main thread
    DispatchQueue.main.async {
        UIApplication.shared.applicationIconBadgeNumber -= 1
    }

    let center = UNUserNotificationCenter.current()
    center.getPendingNotificationRequests(completionHandler: {requests in
        //Update only the notifications that have userInfo["timeInterval"] set
        let newRequests: [UNNotificationRequest] =
            requests
                .filter{ rq in
                    return rq.content.userInfo["timeInterval"] is Double?
                }
                .map { request in
                    let newContent: UNMutableNotificationContent = request.content.mutableCopy() as! UNMutableNotificationContent
                    newContent.badge = (Int(truncating: request.content.badge ?? 0) - 1) as NSNumber
                    let newRequest: UNNotificationRequest =
                        UNNotificationRequest(identifier: request.identifier,
                                              content: newContent,
                                              trigger: request.trigger)
                    return newRequest
        }
        newRequests.forEach { center.add([=13=], withCompletionHandler: { (error) in
            // Handle error
        })
        }
    })
    completionHandler()
}

这会在与通知交互时通过减少它来更新应用徽章，即点击。此外，它还会更新待处理通知的内容标志。添加具有相同标识符的通知请求只会更新待处理的通知。

要在前台接收通知，并在未与通知交互时增加应用徽章图标，请执行以下操作：

func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    DispatchQueue.main.async {
        UIApplication.shared.applicationIconBadgeNumber += 1
    }
    completionHandler([.alert, .sound])
}

这里有一些 gif：

1st：接收本地通知增加应用徽章。而与通知交互会减少应用徽章。
2nd: 应用被杀死时接收本地通知（我在这个中使用了15s的触发时间间隔）。
3rd：在前台接收通知会增加应用徽章，除非用户与之交互。

我的测试项目中使用的完整class如下所示：

import UIKit
import UserNotifications

class ViewController: UIViewController, UNUserNotificationCenterDelegate {
    var bit = true
    @IBAction func send(_ sender: UIButton) {
        let time: TimeInterval = bit ? 8 : 4
        bit.toggle()
        sendNotification(title: "Meeting Reminder",
                         subtitle: "Staff Meeting in 20 minutes",
                         body: "Don't forget to bring coffee.",
                         timeInterval: time)
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

        UNUserNotificationCenter.current().delegate = self
    }

    func sendNotification(title: String, subtitle: String, body: String, timeInterval: TimeInterval) {
        let center = UNUserNotificationCenter.current()
        center.getPendingNotificationRequests(completionHandler: { pendingNotificationRequests in
            DispatchQueue.main.sync {
                let content = UNMutableNotificationContent()
                content.title = title
                content.subtitle = subtitle
                content.body = body
                let firingDate = Date().timeIntervalSince1970 + timeInterval
                content.userInfo = ["timeInterval": firingDate]
                let earlierNotificationsCount: Int = pendingNotificationRequests.filter { request in
                    let userInfo = request.content.userInfo
                    if let time = userInfo["timeInterval"] as? Double {
                        if time < firingDate {
                            return true
                        } else {
                            let newContent: UNMutableNotificationContent = request.content.mutableCopy() as! UNMutableNotificationContent
                            newContent.badge = (Int(truncating: request.content.badge ?? 0) + 1) as NSNumber
                            let newRequest: UNNotificationRequest =
                                UNNotificationRequest(identifier: request.identifier,
                                                      content: newContent,
                                                      trigger: request.trigger)
                            center.add(newRequest, withCompletionHandler: { (error) in
                                // Handle error
                            })
                            return false
                        }
                    }
                    return false
                    }.count
                content.badge =  NSNumber(integerLiteral: UIApplication.shared.applicationIconBadgeNumber + earlierNotificationsCount + 1)
                let trigger = UNTimeIntervalNotificationTrigger(timeInterval: timeInterval,
                                                                repeats: false)

                let requestIdentifier = UUID().uuidString  //You probably want to save these request identifiers if you want to remove the corresponding notifications later
                let request = UNNotificationRequest(identifier: requestIdentifier,
                                                    content: content, trigger: trigger)

                center.add(request, withCompletionHandler: { (error) in
                    // Handle error
                })
            }
        })
    }

    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        DispatchQueue.main.async {
            UIApplication.shared.applicationIconBadgeNumber += 1
        }
        completionHandler([.alert, .sound])
    }

    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        DispatchQueue.main.async {
            UIApplication.shared.applicationIconBadgeNumber -= 1
        }

        let center = UNUserNotificationCenter.current()
        center.getPendingNotificationRequests(completionHandler: {requests in
            let newRequests: [UNNotificationRequest] =
                requests
                    .filter{ rq in
                        return rq.content.userInfo["timeInterval"] is Double? 
                    }
                    .map { request in
                        let newContent: UNMutableNotificationContent = request.content.mutableCopy() as! UNMutableNotificationContent
                        newContent.badge = (Int(truncating: request.content.badge ?? 0) - 1) as NSNumber
                        let newRequest: UNNotificationRequest =
                            UNNotificationRequest(identifier: request.identifier,
                                              content: newContent,
                                              trigger: request.trigger)
                        return newRequest
            }
            newRequests.forEach { center.add([=15=], withCompletionHandler: { (error) in
                // Handle error
            })
            }
        })
        completionHandler()
    }
}

Answer 2

我假设这都是本地通知。

据我所知，您的问题有解决方案！

通知到达时，您要么在前台，要么在后台。

foreground: 你得到了 userNotificationCenter(_:willPresent:withCompletionHandler:) 回调，但我认为在那种情况下你不会想要增加徽章，对吗？因为用户刚刚看到了。尽管我可以想象您可能需要在哪里这样做。假设您的应用程序类似于 WhatsApp，并且用户打开了该应用程序并正在向他的母亲发送消息。然后他父亲的消息到达了。此时他还没有打开他和他父亲之间的消息，但他看到了通知。在您的 willPresent 中，您可以查询 getDeliveredNotifications 并调整您的徽章数量。
background: for iOS10+ 本地通知版本你倒霉了！因为你没有回调。通知被发送到 OS 就这样！曾经有一个名为 application:didReceiveLocalNotification: but that's deprecated. For more on that see here
当用户点击（前台或后台）时，您将收到 userNotificationCenter(_:didReceive:withCompletionHandler:) 但这没有用，因为用户已经确认收到通知并且在这种情况下增加徽章没有意义。

长话短说 AFAIK 对于 local 通知您无能为力。

如果它是远程通知，那么在 application(_:didReceiveRemoteNotification:fetchCompletionHandler:) 中您可以查询发送的通知并增加徽章计数...

编辑：

由于 badgeCount 已附加到到达通知，因此如果您可以在到达之前更新其 badgeCount 那么一切都很好。例如在中午 12 点，您可以随时查询待处理通知列表。它将为您提供中午 12 点之后到达的所有通知，并在必要时更新它们的 badgeCount，例如如果阅读了一些已发送的通知，则减少他们的 badgeCount。有关此问题的完整解决方案，请参阅。他回答的要点是

对于您要发送的任何新通知：

获得 pendingNotifications
过滤触发日期早于要发送的新通知的通知并获取其count
将新通知的标记设置为应用的 badgeCount + <strong>filtered</strong>Count + 1
if 任何未决通知的触发日期都大于我们刚刚添加的新通知，那么我们将 pending 通知的 badgeCount 增加 1.
显然，每当您与已发送的通知进行交互时，您必须再次获取所有 pendingNotifications 并将它们的 badgeCount 减少 1

警告：

您不能对触发器基于位置的通知执行此操作，因为显然它们不关心时间。

Usernotification 框架徽章不增加

Usernotification framework badge does not increase

ios

swift

usernotifications