[android] Introduce RunLoop based on Looper

Also implement a Timer and AsyncTask based on Android's Looper.

platform/android/src/run_loop.cpp

@@ -0,0 +1,140 @@
+#include "run_loop_impl.hpp"
+
+#include <mbgl/util/thread_local.hpp>
+
+#include <android/looper.h>
+
+#include <algorithm>
+#include <cassert>
+#include <functional>
+#include <vector>
+
+namespace {
+
+using namespace mbgl::util;
+static ThreadLocal<RunLoop>& current = *new ThreadLocal<RunLoop>;
+
+} // namespace
+
+namespace mbgl {
+namespace util {
+
+void RunLoop::Impl::addRunnable(Runnable* runnable) {
+    std::lock_guard<std::recursive_mutex> lock(mtx);
+
+    if (runnable->iter == runnables.end()) {
+        auto iter = runnables.insert(runnables.end(), runnable);
+        runnable->iter = std::move(iter);
+    }
+
+    ALooper_wake(loop);
+}
+
+void RunLoop::Impl::removeRunnable(Runnable* runnable) {
+    std::lock_guard<std::recursive_mutex> lock(mtx);
+
+    if (runnable->iter != runnables.end()) {
+        runnables.erase(runnable->iter);
+        runnable->iter = runnables.end();
+    }
+}
+
+void RunLoop::Impl::initRunnable(Runnable* runnable) {
+    runnable->iter = runnables.end();
+}
+
+Milliseconds RunLoop::Impl::processRunnables() {
+    std::lock_guard<std::recursive_mutex> lock(mtx);
+
+    auto now = Clock::now();
+    auto nextDue = TimePoint::max();
+
+    // O(N) but in the render thread where we get tons
+    // of messages, the size of the list is usually 1~2.
+    for (auto iter = runnables.begin(); iter != runnables.end();) {
+        Runnable* runnable = *(iter++);
+
+        auto const dueTime = runnable->dueTime();
+        if (dueTime <= now) {
+            runnable->runTask();
+        } else {
+            nextDue = std::min(nextDue, dueTime);
+        }
+    }
+
+    if (runnables.empty() || nextDue == TimePoint::max()) {
+        return Milliseconds(-1);
+    } else {
+        return std::chrono::duration_cast<Milliseconds>(nextDue - now);
+    }
+}
+
+RunLoop* RunLoop::Get() {
+    return current.get();
+}
+
+RunLoop::RunLoop(Type) : impl(std::make_unique<Impl>()) {
+    impl->loop = ALooper_prepare(0);
+    assert(impl->loop);
+
+    ALooper_acquire(impl->loop);
+
+    current.set(this);
+}
+
+RunLoop::~RunLoop() {
+    current.set(nullptr);
+
+    ALooper_release(impl->loop);
+}
+
+LOOP_HANDLE RunLoop::getLoopHandle() {
+    return current.get()->impl.get();
+}
+
+void RunLoop::push(std::shared_ptr<WorkTask> task) {
+    withMutex([&] { queue.push(std::move(task)); });
+    ALooper_wake(impl->loop);
+}
+
+void RunLoop::run() {
+    MBGL_VERIFY_THREAD(tid);
+
+    impl->running = true;
+
+    int outFd, outEvents;
+    char *outData = nullptr;
+
+    while (impl->running) {
+        process();
+        auto timeout = impl->processRunnables().count();
+        ALooper_pollAll(timeout, &outFd, &outEvents, reinterpret_cast<void**>(&outData));
+    }
+}
+
+void RunLoop::runOnce() {
+    MBGL_VERIFY_THREAD(tid);
+
+    int outFd, outEvents;
+    char *outData = nullptr;
+
+    process();
+    impl->processRunnables().count();
+    ALooper_pollOnce(0, &outFd, &outEvents, reinterpret_cast<void**>(&outData));
+}
+
+void RunLoop::stop() {
+    impl->running = false;
+    ALooper_wake(impl->loop);
+}
+
+void RunLoop::addWatch(int, Event, std::function<void(int, Event)>&&) {
+    throw std::runtime_error("Not implemented.");
+}
+
+void RunLoop::removeWatch(int) {
+    throw std::runtime_error("Not implemented.");
+}
+
+} // namespace util
+} // namespace mbgl