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

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

Android VSync事件分发过程源码分析_第1张图片

EventThread线程分发VSync事件



事件连接创建过程


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

Android VSync事件分发过程源码分析_第2张图片

sp EventThread::createEventConnection() const {
    return new Connection(const_cast(this));
}
这里只是简单地构造一个Connection对象,Connection对象的构造过程如下:

EventThread::Connection::Connection(const sp& 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& 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 > 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 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 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 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& dataChannel,Event const* events, size_t count)
{
    return BitTube::sendObjects(dataChannel, events, count);
}
调用BitTube类的sendObjects()函数来发送一个VSync事件信息

ssize_t BitTube::sendObjects(const sp& tube,void const* events, size_t count, size_t objSize)
{
    ssize_t numObjects = 0;
    for (size_t i=0 ; i(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了。

Android VSync事件分发过程源码分析_第3张图片


你可能感兴趣的:(【Android,显示模块】)