simplernble 1.2.1-dev132 → 1.2.1-dev136

package/native/VERSION

@@ -1 +1 @@
-1.2.1-dev132
+1.2.1-dev136

package/native/dependencies/internal/include/simplejni/ThreadRunner.hpp

@@ -0,0 +1,166 @@
+#pragma once
+
+#include <simpleble/Logging.h>
+
+#include <condition_variable>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <utility>
+
+#include "Common.hpp"
+#include "VM.hpp"
+
+namespace SimpleJNI {
+
+/**
+ * Runs Java callbacks one at a time, in order, on a single thread attached to the JVM.
+ *
+ * Follows kvn::thread_runner: stop() runs the queued functions, functions enqueued afterwards are dropped, and the
+ * runner may be destroyed from one of its own functions. On top of that, it does what a JNI callback thread needs:
+ * - The thread starts on the first enqueue, since the JavaVM is only known after JNI_OnLoad.
+ * - The thread stays attached under the runner's name, which debuggers and ANR traces show, and detaches before it
+ *   ends, as ART requires. It attaches as a daemon, so it does not keep a desktop JVM from exiting.
+ * - A function that throws, or that leaves a Java exception pending, is logged under the runner's name and the thread
+ *   carries on.
+ */
+class ThreadRunner final {
+  public:
+    explicit ThreadRunner(std::string name) : _state(std::make_shared<state>()) { _state->name = std::move(name); }
+
+    // Remove copy constructor and copy assignment
+    ThreadRunner(const ThreadRunner&) = delete;
+    ThreadRunner& operator=(const ThreadRunner&) = delete;
+
+    ~ThreadRunner() {
+        if (!on_own_thread()) {
+            stop();
+            return;
+        }
+
+        // Destroyed from one of its own functions: the thread cannot join itself. It keeps its own reference to the
+        // state, and detaches from the JVM and ends once the current function returns.
+        std::queue<std::function<void()>> dropped;
+        {
+            std::lock_guard<std::mutex> lock(_state->mutex);
+            _state->stop = true;
+            dropped.swap(_state->queue);
+        }
+        _state->cv.notify_one();
+        _thread.detach();
+    }
+
+    /**
+     * Functions enqueued after stop() are dropped.
+     */
+    void enqueue(std::function<void()> func) {
+        {
+            std::lock_guard<std::mutex> lock(_state->mutex);
+            if (_state->stop) return;
+            if (!_thread.joinable()) {
+                _thread = std::thread(&ThreadRunner::thread_func, _state);
+                _thread_id = _thread.get_id();
+            }
+            _state->queue.push(std::move(func));
+        }
+        _state->cv.notify_one();
+    }
+
+    /**
+     * Run the functions already enqueued, then end the thread.
+     *
+     * Safe to call more than once. When called from one of the runner's own functions, it returns right away and the
+     * thread ends once the queue is empty.
+     */
+    void stop() {
+        {
+            std::lock_guard<std::mutex> lock(_state->mutex);
+            _state->stop = true;
+        }
+        _state->cv.notify_one();
+
+        // Once stopped, enqueue() no longer starts the thread, so it is safe to read here.
+        if (on_own_thread()) return;
+
+        std::lock_guard<std::mutex> lock(_join_mutex);
+        if (_thread.joinable()) {
+            _thread.join();
+        }
+    }
+
+  private:
+    /** Shared with the thread, so the thread never touches the runner itself. */
+    struct state {
+        std::mutex mutex;
+        std::condition_variable cv;
+        std::queue<std::function<void()>> queue;
+        bool stop = false;
+        std::string name;
+    };
+
+    static void log_error(const state& shared, const std::string& message) noexcept {
+        SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Error, shared.name, __FILE__, __LINE__,
+                                               __func__, message);
+    }
+
+    static void thread_func(std::shared_ptr<state> shared) noexcept {
+        try {
+            VM::attach_as_daemon(shared->name.c_str());
+        } catch (const std::exception& exception) {
+            log_error(*shared, std::string("Failed to attach callback thread: ") + exception.what());
+
+            // Nothing can run without the JVM, so drop the queued functions instead of letting the queue grow.
+            std::queue<std::function<void()>> dropped;
+            std::lock_guard<std::mutex> lock(shared->mutex);
+            shared->stop = true;
+            dropped.swap(shared->queue);
+            return;
+        }
+
+        while (true) {
+            std::function<void()> func;
+            {
+                std::unique_lock<std::mutex> lock(shared->mutex);
+                shared->cv.wait(lock, [&shared] { return shared->stop || !shared->queue.empty(); });
+                if (shared->stop && shared->queue.empty()) {
+                    break;
+                }
+                func = std::move(shared->queue.front());
+                shared->queue.pop();
+            }
+            run(*shared, func);
+        }
+
+        VM::detach();
+    }
+
+    static void run(const state& shared, const std::function<void()>& func) noexcept {
+        try {
+            func();
+        } catch (const std::exception& exception) {
+            log_error(shared, std::string("Exception in callback thread: ") + exception.what());
+        } catch (...) {
+            log_error(shared, "Unknown exception in callback thread");
+        }
+
+        // A pending Java exception would break every later JNI call on this thread.
+        try {
+            Exception::check(VM::env());
+        } catch (const std::exception& exception) {
+            log_error(shared, std::string("Java exception left pending in callback thread: ") + exception.what());
+        }
+    }
+
+    bool on_own_thread() const { return std::this_thread::get_id() == _thread_id; }
+
+    std::shared_ptr<state> _state;
+    std::thread _thread;
+    std::thread::id _thread_id;
+    std::mutex _join_mutex;
+};
+
+}  // namespace SimpleJNI

package/native/dependencies/internal/include/simplejni/VM.hpp

@@ -87,6 +87,25 @@ class VM {
         }
     }
 
+    // Attaches the calling thread as a daemon, unless it is attached already, so a desktop JVM can exit while the
+    // thread is still running.
+    static void attach_as_daemon(const char* thread_name = nullptr) {
+        JavaVM* jvm = VM::jvm();
+        JNIEnv* env = nullptr;
+        if (jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) == JNI_OK) return;
+
+        // OpenJDK declares the name as char*, but the JVM only reads it.
+        JavaVMAttachArgs args{JNI_VERSION_1_6, const_cast<char*>(thread_name), nullptr};
+#ifdef __ANDROID__
+        auto result = jvm->AttachCurrentThreadAsDaemon(&env, &args);
+#else
+        auto result = jvm->AttachCurrentThreadAsDaemon(reinterpret_cast<void**>(&env), &args);
+#endif
+        if (result != JNI_OK) {
+            throw std::runtime_error("Failed to attach the current thread to the JVM");
+        }
+    }
+
     static void detach() {
         JavaVM* jvm = VM::jvm();
         jvm->DetachCurrentThread();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simplernble",
-  "version": "1.2.1-dev132",
+  "version": "1.2.1-dev136",
   "description": "SimpleBLE for React Native: a cross-platform Bluetooth Low Energy library for iOS and Android",
   "keywords": [
     "react-native",

package/prebuilt/release/SimpleBLE.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>libsimpleble.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libsimpleble.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>libsimpleble.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libsimpleble.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>