Android 12(S) 图像显示系统 - SurfaceFlinger 之 VSync - 中篇（十七）

---

必读：

Android 12(S) 图像显示系统 - 开篇

---

1 前言

这一篇文章，将继续讲解有关VSync的知识，前一篇文章 Android 12(S) 图像显示系统 - SurfaceFlinger之VSync-上篇（十六）中，主要是分析了SurfaceFlinger启动后VSync的一些初始化流程，以及vsync events的分发逻辑。

vsync events汇集到了两个地方：

1. MessageQueue::vsyncCallback  ==> VSYNC-sf

2. EventThread::onVSyncEvent  ==> VSYNC-app  & VSYNC-appSf

本篇中，将从一个简单的demo出发，来具体分析，vsync events是如何传递到  ==> 真正需要的地方

2 可以监测vsync event的应用

2.1 代码位置

代码存放到了GitHub，自取哦

https://github.com/yrzroger/DisplayEventTracker

2.2 如何使用

1. 下载代码放到android源码目录下

2. 执行 mm 编译得到可执行档 DisplayEventTracker

3. 将 DisplayEventTracker，adb push 到测试板的 /system/bin/ 目录下

4. 在console下执行 DisplayEventTracker -h，可以查看简单的命令说明

usage: DisplayEventTracker [options]
------------------------------------ options ---------------------------------------------
[-i] vsync rate(default:1)
[-h] help
input 'r' to call requestNextVsync or input 'q' to exit when running
------------------------------------------------------------------------------------------

5. 示例命令

DisplayEventTracker          // 默认vsync rate = 1, 每个vsync到来时都会收到该event
DisplayEventTracker -i 3     //表示vsync rate = 3, 每3个vsync才会通知一次
DisplayEventTracker -i 0     //除非调用requestNextVsync，否则不会收到vsync event,此时可以输入‘r’来调用requestNextVsync

2.3 执行结果展示

我的测试板默认的屏幕刷新率是60Hz，一个VSync间隔是16.67ms

结果一：默认setVsyncRate(1)，每一个vsync event都会都到，可以看结果Vsync period大约是16.68ms

root:/ $ DisplayEventTracker
Vsync received: count=149
Vsync received: count=150       16.687281 ms (59.925879 Hz)
Vsync received: count=151       16.687281 ms (59.925879 Hz)
Vsync received: count=152       16.687281 ms (59.925879 Hz)
Vsync received: count=153       16.687281 ms (59.925879 Hz)
Vsync received: count=154       16.687281 ms (59.925879 Hz)
Vsync received: count=155       16.687281 ms (59.925879 Hz)

结果二：setVsyncRate(6)，每间隔6个vsync events才投递一次

root:/ $ DisplayEventTracker -i 6
Vsync received: count=540
Vsync received: count=546       100.102455 ms (9.989765 Hz)
Vsync received: count=552       100.102455 ms (9.989765 Hz)
Vsync received: count=558       100.102455 ms (9.989765 Hz)
Vsync received: count=564       100.102455 ms (9.989765 Hz)
Vsync received: count=570       100.102455 ms (9.989765 Hz)
Vsync received: count=576       100.102455 ms (9.989765 Hz)
Vsync received: count=582       100.102455 ms (9.989765 Hz)

结果三：setVsyncRate(0)，每次调用requestNextVsync()后才收到一次vsync event

root:/ $ DisplayEventTracker -i 6
130|RealtekStark:/ $ DisplayEventTracker -i 0
r
Vsync received: count=797
r
Vsync received: count=801       583.896606 ms (1.712632 Hz)
r
Vsync received: count=803       583.900635 ms (1.712620 Hz)
r
Vsync received: count=805       633.949219 ms (1.577413 Hz)
r
Vsync received: count=807       2002.051880 ms (0.499488 Hz)
r
Vsync received: count=809       1951.946533 ms (0.512309 Hz)

