Cocos2d-x 3.x事件机制源码分析
整个事件机制，由以下几个部分构成：
事件 ： 描述事件。
监听器 ： 描述事件接收者与事件的“兴趣关系”。
分发器 ： 针对所产生的事件，将事件分发给符合事件类型的事件接收者。
整个事件机制采用观察者模式，GL视图负责感应事件的产生，并包装事件，然后主动调用分发器的dispatchEvent函数用于分发。GL视图是观察者，图层或者说场景是被观察者。GL视图观察到事件，然后通过事件分发器通知被观察者。监听器，这么称呼有点名不副实，它并不是用于监听事件，而是作为一个桥梁为事件接收者（场景、图层、精灵等等）和事件分发者之间建立联系，当一个图层（或者精灵）关联到某一类型的监听器，则表明该图层（或精灵）对此类事件感兴趣，而监听器则是描述了图层（或精灵）与事件之间的这种“兴趣关系”，将监听器添加到分发器中，就是将这种“兴趣关系”告诉分发器，以便分发器能更好更合理的分发事件。
1、事件
事件，定义了事件的类型，如触摸、鼠标、键盘等等事件类型。每个事件类型都继承自Event。Event类封装了事件的一些共有属性。
class CC_DLL Event : public Ref
{
public:
//事件的类型主要有：触摸、键盘、加速计、鼠标、游戏手柄
enum class Type
{
TOUCH,
KEYBOARD,
ACCELERATION,
MOUSE,
FOCUS,
GAME_CONTROLLER,
CUSTOM
};
CC_CONSTRUCTOR_ACCESS:
Event(Type type);
public:
virtual ~Event();
inline Type getType() const { return _type; };
//停止事件的传播
inline void stopPropagation() { _isStopped = true; };
//检测当前事件是否停止了传播
inline bool isStopped() const { return _isStopped; };
//获得触发当前事件的对象
inline Node* getCurrentTarget() { return _currentTarget; };
protected:
inline void setCurrentTarget(Node* target) { _currentTarget = target; };
Type _type; ///< Event type
bool _isStopped; ///< whether the event has been stopped.
Node* _currentTarget; ///< Current target
//EventDispatcher为友元类，EventDispatcher可以使用Event的方法
friend class EventDispatcher;
};以下以触摸事件为例：
触摸事件
Touch类封装了所产生的触摸事件的信息，触摸事件通过_id来区别。EventTouch管理触摸事件，封装了触摸事件的属性。
class CC_DLL EventTouch : public Event
{
public:
static const int MAX_TOUCHES = 15;
/** EventCode Touch event code.*/
//触摸过程：开始、移动、末尾、不触摸
enum class EventCode
{
BEGAN,
MOVED,
ENDED,
CANCELLED
};
EventTouch();
inline EventCode getEventCode() const { return _eventCode; };
inline const std::vector<Touch*>& getTouches() const { return _touches; };
#if TOUCH_PERF_DEBUG
void setEventCode(EventCode eventCode) { _eventCode = eventCode; };
void setTouches(const std::vector<Touch*>& touches) { _touches = touches; };
#endif
private:
EventCode _eventCode;
//Touch类封装了 触摸事件的一些信息：触摸点、增量等等信息
std::vector<Touch*> _touches;
//GLView为友元类，GLView可以使用EventTouch的方法
friend class GLView;
};
class CC_DLL Touch : public Ref
{
public:
enum class DispatchMode {
ALL_AT_ONCE, /** All at once. */
ONE_BY_ONE, /** One by one. */
};
Touch()
: _id(0),
_startPointCaptured(false)
{}
//获得当前触摸点的坐标
Vec2 getLocation() const;
//获得前一个触摸点的坐标
Vec2 getPreviousLocation() const;
//获得开始触摸时的坐标
Vec2 getStartLocation() const;
//获得前后两个触摸点之间增量
Vec2 getDelta() const;
Vec2 getLocationInView() const;
Vec2 getPreviousLocationInView() const;
Vec2 getStartLocationInView() const;
//设置触摸点信息
void setTouchInfo(int id, float x, float y)
{
_id = id;
_prevPoint = _point;
_point.x = x;
_point.y = y;
if (!_startPointCaptured)
{
_startPoint = _point;
_startPointCaptured = true;
_prevPoint = _point;
}
}
int getID() const
{
return _id;
}
private:
int _id;
bool _startPointCaptured;
Vec2 _startPoint;
Vec2 _point;
Vec2 _prevPoint;
};2、事件监听器
由于事件分为多种，有触摸事件、鼠标事件等等。因此，cocos2d中也定义了多种事件监听器。但是所有的事件监听器都派生自EventListener。监听器负责为事件接收者 与 事件分发者 之间建立联系。
class CC_DLL EventListener : public Ref
{
public:
/** Type Event type.*/
enum class Type
{
UNKNOWN,
TOUCH_ONE_BY_ONE,
TOUCH_ALL_AT_ONCE,
KEYBOARD,
MOUSE,
ACCELERATION,
FOCUS,
GAME_CONTROLLER,
CUSTOM
};
typedef std::string ListenerID;
CC_CONSTRUCTOR_ACCESS:
EventListener();
bool init(Type t, const ListenerID& listenerID, const std::function<void(Event*)>& callback);
public:
virtual ~EventListener();
virtual bool checkAvailable() = 0;
virtual EventListener* clone() = 0;
//设置本监听器是否接受事件：true,接收；false，不接受
inline void setEnabled(bool enabled) { _isEnabled = enabled; };
inline bool isEnabled() const { return _isEnabled; };
protected:
inline void setPaused(bool paused) { _paused = paused; };
inline bool isPaused() const { return _paused; };
inline void setRegistered(bool registered) { _isRegistered = registered; };
//判断本监听器是否注册到分发器中
inline bool isRegistered() const { return _isRegistered; };
//获得当前事件类型
inline Type getType() const { return _type; };
inline const ListenerID& getListenerID() const { return _listenerID; };
inline void setFixedPriority(int fixedPriority) { _fixedPriority = fixedPriority; };
inline int getFixedPriority() const { return _fixedPriority; };
//获得被本监听器 所 监听的所有对象
inline Node* getAssociatedNode() const { return _node; };
std::function<void(Event*)> _onEvent; /// Event callback function
Type _type; /// Event listener type
ListenerID _listenerID; /// Event listener ID
bool _isRegistered; /// Whether the listener has been added to dispatcher.
int _fixedPriority; // The higher the number, the higher the priority, 0 is for scene graph base priority.
Node* _node; // scene graph based priority
bool _paused; // Whether the listener is paused
bool _isEnabled; // Whether the listener is enabled
friend class EventDispatcher;
};触摸事件监听器
单点触摸事件监听器。
class CC_DLL EventListenerTouchOneByOne : public EventListener
{
public:
static const std::string LISTENER_ID;
/** Create a one by one touch event listener. */
static EventListenerTouchOneByOne* create();
/** * Destructor. * @js NA */
virtual ~EventListenerTouchOneByOne();
/** Whether or not to swall touches. * * @param needSwallow True if needs to swall touches. */
//设置是否向下传递触摸，若设置为true，则不向下传递触摸
void setSwallowTouches(bool needSwallow);
/** Is swall touches or not. * * @return True if needs to swall touches. */
bool isSwallowTouches();
/// Overrides
virtual EventListenerTouchOneByOne* clone() override;
virtual bool checkAvailable() override;
public:
typedef std::function<bool(Touch*, Event*)> ccTouchBeganCallback;
typedef std::function<void(Touch*, Event*)> ccTouchCallback;
ccTouchBeganCallback onTouchBegan;
ccTouchCallback onTouchMoved;
ccTouchCallback onTouchEnded;
ccTouchCallback onTouchCancelled;
CC_CONSTRUCTOR_ACCESS:
EventListenerTouchOneByOne();
bool init();
private:
std::vector<Touch*> _claimedTouches;
bool _needSwallow;
friend class EventDispatcher;
};3、事件分发器
- 事件分发器维护了一个队列，这个队列是各种监听器的集合：
- 这个类管理事件监听器的订阅和事件的分发
- 事件监听器列表以这样的方式来进行管理：当事件正在分发的过程中，事件监听器可以被添加或者移除，包括事件监听器内部的监听器
以下这段代码
{
public:
// Adds event listener.
/** Adds a event listener for a specified event with the priority of scene graph.
* @param listener The listener of a specified event.
* @param node The priority of the listener is based on the draw order of this node.
* @note The priority of scene graph will be fixed value 0. So the order of listener item
* in the vector will be ' <0, scene graph (0 priority), >0'.
*/
//为一个特定的事件添加一个事件监听器，该监听器的优先级是基于Node节点的绘图顺序。
void addEventListenerWithSceneGraphPriority(EventListener* listener, Node* node);
//监听器的优先级由fixedPriority给出
void addEventListenerWithFixedPriority(EventListener* listener, int fixedPriority);
EventListenerCustom* addCustomEventListener(const std::string &eventName, const std::function<void(EventCustom*)>& callback);
// 移除 某个事件监听器
void removeEventListener(EventListener* listener);
//移除 特定类型的所有事件监听器
void removeEventListenersForType(EventListener::Type listenerType);
/** Removes all listeners which are associated with the specified target. * * @param target A given target node. * @param recursive True if remove recursively, the default value is false. */
//移除 与target关联的所有事件监听器
void removeEventListenersForTarget(Node* target, bool recursive = false);
/** Removes all custom listeners with the same event name. * * @param customEventName A given event listener name which needs to be removed. */
void removeCustomEventListeners(const std::string& customEventName);
/** Removes all listeners. */
//移除所有的事件监听器
void removeAllEventListeners();
/////////////////////////////////////////////
// Pauses / Resumes event listener
/** Pauses all listeners which are associated the specified target. * * @param target A given target node. * @param recursive True if pause recursively, the default value is false. */
void pauseEventListenersForTarget(Node* target, bool recursive = false);
/** Resumes all listeners which are associated the specified target. * * @param target A given target node. * @param recursive True if resume recursively, the default value is false. */
void resumeEventListenersForTarget(Node* target, bool recursive = false);
/////////////////////////////////////////////
/** Sets listener's priority with fixed value. * * @param listener A given listener. * @param fixedPriority The fixed priority value. */
void setPriority(EventListener* listener, int fixedPriority);
/** Whether to enable dispatching events. * * @param isEnabled True if enable dispatching events. */
void setEnabled(bool isEnabled);
/** Checks whether dispatching events is enabled. * * @return True if dispatching events is enabled. */
bool isEnabled() const;
/////////////////////////////////////////////
/** Dispatches the event. * Also removes all EventListeners marked for deletion from the * event dispatcher list. * * @param event The event needs to be dispatched. */
//分发事件：主要接口（内部通过判别event的类型，来调用不同的分发函数）
void dispatchEvent(Event* event);
//...部分省略
/** Whether the dispatcher isdispatching event */
int _inDispatch;
/** Whether to enable dispatching event */
bool _isEnabled;
int _nodePriorityIndex;
std::set<std::string> _internalCustomListenerIDs;
};小结
GL视图负责感应事件，当有事件作用于GL视图的时候，GL视图将调用分发器EventDispatcher的接口（dispatchEvent）分发事件。而具体分发给谁，分发器将首先根据分发器中所维护的监听器队列来选择，因为可能有多个层希望接收这一类型事件，但是这些层的绘图顺序是不一样的，所以当选定了需要向哪些类型的监听器分发消息后，还将先把消息传递给最上层的图层（即本帧最后绘制的图层）。