blob: 90d32a58e9bb3898dfde5eacccf788c0babcf2ff [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/message_loop/message_pump_android.h"
#include <android/looper.h>
#include <errno.h>
#include <fcntl.h>
#include <jni.h>
#include <sys/eventfd.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include <utility>
#include "base/android/jni_android.h"
#include "base/android/scoped_java_ref.h"
#include "base/callback_helpers.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/run_loop.h"
#include "build/build_config.h"
// Android stripped sys/timerfd.h out of their platform headers, so we have to
// use syscall to make use of timerfd. Once the min API level is 20, we can
// directly use timerfd.h.
#ifndef __NR_timerfd_create
#error "Unable to find syscall for __NR_timerfd_create"
#define TFD_TIMER_ABSTIME (1 << 0)
using base::android::JavaParamRef;
using base::android::ScopedJavaLocalRef;
namespace base {
namespace {
// See sys/timerfd.h
int timerfd_create(int clockid, int flags) {
return syscall(__NR_timerfd_create, clockid, flags);
// See sys/timerfd.h
int timerfd_settime(int ufc,
int flags,
const struct itimerspec* utmr,
struct itimerspec* otmr) {
return syscall(__NR_timerfd_settime, ufc, flags, utmr, otmr);
// The stack may not be aligned when the ALooper calls
// into our code due to the inconsistent ABI on older Android OS versions.
#if defined(ARCH_CPU_X86)
#define STACK_ALIGN __attribute__((force_align_arg_pointer))
STACK_ALIGN int NonDelayedLooperCallback(int fd, int events, void* data) {
return 0;
MessagePumpForUI* pump = reinterpret_cast<MessagePumpForUI*>(data);
return 1; // continue listening for events
STACK_ALIGN int DelayedLooperCallback(int fd, int events, void* data) {
return 0;
MessagePumpForUI* pump = reinterpret_cast<MessagePumpForUI*>(data);
return 1; // continue listening for events
} // namespace
MessagePumpForUI::MessagePumpForUI() {
// The Android native ALooper uses epoll to poll our file descriptors and wake
// us up. We use a simple level-triggered eventfd to signal that non-delayed
// work is available, and a timerfd to signal when delayed work is ready to
// be run.
non_delayed_fd_ = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
CHECK_NE(non_delayed_fd_, -1);
DCHECK_EQ(TimeTicks::GetClock(), TimeTicks::Clock::LINUX_CLOCK_MONOTONIC);
// We can't create the timerfd with TFD_NONBLOCK | TFD_CLOEXEC as we can't
// include timerfd.h. See comments above on __NR_timerfd_create. It looks like
// they're just aliases to O_NONBLOCK and O_CLOEXEC anyways, so this should be
// fine.
delayed_fd_ = timerfd_create(CLOCK_MONOTONIC, O_NONBLOCK | O_CLOEXEC);
CHECK_NE(delayed_fd_, -1);
looper_ = ALooper_prepare(0);
// Add a reference to the looper so it isn't deleted on us.
ALooper_addFd(looper_, non_delayed_fd_, 0, ALOOPER_EVENT_INPUT,
&NonDelayedLooperCallback, reinterpret_cast<void*>(this));
ALooper_addFd(looper_, delayed_fd_, 0, ALOOPER_EVENT_INPUT,
&DelayedLooperCallback, reinterpret_cast<void*>(this));
MessagePumpForUI::~MessagePumpForUI() {
DCHECK_EQ(ALooper_forThread(), looper_);
ALooper_removeFd(looper_, non_delayed_fd_);
ALooper_removeFd(looper_, delayed_fd_);
looper_ = nullptr;
void MessagePumpForUI::OnDelayedLooperCallback() {
// ALooper_pollOnce may call this after Quit() if OnNonDelayedLooperCallback()
// resulted in Quit() in the same round.
if (ShouldQuit())
// Clear the fd.
uint64_t value;
int ret = read(delayed_fd_, &value, sizeof(value));
// TODO(mthiesse): Figure out how it's possible to hit EAGAIN here.
// According to
// EAGAIN only happens if no timer has expired. Also according to the man page
// poll only returns readable when a timer has expired. So this function will
// only be called when a timer has expired, but reading reveals no timer has
// expired...
// Quit() and ScheduleDelayedWork() are the only other functions that touch
// the timerfd, and they both run on the same thread as this callback, so
// there are no obvious timing or multi-threading related issues.
DPCHECK(ret >= 0 || errno == EAGAIN);
Delegate::NextWorkInfo next_work_info = delegate_->DoSomeWork();
if (ShouldQuit())
if (next_work_info.is_immediate()) {
if (!next_work_info.delayed_run_time.is_max())
void MessagePumpForUI::OnNonDelayedLooperCallback() {
// ALooper_pollOnce may call this after Quit() if OnDelayedLooperCallback()
// resulted in Quit() in the same round.
if (ShouldQuit())
// A bit added to the |non_delayed_fd_| to keep it signaled when we yield to
// native tasks below.
constexpr uint64_t kTryNativeTasksBeforeIdleBit = uint64_t(1) << 32;
// We're about to process all the work requested by ScheduleWork().
// MessagePump users are expected to do their best not to invoke
// ScheduleWork() again before DoSomeWork() returns a non-immediate
// NextWorkInfo below. Hence, capturing the file descriptor's value now and
// resetting its contents to 0 should be okay. The value currently stored
// should be greater than 0 since work having been scheduled is the reason
// we're here. See
uint64_t pre_work_value = 0;
int ret = read(non_delayed_fd_, &pre_work_value, sizeof(pre_work_value));
DPCHECK(ret >= 0);
DCHECK_GT(pre_work_value, 0U);
// Note: We can't skip DoSomeWork() even if
// |pre_work_value == kTryNativeTasksBeforeIdleBit| here (i.e. no additional
// ScheduleWork() since yielding to native) as delayed tasks might have come
// in and we need to re-sample |next_work_info|.
// Runs all application tasks scheduled to run.
Delegate::NextWorkInfo next_work_info;
do {
if (ShouldQuit())
next_work_info = delegate_->DoSomeWork();
} while (next_work_info.is_immediate());
// Do not resignal |non_delayed_fd_| if we're quitting (this pump doesn't
// allow nesting so needing to resume in an outer loop is not an issue
// either).
if (ShouldQuit())
// Before declaring this loop idle, yield to native tasks and arrange to be
// called again (unless we're already in that second call).
if (pre_work_value != kTryNativeTasksBeforeIdleBit) {
// Note: This write() is racing with potential ScheduleWork() calls. This is
// fine as write() is adding this bit, not overwriting the existing value,
// and as such racing ScheduleWork() calls would merely add 1 to the lower
// bits and we would find |pre_work_value != kTryNativeTasksBeforeIdleBit|
// in the next cycle again, retrying this.
ret = write(non_delayed_fd_, &kTryNativeTasksBeforeIdleBit,
DPCHECK(ret >= 0);
// We yielded to native tasks already and they didn't generate a
// ScheduleWork() request so we can declare idleness. It's possible for a
// ScheduleWork() request to come in racily while this method unwinds, this is
// fine and will merely result in it being re-invoked shortly after it
// returns.
// TODO(scheduler-dev): this doesn't account for tasks that don't ever call
// SchedulerWork() but still keep the system non-idle (e.g., the Java Handler
// API). It would be better to add an API to query the presence of native
// tasks instead of relying on yielding once + kTryNativeTasksBeforeIdleBit.
DCHECK_EQ(pre_work_value, kTryNativeTasksBeforeIdleBit);
if (ShouldQuit())
// At this point, the java looper might not be idle - it's impossible to know
// pre-Android-M, so we may end up doing Idle work while java tasks are still
// queued up. Note that this won't cause us to fail to run java tasks using
// QuitWhenIdle, as the JavaHandlerThread will finish running all currently
// scheduled tasks before it quits. Also note that we can't just add an idle
// callback to the java looper, as that will fire even if application tasks
// are still queued up.
if (!next_work_info.delayed_run_time.is_max())
void MessagePumpForUI::DoIdleWork() {
if (delegate_->DoIdleWork()) {
// If DoIdleWork() resulted in any work, we're not idle yet. We need to pump
// the loop here because we may in fact be idle after doing idle work
// without any new tasks being queued.
void MessagePumpForUI::Run(Delegate* delegate) {
// This function is only called in tests. We manually pump the native looper
// which won't run any java tasks.
quit_ = false;
// Pump the loop once in case we're starting off idle as ALooper_pollOnce will
// never return in that case.
while (true) {
// Waits for either the delayed, or non-delayed fds to be signalled, calling
// either OnDelayedLooperCallback, or OnNonDelayedLooperCallback,
// respectively. This uses Android's Looper implementation, which is based
// off of epoll.
ALooper_pollOnce(-1, nullptr, nullptr, nullptr);
if (quit_)
void MessagePumpForUI::Attach(Delegate* delegate) {
// Since the Looper is controlled by the UI thread or JavaHandlerThread, we
// can't use Run() like we do on other platforms or we would prevent Java
// tasks from running. Instead we create and initialize a run loop here, then
// return control back to the Looper.
run_loop_ = std::make_unique<RunLoop>();
// Since the RunLoop was just created above, BeforeRun should be guaranteed to
// return true (it only returns false if the RunLoop has been Quit already).
if (!run_loop_->BeforeRun())
void MessagePumpForUI::Quit() {
if (quit_)
quit_ = true;
int64_t value;
// Clear any pending timer.
read(delayed_fd_, &value, sizeof(value));
// Clear the eventfd.
read(non_delayed_fd_, &value, sizeof(value));
if (run_loop_) {
run_loop_ = nullptr;
if (on_quit_callback_) {
void MessagePumpForUI::ScheduleWork() {
// Write (add) 1 to the eventfd. This tells the Looper to wake up and call our
// callback, allowing us to run tasks. This also allows us to detect, when we
// clear the fd, whether additional work was scheduled after we finished
// performing work, but before we cleared the fd, as we'll read back >=2
// instead of 1 in that case.
// See the eventfd man pages
// ( for details on how
// the read and write APIs for this file descriptor work, specifically without
uint64_t value = 1;
int ret = write(non_delayed_fd_, &value, sizeof(value));
DPCHECK(ret >= 0);
void MessagePumpForUI::ScheduleDelayedWork(const TimeTicks& delayed_work_time) {
if (ShouldQuit())
if (delayed_scheduled_time_ && *delayed_scheduled_time_ == delayed_work_time)
delayed_scheduled_time_ = delayed_work_time;
int64_t nanos = delayed_work_time.since_origin().InNanoseconds();
struct itimerspec ts;
ts.it_interval.tv_sec = 0; // Don't repeat.
ts.it_interval.tv_nsec = 0;
ts.it_value.tv_sec = nanos / TimeTicks::kNanosecondsPerSecond;
ts.it_value.tv_nsec = nanos % TimeTicks::kNanosecondsPerSecond;
int ret = timerfd_settime(delayed_fd_, TFD_TIMER_ABSTIME, &ts, nullptr);
DPCHECK(ret >= 0);
void MessagePumpForUI::QuitWhenIdle(base::OnceClosure callback) {
on_quit_callback_ = std::move(callback);
// Pump the loop in case we're already idle.
bool MessagePumpForUI::IsTestImplementation() const {
return false;
} // namespace base