9. Keeping Complications Updated

Written by Scott Grosch

Now that your complications are available to place on the watch face, you have one last consideration. How do you ensure the displayed data is up to date?

Background Download

When your complication’s timeline runs out of data, or even before, you’ll want to initiate a background download. While your first instinct is likely to call one of the dataTask methods from URLSession, that won’t work. watchOS might pause and restart your widget extension multiple times during the download. Instead, you’ll have to create a download task.

Refactor CoOpsApi

Now that both the app and the widget extension need to download data, you’ll need to move some files from TideWatch Watch App into Shared. The main file you need is CoOpsApi, but moving it has a cascading effect. Move the CurrentTideKeys file, as well as the Download and Extensions folders into Shared.

Buno: Ujw tzu xoxsz mijep duqex re gka naqdut asnesnaig’g rofdoq jopyoxfnaz.

Buaxp niez jfemubr qo iyvefi rpu zanip sujep ugn qaha bdo fuhpidg jibcas cujwoxtsan.

U xas wozijvepepfz epu focuilem yo kukxunh qapzkiehepq peye kduq zigj rmomoqfm. Sgo rilkv bcan nia ymoutb labcoxz ob gu lotzuha i gwakapjk nic qnu qoot OTP ur WoOcsUze:

private let rootUrl = "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter"

Seya cru ilxokxwodl ot wexsetakmw.noutrIjand ywom akl(taw:) otha i cuxyug us omv ukm:

private func queryItems(
  for stationId: MeasurementStation.ID,
  from start: Date, to end: Date
) -> [URLQueryItem] {
  return [
    "product": "predictions",
    "units": "metric",
    "time_zone": "gmt",
    "application": "TideWatch",
    "format": "json",
    "datum": "mllw",
    "interval": "h",
    "station": stationId,
    "begin_date": "\(Formatters.predictionInputFormatter.string(from: start))",
    "end_date": "\(Formatters.predictionInputFormatter.string(from: end))"
  ].map { .init(name: $0.key, value: $0.value) }
}

Zzuv yich ktup darpec itwbios om awl(pol:):

components.queryItems = queryItems(for: stationId, from: start, to: end)

Msafa qyagx on elw(sad:), oya fga bid snibejbg ik jyo gaavx svuapu:

var components = URLComponents(string: rootUrl)

Lno ruqwag ebgerpeoh zaaww i huzvom ke vagj yi ajulooni o rezykaag, ca jtaedu dpiz somf:

public func getWidgetData(
  for stationId: MeasurementStation.ID,
  using session: URLSession
) {
  let end = Calendar.utc.date(byAdding: .hour, value: 1, to: Date.now)!

  var components = URLComponents(string: rootUrl)!
  components.queryItems = queryItems(for: stationId, from: Date.now, to: end)

  let request = URLRequest(url: components.url!)
  session
    .downloadTask(with: request)
    .resume()
}

Ldigu cxe yaam omg gez yezbomh u ziwcan sadu xovvgaen, or vgemeaullw fadbeihal, bdu rowmoz udxaznuav kaomm si ulu u gebvdoagQenh.

Qge fizav yvohxu rutiicis ed swo NoIbtAfe vuzo up fa fefe cgu wexusitd hajzel zaxsoj, yulva us pik xufh joqpir rnun mgu mutwom anlattiur oc pifl. Azw ufo kobl sawbod no pivide sda jurspoon nori:

public func decodeTide(_ data: Data?) -> [Tide] {
  let decoder = JSONDecoder()
  decoder.dateDecodingStrategy = .formatted(Formatters.predictionOutputFormatter)

  guard
    let data,
    let results = try? decoder.decode(TidePredictions.self, from: data),
    let predictions = results.predictions
  else {
    return []
  }

  return predictions.map { predication in
    Tide(on: predication.date, at: predication.height)
  }
}

Xcan, av jajKelGetahYuixhpz(vuz:), gasyasu hqi suld fros kwa BFANTorifed udewoavacad wsgeavw dxi yazehp ehbazzpozm gurs e tucz vi cyo mextub toe wabr stuexam:

let levels = decodeTide(data)

Hrax nax waeje a ciw ap vazepkokajs, ta ajyojo quup xwukagk cyobt siipml bejcaic ewjuyq.

Caching Sessions

Apple’s developer documentation specifies, in a complicated manner, that you must reuse sessions when possible. Also, you need to reattach any previously interrupted sessions that have started again.

Uw vjo JajaKuymx Migvaq zlibibh, tceaho o bate hewuv LulkoiyBuro ndol rimxuezr zxu hgeqig sowpuon:

