sp<Looper> Looper::prepare(int opts) {
    // opts決定Looper::addFd()的參數(shù)callback是否可以為空
    bool allowNonCallbacks = opts & PREPARE_ALLOW_NON_CALLBACKS;
    // 通過(guò)pthread_getspecific()獲取線程本地存儲(chǔ)中的Looper對(duì)象
    sp<Looper> looper = Looper::getForThread();
    if (looper == nullptr) {
        looper = new Looper(allowNonCallbacks);
        // 通過(guò)pthread_setspecific()把Looper對(duì)象保存到線程本地存儲(chǔ)中
        Looper::setForThread(looper);
    }
    return looper;
}

Looper::Looper(bool allowNonCallbacks)
    : mAllowNonCallbacks(allowNonCallbacks),
      mSendingMessage(false),
      mPolling(false),
      mEpollRebuildRequired(false),
      mNextRequestSeq(0),
      mResponseIndex(0),
      mNextMessageUptime(LLONG_MAX) {
    // 1. 創(chuàng)建 eventfd 對(duì)象，用于喚醒 Looper
    mWakeEventFd.reset(eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC));
    AutoMutex _l(mLock);
    // 2. 創(chuàng)建 epoll 對(duì)象，并監(jiān)聽(tīng)剛才創(chuàng)建的 eventfd 的輸入事件
    rebuildEpollLocked();
}

void Looper::rebuildEpollLocked() {
    // ...
    // 創(chuàng)建epoll對(duì)象
    mEpollFd.reset(epoll_create1(EPOLL_CLOEXEC));
    // 監(jiān)聽(tīng) mWakeEventFd 輸入事件
    struct epoll_event eventItem;
    memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union
    eventItem.events = EPOLLIN;
    eventItem.data.fd = mWakeEventFd.get();
    int result = epoll_ctl(mEpollFd.get(), EPOLL_CTL_ADD, mWakeEventFd.get(), &eventItem);
    for (size_t i = 0; i < mRequests.size(); i++) {
        // ...
    }
}

void Looper::sendMessageAtTime(nsecs_t uptime, const sp<MessageHandler>& handler,
        const Message& message) {
    size_t i = 0;
    { // acquire lock
        // 通過(guò)鎖，可以保存 mMessageEnvelopes 的線程安全
        AutoMutex _l(mLock);
        // 獲取消息要插入的位置
        size_t messageCount = mMessageEnvelopes.size();
        while (i < messageCount && uptime >= mMessageEnvelopes.itemAt(i).uptime) {
            i += 1;
        }
        // 1. 把信息保存到 mMessageEnvelopes 中
        MessageEnvelope messageEnvelope(uptime, handler, message);
        mMessageEnvelopes.insertAt(messageEnvelope, i, 1);
        // mSendingMessage 表明 Looper 正在處理消息，因此不用喚醒Looper
        if (mSendingMessage) {
            return;
        }
    } // release lock
    // 2. 如有必要，就喚醒Looper
    if (i == 0) {
        wake();
    }
}

void Looper::wake() {
    uint64_t inc = 1;
    // 向 mWakeFd 中寫(xiě)入數(shù)據(jù)
    // TEMP_FAILURE_RETRY 是一個(gè)重試機(jī)制，確保不會(huì)因?yàn)橄到y(tǒng)中斷而導(dǎo)致數(shù)據(jù)沒(méi)有寫(xiě)入
    ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd.get(), &inc, sizeof(uint64_t)));
    // 確保寫(xiě)入的是 unsigned 64-bit 的數(shù)據(jù)
    if (nWrite != sizeof(uint64_t)) {
        if (errno != EAGAIN) {
            LOG_ALWAYS_FATAL("Could not write wake signal to fd %d (returned %zd): %s",
                             mWakeEventFd.get(), nWrite, strerror(errno));
        }
    }
}

