simpleble 0.0.1

data/vendor/simpleble/simpledbus/test/src/test_proxy_lifetime.cpp

@@ -0,0 +1,18 @@
+#include <gtest/gtest.h>
+
+#include <simpledbus/advanced/Proxy.h>
+
+using namespace SimpleDBus;
+
+TEST(ProxyLifetime, Validity) {
+    Proxy p = Proxy(nullptr, "", "/");
+
+    // A newly created proxy should always be valid.
+    ASSERT_TRUE(p.valid());
+
+    // Should notify that the proxy can be safely deleted, as nothing worth keeping is left
+    ASSERT_TRUE(p.path_remove("/", Holder::create_array()));
+
+    // A proxy that has been removed is no longer valid.
+    ASSERT_FALSE(p.valid());
+}

data/vendor/simpleble/simpledroidble/simpledroidble/src/main/cpp/ThreadRunner.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <fmt/core.h>
+#include <jni.h>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <optional>
+#include <queue>
+#include <thread>
+#include "android_utils.h"
+
+class ThreadRunner {
+  public:
+    ThreadRunner() : _stop(false), _jvm(nullptr) {}
+
+    ~ThreadRunner() {
+        {
+            std::unique_lock<std::mutex> lock(_mutex);
+            _stop = true;
+            _cv.notify_one();
+        }
+        if (_thread && _thread->joinable()) {
+            _thread->join();
+        }
+    }
+
+    void set_jvm(JavaVM* jvm) { _jvm = jvm; }
+
+    void enqueue(std::function<void()> func) {
+        {
+            std::unique_lock<std::mutex> lock(_mutex);
+            if (!_thread) {
+                // Thread is lazily started upon the first task enqueue
+                _thread.emplace(&ThreadRunner::threadFunc, this);
+            }
+            _queue.push(std::move(func));
+        }
+        _cv.notify_one();
+    }
+
+  private:
+    void threadFunc() {
+        if (!_jvm) {
+            log_error("No JVM provided");
+            return;
+        }
+
+        // Attach the thread to the JVM
+        JNIEnv* env;
+        jint result = _jvm->AttachCurrentThread(&env, NULL);
+        if (result != JNI_OK) {
+            log_error("Failed to attach thread");
+            return;
+        }
+
+        // Run the thread loop
+        while (true) {
+            std::function<void()> func;
+
+            // Retrieve and execute the next task
+            {
+                std::unique_lock<std::mutex> lock(_mutex);
+                _cv.wait(lock, [this] { return _stop || !_queue.empty(); });
+                if (_stop && _queue.empty()) {
+                    break;
+                }
+                func = std::move(_queue.front());
+                _queue.pop();
+            }
+
+            try {
+                func();
+            } catch (const std::exception& e) {
+                log_error(fmt::format("Exception in thread: {}", e.what()));
+            }
+        }
+
+        // Detach the thread from the JVM
+        _jvm->DetachCurrentThread();
+    }
+
+    JavaVM* _jvm;
+    std::optional<std::thread> _thread;
+    std::mutex _mutex;
+    std::condition_variable _cv;
+    std::queue<std::function<void()>> _queue;
+    bool _stop;
+};

data/vendor/simpleble/simpledroidble/simpledroidble/src/main/cpp/android_utils.cpp

@@ -0,0 +1,55 @@
+#include "android_utils.h"
+
+#include <android/log.h>
+#include <fmt/core.h>
+
+void log_error(const std::string& msg) { __android_log_write(ANDROID_LOG_ERROR, "SimpleBLE", msg.c_str()); }
+void log_info(const std::string& msg) { __android_log_write(ANDROID_LOG_INFO, "SimpleBLE", msg.c_str()); }
+void log_debug(const std::string& msg) { __android_log_write(ANDROID_LOG_DEBUG, "SimpleBLE", msg.c_str()); }
+
+jstring to_jstring(JNIEnv* env, const std::string& str) { return env->NewStringUTF(str.c_str()); }
+
+std::string from_jstring(JNIEnv* env, jstring str) {
+    const char* c_str = env->GetStringUTFChars(str, nullptr);
+    std::string result(c_str);
+    env->ReleaseStringUTFChars(str, c_str);
+    return result;
+}
+
+jbyteArray to_jbyteArray(JNIEnv* env, const std::string& data) {
+    jbyteArray result = env->NewByteArray(data.size());
+    env->SetByteArrayRegion(result, 0, data.size(), reinterpret_cast<const jbyte*>(data.data()));
+
+    jsize length = env->GetArrayLength(result);
+    jbyte* bytes = env->GetByteArrayElements(result, NULL);
+
+    std::string arrayOut = "Array: ";
+    for (jsize i = 0; i < length; i++) {
+        arrayOut += fmt::format("{:02x} ", bytes[i]);
+    }
+    log_debug(arrayOut);
+
+    env->ReleaseByteArrayElements(result, bytes, JNI_ABORT);
+
+    return result;
+}
+
+jobject jarraylist_new(JNIEnv* env) {
+    jclass arrayListClass = env->FindClass("java/util/ArrayList");
+    jmethodID arrayListConstructor = env->GetMethodID(arrayListClass, "<init>", "()V");
+    jobject arrayList = env->NewObject(arrayListClass, arrayListConstructor);
+    return arrayList;
+}
+
+void jarraylist_add(JNIEnv* env, jobject arrayList, jobject element) {
+    jclass arrayListClass = env->GetObjectClass(arrayList);
+    jmethodID arrayListAdd = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z");
+    env->CallBooleanMethod(arrayList, arrayListAdd, element);
+}
+
+void throw_exception(JNIEnv* env, const std::string& msg) {
+    log_error(fmt::format("Throwing exception: {}", msg));
+
+    jclass Exception = env->FindClass("java/lang/Exception");
+    env->ThrowNew(Exception, msg.c_str());
+}

data/vendor/simpleble/simpledroidble/simpledroidble/src/main/cpp/android_utils.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <jni.h>
+#include <string>
+
+void log_error(const std::string& msg);
+void log_info(const std::string& msg);
+void log_debug(const std::string& msg);
+
+jstring to_jstring(JNIEnv* env, const std::string& str);
+std::string from_jstring(JNIEnv* env, jstring str);
+
+jbyteArray to_jbyteArray(JNIEnv* env, const std::string& data);
+
+jobject jarraylist_new(JNIEnv* env);
+void jarraylist_add(JNIEnv* env, jobject arrayList, jobject element);
+
+void throw_exception(JNIEnv* env, const std::string& msg);