simplejsble 0.0.4 → 0.0.6

package/dependencies/internal/include/simplejni/References.hpp

@@ -0,0 +1,151 @@
+#pragma once
+
+#include <jni.h>
+
+#include "VM.hpp"
+
+namespace SimpleJNI {
+
+template <typename T>
+class GlobalRef {
+  public:
+    GlobalRef() = default;
+
+    explicit GlobalRef(T obj) : _obj(obj ? static_cast<T>(VM::env()->NewGlobalRef(obj)) : nullptr) {}
+
+    ~GlobalRef() {
+        if (_obj && VM::is_jvm_alive()) VM::env()->DeleteGlobalRef(_obj);
+    }
+
+    // Copy constructor
+    GlobalRef(const GlobalRef& other)
+        : _obj(other._obj ? static_cast<T>(VM::env()->NewGlobalRef(other._obj)) : nullptr) {}
+
+    // Copy assignment operator
+    GlobalRef& operator=(const GlobalRef& other) {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteGlobalRef(_obj);
+            _obj = other._obj ? static_cast<T>(VM::env()->NewGlobalRef(other._obj)) : nullptr;
+        }
+        return *this;
+    }
+
+    // Move constructor
+    GlobalRef(GlobalRef&& other) noexcept : _obj(other._obj) { other._obj = nullptr; }
+
+    // Move assignment operator
+    GlobalRef& operator=(GlobalRef&& other) noexcept {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteGlobalRef(_obj);
+            _obj = other._obj;
+            other._obj = nullptr;
+        }
+        return *this;
+    }
+
+    T get() const { return _obj; }
+
+  protected:
+    T _obj = nullptr;
+};
+
+template <typename T>
+class LocalRef {
+  public:
+    LocalRef() = default;
+
+    explicit LocalRef(T obj) : _obj(obj ? static_cast<T>(VM::env()->NewLocalRef(obj)) : nullptr) {}
+
+    ~LocalRef() {
+        if (_obj) VM::env()->DeleteLocalRef(_obj);
+    }
+
+    // Copy constructor
+    LocalRef(const LocalRef& other) : _obj(other._obj ? static_cast<T>(VM::env()->NewLocalRef(other._obj)) : nullptr) {}
+
+    // Copy assignment operator
+    LocalRef& operator=(const LocalRef& other) {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteLocalRef(_obj);
+            _obj = other._obj ? static_cast<T>(VM::env()->NewLocalRef(other._obj)) : nullptr;
+        }
+        return *this;
+    }
+
+    // Move constructor
+    LocalRef(LocalRef&& other) noexcept : _obj(other._obj) { other._obj = nullptr; }
+
+    // Move assignment operator
+    LocalRef& operator=(LocalRef&& other) noexcept {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteLocalRef(_obj);
+            _obj = other._obj;
+            other._obj = nullptr;
+        }
+        return *this;
+    }
+
+    T get() const { return _obj; }
+
+  protected:
+    T _obj = nullptr;
+};
+
+// A type for references intended to be returned to JNI
+template <typename T>
+class ReleasableLocalRef : public LocalRef<T> {
+  public:
+    using LocalRef<T>::LocalRef;
+    T release() noexcept {
+        T obj = this->_obj;
+        this->_obj = nullptr;
+        return obj;
+    }
+};
+
+template <typename T>
+class WeakRef {
+  public:
+    WeakRef() = default;
+
+    explicit WeakRef(T obj) : _obj(obj ? static_cast<T>(VM::env()->NewWeakGlobalRef(obj)) : nullptr) {}
+
+    ~WeakRef() {
+        if (_obj && VM::is_jvm_alive()) VM::env()->DeleteWeakGlobalRef(_obj);
+    }
+
+    // Copy constructor
+    WeakRef(const WeakRef& other)
+        : _obj(other._obj ? static_cast<T>(VM::env()->NewWeakGlobalRef(other._obj)) : nullptr) {}
+
+    // Copy assignment operator
+    WeakRef& operator=(const WeakRef& other) {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteWeakGlobalRef(_obj);
+            _obj = other._obj ? static_cast<T>(VM::env()->NewWeakGlobalRef(other._obj)) : nullptr;
+        }
+        return *this;
+    }
+
+    // Move constructor
+    WeakRef(WeakRef&& other) noexcept : _obj(other._obj) { other._obj = nullptr; }
+
+    // Move assignment operator
+    WeakRef& operator=(WeakRef&& other) noexcept {
+        if (this != &other) {
+            if (_obj) VM::env()->DeleteWeakGlobalRef(_obj);
+            _obj = other._obj;
+            other._obj = nullptr;
+        }
+        return *this;
+    }
+
+    T get() const { return _obj; }
+
+    bool is_valid() const { return _obj && !VM::env()->IsSameObject(_obj, nullptr); }
+
+  protected:
+    T _obj = nullptr;
+};
+
+}  // namespace SimpleJNI

