Android VSync事件分发过程源码分析

在上一篇文章Android
VSync信号产生过程源码分析中分别介绍了VSync的两种产生方式，无论是通过硬件中断产生还是通过软件模拟产生，VSync事件最终都会交给EventThread线程来分发给所有VSync事件接收者。VSync事件接收者有很多，SurfaceFlinger就是其中一个重要的VSync事件接收者。那么EventThread线程是如何知道该将VSync分发给谁呢？EventThread线程有是如何将VSync事件分发给所有VSync事件接收者的呢？本文就针对这两个问题展开分析。我们知道VSync事件是由EventThread线程分发，而VSync事件接收者可能与EventThread线程同属一个进程，也可能分属不同的进程，这里就设计跨进程通信了，Android对VSync事件的分发采用Socket通信方式。



EventThread线程分发VSync事件

事件连接创建过程

对VSYNC等事件感兴趣的对象，比如MessageQueue，首先要通过EventThread::createEventConnection()来建立一个连接，实际上就是生成了一个EventThread::Connection对象，Connection只是双方业务上连接，而BitTube则是数据传输通道。

sp<EventThread::Connection> EventThread::createEventConnection() const {
return new Connection(const_cast<EventThread*>(this));
}

这里只是简单地构造一个Connection对象，Connection对象的构造过程如下：

EventThread::Connection::Connection(const sp<EventThread>& eventThread)
: count(-1), mEventThread(eventThread), mChannel(new BitTube())
{
}

在构造Connection对象时，构造了一个BitTube对象来初始化Connection对象的成员变量mChannel，从上图可以看出，BitTube类只是对Socket通信方式的封装，BitTube对象的构造过程如下：

BitTube::BitTube(): mSendFd(-1), mReceiveFd(-1)
{
int sockets[2];
if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets) == 0) {
int size = SOCKET_BUFFER_SIZE;
setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
fcntl(sockets[0], F_SETFL, O_NONBLOCK);
fcntl(sockets[1], F_SETFL, O_NONBLOCK);
mReceiveFd = sockets[0];
mSendFd = sockets[1];
} else {
mReceiveFd = -errno;
ALOGE("BitTube: pipe creation failed (%s)", strerror(-mReceiveFd));
}
}

事件连接注册过程

当Connection对象第一次被强引用时，自动调用onFirstRef()函数来初始化该对象。

void EventThread::Connection::onFirstRef() {
mEventThread->registerDisplayEventConnection(this);
}

在onFirstRef()函数里主动调用EventThread::registerDisplayEventConnection()把自己加入到EventThread的成员变量mDisplayEventConnections中，mDisplayEventConnections是一个向量类型，保存所有需要接收VSync信号的连接Connection，这样EventThread线程在分发VSync事件时，就知道将VSync事件分发给谁了。对VSYNC信号感兴趣的人，通过registerDisplayEventConnection()函数将连接Connection注册到EventThread中。

status_t EventThread::registerDisplayEventConnection(
const sp<EventThread::Connection>& connection) {
Mutex::Autolock _l(mLock);
//仅仅将注册的Connection添加到EventThread的成员变量mDisplayEventConnections中
mDisplayEventConnections.add(connection);
mCondition.broadcast();
return NO_ERROR;
}

EventThread的成员变量mDisplayEventConnections用于记录所有注册的Connection连接。

VSync事件分发过程

VSync事件最终在EventThread线程执行体threadLoop()中分发给各个监听者。