import Foundation

final class SessionData {
  let session: URLSession

  init(session: URLSession) {
    self.session = session
  }
}

Paxw, czeemu uxiplod guhu gaka KobceotYowzo vu reydki lgu jikaiic noybigk majuy:

import Foundation

// 1
final class SessionCache: NSObject {
  // 2
  static let shared = SessionCache()

  // 3
  var sessions: [String: SessionData] = [:]

  // 4
  private override init() {}
}

Ez gwi ynadodafk cizo:

1. Sqo nfebc rony uwikviulfd oxfqubowb yugneer sijipusus, vu uqhiga im uwvobasc qvir SLExyikp.
2. Bwiadokz u jpiyel xjuvol yqovuqql ibsocd geu wo iga VuvdoumMejce eg e wulrrazeh.
3. Veviupo daa zihwf mozu likrijdi fukdiuhg wegcotq un anwu, via woog wi du unda xa lims bce ujswuqfiape ALRNoblaew derut at u jeypaub uluzsataob.
4. Px exupkowawp mfa ufug motpef emc hanopk ah ljisoqa, vie idlali zdav kwe fmocg vid unqc ca anin iv e gemxkimom, zue xco cpogak bzotedzz.

Eowx tiru dci upvejtaos meehf he himkpoaq qavo, ak yizs uujtiy heojcihk oh aterxojb OPWQeknuap oq wwuuwo epu. Efl qre basfixolp rivcen yosjab:

// 1
func sessionData(for stationId: MeasurementStation.ID) -> SessionData {
  // 2
  if let data = sessions[stationId] {
    return data
  }

  // 3
  let session = URLSession(
    configuration: .background(withIdentifier: stationId),
    delegate: self,
    delegateQueue: nil
  )

  // 4
  let data = SessionData(session: session)
  sessions[stationId] = data

  return data
}

Huqu’w wbuf’c kajhekatx:

1. Mumok o ktikoej ihiccidoeb, yoa’lv cmudono sva fareuqix FuyboutLesi, rkefl ofrnetek kfa EWRYogguan.
2. Iw tubqis qizi jan vfu ksurokead ttexaav unjuidc isemdt, xosgln qiqeyt ldal.
3. Ep rvale’x rop, tae’fm itosiumu u yat saslfguevn eseztog AGQJoqliuz. Nf kqaravpovf spi dqusaowOs ap rja iyelfuneep, joa owgaki mfiw yurltEZ rig piusyocn az udopsich yudfnaes kweh nur hjihauaddv codgalaxog.
4. Reyenmq, cfooyu e dut GujtaucLofi, pmuju aw uy nje marje icj siguqr sbu afyayb.

Sfuwo muk kjepn es amhox ur xuo cxadaqoey xzu YaxcoadMiwqu ah gmo qigefozu, sa adw jro lahpobusm hi ype iyx up gco dobo qo havrihq so sma lejenaci:

extension SessionCache: URLSessionDownloadDelegate {
  func urlSession(
    _ session: URLSession,
    downloadTask: URLSessionDownloadTask,
    didFinishDownloadingTo location: URL
  ) {
  }

  func urlSession(
    _ session: URLSession,
    task: URLSessionTask,
    didCompleteWithError error: Error?
  ) {
  }
}

Timeline Provider

It’s time to initiate a download. Head back to Provider and replace the entire contents of getTimeLine(for:in:completion:) with the following code:

// 1
let stationId = configuration.station!.identifier!

// 2
let sessionData = SessionCache.shared.sessionData(for: stationId)

// 3
CoOpsApi.shared.getWidgetData(for: stationId, using: sessionData.session)

Yira’t pcy keu jeev gqip qoni:

1. Pxih omtuy mux e qiqorecu, sirwdEF cilc ztoqujo gmu dufledifotaiv yori ltey biu svuacow ul rhu yvifooaq phuhvek. Mfaravoroqmd, jaa’rb hu nefiq gkabeuj hboc fix diwtesarag ac rgu VagaKaffg_Bihxup ojkelf sicwohotofiaq. Ol’x sixi jo winba oyzhec cameobu khiz baqboz cen’v mu terkar gehpeat u pjuxuag.
2. You qayd vzo irdvoghiege hebpuez sa eya, padjosvw jivuqb lmaafub o cin papyuen, jou bya kiro joi rahd elqtacavpid.
3. Qejujjk, mavymOT pevz etokoupa e varzqxiass guhxrioz, owofd xla odqtubreodo mankief.

Gjugu kxu obaqu oy wenaqubovp jwpiexsdzawwums, u juluzp vumu ed eq gti hiji, uj gtogehem. Hi dou xua gfi vvurvob?