package/dependencies/internal/include/simplejni/Registry.hpp

@@ -0,0 +1,249 @@
+#pragma once
+
+#include "References.hpp"
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+
+namespace SimpleJNI {
+
+/**
+ * @brief Descriptor for a single Java method to be preloaded.
+ *
+ * This struct holds the metadata for a method that a Java class needs to expose to C++.
+ * It links a method name and signature to a jmethodID pointer where the resolved ID will
+ * be stored during JNI_OnLoad.
+ */
+struct MethodDescriptor {
+    std::string name;             ///< Name of the Java method (e.g., "startScan").
+    std::string signature;        ///< JNI signature of the method (e.g., "(Landroid/bluetooth/le/ScanCallback;)V").
+    jmethodID* target = nullptr;  ///< Pointer to where the resolved jmethodID will be stored.
+
+    MethodDescriptor(const std::string& n, const std::string& sig, jmethodID* tgt)
+        : name(n), signature(sig), target(tgt) {}
+};
+
+/**
+ * @brief Descriptor for a Java class and its methods to be preloaded.
+ *
+ * This struct defines a Java class by its fully qualified name and a list of methods
+ * that need JNI access. It ties the class and its methods to storage locations
+ * (GlobalRef<jclass> and jmethodID pointers) that will be populated during preloading.
+ */
+struct JNIDescriptor {
+    std::string class_name;  ///< Fully qualified Java class name (e.g., "android/bluetooth/le/BluetoothLeScanner").
+    GlobalRef<jclass>* class_target;  ///< Pointer to where the resolved jclass will be stored.
+    std::vector<MethodDescriptor> methods;       ///< List of methods to preload for this class.
+
+    JNIDescriptor(const std::string& name, SimpleJNI::GlobalRef<jclass>* cls_target,
+                  std::initializer_list<MethodDescriptor> meths)
+        : class_name(name), class_target(cls_target), methods(meths) {}
+};
+
+/**
+ * @brief Descriptor for a Java class and its static methods to be preloaded.
+ *
+ * This struct defines a Java class by its fully qualified name and a list of static methods
+ * that need JNI access. It ties the class and its static methods to storage locations
+ * (GlobalRef<jclass> and jmethodID pointers) that will be populated during preloading.
+ */
+struct StaticJNIDescriptor {
+    std::string class_name;  ///< Fully qualified Java class name (e.g., "android/bluetooth/le/BluetoothLeScanner").
+    GlobalRef<jclass>* class_target;  ///< Pointer to where the resolved jclass will be stored.
+    std::vector<MethodDescriptor> static_methods;  ///< List of static methods to preload for this class.
+
+    StaticJNIDescriptor(const std::string& name, SimpleJNI::GlobalRef<jclass>* cls_target,
+                        std::initializer_list<MethodDescriptor> meths)
+        : class_name(name), class_target(cls_target), static_methods(meths) {}
+};
+
+/**
+ * @brief Singleton registrar for collecting and preloading JNI class descriptors.
+ *
+ * The Registrar collects JNIDescriptor and StaticJNIDescriptor instances at compile-time
+ * (via static initialization) and preloads their JNI resources (jclass and jmethodID)
+ * during JNI_OnLoad. This ensures all necessary JNI metadata is resolved early on the
+ * correct thread, avoiding runtime ClassLoader or thread-context issues.
+ */
+class Registrar {
+  public:
+    /// @brief Get the singleton instance of the Registrar.
+    static Registrar& get() {
+        static Registrar instance;
+
+        // Register common classes that are used in many places.
+        static const JNIDescriptor desc{
+            "java/lang/Object",  // Java class name
+            nullptr,             // Where to store the jclass
+            {                    // Instance methods to preload
+                {"hashCode", "()I", nullptr},
+            }
+        };
+
+        instance.register_descriptor(&desc);
+
+        return instance;
+    }
+
+    /**
+     * @brief Register a JNIDescriptor for preloading.
+     *
+     * Called automatically by AutoRegister during static initialization. Adds the descriptor
+     * to an internal list that will be processed in preload().
+     * @param descriptor Pointer to the JNIDescriptor to register.
+     */
+    void register_descriptor(const JNIDescriptor* descriptor) { descriptors.push_back(descriptor); }
+
+    /**
+     * @brief Register a StaticJNIDescriptor for preloading.
+     *
+     * Called automatically by AutoRegister during static initialization. Adds the descriptor
+     * to an internal list that will be processed in preload().
+     * @param descriptor Pointer to the StaticJNIDescriptor to register.
+     */
+    void register_static_descriptor(const StaticJNIDescriptor* descriptor) { static_descriptors.push_back(descriptor); }
+
+    /**
+     * @brief Preload all registered JNI resources.
+     *
+     * Called from JNI_OnLoad to resolve jclass and jmethodID for all registered descriptors.
+     * Uses the provided JNIEnv to perform JNI lookups on the thread that loads the library,
+     * ensuring access to the correct ClassLoader context (e.g., system classes on Android).
+     * @param env JNIEnv pointer from JNI_OnLoad.
+     * @throws std::runtime_error if a class or method cannot be resolved.
+     */
+    void preload(JNIEnv* env) {
+        // Preload instance method descriptors
+        for (const JNIDescriptor* desc : descriptors) {
+            // Load the Java class
+            jclass local_cls = env->FindClass(desc->class_name.c_str());
+            if (!local_cls) {
+                throw std::runtime_error("Failed to load class: " + desc->class_name);
+            }
+
+            GlobalRef<jclass> class_target(local_cls);
+            env->DeleteLocalRef(local_cls);  // Clean up the local reference
+
+            // If *desc->class_target is null, we don't set it.
+            if (desc->class_target != nullptr) {
+                *desc->class_target = class_target;
+            }
+            class_targets[desc->class_name] = class_target;
+
+            // Load each method
+            for (const MethodDescriptor& method : desc->methods) {
+                jmethodID method_id = env->GetMethodID(class_target.get(), method.name.c_str(), method.signature.c_str());
+                if (!method_id) {
+                    throw std::runtime_error("Failed to get method: " + desc->class_name + "." + method.name);
+                }
+
+                // If *method.target is null, we don't set it.
+                if (method.target != nullptr) {
+                    *method.target = method_id;
+                }
+                method_targets[desc->class_name][method.name] = method_id;
+            }
+        }
+
+        // Clear descriptors once they are preloaded
+        descriptors.clear();
+
+        // Preload static method descriptors
+        for (const StaticJNIDescriptor* desc : static_descriptors) {
+            // Load the Java class
+            jclass local_cls = env->FindClass(desc->class_name.c_str());
+            if (!local_cls) {
+                throw std::runtime_error("Failed to load class: " + desc->class_name);
+            }
+
+            GlobalRef<jclass> class_target(local_cls);
+            env->DeleteLocalRef(local_cls);  // Clean up the local reference
+
+            // If *desc->class_target is null, we don't set it.
+            if (desc->class_target != nullptr) {
+                *desc->class_target = class_target;
+            }
+            static_class_targets[desc->class_name] = class_target;
+
+            // Load each static method
+            for (const MethodDescriptor& method : desc->static_methods) {
+                jmethodID method_id = env->GetStaticMethodID(class_target.get(), method.name.c_str(), method.signature.c_str());
+                if (!method_id) {
+                    throw std::runtime_error("Failed to get static method: " + desc->class_name + "." + method.name);
+                }
+
+                // If *method.target is null, we don't set it.
+                if (method.target != nullptr) {
+                    *method.target = method_id;
+                }
+                static_method_targets[desc->class_name][method.name] = method_id;
+            }
+        }
+
+        // Clear static descriptors once they are preloaded
+        static_descriptors.clear();
+    }
+
+    GlobalRef<jclass> get_class(const std::string& name) {
+        return class_targets[name];
+    }
+
+    jmethodID get_method(const std::string& class_name, const std::string& method_name) {
+        return method_targets[class_name][method_name];
+    }
+
+    GlobalRef<jclass> get_static_class(const std::string& name) {
+        return static_class_targets[name];
+    }
+
+    jmethodID get_static_method(const std::string& class_name, const std::string& method_name) {
+        return static_method_targets[class_name][method_name];
+    }
+
+  private:
+    Registrar() = default;
+    ~Registrar() = default;
+    Registrar(const Registrar&) = delete;
+    Registrar& operator=(const Registrar&) = delete;
+
+    std::unordered_map<std::string, GlobalRef<jclass>> class_targets;
+    std::unordered_map<std::string, std::unordered_map<std::string, jmethodID>> method_targets;
+
+    std::unordered_map<std::string, GlobalRef<jclass>> static_class_targets;
+    std::unordered_map<std::string, std::unordered_map<std::string, jmethodID>> static_method_targets;
+
+    std::vector<const JNIDescriptor*> descriptors;  ///< List of registered descriptors.
+    std::vector<const StaticJNIDescriptor*> static_descriptors;  ///< List of registered static descriptors.
+};
+
+/**
+ * @brief Helper to automatically register JNI descriptors at compile time.
+ *
+ * This template class uses static initialization to register descriptors with the Registrar
+ * when the program loads. The constructor runs before main() or JNI_OnLoad, ensuring all
+ * classes are registered without manual intervention. It supports registering non-static methods,
+ * static methods, or both.
+ * @tparam T The class type (e.g., BluetoothScanner) that owns the descriptor.
+ */
+template <typename T>
+struct AutoRegister {
+    // Constructor for non-static methods only
+    AutoRegister(const JNIDescriptor* desc) {
+        Registrar::get().register_descriptor(desc);
+    }
+
+    // Constructor for static methods only
+    AutoRegister(const StaticJNIDescriptor* static_desc) {
+        Registrar::get().register_static_descriptor(static_desc);
+    }
+
+    // Constructor for both non-static and static methods
+    AutoRegister(const JNIDescriptor* desc, const StaticJNIDescriptor* static_desc) {
+        Registrar::get().register_descriptor(desc);
+        Registrar::get().register_static_descriptor(static_desc);
+    }
+};
+
+}  // namespace SimpleJNI

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

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <jni.h>
+
+#include <mutex>
+
+namespace SimpleJNI {
+
+// Generic class to handle the Java Virtual Machine (JVM)
+class VM {
+  public:
+    // TODO: Make the VM class transparent to the JavaVM pointer.
+    static JavaVM* jvm(JavaVM* jvm_override = nullptr) {
+        static std::mutex mutex;  // Function-local for tied lifecycle
+        static VM instance;       // Function-local for lazy init and auto-cleanup
+
+        std::scoped_lock lock(mutex);  // Lock entire access for safety
+        if (jvm_override != nullptr) {
+            if (instance._jvm != nullptr && instance._jvm != jvm_override) {
+                throw std::runtime_error("JavaVM pointer already set");
+            }
+            instance._jvm = jvm_override;
+        } else if (instance._jvm == nullptr) {
+            jsize count;
+            if (JNI_GetCreatedJavaVMs(&instance._jvm, 1, &count) != JNI_OK || count == 0) {
+                throw std::runtime_error("Failed to retrieve the Java Virtual Machine");
+            }
+        }
+        return instance._jvm;
+    }
+
+    static bool is_jvm_alive() {
+        JavaVM* jvm = VM::jvm();
+        if (!jvm) return false;
+        JNIEnv* env = nullptr;
+        return jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) == JNI_OK;
+    }
+
+    static JNIEnv* env() {
+        JNIEnv* env = nullptr;
+        JavaVM* jvm = VM::jvm();
+
+        auto getEnvResult = jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
+        switch (getEnvResult) {
+            case JNI_OK:
+                break;
+            case JNI_EDETACHED: {
+#ifdef __ANDROID__
+                auto result = jvm->AttachCurrentThread(&env, nullptr);
+#else
+                auto result = jvm->AttachCurrentThread(reinterpret_cast<void**>(&env), nullptr);
+#endif
+                if (result != JNI_OK) {
+                    throw std::runtime_error("Failed to attach the current thread to the JVM");
+                }
+                break;
+            }
+            case JNI_EVERSION:
+                throw std::runtime_error("Failed to get the JNIEnv, JNI version not supported");
+            default:
+                throw std::runtime_error("Failed to get the JNIEnv, unknown error");
+        }
+        return env;
+    }
+
+    static void attach() {
+        JNIEnv* env = nullptr;
+        JavaVM* jvm = VM::jvm();
+#ifdef __ANDROID__
+        auto result = jvm->AttachCurrentThread(&env, nullptr);
+#else
+        auto result = jvm->AttachCurrentThread(reinterpret_cast<void**>(&env), nullptr);
+#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();
+    }
+
+  private:
+    VM() = default;
+    virtual ~VM() = default;
+    VM(VM& other) = delete;              // Remove the copy constructor
+    void operator=(const VM&) = delete;  // Remove the copy assignment
+
+    JavaVM* _jvm = nullptr;
+};
+
+}  // namespace SimpleJNI