int Looper::addFd(int fd, int ident, int events, const sp<LooperCallback>& callback, void* data) {
    // 1. 確認(rèn) ident 的值
    if (!callback.get()) { // 回調(diào)為空
        if (! mAllowNonCallbacks) { // mAllowNonCallbacks是在創(chuàng)建Looper時(shí)初始化的
            ALOGE("Invalid attempt to set NULL callback but not allowed for this looper.");
            return -1;
        }
        if (ident < 0) { // 回調(diào)為空，ident的值不能小于0
            ALOGE("Invalid attempt to set NULL callback with ident < 0.");
            return -1;
        }
    } else { // 回調(diào)不為空
        // POLL_CALLBACK值為-2，表示請(qǐng)求通過(guò)回調(diào)處理請(qǐng)求
        ident = POLL_CALLBACK;
    }
    { // acquire lock
        AutoMutex _l(mLock);
        // 2. 包裝成一個(gè) Request
        Request request;
        request.fd = fd;
        request.ident = ident;
        request.events = events;
        request.seq = mNextRequestSeq++;
        request.callback = callback;
        request.data = data;
        if (mNextRequestSeq == -1) mNextRequestSeq = 0; // reserve sequence number -1
        struct epoll_event eventItem;
        request.initEventItem(&eventItem);
        // 3. 用 epoll 對(duì)象監(jiān)聽(tīng) fd 的事件，并把請(qǐng)求保存到 mRequests 中
        ssize_t requestIndex = mRequests.indexOfKey(fd);
        if (requestIndex < 0) {
            int epollResult = epoll_ctl(mEpollFd.get(), EPOLL_CTL_ADD, fd, &eventItem);
            if (epollResult < 0) {
                ALOGE("Error adding epoll events for fd %d: %s", fd, strerror(errno));
                return -1;
            }
            mRequests.add(fd, request);
        } else {
            int epollResult = epoll_ctl(mEpollFd.get(), EPOLL_CTL_MOD, fd, &eventItem);
            if (epollResult < 0) {
                // ...
            }
            mRequests.replaceValueAt(requestIndex, request);
        }
    } // release lock
    return 1;
}

int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
    int result = 0;
    for (;;) { // 無(wú)限循環(huán)
        // 1. 處理那些不是通過(guò)callback處理的請(qǐng)求
        while (mResponseIndex < mResponses.size()) {
            // ...
        }
        // 2. 處理pollInner()輪詢的結(jié)果
        if (result != 0) {
            // ...
        }
        // 3. epoll 等待并處理事件(如果有事件到來(lái))
        result = pollInner(timeoutMillis);
    }
}