3 示例Demo源码解析

3.1 DisplayEventTracker类的定义

DisplayEventTracker定义很简单，继承自Thread，这意味着它可以开启一个独立的新线程，并在新线程中执行threadLoop()中的处理逻辑。

class DisplayEventTracker : public Thread
{
public:
    explicit DisplayEventTracker(int vsyncRate); // 构造函数
    virtual ~DisplayEventTracker(); // 析构函数

    void requestNextVsync(); // 请求下一个 vsync event

private:
    virtual bool        threadLoop();
    virtual status_t    readyToRun();
    void processDisplayEvents(); 

    // Display event handling
    class DisplayEventCallback; // LooperCallback的实现类

    std::unique_ptr<DisplayEventReceiver> mDisplayEventReceiver; // 接收 display events的核心成员
    sp<Looper> mLooper;
    int mVsyncRate; // 投递 vsync events的间隔、频率
};

3.2 DisplayEventTracker::readyToRun完成一些初始化设置，设置监听和回调

status_t DisplayEventTracker::readyToRun() {
    // Register a display event receiver
    // To receive ModeChanged and/or FrameRateOverrides events specify this in the constructor.
    mDisplayEventReceiver = std::make_unique<DisplayEventReceiver>(); // 创建 DisplayEventReceiver 对象
    status_t status = mDisplayEventReceiver->initCheck(); // 检查 DisplayEventReceiver 初始化成功
    if(status != NO_ERROR)
        printf("Initialization of DisplayEventReceiver failed with status: %d", status);

    mLooper->addFd(mDisplayEventReceiver->getFd(), 0, Looper::EVENT_INPUT, // 添加待监测的fd，并设置回调 DisplayEventCallback()
            new DisplayEventCallback(), mDisplayEventReceiver.get()); //mDisplayEventReceiver.get()指针作为回调时传递给回调方法的数据
    // setVsyncRate() sets the Event::VSync delivery rate.
    // A value of 1 returns every Event::VSync.
    // A value of 2 returns every other event, etc...
    // a value of 0 returns no event unless  requestNextVsync() has been called.
    mDisplayEventReceiver->setVsyncRate(mVsyncRate); // 设置投递 vsync event的频率

    return NO_ERROR;
}

3.3 新线程开启，DisplayEventTracker::threadLoop中等待事件发生

bool DisplayEventTracker::threadLoop() {
    processDisplayEvents();
    return true;
}

void DisplayEventTracker::processDisplayEvents() {
    // This will poll mDisplayEventReceiver and if there are new events it'll call
    // displayEventCallback synchronously.
    mLooper->pollOnce(-1);// 阻塞等待事件发生
}

threadLooper返回true，所以会反复执行。

---

上面的逻辑就是典型的 Android Native Looper 机制，不熟悉的可以参见文章：

Android Native -- Message/Handler/Looper机制（原理篇）

Android Native -- Message/Handler/Looper机制（应用篇）

---

3.4 vsync event到来时，回调 handleEvent

class DisplayEventTracker::DisplayEventCallback : public LooperCallback {
    nsecs_t oldTimeStamp; // 记录前一个vsync的时间
public:
    DisplayEventCallback(): oldTimeStamp(0) {}

