SurfaceFlinger Vsync初始化过程
DispVsync是软件Vsync的信号源， 是SurfaceFlinger中的一个变量，在SurfaceFlinger的init方法中会根据DispVsync初始化相关Vsync相关的变量。
void SurfaceFlinger::init() {
......
sp vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
vsyncPhaseOffsetNs, true, "app");
mEventThread = new EventThread(vsyncSrc);
sp sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
sfVsyncPhaseOffsetNs, true, "sf");
mSFEventThread = new EventThread(sfVsyncSrc);
mEventQueue.setEventThread(mSFEventThread);
.......
//如果HWC硬件有问题，就设置DispSync的周期模型为16.6ms
if (mHwc->initCheck() != NO_ERROR) {
mPrimaryDispSync.setPeriod(16666667);
}
}
SurfaceFlinger的init方法中,根据mPrimaryDispSync分别创建了app的DisplaySyncSource对象，和一个SF的DisplaySyncSource对象。然后根据App的DisplaySyncSource创建了一个App的EventThread，根据SF的DisplaySyncSource创建了一个SF的EventThread。
上一篇分析了软件Vsync产生过程，以及DispSyncSource。接着看下EventThread。
EventThread
EventThread::EventThread(const sp& src)
: mVSyncSource(src),
mUseSoftwareVSync(false),
mVsyncEnabled(false),
mDebugVsyncEnabled(false),
mVsyncHintSent(false) {
//初始化mVSyncEvent数组。
//mVSyncEvent数组中的每个数组成员都代表一个显示设备的Vsync事件。将这个事件timestamp初始化
for (int32_t i=0 ; i EventThread 创建对象后会触发onFirstRef方法，onFirstRef方法会触发线程run方法执行EventThread的threadloop方法。
bool EventThread::threadLoop() {
DisplayEventReceiver::Event event;
//初始化一个Connection列表
Vector< sp > signalConnections;
//等待事件到来，判断是否需要触发Connection回调，将需要触发的Connection放入Connection列表中
signalConnections = waitForEvent(&event);
// 分发事件给listener
const size_t count = signalConnections.size();
for (size_t i=0 ; i& conn(signalConnections[i]);
// 调用postEvent方法，将事件通知监听者
status_t err = conn->postEvent(event);
......
}
return true;
}
// 等待事件到来
Vector< sp > EventThread::waitForEvent(
DisplayEventReceiver::Event* event)
{
Mutex::Autolock _l(mLock);
Vector< sp > signalConnections;
do {
bool eventPending = false;
bool waitForVSync = false;
size_t vsyncCount = 0;
nsecs_t timestamp = 0;
//检测mVSyncEvent数组，查看检查具体设备是否有Vsync事件到来，mVSyncEvent[i].header.timestamp值不为0，则表示有新的Vsync事件
for (int32_t i=0 ; i connection(mDisplayEventConnections[i].promote());
if (connection != NULL) {
bool added = false;
//这里的connection->count的值的大小有如下含义
// count >= 1 : continuous event. count is the vsync rate 如果在大于等于1，表示会持续接收vsync event
// count == 0 : one-shot event that has not fired 表示只接收一次
// count ==-1 : one-shot event that fired this round / disabled 等于-1，表示不能再接收vsync事件了
if (connection->count >= 0) {
waitForVSync = true;
if (timestamp) {
// 只接收一次Vsync事件，接收到之后将count 设置为-1, 下次这个Connection便不在接收事件
if (connection->count == 0) {
connection->count = -1;
signalConnections.add(connection);
added = true;
} else if (connection->count == 1 ||
(vsyncCount % connection->count) == 0) {
// continuous event, and time to report it
signalConnections.add(connection);
added = true;
}
}
}
if (eventPending && !timestamp && !added) {
//添加到关注的Connection列表
signalConnections.add(connection);
}
} else {
// we couldn't promote this reference, the connection has
// died, so clean-up!
mDisplayEventConnections.removeAt(i);
--i; --count;
}
}
......
// 既没有vsync事件，也没有其它pending的事件(hotplug事件)
if (!timestamp && !eventPending) {
if (waitForVSync) {
bool softwareSync = mUseSoftwareVSync;
nsecs_t timeout = softwareSync ? ms2ns(16) : ms2ns(1000);
if (mCondition.waitRelative(mLock, timeout) == TIMED_OUT) {
if (!softwareSync) {
ALOGW("Timed out waiting for hw vsync; faking it");
}
//如果是driver的bug,如果硬件一直不上报vsync事件怎么办？？难道就一直等下去？？那client不就饿死了么？
//所以这里如果driver不报vsync，那么就软件模拟一个vsync事件，这里的timeout是1000ms，发一个
mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
mVSyncEvent[0].header.id = DisplayDevice::DISPLAY_PRIMARY;
mVSyncEvent[0].header.timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
mVSyncEvent[0].vsync.count++;
}
} else {
//既没有client, 又没有硬件vsync事件，那么就死等下去了
mCondition.wait(mLock);
}
}
//没有事件则就行检测消息或者等待
} while (signalConnections.isEmpty());
//返回关注消息的Connection
return signalConnections;
}
EventThread会开启一个线程，该线程用于等待Vsync事件或者hotplug事件。当有任何一个事件到来的时候，EventThread线程会收集所有关注该事件的连接，通过Connection连接通知所有关注该事件的监听者.
EventThread中维护了一个Connection类型的列表 mDisplayEventConnections，该列表中维护了所有关注EventThread事件的监听者，但是每次Vsync事件或者hotplug事件到来时，并不是每一个在该列表中的监听者都会关心此次事件，我们要做的就是从列表中找出关心此次事件的监听者，然后将消息传递给他.
但是，如何区分哪个Connection关心此次事件呢？
在每一个Connection中维护了一个count变量，该变量有三个取值。
- count >= 1 : continuous event. count is the vsync rate 如果在大于等于1，表示会持续接收vsync event
- count == 0 : one-shot event that has not fired 表示只接收一次，接收完这次事件以后就会将count修改成了-1
- count ==-1 : one-shot event that fired this round / disabled 等于-1，表示不能再接收vsync事件了
根据这三种类型，将count >=0的 Connection添加到Connection列表，然后统一发送消息，通知监听者。
count的值是什么时候修改呢？
就是在EventThread的requestNextVsync方法中.
void EventThread::requestNextVsync(
const sp& connection) {
Mutex::Autolock _l(mLock);
if (connection->count < 0) {
connection->count = 0;
mCondition.broadcast();
}
}
requstNextVsync表示请求接收下一次Vsync事件。在系统里APP和SurfaceFlinger都会利用该方法请求下一次Vsync到来的时候被叫起来做事情，也就是时候，虽然系统硬件每秒会有60个Vsync事件，但是并不代表软件Vsync每个Vsync都会做事情,也正是这样，Android系统根据软件Vsync来做事情，软件Vsync又是根据硬件Vsync样本来计算推测下一个Vsync的时间。
MessageQueue和Connection
SurfaceFlinger init初始化的时候，创建了两个EventThread，MessageQueue设置EventThread为SF的EventThread。代码如下
sp sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
sfVsyncPhaseOffsetNs, true, "sf");
mSFEventThread = new EventThread(sfVsyncSrc);
mEventQueue.setEventThread(mSFEventThread);
DisplaySyncThread和EventThread已经分析过了，直接看MessageQueue的setEventThread方法.
void MessageQueue::setEventThread(const sp& eventThread)
{
mEventThread = eventThread;
mEvents = eventThread->createEventConnection();
mEventTube = mEvents->getDataChannel();
mLooper->addFd(mEventTube->getFd(), 0, Looper::EVENT_INPUT,
MessageQueue::cb_eventReceiver, this);
}
int MessageQueue::eventReceiver(int /*fd*/, int /*events*/) {
ssize_t n;
DisplayEventReceiver::Event buffer[8];
while ((n = DisplayEventReceiver::getEvents(mEventTube, buffer, 8)) > 0) {
for (int i=0 ; idispatchInvalidate();
break;
}
}
}
return 1;
}
setEventThread做了什么工作？
1:调用SF EventThread的createEventConnection方法，创建MessageQueue和EventThread的连接，，表示MessageQueue是SF EventThread的监听者. 这个连接会创建一个Socket通信， EventThread端持有Socket Server端,MessageQueue持有Socket Client端.
2:获取mEvent的Socket的Client端，Socket创建在EventTube中，不在详细分析.
3:获取到Socket Client的文件描述符fd,添加到MessageQueue的Looper中进行监控.档EventThread发送通知消息的时候，回调cb_eventReceiver方法.
4:收到eventReceiver回调后，发送Handler消息给MessageQueue消息队列，由MessageQueue的handlerMessage调用SurfaceFlinger处理. 以前我们讲过,MessageQueue作为SurfaceFlinger的主线程，此时就交由SurfaceFliger主线程来处理合成了
总结
Vsync产生过程如上图:
1：HWC产生硬件Vsync信号，添加到DispSync样本中
2：DispSync计算周期和偏差，然后根据APP和SF设置的时间偏差，根据Vsync信号各自计算SF和APP Vsync回调时间.
3：DispSync通过VsyncSource通知了App 和 SF的EventThread线程
4：APP EventThread暂时不管， SF的EventThread收到消息后，收集对该Vsync事件感兴趣的监听者，发送消息命令，通过Connection Socket的服务端来通知客户端。
5：MessageQueue作为SF EventThread的监听者，和EventThread创建了Connection，监听了Connection Socket 客户端，监听消息。收到消息后通过Message的Handler发送到SF的主线程 MessageQueue消息队列中.
6:MessageQueue消息队列handleMessage处理消息，调用SF的invlidate来更新合成图像。
此时Vsync整个流程就简单分析完成了