• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright 2010 The Android Open Source Project
3 //
4 // A looper implementation based on epoll().
5 //
6 #define LOG_TAG "Looper"
7 
8 //#define LOG_NDEBUG 0
9 
10 // Debugs poll and wake interactions.
11 #define DEBUG_POLL_AND_WAKE 0
12 
13 // Debugs callback registration and invocation.
14 #define DEBUG_CALLBACKS 0
15 
16 #include <cutils/log.h>
17 #include <utils/Looper.h>
18 #include <utils/Timers.h>
19 
20 #include <unistd.h>
21 #include <fcntl.h>
22 #include <limits.h>
23 #include <inttypes.h>
24 #include <sys/eventfd.h>
25 
26 
27 namespace android {
28 
29 // --- WeakMessageHandler ---
30 
WeakMessageHandler(const wp<MessageHandler> & handler)31 WeakMessageHandler::WeakMessageHandler(const wp<MessageHandler>& handler) :
32         mHandler(handler) {
33 }
34 
~WeakMessageHandler()35 WeakMessageHandler::~WeakMessageHandler() {
36 }
37 
handleMessage(const Message & message)38 void WeakMessageHandler::handleMessage(const Message& message) {
39     sp<MessageHandler> handler = mHandler.promote();
40     if (handler != NULL) {
41         handler->handleMessage(message);
42     }
43 }
44 
45 
46 // --- SimpleLooperCallback ---
47 
SimpleLooperCallback(Looper_callbackFunc callback)48 SimpleLooperCallback::SimpleLooperCallback(Looper_callbackFunc callback) :
49         mCallback(callback) {
50 }
51 
~SimpleLooperCallback()52 SimpleLooperCallback::~SimpleLooperCallback() {
53 }
54 
handleEvent(int fd,int events,void * data)55 int SimpleLooperCallback::handleEvent(int fd, int events, void* data) {
56     return mCallback(fd, events, data);
57 }
58 
59 
60 // --- Looper ---
61 
62 // Hint for number of file descriptors to be associated with the epoll instance.
63 static const int EPOLL_SIZE_HINT = 8;
64 
65 // Maximum number of file descriptors for which to retrieve poll events each iteration.
66 static const int EPOLL_MAX_EVENTS = 16;
67 
68 static pthread_once_t gTLSOnce = PTHREAD_ONCE_INIT;
69 static pthread_key_t gTLSKey = 0;
70 
Looper(bool allowNonCallbacks)71 Looper::Looper(bool allowNonCallbacks) :
72         mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),
73         mPolling(false), mEpollFd(-1), mEpollRebuildRequired(false),
74         mNextRequestSeq(0), mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {
75     mWakeEventFd = eventfd(0, EFD_NONBLOCK);
76     LOG_ALWAYS_FATAL_IF(mWakeEventFd < 0, "Could not make wake event fd.  errno=%d", errno);
77 
78     AutoMutex _l(mLock);
79     rebuildEpollLocked();
80 }
81 
~Looper()82 Looper::~Looper() {
83     close(mWakeEventFd);
84     if (mEpollFd >= 0) {
85         close(mEpollFd);
86     }
87 }
88 
initTLSKey()89 void Looper::initTLSKey() {
90     int result = pthread_key_create(& gTLSKey, threadDestructor);
91     LOG_ALWAYS_FATAL_IF(result != 0, "Could not allocate TLS key.");
92 }
93 
threadDestructor(void * st)94 void Looper::threadDestructor(void *st) {
95     Looper* const self = static_cast<Looper*>(st);
96     if (self != NULL) {
97         self->decStrong((void*)threadDestructor);
98     }
99 }
100 
setForThread(const sp<Looper> & looper)101 void Looper::setForThread(const sp<Looper>& looper) {
102     sp<Looper> old = getForThread(); // also has side-effect of initializing TLS
103 
104     if (looper != NULL) {
105         looper->incStrong((void*)threadDestructor);
106     }
107 
108     pthread_setspecific(gTLSKey, looper.get());
109 
110     if (old != NULL) {
111         old->decStrong((void*)threadDestructor);
112     }
113 }
114 
getForThread()115 sp<Looper> Looper::getForThread() {
116     int result = pthread_once(& gTLSOnce, initTLSKey);
117     LOG_ALWAYS_FATAL_IF(result != 0, "pthread_once failed");
118 
119     return (Looper*)pthread_getspecific(gTLSKey);
120 }
121 
prepare(int opts)122 sp<Looper> Looper::prepare(int opts) {
123     bool allowNonCallbacks = opts & PREPARE_ALLOW_NON_CALLBACKS;
124     sp<Looper> looper = Looper::getForThread();
125     if (looper == NULL) {
126         looper = new Looper(allowNonCallbacks);
127         Looper::setForThread(looper);
128     }
129     if (looper->getAllowNonCallbacks() != allowNonCallbacks) {
130         ALOGW("Looper already prepared for this thread with a different value for the "
131                 "LOOPER_PREPARE_ALLOW_NON_CALLBACKS option.");
132     }
133     return looper;
134 }
135 
getAllowNonCallbacks() const136 bool Looper::getAllowNonCallbacks() const {
137     return mAllowNonCallbacks;
138 }
139 
rebuildEpollLocked()140 void Looper::rebuildEpollLocked() {
141     // Close old epoll instance if we have one.
142     if (mEpollFd >= 0) {
143 #if DEBUG_CALLBACKS
144         ALOGD("%p ~ rebuildEpollLocked - rebuilding epoll set", this);
145 #endif
146         close(mEpollFd);
147     }
148 
149     // Allocate the new epoll instance and register the wake pipe.
150     mEpollFd = epoll_create(EPOLL_SIZE_HINT);
151     LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);
152 
153     struct epoll_event eventItem;
154     memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union
155     eventItem.events = EPOLLIN;
156     eventItem.data.fd = mWakeEventFd;
157     int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeEventFd, & eventItem);
158     LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake event fd to epoll instance.  errno=%d",
159             errno);
160 
161     for (size_t i = 0; i < mRequests.size(); i++) {
162         const Request& request = mRequests.valueAt(i);
163         struct epoll_event eventItem;
164         request.initEventItem(&eventItem);
165 
166         int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, request.fd, & eventItem);
167         if (epollResult < 0) {
168             ALOGE("Error adding epoll events for fd %d while rebuilding epoll set, errno=%d",
169                     request.fd, errno);
170         }
171     }
172 }
173 
scheduleEpollRebuildLocked()174 void Looper::scheduleEpollRebuildLocked() {
175     if (!mEpollRebuildRequired) {
176 #if DEBUG_CALLBACKS
177         ALOGD("%p ~ scheduleEpollRebuildLocked - scheduling epoll set rebuild", this);
178 #endif
179         mEpollRebuildRequired = true;
180         wake();
181     }
182 }
183 
pollOnce(int timeoutMillis,int * outFd,int * outEvents,void ** outData)184 int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
185     int result = 0;
186     for (;;) {
187         while (mResponseIndex < mResponses.size()) {
188             const Response& response = mResponses.itemAt(mResponseIndex++);
189             int ident = response.request.ident;
190             if (ident >= 0) {
191                 int fd = response.request.fd;
192                 int events = response.events;
193                 void* data = response.request.data;
194 #if DEBUG_POLL_AND_WAKE
195                 ALOGD("%p ~ pollOnce - returning signalled identifier %d: "
196                         "fd=%d, events=0x%x, data=%p",
197                         this, ident, fd, events, data);
198 #endif
199                 if (outFd != NULL) *outFd = fd;
200                 if (outEvents != NULL) *outEvents = events;
201                 if (outData != NULL) *outData = data;
202                 return ident;
203             }
204         }
205 
206         if (result != 0) {
207 #if DEBUG_POLL_AND_WAKE
208             ALOGD("%p ~ pollOnce - returning result %d", this, result);
209 #endif
210             if (outFd != NULL) *outFd = 0;
211             if (outEvents != NULL) *outEvents = 0;
212             if (outData != NULL) *outData = NULL;
213             return result;
214         }
215 
216         result = pollInner(timeoutMillis);
217     }
218 }
219 
pollInner(int timeoutMillis)220 int Looper::pollInner(int timeoutMillis) {
221 #if DEBUG_POLL_AND_WAKE
222     ALOGD("%p ~ pollOnce - waiting: timeoutMillis=%d", this, timeoutMillis);
223 #endif
224 
225     // Adjust the timeout based on when the next message is due.
226     if (timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {
227         nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
228         int messageTimeoutMillis = toMillisecondTimeoutDelay(now, mNextMessageUptime);
229         if (messageTimeoutMillis >= 0
230                 && (timeoutMillis < 0 || messageTimeoutMillis < timeoutMillis)) {
231             timeoutMillis = messageTimeoutMillis;
232         }
233 #if DEBUG_POLL_AND_WAKE
234         ALOGD("%p ~ pollOnce - next message in %" PRId64 "ns, adjusted timeout: timeoutMillis=%d",
235                 this, mNextMessageUptime - now, timeoutMillis);
236 #endif
237     }
238 
239     // Poll.
240     int result = POLL_WAKE;
241     mResponses.clear();
242     mResponseIndex = 0;
243 
244     // We are about to idle.
245     mPolling = true;
246 
247     struct epoll_event eventItems[EPOLL_MAX_EVENTS];
248     int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
249 
250     // No longer idling.
251     mPolling = false;
252 
253     // Acquire lock.
254     mLock.lock();
255 
256     // Rebuild epoll set if needed.
257     if (mEpollRebuildRequired) {
258         mEpollRebuildRequired = false;
259         rebuildEpollLocked();
260         goto Done;
261     }
262 
263     // Check for poll error.
264     if (eventCount < 0) {
265         if (errno == EINTR) {
266             goto Done;
267         }
268         ALOGW("Poll failed with an unexpected error, errno=%d", errno);
269         result = POLL_ERROR;
270         goto Done;
271     }
272 
273     // Check for poll timeout.
274     if (eventCount == 0) {
275 #if DEBUG_POLL_AND_WAKE
276         ALOGD("%p ~ pollOnce - timeout", this);
277 #endif
278         result = POLL_TIMEOUT;
279         goto Done;
280     }
281 
282     // Handle all events.
283 #if DEBUG_POLL_AND_WAKE
284     ALOGD("%p ~ pollOnce - handling events from %d fds", this, eventCount);
285 #endif
286 
287     for (int i = 0; i < eventCount; i++) {
288         int fd = eventItems[i].data.fd;
289         uint32_t epollEvents = eventItems[i].events;
290         if (fd == mWakeEventFd) {
291             if (epollEvents & EPOLLIN) {
292                 awoken();
293             } else {
294                 ALOGW("Ignoring unexpected epoll events 0x%x on wake event fd.", epollEvents);
295             }
296         } else {
297             ssize_t requestIndex = mRequests.indexOfKey(fd);
298             if (requestIndex >= 0) {
299                 int events = 0;
300                 if (epollEvents & EPOLLIN) events |= EVENT_INPUT;
301                 if (epollEvents & EPOLLOUT) events |= EVENT_OUTPUT;
302                 if (epollEvents & EPOLLERR) events |= EVENT_ERROR;
303                 if (epollEvents & EPOLLHUP) events |= EVENT_HANGUP;
304                 pushResponse(events, mRequests.valueAt(requestIndex));
305             } else {
306                 ALOGW("Ignoring unexpected epoll events 0x%x on fd %d that is "
307                         "no longer registered.", epollEvents, fd);
308             }
309         }
310     }
311 Done: ;
312 
313     // Invoke pending message callbacks.
314     mNextMessageUptime = LLONG_MAX;
315     while (mMessageEnvelopes.size() != 0) {
316         nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
317         const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);
318         if (messageEnvelope.uptime <= now) {
319             // Remove the envelope from the list.
320             // We keep a strong reference to the handler until the call to handleMessage
321             // finishes.  Then we drop it so that the handler can be deleted *before*
322             // we reacquire our lock.
323             { // obtain handler
324                 sp<MessageHandler> handler = messageEnvelope.handler;
325                 Message message = messageEnvelope.message;
326                 mMessageEnvelopes.removeAt(0);
327                 mSendingMessage = true;
328                 mLock.unlock();
329 
330 #if DEBUG_POLL_AND_WAKE || DEBUG_CALLBACKS
331                 ALOGD("%p ~ pollOnce - sending message: handler=%p, what=%d",
332                         this, handler.get(), message.what);
333 #endif
334                 handler->handleMessage(message);
335             } // release handler
336 
337             mLock.lock();
338             mSendingMessage = false;
339             result = POLL_CALLBACK;
340         } else {
341             // The last message left at the head of the queue determines the next wakeup time.
342             mNextMessageUptime = messageEnvelope.uptime;
343             break;
344         }
345     }
346 
347     // Release lock.
348     mLock.unlock();
349 
350     // Invoke all response callbacks.
351     for (size_t i = 0; i < mResponses.size(); i++) {
352         Response& response = mResponses.editItemAt(i);
353         if (response.request.ident == POLL_CALLBACK) {
354             int fd = response.request.fd;
355             int events = response.events;
356             void* data = response.request.data;
357 #if DEBUG_POLL_AND_WAKE || DEBUG_CALLBACKS
358             ALOGD("%p ~ pollOnce - invoking fd event callback %p: fd=%d, events=0x%x, data=%p",
359                     this, response.request.callback.get(), fd, events, data);
360 #endif
361             // Invoke the callback.  Note that the file descriptor may be closed by
362             // the callback (and potentially even reused) before the function returns so
363             // we need to be a little careful when removing the file descriptor afterwards.
364             int callbackResult = response.request.callback->handleEvent(fd, events, data);
365             if (callbackResult == 0) {
366                 removeFd(fd, response.request.seq);
367             }
368 
369             // Clear the callback reference in the response structure promptly because we
370             // will not clear the response vector itself until the next poll.
371             response.request.callback.clear();
372             result = POLL_CALLBACK;
373         }
374     }
375     return result;
376 }
377 
pollAll(int timeoutMillis,int * outFd,int * outEvents,void ** outData)378 int Looper::pollAll(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
379     if (timeoutMillis <= 0) {
380         int result;
381         do {
382             result = pollOnce(timeoutMillis, outFd, outEvents, outData);
383         } while (result == POLL_CALLBACK);
384         return result;
385     } else {
386         nsecs_t endTime = systemTime(SYSTEM_TIME_MONOTONIC)
387                 + milliseconds_to_nanoseconds(timeoutMillis);
388 
389         for (;;) {
390             int result = pollOnce(timeoutMillis, outFd, outEvents, outData);
391             if (result != POLL_CALLBACK) {
392                 return result;
393             }
394 
395             nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
396             timeoutMillis = toMillisecondTimeoutDelay(now, endTime);
397             if (timeoutMillis == 0) {
398                 return POLL_TIMEOUT;
399             }
400         }
401     }
402 }
403 
wake()404 void Looper::wake() {
405 #if DEBUG_POLL_AND_WAKE
406     ALOGD("%p ~ wake", this);
407 #endif
408 
409     uint64_t inc = 1;
410     ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd, &inc, sizeof(uint64_t)));
411     if (nWrite != sizeof(uint64_t)) {
412         if (errno != EAGAIN) {
413             ALOGW("Could not write wake signal, errno=%d", errno);
414         }
415     }
416 }
417 
awoken()418 void Looper::awoken() {
419 #if DEBUG_POLL_AND_WAKE
420     ALOGD("%p ~ awoken", this);
421 #endif
422 
423     uint64_t counter;
424     TEMP_FAILURE_RETRY(read(mWakeEventFd, &counter, sizeof(uint64_t)));
425 }
426 
pushResponse(int events,const Request & request)427 void Looper::pushResponse(int events, const Request& request) {
428     Response response;
429     response.events = events;
430     response.request = request;
431     mResponses.push(response);
432 }
433 
addFd(int fd,int ident,int events,Looper_callbackFunc callback,void * data)434 int Looper::addFd(int fd, int ident, int events, Looper_callbackFunc callback, void* data) {
435     return addFd(fd, ident, events, callback ? new SimpleLooperCallback(callback) : NULL, data);
436 }
437 
addFd(int fd,int ident,int events,const sp<LooperCallback> & callback,void * data)438 int Looper::addFd(int fd, int ident, int events, const sp<LooperCallback>& callback, void* data) {
439 #if DEBUG_CALLBACKS
440     ALOGD("%p ~ addFd - fd=%d, ident=%d, events=0x%x, callback=%p, data=%p", this, fd, ident,
441             events, callback.get(), data);
442 #endif
443 
444     if (!callback.get()) {
445         if (! mAllowNonCallbacks) {
446             ALOGE("Invalid attempt to set NULL callback but not allowed for this looper.");
447             return -1;
448         }
449 
450         if (ident < 0) {
451             ALOGE("Invalid attempt to set NULL callback with ident < 0.");
452             return -1;
453         }
454     } else {
455         ident = POLL_CALLBACK;
456     }
457 
458     { // acquire lock
459         AutoMutex _l(mLock);
460 
461         Request request;
462         request.fd = fd;
463         request.ident = ident;
464         request.events = events;
465         request.seq = mNextRequestSeq++;
466         request.callback = callback;
467         request.data = data;
468         if (mNextRequestSeq == -1) mNextRequestSeq = 0; // reserve sequence number -1
469 
470         struct epoll_event eventItem;
471         request.initEventItem(&eventItem);
472 
473         ssize_t requestIndex = mRequests.indexOfKey(fd);
474         if (requestIndex < 0) {
475             int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);
476             if (epollResult < 0) {
477                 ALOGE("Error adding epoll events for fd %d, errno=%d", fd, errno);
478                 return -1;
479             }
480             mRequests.add(fd, request);
481         } else {
482             int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_MOD, fd, & eventItem);
483             if (epollResult < 0) {
484                 if (errno == ENOENT) {
485                     // Tolerate ENOENT because it means that an older file descriptor was
486                     // closed before its callback was unregistered and meanwhile a new
487                     // file descriptor with the same number has been created and is now
488                     // being registered for the first time.  This error may occur naturally
489                     // when a callback has the side-effect of closing the file descriptor
490                     // before returning and unregistering itself.  Callback sequence number
491                     // checks further ensure that the race is benign.
492                     //
493                     // Unfortunately due to kernel limitations we need to rebuild the epoll
494                     // set from scratch because it may contain an old file handle that we are
495                     // now unable to remove since its file descriptor is no longer valid.
496                     // No such problem would have occurred if we were using the poll system
497                     // call instead, but that approach carries others disadvantages.
498 #if DEBUG_CALLBACKS
499                     ALOGD("%p ~ addFd - EPOLL_CTL_MOD failed due to file descriptor "
500                             "being recycled, falling back on EPOLL_CTL_ADD, errno=%d",
501                             this, errno);
502 #endif
503                     epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);
504                     if (epollResult < 0) {
505                         ALOGE("Error modifying or adding epoll events for fd %d, errno=%d",
506                                 fd, errno);
507                         return -1;
508                     }
509                     scheduleEpollRebuildLocked();
510                 } else {
511                     ALOGE("Error modifying epoll events for fd %d, errno=%d", fd, errno);
512                     return -1;
513                 }
514             }
515             mRequests.replaceValueAt(requestIndex, request);
516         }
517     } // release lock
518     return 1;
519 }
520 
removeFd(int fd)521 int Looper::removeFd(int fd) {
522     return removeFd(fd, -1);
523 }
524 
removeFd(int fd,int seq)525 int Looper::removeFd(int fd, int seq) {
526 #if DEBUG_CALLBACKS
527     ALOGD("%p ~ removeFd - fd=%d, seq=%d", this, fd, seq);
528 #endif
529 
530     { // acquire lock
531         AutoMutex _l(mLock);
532         ssize_t requestIndex = mRequests.indexOfKey(fd);
533         if (requestIndex < 0) {
534             return 0;
535         }
536 
537         // Check the sequence number if one was given.
538         if (seq != -1 && mRequests.valueAt(requestIndex).seq != seq) {
539 #if DEBUG_CALLBACKS
540             ALOGD("%p ~ removeFd - sequence number mismatch, oldSeq=%d",
541                     this, mRequests.valueAt(requestIndex).seq);
542 #endif
543             return 0;
544         }
545 
546         // Always remove the FD from the request map even if an error occurs while
547         // updating the epoll set so that we avoid accidentally leaking callbacks.
548         mRequests.removeItemsAt(requestIndex);
549 
550         int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_DEL, fd, NULL);
551         if (epollResult < 0) {
552             if (seq != -1 && (errno == EBADF || errno == ENOENT)) {
553                 // Tolerate EBADF or ENOENT when the sequence number is known because it
554                 // means that the file descriptor was closed before its callback was
555                 // unregistered.  This error may occur naturally when a callback has the
556                 // side-effect of closing the file descriptor before returning and
557                 // unregistering itself.
558                 //
559                 // Unfortunately due to kernel limitations we need to rebuild the epoll
560                 // set from scratch because it may contain an old file handle that we are
561                 // now unable to remove since its file descriptor is no longer valid.
562                 // No such problem would have occurred if we were using the poll system
563                 // call instead, but that approach carries others disadvantages.
564 #if DEBUG_CALLBACKS
565                 ALOGD("%p ~ removeFd - EPOLL_CTL_DEL failed due to file descriptor "
566                         "being closed, errno=%d", this, errno);
567 #endif
568                 scheduleEpollRebuildLocked();
569             } else {
570                 // Some other error occurred.  This is really weird because it means
571                 // our list of callbacks got out of sync with the epoll set somehow.
572                 // We defensively rebuild the epoll set to avoid getting spurious
573                 // notifications with nowhere to go.
574                 ALOGE("Error removing epoll events for fd %d, errno=%d", fd, errno);
575                 scheduleEpollRebuildLocked();
576                 return -1;
577             }
578         }
579     } // release lock
580     return 1;
581 }
582 
sendMessage(const sp<MessageHandler> & handler,const Message & message)583 void Looper::sendMessage(const sp<MessageHandler>& handler, const Message& message) {
584     nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
585     sendMessageAtTime(now, handler, message);
586 }
587 
sendMessageDelayed(nsecs_t uptimeDelay,const sp<MessageHandler> & handler,const Message & message)588 void Looper::sendMessageDelayed(nsecs_t uptimeDelay, const sp<MessageHandler>& handler,
589         const Message& message) {
590     nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
591     sendMessageAtTime(now + uptimeDelay, handler, message);
592 }
593 
sendMessageAtTime(nsecs_t uptime,const sp<MessageHandler> & handler,const Message & message)594 void Looper::sendMessageAtTime(nsecs_t uptime, const sp<MessageHandler>& handler,
595         const Message& message) {
596 #if DEBUG_CALLBACKS
597     ALOGD("%p ~ sendMessageAtTime - uptime=%" PRId64 ", handler=%p, what=%d",
598             this, uptime, handler.get(), message.what);
599 #endif
600 
601     size_t i = 0;
602     { // acquire lock
603         AutoMutex _l(mLock);
604 
605         size_t messageCount = mMessageEnvelopes.size();
606         while (i < messageCount && uptime >= mMessageEnvelopes.itemAt(i).uptime) {
607             i += 1;
608         }
609 
610         MessageEnvelope messageEnvelope(uptime, handler, message);
611         mMessageEnvelopes.insertAt(messageEnvelope, i, 1);
612 
613         // Optimization: If the Looper is currently sending a message, then we can skip
614         // the call to wake() because the next thing the Looper will do after processing
615         // messages is to decide when the next wakeup time should be.  In fact, it does
616         // not even matter whether this code is running on the Looper thread.
617         if (mSendingMessage) {
618             return;
619         }
620     } // release lock
621 
622     // Wake the poll loop only when we enqueue a new message at the head.
623     if (i == 0) {
624         wake();
625     }
626 }
627 
removeMessages(const sp<MessageHandler> & handler)628 void Looper::removeMessages(const sp<MessageHandler>& handler) {
629 #if DEBUG_CALLBACKS
630     ALOGD("%p ~ removeMessages - handler=%p", this, handler.get());
631 #endif
632 
633     { // acquire lock
634         AutoMutex _l(mLock);
635 
636         for (size_t i = mMessageEnvelopes.size(); i != 0; ) {
637             const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(--i);
638             if (messageEnvelope.handler == handler) {
639                 mMessageEnvelopes.removeAt(i);
640             }
641         }
642     } // release lock
643 }
644 
removeMessages(const sp<MessageHandler> & handler,int what)645 void Looper::removeMessages(const sp<MessageHandler>& handler, int what) {
646 #if DEBUG_CALLBACKS
647     ALOGD("%p ~ removeMessages - handler=%p, what=%d", this, handler.get(), what);
648 #endif
649 
650     { // acquire lock
651         AutoMutex _l(mLock);
652 
653         for (size_t i = mMessageEnvelopes.size(); i != 0; ) {
654             const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(--i);
655             if (messageEnvelope.handler == handler
656                     && messageEnvelope.message.what == what) {
657                 mMessageEnvelopes.removeAt(i);
658             }
659         }
660     } // release lock
661 }
662 
isPolling() const663 bool Looper::isPolling() const {
664     return mPolling;
665 }
666 
initEventItem(struct epoll_event * eventItem) const667 void Looper::Request::initEventItem(struct epoll_event* eventItem) const {
668     int epollEvents = 0;
669     if (events & EVENT_INPUT) epollEvents |= EPOLLIN;
670     if (events & EVENT_OUTPUT) epollEvents |= EPOLLOUT;
671 
672     memset(eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union
673     eventItem->events = epollEvents;
674     eventItem->data.fd = fd;
675 }
676 
677 } // namespace android
678