Repeat

modern NSTimer in GCD, debouncer and throttler.

Repeat is small lightweight alternative to NSTimer with a modern Swift Syntax, no strong references, multiple observers reusable instances. Repeat is based upon GCD - Grand Central Dispatch. It also support debouncer and throttler features.

Features Highlights

Main features offered by Repeat are:

  • Simple, less verbose APIs methods to create and manage our timer. Just call every() or once to create a new Timer even in background thread.
  • Avoid strong references to the destination target and avoid NSObject inheritance.
  • Support multiple observers to receive fire events from timer.
  • Ability to pause , start , resume and reset our timer without allocating a new instance.
  • Ability to set different repeat modes (infinite : infinite sequence of fires, at regular intervals, finite : a finite sequence of fires, at regular intervals, once : a single fire events at specified interval since start).

Moreover Repeat also provide supports for:

  • Debouncer: Debouncer will delay a function call, and every time it's getting called it will delay the preceding call until the delay time is over.
  • Throttler: Throttling wraps a block of code with throttling logic, guaranteeing that an action will never be called more than once each specified interval.

Timer

Note: As any other object Repeater class is subject to the standard memory management rules. So once you create your timer instance you need to retain it somewhere in order to avoid premature deallocation just after the start command.

Create single fire timer

The following code create a timer which fires a single time after 5 seconds.

self.timer = Repeater.once(after: .seconds(5)) { timer in
  // do something	
}

Create recurrent finite timer

The following code create a recurrent timer: it will fire every 10 minutes for 5 times, then stops.

self.timer = Repeater.every(.minutes(10), count: 5) { timer  in
  // do something		
}

Create recurrent infinite timer

The following code create a recurrent timer which fires every hour until it is manually stopped .

self.timer = Repeater.every(.hours(1)) { timer in
  // do something
}

Manage a timer

You can create a new instance of timer and start as needed by calling the start() function.

self.timer = Repeater(interval: .seconds(5), mode: .infinite) { _ in
  // do something		
}
timer.start()

Other functions are:

  • start(): start a paused or newly created timer
  • pause(): pause a running timer
  • reset(_ interval: Interval, restart: Bool): reset a running timer, change the interval and restart again if set.
  • fire(): manually fire an event of the timer from an external source

Properties:

  • .id: unique identifier of the timer
  • .mode: define the type of timer (infinite,finite,once)
  • .remainingIterations: for a .finite mode it contains the remaining number of iterations before it finishes.

Adding/Removing Observers

By default a new timer has a single observer specified by the init functions. You can, however, create additional observer by using observe() function. The result of this call is a token identifier you can use to remove the observer in a second time.
Timer instance received in callback is weak.

let token = timer.observe { _ in
  // a new observer is called		
}
timer.start()

You can remove an observer by using the token:

timer.remove(token)

Observing state change

Each timer can be in one of the following states, you can observe via .state property:

  • .paused: timer is in idle (never started yet) or paused
  • .running: timer is currently active and running
  • .executing: registered observers are being executed
  • .finished: timer lifecycle is finished (it's valid for a finite/once state timer)

You can listen for state change by assigning a function callback for .onStateChanged property.

timer.onStateChanged = { (timer,newState) in
	// your own code
}

Debouncer

Since 0.5 Repeater introduced Debouncer class.
The Debouncer will delay a function call, and every time it's getting called it will delay the preceding call until the delay time is over.

The debounce function is an extremely useful tool that can help throttle requests.
It is different to throttle though as throttle will allow only one request per time period, debounce will not fire immediately and wait the specified time period before firing the request.
If there is another request made before the end of the time period then we restart the count. This can be extremely useful for calling functions that often get called and are only needed to run once after all the changes have been made.

let debouncer = Debouncer(.seconds(10))
debouncer.callback = {
	// your code here
}

// Call debouncer to start the callback after the delayed time.
// Multiple calls will ignore the older calls and overwrite the firing time.
debouncer.call()

(Make sure to check out the Unit Tests for further code samples.)

Throttler

Since 0.5 Repeater introduced Throttler class.

Throttling wraps a block of code with throttling logic, guaranteeing that an action will never be called more than once each specified interval. Only the last dispatched code-block will be executed when delay has passed.

let throttler = Throttler(time: .milliseconds(500), {
  // your code here
})

// Call throttler. Defined block will never be called more than once each specified interval.
throttler.call()

Requirements

Repeat is compatible with Swift 4.x.
All Apple platforms are supported:

  • iOS 8.0+
  • macOS 10.10+
  • watchOS 2.0+
  • tvOS 9.0+

GitHub