Timing service

Every once in a while, I find myself in need of a timing mechanism. Something that will handle timing and scheduling, and allow me to hook with a custom functionality every interval.

Some uses can be, for example, a clock counting down or simply showing the time passing by, polling the server back-end for new data, etc. Basically, anything that needs to happen every given interval.

Sure, you could implement a timer of sorts where applicable or even angular’s own $interval, but that would be terrible code duplication not to mention a maintenance overhead.

So, I came up with a different approach.
I decided to implement a timing service to centralize this timing mechanism.

Other entities will register to it and provide a handler function and an interval and the timing service will handle the interval granularity and be in-charge of calling the handler function when the interval is up.

Typically, registrants would be other services, but since AngularJS relies on composition via injection it could just as easily be a directive or a controller.

So, first thing this service will need is somewhere to store the registrants configuration – the registrants map.
It will also need to know it’s own interval – internalInterval.

 

I set the interval hard-coded to 1 second but it could easily be set from a configuration file or something, as well as be any value that makes sense in your application.

Note – if you go below 1 second, though, be sure to pick a value that rounds to a complete second every few intervals to allow registrants the option to have a complete second interval (i.e. 250ms interval will reach 1 second every 4 intervals, as opposed to 400ms which will miss the 1 second interval).

Next step – providing registrants the means to register and unregister:

 

So, registrants will use the register method to register by providing:

• id – a unique identifier. A good candidate is the registrant name (service, directive or controller name is unique).
• tickHandler – a callback Function reference that contains the registrant’s logic to be executed each interval
• interval – the interval (in ms)
• delay – how much time (in ms) should pass before the first launch. Obviously, passing 0 will cause it to tick on next internalInterval cycle.

Respectfully, registrants will use the unregister method to unregister. It is enough to provide the id when unregistering.

Next, we need the logic for the tick:

 

So every tick we go over all the registrants and for each, we call it’s tick callback handler if it’s delay is <= 0.

Now, all this is great, but it’s not enough. All we have implemented up until now is just the API for registrants to use.
We still need to make the service run every internalInterval.

So here is the final step:

 

So, we added the $interval service as dependency and then added an internal start method that is called only once just before the service is returned. It simply fires up the $interval to tick every internalInterval and execute the tick method. Since $interval will only tick on next interval, we call the tick method synthetically once.

This service can be treated as a Timing service or it can be extended to behave as a Scheduler or even a Task Manager, if you add support for the number of times the task (registrant) should run in total or at a specific date/time.

The complete code can be found on Github.
Feel free to use and abuse 🙂
If you modify jsBlackBelt code, please let me know or submit a pull request for the benefit of others.