int Looper::pollInner(int timeoutMillis) {
    // 省略計(jì)算 timeoutMillis 的代碼
    int result = POLL_WAKE;
    mResponses.clear();
    mResponseIndex = 0;
    mPolling = true;
    struct epoll_event eventItems[EPOLL_MAX_EVENTS];
    // 1. 等待事件
    int eventCount = epoll_wait(mEpollFd.get(), eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
    // ...
}

int Looper::pollInner(int timeoutMillis) {
    // ...
    // 1. 等待I/O就緒
    int eventCount = epoll_wait(mEpollFd.get(), eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
    // ...
    // 2. 處理 epoll 事件
    for (int i = 0; i < eventCount; i++) {
        int fd = eventItems[i].data.fd;
        uint32_t epollEvents = eventItems[i].events;
        if (fd == mWakeEventFd.get()) { 
            // 2.1 處理被消息喚醒的情況
            if (epollEvents & EPOLLIN) {
                // 清理eventfd中的數(shù)據(jù)
                awoken();
            } else {
                ALOGW("Ignoring unexpected epoll events 0x%x on wake event fd.", epollEvents);
            }
        } else { 
            // 2.2 處理被請(qǐng)求喚醒的情況
            ssize_t requestIndex = mRequests.indexOfKey(fd);
            if (requestIndex >= 0) {
                // 根據(jù)epoll觸發(fā)的事件類型，填充events相應(yīng)的位
                int events = 0;
                if (epollEvents & EPOLLIN) events |= EVENT_INPUT;
                if (epollEvents & EPOLLOUT) events |= EVENT_OUTPUT;
                if (epollEvents & EPOLLERR) events |= EVENT_ERROR;
                if (epollEvents & EPOLLHUP) events |= EVENT_HANGUP;
                // 創(chuàng)建Response對(duì)象，保存兩個(gè)參數(shù)，然后把Response對(duì)象保存到mResponses中
                pushResponse(events, mRequests.valueAt(requestIndex));
            } else {
                ALOGW("Ignoring unexpected epoll events 0x%x on fd %d that is "
                        "no longer registered.", epollEvents, fd);
            }
        }
    }    
}

void Looper::pushResponse(int events, const Request& request) {
    Response response;
    response.events = events;
    response.request = request;
    mResponses.push(response);
}

int Looper::pollInner(int timeoutMillis) {
    // ...
    // 1. 等待I/O就緒
    int eventCount = epoll_wait(mEpollFd.get(), eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
    // ...
    // 2. 處理 epoll 事件
    for (int i = 0; i < eventCount; i++) {
        // ...
    }    
Done: ;
    mNextMessageUptime = LLONG_MAX;
    // 3. 處理消息
    while (mMessageEnvelopes.size() != 0) { // 循環(huán)處理消息
        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
        // 3.1 取出隊(duì)頭消息
        const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);
        if (messageEnvelope.uptime <= now) { 
            // 3.2 隊(duì)頭消息處理的時(shí)間點(diǎn)小于當(dāng)前時(shí)間點(diǎn)，表示要立即處理消息
            {
                // 獲取handler
                sp<MessageHandler> handler = messageEnvelope.handler;
                Message message = messageEnvelope.message;
                mMessageEnvelopes.removeAt(0);
                mSendingMessage = true;
                mLock.unlock();
                // 消息交給handler處理
                handler->handleMessage(message);
            } // release handler
            mLock.lock();
            mSendingMessage = false;
            // POLL_CALLBACK 表示消息被回調(diào)處理
            result = POLL_CALLBACK;
        } else {
            // 3.2 隊(duì)頭的消息處理的時(shí)間點(diǎn)大于當(dāng)前時(shí)間，表示還沒(méi)有到處理的時(shí)間點(diǎn)，就退出處理消息的循環(huán)
            // mNextMessageUptime 表示下一個(gè)消息要處理的時(shí)間點(diǎn)，當(dāng)通過(guò)break退出循環(huán)后，
            // 在外層的下一次循調(diào)用pollInner()時(shí)，會(huì)通過(guò) mNextMessageUptime 計(jì)算 epoll_wait 的超時(shí)時(shí)間
            mNextMessageUptime = messageEnvelope.uptime;
            break;
        }
    }
    // Release lock.
    mLock.unlock();    
}

int Looper::pollInner(int timeoutMillis) {
    // ...
    // 1. 等待事件
    int eventCount = epoll_wait(mEpollFd.get(), eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
    // ...
    // 2. 處理 epoll 事件
    for (int i = 0; i < eventCount; i++) {
        // ...
    }
Done: ;
    // 3. 處理消息
    while (mMessageEnvelopes.size() != 0) { // 循環(huán)處理消息
         // ...
    }
    // 4. 循環(huán)處理請(qǐng)求
    for (size_t i = 0; i < mResponses.size(); i++) {
        Response& response = mResponses.editItemAt(i);
        // 檢測(cè)請(qǐng)求是否通過(guò)回調(diào)處理
        if (response.request.ident == POLL_CALLBACK) {
            int fd = response.request.fd;
            int events = response.events;
            void* data = response.request.data;
            int callbackResult = response.request.callback->handleEvent(fd, events, data);
            if (callbackResult == 0) {
                removeFd(fd, response.request.seq);
            }
            response.request.callback.clear();
            // 表明消息被回調(diào)處理了
            result = POLL_CALLBACK;
        }
    }
    // 返回結(jié)果
    return result;
}

int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
    int result = 0;
    for (;;) { // 無(wú)限循環(huán)
        // 1. 處理那些不是通過(guò)callback處理的請(qǐng)求
        while (mResponseIndex < mResponses.size()) {
            const Response& response = mResponses.itemAt(mResponseIndex++);
            int ident = response.request.ident;
            // 從Looper::addFd()分析可知，只有當(dāng)callback為空的情況下，ident的值>=0，否則為POLL_CALLBACK(-2)
            // 因此，這里處理的是那些沒(méi)有通過(guò)callback處理的請(qǐng)求            
            if (ident >= 0) {
                int fd = response.request.fd;
                int events = response.events;
                void* data = response.request.data;
                // 因?yàn)長(zhǎng)ooper無(wú)法通過(guò)callback處理，所以把這些元數(shù)據(jù)交給調(diào)用者處理
                if (outFd != nullptr) *outFd = fd;
                if (outEvents != nullptr) *outEvents = events;
                if (outData != nullptr) *outData = data;
                // 注意，這里返回的值大于0
                return ident;
            }
        }
        // 2. 處理pollInner()輪詢的結(jié)果
        // result的值有很多種，但是都為負(fù)數(shù)(注意，上面處理那些不是通過(guò)callback處理的請(qǐng)求，返回正值)
        // 1. POLL_WAKE(-1): 表示epoll_wait()是被eventfd喚醒的
        // 1. POLL_ERROR(-4): 表示epoll_wait()出錯(cuò)
        // 2. POLL_TIMEOUT(-3) : 表示epoll_wait()超時(shí)
        // 3. POLL_CALLBACK(-2) : 表示消息或請(qǐng)求是通過(guò)回調(diào)處理的
        if (result != 0) {
            // 消息或事件無(wú)論是否被callback處理，這些傳入的參數(shù)都沒(méi)有意義，因此清空
            if (outFd != nullptr) *outFd = 0;
            if (outEvents != nullptr) *outEvents = 0;
            if (outData != nullptr) *outData = nullptr;
            // 注意，返回的是負(fù)值
            return result;
        }
        // 3. epoll 等待并處理事件(如果有事件到來(lái))
        result = pollInner(timeoutMillis);
    }
}