    int handleEvent(int /* fd */, int /*events*/, void* data) {
        DisplayEventReceiver* displayEventReceiver = (DisplayEventReceiver*)data;
        constexpr int kBufferSize = 100;
        DisplayEventReceiver::Event buffer[kBufferSize];
        ssize_t numEvents;
        do {
            numEvents = displayEventReceiver->getEvents(buffer, kBufferSize); // 获取事件
            for (size_t i = 0; i < static_cast<size_t>(numEvents); i++) {
                const auto& event = buffer[i];
                if (event.header.type == DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG) { // 热插拔事件
                    printf("Hotplug received: %s\n", event.hotplug.connected?"connected":"disconnected");
                }

                if(event.header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) { // vsync 事件
                    printf("Vsync received: count=%d\t", event.vsync.count); // 打印计数
                    if (oldTimeStamp) {
                        float t = float(event.header.timestamp - oldTimeStamp) / s2ns(1);
                        printf("%f ms (%f Hz)\n", t*1000, 1.0/t); //打印 vsync 事件间隔
                    } else {
                        printf("\n");
                    }
                    oldTimeStamp = event.header.timestamp; // 记录事件
                }

                if(event.header.type == DisplayEventReceiver::DISPLAY_EVENT_MODE_CHANGE) { // 模式变化事件
                    printf("Mode change received\n");
                }

            }
        } while (numEvents > 0);

        return 1;  // keep the callback
    }
};

---

小结：

demo的整体流程是非常简单的，本质就是通过Looper去监测DisplayEventReceiver::getFd()中的fd，当fd上有事件发生时，就会回调到我们设置的函数。然后就可以从DisplayEventReceiver中getEvents获取事件，判断事件类型进行对应处理了

DisplayEventReceiver由是个啥东东？它为什么可以收到vsync event呢？莫急，稍后分析

---

4 DisplayEventReceiver相关原理分析

DisplayEventReceiver创建并注册与SurfaceFlinger的事件连接。可用来监测VSync、HotPlug、ModeChange、FrameRateOverride事件。

4.1 类定义

4.2 主要方法解释

DisplayEventReceiver构造函数

可以根据需求来指定VsyncSource，并设置EventRegistrationFlags来决定是否接收ModeChanged和FrameRateOverrides事件。

[/frameworks/native/libs/gui/include/gui/ISurfaceComposer.h]
enum VsyncSource {
    eVsyncSourceApp = 0,
    eVsyncSourceSurfaceFlinger = 1
};

enum class EventRegistration {
    modeChanged = 1 << 0,
    frameRateOverride = 1 << 1,
};

status_t setVsyncRate(uint32_t count)

设置投递vsync events的频率，设置1代表每个vsync event均被投递，设置2代表每隔一个投递一次，依次类推 ...

设置0代表只有调用requestNextVsync()后才会投递一次vsync event

status_t requestNextVsync()

请求下一个vsync event，在vsync rate大于0的时候，这个函数调用无效

int getFd() const

获取用于接收事件的文件描述符

ssize_t getEvents(Event* events, size_t count)

当监测到有事件发生时，通过它获取具体的事件列表，函数返回值就是事件的数量

ssize_t sendEvents(Event const* events, size_t count)

发送事件，函数返回值就是事件的数量

本文作者@二的次方  2022-04-27 发布于博客园

4.3 DisplayEventReceiver工作原理，事件是怎么传递过来的？

先看看它的构造函数的具体实现

[/frameworks/native/libs/gui/DisplayEventReceiver.cpp]
DisplayEventReceiver::DisplayEventReceiver(
        ISurfaceComposer::VsyncSource vsyncSource,
        ISurfaceComposer::EventRegistrationFlags eventRegistration) {
    sp<ISurfaceComposer> sf(ComposerService::getComposerService()); // 获取SurfaceFLinger服务
    if (sf != nullptr) {
        mEventConnection = sf->createDisplayEventConnection(vsyncSource, eventRegistration); // 创建远程事件连接
        if (mEventConnection != nullptr) {
            mDataChannel = std::make_unique<gui::BitTube>();
            mEventConnection->stealReceiveChannel(mDataChannel.get()); // 传递 BitTube
        }
    }
}

核心的处理应该是createDisplayEventConnection和stealReceiveChannel，下面分别看看这两个操作具体做了啥子

4.3.1 SurfaceFlinger::createDisplayEventConnection

这个方法通过Binder IPC跨进程，一路飞奔，直到SurfaceFlinger核心服务 SurfaceFlinger::createDisplayEventConnection

