Cocos2dx 事件响应机制(2)：事件处理机制

其他 2018-10-31 13:01:10 阅读次数: 0

1 事件的工作机制


图1
传统事件系统如上图，模块A为事件触发者，模块B为事件响应者。A的实现依赖于模块B的实现，如果B的实现发生变化,A也可能需要作出相应调整。Cocos用订阅者模式将事件的触发者和响应者分开。触发者向一个公共的事件分发器发送一个事件消息，事件响应者向事件分发器订阅一个特定类型的消息来响应事件。以图1为例，B创建一个订阅者(ListenerB)并将此订阅者注册至事件分发器中，其中ListenerB附带了响应事件时需要执行的回调函数地址callBackFunc。当事件发生时，A使得事件发生器发出消息通知，以此触发B中的回调函数。

    // 事件触发者A 以按下事件 TouchesBegin 为例
    void GLView::handleTouchesBegin(int num, intptr_t ids[], float xs[], float ys[])
    {
        // ...
        touchEvent._eventCode = EventTouch::EventCode::BEGAN;
        // 当游戏发生 TouchesBegin 事件时，通知分发器发送相关事件
        auto dispatcher = Director::getInstance()->getEventDispatcher();
        dispatcher->dispatchEvent(&touchEvent);
    }
    // 事件响应者B
    void Widget::setTouchEnabled(bool enable)
    {
        if (enable == _touchEnabled)
        {
            return;
        }
        _touchEnabled = enable;
        if (_touchEnabled)
        {
            // 为widget创建一个订阅者 
            _touchListener = EventListenerTouchOneByOne::create();
            CC_SAFE_RETAIN(_touchListener);
            _touchListener->setSwallowTouches(true);
            // 将响应事件时需要回调的函数加至订阅者中
            _touchListener->onTouchBegan = CC_CALLBACK_2(Widget::onTouchBegan, this);
            _touchListener->onTouchMoved = CC_CALLBACK_2(Widget::onTouchMoved, this);
            _touchListener->onTouchEnded = CC_CALLBACK_2(Widget::onTouchEnded, this);
            _touchListener->onTouchCancelled = CC_CALLBACK_2(Widget::onTouchCancelled, this);
            // 将此订阅者注册至事件分发器中
            _eventDispatcher->addEventListenerWithSceneGraphPriority(_touchListener, this);
        }
        else
        {
            _eventDispatcher->removeEventListener(_touchListener);
            CC_SAFE_RELEASE_NULL(_touchListener);
        }
    }

2 Cocos2dx中的事件分发器

2.1 基本组成

事件处理机制的组成部分包括：事件源、订阅者与分发者。事件源包含了该事件的类型Type与listenerID。订阅者包含了订阅者类型与listenerID, 因此三者之间的关系是：分发器EventDispatch根据事件的类型找到对应的listenerID, 进而找到所有该事件的订阅者。

2.2 注册订阅者

2.2.1 事件优先级

指定事件优先级有两个作用：1）让某些元素优先处理，并不再向后面的订阅者传递；2）控制元素间逻辑处理上的优先级。

// 方式1：通过关联UI指定事件分发优先级
void EventDispatcher::addEventListenerWithSceneGraphPriority(EventListener* listener, Node* node)
{
    if (!listener->checkAvailable())
        return;
    // 关联到特定node
    listener->setAssociatedNode(node);
    // 优先级数字默认为0
    listener->setFixedPriority(0);
    listener->setRegistered(true);
    addEventListener(listener);
}
// 方式2：指定一个整数的优先级
void EventDispatcher::addEventListenerWithFixedPriority(EventListener* listener, int fixedPriority)
{
    if (!listener->checkAvailable())
        return;

    listener->setAssociatedNode(nullptr);
    listener->setFixedPriority(fixedPriority);
    listener->setRegistered(true);
    listener->setPaused(false);
    addEventListener(listener);
}

关联到具体UI的优先级指定方式很多时候要优于指定整数优先级的方式。后者需要开发者创建并关注一堆毫无意义的优先级枚举变量，这很有可能会导致某些问题，如：UI层级低的事件优先级数值比层级高的数值大，具体表现为：被遮挡的UI响应了触发事件而位于前面的UI却无任何反应。这肯定是不合理的。实际上，通过UI设置事件优先级的机制是在Cocos2dx 3.x之后引入的。

2.2.2 添加订阅者

上述关联代码需要关注的一个函数是addEventListener。事件的分发是可以嵌套的，即可以在一个事件中触发另一个事件。_inDispatch记录了事件的嵌套数目，0表示没有事件需要分发。何时会发生事件的循环嵌套？举例说明：当按下A节点时，分发Touch事件，执行相关onTouchEvent函数，该函数内实现了一个自定义事件，并再次调用事件分发函数，此时就产生了嵌套。

