Должен ли я использовать обработчик завершения здесь?Если так, то как лучше это сделать?

Question

У меня есть ошибка в моем приложении, которую я только что обнаружил в этом методе:

private func createNotifications(dateComponents: DateComponents) {

    switch (recurrence) {
    case .today:
        createNotification(for: dateComponents)
    case .tomorrow:
        createNotification(for: day(after: dateComponents))
    case .daily:
        let center = UNUserNotificationCenter.current()
        center.getPendingNotificationRequests { (notifications) in
            var numberOfCreatableNotifications = 64 - notifications.count
            var numberOfCreatedNotifications = 0
            var currentDay: DateComponents? = dateComponents
            while numberOfCreatableNotifications > 0
                    && numberOfCreatedNotifications < self.NUMBER_OF_ALLOWED_NOTIFICATIONS_CREATED_AT_ONE_TIME {
                self.createNotification(for: currentDay)
                currentDay = self.day(after: currentDay)
                numberOfCreatableNotifications -= 1
                numberOfCreatedNotifications += 1
            }
        }
    }
}

Я пытаюсь создать сигнал тревоги с определенной опцией повторения (сегодня, завтра или ежедневно) иежедневный случай не работал.Код выше находится в Alarm.swift.Когда сигнал тревоги создается, он передается обратно в контроллер основного вида для сохранения в Базовых данных.Я понял, что уведомления не сохраняются в Базовых данных, потому что они не создаются к моменту сохранения тревоги в Базовых данных.Это закрытие center.getPendingNotificationRequests (), которое, по-видимому, занимает некоторое время, прежде чем возвращается и запускает обработчик завершения.

Я использую метод getPendingNotificationRequests (), потому что я пытаюсь определить, сколько оставшихся уведомлений я могу создать (максимум 64).

Вот мой вопрос: должен ли я продолжать использовать этот асинхронный метод и просто сохранить некоторые данные в Core Data во время обработчика завершения?Или код сохранения должен остаться в главном контроллере представления, и я просто перестал использовать этот асинхронный метод, потому что он мне почему-то не нужен?

Спасибо

Кстати, вот большинствокод из моего файла AlarmTableViewController, основной VC в моем приложении:

//MARK: Public properties
var alarms = [AlarmMO]()
let ALARM_CELL_IDENTIFIER = "AlarmTableViewCell"

override func viewDidLoad() {
    super.viewDidLoad()
    requestUserNotificationsPermissionsIfNeeded()
    NotificationCenter.default.addObserver(self, selector: #selector(didBecomeActive), name: UIApplication.didBecomeActiveNotification, object: nil)
    loadAlarms()

    for alarm in self.alarms {
        os_log("There are %d notifications for alarm %d", log: OSLog.default, type: .debug, alarm.notificationUuids.count, alarm.alarmNumber)
    }
}

deinit {
    NotificationCenter.default.removeObserver(self, name: UIApplication.didBecomeActiveNotification, object: nil)
}

// MARK: - Table view data source

override func numberOfSections(in tableView: UITableView) -> Int {
    return 1
}

override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return self.alarms.count
}

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {

    guard let cell = tableView.dequeueReusableCell(withIdentifier: ALARM_CELL_IDENTIFIER, for: indexPath) as? AlarmTableViewCell else {
        fatalError("The dequeued cell is not an instance of AlarmTableViewCell.")
    }

    guard let alarmMO = self.alarms[safe: indexPath.row] else {
        os_log("Could not unwrap alarm for indexPath in AlarmTableViewController.swift", log: OSLog.default, type: .default)
        self.tableView.reloadData()
        return AlarmTableViewCell()
    }
    let alarmNumber = alarmMO.value(forKey: "alarmNumber") as! Int
    let beginTime = alarmMO.value(forKey: "startTimeInterval") as! Double
    let endTime = alarmMO.value(forKey: "endTimeInterval") as! Double
    cell.alarmNumberLabel.text = "Alarm " + String(alarmNumber)

    let beginTimeHour = Alarm.extractHourFromTimeDouble(alarmTimeDouble: beginTime)
    let beginTimeMinute = Alarm.extractMinuteFromTimeDouble(alarmTimeDouble: beginTime)
    cell.beginTimeLabel.text = formatTime(hour: beginTimeHour, minute: beginTimeMinute)

    let endTimeHour = Alarm.extractHourFromTimeDouble(alarmTimeDouble: endTime)
    let endTimeMinute = Alarm.extractMinuteFromTimeDouble(alarmTimeDouble: endTime)
    cell.endTimeLabel.text = formatTime(hour: endTimeHour, minute: endTimeMinute)

    guard let notificationUuids = self.getNotificationUuidsFromAlarmMO(alarmMO: alarmMO) else {
        os_log("Could not get notificationUuids from AlarmMO in tableView(cellForRowAt:) in AlarmTableViewController.swift", log: OSLog.default, type: .debug)
        return cell
    }
    os_log("----- notificationUuids: -----", log: OSLog.default, type: .debug)
    for uuid in notificationUuids {
        os_log("uuid: %@", log: OSLog.default, type: .debug, uuid)
    }

    return cell

}

