simpleble 0.0.1

data/vendor/simpleble/simplejavable/cpp/src/core/AdapterWrapper.cpp

@@ -0,0 +1,37 @@
+#include "AdapterWrapper.h"
+#include "Cache.h"
+#include "PeripheralWrapper.h"
+
+AdapterWrapper::AdapterWrapper(const SimpleBLE::Adapter& adapter) : _adapter(adapter) {}
+
+AdapterWrapper::~AdapterWrapper() {
+    _adapter.set_callback_on_scan_found(nullptr);
+    _adapter.set_callback_on_scan_updated(nullptr);
+    _adapter.set_callback_on_scan_start(nullptr);
+    _adapter.set_callback_on_scan_stop(nullptr);
+}
+
+SimpleBLE::Adapter& AdapterWrapper::get() { return _adapter; }
+
+const SimpleBLE::Adapter& AdapterWrapper::get() const { return _adapter; }
+
+void AdapterWrapper::setCallback(Org::SimpleJavaBLE::AdapterCallback& callback) {
+    _callback = std::move(callback);
+
+    _adapter.set_callback_on_scan_found([this](const SimpleBLE::Peripheral& peripheral) {
+        PeripheralWrapper peripheral_wrapper(peripheral);
+        Cache::get().addPeripheral(getHash(), peripheral_wrapper.getHash(), peripheral_wrapper);
+        _callback.on_scan_found(peripheral_wrapper.getHash());
+    });
+
+    _adapter.set_callback_on_scan_updated([this](const SimpleBLE::Peripheral& peripheral) {
+        PeripheralWrapper peripheral_wrapper(peripheral);
+        _callback.on_scan_updated(peripheral_wrapper.getHash());
+    });
+
+    _adapter.set_callback_on_scan_start([this]() { _callback.on_scan_start(); });
+
+    _adapter.set_callback_on_scan_stop([this]() { _callback.on_scan_stop(); });
+}
+
+size_t AdapterWrapper::getHash() { return std::hash<std::string>{}(_adapter.identifier()); }

data/vendor/simpleble/simplejavable/cpp/src/core/AdapterWrapper.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <simpleble/SimpleBLE.h>
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+#include "org/simplejavable/AdapterCallback.h"
+
+class AdapterWrapper {
+  public:
+    explicit AdapterWrapper(const SimpleBLE::Adapter& adapter);
+    ~AdapterWrapper();
+
+    // Accessor to the underlying adapter
+    SimpleBLE::Adapter& get();
+    const SimpleBLE::Adapter& get() const;
+
+    void setCallback(Org::SimpleJavaBLE::AdapterCallback& callback);
+
+    size_t getHash();
+
+  private:
+    SimpleBLE::Adapter _adapter;
+    Org::SimpleJavaBLE::AdapterCallback _callback;
+};

data/vendor/simpleble/simplejavable/cpp/src/core/Cache.cpp

@@ -0,0 +1,58 @@
+#include "Cache.h"
+
+Cache& Cache::get() {
+    static Cache instance;
+    return instance;
+}
+
+void Cache::addAdapter(size_t adapter_id, const AdapterWrapper& adapter) {
+    if (hasAdapter(adapter_id)) return;
+
+    cached_adapters.emplace(adapter_id, adapter);
+}
+
+AdapterWrapper* Cache::getAdapter(size_t adapter_id) {
+    auto it = cached_adapters.find(adapter_id);
+    return (it != cached_adapters.end()) ? &it->second : nullptr;
+}
+
+bool Cache::hasAdapter(size_t adapter_id) const { return cached_adapters.find(adapter_id) != cached_adapters.end(); }
+
+bool Cache::hasPeripheral(size_t adapter_id, size_t peripheral_id) const {
+    auto adapter_it = cached_peripherals.find(adapter_id);
+    return (adapter_it != cached_peripherals.end()) &&
+           (adapter_it->second.find(peripheral_id) != adapter_it->second.end());
+}
+
+void Cache::addPeripheral(size_t adapter_id, size_t peripheral_id, const PeripheralWrapper& peripheral) {
+    if (!hasAdapter(adapter_id)) {
+        // Optional: Log or throw
+        return;
+    }
+
+    if (hasPeripheral(adapter_id, peripheral_id)) {
+        return;
+    }
+
+    cached_peripherals[adapter_id].emplace(peripheral_id, peripheral);
+}
+
+PeripheralWrapper* Cache::getPeripheral(size_t adapter_id, size_t peripheral_id) {
+    auto adapter_it = cached_peripherals.find(adapter_id);
+    if (adapter_it == cached_peripherals.end()) return nullptr;
+
+    auto peripheral_it = adapter_it->second.find(peripheral_id);
+    return (peripheral_it != adapter_it->second.end()) ? &peripheral_it->second : nullptr;
+}
+
+void Cache::removeAdapter(size_t adapter_id) {
+    cached_adapters.erase(adapter_id);
+    cached_peripherals.erase(adapter_id);
+}
+
+void Cache::removePeripheral(size_t adapter_id, size_t peripheral_id) {
+    auto adapter_it = cached_peripherals.find(adapter_id);
+    if (adapter_it != cached_peripherals.end()) {
+        adapter_it->second.erase(peripheral_id);
+    }
+}

