#include <functional>
#include <mutex>
#include <set>#include "CCRef.h"
#include "CCVector.h"
#include "uthash.h"NS_CC_BEGIN/*** @addtogroup global* @{*/class Scheduler;typedef std::function<void(float)> ccSchedulerFunc;

class CC_DLL Timer : public Ref
{
protected:Timer();
public:/** get interval in seconds */inline float getInterval() const { return _interval; };/** set interval in seconds */inline void setInterval(float interval) { _interval = interval; };void setupTimerWithInterval(float seconds, unsigned int repeat, float delay);virtual void trigger() = 0;virtual void cancel() = 0;/** triggers the timer */void update(float dt);protected:Scheduler* _scheduler; // weak reffloat _elapsed;bool _runForever;bool _useDelay;unsigned int _timesExecuted;unsigned int _repeat; //0 = once, 1 is 2 x executedfloat _delay;float _interval;
};

Scheduler* _scheduler; // weak ref

    float _elapsed;              // 渡过的时间.bool _runForever;            // 状态变量，标记是否永远的运行。bool _useDelay;              // 状态变量，标记是否使用延迟unsigned int _timesExecuted; // 记录已经执行了多少次。unsigned int _repeat;        // 定义要执行的总次数，0为1次  1为2次 ……float _delay;                // 延迟的时间 单位应该是秒float _interval;             

// 时间间隔。

void Timer::setupTimerWithInterval(float seconds, unsigned int repeat, float delay)
{_elapsed = -1;_interval = seconds;_delay = delay;_useDelay = (_delay > 0.0f) ? true : false;_repeat = repeat;_runForever = (_repeat == kRepeatForever) ? true : false;
}

#define kRepeatForever (UINT_MAX -1)

void Timer::update(float dt)//参数dt表示距离上一次update调用的时间间隔，这也是从后面的代码中分析出来的。
{if (_elapsed == -1)// 如果 _elapsed值为-1表示这个定时器是第一次进入到update方法 作了初始化操作。{_elapsed = 0;_timesExecuted = 0;}else{if (_runForever && !_useDelay){//standard timer usage_elapsed += dt;  //累计渡过的时间。if (_elapsed >= _interval){trigger();_elapsed = 0; //触发后将_elapsed清除为0，小鱼分析这里可能会有一小点的问题，因为 _elapsed值有可能大于_interval这里没有做冗余处理，所以会吞掉一些时间，比如 1秒执行一次，而10秒内可能执行的次数小于10，吞掉多少与update调用的频率有关系。}}    else{//advanced usage_elapsed += dt;if (_useDelay){if( _elapsed >= _delay ){trigger();_elapsed = _elapsed - _delay;//延迟执行的计算，代码写的很干净_timesExecuted += 1;_useDelay = false;//延迟已经过了，清除_useDelay标记。}}else{if (_elapsed >= _interval){trigger();_elapsed = 0;_timesExecuted += 1;}}if (!_runForever && _timesExecuted > _repeat)//触发的次数已经满足了_repeat的设置就取消定时器。{    //unschedule timer
                cancel();}}}
}

class CC_DLL TimerTargetSelector : public Timer
{
public:TimerTargetSelector();/** Initializes a timer with a target, a selector and an interval in seconds, repeat in number of times to repeat, delay in seconds. */bool initWithSelector(Scheduler* scheduler, SEL_SCHEDULE selector, Ref* target, float seconds, unsigned int repeat, float delay);inline SEL_SCHEDULE getSelector() const { return _selector; };virtual void trigger() override;virtual void cancel() override;protected:Ref* _target;SEL_SCHEDULE _selector;
};

Ref* _target;

SEL_SCHEDULE _selector;

