simpleble 0.0.1

data/vendor/simpleble/simplejavable/cpp/src/java/lang/Integer.cpp

@@ -0,0 +1,93 @@
+#include "Integer.h"
+
+namespace Java::Util {
+
+template <template <typename> class RefType>
+SimpleJNI::GlobalRef<jclass> Integer<RefType>::_cls;
+
+template <template <typename> class RefType>
+jmethodID Integer<RefType>::_method_init = nullptr;
+
+template <template <typename> class RefType>
+jmethodID Integer<RefType>::_method_int_value = nullptr;
+
+template <template <typename> class RefType>
+jmethodID Integer<RefType>::_method_value_of = nullptr;
+
+template <template <typename> class RefType>
+const SimpleJNI::JNIDescriptor Integer<RefType>::descriptor{"java/lang/Integer",  // Java class name
+                                                            &_cls,                // Where to store the jclass
+                                                            {
+                                                                // Methods to preload
+                                                                {"<init>", "(I)V", &_method_init},
+                                                                {"intValue", "()I", &_method_int_value},
+                                                            }};
+
+template <template <typename> class RefType>
+const SimpleJNI::AutoRegister<Integer<RefType>> Integer<RefType>::registrar{&descriptor};
+
+template <template <typename> class RefType>
+Integer<RefType>::Integer() : _obj() {}
+
+template <template <typename> class RefType>
+Integer<RefType>::Integer(jobject obj) : _obj(obj) {
+    if (!_cls.get()) {
+        throw std::runtime_error("Integer JNI resources not preloaded");
+    }
+}
+
+template <template <typename> class RefType>
+Integer<RefType>::Integer(int value) : _obj() {
+    if (!_cls.get()) {
+        throw std::runtime_error("Integer JNI resources not preloaded");
+    }
+    JNIEnv* env = SimpleJNI::VM::env();
+    jobject obj = env->NewObject(_cls.get(), _method_init, value);
+    _obj = SimpleJNI::Object<RefType, jobject>(obj, _cls.get());
+}
+
+template <template <typename> class RefType>
+template <template <typename> class OtherRefType>
+Integer<RefType>::Integer(const SimpleJNI::Object<OtherRefType, jobject>& obj) : _obj(obj.get()) {}
+
+template <template <typename> class RefType>
+Integer<SimpleJNI::LocalRef> Integer<RefType>::to_local() const {
+    if (!*this) return Integer<SimpleJNI::LocalRef>();
+    return Integer<SimpleJNI::LocalRef>(_obj.get());
+}
+
+template <template <typename> class RefType>
+Integer<SimpleJNI::GlobalRef> Integer<RefType>::to_global() const {
+    if (!*this) return Integer<SimpleJNI::GlobalRef>();
+    return Integer<SimpleJNI::GlobalRef>(_obj.get());
+}
+
+template <template <typename> class RefType>
+jobject Integer<RefType>::get() const {
+    return _obj.get();
+}
+
+template <template <typename> class RefType>
+Integer<RefType>::operator bool() const {
+    return _obj.get() != nullptr;
+}
+
+template <template <typename> class RefType>
+int Integer<RefType>::int_value() const {
+    if (!*this) {
+        throw std::runtime_error("Integer is not initialized");
+    }
+    return _obj.call_int_method(_method_int_value);
+}
+
+template <template <typename> class RefType>
+Integer<RefType>::operator SimpleJNI::Object<RefType, jobject>() const {
+    return _obj;
+}
+
+// Explicit template instantiations
+template class Integer<SimpleJNI::LocalRef>;
+template class Integer<SimpleJNI::GlobalRef>;
+template class Integer<SimpleJNI::WeakRef>;
+template class Integer<SimpleJNI::ReleasableLocalRef>;
+}  // namespace Java::Util