[/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp]
sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
        ISurfaceComposer::VsyncSource vsyncSource,
        ISurfaceComposer::EventRegistrationFlags eventRegistration) {
    const auto& handle = // 判断选哪个 vsyncSource
            vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
    // 创建 DisplayEventConnection
    return mScheduler->createDisplayEventConnection(handle, eventRegistration);
}

mSfConnectionHandle和mAppConnectionHandle是在initScheduler时创建的scheduler::ConnectionHandle对象，前一篇文章中有分析过。

通过这两个handle可以在Scheduler::mConnections中找到和他们分别对应的Connection，即

    // Stores EventThread associated with a given VSyncSource, and an initial EventThreadConnection.
    struct Connection {
        sp<EventThreadConnection> connection;
        std::unique_ptr<EventThread> thread;
    };

4.3.2 Scheduler::createDisplayEventConnection

先看代码

[/frameworks/native/services/surfaceflinger/Scheduler/Scheduler.cpp]
sp<IDisplayEventConnection> Scheduler::createDisplayEventConnection(
        ConnectionHandle handle, ISurfaceComposer::EventRegistrationFlags eventRegistration) {
    std::lock_guard<std::mutex> lock(mConnectionsLock);
    RETURN_IF_INVALID_HANDLE(handle, nullptr);
    return createConnectionInternal(mConnections[handle].thread.get(), eventRegistration);
}

根据handle，从Scheduler::mConnections取出对应的EventThread对象，继续调用 Scheduler::createConnectionInternal

[/frameworks/native/services/surfaceflinger/Scheduler/Scheduler.cpp]
sp<EventThreadConnection> Scheduler::createConnectionInternal(
        EventThread* eventThread, ISurfaceComposer::EventRegistrationFlags eventRegistration) {
    return eventThread->createEventConnection([&] { resync(); }, eventRegistration);
}

继续去调用了 EventThread::createEventConnection

[/frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp]
sp<EventThreadConnection> EventThread::createEventConnection(
        ResyncCallback resyncCallback,
        ISurfaceComposer::EventRegistrationFlags eventRegistration) const {
    return new EventThreadConnection(const_cast<EventThread*>(this),
                                     IPCThreadState::self()->getCallingUid(),
                                     std::move(resyncCallback), eventRegistration);
}

创建了一个EventThreadConnection对象，并返回给调用者。如下图继承关系，保证了DisplayEventReceiver可以取得EventThreadConnection对象的远程代理，保存在成员sp<IDisplayEventConnection> mEventConnection

流程继续，创建EventThreadConnection对象，第一次被引用时会进到onFirstRef中进行注册

void EventThreadConnection::onFirstRef() {
    // NOTE: mEventThread doesn't hold a strong reference on us
    mEventThread->registerDisplayEventConnection(this);
}

再转到EventThread::registerDisplayEventConnection中，就是把这个connecttion保存到EventThread::mDisplayEventConnections

status_t EventThread::registerDisplayEventConnection(const sp<EventThreadConnection>& connection) {
    std::lock_guard<std::mutex> lock(mMutex);

    // this should never happen
    auto it = std::find(mDisplayEventConnections.cbegin(),
            mDisplayEventConnections.cend(), connection);
    if (it != mDisplayEventConnections.cend()) {  // 判断是否已经存在
        ALOGW("DisplayEventConnection %p already exists", connection.get());
        mCondition.notify_all();
        return ALREADY_EXISTS;
    }

    mDisplayEventConnections.push_back(connection);// 保存到 mDisplayEventConnections 这个vector数组中
    mCondition.notify_all();
    return NO_ERROR;
}

DisplayEventReceiver已经和SurfaceFlinger服务端的Scheduler建立了关系，再回到DisplayEventReceiver的构造函数接着分析下面的操作

