Question

在开始之前，请不要燃烧我，因为我知道这里已经被问了数百遍了，没有可靠的答案，但是我相信有一种使用后台刷新的解决方案。 https://medisafe.com/应用似乎已经解决了！

目标：每隔x天在指定时间触发一次本地通知

我的解决方案

第1步：从开始日期和发生的奇数时间（本例为2）天（已编辑）开始计时间隔

步骤2：针对此差异设置间隔计时器，重复进行

第3步：激活后台刷新（如果该应用程序甚至终止，它将在后台加载该应用程序，并为我提供一个小窗口来执行某些任务）

步骤4.将后台刷新设置为每天触发一次

第5步：执行获取项api，它将刷新所有计时器和通知

第6步坐下来，对我的解决方案感到惊讶

但是失败了。

一个计时器间隔

 let newTrigger = UNTimeIntervalNotificationTrigger(timeInterval: 172800,repeats: true)

但是这只会在每天执行后台抓取操作时重置计时器，它将从现在开始触发2天，而不是从开始日期触发。

因此必须有一种比较小时和分钟（开始日期，x日期和当前日期）的方法来计算计时器间隔值。

当前正在使用日历组件。触发我每天执行以下操作

      var triggerType : DateComponents? {
    var triggerT : DateComponents?
    var cal = Calendar(identifier: .gregorian)
    cal.firstWeekday = 2
    if let notificationModel = self.notificationModel {
        switch notificationModel.reminderType {
        case .daily?, .weekly?:
            if let date = notificationModel.date {
                triggerT = cal.dateComponents([.weekday, .hour, .minute], from:date)
                if let weekday = notificationModel.weekday {
                    triggerT?.weekday = weekday
                }
            }
        case .alternateDays?:
            if let date = notificationModel.date {
                triggerT = cal.dateComponents([ .hour, .minute], from:date)
                // THIS IS WHERE I NEED HELP
            }
        case .monthly?:
            if let date = notificationModel.date {
                triggerT = cal.dateComponents([.day,.hour,.minute], from: date)
            }
        case .yearly?:
            triggerT = Calendar.current.dateComponents([.month,.day,.hour,.minute], from: (notificationModel.date)!)
        case .oneOff?:
            triggerT = Calendar.current.dateComponents([.year,.month,.day,.hour,.minute], from: (notificationModel.date)!)
        case .none:
            DispatchQueue.main.async {
                if let category = self.notificationModel?.category, let title = self.notificationModel?.title {
                    Toast.down("An error was discovered in \(category). Please change the occurance value for the following \(title)")
                }
            }
        }
    } else {
        print("NOTIFICATION MODEL IS CORRUPT")
    }
    return triggerT
}

func add(notification: NotificationModel){
    let content = UNMutableNotificationContent()

    if let title = notification.title,
        let body = notification.body,
        let identifier = notification.identifier {


        content.title = title
        content.body = body
        content.sound = UNNotificationSound.default()
        content.categoryIdentifier = (notification.category?.rawValue)!
        content.setValue("YES", forKeyPath: "shouldAlwaysAlertWhileAppIsForeground")

        var trigger : UNCalendarNotificationTrigger?

        if let triggerType = self.triggerType {

            if let occurance = notification.occurance {
                if occurance > 0 {
                }
            }
            trigger = UNCalendarNotificationTrigger(dateMatching: triggerType, repeats: true)

        } else {
            return
        }

        let interval = Date().timeIntervalSince1970
        let identifierString = "2\(interval)"

        var request : UNNotificationRequest!
        if notification.reminderType == .alternateDays {
            print("ADDING TIMER NOTIFICATION")
            print("REMINDER TIME = \(notification.date)")
            // 172800 = two days
            let newTrigger = UNTimeIntervalNotificationTrigger(timeInterval: 172800,
                                                        repeats: true)
            request = UNNotificationRequest(identifier: identifierString,
                                            content: content, trigger: newTrigger)
        } else {
            request = UNNotificationRequest(identifier: identifierString,
                                            content: content, trigger: trigger)
        }


        center.add(request, withCompletionHandler: { (error) in
            if let error = error {
                // Something went wrong
                print(error.localizedDescription)
            } else
            {
                print("ADDING NOTIDCIATION \(content.title)")

            }
        })



        //SNOOZE OR DELETE NOTIFICATIONS
        let snoozeAction = UNNotificationAction(identifier: "Snooze",                                          title: "Snooze", options: [])
        let deleteAction = UNNotificationAction(identifier: "UYLDeleteAction",title: "Delete", options: [.destructive])
        //Create a category with the actions: This requires another unique identifier (you probably want to define these magic strings in an enum):
        let category = UNNotificationCategory(identifier: notification.category!.rawValue,
                                              actions: [snoozeAction,deleteAction],
                                              intentIdentifiers: [], options: [])

        //Register the category with the notification center. It is recommended to do this early in the app lifecycle.

        center.setNotificationCategories([category])
        //To include this action in our notifications we need to set the category in the notification content:

    } else {
        print("Failed to add notification")
    }
}

但是，我希望每隔一天就不想使用64个通知限制。

感谢您的时间

托马斯

Answer 1

让我们说您想从现在开始2、4和6天触发通知，这是您可以执行的操作：

在我的示例中，我将扩展名添加到Date

extension Date {
    func adding(days: Int) -> Date? {
        var dateComponents = DateComponents()
        dateComponents.day = days

        return NSCalendar.current.date(byAdding: dateComponents, to: self)
    }
}