data/vendor/simpleble/simplejavable/cpp/src/java/lang/Integer.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Java::Util {
+
+template <template <typename> class RefType>
+class Integer {
+  public:
+    Integer();
+    explicit Integer(jobject obj);
+    explicit Integer(int value);
+
+    template <template <typename> class OtherRefType>
+    Integer(const SimpleJNI::Object<OtherRefType, jobject>& obj);
+
+    // Conversion methods
+    Integer<SimpleJNI::LocalRef> to_local() const;
+    Integer<SimpleJNI::GlobalRef> to_global() const;
+
+    // Get the underlying jobject
+    jobject get() const;
+
+    // Check if the object is valid
+    explicit operator bool() const;
+
+    // Implicit conversion to SimpleJNI::Object
+    operator SimpleJNI::Object<RefType, jobject>() const;
+
+    // Integer methods
+    int int_value() const;
+
+  private:
+    // Underlying JNI object
+    SimpleJNI::Object<RefType, jobject> _obj;
+
+    // Static JNI resources
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_init;
+    static jmethodID _method_int_value;
+    static jmethodID _method_value_of;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<Integer> registrar;
+};
+
+}  // namespace Java::Util

data/vendor/simpleble/simplejavable/cpp/src/java/lang/Iterator.cpp

@@ -0,0 +1,85 @@
+#include "Iterator.h"
+
+namespace Java::Util {
+
+template <template <typename> class RefType>
+SimpleJNI::GlobalRef<jclass> Iterator<RefType>::_cls;
+
+template <template <typename> class RefType>
+jmethodID Iterator<RefType>::_method_has_next = nullptr;
+
+template <template <typename> class RefType>
+jmethodID Iterator<RefType>::_method_next = nullptr;
+
+template <template <typename> class RefType>
+const SimpleJNI::JNIDescriptor Iterator<RefType>::descriptor{"java/util/Iterator",  // Java interface name
+                                                             &_cls,                 // Where to store the jclass
+                                                             {                      // Methods to preload
+                                                              {"hasNext", "()Z", &_method_has_next},
+                                                              {"next", "()Ljava/lang/Object;", &_method_next}}};
+
+template <template <typename> class RefType>
+const SimpleJNI::AutoRegister<Iterator<RefType>> Iterator<RefType>::registrar{&descriptor};
+
+template <template <typename> class RefType>
+Iterator<RefType>::Iterator() : _obj() {}
+
+template <template <typename> class RefType>
+Iterator<RefType>::Iterator(jobject obj) : _obj(obj) {
+    if (!_cls.get()) {
+        throw std::runtime_error("Iterator JNI resources not preloaded");
+    }
+    _obj = SimpleJNI::Object<RefType, jobject>(obj, _cls.get());
+}
+
+template <template <typename> class RefType>
+template <template <typename> class OtherRefType>
+Iterator<RefType>::Iterator(const SimpleJNI::Object<OtherRefType, jobject>& obj) : _obj(obj.get()) {}
+
+template <template <typename> class RefType>
+Iterator<SimpleJNI::LocalRef> Iterator<RefType>::to_local() const {
+    if (!*this) return Iterator<SimpleJNI::LocalRef>();
+    return Iterator<SimpleJNI::LocalRef>(_obj.get());
+}
+
+template <template <typename> class RefType>
+Iterator<SimpleJNI::GlobalRef> Iterator<RefType>::to_global() const {
+    if (!*this) return Iterator<SimpleJNI::GlobalRef>();
+    return Iterator<SimpleJNI::GlobalRef>(_obj.get());
+}
+
+template <template <typename> class RefType>
+jobject Iterator<RefType>::get() const {
+    return _obj.get();
+}
+
+template <template <typename> class RefType>
+Iterator<RefType>::operator bool() const {
+    return _obj.get() != nullptr;
+}
+
+template <template <typename> class RefType>
+bool Iterator<RefType>::has_next() const {
+    if (!*this) return false;
+    return _obj.call_boolean_method(_method_has_next);
+}
+
+template <template <typename> class RefType>
+SimpleJNI::Object<SimpleJNI::LocalRef> Iterator<RefType>::next() {
+    if (!*this) {
+        throw std::runtime_error("Iterator is not initialized");
+    }
+    return _obj.call_object_method(_method_next);
+}
+
+template <template <typename> class RefType>
+Iterator<RefType>::operator SimpleJNI::Object<RefType, jobject>() const {
+    return _obj;
+}
+
+// Explicit template instantiations
+template class Iterator<SimpleJNI::LocalRef>;
+template class Iterator<SimpleJNI::GlobalRef>;
+template class Iterator<SimpleJNI::WeakRef>;
+template class Iterator<SimpleJNI::ReleasableLocalRef>;
+}  // namespace Java::Util

