static void android_os_MessageQueue_nativePollOnce(JNIEnv*env, jobject obj,
    jintptr, jint timeoutMillis)
   NativeMessageQueue*nativeMessageQueue =
              reinterpret_cast<NativeMessageQueue*>(ptr);
  //取出NativeMessageQueue對象，并調(diào)用它的pollOnce
  nativeMessageQueue->pollOnce(timeoutMillis);
}
//分析pollOnce函數(shù)
void NativeMessageQueue::pollOnce(inttimeoutMillis) {
  mLooper->pollOnce(timeoutMillis); //重任傳遞到Looper的pollOnce函數(shù)
}

inline int pollOnce(int timeoutMillis) {
    return pollOnce(timeoutMillis, NULL, NULL, NULL);
}

/*
使用epoll前，需要先通過epoll_create函數(shù)創(chuàng)建一個(gè)epoll句柄。
下面一行代碼中的10表示該epoll句柄初次創(chuàng)建時(shí)候分配能容納10個(gè)fd相關(guān)信息的緩存。
對于2.6.8版本以后的內(nèi)核，該值沒有實(shí)際作用，這里可以忽略。其實(shí)這個(gè)值的主要目的是
確定分配一塊多大的緩存?，F(xiàn)在的內(nèi)核都支持動(dòng)態(tài)拓展這塊緩存，所以該值就沒有意義了
*/ 
int epollHandle = epoll_create(10);

/*
  得到epoll句柄后，下一步就是通過epoll_ctl把需要監(jiān)聽的文件句柄加入到epoll句柄中。
  除了指定文件句柄本身的fd值外，同時(shí)還需要指定在該fd上等待什么事件。epoll支持四類事件，
 分別是EPOLLIN(句柄可讀)、EPOLLOUT(句柄可寫),EPOLLERR(句柄錯(cuò)誤)、EPOLLHUP(句柄斷)。
  epoll定義了一個(gè)結(jié)構(gòu)體struct epoll_event來表達(dá)監(jiān)聽句柄的訴求。
  假設(shè)現(xiàn)在有一個(gè)監(jiān)聽端的socket句柄listener，要把它加入到epoll句柄中。
 */
 structepoll_event listenEvent; //先定義一個(gè)event
 /*
 EPOLLIN表示可讀事件,EPOLLOUT表示可寫事件，另外還有EPOLLERR,EPOLLHUP表示
 系統(tǒng)默認(rèn)會(huì)將EPOLLERR加入到事件集合中
 */
 listenEvent.events= EPOLLIN;//指定該句柄的可讀事件
 //epoll_event中有一個(gè)聯(lián)合體叫data，用來存儲(chǔ)上下文數(shù)據(jù)，本例的上下文數(shù)據(jù)就是句柄自己
 listenEvent.data.fd= listenEvent;
/*
 EPOLL_CTL_ADD將監(jiān)聽fd和監(jiān)聽事件加入到epoll句柄的等待隊(duì)列中；
 EPOLL_CTL_DEL將監(jiān)聽fd從epoll句柄中移除；
 EPOLL_CTL_MOD修改監(jiān)聽fd的監(jiān)聽事件，例如本來只等待可讀事件，現(xiàn)在需要同時(shí)等待
可寫事件，那么修改listenEvent.events 為EPOLLIN|EPOLLOUT后，再傳給epoll句柄
 */
 epoll_ctl(epollHandle,EPOLL_CTL_ADD,listener,&listenEvent);
 /*
 當(dāng)把所有感興趣的fd都加入到epoll句柄后，就可以開始坐等感興趣的事情發(fā)生了。
 為了接收所發(fā)生的事情，先定義一個(gè)epoll_event數(shù)組
 */
