Android4.4——SurfaceFlinger启动


http://blog.csdn.net/yaowei514473839/article/details/39560055


        SurfaceFlinger是一项系统底层的服务，是负责UI方面的渲染的，与应用Application实时交互，实时刷新Surface，是与用户最直接打交道的一项服务。

        下面我们将分析SurfaceFlinger服务的启动过程。


        在system/core/rootdir/init.rc文件中，有这么段代码：

[java] view plain copy
  1. ……  
  2. service servicemanager /system/bin/servicemanager  
  3.     class core  
  4.     user system  
  5.     group system  
  6.     critical  
  7.     onrestart restart healthd  
  8.     onrestart restart zygote  
  9.     onrestart restart media  
  10.     onrestart restart surfaceflinger  
  11. onrestart restart drm  
  12. ……  
  13. service surfaceflinger /system/bin/surfaceflinger  
  14.     class main  
  15.     user system  
  16.     group graphics drmrpc  
  17. onrestart restart zygote  
  18. ……  
        SurfaceFlinger服务是在init过程中通过执行/system/bin/surfaceflinger这个bin文件启动，而在编译过程中通过编译frameworks/native/services/surfaceflinger该目录下的代码最终生成了surfaceflinger这个bin文件。
        好，下面来开始跟踪一下其中最终要的surfaceflinger服务的main函数。

Step 1、main()

在Android 4.4中，SurfaceFlinger的启动由frameworks/native/services/surfaceflinger/Main_surfaceflinger.cpp

中的main函数启动。


[java] view plain copy
  1. int main(int argc, char** argv) {  
  2.     // When SF is launched in its own process, limit the number of  
  3.     // binder threads to 4.  
  4.     ProcessState::self()->setThreadPoolMaxThreadCount(4);  
  5.   
  6.     // start the thread pool  
  7.     sp<ProcessState> ps(ProcessState::self());  
  8.     ps->startThreadPool();  
  9.   
  10.     // instantiate surfaceflinger  
  11.     sp<SurfaceFlinger> flinger = new SurfaceFlinger(); //创建一个SurfaceFlinger对象  
  12.   
  13. #if defined(HAVE_PTHREADS)  
  14.     setpriority(PRIO_PROCESS, 0, PRIORITY_URGENT_DISPLAY);  
  15. #endif  
  16.     set_sched_policy(0, SP_FOREGROUND);  
  17.   
  18.     // initialize before clients can connect  
  19.     flinger->init(); //初始化SurfaceFlinger  
  20.   
  21.     // publish surface flinger  
  22.     sp<IServiceManager> sm(defaultServiceManager());  
  23.     sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false);//将SrufaceFlinger加入服务  
  24.   
  25.     // run in this thread  
  26.     flinger->run();//运行SurfaceFlinger服务  
  27.   
  28.     return 0;  
  29. }  

        这里创建了SurfaceFlinger对象，随后初始化该对象，并且以该对象作为参数，将SurfaceFlinger服务加入ServiceManager中。

接下来，来分步解析。


Step 2、new SurfaceFlinger()

        该代码在frameworks/native/services/surfaceflinger.cpp中。

[java] view plain copy
  1. SurfaceFlinger::SurfaceFlinger()  
  2.     :   BnSurfaceComposer(),//创建SurfaceComposer本地对象  
  3.         mTransactionFlags(0),  
  4.         mTransactionPending(false),  
  5.         mAnimTransactionPending(false),  
  6.         mLayersRemoved(false),  
  7.         mRepaintEverything(0),  
  8.         mRenderEngine(NULL),  
  9.         mBootTime(systemTime()),  
  10.         mVisibleRegionsDirty(false),  
  11.         mHwWorkListDirty(false),  
  12.         mAnimCompositionPending(false),  
  13.         mDebugRegion(0),  
  14.         mDebugDDMS(0),  
  15.         mDebugDisableHWC(0),  
  16.         mDebugDisableTransformHint(0),  
  17.         mDebugInSwapBuffers(0),  
  18.         mLastSwapBufferTime(0),  
  19.         mDebugInTransaction(0),  
  20.         mLastTransactionTime(0),  
  21.         mBootFinished(false),  
  22.         mGpuTileRenderEnable(false),  
  23.         mPrimaryHWVsyncEnabled(false),  
  24.         mHWVsyncAvailable(false),  
  25.         mDaltonize(false)  
  26. {  
  27.     ALOGI("SurfaceFlinger is starting");  
  28.   
  29.     // debugging stuff...  
  30.     char value[PROPERTY_VALUE_MAX];  
  31.   
  32.     property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");  
  33.     mGpuToCpuSupported = !atoi(value);  
  34.   
  35.     property_get("debug.sf.showupdates", value, "0");  
  36.     mDebugRegion = atoi(value);  
  37.   
  38.     property_get("debug.sf.ddms", value, "0");  
  39.     mDebugDDMS = atoi(value);  
  40.     if (mDebugDDMS) {  
  41.         if (!startDdmConnection()) {  
  42.             // start failed, and DDMS debugging not enabled  
  43.             mDebugDDMS = 0;  
  44.         }  
  45.     }  
  46. }  


Step 2、SurfaceFlinger::OnFirstRef()

        由于flinger为sp<SurfaceFlinger>强指针类型，当第一次被一个强指针引用时，就会执行SurfaceFlinger::OnFirstRef()函数。

[java] view plain copy
  1. void SurfaceFlinger::onFirstRef()  
  2. {  
  3.     mEventQueue.init(this);  
  4. }  

        这里，mEventQueue是一个MessageQueue对象，是一个消息队列。定义的地方在SurfaceFlinger.h文件中。

[java] view plain copy
  1. mutable MessageQueue mEventQueue;  

        将SurfaceFlinger对象作为参数传入ini函数中，对MessageQueue初始化。将surfaceFlinger对象本神赋值给MessageQueue.mFlinger，也对MessageQueue中mHandler和mLooper进行赋值。


Step 3、MessageQueue::init

        代码位于frameworks/native/services/surfaceflinger/MessageQueue.cpp中。

[java] view plain copy
  1. void MessageQueue::init(const sp<SurfaceFlinger>& flinger)  
  2. {  
  3.     mFlinger = flinger; <pre name="code" class="java">    //创建主线程1   
  4.     mLooper = new Looper(true);  
  5.     mHandler = new Handler(*this);  
  6. }  

        将之前传入的SurfaceFlinger对象赋给MessageQueue的成员变量mFlinger，并且创建了消息队列的循环体Looper和事件处理器Handler。关于Looper和Handler，可以参考：http://www.cnblogs.com/codingmyworld/archive/2011/09/14/2174255.html这个博客，里面讲的很是详细。

        MessageQueue::init函数创建了下图中的主线程1，Looper配合着Message、Handle、Thread、MessageQueue完成了太多的事情，在这里简单说就是它搞了一个睡眠等待事件，然后等着被唤醒。结合到SF中就是说，这里开了一个线程等待surface的刷新，而做出相关的操作。至于是怎么唤醒的可以参考这个连接的博文http://blog.csdn.net/broadview2006/article/details/8552148。

Step 4、SurfaceFlinger::init()

        在前面几步后，完成了SurfaceFlinger对象的创建过程后，需要对SurfaceFlinger对象进行初始化。

        本部分的代码位于frameworks/native/services/wurfaceflinger.cpp中。

[java] view plain copy
  1. void SurfaceFlinger::init() {  
  2.   
  3.     status_t err;  
  4.     Mutex::Autolock _l(mStateLock);  
  5.   
  6.     // initialize EGL for the default display  
  7.     mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);  
  8.     eglInitialize(mEGLDisplay, NULL, NULL);  
  9.   
  10.     // Initialize the H/W composer object.  There may or may not be an  
  11.     // actual hardware composer underneath.  
  12.     mHwc = new HWComposer(this,  
  13.             *static_cast<HWComposer::EventHandler *>(this)); //创建HWComposer对象，通过HWComposer对象可以产生VSync同步信号。  
  14.   
  15.     // First try to get an ES2 config  
  16.     err = selectEGLConfig(mEGLDisplay, mHwc->getVisualID(), EGL_OPENGL_ES2_BIT,  
  17.             &mEGLConfig);  
  18.   
  19.     if (err != NO_ERROR) {  
  20.         // If ES2 fails, try ES1  
  21.         err = selectEGLConfig(mEGLDisplay, mHwc->getVisualID(),  
  22.                 EGL_OPENGL_ES_BIT, &mEGLConfig);  
  23.     }  
  24.   
  25.     // print some debugging info  
  26.     EGLint r,g,b,a;  
  27.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_RED_SIZE,   &r);  
  28.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_GREEN_SIZE, &g);  
  29.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_BLUE_SIZE,  &b);  
  30.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_ALPHA_SIZE, &a);  
  31.   
  32.     // get a RenderEngine for the given display / config (can't fail)  
  33.     mRenderEngine = RenderEngine::create(mEGLDisplay, mEGLConfig);  
  34.   
  35.     // retrieve the EGL context that was selected/created  
  36.     mEGLContext = mRenderEngine->getEGLContext();  
  37.   
  38.     // figure out which format we got  
  39.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig,  
  40.             EGL_NATIVE_VISUAL_ID, &mEGLNativeVisualId);  
  41.   
  42.     LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,  
  43.             "couldn't create EGLContext");  
  44.   
  45.     // initialize our non-virtual displays  
  46.     for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {  
  47.         DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);  
  48.         // set-up the displays that are already connected  
  49.         if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {  
  50.             // All non-virtual displays are currently considered secure.  
  51.             bool isSecure = true;  
  52.             createBuiltinDisplayLocked(type);  
  53.             wp<IBinder> token = mBuiltinDisplays[i];  
  54.   
  55.             sp<BufferQueue> bq = new BufferQueue(new GraphicBufferAlloc());  
  56.             sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i, bq);  
  57.             sp<DisplayDevice> hw = new DisplayDevice(this,  
  58.                     type, allocateHwcDisplayId(type), isSecure, token,  
  59.                     fbs, bq,  
  60.                     mEGLConfig);  
  61.             if (i > DisplayDevice::DISPLAY_PRIMARY) {  
  62.                 // FIXME: currently we don't get blank/unblank requests  
  63.                 // for displays other than the main display, so we always  
  64.                 // assume a connected display is unblanked.  
  65.                 ALOGD("marking display %d as acquired/unblanked", i);  
  66.                 hw->acquireScreen();  
  67.             }  
  68.             mDisplays.add(token, hw);  
  69.         }  
  70.     }  
  71.   
  72.     // make the GLContext current so that we can create textures when creating Layers  
  73.     // (which may happens before we render something)  
  74.     getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);  
  75.   
  76.     // start the EventThread  
  77.     sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  78.             vsyncPhaseOffsetNs, true);  
  79.     mEventThread = new EventThread(vsyncSrc);  
  80.     sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  81.             sfVsyncPhaseOffsetNs, true);  
  82.     mSFEventThread = new EventThread(sfVsyncSrc);  
  83.     mEventQueue.setEventThread(mSFEventThread);  
  84.   
  85.     mEventControlThread = new EventControlThread(this);  
  86.     mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);  
  87.   
  88.     // set a fake vsync period if there is no HWComposer  
  89.     if (mHwc->initCheck() != NO_ERROR) {  
  90.         mPrimaryDispSync.setPeriod(16666667);  
  91.     }  
  92.   
  93.     // initialize our drawing state  
  94.     mDrawingState = mCurrentState;  
  95.   
  96.     // set initial conditions (e.g. unblank default device)  
  97.     initializeDisplays();  
  98.   
  99.     // start boot animation  
  100.     startBootAnim();  
  101. }  
        在init的过程中，创建了下图中的线程3，其中的关键代码如下：
[java] view plain copy
  1. // start the EventThread  
  2. sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  3.         vsyncPhaseOffsetNs, true);  
  4. mEventThread = new EventThread(vsyncSrc);  
  5. sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  6.         sfVsyncPhaseOffsetNs, true);  
  7. mSFEventThread = new EventThread(sfVsyncSrc);  
  8. mEventQueue.setEventThread(mSFEventThread);  
  9.   
  10. mEventControlThread = new EventControlThread(this);  
  11. mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);  

        这里分两个线路来说：

        1、EventThread继承自Thread线程类，Thread的基类中有RefBase，如下：

[java] view plain copy
  1. class VSyncSource : public virtual RefBase {  
  2. public:  
  3.     class Callback: public virtual RefBase {  
  4.     public:  
  5.         virtual ~Callback() {}  
  6.         virtual void onVSyncEvent(nsecs_t when) = 0;  
  7.     };  
  8.   
  9.     virtual ~VSyncSource() {}  
  10.     virtual void setVSyncEnabled(bool enable) = 0;  
  11.     virtual void setCallback(const sp<Callback>& callback) = 0;  
  12. };  
[java] view plain copy
  1. class EventThread : public Thread, private VSyncSource::Callback {  
  2.     class Connection : public BnDisplayEventConnection {  
  3.     public:  
  4.         Connection(const sp<EventThread>& eventThread);  
  5.         status_t postEvent(const DisplayEventReceiver::Event& event);  
  6.   
  7.         // count >= 1 : continuous event. count is the vsync rate  
  8.         // count == 0 : one-shot event that has not fired  
  9.         // count ==-1 : one-shot event that fired this round / disabled  
  10.         int32_t count;  
  11.   
  12.     private:  
  13.         virtual ~Connection();  
  14.         virtual void onFirstRef();  
  15.         virtual sp<BitTube> getDataChannel() const;  
  16.         virtual void setVsyncRate(uint32_t count);  
  17.         virtual void requestNextVsync();    // asynchronous  
  18.         sp<EventThread> const mEventThread;  
  19.         sp<BitTube> const mChannel;  
  20. };  
  21.   
  22.     …  
  23.   
  24. };  
        所以当EventThread定义的时候就会调用OnFirstRef()函数，这个函数中只有run()函数。
[java] view plain copy
  1. void EventThread::onFirstRef() {  
  2.     run("EventThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);  
  3. }  
        由于EventThread继承自Thread，所以在执行run函数之后，会执行EventThread::threadLoop()函数。
[java] view plain copy
  1. bool EventThread::threadLoop() {  
  2.     DisplayEventReceiver::Event event;  
  3.     Vector< sp<EventThread::Connection> > signalConnections;  
  4.     signalConnections = waitForEvent(&event);//等待Vsync事件  
  5.   
  6.     // dispatch events to listeners...  
  7.     const size_t count = signalConnections.size();  
  8.     for (size_t i=0 ; i<count ; i++) {  
  9.         const sp<Connection>& conn(signalConnections[i]);  
  10.         // now see if we still need to report this event  
  11.         status_t err = conn->postEvent(event);//事件信息写入BitTuBe，也就是已建立连接的套接字队的一个套接字中，注册的接收端通过另一个套接字接收数据  
  12.         if (err == -EAGAIN || err == -EWOULDBLOCK) {  
  13.             // The destination doesn't accept events anymore, it's probably  
  14.             // full. For now, we just drop the events on the floor.  
  15.             // FIXME: Note that some events cannot be dropped and would have  
  16.             // to be re-sent later.  
  17.             // Right-now we don't have the ability to do this.  
  18.             ALOGW("EventThread: dropping event (%08x) for connection %p",  
  19.                     event.header.type, conn.get());  
  20.         } else if (err < 0) {  
  21.             // handle any other error on the pipe as fatal. the only  
  22.             // reasonable thing to do is to clean-up this connection.  
  23.             // The most common error we'll get here is -EPIPE.  
  24.             removeDisplayEventConnection(signalConnections[i]);  
  25.         }  
  26.     }  
  27.     return true;  
  28. }  
        当客户端请求渲染Surface的时候，这里就会接收到Vsync事件，则waitForEvent函数将返回用于连接客户端的signalConnections的Connection列表。（以后研究）

        如果收到一个Vsync事件，就会执行到conn->postEvent(event)，该函数作用请看上面的注释。至此，EventThread线程发送了一个套接字信息。下面继续讲讲上面提到的注册的接收端。

        2、到底谁来接收套接字？

        在之前SurfaceFlinger::init函数中有这样一句代码：

[java] view plain copy
  1. mEventQueue.setEventThread(mSFEventThread);  
        这个与pollOnce函数有关。

        setEventThread函数的具体实现如下。

[java] view plain copy
  1. void MessageQueue::setEventThread(const sp<EventThread>& eventThread)  
  2. {  
  3.     mEventThread = eventThread;  
  4.     mEvents = eventThread->createEventConnection();//创建一个到EventThread的连接  
  5.     mEventTube = mEvents->getDataChannel();//得到发送Vsync事件通知的BitTuBe  
  6.     mLooper->addFd(mEventTube->getFd(), 0, ALOOPER_EVENT_INPUT,  
  7.             MessageQueue::cb_eventReceiver, this);  
  8. }  
        上面addFd函数的第一个参数是获取套接字队列中的信息，一旦有东西就会调用MessageQueue::cb_eventReceiver这个回调函数。
[java] view plain copy
  1. int MessageQueue::cb_eventReceiver(int fd, int events, void* data) {  
  2.     MessageQueue* queue = reinterpret_cast<MessageQueue *>(data);  
  3.     return queue->eventReceiver(fd, events);//返回事件接收者  
  4. }  
        根据套接字队列中的信息，得到事件队列，最后返回事件接收者。
[java] view plain copy
  1. int MessageQueue::eventReceiver(int fd, int events) {  
  2.     ssize_t n;  
  3.     DisplayEventReceiver::Event buffer[8];  
  4.     while ((n = DisplayEventReceiver::getEvents(mEventTube, buffer, 8)) > 0) {  
  5.         for (int i=0 ; i<n ; i++) {  
  6.             if (buffer[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {  
  7. #if INVALIDATE_ON_VSYNC  
  8.                 mHandler->dispatchInvalidate();  
  9. #else  
  10.                 mHandler->dispatchRefresh();  
  11. #endif  
  12.                 break;  
  13.             }  
  14.         }  
  15.     }  
  16.     return 1;  
  17. }  
        这里主线程一直在获取事件，一旦事件类型为DISPLAY_EVENT_VSYNC，就会执行dispatchInvalidate或者dispatchRefresh函数。有关Vsync，之后再详细研究，先看看这篇博客：http://blog.csdn.net/broadview2006/article/details/8541727。

        dispatchInvalidate请看看这篇博客：http://blog.csdn.net/w401229755/article/details/38224481的后半段。这里只看dispatchRefresh函数。

[java] view plain copy
  1. void MessageQueue::Handler::dispatchRefresh() {  
  2.     if ((android_atomic_or(eventMaskRefresh, &mEventMask) & eventMaskRefresh) == 0) {  
  3.         mQueue.mLooper->sendMessage(this, Message(MessageQueue::REFRESH));  
  4.     }  
  5. }  
        这里发送了REFRESH消息，在SurfaceFlinger::run函数中创建了下图中的线程2后在一直睡眠等待消息，其中的pollInner函数的handleMessage是具体处理消息的地方，具体分析请参照Step 8和Step 9。

Step 5、SurfaceFlinger::run()

        在创建初始化SurfaceFlinger对象后，随后调用SurfaceFlinger的成员函数run()运行SurfaceFlinger服务。

        本代码位于frameworks/native/services/surfaceflinger.cpp中。

[java] view plain copy
  1. void SurfaceFlinger::run() {  
  2.     do {  
  3.         waitForEvent();  
  4.     } while (true);  
  5. }  

        这里创建了下图中的线程2。

        由于SurfaceFlinger服务需要时刻运行，实时绘制，所以不能理解使用do...while循环无限调用SurfaceFlinger成员函数waitForEvent。


Step 6 、SurfaceFlinger::waitForEvent()
本代码位于frameworks/native/services/surfaceflinger.cpp中。

[java] view plain copy
  1. void SurfaceFlinger::waitForEvent() {  
  2.     mEventQueue.waitMessage();  
  3. }  


Step 7、MessageQueue::waitMessage()

        本代码位于frameworks/native/services/MessageQueue.cpp中。

[java] view plain copy
  1. void MessageQueue::waitMessage() {  
  2.     do {  
  3.         IPCThreadState::self()->flushCommands();  
  4.         int32_t ret = mLooper->pollOnce(-1);  
  5.         switch (ret) {  
  6.             case ALOOPER_POLL_WAKE:  
  7.             case ALOOPER_POLL_CALLBACK:  
  8.                 continue;  
  9.             case ALOOPER_POLL_ERROR:  
  10.                 ALOGE("ALOOPER_POLL_ERROR");  
  11.             case ALOOPER_POLL_TIMEOUT:  
  12.                 // timeout (should not happen)  
  13.                 continue;  
  14.             default:  
  15.                 // should not happen  
  16.                 ALOGE("Looper::pollOnce() returned unknown status %d", ret);  
  17.                 continue;  
  18.         }  
  19.     } while (true);  
  20. }  
        程序进入了一个死循环，即使mLooper->pollOnce的返回结果为ALOOPER_POLL_TIMEOUT也不会退出。Android对于处理一些严重的系统错误，采取的是一种"Let it be"的态度。

Step 8、Looper::pollOnce()
        mLooper->pollOnce函数的代码位于frameworks/base/libs/utils/Looper.cpp中。

[java] view plain copy
  1. int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {  
  2.     int result = 0;  
  3.     for (;;) {  
  4.         while (mResponseIndex < mResponses.size()) {  
  5.             const Response& response = mResponses.itemAt(mResponseIndex++);  
  6.             int ident = response.request.ident;  
  7.             if (ident >= 0) {  
  8.                 int fd = response.request.fd;  
  9.                 int events = response.events;  
  10.                 void* data = response.request.data;  
  11.                 if (outFd != NULL) *outFd = fd;  
  12.                 if (outEvents != NULL) *outEvents = events;  
  13.                 if (outData != NULL) *outData = data;  
  14.                 return ident;  
  15.             }  
  16.         }  
  17.   
  18.         if (result != 0) {  
  19.             if (outFd != NULL) *outFd = 0;  
  20.             if (outEvents != NULL) *outEvents = 0;  
  21.             if (outData != NULL) *outData = NULL;  
  22.             return result;  
  23.         }  
  24.   
  25.         result = pollInner(timeoutMillis);  
  26.     }  
  27. }  


Step 9、Looper::pollInner

[java] view plain copy
  1. int Looper::pollInner(int timeoutMillis) {  
  2.   
  3.     // Adjust the timeout based on when the next message is due.  
  4.     if (timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {  
  5.         nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  6.         int messageTimeoutMillis = toMillisecondTimeoutDelay(now, mNextMessageUptime);  
  7.         if (messageTimeoutMillis >= 0  
  8.                 && (timeoutMillis < 0 || messageTimeoutMillis < timeoutMillis)) {  
  9.             timeoutMillis = messageTimeoutMillis;  
  10.         }  
  11.     }  
  12.   
  13.     // Poll.  
  14.     int result = ALOOPER_POLL_WAKE;  
  15.     mResponses.clear();  
  16.     mResponseIndex = 0;  
  17.   
  18.     // We are about to idle.  
  19.     mIdling = true;  
  20.   
  21.     struct epoll_event eventItems[EPOLL_MAX_EVENTS];  
  22.     int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);  
  23.   
  24.     // No longer idling.  
  25.     mIdling = false;  
  26.   
  27.     // Acquire lock.  
  28.     mLock.lock();  
  29.   
  30.     // Check for poll error.  
  31.     if (eventCount < 0) {  
  32.         if (errno == EINTR) {  
  33.             goto Done;  
  34.         }  
  35.         result = ALOOPER_POLL_ERROR;  
  36.         goto Done;  
  37.     }  
  38.   
  39.     // Check for poll timeout.  
  40.     if (eventCount == 0) {  
  41.         result = ALOOPER_POLL_TIMEOUT;  
  42.         goto Done;  
  43.     }  
  44.   
  45.     // Handle all events.  
  46.     for (int i = 0; i < eventCount; i++) {  
  47.         int fd = eventItems[i].data.fd;  
  48.         uint32_t epollEvents = eventItems[i].events;  
  49.         if (fd == mWakeReadPipeFd) {  
  50.             if (epollEvents & EPOLLIN) {  
  51.                 awoken();  
  52.             } else {  
  53.                 ALOGW("Ignoring unexpected epoll events 0x%x on wake read pipe.", epollEvents);  
  54.             }  
  55.         } else {  
  56.             ssize_t requestIndex = mRequests.indexOfKey(fd);  
  57.             if (requestIndex >= 0) {  
  58.                 int events = 0;  
  59.                 if (epollEvents & EPOLLIN) events |= ALOOPER_EVENT_INPUT;  
  60.                 if (epollEvents & EPOLLOUT) events |= ALOOPER_EVENT_OUTPUT;  
  61.                 if (epollEvents & EPOLLERR) events |= ALOOPER_EVENT_ERROR;  
  62.                 if (epollEvents & EPOLLHUP) events |= ALOOPER_EVENT_HANGUP;  
  63.                 pushResponse(events, mRequests.valueAt(requestIndex));  
  64.             } else {  
  65.                 ALOGW("Ignoring unexpected epoll events 0x%x on fd %d that is "  
  66.                         "no longer registered.", epollEvents, fd);  
  67.             }  
  68.         }  
  69.     }  
  70. Done: ;  
  71.   
  72.     // Invoke pending message callbacks.  
  73.     mNextMessageUptime = LLONG_MAX;  
  74.     <strong>while (mMessageEnvelopes.size() != 0)</strong> {  
  75.         nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  76.         const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);  
  77.         if (messageEnvelope.uptime <= now) {  
  78.             // Remove the envelope from the list.  
  79.             // We keep a strong reference to the handler until the call to handleMessage  
  80.             // finishes.  Then we drop it so that the handler can be deleted *before*  
  81.             // we reacquire our lock.  
  82.             { // obtain handler  
  83.                 sp<MessageHandler> handler = messageEnvelope.handler;  
  84.                 Message message = messageEnvelope.message;  
  85.                 mMessageEnvelopes.removeAt(0);  
  86.                 mSendingMessage = true;  
  87.                 mLock.unlock();  
  88.   
  89.                 handler->handleMessage(message);  
  90.             } // release handler  
  91.   
  92.             mLock.lock();  
  93.             mSendingMessage = false;  
  94.             result = ALOOPER_POLL_CALLBACK;  
  95.         } else {  
  96.             // The last message left at the head of the queue determines the next wakeup time.  
  97.             mNextMessageUptime = messageEnvelope.uptime;  
  98.             break;  
  99.         }  
  100.     }  
  101.   
  102.     // Release lock.  
  103.     mLock.unlock();  
  104.   
  105.     // Invoke all response callbacks.  
  106.     for (size_t i = 0; i < mResponses.size(); i++) {  
  107.         Response& response = mResponses.editItemAt(i);  
  108.         if (response.request.ident == ALOOPER_POLL_CALLBACK) {  
  109.             int fd = response.request.fd;  
  110.             int events = response.events;  
  111.             void* data = response.request.data;  
  112.   
  113.             int callbackResult = response.request.callback->handleEvent(fd, events, data);  
  114.             if (callbackResult == 0) {  
  115.                 removeFd(fd);  
  116.             }  
  117.             // Clear the callback reference in the response structure promptly because we  
  118.             // will not clear the response vector itself until the next poll.  
  119.             response.request.callback.clear();  
  120.             result = ALOOPER_POLL_CALLBACK;  
  121.         }  
  122.     }  
  123.     return result;  
  124. }  

        pollOnce与pollInner的关系，请看看这篇博客：http://blog.csdn.net/broadview2006/article/details/8541727。

        在Looper::pollInner函数中内部调用MessageQueue::mHandler处理消息？？？？？

        PS：（下面一段摘自大侠林学森的博客文章——Android显示系统之SurfaceFlinger（一））

这样子就构建了一个简洁而又完整的循环消息处理框架，SurfaceFlinger就是基于这个框架完成来自系统中各个程序的显示请求的。大家可能会有疑问，mHandler是由MessageQueue直接通过new Handler()生成的，这样的话如何能处理特定的SurfaceFlinger消息请求呢？个人感觉有这个困惑是由于Handler类取名不当引起的。实际上此Handler并非我们经常看到的那个Handler，这里的Handler是MessageQueue中自定义的一个事件处理器，也就是说它是专门为SurfaceFlinger设计的。


Step 10、MessageQueue::Handler::handleMessage()

代码位于frameworks/native/services/surfaceflinger/MessageQueue.cpp中。

[java] view plain copy
  1. void MessageQueue::Handler::handleMessage(const Message& message) {  
  2.     switch (message.what) {  
  3.         case INVALIDATE:  
  4.             android_atomic_and(~eventMaskInvalidate, &mEventMask);  
  5.             mQueue.mFlinger->onMessageReceived(message.what);  
  6.             break;  
  7.         case REFRESH:  
  8.             android_atomic_and(~eventMaskRefresh, &mEventMask);  
  9.             mQueue.mFlinger->onMessageReceived(message.what);  
  10.             break;  
  11.         case TRANSACTION:  
  12.             android_atomic_and(~eventMaskTransaction, &mEventMask);  
  13.             mQueue.mFlinger->onMessageReceived(message.what);  
  14.             break;  
  15.     }  
  16. }  
        当mHandler收到INVALIDATE、REFRESH和TRANSACTION消息后，又会回调SurfaceFlinger::onMessageReceived函数。这样绕了一圈友重新返回到了SurfaceFlinger中。


        附上一张网上大牛画的一张有关SurfaceFlinger的图，逻辑很清晰。




posted @ 2016-11-26 10:57  张同光  阅读(156)  评论(0)  编辑  收藏  举报