data/vendor/simpleble/simplejavable/cpp/src/java/lang/Iterator.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Java::Util {
+
+template <template <typename> class RefType>
+class Iterator {
+  public:
+    Iterator();
+    explicit Iterator(jobject obj);
+
+    template <template <typename> class OtherRefType>
+    Iterator(const SimpleJNI::Object<OtherRefType, jobject>& obj);
+
+    // Conversion methods
+    Iterator<SimpleJNI::LocalRef> to_local() const;
+    Iterator<SimpleJNI::GlobalRef> to_global() const;
+
+    // Get the underlying jobject
+    jobject get() const;
+
+    // Check if the object is valid
+    explicit operator bool() const;
+
+    // Implicit conversion to SimpleJNI::Object
+    operator SimpleJNI::Object<RefType, jobject>() const;
+
+    // Iterator methods
+    bool has_next() const;
+    SimpleJNI::Object<SimpleJNI::LocalRef> next();
+
+  private:
+    // Underlying JNI object
+    SimpleJNI::Object<RefType, jobject> _obj;
+
+    // Static JNI resources
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_has_next;
+    static jmethodID _method_next;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<Iterator> registrar;
+};
+
+}  // namespace Java::Util

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/AdapterCallback.cpp

@@ -0,0 +1,91 @@
+#include "AdapterCallback.h"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> AdapterCallback::_cls;
+jmethodID AdapterCallback::_method_on_scan_start = nullptr;
+jmethodID AdapterCallback::_method_on_scan_stop = nullptr;
+jmethodID AdapterCallback::_method_on_scan_updated = nullptr;
+jmethodID AdapterCallback::_method_on_scan_found = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor AdapterCallback::descriptor{
+    "org/simplejavable/Adapter$Callback",  // Java interface name (inner class notation)
+    &_cls,                                 // Where to store the jclass
+    {                                      // Methods to preload
+     {"onScanStart", "()V", &_method_on_scan_start},
+     {"onScanStop", "()V", &_method_on_scan_stop},
+     {"onScanUpdated", "(J)V", &_method_on_scan_updated},
+     {"onScanFound", "(J)V", &_method_on_scan_found}}};
+
+// Define the AutoRegister instance
+const SimpleJNI::AutoRegister<AdapterCallback> AdapterCallback::registrar{&descriptor};
+
+/**
+ * @brief Construct a Callback from a Java object.
+ *
+ * Initializes the internal SimpleJNI::Object with the provided jobject and the preloaded
+ * jclass. The check for _cls.get() ensures that JNI_OnLoad has run and preloaded the
+ * necessary resources, throwing an exception otherwise to catch initialization issues early.
+ * @param obj The Java object implementing the Callback interface.
+ * @throws std::runtime_error if JNI resources are not preloaded.
+ */
+AdapterCallback::AdapterCallback(jobject obj) : _obj(obj, _cls.get()) {
+    if (!_cls.get()) {
+        throw std::runtime_error("AdapterCallback JNI resources not preloaded");
+    }
+}
+
+/**
+ * @brief Invoke the onScanStart method on the Java Callback object.
+ *
+ * Uses the preloaded _method_on_scan_start to call the Java method via SimpleJNI::Object.
+ * No additional checks are needed here since the constructor enforces resource availability.
+ */
+void AdapterCallback::on_scan_start() {
+    if (_obj.is_valid()) {
+        _obj.to_local().call_void_method(_method_on_scan_start);
+    }
+}
+
+/**
+ * @brief Invoke the onScanStop method on the Java Callback object.
+ *
+ * Calls the Java onScanStop() method using the preloaded jmethodID.
+ */
+void AdapterCallback::on_scan_stop() {
+    if (_obj.is_valid()) {
+        _obj.to_local().call_void_method(_method_on_scan_stop);
+    }
+}
+
+/**
+ * @brief Invoke the onScanUpdated method on the Java Callback object.
+ *
+ * Calls the Java onScanUpdated(long) method, converting the C++ int64_t to a JNI jlong.
+ * The preloaded jmethodID ensures the call is efficient and safe.
+ * @param peripheral_id The ID of the peripheral that was updated.
+ */
+void AdapterCallback::on_scan_updated(int64_t peripheral_id) {
+    if (_obj.is_valid()) {
+        _obj.to_local().call_void_method(_method_on_scan_updated, static_cast<jlong>(peripheral_id));
+    }
+}
+
+/**
+ * @brief Invoke the onScanFound method on the Java Callback object.
+ *
+ * Calls the Java onScanFound(long) method with the provided peripheral ID, using the
+ * preloaded jmethodID for efficiency.
+ * @param peripheral_id The ID of the peripheral that was found.
+ */
+void AdapterCallback::on_scan_found(int64_t peripheral_id) {
+    if (_obj.is_valid()) {
+        _obj.to_local().call_void_method(_method_on_scan_found, static_cast<jlong>(peripheral_id));
+    }
+}
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/AdapterCallback.h