void EventDispatcher::addEventListener(EventListener* listener)
{
    // _inDispatch:事件嵌套数
    if (_inDispatch == 0)
    {
        // 无嵌套时调用
        forceAddEventListener(listener);
    }
    else
    {
        // 存在嵌套时调用
        _toAddedListeners.push_back(listener);
    }
    listener->retain();
}

  1. 无嵌套时的添加过程

    void EventDispatcher::forceAddEventListener(EventListener* listener)
{
    EventListenerVector* listeners = nullptr;
    EventListener::ListenerID listenerID = listener->getListenerID();
    auto itr = _listenerMap.find(listenerID);
    if (itr == _listenerMap.end())
    {
        // 如果_listenerMap中没有当前订阅者类型 创建一个新的订阅者数组 
        listeners = new (std::nothrow) EventListenerVector();
        _listenerMap.emplace(listenerID, listeners);
    }
    else
    {
        listeners = itr->second;
    }
    // 将订阅者加入至当前类型的容器中
    listeners->push_back(listener);
    // 订阅者与UI绑定
    if (listener->getFixedPriority() == 0)
    {
        // 标记当前订阅者类型 该标记用于加速事件排序
        setDirty(listenerID, DirtyFlag::SCENE_GRAPH_PRIORITY);
        auto node = listener->getAssociatedNode();
        // 添加至nodeListenerMap，该map的key为node，value为所有关联到该node的订阅者
        associateNodeAndEventListener(node, listener);
        if (node->isRunning())
        {
            // 节点关联的所有订阅者：setPause(false)|setDirty()
            resumeEventListenersForTarget(node);
        }
    }
    else
    {
        setDirty(listenerID, DirtyFlag::FIXED_PRIORITY);
    }
}

    该过程主要做了两件事：

    • 将传入的订阅者添加至两个容器中：_listenerMap 与 _nodeListenersMap。前者以ListenerID 为key，后者以node为key。使用两个容器，以空间开销换时间检索效率；

    • 标记订阅器：1) 将当前类型的订阅器做标记；2) 将node关联到的所有订阅器做标记。为何要做标记？这是用于加速订阅器的排序。订阅器的优先级随时会发生变动，为了保证事件分发能够按照正确顺序进行，事件分发时必须首先进行订阅器的排序。但为了避免频繁且重复的排序导致的性能问题，在订阅器发生变动时打上标记。排序时仅操作标记过的订阅者。具体排序实现后续会介绍。

      // 标记传入类型的订阅者
void EventDispatcher::setDirty(const EventListener::ListenerID& listenerID, DirtyFlag flag)
{
    // 标记的类型存入 _priorityDirtyFlagMap 映射表
    auto iter = _priorityDirtyFlagMap.find(listenerID);
    if (iter == _priorityDirtyFlagMap.end())
    {
        // 映射表未找到 存入
        _priorityDirtyFlagMap.emplace(listenerID, flag);
    }
    else
    {
        //映射表找到 基于位的或操作更新
        int ret = (int)flag | (int)iter->second;
        iter->second = (DirtyFlag) ret;
    }
}
// 标记传入node关联到的所有订阅者
void EventDispatcher::setDirtyForNode(Node* node)
{
    // Mark the node dirty only when there is an eventlistener associated with it. 
    if (_nodeListenersMap.find(node) != _nodeListenersMap.end())
    {
        _dirtyNodes.insert(node);
    }

    // Also set the dirty flag for node's children
    const auto& children = node->getChildren();
    for (const auto& child : children)
    {
        setDirtyForNode(child);
    }
}
  2. 事件嵌套时的添加过程
    当事件嵌套时，传入的订阅者不会立即被立即添加至相关容器中，而是先放置在待处理容器_toAddedListeners中。这些待处理的订阅者将在当前分发过程结束时加入，具体实现在后文的事件分发中描述。

2.3 事件分发

Touch事件是所有类型中最常用也是最复杂的一种事件，下文将以Touch事件为例详细剖析事件分发的核心过程。

2.3.1 事件触发源

touch事件的触发源在GLView中发生。

