One of the new features included with ActionScript 3.0 is the Timer class. The new Timer class is essentially an encapsulated setInterval command with an intuitive stopwatch-like interface. Creating a new Timer object requires two parameters: delay and repeat count. Once instantiated, you assign one or more listeners to the Timer which listen for events. After assigning listeners, you use the Timer object by calling it’s start(), reset() and stop() methods.

My first thought when I saw the Timer class was “Sweet, I wish this was available in AS2.” Well, it didn’t take long for me to start thinking about how I could recreate this class in AS2. A short while later I had something similiar.

com.jor.utils.Timer

/**
 * An AS2 implementation of the AS3 Timer class.
 * See http://livedocs.macromedia.com/labs/as3preview/langref/flash/utils/Timer.html
 */
import mx.events.EventDispatcher;
import com.jor.events.TimerEvent;

class com.jor.utils.Timer
{
  // Event dispatcher required functions
  private static var mixit = mx.events.EventDispatcher.initialize(com.jor.utils.Timer.prototype);
  function dispatchEvent() {};
  function addEventListener() {};
  function removeEventListener() {};
  /**
   * The total number of times the timer has fired since it
   * started at zero. If the timer has been reset, only the
   * fires since the reset are counted.
   */
  private var _currentCount:Number;
  public function get currentCount ():Number {
    return _currentCount;
  }
  /**
   * The delay, in milliseconds, between timer events. If you
   * set the delay interval while the timer is running, the
   * timer will restart at the same repeatCount iteration.
   */
  private var _delay:Number;
  public function get delay ():Number {
    return _delay;
  }
  public function set delay (d:Number):Void {
    _delay = (isNaN(d))?0:d;
  }
  /**
   * The total number of times the timer is set to run. If the
   * repeat count is set to 0, the timer continues forever or
   * until the stop() method is invoked or the program stops.
   * If the repeat count is nonzero, the timer runs the specified
   * number of times. If repeatCount is set to a total that is
   * the same or less then currentCount  the timer stops and
   * will not fire again.
   */
  private var _repeatCount:Number;
  public function get repeatCount ():Number {
    return _repeatCount;
  }
  public function set repeatCount (c:Number):Void {
    if (isFinite(c) && c>=0) {
      _repeatCount = c;
    } else {
      throw new Error ("repeatCount must be either zero or a positive finite number");
    }
  }
  // The timer’s current state; true if the timer is running, otherwise false.
  private var _running:Boolean;
  public function get running():Boolean {
    return _running;
  }
  // The timer’s setInterval ID holder
  private var _intervalID:Number;
  /**
   * Constructs a new Timer object with the specified delay
   * and repeatCount states.
   * <P>The timer does not start automatically; you must
   * call the start() method to start it.</P>
   * @param   delay         The delay between timer events, in milliseconds.
   * @param   repeatCount   Specifies the number of repetitions. If zero,
   *                        the timer repeats infinitely. If nonzero, the
   *                        timer runs the specified number of times and then stops.
   * @throws                Error — if the delay specified is negative or not
   *                        a finite number
   */
  public function Timer (delay:Number, repeatCount:Number)
  {
    this.delay = delay;
    this.repeatCount = repeatCount;
    _currentCount = 0;
  }
  /**
   * Stops the timer, if it is running, and sets the currentCount
   * property back to 0, like the reset button of a stopwatch.
   * Then, when start() is called, the timer instance runs for the
   * specified number of repetitions, as set by the repeatCount value.
   */
  public function reset ():Void
  {
    stop();
    _currentCount = 0;
  }
  /**
   * Starts the timer, if it is not already running.
   */
  public function start ():Void
  {
    if (!_running) {
      clearInterval(_intervalID);
      _intervalID = setInterval(this, "onTimer", _delay);
      _running = true;
    }
  }
  /**
   * Stops the timer. When start() is called after stop(), the timer
   * instance runs for the remaining number of repetitions, as set
   * by the repeatCount property.
   */
  public function stop ():Void
  {
    clearInterval(_intervalID);
    _running = false;
  }
  /**
   * Called on every interation of the setInterval call and
   * dispatches timer and timerComplete events.  When the timer
   * has executed the expected number of repitions, the timer
   * is stopped
   */
  private function onTimer ():Void
  {
    _currentCount++;
    dispatchEvent(new TimerEvent(this, TimerEvent.TIMER));
    if (_repeatCount != 0) {
      if (_currentCount == _repeatCount) {
        this.stop();
        dispatchEvent(new TimerEvent(this, TimerEvent.TIMER_COMPLETE));
      }
    }
  }
  /**
   * Trace friendly output
   */
  public function toString ():String
  {
    return "[Timer " +
        "current=" + _currentCount + " " +
        "repeat=" + _repeatCount + " " +
        "delay=" + _delay + "]";
  }
}
/**
 * com.jor.utils.Timer
 * An AS2 implementation of the AS3 Timer class.
 *
 * Author: James O’Reilly - JOR
 *   www.jamesor.com
 *
 * This work is licensed under the Creative Commons attribution 2.5
 * This comment block must remain intact.
 */

com.jor.events.TimerEvent

/**
 * A simple TimerEvent Object used for dispatching by the Timer Object
 */
class com.jor.events.TimerEvent
{
  public static var TIMER:String = "timer";
  public static var TIMER_COMPLETE:String = "timerComplete";
  // Target Object dispatching the TimerEvent
  private var _target:Object;
  public function get target ():Object {
    return _target;
  }
  // Type of TimerEvent being dispatched
  private var _type:String;
  public function get type ():String {
    return _type;
  }
  /**
   * Constructor
   * @param   target   Target Object dispatching the TimerEvent
   * @param   type     Type of TimerEvent being dispatched
   */
  public function TimerEvent (target:Object, type:String)
  {
    _target = target;
    _type = type;
  }
  /**
   * Trace friendly output
   */
  public function toString ():String
  {
    return "[TimerEvent target=" + _target + " type=" + _type + "]";
  }
}
/**
 * com.jor.events.TimerEvent
 *
 * Author: James O’Reilly - JOR
 *   www.jamesor.com
 *
 * This work is licensed under the Creative Commons attribution 2.5
 * This comment block must remain intact.
 */

Testing the Timer class:

import mx.utils.Delegate;
import com.jor.utils.Timer;
import com.jor.events.TimerEvent;

var myTimer:Timer = new Timer(1000, 3);
myTimer.addEventListener(TimerEvent.TIMER, Delegate.create(this, timerHandler));
myTimer.addEventListener(TimerEvent.TIMER_COMPLETE, Delegate.create(this, timerHandler));
myTimer.start();

function timerHandler(event:TimerEvent):Void {
  trace("timerHandler: " + event);
}

This entry was posted on Wednesday, October 18th, 2006 at 12:52 pm and is filed under ActionScript, Flash. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.