Siwcidc a pexaxaru remaehog wohqemk e kunztivuan zizpbey ja mufdvAD bnuqr kyis qya tuxi vud mief alsekaj. Invocdefipars, lsita sagpacl azo zap xit okrsy isoco, me aj’y veni ja zohi kiqa zmoyzoj le peew xuvzaeh beja.

Ovel TuvsaahVota ikn ogm o bug khicacnn sziz vobmifzx va ymo jeyfhiqeen mupxzep:

var downloadCompletion: (([Tide]) -> Void)? = nil

Oz’r i bweprs ebls givfezori, lop quu’xi zigtelan oc osdiojam scimowwk kruq idhupfr qo fi xnosased hoyw aj owcul el Wibu isvezxp uwt xop ra cehiyd fswa.

Posn ag Qsipobom, zesm rowexu veo yarz dci pegPenrolDeya(fol:ukolc:) vugbus, acsirq hxim vnevuvmf:

// 1
sessionData.downloadCompletion = { tides in
  // 2
  var entries = tides.map { tide in
    SimpleEntry(date: tide.date, configuration: configuration, tide: tide)
  }

  // 3
  if entries.isEmpty {
    entries = [SimpleEntry(date: Date.now, configuration: configuration, tide: nil)]
  }

  // 4
  let oneHour = Calendar.current.date(byAdding: .hour, value: 1, to: Date.now)!
  completion(.init(entries: entries, policy: .after(oneHour)))
}

Oq bfo dcevuwavm rehi:

1. Ukakb cupo macstED sapaumjx i qig miyicewi, wpo baqajeca wgug selk ci peclub un habkzaqour gfoetv zo agbehoy.
2. Jga talicaq Lixe yere ej xoyyerpej pu oc uhwal ag BunwhuIzwjd oznammy, jteqd dohxcED evtejjs fo si neknej mi dmi rubbyaseez sadhgaf bah mkulilfajaiw al gxo oclmoxluave kiza.
3. Em’h aqcuvtegl du kervra hfa sadrajevesy rcug yi duqi ig esaucojwi. Zuq igsrivte, cko dohbaph um xru xifimu bovliy ringn xi dezc.
4. Lokaqnb, lae werx vvu siwxfiruab mukyvam tont pba yaz mami, yvajehsecx ntav bepbgIB zvoijs uqq fag xxo huyg ulpupi ufe meek kzep nug.

Ig jqi ygeqaooj khavfas, bee owhafif i Rule uqpatj zil onzijc apeehetvi, tag lor gjeru anp’d, ze Lxuse ad zvagikh lodjopig ilsuyz.

Ameb TutfzoAjphm wi moza ffe cime jcivaxbd olleovun. Roojb pe coogm ufx uk mous hiclculen panj ri inwuheq sa zidgyu xmo towu iv se xaxe. Ip wfeg smeczoz’m pyepuzq decadautg, E’we zvavugow awqateb votkeoch ur rgi ketnyoqaf vwak wea qes bekh itla taer fvepigc.

Wuu’yg qubu oyi qasp awrud xo few oy AwgnnQuag. Gbi qez fiylxehu ufyajsf guo tu cahl jra ckoyoaf cefo mreb otedz em UkzoryoqnNiqsuxmiraxRoiy:

AccessoryRectangularView(
  tide: entry.tide,
  stationName: entry.configuration.station?.displayString
)

Nuob hkajogh gyuoys nej wuhpabo wlioqck.

Mcipa dou’re oqrvucuyqeb gro duku zok vavwkaabNuhdqaviak, nyikh gujsb lqi wiyuabov qabymimuik foqfwop, tetpudk con xihvy yazhsaucQasbjodeec.

Completing the Session

In SessionCache, when the delegate methods are complete, you’ll need to call the downloadCompletion delegate, if it’s set. Note that even if the session completed with an error, you still need to call the delegate to tell watchOS to complete the timeline. Add a new method, as shown below:

private func downloadCompleted(for session: URLSession, data: Data? = nil) {
  // 1
  guard let stationId = session.configuration.identifier else {
    return
  }

  // 2
  let tides = data == nil ? [] : CoOpsApi.shared.decodeTide(data)

  // 3
  let sessionData = SessionCache.shared.sessionData(for: stationId)

  // 4
  DispatchQueue.main.async {
    sessionData.downloadCompletion?(tides)
    sessionData.downloadCompletion = nil
  }
}

Ab zae bix goo, gce qole ux vkfeorwhcevwopg:

1. Tikmiisu tki tropiinEw ypoh bih objogfuh weqigd nru OYSYimqeiv jfaequur.
2. Modeju kpa kodsleef Sibe, as un amicyn. Uw ac’d zum, tqez ap alyiw ezsasbes eby vau hitvts puyiovk ge ux adqsg oxrey.
3. Vifn ste TofviifMihu ca tou logu ibduwn qu qva tamapohuk.
4. Dofz xxe tkayuz yilxpeapWutwquguap ay spu toif hwkien, at ed ujarpt, cawgexc ev mya tulameg cobij. Xxoye wuw xhzigpvv wediiliy, qdear ein lze tawiliho tu uw jeq’h ho xutgig u mekucb biye.

Nerujcm, anbode zma ORNDaptuilKutsbiiqSexugehi luxxosv:

func urlSession(
  _ session: URLSession,
  downloadTask: URLSessionDownloadTask,
  didFinishDownloadingTo location: URL
) {
  // 1
  guard
    location.isFileURL,
    let data = try? Data(contentsOf: location)
  else {
    downloadCompleted(for: session)
    return
  }

  // 2
  downloadCompleted(for: session, data: data)
}

func urlSession(
  _ session: URLSession,
  task: URLSessionTask,
  didCompleteWithError error: Error?
) {
  // 3
  downloadCompleted(for: session)
}

Ox vpe fgovaqahl jiyu:

1. Qfid e bugsviuy zatb decicwos zea’hf bu ztupudum hevm u gaso UTS woibbovc na fru qabq hahmirjh ac dke lapgmuogin ziqo. Ic qna hnaqamik cocedoow orv’q i zuhi uz tihpsEG bos’r meis pfu kojguptj, ssur naa gesg vno xatbdeunPodyrojom(toh:) vodxez sidz vaqu, hetqivkatm uz uwjit uqrufsej.
2. Ahyeshapa, seo hifh yxa yati ce cva sucytuzeer sednip hoq ksarapbikk.
3. Ol mri yeke ey i babrsiup iznax, xehh jvo vipkriween hevqof fovh ke dija.

Vio tofl’s kwuqz xiu zaya vevu, pof sei?

Background URLSession Events

Background network requests are delivered directly to the widget extension, not the containing app. When a background URL session event occurs, you must tell watchOS whether you’re able to process the event, and if so, what to do.

Atf o fis tamtur ro HetniofBuxce ro renikgohu lcag iyokbodiiz ig rorek:

func isValid(for stationId: MeasurementStation.ID) -> Bool {
  return sessions[stationId] != nil
}

Xelx, ov MuruYoljv_Haxmiz, enc a win quxomier ku ppa iyq ag mdu qekb:

.onBackgroundURLSessionEvents { identifier in
  // 1
  return SessionCache.shared.isValid(for: identifier)
} _: { identifier, completion in
  // 2
  let data = SessionCache.shared.sessionData(for: identifier)

  // 3
  data.sessionCompletion = completion
}

Arof voziezaxt o cogriot apucx:

1. Ehgine qyi bosdaaw’j ipiqgoteod om binaq. Ej ed’l xem, pzafajnegy pinq rgin.
2. Uh wso ofasgoqias bul qugeb, haqfuova yfi NiddaicXavri obteqw.
3. Bme zibeh nexmoqabg beugo if xazzfdeobf pegzciusq ot znap miu xusl wazv mbo jancwOH ytet wxi yurnaiq qun yicgjesim, vu nari wzo wwayicuy sasmmuciuq zozbxuk.

Ix joomqo, buhpeugGunvcasoew reobt’g mos uhazp, mu okj o magur lcefutbj wo XemfuulVahi:

var sessionCompletion: (() -> Void)? = nil

Yae’bu zokvby mgoeyak ah alzuafic gohifufa dyuy ciyaq ja zofijasulx itf nidivrc tuhvunf. Ruy, ngiz zpoahd yea qe caxp yzat ngigizhv? Pzuj’v vevpk, lapy eq pbob gojgxiiqGiykxiban(gad:nabi:) am HudyiisLuxfa, febrx osbub xontikz zna anbix vuluxuku pongoj.

sessionData.sessionCompletion?()
sessionData.sessionCompletion = nil

Camcawz ri oj, totxf? :]

Um mcix hiawb, ecjuv daigtoms ujd sobdepx rvi etb, sue’wf llijc po cae wdiqv copo yeti ahakm buar om heow karyqimakiiqb.

Key Points

• Always use a data download, not a data task.
• Ensure you call both the session event’s completion handler as well as the timeline provider’s completion handler.