struct epoll_eventresultEvents[10];
 inttimeout = -1;
 while(1)
 {
  /*
  調(diào)用epoll_wait用于等待事件，其中timeout可以指定一個(gè)超時(shí)時(shí)間，
  resultEvents用于接收發(fā)生的事件，10為該數(shù)組的大小。
   epoll_wait函數(shù)的返回值有如下含義：
   nfds大于0表示所監(jiān)聽的句柄上有事件發(fā)生；
   nfds等于0表示等待超時(shí)；
   nfds小于0表示等待過程中發(fā)生了錯(cuò)誤
  */
 int nfds= epoll_wait(epollHandle, resultEvents, 10, timeout);
 if(nfds== -1)
 {
  // epoll_wait發(fā)生了錯(cuò)誤
 }
 elseif(nfds == 0)
 {
  //發(fā)生超時(shí)，期間沒有發(fā)生任何事件
 }
 else
 {
  //resultEvents用于返回那些發(fā)生了事件的信息
  for(int i = 0; i < nfds; i++)
  {
    struct epoll_event & event =resultEvents[i];
    if(event & EPOLLIN)
   {
     /*
      收到可讀事件。到底是哪個(gè)文件句柄發(fā)生該事件呢？可通過event.data這個(gè)聯(lián)合體取得
      之前傳遞給epoll的上下文數(shù)據(jù)，該上下文信息可用于判斷到底是誰發(fā)生了事件。
     */
   }
    .......//其他處理 
  }
 }

}

int Looper::pollOnce(int timeoutMillis, int*outFd, int* outEvents,
void** outData) {
  intresult = 0;
  for (;;){ //一個(gè)無限循環(huán)
  //mResponses是一個(gè)Vector，這里首先需要處理response
    while (mResponseIndex < mResponses.size()) {
      const Response& response = mResponses.itemAt(mResponseIndex++);
      ALooper_callbackFunc callback = response.request.callback;
      if (!callback) {//首先處理那些沒有callback的Response
        int ident = response.request.ident; //ident是這個(gè)Response的id
        int fd = response.request.fd;
        int events = response.events;
        void* data = response.request.data;
        ......
        if (outFd != NULL) *outFd = fd;
        if (outEvents != NULL) *outEvents = events;
        if (outData != NULL) *outData = data;
        //實(shí)際上，對于沒有callback的Response，pollOnce只是返回它的
       //ident，并沒有實(shí)際做什么處理。因?yàn)闆]有callback，所以系統(tǒng)也不知道如何處理
        return ident;
      }
    }
 
    if(result != 0) {
     if (outFd != NULL) *outFd = 0;
      if (outEvents != NULL) *outEvents = NULL;
      if (outData != NULL) *outData = NULL;
      return result;
    }
    //調(diào)用pollInner函數(shù)。注意，它在for循環(huán)內(nèi)部
    result = pollInner(timeoutMillis);
  }
}

