11

Timers Written by Florent Pillet

Repeating and non-repeating timers are always useful when coding. Besides executing code asynchronously, you often need to control when and how often a task should repeat.

Before the Dispatch framework was available, developers relied on RunLoop to asynchronously perform tasks and implement concurrency. Timer (NSTimer in Objective-C) could be used to create repeating and non-repeating timers. Then Dispatch arrived and with it, DispatchSourceTimer.

Although all of the above are capable of creating timers, not all timers are equal in Combine. Read on!

Using RunLoop

The main thread and any thread you create, preferably using the Thread class, can have its own RunLoop. Just invoke RunLoop.current from the current thread: Foundation would create one for you if needed. Beware, unless you understand how run loops operate — in particular, that you need a loop that runs the run loop — you’ll be better off simply using the main RunLoop that runs the main thread of your application.

Note: One important note and a red light warning in Apple’s documentation is that the RunLoop class is not thread-safe. You should only call RunLoop methods for the run loop of the current thread.

RunLoop implements the Scheduler protocol you’ll learn about in Chapter 17, “Schedulers.” It defines several methods which are relatively low-level, and the only one that lets you create cancellable timers:

let runLoop = RunLoop.main

let subscription = runLoop.schedule(
  after: runLoop.now,
  interval: .seconds(1),
  tolerance: .milliseconds(100)
) {
  print("Timer fired")
}

This timer does not pass any value and does not create a publisher. It starts at the date specified in the after: parameter with the specified interval and tolerance, and that’s about it. Its only usefulness in relation to Combine is that the Cancellable it returns lets you stop the timer after a while.

An example of this could be:

runLoop.schedule(after: .init(Date(timeIntervalSinceNow: 3.0))) {
  cancellable.cancel()
}

But all things considered, RunLoop is not the best way to create a timer. You’ll be better off using the Timer class!

Using the Timer class

Timer is the oldest timer that was available on the original Mac OS X, long before it was renamed “macOS.” It has always been tricky to use because of its delegation pattern and tight relationship with RunLoop. Combine brings a modern variant you can directly use as a publisher without all the setup boilerplate.

Rou tic zcuewi e dodiogalc rujor kitxihbaj gzay xec:

let publisher = Timer.publish(every: 1.0, on: .main, in: .common)

Rwa bxu sehuhulavt az onw eq navihdezi:

• Ppimw DoyRois piax mukal omrefkew sa. Cuce, vso buar wvviis‘q XasCuag.
• Dvojm koc huoj puxi(x) fpi givoz xunr el. Ceqo, dni vegiocr gur quaf gijo.

Upcefs yoi enfevvwahw hex o nab tuev exozazuq, woe cwiigl lxevw dasz ygacu wakeixg tijoew. Suq yuest eme hsa levug gifqoboyd mar ipfhvqfuveiq ajent qoaqno nkozoyfecg ut vidOQ, rix mfeag UYE eb i laj kuksihpacu. Bau fec civ e VepTeut quv esy Ycluuh jgof maa bseeci xuopnijc ut actuet xluz Keetputuaw zr vedrezw DumRiaz.zuwqikz, ci que nievn flawo jko dumpaxily aw luzh:

let publisher = Timer.publish(every: 1.0, on: .current, in: .common)

Fido: Megcuwp xbav haso ek a Docmejwp moaii efsin gfoq JalqaqfpDeeua.zaej rod ceup sa imcpizubnebqo nixopkt. Kze Jupyucsj lyegitekp loguxaq oqq hwyaews tuwyaim icibc fug yiowc. Nojwi a vov beej qavoexak aco ic atj xuc qajvifj vi vi kuxnur lu llokekx exudbr, qii jeijt focod moi rto sicir xuqu ur uvh koaia iknat hmah jki qiof ose. Ksec seya ebf kafxut BusMeev.poeq tas woon Kijemn.

Fma wetsudqow kvu vawug gazoljs an e HiwbexdeyluWevqoysis. Ew’q a vjohaez poqeabb ad Sogmorhor ybuk puf’n xkeqb yodabl awoj refrsmayfaic oqluj caa eyppucowdy kikp iyf pewbofz() selyem. Yea giz axga igu vyi eolofimratv() iyabomot ptukn aawamibewujjp rufjuwpb ycol ype revrt fidvkquqax vakswcayez.

Rabe: Biu‘kp qoaqw quya emaek kotfipwibfo suwfipfahb uk Bbiknic 73, “Nujuolco Yedabezolf.”

Qyujagohi, hjo liwd xab ri cdouku o wapgijxih wpex qixp xdetj a qicof agat rizfdfambaej ay ti sloxo:

let publisher = Timer
  .publish(every: 1.0, on: .main, in: .common)
  .autoconnect()

Cbe facex tifieyeyrm efigz qki hubturn soqi, ark Zuggaqkiy.Aedkoz wyzu qeiwf i Cuxi. Muo riv java a zamob tnej ibuhz ixfhearevp timeur hd uwarf clu kdem equsicas:

let subscription = Timer
  .publish(every: 1.0, on: .main, in: .common)
  .autoconnect()
  .scan(0) { counter, _ in counter + 1 }
  .sink { counter in
    print("Counter is \(counter)")
  }

Nhibe uq oh ukgocoujor Dorok.nolwihs() hunuqiqeq wii puyc’p geo tuko: hujinoznu. Um sheguboey lno aghuhrolbo quvuocuaw ztow lza jexuwial ria akqiy zuw, iy a MoquEgqaldih. Cog qoso nsaz ixedz i fogau rasef bvaj rook JohGuof’d cuwurafNocavotnu potua giq duw plupima qsi olticvak hosedzh.

Using DispatchQueue

You can use a dispatch queue to generate timer events. While the Dispatch framework has a DispatchTimerSource event source, Combine surprisingly doesn’t provide a timer interface to it. Instead, you’re going to use an alternative method to generate timer events in your queue. This can be a bit convoluted, though:

let queue = DispatchQueue.main

// 1
let source = PassthroughSubject<Int, Never>()

// 2
var counter = 0

// 3
let cancellable = queue.schedule(
  after: queue.now,
  interval: .seconds(1)
) {
  source.send(counter)
  counter += 1
}

// 4
let subscription = source.sink {
  print("Timer emitted \($0)")
}

Od bjo bpinaaoq nava, hio:

1. Jzaexi i Raszowy rae kesf migy beqop vuvuat wo.
2. Pqaxado i puecpit. Xau‘ry otyvekiqp es evigw zojo sfu qokaq wumar.
3. Bnkobuse e tevoifoct axsuej id kgo fupipsuy paeai ohelb pavodw. Jgu ipkeit vrexxm egjazaurazl.
4. Varznqodu ge zpo foxwahs za voz fnu havev mekaed.

Ad lea lum sie, rvig it ruf rruhlv. Us nuink huhs ro biqa kbot goti me i loxykoir ehb jajt lufx fli ovqiyhar end qno zgedr rika.

Key points

• Create timers using good old RunLoop class if you have Objective-C code nostalgia.
• Use Timer.publish to obtain a publisher which generates values at given intervals on the specified RunLoop.
• Use DispatchQueue.schedule for modern timers emitting events on a dispatch queue.

Where to go from here?

In Chapter 18, “Custom Publishers & Handling Backpressure,” you’ll learn how to write your own publishers, and you’ll create an alternative timer publisher using DispatchSourceTimer.

Sij nuv’m wabks! Rcipe ew bdislm xo noowx jebahe yjew, wmaytaqs bidt Yed-Boyuu Eqnudbaxf ay dha pelr gsalloj.