@@ -0,0 +1,90 @@
+#pragma once
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+/**
+ * @brief C++ wrapper for the org.simplejavable.Adapter$Callback Java interface.
+ *
+ * This class encapsulates a jobject representing an instance of the Callback interface
+ * from the org.simplejavable.Adapter class. It provides methods to invoke the interface's
+ * Java methods (onScanStart, onScanStop, onScanUpdated, onScanFound) via JNI. JNI resources
+ * are preloaded during JNI_OnLoad using the AutoRegister mechanism.
+ */
+class AdapterCallback {
+  public:
+    AdapterCallback() = default;
+
+    /**
+     * @brief Construct a Callback from a Java object.
+     *
+     * Initializes the internal SimpleJNI::Object with the provided jobject and the preloaded
+     * jclass. Throws if JNI resources aren’t preloaded, enforcing initialization via JNI_OnLoad.
+     * @param obj The Java object implementing the Callback interface.
+     * @throws std::runtime_error if JNI resources are not preloaded.
+     */
+    explicit AdapterCallback(jobject obj);
+
+    /**
+     * @brief Invoke the onScanStart method on the Java Callback object.
+     *
+     * Calls the Java onScanStart() method, which has no arguments and returns void.
+     */
+    void on_scan_start();
+
+    /**
+     * @brief Invoke the onScanStop method on the Java Callback object.
+     *
+     * Calls the Java onScanStop() method, which has no arguments and returns void.
+     */
+    void on_scan_stop();
+
+    /**
+     * @brief Invoke the onScanUpdated method on the Java Callback object.
+     *
+     * Calls the Java onScanUpdated(long) method, passing a peripheral ID as a jlong.
+     * @param peripheral_id The ID of the peripheral that was updated.
+     */
+    void on_scan_updated(int64_t peripheral_id);
+
+    /**
+     * @brief Invoke the onScanFound method on the Java Callback object.
+     *
+     * Calls the Java onScanFound(long) method, passing a peripheral ID as a jlong.
+     * @param peripheral_id The ID of the peripheral that was found.
+     */
+    void on_scan_found(int64_t peripheral_id);
+
+  private:
+    // Static JNI resources, populated by Registrar during JNI_OnLoad
+    static SimpleJNI::GlobalRef<jclass> _cls;  ///< Preloaded jclass for org.simplejavable.Adapter$Callback.
+    static jmethodID _method_on_scan_start;    ///< Preloaded jmethodID for onScanStart.
+    static jmethodID _method_on_scan_stop;     ///< Preloaded jmethodID for onScanStop.
+    static jmethodID _method_on_scan_updated;  ///< Preloaded jmethodID for onScanUpdated.
+    static jmethodID _method_on_scan_found;    ///< Preloaded jmethodID for onScanFound.
+
+    /**
+     * @brief JNI descriptor defining the Callback interface and its methods.
+     *
+     * Declares the Java interface and its methods, linking to static storage locations
+     * where Registrar stores resolved JNI resources. Defined in Callback.cpp to ensure
+     * a single point of definition.
+     */
+    static const SimpleJNI::JNIDescriptor descriptor;
+
+    /**
+     * @brief Automatic registration of the descriptor with Registrar.
+     *
+     * Triggers registration during static initialization of Callback.cpp, ensuring the
+     * descriptor is added to Registrar before JNI_OnLoad. Defined in Callback.cpp to
+     * maintain a single instantiation.
+     */
+    static const SimpleJNI::AutoRegister<AdapterCallback> registrar;
+
+    SimpleJNI::Object<SimpleJNI::WeakRef> _obj;  ///< Wrapped Java object with WeakGlobalRef lifetime.
+};
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/Characteristic.cpp