int Looper::pollInner(int timeoutMillis) {
  
  if(timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {
    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
    ......//根據(jù)Native Message的信息計(jì)算此次需要等待的時(shí)間
    timeoutMillis= messageTimeoutMillis;
   }
  intresult = ALOOPER_POLL_WAKE;
  mResponses.clear();
  mResponseIndex = 0;
#ifdef LOOPER_USES_EPOLL //我們只討論使用epoll進(jìn)行I/O復(fù)用的方式
  structepoll_event eventItems[EPOLL_MAX_EVENTS];
  //調(diào)用epoll_wait，等待感興趣的事件或超時(shí)發(fā)生
  inteventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS,
                   timeoutMillis);
#else
   ......//使用別的方式進(jìn)行I/O復(fù)用
#endif
  //從epoll_wait返回，這時(shí)候一定發(fā)生了什么事情
  mLock.lock();
  if(eventCount < 0) { //返回值小于零，表示發(fā)生錯(cuò)誤
    if(errno == EINTR) {
      goto Done;
    }
    //設(shè)置result為ALLOPER_POLL_ERROR,并跳轉(zhuǎn)到Done
    result = ALOOPER_POLL_ERROR;
    gotoDone;
  }
 
  //eventCount為零，表示發(fā)生超時(shí)，因此直接跳轉(zhuǎn)到Done
  if(eventCount == 0) {
   result = ALOOPER_POLL_TIMEOUT;
    gotoDone;
  }
#ifdef LOOPER_USES_EPOLL
  //根據(jù)epoll的用法，此時(shí)的eventCount表示發(fā)生事件的個(gè)數(shù)
  for (inti = 0; i < eventCount; i++) {
    intfd = eventItems[i].data.fd;
    uint32_t epollEvents = eventItems[i].events;
    /*
     之前通過pipe函數(shù)創(chuàng)建過兩個(gè)fd，這里根據(jù)fd知道是管道讀端有可讀事件。
     讀者還記得對nativeWake函數(shù)的分析嗎？在那里我們向管道寫端寫了一個(gè)”W”字符，這樣
     就能觸發(fā)管道讀端從epoll_wait函數(shù)返回了
     */
    if(fd == mWakeReadPipeFd) {
      if (epollEvents & EPOLLIN) {
        //awoken函數(shù)直接讀取并清空管道數(shù)據(jù)，讀者可自行研究該函數(shù)
        awoken();
      }
     ......
    }else {
      /*
      mRequests和前面的mResponse相對應(yīng)，它也是一個(gè)KeyedVector，其中存儲(chǔ)了
      fd和對應(yīng)的Request結(jié)構(gòu)體，該結(jié)構(gòu)體封裝了和監(jiān)控文件句柄相關(guān)的一些上下文信息，
      例如回調(diào)函數(shù)等。我們在后面的小節(jié)會(huì)再次介紹該結(jié)構(gòu)體
      */
      ssize_t requestIndex = mRequests.indexOfKey(fd);
      if (requestIndex >= 0) {
        int events = 0;
        //將epoll返回的事件轉(zhuǎn)換成上層LOOPER使用的事件
        if (epollEvents & EPOLLIN) events |= ALOOPER_EVENT_INPUT;
        if (epollEvents & EPOLLOUT) events |= ALOOPER_EVENT_OUTPUT;
        if (epollEvents & EPOLLERR) events |= ALOOPER_EVENT_ERROR;
        if (epollEvents & EPOLLHUP) events |= ALOOPER_EVENT_HANGUP;
        //每處理一個(gè)Request，就相應(yīng)構(gòu)造一個(gè)Response
        pushResponse(events, mRequests.valueAt(requestIndex));
      } 
      ......
    }
  }
Done: ;
#else
   ......
#endif
  //除了處理Request外，還處理Native的Message
  mNextMessageUptime = LLONG_MAX;
  while(mMessageEnvelopes.size() != 0) {
    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
    const MessageEnvelope& messageEnvelope =mMessageEnvelopes.itemAt(0);
    if(messageEnvelope.uptime <= now) {
      {
        sp<MessageHandler> handler = messageEnvelope.handler;
        Message message = messageEnvelope.message;
        mMessageEnvelopes.removeAt(0);
        mSendingMessage = true;
        mLock.unlock();
        //調(diào)用Native的handler處理Native的Message
        //從這里也可看出NativeMessage和Java層的Message沒有什么關(guān)系
        handler->handleMessage(message);
      }
      mLock.lock();
      mSendingMessage = false;
      result = ALOOPER_POLL_CALLBACK;
    }else {
      mNextMessageUptime = messageEnvelope.uptime;
      break;
    }
  }
 
  mLock.unlock();
  //處理那些帶回調(diào)函數(shù)的Response
  for(size_t i = 0; i < mResponses.size(); i++) {
    const Response& response = mResponses.itemAt(i);
    ALooper_callbackFunc callback = response.request.callback;
    if(callback) {//有了回調(diào)函數(shù)，就能知道如何處理所發(fā)生的事情了
      int fd = response.request.fd;
      int events = response.events;
      void* data = response.request.data;
      //調(diào)用回調(diào)函數(shù)處理所發(fā)生的事件
      int callbackResult = callback(fd, events, data);
      if (callbackResult == 0) {
        //callback函數(shù)的返回值很重要，如果為0，表明不需要再次監(jiān)視該文件句柄
        removeFd(fd);
      }
      result = ALOOPER_POLL_CALLBACK;
    }
  }
  returnresult;
}

