[android] Android specific thread pool that keeps threads attached to…

… JVM

platform/android/core-files.json

@@ -85,13 +85,14 @@
         "platform/android/src/thread.cpp",
         "platform/android/src/timer.cpp",
         "platform/android/src/unaccent.cpp",
+        "platform/android/src/android_thread_pool.cpp",
+        "platform/android/src/shared_thread_pool.cpp",
         "platform/default/src/mbgl/gl/headless_backend.cpp",
         "platform/default/src/mbgl/gl/headless_frontend.cpp",
         "platform/default/src/mbgl/map/map_snapshotter.cpp",
         "platform/default/src/mbgl/text/bidi.cpp",
         "platform/default/src/mbgl/util/default_thread_pool.cpp",
         "platform/default/src/mbgl/util/png_writer.cpp",
-        "platform/default/src/mbgl/util/shared_thread_pool.cpp",
         "platform/default/src/mbgl/util/thread_local.cpp",
         "platform/default/src/mbgl/util/utf.cpp",
         "platform/linux/src/headless_backend_egl.cpp"
@@ -150,6 +151,7 @@
         "map_renderer_runnable.hpp": "platform/android/src/map_renderer_runnable.hpp",
         "native_map_view.hpp": "platform/android/src/native_map_view.hpp",
         "run_loop_impl.hpp": "platform/android/src/run_loop_impl.hpp",
+        "android_thread_pool.hpp": "platform/android/src/android_thread_pool.hpp",
         "snapshotter/map_snapshot.hpp": "platform/android/src/snapshotter/map_snapshot.hpp",
         "snapshotter/map_snapshotter.hpp": "platform/android/src/snapshotter/map_snapshotter.hpp",
         "style/android_conversion.hpp": "platform/android/src/style/android_conversion.hpp",

platform/android/src/android_thread_pool.cpp

@@ -0,0 +1,23 @@
+#include "android_thread_pool.hpp"
+#include <mbgl/util/platform.hpp>
+#include <cassert>
+
+namespace mbgl {
+namespace android {
+
+AndroidThreadPool::AndroidThreadPool(size_t count)
+        : mbgl::ThreadPool(count, {
+        [] {
+            JNIEnv* env = nullptr;
+            attach_jni_thread(theJVM, &env, platform::getCurrentThreadName());
+            return env;
+        },
+        [](ThreadLifecycle::ThreadData threadData_) {
+            assert(threadData_);
+            auto env = static_cast<JNIEnv*>(threadData_);
+            detach_jni_thread(theJVM, &env, true);
+        }
+}) {}
+
+} // namespace android
+} // namespace mbgl

platform/android/src/android_thread_pool.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include <mbgl/util/default_thread_pool.hpp>
+#include <map>
+#include "jni.hpp"
+
+namespace mbgl {
+namespace android {
+
+class AndroidThreadPool : public mbgl::ThreadPool {
+public:
+    explicit AndroidThreadPool(size_t count);
+};
+
+} // namespace android
+} // namespace mbgl

platform/android/src/shared_thread_pool.cpp

@@ -0,0 +1,15 @@
+#include <mbgl/util/shared_thread_pool.hpp>
+#include "android_thread_pool.hpp"
+
+namespace mbgl {
+
+std::shared_ptr<ThreadPool> sharedThreadPool() {
+    static std::weak_ptr<ThreadPool> weak;
+    auto pool = weak.lock();
+    if (!pool) {
+        weak = pool = std::make_shared<android::AndroidThreadPool>(4);
+    }
+    return pool;
+}
+
+} // namespace mbgl

platform/default/include/mbgl/util/default_thread_pool.hpp

@@ -6,17 +6,40 @@
 #include <mutex>
 #include <queue>
 #include <thread>
+#include <functional>
 
 namespace mbgl {
 
+struct ThreadLifecycle {
+    using ThreadData = void*;
+    ThreadLifecycle() = default;
+    ThreadLifecycle(std::function<ThreadData()> onThreadCreated_,
+                    std::function<void(ThreadData)> onThreadDestroyed_) :
+            onThreadCreatedFn(onThreadCreated_),
+            onThreadDestroyedFn(onThreadDestroyed_) {}
+
+    ThreadData onThreadCreated() const {
+        return onThreadCreatedFn();
+    }
+
+    void onThreadDestroyed(ThreadData threadData_) const {
+        onThreadDestroyedFn(threadData_);
+    }
+
+private:
+    std::function<ThreadData()> onThreadCreatedFn = [] { return nullptr; };
+    std::function<void(ThreadData)> onThreadDestroyedFn = [](ThreadData) {};
+};
+
 class ThreadPool : public Scheduler {
 public:
-    ThreadPool(std::size_t count);
+    explicit ThreadPool(std::size_t count, ThreadLifecycle _lifecycle = ThreadLifecycle());
     ~ThreadPool() override;
 
     void schedule(std::weak_ptr<Mailbox>) override;
 
 private:
+    ThreadLifecycle lifecycle;
     std::vector<std::thread> threads;
     std::queue<std::weak_ptr<Mailbox>> queue;
     std::mutex mutex;

platform/default/src/mbgl/util/default_thread_pool.cpp

@@ -5,12 +5,14 @@
 
 namespace mbgl {
 
-ThreadPool::ThreadPool(std::size_t count) {
+ThreadPool::ThreadPool(std::size_t count, ThreadLifecycle _lifecycle) : lifecycle(std::move(_lifecycle)) {
     threads.reserve(count);
     for (std::size_t i = 0; i < count; ++i) {
         threads.emplace_back([this, i]() {
             platform::setCurrentThreadName(std::string{ "Worker " } + util::toString(i + 1));
 
+            ThreadLifecycle::ThreadData threadData = lifecycle.onThreadCreated();
+
             while (true) {
                 std::unique_lock<std::mutex> lock(mutex);
 
@@ -19,6 +21,7 @@ ThreadPool::ThreadPool(std::size_t count) {
                 });
 
                 if (terminate) {
+                    lifecycle.onThreadDestroyed(threadData);
                     return;
                 }