class Node;typedef void (Ref::*SEL_CallFunc)();
typedef void (Ref::*SEL_CallFuncN)(Node*);
typedef void (Ref::*SEL_CallFuncND)(Node*, void*);
typedef void (Ref::*SEL_CallFuncO)(Ref*);
typedef void (Ref::*SEL_MenuHandler)(Ref*);
typedef void (Ref::*SEL_SCHEDULE)(float);#define callfunc_selector(_SELECTOR) static_cast<cocos2d::SEL_CallFunc>(&_SELECTOR)
#define callfuncN_selector(_SELECTOR) static_cast<cocos2d::SEL_CallFuncN>(&_SELECTOR)
#define callfuncND_selector(_SELECTOR) static_cast<cocos2d::SEL_CallFuncND>(&_SELECTOR)
#define callfuncO_selector(_SELECTOR) static_cast<cocos2d::SEL_CallFuncO>(&_SELECTOR)
#define menu_selector(_SELECTOR) static_cast<cocos2d::SEL_MenuHandler>(&_SELECTOR)
#define schedule_selector(_SELECTOR) static_cast<cocos2d::SEL_SCHEDULE>(&_SELECTOR)

bool TimerTargetSelector::initWithSelector(Scheduler* scheduler, SEL_SCHEDULE selector, Ref* target, float seconds, unsigned int repeat, float delay)
{_scheduler = scheduler;_target = target;_selector = selector;setupTimerWithInterval(seconds, repeat, delay);return true;
}

void TimerTargetSelector::trigger()
{if (_target && _selector){(_target->*_selector)(_elapsed);}
}void TimerTargetSelector::cancel()
{_scheduler->unschedule(_selector, _target);
}

class CC_DLL TimerTargetCallback : public Timer
{
public:TimerTargetCallback();/** Initializes a timer with a target, a lambda and an interval in seconds, repeat in number of times to repeat, delay in seconds. */bool initWithCallback(Scheduler* scheduler, const ccSchedulerFunc& callback, void *target, const std::string& key, float seconds, unsigned int repeat, float delay);/*** @js NA* @lua NA*/inline const ccSchedulerFunc& getCallback() const { return _callback; };inline const std::string& getKey() const { return _key; };virtual void trigger() override;virtual void cancel() override;protected:void* _target;ccSchedulerFunc _callback;std::string _key;
};

void TimerTargetCallback::trigger()
{if (_callback){_callback(_elapsed);}
}void TimerTargetCallback::cancel()
{_scheduler->unschedule(_key, _target);
}

struct _listEntry;
struct _hashSelectorEntry;
struct _hashUpdateEntry;#if CC_ENABLE_SCRIPT_BINDING
class SchedulerScriptHandlerEntry;
#endif

class CC_DLL Scheduler : public Ref
{