override func tableView(_ tableView: UITableView, canEditRowAt indexPath: IndexPath) -> Bool {
    return true
}

override func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {

    if (editingStyle == .delete) {

        guard let alarm = self.alarms[safe: indexPath.row] else {
            os_log("Could not get alarm from its indexPath in AlarmTableViewController.swift", log: OSLog.default, type: .default)
            self.tableView.reloadData()
            return
        }
        guard let notificationUuids = self.getNotificationUuidsFromAlarmMO(alarmMO: alarm) else {
            os_log("Could not get notificationUuids from AlarmMO in tableView(forRowAt:) in AlarmTableViewController.swift", log: OSLog.default, type: .debug)
            return
        }
        self.removeNotifications(notificationUuids: notificationUuids)
        guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else {
            return
        }
        let managedContext = appDelegate.persistentContainer.viewContext
        managedContext.delete(alarm)
        self.alarms.remove(at: indexPath.row)

        for (index, alarm) in self.alarms.enumerated() {
            let alarmNumber = index + 1
            alarm.setValue(alarmNumber, forKey: "alarmNumber")
        }

        self.saveContext()
        self.tableView.reloadData()

    }

}

// MARK: Actions

@IBAction func unwindToAlarmList(sender: UIStoryboardSegue) {

    if let sourceViewController = sender.source as? AddAlarmViewController, let alarm = sourceViewController.alarm {
        let newIndexPath = IndexPath(row: self.alarms.count, section: 0)
        os_log("There are %d notificationUuids attached to the alarm created", log: OSLog.default, type: .debug, alarm.notificationUuids.count)
        saveAlarm(alarmToSave: alarm)
        tableView.insertRows(at: [newIndexPath], with: .automatic)
    }

}

// MARK: Private functions

@objc private func didBecomeActive() {

    deleteOldAlarms {
        DispatchQueue.main.async {
            self.tableView.reloadData()
        }
    }

}

private func deleteOldAlarms(completionHandler: @escaping () -> Void) {

    os_log("deleteOldAlarms() called", log: OSLog.default, type: .default)
    let notificationCenter = UNUserNotificationCenter.current()
    var alarmsToDelete = [AlarmMO]()
    guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else {
        return
    }
    let managedContext = appDelegate.persistentContainer.viewContext

    notificationCenter.getPendingNotificationRequests(completionHandler: { (requests) in

        alarmsToDelete = self.calculateAlarmsToDelete(requests: requests)
        os_log("Deleting %d alarms", log: OSLog.default, type: .debug, alarmsToDelete.count)
        for alarmMOToDelete in alarmsToDelete {
            guard let notificationUuids = self.getNotificationUuidsFromAlarmMO(alarmMO: alarmMOToDelete) else {
                os_log("Could not get notificationUuids from AlarmMO in deleteOldAlarms() in AlarmTableViewController.swift", log: OSLog.default, type: .debug)
                return
            }
            self.removeNotifications(notificationUuids: notificationUuids)
            managedContext.delete(alarmMOToDelete)
            self.alarms.removeAll { (alarmMO) -> Bool in
                return alarmMOToDelete == alarmMO
            }
        }
        completionHandler()

    })

}