bool EventThread::threadLoop() {
nsecs_t timestamp;
DisplayEventReceiver::Event vsync;
//定义displayEventConnections向量，用于保存所有需要接收VSync事件的连接
Vector< wp<EventThread::Connection> > displayEventConnections;
do {
Mutex::Autolock _l(mLock);
//判断是否上报VSync
do {
// latch VSYNC event if any
timestamp = mVSyncTimestamp;
mVSyncTimestamp = 0;
//标示是否有客户端在等待VSync事件
bool waitForNextVsync = false;
size_t count = mDisplayEventConnections.size();
for (size_t i=0 ; i<count ; i++) {
sp<Connection> connection = mDisplayEventConnections.itemAt(i).promote();
// count >= 1 : continuous event. count is the vsync rate
// count == 0 : one-shot event that has not fired
// count ==-1 : one-shot event that fired this round / disabled
// count ==-2 : one-shot event that fired the round before
if (connection!=0 && connection->count >= 0) {
// at least one continuous mode or active one-shot event
waitForNextVsync = true;
break;
}
}
if (timestamp) {
if (!waitForNextVsync) {
//接收到VSync事件，但当前没有客户端需要接收VSync事件，所以关闭VSync事件源
disableVSyncLocked();
} else {
//如果有客户需要接收VSync事件，则跳出此循环，进入VSync事件分发阶段
break;
}
} else {
//等待接收VSync事件，并重新评估是否需要分发该事件或者是否需要关闭VSync事件源
if (waitForNextVsync) {
//如果有客户端需要接收VSync事件，则打开VSync事件源
enableVSyncLocked();
}
}
//等待VSync事件
if (mUseSoftwareVSync && waitForNextVsync) {
// h/w vsync cannot be used (screen is off), so we use
// a  timeout instead. it doesn't matter how imprecise this
// is, we just need to make sure to serve the clients
if (mCondition.waitRelative(mLock, ms2ns(16)) == TIMED_OUT) {
mVSyncTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
}
} else {
mCondition.wait(mLock);
}
} while(true);
//当需要分发VSync时，跳出上面的while循环，
mDeliveredEvents++;
mLastVSyncTimestamp = timestamp;
// now see if we still need to report this VSYNC event
const size_t count = mDisplayEventConnections.size();
//遍历已注册的所有Connection，将需要接收VSync的Connection添加到displayEventConnections向量中
for (size_t i=0 ; i<count ; i++) {
bool reportVsync = false;
sp<Connection> connection = mDisplayEventConnections.itemAt(i).promote();
//如果当前Connection已经死亡，则遍历下一个注册的Connection
if (connection == 0)
continue;
const int32_t count = connection->count;
if (count >= 1) {
if (count==1 || (mDeliveredEvents % count) == 0) {
// continuous event, and time to report it
reportVsync = true;
}
} else if (count >= -1) {
if (count == 0) {
// fired this time around
reportVsync = true;
}
connection->count--;
}
if (reportVsync) {
displayEventConnections.add(connection);
}
}
} while (!displayEventConnections.size());
//如果向量displayEventConnections的大小大于0，则将VSync信号分发给displayEventConnections中的Connection
//定义即将分发的VSync事件
vsync.header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
vsync.header.timestamp = timestamp;
vsync.vsync.count = mDeliveredEvents;
const size_t count = displayEventConnections.size();
//遍历displayEventConnections中的所有Connection
for (size_t i=0 ; i<count ; i++) {
sp<Connection> conn(displayEventConnections[i].promote());
// make sure the connection didn't die
if (conn != NULL) {
//发送VSync事件
status_t err = conn->postEvent(vsync);
if (err == -EAGAIN || err == -EWOULDBLOCK) {
//这两个错误是指对方当前不接受事件，有可能是事件已满，放弃这次操作，不作处理
} else if (err < 0) {
//事件发送错误，则从Connection注册列表mDisplayEventConnections中移除该Connection
removeDisplayEventConnection(displayEventConnections[i]);
}
} else {
//Connection为空，则从Connection注册列表mDisplayEventConnections中移除该Connection
removeDisplayEventConnection(displayEventConnections[i]);
}
}
//VSync事件分发完毕，清空displayEventConnections向量
displayEventConnections.clear();
return true;
}

在EventThread线程中，通过遍历连接注册列表mDisplayEventConnections，将VSync事件分发给已注册，并且需要接收VSync事件的Connection。调用各个Connection的postEvent()函数来发送一个VSync事件：

status_t EventThread::Connection::postEvent(const DisplayEventReceiver::Event& event) {
ssize_t size = DisplayEventReceiver::sendEvents(mChannel, &event, 1);
return size < 0 ? status_t(size) : status_t(NO_ERROR);
}

参数event描述的是一个VSync事件，Connection的成员变量mChannel指向BitTube对象，通过已创建的BitTube传输通道来发送VSync事件Event信息。

ssize_t DisplayEventReceiver::sendEvents(const sp<BitTube>& dataChannel,Event const* events, size_t count)
{
return BitTube::sendObjects(dataChannel, events, count);
}

调用BitTube类的sendObjects()函数来发送一个VSync事件信息

ssize_t BitTube::sendObjects(const sp<BitTube>& tube,void const* events, size_t count, size_t objSize)
{
ssize_t numObjects = 0;
for (size_t i=0 ; i<count ; i++) {
const char* vaddr = reinterpret_cast<const char*>(events) + objSize * i;
ssize_t size = tube->write(vaddr, objSize);
if (size < 0) {
// error occurred
return size;
} else if (size == 0) {
// no more space
break;
}
numObjects++;
}
return numObjects;
}

该函数可以发送多个事件对象，对于每一个事件对象的发送使用BitTube类的write()函数来完成。

ssize_t BitTube::write(void const* vaddr, size_t size)
{
ssize_t err, len;
do {
len = ::send(mSendFd, vaddr, size, MSG_DONTWAIT | MSG_NOSIGNAL);
err = len < 0 ? errno : 0;
} while (err == EINTR);
return err == 0 ? len : -err;
}

这里就采用BitTube对象中创建的Socket来发送一个事件信息。因此EventThread线程分发VSync事件是通过在Socket发送端mSendFd写入一个Event事件信息，这样对于监听在Socket接收端的VSync接收者就可以收到VSync事件信息Event了。