    float _timeScale;   // 速度控制，值为1.0f为正常速度 小于1 慢放，大于1 快放。//// "updates with priority" stuff//
    struct _listEntry *_updatesNegList;        // list of priority < 0  三种优先级的list具体作用这里看不出来，下面在源码中去分析struct _listEntry *_updates0List;            // list priority == 0struct _listEntry *_updatesPosList;        // list priority > 0struct _hashUpdateEntry *_hashForUpdates; // hash used to fetch quickly the list entries for pause,delete,etc// Used for "selectors with interval"struct _hashSelectorEntry *_hashForTimers;struct _hashSelectorEntry *_currentTarget;bool _currentTargetSalvaged;// If true unschedule will not remove anything from a hash. Elements will only be marked for deletion.bool _updateHashLocked;#if CC_ENABLE_SCRIPT_BINDINGVector<SchedulerScriptHandlerEntry*> _scriptHandlerEntries;
#endif// Used for "perform Function"std::vector<std::function<void()>> _functionsToPerform;std::mutex _performMutex;

Scheduler::Scheduler(void)
: _timeScale(1.0f)
, _updatesNegList(nullptr)
, _updates0List(nullptr)
, _updatesPosList(nullptr)
, _hashForUpdates(nullptr)
, _hashForTimers(nullptr)
, _currentTarget(nullptr)
, _currentTargetSalvaged(false)
, _updateHashLocked(false)
#if CC_ENABLE_SCRIPT_BINDING
, _scriptHandlerEntries(20)
#endif
{// I don't expect to have more than 30 functions to all per frame_functionsToPerform.reserve(30);
}Scheduler::~Scheduler(void)
{unscheduleAll();
}

void Scheduler::schedule(SEL_SCHEDULE selector, Ref *target, float interval, unsigned int repeat, float delay, bool paused)
{CCASSERT(target, "Argument target must be non-nullptr");tHashTimerEntry *element = nullptr;HASH_FIND_PTR(_hashForTimers, &target, element);if (! element){element = (tHashTimerEntry *)calloc(sizeof(*element), 1);element->target = target;HASH_ADD_PTR(_hashForTimers, target, element);// Is this the 1st element ? Then set the pause level to all the selectors of this targetelement->paused = paused;}else{CCASSERT(element->paused == paused, "");}if (element->timers == nullptr){element->timers = ccArrayNew(10);}else{for (int i = 0; i < element->timers->num; ++i){TimerTargetSelector *timer = static_cast<TimerTargetSelector*>(element->timers->arr[i]);if (selector == timer->getSelector()){CCLOG("CCScheduler#scheduleSelector. Selector already scheduled. Updating interval from: %.4f to %.4f", timer->getInterval(), interval);timer->setInterval(interval);return;}}ccArrayEnsureExtraCapacity(element->timers, 1);}TimerTargetSelector *timer = new TimerTargetSelector();timer->initWithSelector(this, selector, target, interval, repeat, delay);ccArrayAppendObject(element->timers, timer);timer->release();
}

void Scheduler::schedule(const ccSchedulerFunc& callback, void *target, float interval, bool paused, const std::string& key)
{this->schedule(callback, target, interval, kRepeatForever, 0.0f, paused, key);
}

void Scheduler::schedule(const ccSchedulerFunc& callback, void *target, float interval, unsigned int repeat, float delay, bool paused, const std::string& key)
{CCASSERT(target, "Argument target must be non-nullptr");CCASSERT(!key.empty(), "key should not be empty!");tHashTimerEntry *element = nullptr;HASH_FIND_PTR(_hashForTimers, &target, element);if (! element){element = (tHashTimerEntry *)calloc(sizeof(*element), 1);element->target = target;HASH_ADD_PTR(_hashForTimers, target, element);// Is this the 1st element ? Then set the pause level to all the selectors of this targetelement->paused = paused;}else{CCASSERT(element->paused == paused, "");}if (element->timers == nullptr){element->timers = ccArrayNew(10);}else {for (int i = 0; i < element->timers->num; ++i){TimerTargetCallback *timer = static_cast<TimerTargetCallback*>(element->timers->arr[i]);if (key == timer->getKey()){CCLOG("CCScheduler#scheduleSelector. Selector already scheduled. Updating interval from: %.4f to %.4f", timer->getInterval(), interval);timer->setInterval(interval);return;}        }ccArrayEnsureExtraCapacity(element->timers, 1);}TimerTargetCallback *timer = new TimerTargetCallback();timer->initWithCallback(this, callback, target, key, interval, repeat, delay);ccArrayAppendObject(element->timers, timer);timer->release();
}

void Scheduler::unschedule(SEL_SCHEDULE selector, Ref *target)
{// explicity handle nil arguments when removing an objectif (target == nullptr || selector == nullptr){return;}//CCASSERT(target);//CCASSERT(selector);
    tHashTimerEntry *element = nullptr;HASH_FIND_PTR(_hashForTimers, &target, element);if (element){for (int i = 0; i < element->timers->num; ++i){TimerTargetSelector *timer = static_cast<TimerTargetSelector*>(element->timers->arr[i]);if (selector == timer->getSelector()){if (timer == element->currentTimer && (! element->currentTimerSalvaged)){element->currentTimer->retain();element->currentTimerSalvaged = true;}ccArrayRemoveObjectAtIndex(element->timers, i, true);// update timerIndex in case we are in tick:, looping over the actionsif (element->timerIndex >= i){element->timerIndex--;}if (element->timers->num == 0){if (_currentTarget == element){_currentTargetSalvaged = true;}else{removeHashElement(element);}}return;}}}
}

void Scheduler::update(float dt)
{_updateHashLocked = true;// 这里加了一个状态锁，应该是线程同步的作用。if (_timeScale != 1.0f){dt *= _timeScale;// 时间速率调整，根据设置的_timeScale 进行了乘法运算。}//// Selector callbacks//// 定义了两个链表遍历的指针。tListEntry *entry, *tmp;// 处理优先级小于0的定时器，这些定时器存在了_updatesNegList链表里面，具体怎么存进来的，目前我们还不知道，这里放出一个疑问2
    DL_FOREACH_SAFE(_updatesNegList, entry, tmp){if ((! entry->paused) && (! entry->markedForDeletion)){entry->callback(dt);// 对活动有效的定时器执行回调。 }}// 处理优先级为0的定时器。
    DL_FOREACH_SAFE(_updates0List, entry, tmp){if ((! entry->paused) && (! entry->markedForDeletion)){entry->callback(dt);}}// 处理优先级大于0的定时器
    DL_FOREACH_SAFE(_updatesPosList, entry, tmp){if ((! entry->paused) && (! entry->markedForDeletion)){entry->callback(dt);}}// 遍历_hashForTimers里自定义的计时器对象列表for (tHashTimerEntry *elt = _hashForTimers; elt != nullptr; ){_currentTarget = elt;// 这里通过遍历动态设置了当前_currentTarget对象。_currentTargetSalvaged = false;// 当前目标定时器没有被处理过标记。if (! _currentTarget->paused){// 遍历每一个对象的定时器列表 for (elt->timerIndex = 0; elt->timerIndex < elt->timers->num; ++(elt->timerIndex)){elt->currentTimer = (Timer*)(elt->timers->arr[elt->timerIndex]);// 这里更新了对象的currentTimerelt->currentTimerSalvaged = false;elt->currentTimer->update(dt);// 执行定时器过程。if (elt->currentTimerSalvaged){// The currentTimer told the remove itself. To prevent the timer from// accidentally deallocating itself before finishing its step, we retained// it. Now that step is done, it's safe to release it.

                   // currentTimerSalvaged的作用是标记当前这个定时器是否已经失效，在设置失效的时候我们对定时器增加过一次引用记数，这里调用release来减少那次引用记数，这样释放很安全，这里用到了这个小技巧，延迟释放，这样后面的程序不会出现非法引用定时器指针而出现错误elt->currentTimer->release();}
                // currentTimer指针使用完了，设置成空指针elt->currentTimer = nullptr;}}// elt, at this moment, is still valid// so it is safe to ask this here (issue #490)

        // 因为下面有可能要清除这个对象currentTarget为了循环进行下去，这里先在currentTarget对象还存活的状态下找到链表的下一个指针。elt = (tHashTimerEntry *)elt->hh.next;// only delete currentTarget if no actions were scheduled during the cycle (issue #481)

        // 如果_currentTartetSalvaged 为 true 且这个对象里面的定时器列表为空那么这个对象就没有计时任务了我们要把它从__hashForTimers列表里面删除。if (_currentTargetSalvaged && _currentTarget->timers->num == 0){removeHashElement(_currentTarget);}}// 下面这三个循环也是清理工作// updates with priority < 0
    DL_FOREACH_SAFE(_updatesNegList, entry, tmp){if (entry->markedForDeletion){this->removeUpdateFromHash(entry);}}// updates with priority == 0
    DL_FOREACH_SAFE(_updates0List, entry, tmp){if (entry->markedForDeletion){this->removeUpdateFromHash(entry);}}// updates with priority > 0
    DL_FOREACH_SAFE(_updatesPosList, entry, tmp){if (entry->markedForDeletion){this->removeUpdateFromHash(entry);}}_updateHashLocked = false;_currentTarget = nullptr;#if CC_ENABLE_SCRIPT_BINDING//// Script callbacks//// Iterate over all the script callbacksif (!_scriptHandlerEntries.empty()){for (auto i = _scriptHandlerEntries.size() - 1; i >= 0; i--){SchedulerScriptHandlerEntry* eachEntry = _scriptHandlerEntries.at(i);if (eachEntry->isMarkedForDeletion()){_scriptHandlerEntries.erase(i);}else if (!eachEntry->isPaused()){eachEntry->getTimer()->update(dt);}}}
#endif//// 上面都是对象的定时任务, 这里是多线程处理函数的定时任务。//// Testing size is faster than locking / unlocking.// And almost never there will be functions scheduled to be called. 这块作者已经说明了，函数的定时任务不常用。我们简单了解一下就可了。if( !_functionsToPerform.empty() ) {_performMutex.lock();// fixed #4123: Save the callback functions, they must be invoked after '_performMutex.unlock()', otherwise if new functions are added in callback, it will cause thread deadlock.auto temp = _functionsToPerform;_functionsToPerform.clear();_performMutex.unlock();for( const auto &function : temp ) {function();}}
}

 /** 根据key与target 指针来判断是否这个对象的这个key的定时器在Scheduled里面控制。*/bool isScheduled(const std::string& key, void *target);/** 同上，只不过判断条件不一样。.@since v3.0*/bool isScheduled(SEL_SCHEDULE selector, Ref *target);//** 暂停一个对象的所有定时器     */void pauseTarget(void *target);/**    恢复一个对象的所有定时器  */void resumeTarget(void *target);/** 询问一个对象的定时器是不是暂停状态    */bool isTargetPaused(void *target);/** 暂停所有对象的定时器      */std::set<void*> pauseAllTargets();/** 根据权重值来暂停所有对象的定时器      */std::set<void*> pauseAllTargetsWithMinPriority(int minPriority);/** 恢复描写对象的定时器暂停状态。      */void resumeTargets(const std::set<void*>& targetsToResume);/** 将一个函数定时器加入到调度管理器里面。 这也是update函数中最后处理的那个函数列表里的函数 任务增加的接口。 */void performFunctionInCocosThread( const std::function<void()> &function);

_scheduler = director->getScheduler();_scheduler->retain();

void Node::schedule(SEL_SCHEDULE selector)
{this->schedule(selector, 0.0f, kRepeatForever, 0.0f);
}void Node::schedule(SEL_SCHEDULE selector, float interval)
{this->schedule(selector, interval, kRepeatForever, 0.0f);
}void Node::schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay)
{CCASSERT( selector, "Argument must be non-nil");CCASSERT( interval >=0, "Argument must be positive");_scheduler->schedule(selector, this, interval , repeat, delay, !_running);
}void Node::scheduleOnce(SEL_SCHEDULE selector, float delay)
{this->schedule(selector, 0.0f, 0, delay);
}void Node::unschedule(SEL_SCHEDULE selector)
{// explicit null handlingif (selector == nullptr)return;_scheduler->unschedule(selector, this);
}void Node::unscheduleAllSelectors()
{_scheduler->unscheduleAllForTarget(this);
}

/*** Schedules the "update" method.** It will use the order number 0. This method will be called every frame.* Scheduled methods with a lower order value will be called before the ones that have a higher order value.* Only one "update" method could be scheduled per node.* @js NA* @lua NA*/void scheduleUpdate(void);/*** Schedules the "update" method with a custom priority.** This selector will be called every frame.* Scheduled methods with a lower priority will be called before the ones that have a higher value.* Only one "update" selector could be scheduled per node (You can't have 2 'update' selectors).* @js NA* @lua NA*/void scheduleUpdateWithPriority(int priority);

/** Update method will be called automatically every frame if "scheduleUpdate" is called, and the node is "live"*/virtual void update(float delta);

void Node::scheduleUpdate()
{scheduleUpdateWithPriority(0);
}void Node::scheduleUpdateWithPriority(int priority)
{_scheduler->scheduleUpdate(this, priority, !_running);
}

template <class T>void scheduleUpdate(T *target, int priority, bool paused){this->schedulePerFrame([target](float dt){target->update(dt);}, target, priority, paused);}

void Scheduler::schedulePerFrame(const ccSchedulerFunc& callback, void *target, int priority, bool paused)
{tHashUpdateEntry *hashElement = nullptr;HASH_FIND_PTR(_hashForUpdates, &target, hashElement);if (hashElement){
#if COCOS2D_DEBUG >= 1CCASSERT(hashElement->entry->markedForDeletion,"");
#endif// TODO: check if priority has changed!
hashElement->entry->markedForDeletion = false;return;}// most of the updates are going to be 0, that's way there// is an special list for updates with priority 0if (priority == 0){appendIn(&_updates0List, callback, target, paused);}else if (priority < 0){priorityIn(&_updatesNegList, callback, target, priority, paused);}else{// priority > 0priorityIn(&_updatesPosList, callback, target, priority, paused);}
}