data/vendor/simpleble/simplejavable/cpp/src/core/Cache.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <map>
+
+#include "AdapterWrapper.h"
+#include "PeripheralWrapper.h"
+
+class Cache {
+  private:
+    Cache() = default;
+
+    // Maps now store wrappers
+    std::map<size_t, AdapterWrapper> cached_adapters;
+    std::map<size_t, std::map<size_t, PeripheralWrapper>> cached_peripherals;
+
+  public:
+    static Cache& get();
+
+    Cache(const Cache&) = delete;
+    Cache& operator=(const Cache&) = delete;
+
+    // Adapter management
+    void addAdapter(size_t adapter_id, const AdapterWrapper& adapter);
+    AdapterWrapper* getAdapter(size_t adapter_id);
+    bool hasAdapter(size_t adapter_id) const;
+
+    // Peripheral management
+    void addPeripheral(size_t adapter_id, size_t peripheral_id, const PeripheralWrapper& peripheral);
+    PeripheralWrapper* getPeripheral(size_t adapter_id, size_t peripheral_id);
+    bool hasPeripheral(size_t adapter_id, size_t peripheral_id) const;
+
+    // Removal methods
+    void removeAdapter(size_t adapter_id);
+    void removePeripheral(size_t adapter_id, size_t peripheral_id);
+};

data/vendor/simpleble/simplejavable/cpp/src/core/PeripheralWrapper.cpp

@@ -0,0 +1,17 @@
+#include "PeripheralWrapper.h"
+
+PeripheralWrapper::PeripheralWrapper(const SimpleBLE::Peripheral& peripheral) : _peripheral(peripheral) {}
+
+SimpleBLE::Peripheral& PeripheralWrapper::get() { return _peripheral; }
+
+const SimpleBLE::Peripheral& PeripheralWrapper::get() const { return _peripheral; }
+
+void PeripheralWrapper::setCallback(Org::SimpleJavaBLE::PeripheralCallback& callback) {
+    _callback = std::move(callback);
+
+    _peripheral.set_callback_on_connected([this]() { _callback.on_connected(); });
+
+    _peripheral.set_callback_on_disconnected([this]() { _callback.on_disconnected(); });
+}
+
+size_t PeripheralWrapper::getHash() { return std::hash<std::string>{}(_peripheral.address()); }

data/vendor/simpleble/simplejavable/cpp/src/core/PeripheralWrapper.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <simpleble/SimpleBLE.h>
+#include "org/simplejavable/PeripheralCallback.h"
+
+class PeripheralWrapper {
+  public:
+    explicit PeripheralWrapper(const SimpleBLE::Peripheral& peripheral);
+
+    SimpleBLE::Peripheral& get();
+    const SimpleBLE::Peripheral& get() const;
+
+    void setCallback(Org::SimpleJavaBLE::PeripheralCallback& callback);
+
+    size_t getHash();
+
+  private:
+    SimpleBLE::Peripheral _peripheral;
+    Org::SimpleJavaBLE::PeripheralCallback _callback;
+};

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