// touch begin事件
void GLView::handleTouchesBegin(int num, intptr_t ids[], float xs[], float ys[])
{
    touchEvent._eventCode = EventTouch::EventCode::BEGAN;
    auto dispatcher = Director::getInstance()->getEventDispatcher();
    dispatcher->dispatchEvent(&touchEvent);
}
// touch move事件
void GLView::handleTouchesMove(int num, intptr_t ids[], float xs[], float ys[], float fs[], float ms[])
{
    touchEvent._eventCode = EventTouch::EventCode::MOVED;
    auto dispatcher = Director::getInstance()->getEventDispatcher();
    dispatcher->dispatchEvent(&touchEvent);
}
// end or cancel ...

2.3.2 分发过程

事件分发的入口为dispatchEvent,这一函数包含了事件分发的主要过程。我们将逐步研究函数内部细节实现。

void EventDispatcher::dispatchEvent(Event* event)
{
    if (!_isEnabled)
        return;

    updateDirtyFlagForSceneGraph();

    DispatchGuard guard(_inDispatch);

    if (event->getType() == Event::Type::TOUCH)
    {
        dispatchTouchEvent(static_cast<EventTouch*>(event));
        return;
    }
    // ... 其他类型事件处理 略
}

  • updateDirtyFlagForSceneGraph
    当关联的UI发生层级变化时，需要更新该UI节点对应的所有事件分发顺序。如在父控件上有A B两个子节点。起初A遮盖B，之后基于逻辑调整，B层级被调整并高过A，此时B事件响应等级也应当高于A。

    void EventDispatcher::updateDirtyFlagForSceneGraph()
{
    if (!_dirtyNodes.empty())
    {
        for (auto& node : _dirtyNodes)
        {
            auto iter = _nodeListenersMap.find(node);
            if (iter != _nodeListenersMap.end())
            {
                for (auto& l : *iter->second)
                {
                    // 标记node中所有订阅者
                    setDirty(l->getListenerID(), DirtyFlag::SCENE_GRAPH_PRIORITY);
                }
            }
        }
        _dirtyNodes.clear();
    }
}

    _dirtyNodes存放了一堆需要更新其订阅者的节点。这些节点什么时候会被加入至_dirtyNodes中呢？1） 节点的某个订阅者发生变化，如向该节点加入一个订阅者；2）节点的层级发生变化，实现过程如下。

    void Node::setLocalZOrder(int z)
{
    if (getLocalZOrder() == z)
        return;
    // 设置父节点下的层次
    _setLocalZOrder(z);
    if (_parent)
    {
        _parent->reorderChild(this, z);
    }
    _eventDispatcher->setDirtyForNode(this);
}

  • DispatchGuard
    在函数内部创建一个DispatchGuard，该变量被分配在栈上，创建时_inDispatch嵌套数量加1，当前事件分发函数结束时变量自动析构，嵌套数减1。

    class DispatchGuard
{
public:
    DispatchGuard(int& count):_count(count)
    {
        ++_count;
    }

    ~DispatchGuard()
    {
        --_count;
    }

private:
    int& _count;
};

  • dispatchTouchEvent
    该函数包含了Touch触摸事件分发的全部过程，包括：订阅者排序、将事件处理函数分发至订阅者以及更新订阅者。

    void EventDispatcher::dispatchTouchEvent(EventTouch* event)
{
    // 不同类型分开排序
    sortEventListeners(EventListenerTouchOneByOne::LISTENER_ID);
    sortEventListeners(EventListenerTouchAllAtOnce::LISTENER_ID);
    auto oneByOneListeners = getListeners(EventListenerTouchOneByOne::LISTENER_ID);
    auto allAtOnceListeners = getListeners(EventListenerTouchAllAtOnce::LISTENER_ID);

    // If there aren't any touch listeners, return directly.
    if (nullptr == oneByOneListeners && nullptr == allAtOnceListeners)
        return;

    bool isNeedsMutableSet = (oneByOneListeners && allAtOnceListeners);

    const std::vector<Touch*>& originalTouches = event->getTouches();
    std::vector<Touch*> mutableTouches(originalTouches.size());
    std::copy(originalTouches.begin(), originalTouches.end(), mutableTouches.begin());

    // process the target handlers 1st
    if (oneByOneListeners)
    {
        auto mutableTouchesIter = mutableTouches.begin();

        for (auto& touches : originalTouches)
        {
            bool isSwallowed = false;

            auto onTouchEvent = [&](EventListener* l) -> bool { // Return true to break
                EventListenerTouchOneByOne* listener = static_cast<EventListenerTouchOneByOne*>(l);

                // Skip if the listener was removed.
                if (!listener->_isRegistered)
                    return false;

                event->setCurrentTarget(listener->_node);

                bool isClaimed = false;
                std::vector<Touch*>::iterator removedIter;

                EventTouch::EventCode eventCode = event->getEventCode();

                if (eventCode == EventTouch::EventCode::BEGAN)
                {
                    if (listener->onTouchBegan)
                    {
                        isClaimed = listener->onTouchBegan(touches, event);
                        if (isClaimed && listener->_isRegistered)
                        {
                            listener->_claimedTouches.push_back(touches);
                        }
                    }
                }
                else if (listener->_claimedTouches.size() > 0
                         && ((removedIter = std::find(listener->_claimedTouches.begin(), listener->_claimedTouches.end(), touches)) != listener->_claimedTouches.end()))
                {
                    isClaimed = true;
                    switch (eventCode)
                    {
                        case EventTouch::EventCode::MOVED:
                            if (listener->onTouchMoved)
                            {
                                listener->onTouchMoved(touches, event);
                            }
                            break;
                        case EventTouch::EventCode::ENDED:
                            if (listener->onTouchEnded)
                            {
                                listener->onTouchEnded(touches, event);
                            }
                            if (listener->_isRegistered)
                            {
                                listener->_claimedTouches.erase(removedIter);
                            }
                            break;
                        case EventTouch::EventCode::CANCELLED:
                            if (listener->onTouchCancelled)
                            {
                                listener->onTouchCancelled(touches, event);
                            }
                            if (listener->_isRegistered)
                            {
                                listener->_claimedTouches.erase(removedIter);
                            }
                            break;
                        default:
                            CCASSERT(false, "The eventcode is invalid.");
                            break;
                    }
                }
                // If the event was stopped, return directly.
                if (event->isStopped())
                {
                    updateListeners(event);
                    return true;
                }
                if (isClaimed && listener->_isRegistered && listener->_needSwallow)
                {
                    if (isNeedsMutableSet)
                    {
                        mutableTouchesIter = mutableTouches.erase(mutableTouchesIter);
                        isSwallowed = true;
                    }
                    return true;
                }

                return false;
            };
            //
            dispatchTouchEventToListeners(oneByOneListeners, onTouchEvent);
            if (event->isStopped())
            {
                return;
            }
            if (!isSwallowed)
                ++mutableTouchesIter;
        }
    }
    // ... allAtOnceListeners 处理部分 略    
    updateListeners(event);
}
    1）订阅者排序

    EventListenerTouchOneByOne 与 EventListenerTouchAllAtOnce的相关逻辑是分开处理的，因此排序方面也是独立进行。排序前，首先判断当前订阅者类型是否被记录在标记映射表内，如未标记则不进行任何操作；之后基于标记类型判断订阅者需要进行何种类型(数值指定优先级类型 与 节点赋予的优先级类型)的排序。

    void EventDispatcher::sortEventListeners(const EventListener::ListenerID& listenerID)
{
    DirtyFlag dirtyFlag = DirtyFlag::NONE;
    // 先检测当前类型订阅器是否需要排序
    auto dirtyIter = _priorityDirtyFlagMap.find(listenerID);
    if (dirtyIter != _priorityDirtyFlagMap.end())
    {
        dirtyFlag = dirtyIter->second;
    }
    // 仅当当前类型被标记时 再排序，这一优化能较大的提升排序效率
    if (dirtyFlag != DirtyFlag::NONE)
    {
        // Clear the dirty flag first, if `rootNode` is nullptr, then set its dirty flag of scene graph priority
        dirtyIter->second = DirtyFlag::NONE;
        // 订阅者优先级通过数值指定且被标记
        if ((int)dirtyFlag & (int)DirtyFlag::FIXED_PRIORITY)
        {
            sortEventListenersOfFixedPriority(listenerID);
        }
        // 订阅者优先级通过node指定且被标记
        if ((int)dirtyFlag & (int)DirtyFlag::SCENE_GRAPH_PRIORITY)
        {
            auto rootNode = Director::getInstance()->getRunningScene();
            if (rootNode)
            {
              sortEventListenersOfSceneGraphPriority(listenerID, rootNode);
            }
            else
            {
                dirtyIter->second = DirtyFlag::SCENE_GRAPH_PRIORITY;
            }
        }
    }
}

    下面来看如何对Node指定优先级类型的订阅者排序过程进行分析。该过程首先将需要排序的订阅者筛选出来。可以发现，检索操作十分频繁，检索得事件复杂度至多为O(n)，而排序的最优效率最高为O(nlog(n))，因此排序相较于检索要更加耗时。为保证排序高效完成，在排序前要采用响应手段尽量将无需参与排序的元素剔除；完成筛选后，更新_nodePriorityMap，该表内存储了所有节点对应的优先级，作为后续排序的凭证。为保证节点优先级的实时性与有效性，每次进行排序时都需要从根节点深度遍历一次所有UI；最后基于最新的优先级排序订阅者。

    void ventDispatcher::sortEventListenersOfSceneGraphPriority(const EventListener::ListenerID& listenerID, Node* rootNode)
{
    auto listeners = getListeners(listenerID);

    if (listeners == nullptr)
        return;
    auto sceneGraphListeners = listeners->getSceneGraphPriorityListeners();

    if (sceneGraphListeners == nullptr)
        return;

    // Reset priority index
    _nodePriorityIndex = 0;
    _nodePriorityMap.clear();

    visitTarget(rootNode, true);

    // After sort: priority < 0, > 0
    std::stable_sort(sceneGraphListeners->begin(), sceneGraphListeners->end(), [this](const EventListener* l1, const EventListener* l2) {
        return _nodePriorityMap[l1->getAssociatedNode()] > _nodePriorityMap[l2->getAssociatedNode()];
    } );
}

    遍历一遍UI树并获得最新的层级表_nodePriorityMap。为什么要做层级表更新？主要有两个原因：1）保证节点局部层级的准确性：一个父节点下包含一些层级小于0的子节点与一些层级大于等于0的子节点，绘制的时候先绘制层级小于0的，之后是父节点，之后是层级大于等于0的；2）保证节点全局层级的准确性：cocos2dx 3.x版本之后可指定任意节点的全局层级，绘制时会优先绘制全局层级高的。如何满足第一点？很简单，首先对相当节点所有子节点排序以保证层次有序，之后采用中序遍历遍历。巧妙之处在于：中序遍历的结果与节点绘制顺序完全一致。如何满足第二点？借助于_globalZOrderNodeMap映射表容器，以全局层次为key，node为value。没有设置全局层次的默认为0，在中序遍历是按照访问顺序被依次加入容器中，设置了全局层次的，也同理。在最后的节点优先级统计阶段，首先将_globalZOrderNodeMap依照key排序，然后从小到大遍历，将每个关联了订阅器的节点优先级加1。

    // 从根节点中序（深度）遍历UI树，更新_nodePriorityMap
