Early on in developing Central apps, I found that I needed something to manage all my Intervals in an application. It was important to have a central place that I could identify, create, and clear intervals, so I developed a singleton manager (IntervalManager) to handle this. In addition, I overloaded the setInterval method, so that one could create delayed calls like setTimeout in javascript, or create an interval that ran N number of times. I managed this by adding a prefixed param N to the setInterval method, which if used tells the interval to run N times, and if not defaults to normal setInterval behavior. Below is the class with usage definitions.

/**
******************************************

@class (SINGLETON): IntervalManager Class
@author: Kenny Bunch

PUBLIC METHODS
setInterval
clearInterval
clearAllIntervals

@usage:
// setting intervals
var id1:Number = IntervalManager.setInterval(2, myFunction, 100, "myArg");
var id2:Number = IntervalManager.setInterval(2, _root, "myFunction", 100, "myArg");
var id3:Number = IntervalManager.setInterval(myFunction, 100, "myArg");
var id4:Number = IntervalManager.setInterval(_root, "myFunction", 100, "myArg");

// clearing intervals
IntervalManager.clearInterval(id1);
IntervalManager.clearAllIntervals();

******************************************
*/

class com.kennybunch.utils.IntervalManager {

        private static var  __intervals:Object = {};

        /**
        @constructor (PRIVATE): IntervalManager
        @comments : can not be instantiated
        */
        private function IntervalManager(Void){}

        /**
        @method (PRIVATE STATIC): createInterval
        @returns : Integer
        */
        private static function createInterval():Number{

                var id:Number = _global.setInterval.apply(_global.setInterval, arguments);

                __intervals[id] = id;

                return id;
        }

        /**
        @method (PUBLIC STATIC): setInterval
        @returns : Integer
        */
        public static function setInterval(iCt, a, b, c, args):Number{

                var func:Function;
                var args:Array;
                var id;

                // for a basic function call:
                if (typeof iCt == "number"){

                        if (typeof arguments[1] == "function"){
                                args = arguments.slice(3);
                                func = function(){
                                        a.apply(null, args);
                                        iCt--;
                                        if (iCt == 0){
                                                clearInterval(id);
                                        }
                                }
                                id = createInterval(func, b, args);
                                // for an object method call:
                        } else{
                                args = arguments.slice(4);
                                func = function(){
                                        a[b].apply(a, args);
                                        iCt--;

                                        if (iCt == 0){
                                                clearInterval(id);
                                        }
                                }

                                id =  createInterval(func, c, args);
                        }
                } else {
                        id = createInterval.apply(IntervalManager, arguments);
                }

                return id;
        }

        /**
        @method (PUBLIC STATIC): clearInterval
        @param (Integer): iId
        @return: Void
        */
        public static function clearInterval(iId:Number):Void{

                _global.clearInterval(iId);
                delete(__intervals[iId]);
        }

        /**
        @method (PUBLIC STATIC): clearAllIntervals
        @return: Void
        */
        public static function clearAllIntervals(Void):Void{

                var each;

                for (each in __intervals){
                        clearInterval(each);
                }
        }
}