static jint
loadNativeCode_native(JNIEnv* env, jobject clazz,jstring path,
             jstring funcName,jobject messageQueue,
             jstring internalDataDir, jstring obbDir,
             jstring externalDataDir, int sdkVersion,
             jobject jAssetMgr, jbyteArraysavedState)
{
 ......
 /*
 調(diào)用Looper的addFd函數(shù)。第一個(gè)參數(shù)表示監(jiān)聽的fd；第二個(gè)參數(shù)0表示ident；
 第三個(gè)參數(shù)表示需要監(jiān)聽的事件，這里為只監(jiān)聽可讀事件；第四個(gè)參數(shù)為回調(diào)函數(shù)，當(dāng)該fd發(fā)生
 指定事件時(shí)，looper將回調(diào)該函數(shù)；第五個(gè)參數(shù)code為回調(diào)函數(shù)的參數(shù)
*/
 code->looper->addFd(code->mainWorkRead,0,
             ALOOPER_EVENT_INPUT,mainWorkCallback, code);
 ......
}

int Looper::addFd(int fd, int ident, int events,
           ALooper_callbackFunccallback, void* data) {
  if (!callback) {
     //判斷該Looper是否支持不帶回調(diào)函數(shù)的文件句柄添加。一般不支持，因?yàn)闆]有回調(diào)函數(shù)
     //Looper也不知道如何處理該文件句柄上發(fā)生的事情
     if(! mAllowNonCallbacks) {
      return -1;
    }
   ......
  }
 
  #ifdefLOOPER_USES_EPOLL
  intepollEvents = 0;
  //將用戶的事件轉(zhuǎn)換成epoll使用的值
  if(events & ALOOPER_EVENT_INPUT) epollEvents |= EPOLLIN;
  if(events & ALOOPER_EVENT_OUTPUT) epollEvents |= EPOLLOUT;
 
  {
    AutoMutex _l(mLock);
    Request request; //創(chuàng)建一個(gè)Request對象
    request.fd = fd; //保存fd
    request.ident = ident; //保存id
    request.callback = callback; //保存callback
    request.data = data; //保存用戶自定義數(shù)據(jù)
 
    struct epoll_event eventItem;
    memset(& eventItem, 0, sizeof(epoll_event));
    eventItem.events = epollEvents;
    eventItem.data.fd = fd;
    //判斷該Request是否已經(jīng)存在，mRequests以fd作為key值
    ssize_t requestIndex = mRequests.indexOfKey(fd);
    if(requestIndex < 0) {
      //如果是新的文件句柄，則需要為epoll增加該fd
      int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);
      ......
      //保存Request到mRequests鍵值數(shù)組
      mRequests.add(fd, request);
    }else {
      //如果之前加過，那么就修改該監(jiān)聽句柄的一些信息
      int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_MOD, fd, &eventItem);
      ......
      mRequests.replaceValueAt(requestIndex, request);
    }
  }
#else
  ......
#endif
  return1;
}

void Looper::pushResponse(int events, constRequest& request) {
  Responseresponse;
  response.events = events;
  response.request = request; //其實(shí)很簡單，就是保存所發(fā)生的事情和對應(yīng)的Request
  mResponses.push(response); //然后保存到mResponse數(shù)組
}

void Looper::sendMessage(constsp<MessageHandler>& handler,
               constMessage& message) {
  //Native的sendMessage函數(shù)必須同時(shí)傳遞一個(gè)Handler
  nsecs_tnow = systemTime(SYSTEM_TIME_MONOTONIC);
  sendMessageAtTime(now, handler, message); //調(diào)用sendMessageAtTime
}
void Looper::sendMessageAtTime(nsecs_t uptime,
                   const sp<MessageHandler>& handler,
                   const Message& message) {
  size_t i= 0;
  { //acquire lock
    AutoMutex _l(mLock);
 
    size_t messageCount = mMessageEnvelopes.size();
    //按時(shí)間排序，將消息插入到正確的位置上
    while (i < messageCount &&
        uptime >= mMessageEnvelopes.itemAt(i).uptime) {
      i += 1;
    }
    
    MessageEnvelope messageEnvelope(uptime, handler, message);
    mMessageEnvelopes.insertAt(messageEnvelope, i, 1);
    //mSendingMessage和Java層中的那個(gè)mBlocked一樣，是一個(gè)小小的優(yōu)化措施
    if(mSendingMessage) {
      return;
    }
  }
  //喚醒epoll_wait，讓它處理消息
  if (i ==0) {
    wake();
  }
}