Android 5.1 SurfaceFlinger --- Dispatching VSync events

surfaceflinger进程由init.rc启动：

service surfaceflinger /system/bin/surfaceflinger

接下来进到surfaceflinger的main()函数:

frameworks/native/services/surfaceflinger/main_surfaceflinger.cpp

int main(int, char**) {    // When SF is launched in its own process, limit the number of    // binder threads to 4.    ProcessState::self()->setThreadPoolMaxThreadCount(4);    // start the thread pool    sp<ProcessState> ps(ProcessState::self());    ps->startThreadPool();    // instantiate surfaceflinger    sp<SurfaceFlinger> flinger = new SurfaceFlinger();#if defined(HAVE_PTHREADS)    setpriority(PRIO_PROCESS, 0, PRIORITY_URGENT_DISPLAY);#endif    set_sched_policy(0, SP_FOREGROUND);    // initialize before clients can connect    flinger->init();    // publish surface flinger    sp<IServiceManager> sm(defaultServiceManager());    sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false);    // run in this thread    flinger->run();    return 0;}

首先设置surfaceflinger进程的Binder线程数量为4，进程优先级是PRIORITY_URGENT_DISPLAY，这个优先级的设置在Display系统的很多地方都能看到。与此同时，创建了一个SurfaceFlinger对象，调用了对应的init()函数，将surfaceflinger注册到ServiceManager中去，并启动surfaceflinger线程。

其中的初始化操作在init()中：

void SurfaceFlinger::init() {    ALOGI(  "SurfaceFlinger's main thread ready to run. "            "Initializing graphics H/W...");    status_t err;    Mutex::Autolock _l(mStateLock);    /* Set the mask bit of the sigset to block the SIGPIPE signal */    sigset_t sigMask;    sigemptyset (&sigMask);    sigaddset(&sigMask, SIGPIPE);    sigprocmask(SIG_BLOCK, &sigMask, NULL);    // initialize EGL for the default display    mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);    eglInitialize(mEGLDisplay, NULL, NULL);    // Initialize the H/W composer object.  There may or may not be an    // actual hardware composer underneath.    mHwc = new HWComposer(this,            *static_cast<HWComposer::EventHandler *>(this));    // get a RenderEngine for the given display / config (can't fail)    mRenderEngine = RenderEngine::create(mEGLDisplay, mHwc->getVisualID());    // retrieve the EGL context that was selected/created    mEGLContext = mRenderEngine->getEGLContext();    LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,            "couldn't create EGLContext");    // initialize our non-virtual displays    for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {        DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);        // set-up the displays that are already connected        if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {            // query from hwc if the non-virtual display is secure.            bool isSecure = mHwc->isSecure(i);;            createBuiltinDisplayLocked(type, isSecure);            wp<IBinder> token = mBuiltinDisplays[i];            sp<IGraphicBufferProducer> producer;            sp<IGraphicBufferConsumer> consumer;            BufferQueue::createBufferQueue(&producer, &consumer,                    new GraphicBufferAlloc());            sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,                    consumer);            int32_t hwcId = allocateHwcDisplayId(type);            sp<DisplayDevice> hw = new DisplayDevice(this,                    type, hwcId, mHwc->getFormat(hwcId), isSecure, token,                    fbs, producer,                    mRenderEngine->getEGLConfig());            if (i > DisplayDevice::DISPLAY_PRIMARY) {                // FIXME: currently we don't get blank/unblank requests                // for displays other than the main display, so we always                // assume a connected display is unblanked.                ALOGD("marking display %zu as acquired/unblanked", i);                hw->setPowerMode(HWC_POWER_MODE_NORMAL);            }            mDisplays.add(token, hw);        }    }    // make the GLContext current so that we can create textures when creating Layers    // (which may happens before we render something)    getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);    // start the EventThread    sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,            vsyncPhaseOffsetNs, true, "app");    mEventThread = new EventThread(vsyncSrc);    sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,            sfVsyncPhaseOffsetNs, true, "sf");    mSFEventThread = new EventThread(sfVsyncSrc);    mEventQueue.setEventThread(mSFEventThread);    mEventControlThread = new EventControlThread(this);    mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);    // set a fake vsync period if there is no HWComposer    if (mHwc->initCheck() != NO_ERROR) {        mPrimaryDispSync.setPeriod(16666667);    }    // initialize our drawing state    mDrawingState = mCurrentState;    // set initial conditions (e.g. unblank default device)    initializeDisplays();    // start boot animation    startBootAnim();}

一步步来看：

    // Initialize the H/W composer object.  There may or may not be an    // actual hardware composer underneath.    mHwc = new HWComposer(this,            *static_cast<HWComposer::EventHandler *>(this));

初始化HWComposer，封装了厂商的HAL层实现，来看看它的构造函数：

frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp

HWComposer::HWComposer(        const sp<SurfaceFlinger>& flinger,        EventHandler& handler)    : mFlinger(flinger),      mFbDev(0), mHwc(0), mNumDisplays(1),      mCBContext(new cb_context),      mEventHandler(handler),      mDebugForceFakeVSync(false),      mVDSEnabled(false){    for (size_t i =0 ; i<MAX_HWC_DISPLAYS ; i++) {        mLists[i] = 0;    }    for (size_t i=0 ; i<HWC_NUM_PHYSICAL_DISPLAY_TYPES ; i++) {        mLastHwVSync[i] = 0;        mVSyncCounts[i] = 0;    }    char value[PROPERTY_VALUE_MAX];    property_get("debug.sf.no_hw_vsync", value, "0");    mDebugForceFakeVSync = atoi(value);    bool needVSyncThread = true;    // Note: some devices may insist that the FB HAL be opened before HWC.    int fberr = loadFbHalModule();    loadHwcModule();    if (mFbDev && mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {        // close FB HAL if we don't needed it.        // FIXME: this is temporary until we're not forced to open FB HAL        // before HWC.        framebuffer_close(mFbDev);        mFbDev = NULL;    }    // If we have no HWC, or a pre-1.1 HWC, an FB dev is mandatory.    if ((!mHwc || !hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))            && !mFbDev) {        ALOGE("ERROR: failed to open framebuffer (%s), aborting",                strerror(-fberr));        abort();    }    // these display IDs are always reserved    for (size_t i=0 ; i<NUM_BUILTIN_DISPLAYS ; i++) {        mAllocatedDisplayIDs.markBit(i);    }    if (mHwc) {        ALOGI("Using %s version %u.%u", HWC_HARDWARE_COMPOSER,              (hwcApiVersion(mHwc) >> 24) & 0xff,              (hwcApiVersion(mHwc) >> 16) & 0xff);        if (mHwc->registerProcs) {            mCBContext->hwc = this;            mCBContext->procs.invalidate = &hook_invalidate;            mCBContext->procs.vsync = &hook_vsync;            if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))                mCBContext->procs.hotplug = &hook_hotplug;            else                mCBContext->procs.hotplug = NULL;            memset(mCBContext->procs.zero, 0, sizeof(mCBContext->procs.zero));            mHwc->registerProcs(mHwc, &mCBContext->procs);        }        // don't need a vsync thread if we have a hardware composer        needVSyncThread = false;        // always turn vsync off when we start        eventControl(HWC_DISPLAY_PRIMARY, HWC_EVENT_VSYNC, 0);        // the number of displays we actually have depends on the        // hw composer version        if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {            // 1.3 adds support for virtual displays            mNumDisplays = MAX_HWC_DISPLAYS;        } else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {            // 1.1 adds support for multiple displays            mNumDisplays = NUM_BUILTIN_DISPLAYS;        } else {            mNumDisplays = 1;        }    }    if (mFbDev) {        ALOG_ASSERT(!(mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)),                "should only have fbdev if no hwc or hwc is 1.0");        DisplayData& disp(mDisplayData[HWC_DISPLAY_PRIMARY]);        disp.connected = true;        disp.format = mFbDev->format;        DisplayConfig config = DisplayConfig();        config.width = mFbDev->width;        config.height = mFbDev->height;        config.xdpi = mFbDev->xdpi;        config.ydpi = mFbDev->ydpi;        config.secure = true; //XXX: Assuming primary is always true        config.refresh = nsecs_t(1e9 / mFbDev->fps);        disp.configs.push_back(config);        disp.currentConfig = 0;    } else if (mHwc) {        // here we're guaranteed to have at least HWC 1.1        for (size_t i =0 ; i<NUM_BUILTIN_DISPLAYS ; i++) {            queryDisplayProperties(i);        }    }    // read system property for VDS solution    // This property is expected to be setup once during bootup    if( (property_get("persist.hwc.enable_vds", value, NULL) > 0) &&        ((!strncmp(value, "1", strlen("1"))) ||        !strncasecmp(value, "true", strlen("true")))) {        //HAL virtual display is using VDS based implementation        mVDSEnabled = true;    }    if (needVSyncThread) {        // we don't have VSYNC support, we need to fake it        mVSyncThread = new VSyncThread(*this);    }#ifdef QCOM_BSP    // Threshold Area to enable GPU Tiled Rect.    property_get("debug.hwc.gpuTiledThreshold", value, "1.9");    mDynThreshold = atof(value);#endif}

一开始做了一些初始化操作，然后加载对应的HAL，对应函数loadHwcModule()：

// Load and prepare the hardware composer module.  Sets mHwc.void HWComposer::loadHwcModule(){    hw_module_t const* module;    if (hw_get_module(HWC_HARDWARE_MODULE_ID, &module) != 0) {        ALOGE("%s module not found", HWC_HARDWARE_MODULE_ID);        return;    }    int err = hwc_open_1(module, &mHwc);    if (err) {        ALOGE("%s device failed to initialize (%s)",              HWC_HARDWARE_COMPOSER, strerror(-err));        return;    }    if (!hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_0) ||            hwcHeaderVersion(mHwc) < MIN_HWC_HEADER_VERSION ||            hwcHeaderVersion(mHwc) > HWC_HEADER_VERSION) {        ALOGE("%s device version %#x unsupported, will not be used",              HWC_HARDWARE_COMPOSER, mHwc->common.version);        hwc_close_1(mHwc);        mHwc = NULL;        return;    }}

实现并不复杂，只是获取到HWComposer对应的hw_module_t结构体，并对老版本做了兼容，mHwc保存真正的HWComposer对象，作为返回结果供接下来的调用使用。

回到SurfaceFlinger的init()函数，继续往下走：

if (mHwc) {    ALOGI("Using %s version %u.%u", HWC_HARDWARE_COMPOSER,          (hwcApiVersion(mHwc) >> 24) & 0xff,          (hwcApiVersion(mHwc) >> 16) & 0xff);    if (mHwc->registerProcs) {        mCBContext->hwc = this;        mCBContext->procs.invalidate = &hook_invalidate;        mCBContext->procs.vsync = &hook_vsync;        if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))            mCBContext->procs.hotplug = &hook_hotplug;        else            mCBContext->procs.hotplug = NULL;        memset(mCBContext->procs.zero, 0, sizeof(mCBContext->procs.zero));        mHwc->registerProcs(mHwc, &mCBContext->procs);    }    ......}

首先判断mHwc->registerProcs是否为空，这是一个函数指针，可以到HAL层的实现里去查找：

hardware/qcom/display/msm8974/libhwcomposer/hwc.cpp(cm-12.1)

static int hwc_device_open(const struct hw_module_t* module, const char* name,                           struct hw_device_t** device){    int status = -EINVAL;    if (!strcmp(name, HWC_HARDWARE_COMPOSER)) {        struct hwc_context_t *dev;        dev = (hwc_context_t*)malloc(sizeof(*dev));        if(dev == NULL)            return status;        memset(dev, 0, sizeof(*dev));        //Initialize hwc context        status = initContext(dev);        if (status < 0) {            free(dev);            return status;        }        //Setup HWC methods        dev->device.common.tag          = HARDWARE_DEVICE_TAG;        dev->device.common.version      = HWC_DEVICE_API_VERSION_1_4;        dev->device.common.module       = const_cast<hw_module_t*>(module);        dev->device.common.close        = hwc_device_close;        dev->device.prepare             = hwc_prepare;        dev->device.set                 = hwc_set;        dev->device.eventControl        = hwc_eventControl;        dev->device.setPowerMode        = hwc_setPowerMode;        dev->device.query               = hwc_query;        dev->device.registerProcs       = hwc_registerProcs;        dev->device.dump                = hwc_dump;        dev->device.getDisplayConfigs   = hwc_getDisplayConfigs;        dev->device.getDisplayAttributes = hwc_getDisplayAttributes;        dev->device.getActiveConfig     = hwc_getActiveConfig;        dev->device.setActiveConfig     = hwc_setActiveConfig;        *device = &dev->device.common;        status = 0;    }    return status;}

可以看到hwc_composer_device_1里定义了很多函数指针，有eventControl，registerProcs，getDisplayConfigs等等，这样可以SurfaceFlinger可以通过预先规定好的接口，调用HAL层里的具体实现。

回到HWComposer::init()，很显然这里mHwc->registerProcs不为空，实际上指向了HAL层的hwc_registerProcs()：

if (mHwc) {    ALOGI("Using %s version %u.%u", HWC_HARDWARE_COMPOSER,          (hwcApiVersion(mHwc) >> 24) & 0xff,          (hwcApiVersion(mHwc) >> 16) & 0xff);    if (mHwc->registerProcs) {        mCBContext->hwc = this;        mCBContext->procs.invalidate = &hook_invalidate;        mCBContext->procs.vsync = &hook_vsync;        if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))            mCBContext->procs.hotplug = &hook_hotplug;        else            mCBContext->procs.hotplug = NULL;        memset(mCBContext->procs.zero, 0, sizeof(mCBContext->procs.zero));        mHwc->registerProcs(mHwc, &mCBContext->procs);    }    ......}

这两句比较有意思，看到后面可以发现这其实就是注册了vsync发生时的回调，在hwcomposer得到硬件发来的vsync，然后做进一步处理：

mCBContext->procs.vsync = &hook_vsync;mHwc->registerProcs(mHwc, &mCBContext->procs);

那我们去hwc_registerProcs()里看看：

hardware/qcom/display/msm8974/libhwcomposer/hwc.cpp(cm-12.1)

/* * Save callback functions registered to HWC */static void hwc_registerProcs(struct hwc_composer_device_1* dev,                              hwc_procs_t const* procs){    ALOGI("%s", __FUNCTION__);    hwc_context_t* ctx = (hwc_context_t*)(dev);    if(!ctx) {        ALOGE("%s: Invalid context", __FUNCTION__);        return;    }    ctx->proc = procs;    // Now that we have the functions needed, kick off    // the uevent & vsync threads    init_uevent_thread(ctx);    init_vsync_thread(ctx);}

先看看init_vsync_thread()函数：

hardware/qcom/display/msm8974/libhwcomposer/hwc_vsync.cpp

void init_vsync_thread(hwc_context_t* ctx){    int ret;    pthread_t vsync_thread;    ALOGI("Initializing VSYNC Thread");    ret = pthread_create(&vsync_thread, NULL, vsync_loop, (void*) ctx);    if (ret) {        ALOGE("%s: failed to create %s: %s", __FUNCTION__,              HWC_VSYNC_THREAD_NAME, strerror(ret));    }}

逻辑也比较简单，vsync_loop函数指针作为参数，创建了一个新的pthread，可以想到这个线程应该就是vsync发送线程，那就看看vsync_loop()函数：

hardware/qcom/display/msm8974/libhwcomposer/hwc_vsync.cpp

static void *vsync_loop(void *param){    hwc_context_t * ctx = reinterpret_cast<hwc_context_t *>(param);    char thread_name[64] = HWC_VSYNC_THREAD_NAME;    prctl(PR_SET_NAME, (unsigned long) &thread_name, 0, 0, 0);    setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY +                android::PRIORITY_MORE_FAVORABLE);    const int MAX_DATA = 64;    char vdata[MAX_DATA];    bool logvsync = false;    struct pollfd pfd[2];    int fb_fd[2];    uint64_t timestamp[2];    int num_displays;    char property[PROPERTY_VALUE_MAX];    if(property_get("debug.hwc.fakevsync", property, NULL) > 0) {        if(atoi(property) == 1)            ctx->vstate.fakevsync = true;    }    if(property_get("debug.hwc.logvsync", property, 0) > 0) {        if(atoi(property) == 1)            logvsync = true;    }    if (ctx->mExtDisplay->getHDMIIndex() > 0)        num_displays = 2;    else        num_displays = 1;    char vsync_node_path[MAX_SYSFS_FILE_PATH];    for (int dpy = HWC_DISPLAY_PRIMARY; dpy < num_displays; dpy++) {        snprintf(vsync_node_path, sizeof(vsync_node_path),                "/sys/class/graphics/fb%d/vsync_event",                dpy == HWC_DISPLAY_PRIMARY ? 0 :                ctx->mExtDisplay->getHDMIIndex());        ALOGI("%s: Reading vsync for dpy=%d from %s", __FUNCTION__, dpy,                vsync_node_path);        fb_fd[dpy] = open(vsync_node_path, O_RDONLY);        if (fb_fd[dpy] < 0) {            // Make sure fb device is opened before starting this thread so this            // never happens.            ALOGE ("%s:not able to open vsync node for dpy=%d, %s",                    __FUNCTION__, dpy, strerror(errno));            if (dpy == HWC_DISPLAY_PRIMARY) {                ctx->vstate.fakevsync = true;                break;            }        }        // Read once from the fds to clear the first notify        pread(fb_fd[dpy], vdata , MAX_DATA, 0);        pfd[dpy].fd = fb_fd[dpy];        if (pfd[dpy].fd >= 0)            pfd[dpy].events = POLLPRI | POLLERR;    }    if (LIKELY(!ctx->vstate.fakevsync)) {        do {            int err = poll(pfd, num_displays, -1);            if(err > 0) {                for (int dpy = HWC_DISPLAY_PRIMARY; dpy < num_displays; dpy++) {                    if (pfd[dpy].revents & POLLPRI) {                        int len = pread(pfd[dpy].fd, vdata, MAX_DATA, 0);                        if (UNLIKELY(len < 0)) {                            // If the read was just interrupted - it is not a                            // fatal error. Just continue in this case                            ALOGE ("%s: Unable to read vsync for dpy=%d : %s",                                    __FUNCTION__, dpy, strerror(errno));                            continue;                        }                        // extract timestamp                        if (!strncmp(vdata, "VSYNC=", strlen("VSYNC="))) {                            timestamp[dpy] = strtoull(vdata + strlen("VSYNC="),                                    NULL, 0);                        }                        // send timestamp to SurfaceFlinger                        ALOGD_IF (logvsync,                                "%s: timestamp %llu sent to SF for dpy=%d",                                __FUNCTION__, timestamp[dpy], dpy);                        ctx->proc->vsync(ctx->proc, dpy, timestamp[dpy]);                    }                }            } else {                ALOGE("%s: vsync poll failed errno: %s", __FUNCTION__,                        strerror(errno));                continue;            }        } while (true);    } else {        //Fake vsync is used only when set explicitly through a property or when        //the vsync timestamp node cannot be opened at bootup. There is no        //fallback to fake vsync from the true vsync loop, ever, as the        //condition can easily escape detection.        //Also, fake vsync is delivered only for the primary display.        do {            usleep(16666);            timestamp[HWC_DISPLAY_PRIMARY] = systemTime();            ctx->proc->vsync(ctx->proc, HWC_DISPLAY_PRIMARY,                    timestamp[HWC_DISPLAY_PRIMARY]);        } while (true);    }    for (int dpy = HWC_DISPLAY_PRIMARY; dpy <= HWC_DISPLAY_EXTERNAL; dpy++ ) {        if(fb_fd[dpy] >= 0)            close (fb_fd[dpy]);    }    return NULL;}

值得一提的是，这个loop线程同样设置了线程的优先级：

    setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY +                android::PRIORITY_MORE_FAVORABLE);

这个函数的逻辑也很清晰：等待vsync消息然后分发给每个display，调用callback：

                for (int dpy = HWC_DISPLAY_PRIMARY; dpy < num_displays; dpy++) {                    if (pfd[dpy].revents & POLLPRI) {                        int len = pread(pfd[dpy].fd, vdata, MAX_DATA, 0);                        if (UNLIKELY(len < 0)) {                            // If the read was just interrupted - it is not a                            // fatal error. Just continue in this case                            ALOGE ("%s: Unable to read vsync for dpy=%d : %s",                                    __FUNCTION__, dpy, strerror(errno));                            continue;                        }                        // extract timestamp                        if (!strncmp(vdata, "VSYNC=", strlen("VSYNC="))) {                            timestamp[dpy] = strtoull(vdata + strlen("VSYNC="),                                    NULL, 0);                        }                        // send timestamp to SurfaceFlinger                        ALOGD_IF (logvsync,                                "%s: timestamp %llu sent to SF for dpy=%d",                                __FUNCTION__, timestamp[dpy], dpy);                        ctx->proc->vsync(ctx->proc, dpy, timestamp[dpy]);                    }                }

也就是在vsync event到来的时候，通过HAL层把事件传递给了hwcomposer对象。

于是我们回到HWComposer里，看看ctx->proc->vsync()也就是hook_vsync()的实现：

void HWComposer::hook_vsync(const struct hwc_procs* procs, int disp,        int64_t timestamp) {    cb_context* ctx = reinterpret_cast<cb_context*>(            const_cast<hwc_procs_t*>(procs));    ctx->hwc->vsync(disp, timestamp);}void HWComposer::vsync(int disp, int64_t timestamp) {    if (uint32_t(disp) < HWC_NUM_PHYSICAL_DISPLAY_TYPES) {        {            Mutex::Autolock _l(mLock);            // There have been reports of HWCs that signal several vsync events            // with the same timestamp when turning the display off and on. This            // is a bug in the HWC implementation, but filter the extra events            // out here so they don't cause havoc downstream.            if (timestamp == mLastHwVSync[disp]) {                ALOGW("Ignoring duplicate VSYNC event from HWC (t=%" PRId64 ")",                        timestamp);                return;            }            mLastHwVSync[disp] = timestamp;        }        char tag[16];        snprintf(tag, sizeof(tag), "HW_VSYNC_%1u", disp);        ATRACE_INT(tag, ++mVSyncCounts[disp] & 1);        mEventHandler.onVSyncReceived(disp, timestamp);    }}

最关键的还是最后一句，mEventHandler其实就是HWComposer构造时候传进来的SurfaceFlinger对象，SurfaceFlinger继承了HWComposer::EventHandler，实现了onVsyncReceived()接口:

        mEventHandler.onVSyncReceived(disp, timestamp);

void SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) {    bool needsHwVsync = false;    { // Scope for the lock        Mutex::Autolock _l(mHWVsyncLock);        if (type == 0 && mPrimaryHWVsyncEnabled) {            needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);        }    }    if (needsHwVsync) {        enableHardwareVsync();    } else {        disableHardwareVsync(false);    }}

SurfaceFlinger::onVSyncReceived对vsync事件做出响应，这里先不继续讨论。创建完HWComposer对象，回到SurfaceFlinger的init()函数，接下来创建一系列显示设备对象，并启动了两个EventThread：

    // start the EventThread    sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,            vsyncPhaseOffsetNs, true, "app");    mEventThread = new EventThread(vsyncSrc);    sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,            sfVsyncPhaseOffsetNs, true, "sf");    mSFEventThread = new EventThread(sfVsyncSrc);    mEventQueue.setEventThread(mSFEventThread);

这里传入参数mPrimaryDispSync创建了两个虚拟的vsync源，分别名叫”VSYNC-app”和”VSYNC-sf”，其实不用查看代码，从systrace里我们就能很直观地看到这两个名称的线程。

先看看mPrimaryDispSync是起什么作用的，它是SurfaceFlinger的一个成员变量：

    DispSync mPrimaryDispSync;

创建SurfaceFlinger对象的时候没有对mPrimaryDispSync进行显式初始化，因此调用默认的构造函数：

DispSync::DispSync() :        mRefreshSkipCount(0),        mThread(new DispSyncThread()) {    mThread->run("DispSync", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);    reset();    beginResync();    if (kTraceDetailedInfo) {        // If we're not getting present fences then the ZeroPhaseTracer        // would prevent HW vsync event from ever being turned off.        // Even if we're just ignoring the fences, the zero-phase tracing is        // not needed because any time there is an event registered we will        // turn on the HW vsync events.        if (!kIgnorePresentFences) {            addEventListener(0, new ZeroPhaseTracer());        }    }}

很显然，在它构造的时候就会启动一个类型为DispSyncThread的新的线程mThread，调用mThread->run()实际上是创建了一个新的进程，并在这个线程内执行DispSyncThread的threadLoop()函数：

    virtual bool threadLoop() {        status_t err;        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);        nsecs_t nextEventTime = 0;        while (true) {            Vector<CallbackInvocation> callbackInvocations;            nsecs_t targetTime = 0;            { // Scope for lock                Mutex::Autolock lock(mMutex);                if (mStop) {                    return false;                }                if (mPeriod == 0) {                    err = mCond.wait(mMutex);                    if (err != NO_ERROR) {                        ALOGE("error waiting for new events: %s (%d)",                                strerror(-err), err);                        return false;                    }                    continue;                }                nextEventTime = computeNextEventTimeLocked(now);                targetTime = nextEventTime;                bool isWakeup = false;                if (now < targetTime) {                    err = mCond.waitRelative(mMutex, targetTime - now);                    if (err == TIMED_OUT) {                        isWakeup = true;                    } else if (err != NO_ERROR) {                        ALOGE("error waiting for next event: %s (%d)",                                strerror(-err), err);                        return false;                    }                }                now = systemTime(SYSTEM_TIME_MONOTONIC);                if (isWakeup) {                    mWakeupLatency = ((mWakeupLatency * 63) +                            (now - targetTime)) / 64;                    if (mWakeupLatency > 500000) {                        // Don't correct by more than 500 us                        mWakeupLatency = 500000;                    }                    if (kTraceDetailedInfo) {                        ATRACE_INT64("DispSync:WakeupLat", now - nextEventTime);                        ATRACE_INT64("DispSync:AvgWakeupLat", mWakeupLatency);                    }                }                callbackInvocations = gatherCallbackInvocationsLocked(now);            }            if (callbackInvocations.size() > 0) {                fireCallbackInvocations(callbackInvocations);            }        }        return false;    }

其中的主要内容是在计算时间，决定信号是否到来，该进行下一步操作，否则就在mCond上等待：

   err = mCond.waitRelative(mMutex, targetTime - now);

那什么时候唤醒它呢？这就是前面提到的SurfaceFlinger::onVSyncReceived():

void SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) {    bool needsHwVsync = false;    { // Scope for the lock        Mutex::Autolock _l(mHWVsyncLock);        if (type == 0 && mPrimaryHWVsyncEnabled) {            needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);        }    }    if (needsHwVsync) {        enableHardwareVsync();    } else {        disableHardwareVsync(false);    }}

其中mPrimaryDispSync.addResyncSample()在满足特定条件下会调用updateModelLocked()：

frameworks/native/services/surfaceflinger/DispSync.cpp

bool DispSync::addResyncSample(nsecs_t timestamp) {    ...    updateModelLocked();    ...}

并调用DispSync::updateModelLocked()：

frameworks/native/services/surfaceflinger/DispSync.cpp

void DispSync::updateModelLocked() {        ...        mThread->updateModel(mPeriod, mPhase);        ...}

最终DispSyncThread:updateModel()，唤醒线程:

void updateModel(nsecs_t period, nsecs_t phase) {    Mutex::Autolock lock(mMutex);    mPeriod = period;    mPhase = phase;    mCond.signal();}

唤醒后，获取需要所有Listeners的回调列表

    callbackInvocations = gatherCallbackInvocationsLocked(now);

frameworks/native/services/surfaceflinger/DispSync.cpp

    Vector<CallbackInvocation> gatherCallbackInvocationsLocked(nsecs_t now) {        Vector<CallbackInvocation> callbackInvocations;        nsecs_t ref = now - mPeriod;        for (size_t i = 0; i < mEventListeners.size(); i++) {            nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i],                    ref);            if (t < now) {                CallbackInvocation ci;                ci.mCallback = mEventListeners[i].mCallback;                ci.mEventTime = t;                callbackInvocations.push(ci);                mEventListeners.editItemAt(i).mLastEventTime = t;            }        }        return callbackInvocations;    }

从这段代码里不难看出，从mEventListeners里找出合适的listener，封装成CallbackInvocation对象并作为返回值返回。

这时候有一个疑问，这些listener是什么时候加到mEventListeners里去的。答案是创建EventThread的时候。

    // start the EventThread    sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,            vsyncPhaseOffsetNs, true, "app");    mEventThread = new EventThread(vsyncSrc);    sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,            sfVsyncPhaseOffsetNs, true, "sf");    mSFEventThread = new EventThread(sfVsyncSrc);    mEventQueue.setEventThread(mSFEventThread);

mEventThread和mSFEventThread均是强指针，因此在第一次引用的时候会调用：

void EventThread::onFirstRef() {    run("EventThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);}

新启动一个名为EventThread的线程：

bool EventThread::threadLoop() {    DisplayEventReceiver::Event event;    Vector< sp<EventThread::Connection> > signalConnections;    signalConnections = waitForEvent(&event);    // dispatch events to listeners...    const size_t count = signalConnections.size();    for (size_t i=0 ; i<count ; i++) {        const sp<Connection>& conn(signalConnections[i]);        // now see if we still need to report this event        status_t err = conn->postEvent(event);        if (err == -EAGAIN || err == -EWOULDBLOCK) {            // The destination doesn't accept events anymore, it's probably            // full. For now, we just drop the events on the floor.            // FIXME: Note that some events cannot be dropped and would have            // to be re-sent later.            // Right-now we don't have the ability to do this.            ALOGW("EventThread: dropping event (%08x) for connection %p",                    event.header.type, conn.get());        } else if (err < 0) {            // handle any other error on the pipe as fatal. the only            // reasonable thing to do is to clean-up this connection.            // The most common error we'll get here is -EPIPE.            removeDisplayEventConnection(signalConnections[i]);        }    }    return true;}

EventThread::waitForEvent()函数：

        // Here we figure out if we need to enable or disable vsyncs        if (timestamp && !waitForVSync) {            // we received a VSYNC but we have no clients            // don't report it, and disable VSYNC events            disableVSyncLocked();        } else if (!timestamp && waitForVSync) {            // we have at least one client, so we want vsync enabled            // (TODO: this function is called right after we finish            // notifying clients of a vsync, so this call will be made            // at the vsync rate, e.g. 60fps.  If we can accurately            // track the current state we could avoid making this call            // so often.)            enableVSyncLocked();        }

timestamp表示上一次某一个display获取到的vsync的时间，在EventThread第一次执行到这里的时候，一切都还没有准备就绪，于是timestamp为0，执行这一个代码段：

else if (!timestamp && waitForVSync) {            // we have at least one client, so we want vsync enabled            // (TODO: this function is called right after we finish            // notifying clients of a vsync, so this call will be made            // at the vsync rate, e.g. 60fps.  If we can accurately            // track the current state we could avoid making this call            // so often.)            enableVSyncLocked();        }

enableVSyncLocked()最终会调用setVSyncEnabled()把当前这个DispSyncSource注册成DispSync的listener。

void EventThread::enableVSyncLocked() {    if (!mUseSoftwareVSync) {        // never enable h/w VSYNC when screen is off        if (!mVsyncEnabled) {            mVsyncEnabled = true;            mVSyncSource->setCallback(static_cast<VSyncSource::Callback*>(this));            mVSyncSource->setVSyncEnabled(true);        }    }    mDebugVsyncEnabled = true;    sendVsyncHintOnLocked();}    virtual void SurfaceFlinger::setVSyncEnabled(bool enable) {        // Do NOT lock the mutex here so as to avoid any mutex ordering issues        // with locking it in the onDispSyncEvent callback.        if (enable) {            status_t err = mDispSync->addEventListener(mPhaseOffset,                    static_cast<DispSync::Callback*>(this));            if (err != NO_ERROR) {                ALOGE("error registering vsync callback: %s (%d)",                        strerror(-err), err);            }            //ATRACE_INT(mVsyncOnLabel.string(), 1);        } else {            status_t err = mDispSync->removeEventListener(                    static_cast<DispSync::Callback*>(this));            if (err != NO_ERROR) {                ALOGE("error unregistering vsync callback: %s (%d)",                        strerror(-err), err);            }            //ATRACE_INT(mVsyncOnLabel.string(), 0);        }    }

就这样，DispSync线程在收到VSync消息的时候就能回调两个虚拟vsync源DispSyncSource的onVSyncEvent()

    void fireCallbackInvocations(const Vector<CallbackInvocation>& callbacks) {        for (size_t i = 0; i < callbacks.size(); i++) {            callbacks[i].mCallback->onDispSyncEvent(callbacks[i].mEventTime);        }    }

    virtual void DispSyncSource::onDispSyncEvent(nsecs_t when) {        sp<VSyncSource::Callback> callback;        {            Mutex::Autolock lock(mMutex);            callback = mCallback;            if (mTraceVsync) {                mValue = (mValue + 1) % 2;                ATRACE_INT(mVsyncEventLabel.string(), mValue);            }        }        if (callback != NULL) {            callback->onVSyncEvent(when);        }    }

最后调用EventThread::onVSyncEvent():

void EventThread::onVSyncEvent(nsecs_t timestamp) {    Mutex::Autolock _l(mLock);    mVSyncEvent[0].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;    mVSyncEvent[0].header.id = 0;    mVSyncEvent[0].header.timestamp = timestamp;    mVSyncEvent[0].vsync.count++;    mCondition.broadcast();}

唤醒EventThread()，并通过conn->postEvent()发送消息:

bool EventThread::threadLoop() {    DisplayEventReceiver::Event event;    Vector< sp<EventThread::Connection> > signalConnections;    signalConnections = waitForEvent(&event);    // dispatch events to listeners...    const size_t count = signalConnections.size();    for (size_t i=0 ; i<count ; i++) {        const sp<Connection>& conn(signalConnections[i]);        // now see if we still need to report this event        status_t err = conn->postEvent(event);        …    }    return true;}

因为我们在main()，也就是SurfaceFlinger中调用了SurfaceFlinger::run():

void SurfaceFlinger::run() {    do {        waitForEvent();    } while (true);}void SurfaceFlinger::waitForEvent() {    mEventQueue.waitMessage();}

事实上，最后EventThread::onVSyncEvent()就是通过MessageQueue(socket)把消息发给了SurfaceFlinger主线程。

void MessageQueue::Handler::handleMessage(const Message& message) {    switch (message.what) {...        case REFRESH:            android_atomic_and(~eventMaskRefresh, &mEventMask);            mQueue.mFlinger->onMessageReceived(message.what);            break;...}void SurfaceFlinger::onMessageReceived(int32_t what) {    ATRACE_CALL();    switch (what) {...        case MessageQueue::REFRESH: {            handleMessageRefresh();            break;        }    }}

就这样，VSync消息一步步传递回了SurfaceFlinger的主线程，接下来就是对vsync进行响应，刷新系统的显示了。值得注意的是，surfaceflinger的刷新是跟着mSFEventThread这个虚拟的VsyncSource走的，因为前面是这么设置的：

mEventQueue.setEventThread(mSFEventThread)

所以vsync事件在线程中的传递流程大致如下：

HAL Thread－DispSyncThread - EventThread - SurfaceFlinger main Thread.