void EventDispatcher::visitTarget(Node* node, bool isRootNode)
{
    // 排序子节点
    node->sortAllChildren();

    int i = 0;
    auto& children = node->getChildren();

    auto childrenCount = children.size();
    // 有子节点 向下遍历
    if(childrenCount > 0)
    {
        Node* child = nullptr;
        // visit children zOrder < 0
        for( ; i < childrenCount; i++ )
        {
            child = children.at(i);

            if ( child && child->getLocalZOrder() < 0 )
                visitTarget(child, false);
            else
                break;
        }
        // 判断该节点是否关联了订阅器
        if (_nodeListenersMap.find(node) != _nodeListenersMap.end())
        {
            _globalZOrderNodeMap[node->getGlobalZOrder()].push_back(node);
        }
        // visit children zOrder >= 0
        for( ; i < childrenCount; i++ )
        {
            child = children.at(i);
            if (child)
                visitTarget(child, false);
        }
    }
    else
    {
        if (_nodeListenersMap.find(node) != _nodeListenersMap.end())
        {
            _globalZOrderNodeMap[node->getGlobalZOrder()].push_back(node);
        }
    }
    // 所有子节点均访问结束
    if (isRootNode)
    {
        std::vector<float> globalZOrders;
        globalZOrders.reserve(_globalZOrderNodeMap.size());

        for (const auto& e : _globalZOrderNodeMap)
        {
            globalZOrders.push_back(e.first);
        }

        std::stable_sort(globalZOrders.begin(), globalZOrders.end(), [](const float a, const float b){
            return a < b;
        });

        for (const auto& globalZ : globalZOrders)
        {
            for (const auto& n : _globalZOrderNodeMap[globalZ])
            {
                // 依照遍历顺序 优先级+1
                _nodePriorityMap[n] = ++_nodePriorityIndex;
            }
        }

        _globalZOrderNodeMap.clear();
    }
}

猜你喜欢

转载自blog.csdn.net/XIANG__jiangsu/article/details/78116046
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
laravle中orm简单的增删改查
文本分类 特征选取之CHI开方检验
Spark核心编程-WordCount
大数据开发实战系列之电信客服(1)
读书笔记 - 把时间当作朋友 by 李笑来
python 笔记--if else
SpringBoot/Mybatis/Druid, 多数据源MultiDataSource配置思路
排序三个整数
redis集群搭建【2】-Windows中Redis集群搭建
STM32F030驱动TM1650点亮4联数码管
每日归档
更多
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022