然后您可以为指定的日期创建新的通知，在此示例中，从现在起2、4、6天

let date = Date()
for i in [2, 4, 6] {
    if let date = date.adding(days: i) {
        scheduleNotification(withDate: date)
    }
}

func scheduleNotification(withDate date: Date) {
    let notificationContent = UNMutableNotificationContent()
    notificationContent.title = "Title"
    notificationContent.subtitle = "Subtitle"
    notificationContent.body = "Body"

    let identifier = "Make up identifiers here"
    let dateComponents = Calendar.autoupdatingCurrent.dateComponents([.day, .month, .year, .hour, .minute, .second], from: date)

    let trigger = UNCalendarNotificationTrigger(dateMatching: dateComponents, repeats: false)

    let notificationReques = UNNotificationRequest(identifier: identifier, content: notificationContent, trigger: trigger)

    UNUserNotificationCenter.current().add(notificationReques) { error in
        if let e = error {
            print("Error \(e.localizedDescription)")
        }
    }
}

这应该安排3条通知-从现在开始的2、4、6天...

Answer 2

因此，感谢您的指导，这是我提出的最终解决方案。确保在应用程序功能中打开后台模式，以便更新当前星期。我每天都挖矿。

然后添加带有注释的代码。

//: Playground - noun: a place where people can play

import UIKit
import UserNotifications

让我们创建一些帮助类，以便更轻松地处理日期

// HELPERS

extension Date {

public var weekday: Int {
    return Calendar.current.component(.weekday, from: self)
}

public var hour: Int {
    get {
        return Calendar.current.component(.hour, from: self)
    }
    set {
        let allowedRange = Calendar.current.range(of: .hour, in: .day, for: self)!
        guard allowedRange.contains(newValue) else { return }

        let currentHour = Calendar.current.component(.hour, from: self)
        let hoursToAdd = newValue - currentHour
        if let date = Calendar.current.date(byAdding: .hour, value: hoursToAdd, to: self) {
            self = date
        }
    }
}

public var minute: Int {
    get {
        return Calendar.current.component(.minute, from: self)
    }
    set {
        let allowedRange = Calendar.current.range(of: .minute, in: .hour, for: self)!
        guard allowedRange.contains(newValue) else { return }

        let currentMinutes = Calendar.current.component(.minute, from: self)
        let minutesToAdd = newValue - currentMinutes
        if let date = Calendar.current.date(byAdding: .minute, value: minutesToAdd, to: self) {
            self = date
        }
    }
}
}

然后我们创建自定义通知结构

struct CustomNotification {

static func everyOtherDay(wtihStartDate startDate: Date) -> [Int]? {

    //
    let currentDate = Date()
    // get initial week day from start date to compare dates
    let weekDay = startDate.weekday

    // Then we need to get week of years for both dates
    let cal = Calendar.current

    guard let weekA = cal.dateComponents([.weekOfYear], from: startDate).weekOfYear else { return nil}

    guard let weekB = cal.dateComponents([.weekOfYear], from: currentDate).weekOfYear else {return nil}

    // create two arrays for week days

    let weekOne = [1,3,5,7]
    let weekTwo = [2,4,6]

    // then we create a module to check if we are in week one or week two

    let currentWeek = (weekA - weekB) % 2

    if currentWeek == 0 {
        //week 1
        return weekOne.contains(weekDay) ? weekOne : weekTwo
    } else {
        // week 2
        return weekOne.contains(weekDay) ? weekTwo : weekOne
    }
}
}

最后在我们创建通知的类中。我个人使用通知管理器。但要迅速向您展示

class AClass : NSObject {

func setupNotifications() {

    let startDate = Date()
    let weekDays =  CustomNotification.everyOtherDay(wtihStartDate: startDate)
    let cal = Calendar.current
    let center = UNUserNotificationCenter.current()
    if let weekDays = weekDays {

        for day in weekDays {

            let identifier = "Some Random ID"

            let content = UNMutableNotificationContent()
            content.title = "title"
            content.body = "body"
            content.sound = UNNotificationSound.default()
            content.categoryIdentifier = "SOME CATEGORY"
            content.setValue("YES", forKeyPath: "shouldAlwaysAlertWhileAppIsForeground")

            var components = cal.dateComponents([.hour, .minute], from:startDate)
            components.weekday = day
            let trigger = UNCalendarNotificationTrigger(dateMatching: components, repeats: true)
            let request = UNNotificationRequest(identifier: identifier,
                                            content: content, trigger: trigger)

            center.add(request, withCompletionHandler: { (error) in
                if let error = error {
                    // Something went wrong
                    print("ERROR ADDING NOTIFICATION TO CENTER \(error.localizedDescription)")
                } else
                {
                    print("ADDING NOTIFCIATION \(content.categoryIdentifier)")
                }
            })

        }
    }
}
}

然后，我们需要在应用程序和应用程序委托中设置后台抓取

        // OVER IN APP DELEGATE

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    // setup background refresh ensuring you turn it on in app capabilities
    // trigger back ground refrsh once a day
    UIApplication.shared.setMinimumBackgroundFetchInterval(86400)

    return true

}

func application(_ application: UIApplication, performFetchWithCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
     // FETCH DATA and REFRESH NOTIFICATIONS
    // We need to do this to ensure the current week value is updated to either 1 or 0
    // You will need to delete all notifications with same same category first else your going to be getting both weeks notifications
    let  aClass = AClass()
    aClass.setupNotifications()
}

希望这对某人有帮助：D Thomas

每X天发送一次本地通知-Swift

2 个答案: