程序博客网 > 南方周末 知乎

Android SurfaceFlinger服务的消息循环过程源码分析

来源：互联网 发布：南方周末 知乎 编辑：程序博客网 时间：2024/06/05 09:45

 

分类： 【Android 显示模块】 2013-11-09 14:19 1836人阅读 评论(0)收藏 举报
EventThreadMessageQueueSurfaceFlingerSocketVSync

目录(?)[+]

  1. SurfaceFlinger消息循环过程
  2. DisplayHardware对象创建过程
  3. EventThread线程启动过程
  4. 事件连接创建过程
  5. 事件连接Connection注册过程
  6. 事件连接Socket接收端注册过程

在Android SurfaceFlinger服务启动过程源码分析中详细分析了SurfaceFlinger的整个启动过程，我们知道，在SurfaceFlinger线程执行过程中，循环调用waitForEvent()函数等待消息事件的到来

[cpp] view plaincopyprint?
  1. bool SurfaceFlinger::threadLoop()  
  2. {  
  3.     waitForEvent();  
  4.     return true;  
  5. }  

而waitForEvent函数则是调用SurfaceFlinger中的消息队列的waitMessage()函数来等待消息事件

[cpp] view plaincopyprint?
  1. void SurfaceFlinger::waitForEvent() {  
  2.     mEventQueue.waitMessage();  
  3. }  
通过跟踪代码发现，MessageQueue的waitMessage()函数则是调用Looper对象的pollOnce()函数来等待消息事件的

[cpp] view plaincopyprint?
  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. }  
该函数无限循环执行，关于Looper的pollOnce()函数在Android应用程序消息循环源码分析有详细的分析过程。本文就针对SurfaceFlinger的消息队列MessageQueue展开讨论，分析SurfaceFlinger的消息队列创建过程。由于在Android SurfaceFlinger服务启动过程源码分析中对SurfaceFlinger的启动过程作了详细的介绍，这里只给出一些关键代码。

[cpp] view plaincopyprint?
  1. void SurfaceFlinger::onFirstRef()  
  2. {  
  3.     //消息队列初始化   
  4.     mEventQueue.init(this);  
  5.     //启动SurfaceFlinger线程   
  6.     run("SurfaceFlinger", PRIORITY_URGENT_DISPLAY);  
  7.     mReadyToRunBarrier.wait();  
  8. }  


SurfaceFlinger消息循环过程


在SurfaceFlinger内部定义了类型为MessageQueue的消息队列。

[cpp] view plaincopyprint?
  1. void MessageQueue::init(const sp<SurfaceFlinger>& flinger)  
  2. {  
  3.     mFlinger = flinger;  
  4.     mLooper = new Looper(true);  
  5.     mHandler = new Handler(*this);  
  6. }  
在初始化消息队列MessageQueue时，为该消息队列创建了一个Looper对象和一个Handler对象。SurfaceFlinger，MessageQueue，Looper，Handler对象之间的关系如下：

在SurfaceFlinger的消息队列MessageQueue的初始化函数中，该该消息队列创建了一个Handler对象，一个Looper对象，Android应用程序消息循环源码分析中分析了Handler，Looper类的相关知识，不过前面介绍的Handler对象是Java层的Handler对象，这里定义的Handler是C++层面的，Looper对象也是C++层的，不过在Android应用程序消息循环源码分析文中对Looper对象有详细的分析，这里就不在重复介绍，重点介绍C++层定义的Handler的实现过程及使用方法。既然SurfaceFlinger的消息队列拥有一个Looper对象，这就说明SurfaceFlinger线程是一个消息循环线程。那么SurfaceFlinger是如何处理消息的呢？

在前面的Android应用程序创建Surface过程源码分析中介绍了应用程序通过调用SurfaceFlinger为应用程序分配的Client对象的Binder远程代理对象的createSurface函数来创建一个Surface：

[cpp] view plaincopyprint?
  1. sp<ISurface> Client::createSurface(  
  2.         ISurfaceComposerClient::surface_data_t* params,  
  3.         const String8& name,  
  4.         DisplayID display, uint32_t w, uint32_t h, PixelFormat format,  
  5.         uint32_t flags)  
  6. {  
  7.     sp<MessageBase> msg = new MessageCreateSurface(mFlinger.get(),params, name, this, display, w, h, format, flags);  
  8.     mFlinger->postMessageSync(msg);  
  9.     return static_cast<MessageCreateSurface*>( msg.get() )->getResult();  
  10. }  
函数首先将请求创建的Surface参数封装为MessageCreateSurface对象，然后调用SurfaceFlinger的postMessageSync函数往SurfaceFlinger的消息队列中发送一个同步消息，当消息处理完后，通过调用消息msg的getResult()函数来得到创建的Surface。

[cpp] view plaincopyprint?
  1. status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,  
  2.         nsecs_t reltime, uint32_t flags) {  
  3.     //往消息队列中发送一个消息   
  4.     status_t res = mEventQueue.postMessage(msg, reltime);  
  5.     //消息发送成功后，当前线程等待消息处理   
  6.     if (res == NO_ERROR) {  
  7.         msg->wait();  
  8.     }  
  9.     return res;  
  10. }  
其实这里发送的并不是消息对象，而是一个Handler对象，MessageCreateSurface的继承关系如下所示：

[cpp] view plaincopyprint?
  1. status_t MessageQueue::postMessage(const sp<MessageBase>& messageHandler, nsecs_t relTime)  
  2. {  
  3.     const Message dummyMessage;  
  4.     //将messageHandler对象和dummyMessage消息对象发送到消息循环Looper对象中  
  5.     if (relTime > 0) {  
  6.         mLooper->sendMessageDelayed(relTime, messageHandler, dummyMessage);  
  7.     } else {  
  8.         mLooper->sendMessage(messageHandler, dummyMessage);  
  9.     }  
  10.     return NO_ERROR;  
  11. }  
关于消息循环Looper对象的消息发送函数sendMessage的调用流程在Android应用程序消息循环源码分析已经有详细的分析。这里再次贴上关于消息插入代码：
[cpp] view plaincopyprint?
  1. void Looper::sendMessageAtTime(nsecs_t uptime, const sp<MessageHandler>& handler,  
  2.         const Message& message) {  
  3.     size_t i = 0;  
  4.     { // acquire lock   
  5.         AutoMutex _l(mLock);  
  6.         //获取消息队列中保存的消息个数   
  7.         size_t messageCount = mMessageEnvelopes.size();  
  8.         //按时间排序，查找当前消息应该插入的位置   
  9.         while (i < messageCount && uptime >= mMessageEnvelopes.itemAt(i).uptime) {  
  10.             i += 1;  
  11.         }  
  12.         //将Message消息及消息处理Handler封装为MessageEnvelope对象，并插入到消息队列mMessageEnvelopes中  
  13.         MessageEnvelope messageEnvelope(uptime, handler, message);  
  14.         mMessageEnvelopes.insertAt(messageEnvelope, i, 1);  
  15.         if (mSendingMessage) {  
  16.             return;  
  17.         }  
  18.     } // release lock   
  19.     //唤醒消息循环线程以及时处理消息   
  20.     if (i == 0) {  
  21.         wake();  
  22.     }  
  23. }  
到此消息发送就完成了，由于发送的是一个同步消息，因此消息发送线程此刻进入睡眠等待状态，而消息循环线程被唤醒起来处理消息，消息处理过程如下：
[cpp] view plaincopyprint?
  1. //所有C++层的消息都封装为MessageEnvelope类型的变量并保存到mMessageEnvelopes链表中  
  2. while (mMessageEnvelopes.size() != 0) {  
  3.     nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  4.     const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);  
  5.     //处理当前时刻之前的所有消息   
  6.     if (messageEnvelope.uptime <= now) {  
  7.         {   
  8.             //取出处理该消息的Hanlder   
  9.             sp<MessageHandler> handler = messageEnvelope.handler;  
  10.             //取出该消息描述符   
  11.             Message message = messageEnvelope.message;  
  12.             //从mMessageEnvelopes链表中移除该消息   
  13.             mMessageEnvelopes.removeAt(0);  
  14.             //表示当前消息循环线程正在处理消息，处于唤醒状态，因此消息发送线程无需唤醒消息循环线程  
  15.             mSendingMessage = true;  
  16.             mLock.unlock();  
  17.             //调用该消息Handler对象的handleMessage函数来处理该消息  
  18.             handler->handleMessage(message);  
  19.         } // release handler   
  20.         mLock.lock();  
  21.         mSendingMessage = false;  
  22.         result = ALOOPER_POLL_CALLBACK;  
  23.     } else {  
  24.         // The last message left at the head of the queue determines the next wakeup time.  
  25.         mNextMessageUptime = messageEnvelope.uptime;  
  26.         break;  
  27.     }  
  28. }  
消息处理过程就是调用该消息的Handler对象的handleMessage函数来完成，由于创建Surface时，往消息队列中发送的Handler对象类型为MessageCreateSurface，因此必定会调用该类的handleMessage函数来处理Surface创建消息。但该类并未实现
handleMessage函数，同时该类继承于MessageBase，由此可见其父类MessageBase必定实现了handleMessage函数：
[cpp] view plaincopyprint?
  1. void MessageBase::handleMessage(const Message&) {  
  2.     this->handler();  
  3.     barrier.open();  
  4. };  
该函数首先调用其子类的handler()函数处理消息，然后唤醒消息发送线程，表明发往消息队列中的消息已得到处理，消息发送线程可以往下执行了。由于MessageCreateSurface是MessageBase的子类，因此该类必定实现了handler()函数来处理Surface创建消息：
[cpp] view plaincopyprint?
  1. class MessageCreateSurface : public MessageBase {  
  2.     sp<ISurface> result;  
  3.     SurfaceFlinger* flinger;  
  4.     ISurfaceComposerClient::surface_data_t* params;  
  5.     Client* client;  
  6.     const String8& name;  
  7.     DisplayID display;  
  8.     uint32_t w, h;  
  9.     PixelFormat format;  
  10.     uint32_t flags;  
  11. public:  
  12.     MessageCreateSurface(SurfaceFlinger* flinger,  
  13.             ISurfaceComposerClient::surface_data_t* params,  
  14.             const String8& name, Client* client,  
  15.             DisplayID display, uint32_t w, uint32_t h, PixelFormat format,  
  16.             uint32_t flags)  
  17.         : flinger(flinger), params(params), client(client), name(name),  
  18.           display(display), w(w), h(h), format(format), flags(flags)  
  19.     {  
  20.     }  
  21.     sp<ISurface> getResult() const { return result; }  
  22.       
  23.     virtual bool handler() {  
  24.         result = flinger->createSurface(params, name, client,display, w, h, format, flags);  
  25.         return true;  
  26.     }  
  27. };  
这里又调用SurfaceFlinger的createSurface函数来创建Surface，Surface的创建调用过程如下：

绕了一圈又回到SurfaceFlinger，为什么要这么做呢？因为在同一时刻可以有多个应用程序请求SurfaceFlinger为其创建Surface，通过消息队列可以实现请求排队，然后SurfaceFlinger依次为应用程序创建Surface。

DisplayHardware对象创建过程


SurfaceFlinger线程启动后，首先会调用readyToRun()函数来完成一些线程运行前的准备工作

[cpp] view plaincopyprint?
  1. status_t SurfaceFlinger::readyToRun()  
  2. {  
  3.     // initialize the main display  
  4.     GraphicPlane& plane(graphicPlane(dpy));  
  5.     //创建DisplayHardware对象   
  6.     DisplayHardware* const hw = new DisplayHardware(this, dpy);  
  7.     plane.setDisplayHardware(hw);  
  8.     ...  
  9.     //创建EventThread线程对象   
  10.     mEventThread = new EventThread(this);  
  11.     mEventQueue.setEventThread(mEventThread);  
  12.     hw.startSleepManagement();  
  13.   
  14.     mReadyToRunBarrier.open();  
  15.     return NO_ERROR;  
  16. }  
在该函数中创建了两个对象：DisplayHardware对象和EventThread对象，同时将EventThread对象设置到消息队列MessageQueue中。MessageQueue消息队列在前面已经介绍了，它是在SurfaceFlinger线程启动前被创建的。

[cpp] view plaincopyprint?
  1. DisplayHardware::DisplayHardware(  
  2.         const sp<SurfaceFlinger>& flinger,  
  3.         uint32_t dpy)  
  4.     : DisplayHardwareBase(flinger, dpy),  
  5.       mFlinger(flinger), mFlags(0), mHwc(0)  
  6. {  
  7.     init(dpy);  
  8. }  
构造DisplayHardware对象前首先会调用其父类DisplayHardwareBase的构造函数
[cpp] view plaincopyprint?
  1. DisplayHardwareBase::DisplayHardwareBase(const sp<SurfaceFlinger>& flinger,  
  2.         uint32_t displayIndex)   
  3. {  
  4.     mScreenAcquired = true;  
  5.     mDisplayEventThread = new DisplayEventThread(flinger);  
  6. }  
这里创建了一个DisplayEventThread线程对象，关于DisplayEventThread线程的执行过程，在后面分析。在DisplayHardware构造函数中，调用的它的init函数来初始化DisplayHardware对象
[cpp] view plaincopyprint?
  1. void DisplayHardware::init(uint32_t dpy)  
  2. {  
  3.     mNativeWindow = new FramebufferNativeWindow();  
  4.     framebuffer_device_t const * fbDev = mNativeWindow->getDevice();  
  5.     if (!fbDev) {  
  6.         ALOGE("Display subsystem failed to initialize. check logs. exiting...");  
  7.         exit(0);  
  8.     }  
  9.     ...  
  10.     // initialize the H/W composer   
  11.     mHwc = new HWComposer(mFlinger, *this, mRefreshPeriod);  
  12.     if (mHwc->initCheck() == NO_ERROR) {  
  13.         mHwc->setFrameBuffer(mDisplay, mSurface);  
  14.     }  
  15. }  
在这里仍然创建了两个对象，分别是FramebufferNativeWindow对象和HWComposer对象，同时将DisplayHardware对象保存到HWComposer的成员变量mEventHandler，接下来分析一下HWComposer对象的创建过程：
[cpp] view plaincopyprint?
  1. HWComposer::HWComposer(  
  2.         const sp<SurfaceFlinger>& flinger,  
  3.         EventHandler& handler,  
  4.         nsecs_t refreshPeriod)  
  5.     : mFlinger(flinger),  
  6.       mModule(0), mHwc(0), mList(0), mCapacity(0),  
  7.       mNumOVLayers(0), mNumFBLayers(0),  
  8.       mDpy(EGL_NO_DISPLAY), mSur(EGL_NO_SURFACE),  
  9.       mEventHandler(handler),  
  10.       mRefreshPeriod(refreshPeriod),  
  11.       mVSyncCount(0), mDebugForceFakeVSync(false)  
  12. {  
  13.     char value[PROPERTY_VALUE_MAX];  
  14.     property_get("debug.sf.no_hw_vsync", value, "0");  
  15.     //....   
  16.     if (needVSyncThread) {  
  17.         // we don't have VSYNC support, we need to fake it  
  18.         mVSyncThread = new VSyncThread(*this);  
  19.     }  
  20. }  
这里首先加载HWComposer硬件抽象模块，HWComposer硬件模块用于产生VSync信号，如果加载失败，说明需要使用软件来模拟产生VSync信号。当变量needVSyncThread为true时，就创建一个VSyncThread线程来模拟产生VSync信号。到处总结一下DisplayHardware对象构造过程中所创建的对象：
1.DisplayHardware父类DisplayHardwareBase构造时创建了一个DisplayEventThread线程对象；
2.初始化DisplayHardware对象时创建了一个FramebufferNativeWindow对象；
3.初始化DisplayHardware对象时同时创建了一个HWComposer对象；
4.在HWComposer对象中创建了一个VSyncThread线程对象；

EventThread线程启动过程


EventThread对象构造过程：
[cpp] view plaincopyprint?
  1. EventThread::EventThread(const sp<SurfaceFlinger>& flinger)  
  2.     : mFlinger(flinger),  
  3.       mHw(flinger->graphicPlane(0).editDisplayHardware()),  
  4.       mLastVSyncTimestamp(0),  
  5.       mVSyncTimestamp(0),  
  6.       mUseSoftwareVSync(false),  
  7.       mDeliveredEvents(0),  
  8.       mDebugVsyncEnabled(false)  
  9. {  
  10. }  
由于EventThread继承RefBase类，因此在第一次强引用该对象时，会自动调用其onFirstRef()函数
[cpp] view plaincopyprint?
  1. void EventThread::onFirstRef() {  
  2.     mHw.setVSyncHandler(this);  
  3.     run("EventThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);  
  4. }  
变量mHw在构造EventThread对象时被赋值为flinger->graphicPlane(0).editDisplayHardware()，在上一小节中创建的DisplayHardware对象通过plane.setDisplayHardware(hw)被保存到GraphicPlane的成员变量mHw中，函数graphicPlane(0)用于获取第0个显示屏GraphicPlane对象，然后调用GraphicPlane的editDisplayHardware()函数返回其成员变量mHw保存的对象指针，因此EventThread的成员变量mHw也保存了上一小节创建的DisplayHardware对象指针。mHw.setVSyncHandler(this)语句是将当前EventThread对象保存到DisplayHardware的成员变量mVSyncHandler中：
[cpp] view plaincopyprint?
  1. void DisplayHardware::setVSyncHandler(const sp<VSyncHandler>& handler) {  
  2.     Mutex::Autolock _l(mLock);  
  3.     mVSyncHandler = handler;  
  4. }  
DisplayHardware的成员变量mVSyncHandler的类型为VSyncHandler，而EventThread是VSyncHandler的子类

然后启动EventThread线程。到此SurfaceFlinger所需的几个重要对象就基本创建完成了，下图显示了SurfaceFlinger启动过程创建了重要对象：


事件连接创建过程


SurfaceFlinger创建并启动完EventThread线程后，还会将该EventThread线程对象保存到SurfaceFlinger的消息队列mEventQueue中：
[cpp] view plaincopyprint?
  1. mEventQueue.setEventThread(mEventThread);  
setEventThread()函数的执行过程如下：
[cpp] view plaincopyprint?
  1. void MessageQueue::setEventThread(const sp<EventThread>& eventThread)  
  2. {  
  3.     mEventThread = eventThread;  
  4.     mEvents = eventThread->createEventConnection();  
  5.     mEventTube = mEvents->getDataChannel();  
  6.     //将socket接收端添加到looper中监听，并且设置了事件处理回调函数cb_eventReceiver  
  7.     mLooper->addFd(mEventTube->getFd(), 0, ALOOPER_EVENT_INPUT,MessageQueue::cb_eventReceiver, this);  
  8. }  
函数首先将创建的EventThread对象保存到消息队列MessageQueue的成员变量mEventThread中，然后调用EventThread对象的createEventConnection()函数创建一个事件连接Connection，Connection类是基于Binder进程间通信框架设计的，因此该对象可以实现跨进程传输，函数调用，其在Binder框架下的类关系图如下：

EventThread类的createEventConnection()函数用于创建一个Connection对象:
[cpp] view plaincopyprint?
  1. sp<EventThread::Connection> EventThread::createEventConnection() const {  
  2.     return new Connection(const_cast<EventThread*>(this));  
  3. }  
参数this指向已创建的EventThread对象
[cpp] view plaincopyprint?
  1. EventThread::Connection::Connection(  
  2.         const sp<EventThread>& eventThread)  
  3.     : count(-1), mEventThread(eventThread), mChannel(new BitTube())  
  4. {  
  5. }  
Connection构造过程中，将EventThread对象保存到Connection的成员变量mEventThread中，同时创建一个BitTube对象，并保存到Connection的成员变量mChannel中。BitTube对象的构造过程如下:
[cpp] view plaincopyprint?
  1. BitTube::BitTube(): mSendFd(-1), mReceiveFd(-1)  
  2. {  
  3.     int sockets[2];  
  4.     //创建一对socket   
  5.     if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets) == 0) {  
  6.         int size = SOCKET_BUFFER_SIZE;  
  7.         setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));  
  8.         setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));  
  9.         setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));  
  10.         setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));  
  11.         fcntl(sockets[0], F_SETFL, O_NONBLOCK);  
  12.         fcntl(sockets[1], F_SETFL, O_NONBLOCK);  
  13.         mReceiveFd = sockets[0];  
  14.         mSendFd = sockets[1];  
  15.     } else {  
  16.         mReceiveFd = -errno;  
  17.         ALOGE("BitTube: pipe creation failed (%s)", strerror(-mReceiveFd));  
  18.     }  
  19. }  
socketpair函数创建了彼此相连的两个套接字。

Connection只是对进程间使用Socket通信的封装类。
EventThread类的createEventConnection()就是简单地创建一个Connection对象，在构造Connection对象时，创建了彼此相连的两个套接字，EventThread线程在接收到VSync信号后，将通过Connection中的套接字发送端向SurfaceFlinger的消息循环中发送一个事件，而Connection中的套接字接收端将注册到SurfaceFlinger的消息循环Looper中，以接收EventThread线程分发过来的VSync事件，上图形象地描述了EventThread线程和SurfaceFlinger的消息循环线程之间的通信过程。

事件连接Connection注册过程


由于Connection继承了RefBase类同时实现了onFirstRef()函数，因此在第一次强引用Connection对象时，onFirstRef()函数自动被调用：
[cpp] view plaincopyprint?
  1. void EventThread::Connection::onFirstRef() {  
  2.     // NOTE: mEventThread doesn't hold a strong reference on us  
  3.     mEventThread->registerDisplayEventConnection(this);  
  4. }  
该函数调用EventThread的registerDisplayEventConnection()函数将当前创建的Connection对象注册到EventThread线程对象中，以便EventThread线程可以将VSync信号事件分发给所有注册的Connection连接的另一端。
[cpp] view plaincopyprint?
  1. status_t EventThread::registerDisplayEventConnection(  
  2.         const sp<EventThread::Connection>& connection) {  
  3.     Mutex::Autolock _l(mLock);  
  4.     //将创建的Connection对象添加到EventThread的成员变量mDisplayEventConnections向量中  
  5.     mDisplayEventConnections.add(connection);  
  6.     //如果EventThread线程正处于睡眠等待，则唤醒EventThread线程  
  7.     mCondition.broadcast();  
  8.     return NO_ERROR;  
  9. }  
到此EventThread线程就可以向已注册的Connection发送事件消息了，通过向Connection中的Socket发送端描述符写入数据，在Socket的接收端描述符中就可以接收到EventThread写入的数据。

事件连接Socket接收端注册过程


虽然此时创建了一对Socket用于EventThread线程和SurfaceFlinger的消息队列之间通信，但是消息队列MessageQueue并没有监听Socket的接收端描述符，因此即使EventThread线程通过Socket的发送端发送数据，消息队列MessageQueue仍然无法接收到EventThread线程发送的数据。这时需要将Socket的接收端文件描述符添加到MessageQueue的文件描述符监控池中：
[cpp] view plaincopyprint?
  1. mEventTube = mEvents->getDataChannel();  
  2. //将socket接收端添加到SurfaceFlinger的消息队列中监控   
  3. mLooper->addFd(mEventTube->getFd(), 0, ALOOPER_EVENT_INPUT,MessageQueue::cb_eventReceiver, this);  
变量mEventTube指向创建的事件连接Connection对象中的BitTube对象
[cpp] view plaincopyprint?
  1. sp<BitTube> EventThread::Connection::getDataChannel() const {  
  2.     return mChannel;//mChannel(new BitTube())  
  3. }  
函数getFd()用于返回创建的Sockets对的接收端描述符
[cpp] view plaincopyprint?
  1. int BitTube::getFd() const  
  2. {  
  3.     return mReceiveFd;  
  4. }  
mLooper->addFd(mEventTube->getFd(), 0, ALOOPER_EVENT_INPUT,MessageQueue::cb_eventReceiver, this)就是将Socket接收端文件描述符添加到消息循环Looper对象中，并且监听该文件描述符下的ALOOPER_EVENT_INPUT事件，当该Socket接收端接收到消息事件后，调用回调函数MessageQueue::cb_eventReceiver来处理该事件。关于向消息循环中添加监控句柄过程在Android应用程序消息循环源码分析中已经详细分析了，将Connection中的Socket接收端文件描述符注册到SurfaceFlinger的消息循环Looper中后，SurfaceFlinger的消息队列MessageQueue就可以接收到EventThread线程分发的事件消息了。
0 0
南方周末 知乎 南方周末 知乎
原创粉丝点击
热门IT博客
淘宝会员名可以修改吗淘宝会员名可以修改吗
操作说明书制作软件操作说明书制作软件
校园网络超市策划书
网络白莲花是什么意思
微信开发入门教程 php
淘宝荣老头是不是假货
在线投票系统源码
淘宝店铺装修店标
论文表格数据来源格式
大闹天宫美人神兵数据
六小龄童知乎扒皮
09外设淘宝店
r语言和python都要学吗
美国渔鹰飞机飞行数据
球球大作战 知乎
中联汽车电子公司 知乎
微信 python创建菜单
小米下载软件
手机维修记账软件
pic单片机内部晶振
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 三尺童蒙 三尺青蛇 三尺枯桐 地无三尺平 2尺 二尺三 门里 师兄他总对我垂涎三尺 三尾 三趾啄木鸟属 英雄谁属非我莫属歌曲 眷属是什么意思 好属色 念球菌属感染 属猪男和属龙女相配吗 12属 三点水加个屯 屯 三山 三山街 三山区 三山镇 三山区吧 镇江三山 镇三山 纪由乃严司屿 纪由乃宫司屿 严司屿纪由乃 屿 宫司屿纪由乃 屿怎么读 七连屿填岛失败 姜念安萧时屿免费阅读 萧时屿姜念安目录 长屿硐天 象屿集团 纪由乃宫与屿免费阅读 天屿湖 纪由乃宫司屿免费阅读 东门屿 萧时屿姜安念第十四章

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里