@@ -0,0 +1,35 @@
+#include "Characteristic.h"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> Characteristic::_cls;
+jmethodID Characteristic::_init_method;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor Characteristic::descriptor{
+    "org/simplejavable/Characteristic",  // Java class name
+    &_cls,                               // Where to store the jclass
+    {
+        {"<init>", "(Ljava/lang/String;Ljava/util/List;ZZZZZ)V", &_init_method}  // Constructor method
+    }};
+
+// Define the AutoRegister instance
+const SimpleJNI::AutoRegister<Characteristic> Characteristic::registrar{&descriptor};
+
+// Constructor implementation
+Characteristic::Characteristic(const SimpleJNI::String<SimpleJNI::LocalRef>& uuid,
+                               const Java::Util::ArrayList<SimpleJNI::LocalRef>& descriptors, bool canRead,
+                               bool canWriteRequest, bool canWriteCommand, bool canNotify, bool canIndicate) {
+    // Use call_new_object to create a new Java Characteristic object
+    _obj = SimpleJNI::Object<SimpleJNI::ReleasableLocalRef>::call_new_object(
+        _cls.get(), _init_method, uuid.get(), descriptors.get(), static_cast<jboolean>(canRead),
+        static_cast<jboolean>(canWriteRequest), static_cast<jboolean>(canWriteCommand),
+        static_cast<jboolean>(canNotify), static_cast<jboolean>(canIndicate));
+}
+
+Characteristic::operator SimpleJNI::Object<SimpleJNI::ReleasableLocalRef, jobject>() const { return _obj; }
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/Characteristic.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include "Descriptor.h"
+#include "java/lang/ArrayList.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+/**
+ * @brief C++ wrapper for the org.simplejavable.Characteristic Java class.
+ *
+ * This class provides basic JNI registration functionality for the Characteristic class.
+ */
+class Characteristic {
+  public:
+    /**
+     * @brief Default constructor.
+     */
+    Characteristic() = default;
+
+    /**
+     * @brief Constructor that creates a Characteristic with the specified properties.
+     *
+     * @param uuid The UUID string for the characteristic.
+     * @param descriptors List of descriptors associated with this characteristic.
+     * @param canRead Whether the characteristic supports read operations.
+     * @param canWriteRequest Whether the characteristic supports write request operations.
+     * @param canWriteCommand Whether the characteristic supports write command operations.
+     * @param canNotify Whether the characteristic supports notifications.
+     * @param canIndicate Whether the characteristic supports indications.
+     */
+    Characteristic(const SimpleJNI::String<SimpleJNI::LocalRef>& uuid,
+                   const Java::Util::ArrayList<SimpleJNI::LocalRef>& descriptors, bool canRead, bool canWriteRequest,
+                   bool canWriteCommand, bool canNotify, bool canIndicate);
+
+    // Implicit conversion to SimpleJNI::Object
+    operator SimpleJNI::Object<SimpleJNI::ReleasableLocalRef, jobject>() const;
+
+  private:
+    // Static JNI resources, populated by Registrar during JNI_OnLoad
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _init_method;
+
+    /**
+     * @brief JNI descriptor defining the Characteristic class.
+     */
+    static const SimpleJNI::JNIDescriptor descriptor;
+
+    /**
+     * @brief Automatic registration of the descriptor with Registrar.
+     */
+    static const SimpleJNI::AutoRegister<Characteristic> registrar;
+
+    SimpleJNI::Object<SimpleJNI::ReleasableLocalRef> _obj;  ///< Wrapped Java object with ReleasableLocalRef lifetime.
+};
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/DataCallback.cpp