@@ -0,0 +1,257 @@
+#include "ArrayList.h"
+
+namespace Java::Util {
+
+template <template <typename> class RefType>
+SimpleJNI::GlobalRef<jclass> ArrayList<RefType>::_cls;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_constructor = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_constructor_capacity = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_iterator = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_add = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_add_at_index = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_remove_object = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_remove_index = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_clear = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_size = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_get = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_set = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_isEmpty = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_ensureCapacity = nullptr;
+
+template <template <typename> class RefType>
+jmethodID ArrayList<RefType>::_method_trimToSize = nullptr;
+
+template <template <typename> class RefType>
+const SimpleJNI::JNIDescriptor ArrayList<RefType>::descriptor{
+    "java/util/ArrayList",  // Java class name
+    &_cls,                  // Where to store the jclass
+    {                       // Methods to preload
+     {"<init>", "()V", &_constructor},
+     {"<init>", "(I)V", &_constructor_capacity},
+     {"iterator", "()Ljava/util/Iterator;", &_method_iterator},
+     {"add", "(Ljava/lang/Object;)Z", &_method_add},
+     {"add", "(ILjava/lang/Object;)V", &_method_add_at_index},
+     {"remove", "(Ljava/lang/Object;)Z", &_method_remove_object},
+     {"remove", "(I)Ljava/lang/Object;", &_method_remove_index},
+     {"clear", "()V", &_method_clear},
+     {"size", "()I", &_method_size},
+     {"get", "(I)Ljava/lang/Object;", &_method_get},
+     {"set", "(ILjava/lang/Object;)Ljava/lang/Object;", &_method_set},
+     {"isEmpty", "()Z", &_method_isEmpty},
+     {"ensureCapacity", "(I)V", &_method_ensureCapacity},
+     {"trimToSize", "()V", &_method_trimToSize}}};
+
+template <template <typename> class RefType>
+const SimpleJNI::AutoRegister<ArrayList<RefType>> ArrayList<RefType>::registrar{&descriptor};
+
+template <template <typename> class RefType>
+ArrayList<RefType>::ArrayList() : _obj() {
+    if (!_cls.get()) {
+        throw std::runtime_error("ArrayList JNI resources not preloaded");
+    }
+
+    SimpleJNI::Env env;
+    jobject obj = env->NewObject(_cls.get(), _constructor);
+    if (obj == nullptr) {
+        throw std::runtime_error("Failed to create ArrayList instance");
+    }
+
+    _obj = SimpleJNI::Object<RefType, jobject>(obj, _cls.get());
+    env->DeleteLocalRef(obj);
+}
+
+template <template <typename> class RefType>
+ArrayList<RefType>::ArrayList(int initialCapacity) : _obj() {
+    if (!_cls.get()) {
+        throw std::runtime_error("ArrayList JNI resources not preloaded");
+    }
+
+    SimpleJNI::Env env;
+    jobject obj = env->NewObject(_cls.get(), _constructor_capacity, initialCapacity);
+    if (obj == nullptr) {
+        throw std::runtime_error("Failed to create ArrayList instance with capacity");
+    }
+
+    _obj = SimpleJNI::Object<RefType, jobject>(obj, _cls.get());
+    env->DeleteLocalRef(obj);
+}
+
+template <template <typename> class RefType>
+ArrayList<RefType>::ArrayList(jobject obj) : _obj() {
+    if (!_cls.get()) {
+        throw std::runtime_error("ArrayList JNI resources not preloaded");
+    }
+    _obj = SimpleJNI::Object<RefType, jobject>(obj, _cls.get());
+}
+
+template <template <typename> class RefType>
+template <template <typename> class OtherRefType>
+ArrayList<RefType>::ArrayList(const SimpleJNI::Object<OtherRefType, jobject>& obj) : _obj(obj.get()) {}
+
+template <template <typename> class RefType>
+ArrayList<SimpleJNI::LocalRef> ArrayList<RefType>::to_local() const {
+    if (!*this) return ArrayList<SimpleJNI::LocalRef>();
+    return ArrayList<SimpleJNI::LocalRef>(_obj.get());
+}
+
+template <template <typename> class RefType>
+ArrayList<SimpleJNI::GlobalRef> ArrayList<RefType>::to_global() const {
+    if (!*this) return ArrayList<SimpleJNI::GlobalRef>();
+    return ArrayList<SimpleJNI::GlobalRef>(_obj.get());
+}
+
+template <template <typename> class RefType>
+jobject ArrayList<RefType>::get() const {
+    return _obj.get();
+}
+
+template <template <typename> class RefType>
+template <template <typename> class R>
+typename std::enable_if<std::is_same<R<jobject>, SimpleJNI::ReleasableLocalRef<jobject>>::value, jobject>::type
+ArrayList<RefType>::release() {
+    return _obj.release();
+}
+
+template <template <typename> class RefType>
+ArrayList<RefType>::operator bool() const {
+    return _obj.get() != nullptr;
+}
+
+template <template <typename> class RefType>
+ArrayList<RefType>::operator SimpleJNI::Object<RefType, jobject>() const {
+    return _obj;
+}
+
+template <template <typename> class RefType>
+Iterator<SimpleJNI::LocalRef> ArrayList<RefType>::iterator() const {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    jobject iter = _obj.call_object_method(_method_iterator).get();
+    return Iterator<SimpleJNI::LocalRef>(iter);
+}
+
+template <template <typename> class RefType>
+void ArrayList<RefType>::add(const SimpleJNI::Object<RefType, jobject>& element) {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    _obj.call_boolean_method(_method_add, element.get());
+}
+
+template <template <typename> class RefType>
+void ArrayList<RefType>::add(size_t index, const SimpleJNI::Object<RefType, jobject>& element) {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    _obj.call_void_method(_method_add_at_index, static_cast<jint>(index), element.get());
+}
+
+template <template <typename> class RefType>
+bool ArrayList<RefType>::remove(const SimpleJNI::Object<RefType, jobject>& element) {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    return _obj.call_boolean_method(_method_remove_object, element.get());
+}
+
+template <template <typename> class RefType>
+SimpleJNI::Object<SimpleJNI::LocalRef> ArrayList<RefType>::remove(size_t index) {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    return _obj.call_object_method(_method_remove_index, static_cast<jint>(index));
+}
+
+template <template <typename> class RefType>
+void ArrayList<RefType>::clear() {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    _obj.call_void_method(_method_clear);
+}
+
+template <template <typename> class RefType>
+size_t ArrayList<RefType>::size() const {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    return static_cast<size_t>(_obj.call_int_method(_method_size));
+}
+
+template <template <typename> class RefType>
+SimpleJNI::Object<SimpleJNI::LocalRef> ArrayList<RefType>::get(size_t index) const {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    return _obj.call_object_method(_method_get, static_cast<jint>(index));
+}
+
+template <template <typename> class RefType>
+SimpleJNI::Object<SimpleJNI::LocalRef> ArrayList<RefType>::set(size_t index,
+                                                               const SimpleJNI::Object<RefType, jobject>& element) {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    return _obj.call_object_method(_method_set, static_cast<jint>(index), element.get());
+}
+
+template <template <typename> class RefType>
+bool ArrayList<RefType>::isEmpty() const {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    return _obj.call_boolean_method(_method_isEmpty);
+}
+
+template <template <typename> class RefType>
+void ArrayList<RefType>::ensureCapacity(int minCapacity) {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    _obj.call_void_method(_method_ensureCapacity, minCapacity);
+}
+
+template <template <typename> class RefType>
+void ArrayList<RefType>::trimToSize() {
+    if (!*this) {
+        throw std::runtime_error("ArrayList is not initialized");
+    }
+    _obj.call_void_method(_method_trimToSize);
+}
+
+// Explicit template instantiations
+template class ArrayList<SimpleJNI::LocalRef>;
+template class ArrayList<SimpleJNI::GlobalRef>;
+template class ArrayList<SimpleJNI::WeakRef>;
+template class ArrayList<SimpleJNI::ReleasableLocalRef>;
+
+template jobject ArrayList<SimpleJNI::ReleasableLocalRef>::release<SimpleJNI::ReleasableLocalRef>();
+
+}  // namespace Java::Util

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

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <cstddef>
+#include "Iterator.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Java::Util {
+
+template <template <typename> class RefType>
+class ArrayList {
+  public:
+    ArrayList();
+    explicit ArrayList(jobject obj);
+    ArrayList(int initialCapacity);
+
+    template <template <typename> class OtherRefType>
+    ArrayList(const SimpleJNI::Object<OtherRefType, jobject>& obj);
+
+    // Conversion methods
+    ArrayList<SimpleJNI::LocalRef> to_local() const;
+    ArrayList<SimpleJNI::GlobalRef> to_global() const;
+
+    // Get the underlying jobject
+    jobject get() const;
+
+    // Release the underlying jobject
+    template <template <typename> class R = RefType>
+    typename std::enable_if<std::is_same<R<jobject>, SimpleJNI::ReleasableLocalRef<jobject>>::value, jobject>::type
+    release();
+
+    // Check if the object is valid
+    explicit operator bool() const;
+
+    // Implicit conversion to SimpleJNI::Object
+    operator SimpleJNI::Object<RefType, jobject>() const;
+
+    // ArrayList methods
+    Iterator<SimpleJNI::LocalRef> iterator() const;
+    void add(const SimpleJNI::Object<RefType, jobject>& element);
+    void add(size_t index, const SimpleJNI::Object<RefType, jobject>& element);
+    bool remove(const SimpleJNI::Object<RefType, jobject>& element);
+    SimpleJNI::Object<SimpleJNI::LocalRef> remove(size_t index);
+    void clear();
+    size_t size() const;
+    SimpleJNI::Object<SimpleJNI::LocalRef> get(size_t index) const;
+    SimpleJNI::Object<SimpleJNI::LocalRef> set(size_t index, const SimpleJNI::Object<RefType, jobject>& element);
+    bool isEmpty() const;
+    void ensureCapacity(int minCapacity);
+    void trimToSize();
+
+  private:
+    // Underlying JNI object
+    SimpleJNI::Object<RefType, jobject> _obj;
+
+    // Static JNI resources
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _constructor;
+    static jmethodID _constructor_capacity;
+    static jmethodID _method_iterator;
+    static jmethodID _method_add;
+    static jmethodID _method_add_at_index;
+    static jmethodID _method_remove_object;
+    static jmethodID _method_remove_index;
+    static jmethodID _method_clear;
+    static jmethodID _method_size;
+    static jmethodID _method_get;
+    static jmethodID _method_set;
+    static jmethodID _method_isEmpty;
+    static jmethodID _method_ensureCapacity;
+    static jmethodID _method_trimToSize;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<ArrayList> registrar;
+};
+
+}  // namespace Java::Util

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

