Timer是时钟管理类，在Laya初始化的时候会创建一个实例，通过Laya.timer访问。
TimerHandler
- TimerHandler是对每一个定时任务的封装，每次调用frameOnce、frameLoop、once、loop或者callLayer都会产生一个TimerHandler实例。
- TimerHandler会缓存传入的参数（args)，当定时器触发时，会将对应的args传递给对应回调。
public var key:int; //唯一key，用于快速找到对应handler
public var repeat:Boolean; //是否是重复调用 分别对应 once/loop
public var delay:int; //延时
public var userFrame:Boolean; // true表示使用帧计时 false表示使用时间计时
public var exeTime:int; //下次执行的时间
public var caller:* //调用者
public var method:Function; //调用方法
public var args:Array; //触发时的参数
public var jumpFrame:Boolean; //时钟是否跳帧。基于时间的循环回调，单位时间间隔内，如能执行多次回调，出于性能考虑，引擎默认只执行一次，设置jumpFrame=true后，则回调会连续执行多次
public function clear():void {
caller = null;
method = null;
args = null;
}
public function run(withClear:Boolean):void {
var caller:* = this.caller;
/*[IF-FLASH]*/
if ((caller is Node) && caller.destroyed)
/*[IF-FLASH]*/
return clear();
//[IF-SCRIPT] if (caller && caller.destroyed) return clear();
var method:Function = this.method;
var args:Array = this.args;
withClear && clear();
if (method == null) return;
args ? method.apply(caller, args) : method.call(caller);
}
Timer数据类型定义
/**@private */
private static var _pool:Array = []; //TimerHandler池
/*[DISABLE-ADD-VARIABLE-DEFAULT-VALUE]*/
/** 两帧之间的时间间隔,单位毫秒。*/
private var _delta:int = 0;
/** 时针缩放。*/
public var scale:Number = 1;
/** 当前帧开始的时间。*/
public var currTimer:Number = _now();
/** 当前的帧数。*/
public var currFrame:int = 0;
/**@private */
private var _lastTimer:Number = _now(); //上一帧的时间
/**@private */
private var _mid:int = 1; //用于生成唯一key
/**@private */
/*[IF-FLASH]*/ //TimerHandler的map 用于查找Handler(包括Later的handler)
private var _map:flash.utils.Dictionary = new flash.utils.Dictionary(true);
//[IF-JS] private var _map:Array = [];
/**@private */
private var _laters:Array = []; //存放callLater创建的handler
/**@private */
private var _handlers:Array = []; //存放非callLater创建的handler，包括frameOnce、frameLoop、once、loop
/**@private */
private var _temp:Array = []; //临时数组，用于清理
/**@private */
private var _count:int = 0; //记录handler.method为空的数量，检测是否清理
初始化
/**@private */
protected function _init():void {
Laya.timer && Laya.timer.frameLoop(1, this, _update);
}
除了Laya.timer之外，其他的timer的实例都是注册到Laya.timer的frameLoop中。
_create方法
- 创建对应的TimerHandler。
- 如果coverBefore并且已经注册过相同Handler，则覆盖之前的handler
- 设置对应参数，并计算下一次执行的时间。
- 为Handler创建唯一key，添加到_map中，用于快速查找。
- 将handler放到_handler数组中，用于_update时遍历。
frameOnce、frameLoop、once、loop实现上都是调用_create方法，传入对应的参数，将handler注册到timer中，等待_update执行相关计算。
/** @private */
public function _create(useFrame:Boolean, repeat:Boolean, delay:int, caller:*, method:Function, args:Array, coverBefore:Boolean):TimerHandler {
//如果延迟为0，则立即执行
if (!delay) {
method.apply(caller, args);
return null;
}
//先覆盖相同函数的计时
if (coverBefore) {
var handler:TimerHandler = _getHandler(caller, method);
if (handler) {
handler.repeat = repeat;
handler.userFrame = useFrame;
handler.delay = delay;
handler.caller = caller;
handler.method = method;
handler.args = args;
handler.exeTime = delay + (useFrame ? this.currFrame : this.currTimer + _now() - _lastTimer);
return handler;
}
}
//找到一个空闲的timerHandler
handler = _pool.length > 0 ? _pool.pop() : new TimerHandler();
handler.repeat = repeat;
handler.userFrame = useFrame;
handler.delay = delay;
handler.caller = caller;
handler.method = method;
handler.args = args;
handler.exeTime = delay + (useFrame ? this.currFrame : this.currTimer + _now() - _lastTimer) + 1;
//索引handler
_indexHandler(handler);
//插入数组
_handlers.push(handler);
return handler;
}
callLater
- callLater使用延时执行，再Timer.update执行末尾调用。
- 如果对应的caller和method已经注册过，则不会重复注册。
- 创建的TimerHandler会放到_laters数组中。
_update
- 计算当前帧和当前时间。
- 计算delta。
- 遍历handler数组，检查时间/帧是否超过了handler的exeTime。
- 超过时间handler执行回调，如果是once则将handler的caller和method设置为空；如果是loop则执行回调，并计算下次执行的时间。如果下次调用的时间间隔内，可以触发多次回调，默认情况下执行执行一次回调。如果设置为jumpFrame则会调用多次回调（如delay为1毫秒，delta为30毫秒，则下个update时，会调用30次回调）。
- 遍历数组时，会记录method为空的handler的数量，当数量为30或者200帧时，会清理一次没用的handler，将没用的handler回收到池中。
- 执行完所有handler之后，遍历所有laters数组，执行callLater所注册的回调。执行完成后，清理所有laters数组。
/**
* @private
* 帧循环处理函数。
*/
public function _update():void {
if (scale <= 0) {
_lastTimer =_now();
return;
}
var frame:int = this.currFrame = this.currFrame + scale;
var now:Number = _now();
_delta = (now - _lastTimer) * scale;
var timer:Number = this.currTimer = this.currTimer + _delta;
_lastTimer = now;
//处理handler
var handlers:Array = this._handlers;
_count = 0;
for (i = 0, n = handlers.length; i < n; i++) {
handler = handlers[i];
if (handler.method !== null) {
var t:int = handler.userFrame ? frame : timer;
if (t >= handler.exeTime) {
if (handler.repeat) {
if (!handler.jumpFrame) {
handler.exeTime += handler.delay;
handler.run(false);
if (t > handler.exeTime) {
//如果执行一次后还能再执行，做跳出处理，如果想用多次执行，需要设置jumpFrame=true
handler.exeTime += Math.ceil((t - handler.exeTime) / handler.delay) * handler.delay;
}
} else {
while (t >= handler.exeTime) {
handler.exeTime += handler.delay;
handler.run(false);
}
}
} else {
handler.run(true);
}
}
} else {
_count++;
}
}
if (_count > 30 || frame % 200 === 0) _clearHandlers();
//处理callLater
var laters:Array = this._laters;
for (var i:int = 0, n:int = laters.length - 1; i <= n; i++) {
var handler:TimerHandler = laters[i];
if (handler.method !== null) {
/*[IF-FLASH]*/
_map[handler.method] = null;
//[IF-SCRIPT]_map[handler.key] = null;
handler.run(false);
}
_recoverHandler(handler);
i === n && (n = laters.length - 1);
}
laters.length = 0;
}
其他
Laya.timer._update是在Laya.stage.loop中调用，Laya.stage.loop是在Render中调用。
在Frash中，监听enterFrame事件。
在js中则是注册requestAnimationFrame，来进入渲染帧。
当stage不可见时（如切到后台），则timer._update每一秒触发一次。一秒钟一帧，当切回前台后，帧率恢复正常。
update是在渲染之前执行。
Laya.stage控制实际帧率，根据Laya.stage.frameRate。