Как я могу немедленно обновить услугу Apple Watch новыми данными?

Question

Моя команда в настоящее время работает над расширением Apple Watch с усложнением. Мы используем усложнение, чтобы позволить пользователям отслеживать определенное значение, которое будет случайным образом обновляться в течение дня по мере поступления новых данных. Наша проблема с усложнением заключается в том, что пользователь заходит в наше расширение и выбирает новое значение для мониторинга, иногда сложность обновляется через 10-15 минут. В расширении акций Apple мы заметили, что последний вид, который вы просматриваете, автоматически становится активным запасом для усложнения, и мы хотим, чтобы наше усложнение функционировало аналогичным образом. Кто-нибудь знает, есть ли способ достичь этой функциональности, или Apple использует для этого закрытый API.

Я включил код в мой ComplicationController, а также методы, в которых я перезагружаю данные об осложнениях.

Контроллер сложности

class ComplicationController: NSObject, CLKComplicationDataSource {

static var metricID : String = ""
static var metricName : String = ""
static var metricValue : Double = 0
static var metricDisplayValue : String = ""
static var metricTimestamp : String = ""
static var metricPercentGoal : Double = 0.01
static var metricDisplayPercentGoal : String = ""
static var metricGoal : String = ""
static var metricTintColor : String = "#81BE41"

let transImage : UIImage = #imageLiteral(resourceName: "S-trans")
let backImage : UIImage = #imageLiteral(resourceName: "S-back")

// MARK: - Timeline Configuration
func getSupportedTimeTravelDirections(for complication: CLKComplication, withHandler handler: @escaping (CLKComplicationTimeTravelDirections) -> Void) {
    handler([.forward])
}

func getTimelineStartDate(for complication: CLKComplication, withHandler handler: @escaping (Date?) -> Void) {

    let date = Calendar.current.startOfDay(for: Date())
    handler(date)
}

func getTimelineEndDate(for complication: CLKComplication, withHandler handler: @escaping (Date?) -> Void) {

    var  date = Calendar.current.startOfDay(for: Date())
    date = Calendar.current.date(byAdding: .day, value: 2, to: date)!
    handler(date)
}

func getPrivacyBehavior(for complication: CLKComplication, withHandler handler: @escaping (CLKComplicationPrivacyBehavior) -> Void) {
    handler(.showOnLockScreen)
}

// MARK: - Timeline Population

func getCurrentTimelineEntry(for complication: CLKComplication, withHandler handler: @escaping (CLKComplicationTimelineEntry?) -> Void) {
    switch complication.family {
    case .utilitarianLarge:
        let template = CLKComplicationTemplateUtilitarianLargeFlat()
        template.textProvider = CLKSimpleTextProvider(text: ComplicationController.metricName)

        let entry = CLKComplicationTimelineEntry(date: NSDate() as Date, complicationTemplate: template)

        handler(entry)
    case .modularSmall:

        if ComplicationController.metricName != "" {
            let template = CLKComplicationTemplateModularSmallStackText()
            let intMetricValue : Int = Int(ComplicationController.metricValue)
            template.line1TextProvider = CLKSimpleTextProvider(text: ComplicationController.metricName)
            template.line2TextProvider = CLKSimpleTextProvider(text: String(intMetricValue))
            template.tintColor = UIColor.color(fromHexString: ComplicationController.metricTintColor)
            let entry = CLKComplicationTimelineEntry(date: NSDate() as Date, complicationTemplate: template)
            handler(entry)
        } else {
            let template = CLKComplicationTemplateModularSmallSimpleImage()
            template.imageProvider = CLKImageProvider(onePieceImage: backImage, twoPieceImageBackground: backImage, twoPieceImageForeground: transImage)
            template.imageProvider.tintColor = UIColor.color(fromHexString: "#81BE41")
            let entry = CLKComplicationTimelineEntry(date: NSDate() as Date, complicationTemplate: template)
            handler(entry)
        }
    case .modularLarge:
        let template = CLKComplicationTemplateModularLargeStandardBody()
        if ComplicationController.metricName != "" {
            template.headerTextProvider = CLKSimpleTextProvider(text: ComplicationController.metricName)
        } else {
            template.headerTextProvider = CLKSimpleTextProvider(text: "SQUEAKS - Metrics")
        }

        if ComplicationController.metricDisplayPercentGoal == "" || ComplicationController.metricDisplayPercentGoal == "0" {
            template.tintColor = UIColor.color(fromHexString: "#81BE41")
        } else {
            template.tintColor = UIColor.color(fromHexString: ComplicationController.metricTintColor)
        }

        if ComplicationController.metricDisplayValue != "" {
            template.body1TextProvider = CLKSimpleTextProvider(text: "Value: \(ComplicationController.metricDisplayValue)", shortText: ComplicationController.metricDisplayValue)
        } else {
            template.body1TextProvider = CLKSimpleTextProvider(text: "----------", shortText: "----------")
        }

        if ComplicationController.metricTimestamp != "" {
            if ComplicationController.metricTimestamp.contains(" at") {
                let formattedTimestamp = ComplicationController.metricTimestamp.replacingOccurrences(of: " at", with: "")
                template.body2TextProvider = CLKSimpleTextProvider(text: formattedTimestamp)
            } else {
                template.body2TextProvider = CLKSimpleTextProvider(text: ComplicationController.metricTimestamp)
            }
        } else {
            template.body2TextProvider = CLKSimpleTextProvider(text: "----------", shortText: "----------")
        }

        let entry = CLKComplicationTimelineEntry(date: NSDate() as Date, complicationTemplate: template)

        handler(entry)
    case .circularSmall:
        if ComplicationController.metricName != "" {
            let template = CLKComplicationTemplateCircularSmallStackText()
            let intMetricValue : Int = Int(ComplicationController.metricValue)
            template.line1TextProvider = CLKSimpleTextProvider(text: ComplicationController.metricName)
            template.line2TextProvider = CLKSimpleTextProvider(text: String(intMetricValue))
            template.tintColor = UIColor.color(fromHexString: ComplicationController.metricTintColor)
            let entry = CLKComplicationTimelineEntry(date: NSDate() as Date, complicationTemplate: template)

            handler(entry)
        } else {
            let template = CLKComplicationTemplateCircularSmallSimpleImage()
            template.imageProvider = CLKImageProvider(onePieceImage: backImage, twoPieceImageBackground: backImage, twoPieceImageForeground: transImage)
            template.imageProvider.tintColor = UIColor.color(fromHexString: "#81BE41")
            let entry = CLKComplicationTimelineEntry(date: NSDate() as Date, complicationTemplate: template)

            handler(entry)
        }
    default:
        handler(nil)
    }
}

func getTimelineEntries(for complication: CLKComplication, before date: Date, limit: Int, withHandler handler: @escaping ([CLKComplicationTimelineEntry]?) -> Void) {
    // Call the handler with the timeline entries prior to the given date
    handler(nil)
}

func getTimelineEntries(for complication: CLKComplication, after date: Date, limit: Int, withHandler handler: @escaping ([CLKComplicationTimelineEntry]?) -> Void) {
}

// MARK: - Placeholder Templates

func getLocalizableSampleTemplate(for complication: CLKComplication, withHandler handler: @escaping (CLKComplicationTemplate?) -> Void) {

    switch complication.family {
    case .modularSmall:
        let template = CLKComplicationTemplateModularSmallSimpleImage()
        template.imageProvider.tintColor = UIColor.color(fromHexString: "#81BE41")
        template.imageProvider = CLKImageProvider(onePieceImage: backImage, twoPieceImageBackground: backImage, twoPieceImageForeground: transImage)
        handler(template)
    case .utilitarianLarge:
        let template = CLKComplicationTemplateUtilitarianLargeFlat()

        template.textProvider = CLKSimpleTextProvider(text: "SQUEAKS - Metrics")

        handler(template)

    case .modularLarge:
        let template = CLKComplicationTemplateModularLargeStandardBody()
        if ComplicationController.metricName != "" {
            template.headerTextProvider = CLKSimpleTextProvider(text: ComplicationController.metricName)
        } else {
            template.headerTextProvider = CLKSimpleTextProvider(text: "SQUEAKS - Metrics")
        }
        template.headerTextProvider.tintColor = UIColor.color(fromHexString: ComplicationController.metricTintColor)
        template.body1TextProvider = CLKSimpleTextProvider(text: "----", shortText: "----")
        template.body2TextProvider = CLKSimpleTextProvider(text: "----", shortText: "----")

        let formattedTimestamp = ComplicationController.metricTimestamp.replacingOccurrences(of: " at", with: "")
        template.body2TextProvider = CLKSimpleTextProvider(text: formattedTimestamp, shortText: formattedTimestamp)

        handler(template)
    case .circularSmall:
        let template = CLKComplicationTemplateCircularSmallSimpleImage()
        template.imageProvider.tintColor = UIColor.color(fromHexString: "#81BE41")
        template.imageProvider = CLKImageProvider(onePieceImage: backImage, twoPieceImageBackground: backImage, twoPieceImageForeground: transImage)
        handler(template)
    default:
        handler(nil)
    }
}

Обновление данных о сложностях

@objc fileprivate func changeMonitoredMetric() {
    if let metricDictionary = selectedMetric {

        if let complicationID = metricDictionary["ID"] as? String {
            ComplicationController.metricID = complicationID
            userDefaults?.set(complicationID, forKey: "MonitoredMetric")
        } else {
            ComplicationController.metricID = ""
        }

        if let complicationName = metricDictionary["Name"] as? String {
            ComplicationController.metricName = complicationName
        } else {
            ComplicationController.metricName = ""
        }

        if let complicationValue = metricDictionary["Value"] as? Double {
            ComplicationController.metricValue = complicationValue
        } else {
            ComplicationController.metricValue = 0
        }

        if let complicationDisplayValue = metricDictionary["Display Value"] as? String {
            ComplicationController.metricDisplayValue = complicationDisplayValue
        } else {
            ComplicationController.metricDisplayValue = ""
        }

        if let complicationGoal = metricDictionary["Goal"] as? String {
            ComplicationController.metricGoal = complicationGoal
        } else {
            ComplicationController.metricGoal = ""
        }

        if let complicationTimestamp = metricDictionary["Timestamp"] as? String {
            ComplicationController.metricTimestamp = complicationTimestamp
        } else {
            ComplicationController.metricTimestamp = ""
        }

        if let complicationPercentGoal = metricDictionary["Display Percent Goal"] as? String {
            var displayPercentGoal = complicationPercentGoal

            if !displayPercentGoal.characters.isEmpty {
                displayPercentGoal.characters.removeLast()

                if Int(displayPercentGoal)! <= 100 {
                    ComplicationController.metricDisplayPercentGoal = displayPercentGoal
                } else {
                    ComplicationController.metricDisplayPercentGoal = "100"
                }
            }
        } else {
            ComplicationController.metricDisplayPercentGoal = "0"
        }

        if let complicationPercentGoal = metricDictionary["Percent Goal"] as? Double {
            ComplicationController.metricPercentGoal = complicationPercentGoal
        } else {
            ComplicationController.metricPercentGoal = 0
        }

        if let complicationTintColor = metricDictionary["Background Color"] as? String {
            ComplicationController.metricTintColor = complicationTintColor
        } else {
            ComplicationController.metricTintColor = ""
        }

        addRemoveMenuItem()
    }

    // Update complication
    reloadComplicationTimeline()

Перезагрузка сроков для осложнений

func reloadComplicationTimeline() {
    let complicationServer = CLKComplicationServer.sharedInstance()
    guard let activeComplications = complicationServer.activeComplications else {
        return
    }

    for complication in activeComplications {
        complicationServer.reloadTimeline(for: complication)
    }
}

Примечание. Мы уже пытались использовать exteTimeline вместо reloadTimeline, и это дало аналогичные результаты.

Заранее спасибо за любую помощь, которую вы можете оказать.

Обновление После тестирования я также заметил, что если через несколько минут я открою расширение для часов, сложность будет обновлена, когда я снова выйду. Кажется, что когда ваше приложение активно, усложнение получает обновление данных. Иногда через 45 минут без обновления, как только я открываю приложение, усложняется обновление.