@@ -0,0 +1,96 @@
+#include "HashMap.h"
+
+namespace Java::Util {
+
+template <template <typename> class RefType>
+SimpleJNI::GlobalRef<jclass> HashMap<RefType>::_cls;
+
+template <template <typename> class RefType>
+jmethodID HashMap<RefType>::_method_init = nullptr;
+
+template <template <typename> class RefType>
+jmethodID HashMap<RefType>::_method_put = nullptr;
+
+template <template <typename> class RefType>
+const SimpleJNI::JNIDescriptor HashMap<RefType>::descriptor{
+    "java/util/HashMap",  // Java class name
+    &_cls,                // Where to store the jclass
+    {                     // Methods to preload
+     {"<init>", "()V", &_method_init},
+     {"put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", &_method_put}}};
+
+template <template <typename> class RefType>
+const SimpleJNI::AutoRegister<HashMap<RefType>> HashMap<RefType>::registrar{&descriptor};
+
+template <template <typename> class RefType>
+HashMap<RefType>::HashMap() : _obj() {
+    if (!_cls.get()) {
+        throw std::runtime_error("HashMap JNI resources not preloaded");
+    }
+
+    JNIEnv* env = SimpleJNI::VM::env();
+    jobject obj = env->NewObject(_cls.get(), _method_init);
+    _obj = SimpleJNI::Object<RefType, jobject>(obj, _cls.get());
+}
+
+template <template <typename> class RefType>
+HashMap<RefType>::HashMap(jobject obj) : _obj(obj) {}
+
+template <template <typename> class RefType>
+template <template <typename> class OtherRefType>
+HashMap<RefType>::HashMap(const SimpleJNI::Object<OtherRefType, jobject>& obj) : _obj(obj.get()) {}
+
+template <template <typename> class RefType>
+HashMap<SimpleJNI::LocalRef> HashMap<RefType>::to_local() const {
+    if (!*this) return HashMap<SimpleJNI::LocalRef>();
+    return HashMap<SimpleJNI::LocalRef>(_obj.get());
+}
+
+template <template <typename> class RefType>
+HashMap<SimpleJNI::GlobalRef> HashMap<RefType>::to_global() const {
+    if (!*this) return HashMap<SimpleJNI::GlobalRef>();
+    return HashMap<SimpleJNI::GlobalRef>(_obj.get());
+}
+
+template <template <typename> class RefType>
+jobject HashMap<RefType>::get() const {
+    return _obj.get();
+}
+
+template <template <typename> class RefType>
+template <template <typename> class R>
+typename std::enable_if<std::is_same<R<jobject>, SimpleJNI::ReleasableLocalRef<jobject>>::value, jobject>::type
+HashMap<RefType>::release() {
+    return _obj.release();
+}
+
+template <template <typename> class RefType>
+HashMap<RefType>::operator bool() const {
+    return _obj.get() != nullptr;
+}
+
+template <template <typename> class RefType>
+template <template <typename> class KeyRefType, template <typename> class ValueRefType>
+SimpleJNI::Object<SimpleJNI::LocalRef> HashMap<RefType>::put(const SimpleJNI::Object<KeyRefType, jobject>& key,
+                                                             const SimpleJNI::Object<ValueRefType, jobject>& value) {
+    return _obj.call_object_method(_method_put, key.get(), value.get());
+}
+
+template <template <typename> class RefType>
+HashMap<RefType>::operator SimpleJNI::Object<RefType, jobject>() const {
+    return _obj;
+}
+
+// Explicit template instantiations
+template class HashMap<SimpleJNI::LocalRef>;
+template class HashMap<SimpleJNI::GlobalRef>;
+template class HashMap<SimpleJNI::WeakRef>;
+template class HashMap<SimpleJNI::ReleasableLocalRef>;
+
+template SimpleJNI::Object<SimpleJNI::LocalRef, jobject> HashMap<SimpleJNI::ReleasableLocalRef>::put<
+    SimpleJNI::LocalRef, SimpleJNI::LocalRef>(const SimpleJNI::Object<SimpleJNI::LocalRef, jobject>& key,
+                                              const SimpleJNI::Object<SimpleJNI::LocalRef, jobject>& value);
+
+template jobject HashMap<SimpleJNI::ReleasableLocalRef>::release<SimpleJNI::ReleasableLocalRef>();
+
+}  // namespace Java::Util

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

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Java::Util {
+
+template <template <typename> class RefType>
+class HashMap {
+  public:
+    HashMap();
+    explicit HashMap(jobject obj);
+
+    template <template <typename> class OtherRefType>
+    HashMap(const SimpleJNI::Object<OtherRefType, jobject>& obj);
+
+    // Conversion methods
+    HashMap<SimpleJNI::LocalRef> to_local() const;
+    HashMap<SimpleJNI::GlobalRef> to_global() const;
+
+    // Get the underlying jobject
+    jobject get() const;
+
+    // Release the underlying jobject
+    template <template <typename> class R = RefType>
+    typename std::enable_if<std::is_same<R<jobject>, SimpleJNI::ReleasableLocalRef<jobject>>::value, jobject>::type
+    release();
+
+    // Check if the object is valid
+    explicit operator bool() const;
+
+    // Implicit conversion to SimpleJNI::Object
+    operator SimpleJNI::Object<RefType, jobject>() const;
+
+    // Put a key-value pair into the map
+    template <template <typename> class KeyRefType, template <typename> class ValueRefType>
+    SimpleJNI::Object<SimpleJNI::LocalRef> put(const SimpleJNI::Object<KeyRefType, jobject>& key,
+                                               const SimpleJNI::Object<ValueRefType, jobject>& value);
+
+  private:
+    // Underlying JNI object
+    SimpleJNI::Object<RefType, jobject> _obj;
+
+    // Static JNI resources
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_init;
+    static jmethodID _method_put;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<HashMap> registrar;
+};
+
+}  // namespace Java::Util