function interval(fn, delay, count, invokeApply) {
      var setInterval = $window.setInterval,
          clearInterval = $window.clearInterval,
          deferred = $q.defer(),
          promise = deferred.promise,
          iteration = 0,
          skipApply = (isDefined(invokeApply) && !invokeApply);
      
      count = isDefined(count) ? count : 0,

      promise.then(null, null, fn);

      promise.$$intervalId = setInterval(function tick() {
        deferred.notify(iteration++);

        if (count > 0 && iteration >= count) {
          deferred.resolve(iteration);
          clearInterval(promise.$$intervalId);
          delete intervals[promise.$$intervalId];
        }

        if (!skipApply) $rootScope.$apply();

      }, delay);

      intervals[promise.$$intervalId] = deferred;

      return promise;
    }
@ngdoc function
@name ng.$interval

@description
Angular's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
milliseconds.

The return value of registering an interval function is a promise. This promise will be
notified upon each tick of the interval, and will be resolved after `count` iterations, or
run indefinitely if `count` is not defined. The value of the notification will be the
number of iterations that have run.
To cancel an interval, call `$interval.cancel(promise)`.

In tests you can use {@link ngMock.$interval#methods_flush `$interval.flush(millis)`} to
move forward by `millis` milliseconds and trigger any functions scheduled to run in that
time.

@param {function()} fn A function that should be called repeatedly.
@param {number} delay Number of milliseconds between each function call.
@param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
  indefinitely.
@param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
  will invoke `fn` within the {@link ng.$rootScope.Scope#methods_$apply $apply} block.
@returns {promise} A promise which will be notified on each iteration.