private func calculateAlarmsToDelete(requests: [UNNotificationRequest]) -> [AlarmMO] {
    var activeNotificationUuids = [String]()
    var alarmsToDelete = [AlarmMO]()
    for request in requests {
        activeNotificationUuids.append(request.identifier)
    }
    for alarm in self.alarms {
        guard let notificationUuids = self.getNotificationUuidsFromAlarmMO(alarmMO: alarm) else {
            os_log("Could not get notificationUuids from AlarmMO in deleteOldAlarms() in AlarmTableViewController.swift", log: OSLog.default, type: .debug)
            return []
        }
        let activeNotificationUuidsSet: Set<String> = Set(activeNotificationUuids)
        let alarmUuidsSet: Set<String> = Set(notificationUuids)
        let union = activeNotificationUuidsSet.intersection(alarmUuidsSet)
        if union.isEmpty {
            alarmsToDelete.append(alarm)
        }
    }
    return alarmsToDelete
}

private func removeNotifications(notificationUuids: [String]) {

    os_log("Removing %d alarm notifications", log: OSLog.default, type: .debug, notificationUuids.count)
    let notificationCenter = UNUserNotificationCenter.current()
    notificationCenter.removePendingNotificationRequests(withIdentifiers: notificationUuids)

}

private func loadAlarms() {

    os_log("loadAlarms() called", log: OSLog.default, type: .debug)
    guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else {
            return
    }
    let managedContext = appDelegate.persistentContainer.viewContext
    let fetchRequest = NSFetchRequest<AlarmMO>(entityName: "Alarm")

    do {
        if self.alarms.count == 0 {
            self.alarms = try managedContext.fetch(fetchRequest)
            os_log("Loading %d alarms", log: OSLog.default, type: .debug, self.alarms.count)
        } else {
            os_log("Didn't need to load alarms", log: OSLog.default, type: .debug)
        }
    } catch let error as NSError {
        print("Could not fetch alarms. \(error), \(error.userInfo)")
    }

}

private func saveAlarm(alarmToSave: Alarm) {

    guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else {
            return
    }
    let managedContext = appDelegate.persistentContainer.viewContext
    let entity = NSEntityDescription.entity(forEntityName: "Alarm", in: managedContext)!
    let alarmMO = AlarmMO(entity: entity, insertInto: managedContext)

    alarmMO.setValue(alarmToSave.alarmTime, forKeyPath: "alarmTime")
    alarmMO.setValue(alarmToSave.alarmNumber, forKeyPath: "alarmNumber")
    alarmMO.setValue(alarmToSave.alarmIntervalBeginTimeDouble, forKeyPath: "startTimeInterval")
    alarmMO.setValue(alarmToSave.alarmIntervalEndTimeDouble, forKeyPath: "endTimeInterval")
    alarmMO.setValue(alarmToSave.recurrence.hashValue, forKeyPath: "recurrence")
    alarmMO.setValue(alarmToSave.notificationUuids, forKeyPath: "notificationUuids")

    if managedContext.hasChanges {
        do {
            try managedContext.save()
            self.alarms.append(alarmMO)
        } catch let error as NSError {
            print("Could not save alarm to CoreData. \(error), \(error.userInfo)")
        }
    } else {
        os_log("No changes to the context to save", log: OSLog.default, type: .debug)
    }

}

private func getNotificationUuidsFromAlarmMO(alarmMO: AlarmMO) -> [String]? {

    guard let notificationUuids = alarmMO.value(forKey: "notificationUuids") as! [String]? else {
        os_log("Found nil when attempting to unwrap notificationUuids in getNotificationUuidsFromAlarmMO() in AlarmTableViewController.swift, returning nil",
               log: OSLog.default, type: .default)
        return nil
    }
    return notificationUuids

}

Answer 1

Вероятно, было бы проще всего, если бы этот метод всегда выполнялся асинхронно, а всегда вызывает обработчик завершения.Итак, ваш вызывающий код передаст этому методу обработчик завершения, как он его вызывает, и остановится.Позже этот метод будет вызывать вызывающую функцию обратно для обработчика завершения, уведомляя его о том, что мы создали несколько уведомлений.Возможный эскиз:

private func createNotifications(dateComponents: DateComponents, completion: (Int) -> Void) {
    let center = UNUserNotificationCenter.current()
    center.getPendingNotificationRequests { (notifications) in
        switch (recurrence) { 
            // this is wrong, you should not be looking outside this method for the recurrence value...
            // ... but it's just a sketch
            case .today:
                createNotification(for: dateComponents)
                completion(1)
            case .tomorrow:
                createNotification(for: day(after: dateComponents))
                completion(1)
            case .daily:
                // ... decide whether to create the notifications or not ...
                // ... and create however many you decide to ...
                let howManyWeCreated = // however many we created
                completion(howManyWeCreated)
        }
    }
}