@@ -0,0 +1,33 @@
+#include "DataCallback.h"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> DataCallback::_cls;
+jmethodID DataCallback::_method_on_data_received = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor DataCallback::descriptor{
+    "org/simplejavable/Peripheral$DataCallback",  // Java interface name (inner class notation)
+    &_cls,                                        // Where to store the jclass
+    {                                             // Methods to preload
+     {"onDataReceived", "([B)V", &_method_on_data_received}}};
+
+// Define the AutoRegister instance
+const SimpleJNI::AutoRegister<DataCallback> DataCallback::registrar{&descriptor};
+
+DataCallback::DataCallback(jobject obj) : _obj(obj, _cls.get()) {
+    if (!_cls.get()) {
+        throw std::runtime_error("DataCallback JNI resources not preloaded");
+    }
+}
+
+void DataCallback::on_data_received(jbyteArray data) {
+    if (_obj.is_valid()) {
+        _obj.to_local().call_void_method(_method_on_data_received, data);
+    }
+}
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/DataCallback.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+/**
+ * @brief C++ wrapper for the org.simplejavable.Peripheral$DataCallback Java interface.
+ *
+ * This class encapsulates a jobject representing an instance of the DataCallback interface
+ * from the org.simplejavable.Peripheral class. It provides methods to invoke the interface's
+ * Java methods (onDataReceived) via JNI. JNI resources are preloaded during
+ * JNI_OnLoad using the AutoRegister mechanism.
+ */
+class DataCallback {
+  public:
+    DataCallback() = default;
+
+    /**
+     * @brief Construct a Callback from a Java object.
+     *
+     * @param obj The Java object implementing the Callback interface.
+     * @throws std::runtime_error if JNI resources are not preloaded.
+     */
+    explicit DataCallback(jobject obj);
+
+    /**
+     * @brief Invoke the onDataReceived method on the Java DataCallback object.
+     */
+    void on_data_received(jbyteArray data);
+
+  private:
+    // Static JNI resources, populated by Registrar during JNI_OnLoad
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_on_data_received;
+
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<DataCallback> registrar;
+
+    SimpleJNI::Object<SimpleJNI::WeakRef> _obj;
+};
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/Descriptor.cpp

@@ -0,0 +1,30 @@
+#include "Descriptor.h"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> Descriptor::_cls;
+jmethodID Descriptor::_init_method;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor Descriptor::descriptor{
+    "org/simplejavable/Descriptor",  // Java class name
+    &_cls,                           // Where to store the jclass
+    {
+        {"<init>", "(Ljava/lang/String;)V", &_init_method}  // Constructor method
+    }};
+
+// Define the AutoRegister instance
+const SimpleJNI::AutoRegister<Descriptor> Descriptor::registrar{&descriptor};
+
+// Constructor implementation
+Descriptor::Descriptor(const SimpleJNI::String<SimpleJNI::LocalRef>& uuid) {
+    // Use call_new_object to create a new Java Descriptor object
+    _obj = SimpleJNI::Object<SimpleJNI::ReleasableLocalRef>::call_new_object(_cls.get(), _init_method, uuid.get());
+}
+
+Descriptor::operator SimpleJNI::Object<SimpleJNI::ReleasableLocalRef, jobject>() const { return _obj; }
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org