[/frameworks/native/libs/gui/DisplayEventReceiver.cpp]
// DisplayEventReceiver构造函数
mDataChannel = std::make_unique<gui::BitTube>();
mEventConnection->stealReceiveChannel(mDataChannel.get()); // 传递跨进程数据传递的对象 BitTube

下一步创建了一个BitTube对象，然后调用了mEventConnection->stealReceiveChannel，这个方法会走到

[/frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp ]
status_t EventThreadConnection::stealReceiveChannel(gui::BitTube* outChannel) {
    outChannel->setReceiveFd(mChannel.moveReceiveFd());// resets this BitTube's receive file descriptor to receiveFd
    outChannel->setSendFd(base::unique_fd(dup(mChannel.getSendFd()))); // resets this BitTube's send file descriptor to sendFd
    return NO_ERROR;
}

这使用到BitTube的跨进程传递数据的方式，基本原理可以参考：Android 12(S) 图像显示系统 - 基础知识之 BitTube

---

到这里，我们可以清晰的看到，DisplayEventReceiver与SurfaceFlinger建立起来了一条跨进程传递事件的通道：BitTube中封装的socketpair (receive fd  & send fd)

---

4.4 事件的传递、分发

通信线路已建立，接下来就要把事件经过这条道路向外传递了。

上一篇文章中曾讲到过

收到vsync events的汇集到了两个地方：

1. MessageQueue::vsyncCallback  ==> VSYNC-sf

2. EventThread::onVSyncEvent  ==> VSYNC-app  & VSYNC-appSf

我们这里只看EventThread::onVSyncEvent

[/frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp]
void EventThread::onVSyncEvent(nsecs_t timestamp, nsecs_t expectedVSyncTimestamp,
                               nsecs_t deadlineTimestamp) {
    ...
    // 包装为 DisplayEventReceiver::Event对象，存入 mPendingEvents 尾部
    mPendingEvents.push_back(makeVSync(mVSyncState->displayId, timestamp, ++mVSyncState->count,
                                       expectedVSyncTimestamp, deadlineTimestamp, vsyncId));
    mCondition.notify_all();
}

EventThread收到 vsync event回调事件后，放入mPendingEvents这个待处理的事件队列中，然后唤醒等待的处理线程，即在EventThread::threadMain

[/frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp]
void EventThread::threadMain(std::unique_lock<std::mutex>& lock) {
    // using DisplayEventConsumers = std::vector<sp<EventThreadConnection>>;
    DisplayEventConsumers consumers; // consumers是一个EventThreadConnection数组

    while (mState != State::Quit) {
        std::optional<DisplayEventReceiver::Event> event;

        // Determine next event to dispatch.
        if (!mPendingEvents.empty()) {
            event = mPendingEvents.front(); // 取出 mPendingEvents 头部第一个待处理的 event
            mPendingEvents.pop_front();     // 删除开头元素

            switch (event->header.type) { // 判断是什么类型的事件
                case DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG: // 热插拔事件
                    if (event->hotplug.connected && !mVSyncState) {
                        mVSyncState.emplace(event->header.displayId);
                    } else if (!event->hotplug.connected && mVSyncState &&
                               mVSyncState->displayId == event->header.displayId) {
                        mVSyncState.reset();
                    }
                    break;

                case DisplayEventReceiver::DISPLAY_EVENT_VSYNC: // VSYNC 事件
                    if (mInterceptVSyncsCallback) {
                        // mInterceptVSyncsCallback 是在SurfaceFlinger::initScheduler中createConnection时一路传递过来的
                        // 这个回调会通知到SurfaceFlinger
                        mInterceptVSyncsCallback(event->header.timestamp);
                    }
                    break;
            }
        }

        bool vsyncRequested = false;

        // Find connections that should consume this event.
        auto it = mDisplayEventConnections.begin(); // mDisplayEventConnections 中保存了所有与这个EventThread建立的连接
        while (it != mDisplayEventConnections.end()) { // 遍历所有Connection
            if (const auto connection = it->promote()) {
                vsyncRequested |= connection->vsyncRequest != VSyncRequest::None;//是否请求vsync

                if (event && shouldConsumeEvent(*event, connection)) { // 判断是否需要分发事件通知这个connection
                    consumers.push_back(connection);
                }

                ++it;
            } else {
                it = mDisplayEventConnections.erase(it);
            }
        }

        if (!consumers.empty()) {
            dispatchEvent(*event, consumers);// 分发事件，最终是使用BitTube发送数据，通知connection
            consumers.clear();
        }

        State nextState;
        if (mVSyncState && vsyncRequested) {
            // synthetic = True if VSYNC should be faked, e.g. when display is off. 屏幕关闭产生虚假的VSYNC
            nextState = mVSyncState->synthetic ? State::SyntheticVSync : State::VSync;
        } else {
            ALOGW_IF(!mVSyncState, "Ignoring VSYNC request while display is disconnected");
            nextState = State::Idle; // 进入Idle阻塞等待
        }

        if (mState != nextState) {
            if (mState == State::VSync) {
                mVSyncSource->setVSyncEnabled(false); // 关闭 vsync
            } else if (nextState == State::VSync) {
                mVSyncSource->setVSyncEnabled(true);  // 开启 vysnc ,作用于CallbackRepeater,循环去schedule next vsync
            }

            mState = nextState;
        }

        if (event) {
            continue;
        }

        // Wait for event or client registration/request.
        if (mState == State::Idle) {
            mCondition.wait(lock);
        } else {
            // Generate a fake VSYNC after a long timeout in case the driver stalls. When the
            // display is off, keep feeding clients at 60 Hz.
            const std::chrono::nanoseconds timeout =
                    mState == State::SyntheticVSync ? 16ms : 1000ms;
            if (mCondition.wait_for(lock, timeout) == std::cv_status::timeout) {
                if (mState == State::VSync) {
                    ALOGW("Faking VSYNC due to driver stall for thread %s", mThreadName);
                    std::string debugInfo = "VsyncSource debug info:\n";
                    mVSyncSource->dump(debugInfo);
                    // Log the debug info line-by-line to avoid logcat overflow
                    auto pos = debugInfo.find('\n');
                    while (pos != std::string::npos) {
                        ALOGW("%s", debugInfo.substr(0, pos).c_str());
                        debugInfo = debugInfo.substr(pos + 1);
                        pos = debugInfo.find('\n');
                    }
                }

                LOG_FATAL_IF(!mVSyncState);
                const auto now = systemTime(SYSTEM_TIME_MONOTONIC);
                const auto deadlineTimestamp = now + timeout.count();
                const auto expectedVSyncTime = deadlineTimestamp + timeout.count();
                const int64_t vsyncId = [&] {
                    if (mTokenManager != nullptr) {
                        return mTokenManager->generateTokenForPredictions(
                                {now, deadlineTimestamp, expectedVSyncTime});
                    }
                    return FrameTimelineInfo::INVALID_VSYNC_ID;
                }();
                mPendingEvents.push_back(makeVSync(mVSyncState->displayId, now,
                                                   ++mVSyncState->count, expectedVSyncTime,
                                                   deadlineTimestamp, vsyncId));
            }
        }
    }
}

EventThread::threadMain代码逻辑上也比较清晰，主体就是从mPendingEvents这个待处理的事件队列中取出event，让后经过判断处理后通知到对应的connections

本文作者@二的次方  2022-04-27 发布于博客园

简单说说

EventThread::shouldConsumeEvent

这个方法就如同它的名字，判断是否去消费这个事件，说白了就是判断这个事件是否要分发通知给指定的connection。

参数event就是当前发生的，准备分发的事件

参数connection就是客户端注册到EventThread中的connection，其中就包装了用于跨进程通信的BitTube对象

对于VSYNC事件，在这个函数中实现了setVsyncRate中设置的分发频率

[ /frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp]
bool EventThread::shouldConsumeEvent(const DisplayEventReceiver::Event& event,
                                     const sp<EventThreadConnection>& connection) const {
    const auto throttleVsync = [&] {
        return mThrottleVsyncCallback &&
                mThrottleVsyncCallback(event.vsync.expectedVSyncTimestamp, connection->mOwnerUid);
    };

    switch (event.header.type) {
        case DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG: // 热插拔事件
            return true;

        case DisplayEventReceiver::DISPLAY_EVENT_MODE_CHANGE: {// mode change事件
            return connection->mEventRegistration.test( //接收者设置了modeChanged标志才会分发
                    ISurfaceComposer::EventRegistration::modeChanged);
        }

        case DisplayEventReceiver::DISPLAY_EVENT_VSYNC: // VSYNC事件
            switch (connection->vsyncRequest) { // setVsyncRate设置分发的频率
                case VSyncRequest::None: // rate==0，不分发
                    return false;
                case VSyncRequest::SingleSuppressCallback:// requestNextVsync 有请求时case
                    connection->vsyncRequest = VSyncRequest::None;
                    return false;
                case VSyncRequest::Single: { // requestNextVsync 有请求时case
                    if (throttleVsync()) {
                        return false;
                    }
                    connection->vsyncRequest = VSyncRequest::SingleSuppressCallback;
                    return true;
                }
                case VSyncRequest::Periodic: // rate==1，周期性，每个VSYNC事件都分发通知
                    if (throttleVsync()) {
                        return false;
                    }
                    return true;
                default:
                    // We don't throttle vsync if the app set a vsync request rate
                    // since there is no easy way to do that and this is a very
                    // rare case
                    // 根据setVsyncRate设置分发的频率，周期性的计数，每connection->vsyncRequest个分发一个
                    return event.vsync.count % vsyncPeriod(connection->vsyncRequest) == 0;
            }

        case DisplayEventReceiver::DISPLAY_EVENT_FRAME_RATE_OVERRIDE:
            [[fallthrough]];
        case DisplayEventReceiver::DISPLAY_EVENT_FRAME_RATE_OVERRIDE_FLUSH: // frame rate override flush事件
            return connection->mEventRegistration.test(// 判断接收者设置了frameRateOverride标志才会分发
                    ISurfaceComposer::EventRegistration::frameRateOverride);

        default:
            return false;
    }
}

EventThread::dispatchEvent

当前面判断某一个事件应该分发出去后，接下来就是去实际把事件分发出去，通知到接收者了

最终的事件是通过调用EventThreadConnection::postEvent==> DisplayEventReceiver::sendEvents ==> gui::BitTube::sendObjects

BitTube跨进程通知到接收者

void EventThread::dispatchEvent(const DisplayEventReceiver::Event& event,
                                const DisplayEventConsumers& consumers) {
    // 注意：using DisplayEventConsumers = std::vector<sp<EventThreadConnection>>;
    // 从consumers数组中遍历EventThreadConnection
    for (const auto& consumer : consumers) {
        DisplayEventReceiver::Event copy = event;
        if (event.header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
            copy.vsync.frameInterval = mGetVsyncPeriodFunction(consumer->mOwnerUid);
        }
        switch (consumer->postEvent(copy)) { // postEvent分发事件==>EventThreadConnection::postEvent
            ...
        }
    }
}

DispSyncSource::setVSyncEnabled

这个方法去call mRegistration.schedule  == > VSyncCallbackRegistration::schedule 去安排下一次的Vsync events

大概如此，从而周期性的收到vsync events ,  不多讲了

---

经过上面流程的分析，事件通过BitTube::sendObjects跨进程通知到接收者，接收者通过监听BitTube::mReceiveFd，并在接收到事件时调用BitTube::recvObjects就可以取出事件，做后续处理了

总结一个不是很准确的图，我也不知道该咋表达了，哈