simpleble 0.0.1

data/vendor/simpleble/simpleble/src/backends/android/bridge/ScanCallback.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <kvn_safe_callback.hpp>
+#include <map>
+#include "types/android/bluetooth/le/ScanResult.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace SimpleBLE {
+namespace Android {
+namespace Bridge {
+
+class ScanCallback {
+  public:
+    ScanCallback();
+    virtual ~ScanCallback();
+    jobject get() const { return _obj.get(); }  // TODO: Remove once nothing uses this
+
+    void set_callback_onScanResult(std::function<void(Android::ScanResult)> callback);
+    void set_callback_onBatchScanResults(std::function<void()> callback);
+    void set_callback_onScanFailed(std::function<void()> callback);
+
+    // Not for public use
+    static void jni_onScanResultCallback(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> thiz, jint callback_type,
+                                         Android::ScanResult scan_result);
+    static void jni_onBatchScanResultsCallback(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> thiz,
+                                              SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> results);
+    static void jni_onScanFailedCallback(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> thiz, jint error_code);
+
+  private:
+    // Underlying JNI object - Use SimpleJNI::Object with GlobalRef
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    // Map for instance tracking - Key should be comparable using JniObjectComparator
+    static kvn::safe_map<SimpleJNI::Object<SimpleJNI::GlobalRef, jobject>, ScanCallback*,
+                         SimpleJNI::ObjectComparator<SimpleJNI::GlobalRef, jobject>>
+        _map;
+
+    // Callbacks
+    kvn::safe_callback<void(Android::ScanResult)> _callback_onScanResult;
+    kvn::safe_callback<void()> _callback_onBatchScanResults;
+    kvn::safe_callback<void()> _callback_onScanFailed;
+
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _constructor;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<ScanCallback> registrar;
+};
+
+}  // namespace Bridge
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/BluetoothAdapter.cpp

@@ -0,0 +1,107 @@
+#include "BluetoothAdapter.h"
+#include "types/java/util/Set.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+// Static member initialization
+SimpleJNI::GlobalRef<jclass> BluetoothAdapter::_cls;
+jmethodID BluetoothAdapter::_method_getName = nullptr;
+jmethodID BluetoothAdapter::_method_getAddress = nullptr;
+jmethodID BluetoothAdapter::_method_isEnabled = nullptr;
+jmethodID BluetoothAdapter::_method_getState = nullptr;
+jmethodID BluetoothAdapter::_method_getBluetoothLeScanner = nullptr;
+jmethodID BluetoothAdapter::_method_getBondedDevices = nullptr;
+jmethodID BluetoothAdapter::_method_getDefaultAdapter = nullptr;
+
+// JNI descriptors for auto-registration
+const SimpleJNI::JNIDescriptor BluetoothAdapter::instance_descriptor{
+    "android/bluetooth/BluetoothAdapter",  // Java class name
+    &_cls,                                 // Where to store the jclass
+    {                                      // Instance methods to preload
+     {"getName", "()Ljava/lang/String;", &_method_getName},
+     {"getAddress", "()Ljava/lang/String;", &_method_getAddress},
+     {"isEnabled", "()Z", &_method_isEnabled},
+     {"getState", "()I", &_method_getState},
+     {"getBluetoothLeScanner", "()Landroid/bluetooth/le/BluetoothLeScanner;", &_method_getBluetoothLeScanner},
+     {"getBondedDevices", "()Ljava/util/Set;", &_method_getBondedDevices}
+    }
+};
+
+const SimpleJNI::StaticJNIDescriptor BluetoothAdapter::static_descriptor{
+    "android/bluetooth/BluetoothAdapter",  // Java class name
+    &_cls,                                 // Where to store the jclass (shared with instance)
+    {                                      // Static methods to preload
+     {"getDefaultAdapter", "()Landroid/bluetooth/BluetoothAdapter;", &_method_getDefaultAdapter}
+    }
+};
+
+// Auto-register both descriptors
+const SimpleJNI::AutoRegister<BluetoothAdapter> BluetoothAdapter::registrar{&instance_descriptor, &static_descriptor};
+
+BluetoothAdapter::BluetoothAdapter(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {
+    if (!obj) {
+        throw std::runtime_error("BluetoothAdapter object is null");
+    }
+}
+
+BluetoothAdapter BluetoothAdapter::getDefaultAdapter() {
+    if (!_cls.get()) {
+        throw std::runtime_error("BluetoothAdapter JNI resources not preloaded. Ensure SimpleJNI::Registrar::preload() is called.");
+    }
+    SimpleJNI::Env env;
+    jobject local_obj = env->CallStaticObjectMethod(_cls.get(), _method_getDefaultAdapter);
+    if (local_obj == nullptr) {
+        throw std::runtime_error("Failed to get default BluetoothAdapter");
+    }
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj(local_obj);
+    env->DeleteLocalRef(local_obj);
+    return BluetoothAdapter(obj);
+}
+
+std::string BluetoothAdapter::getName() {
+    if (!_obj) throw std::runtime_error("BluetoothAdapter is not initialized");
+    return _obj.call_string_method(_method_getName);
+}
+
+std::string BluetoothAdapter::getAddress() {
+    if (!_obj) throw std::runtime_error("BluetoothAdapter is not initialized");
+    return _obj.call_string_method(_method_getAddress);
+}
+
+bool BluetoothAdapter::isEnabled() {
+    if (!_obj) throw std::runtime_error("BluetoothAdapter is not initialized");
+    return _obj.call_boolean_method(_method_isEnabled);
+}
+
+int BluetoothAdapter::getState() {
+    if (!_obj) throw std::runtime_error("BluetoothAdapter is not initialized");
+    return _obj.call_int_method(_method_getState);
+}
+
+BluetoothScanner BluetoothAdapter::getBluetoothLeScanner() {
+    if (!_obj) throw std::runtime_error("BluetoothAdapter is not initialized");
+    auto scanner_obj = _obj.call_object_method(_method_getBluetoothLeScanner);
+    return BluetoothScanner(scanner_obj);
+}
+
+std::vector<BluetoothDevice> BluetoothAdapter::getBondedDevices() {
+    if (!_obj) throw std::runtime_error("BluetoothAdapter is not initialized");
+
+    auto devices_obj = _obj.call_object_method(_method_getBondedDevices);
+    if (!devices_obj) throw std::runtime_error("Failed to get bonded devices");
+
+    std::vector<BluetoothDevice> result;
+    Set set(devices_obj.to_global());
+    Iterator iterator = set.iterator();
+    while (iterator.hasNext()) {
+        auto device_obj = iterator.next();
+        if (!device_obj) continue;
+        result.push_back(BluetoothDevice(device_obj));
+    }
+
+    return result;
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/BluetoothAdapter.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+#include "types/android/bluetooth/BluetoothDevice.h"
+#include "types/android/bluetooth/le/BluetoothScanner.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+class BluetoothAdapter {
+  public:
+    BluetoothAdapter(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+    virtual ~BluetoothAdapter() = default;
+
+    std::string getName();
+    std::string getAddress();
+    bool isEnabled();
+    int getState();
+
+    BluetoothScanner getBluetoothLeScanner();
+    std::vector<BluetoothDevice> getBondedDevices();
+
+    // NOTE: The correct way to request a BluetoothAdapter is to go though the BluetoothManager,
+    // as described in https://developer.android.com/reference/android/bluetooth/BluetoothManager#getAdapter()
+    // However, for simplicity, we are using a direct call to BluetoothAdapter.getDefaultAdapter() which is
+    // deprecated in API 31 but still works. We'll need to implement a backend bypass to get a Context
+    // object and call getSystemService(Context.BLUETOOTH_SERVICE) to get the BluetoothManager.
+
+    // NOTE: Android BluetoothAdapter and BluetoothScanner classes are singletons, but so is this
+    // class, so we don't need to make them static.
+    static BluetoothAdapter getDefaultAdapter();
+    jobject get() const { return _obj.get(); }  // TODO: Remove once nothing uses this
+
+  private:
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_getName;
+    static jmethodID _method_getAddress;
+    static jmethodID _method_isEnabled;
+    static jmethodID _method_getState;
+    static jmethodID _method_getBluetoothLeScanner;
+    static jmethodID _method_getBondedDevices;
+    static jmethodID _method_getDefaultAdapter;
+
+    // JNI descriptors for auto-registration
+    static const SimpleJNI::JNIDescriptor instance_descriptor;
+    static const SimpleJNI::StaticJNIDescriptor static_descriptor;
+    static const SimpleJNI::AutoRegister<BluetoothAdapter> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/BluetoothDevice.cpp

@@ -0,0 +1,68 @@
+#include "BluetoothDevice.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+// Static constants
+const int BluetoothDevice::BOND_NONE;
+const int BluetoothDevice::BOND_BONDING;
+const int BluetoothDevice::BOND_BONDED;
+
+const int BluetoothDevice::ADDRESS_TYPE_ANONYMOUS;
+const int BluetoothDevice::ADDRESS_TYPE_PUBLIC;
+const int BluetoothDevice::ADDRESS_TYPE_RANDOM;
+
+const int BluetoothDevice::TRANSPORT_AUTO;
+const int BluetoothDevice::TRANSPORT_BREDR;
+const int BluetoothDevice::TRANSPORT_LE;
+
+// Static JNI resources
+SimpleJNI::GlobalRef<jclass> BluetoothDevice::_cls;
+jmethodID BluetoothDevice::_method_getAddress;
+jmethodID BluetoothDevice::_method_getName;
+jmethodID BluetoothDevice::_method_getBondState;
+jmethodID BluetoothDevice::_method_connectGatt;
+
+// JNI descriptor and registrar
+const SimpleJNI::JNIDescriptor BluetoothDevice::descriptor{
+    "android/bluetooth/BluetoothDevice", // Java class name
+    &_cls,                               // Where to store the jclass
+    {                                    // Methods to preload
+        {"getAddress", "()Ljava/lang/String;", &_method_getAddress},
+        {"getName", "()Ljava/lang/String;", &_method_getName},
+        {"getBondState", "()I", &_method_getBondState},
+        {"connectGatt", "(Landroid/content/Context;ZLandroid/bluetooth/BluetoothGattCallback;I)Landroid/bluetooth/BluetoothGatt;", &_method_connectGatt}
+    }
+};
+
+const SimpleJNI::AutoRegister<BluetoothDevice> BluetoothDevice::registrar{&descriptor};
+
+BluetoothDevice::BluetoothDevice(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {
+    if (!_cls.get()) {
+        throw std::runtime_error("BluetoothDevice JNI resources not preloaded. Ensure SimpleJNI::Registrar::preload() is called.");
+    }
+}
+
+std::string BluetoothDevice::getAddress() {
+    if (!_obj) throw std::runtime_error("BluetoothDevice is not initialized");
+    return _obj.call_string_method(_method_getAddress);
+}
+
+std::string BluetoothDevice::getName() {
+    if (!_obj) throw std::runtime_error("BluetoothDevice is not initialized");
+    return _obj.call_string_method(_method_getName);
+}
+
+int BluetoothDevice::getBondState() {
+    if (!_obj) throw std::runtime_error("BluetoothDevice is not initialized");
+    return _obj.call_int_method(_method_getBondState);
+}
+
+BluetoothGatt BluetoothDevice::connectGatt(bool autoConnect, Bridge::BluetoothGattCallback& callback) {
+    if (!_obj) throw std::runtime_error("BluetoothDevice is not initialized");
+    return BluetoothGatt(
+        _obj.call_object_method(_method_connectGatt, nullptr, autoConnect, callback.get(), BluetoothDevice::TRANSPORT_LE));
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/BluetoothDevice.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "BluetoothGatt.h"
+#include "bridge/BluetoothGattCallback.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace SimpleBLE {
+namespace Android {
+
+class BluetoothDevice {
+  public:
+    BluetoothDevice(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+    virtual ~BluetoothDevice() = default;
+
+    std::string getAddress();
+    // int getAddressType();
+    std::string getName();
+    int getBondState();
+    // void removeBond();
+
+    BluetoothGatt connectGatt(bool autoConnect, Bridge::BluetoothGattCallback& callback);
+
+    static const int BOND_NONE = 10;
+    static const int BOND_BONDING = 11;
+    static const int BOND_BONDED = 12;
+
+    static const int ADDRESS_TYPE_ANONYMOUS = 255;
+    static const int ADDRESS_TYPE_PUBLIC = 0;
+    static const int ADDRESS_TYPE_RANDOM = 1;
+
+    static const int TRANSPORT_AUTO = 0;
+    static const int TRANSPORT_BREDR = 1;
+    static const int TRANSPORT_LE = 2;
+
+  private:
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_getAddress;
+    // static jmethodID _method_getAddressType;
+    static jmethodID _method_getName;
+    static jmethodID _method_getBondState;
+    static jmethodID _method_removeBond;
+    static jmethodID _method_connectGatt;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<BluetoothDevice> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/BluetoothGatt.cpp

@@ -0,0 +1,115 @@
+#include "BluetoothGatt.h"
+#include <android/log.h>
+#include <fmt/core.h>
+
+#include "types/java/util/List.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+SimpleJNI::GlobalRef<jclass> BluetoothGatt::_cls;
+jmethodID BluetoothGatt::_method_close = nullptr;
+jmethodID BluetoothGatt::_method_connect = nullptr;
+jmethodID BluetoothGatt::_method_disconnect = nullptr;
+jmethodID BluetoothGatt::_method_discoverServices = nullptr;
+jmethodID BluetoothGatt::_method_getServices = nullptr;
+jmethodID BluetoothGatt::_method_readCharacteristic = nullptr;
+jmethodID BluetoothGatt::_method_readDescriptor = nullptr;
+jmethodID BluetoothGatt::_method_setCharacteristicNotification = nullptr;
+jmethodID BluetoothGatt::_method_writeCharacteristic = nullptr;
+jmethodID BluetoothGatt::_method_writeDescriptor = nullptr;
+jmethodID BluetoothGatt::_method_requestConnectionPriority = nullptr;
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor BluetoothGatt::descriptor{
+    "android/bluetooth/BluetoothGatt", // Java class name
+    &_cls,                             // Where to store the jclass
+    {                                  // Methods to preload
+     {"close", "()V", &_method_close},
+     {"connect", "()Z", &_method_connect},
+     {"disconnect", "()V", &_method_disconnect},
+     {"discoverServices", "()Z", &_method_discoverServices},
+     {"getServices", "()Ljava/util/List;", &_method_getServices},
+     {"readCharacteristic", "(Landroid/bluetooth/BluetoothGattCharacteristic;)Z", &_method_readCharacteristic},
+     {"readDescriptor", "(Landroid/bluetooth/BluetoothGattDescriptor;)Z", &_method_readDescriptor},
+     {"setCharacteristicNotification", "(Landroid/bluetooth/BluetoothGattCharacteristic;Z)Z", &_method_setCharacteristicNotification},
+     {"writeCharacteristic", "(Landroid/bluetooth/BluetoothGattCharacteristic;)Z", &_method_writeCharacteristic},
+     {"writeDescriptor", "(Landroid/bluetooth/BluetoothGattDescriptor;)Z", &_method_writeDescriptor},
+     {"requestConnectionPriority", "(I)Z", &_method_requestConnectionPriority}
+    }};
+
+const SimpleJNI::AutoRegister<BluetoothGatt> BluetoothGatt::registrar{&descriptor};
+
+BluetoothGatt::BluetoothGatt() {}
+
+BluetoothGatt::BluetoothGatt(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+void BluetoothGatt::close() {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    _obj.call_void_method(_method_close);
+}
+
+bool BluetoothGatt::connect() {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    return _obj.call_boolean_method(_method_connect);
+}
+
+void BluetoothGatt::disconnect() {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    _obj.call_void_method(_method_disconnect);
+}
+
+bool BluetoothGatt::discoverServices() {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    return _obj.call_boolean_method(_method_discoverServices);
+}
+
+std::vector<BluetoothGattService> BluetoothGatt::getServices() {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> services_obj = _obj.call_object_method(_method_getServices);
+    if (!services_obj) return std::vector<BluetoothGattService>();
+
+    std::vector<BluetoothGattService> result;
+    // Assuming JNI::Types::List and related classes are adapted to SimpleJNI namespace
+    // This part might need further adjustment based on how List and Iterator are implemented in SimpleJNI
+    List list(services_obj.to_global());
+    Iterator iterator = list.iterator();
+    while (iterator.hasNext()) {
+        SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> service = iterator.next();
+        if (!service) continue;
+        result.push_back(BluetoothGattService(service));
+    }
+    return result;
+}
+
+bool BluetoothGatt::readCharacteristic(BluetoothGattCharacteristic characteristic) {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    return _obj.call_boolean_method(_method_readCharacteristic, characteristic.getObject().get());
+}
+
+bool BluetoothGatt::readDescriptor(BluetoothGattDescriptor descriptor) {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    return _obj.call_boolean_method(_method_readDescriptor, descriptor.getObject().get());
+}
+
+bool BluetoothGatt::setCharacteristicNotification(BluetoothGattCharacteristic characteristic, bool enable) {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    return _obj.call_boolean_method(_method_setCharacteristicNotification, characteristic.getObject().get(), enable);
+}
+
+bool BluetoothGatt::writeCharacteristic(BluetoothGattCharacteristic characteristic) {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    return _obj.call_boolean_method(_method_writeCharacteristic, characteristic.getObject().get());
+}
+
+bool BluetoothGatt::writeDescriptor(BluetoothGattDescriptor descriptor) {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    return _obj.call_boolean_method(_method_writeDescriptor, descriptor.getObject().get());
+}
+
+bool BluetoothGatt::requestConnectionPriority(int connectionPriority) {
+    if (!_obj) throw std::runtime_error("BluetoothGatt is not initialized");
+    return _obj.call_boolean_method(_method_requestConnectionPriority, connectionPriority);
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/BluetoothGatt.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "BluetoothGattService.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+#include <cstdint>
+#include <vector>
+
+namespace SimpleBLE {
+namespace Android {
+
+class BluetoothGatt {
+  public:
+
+    static constexpr int CONNECTION_PRIORITY_BALANCED = 0;
+    static constexpr int CONNECTION_PRIORITY_HIGH = 1;
+    static constexpr int CONNECTION_PRIORITY_LOW_POWER = 2;
+    static constexpr int CONNECTION_PRIORITY_DCK = 3;
+
+    BluetoothGatt();
+    BluetoothGatt(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    void close();
+    bool connect();
+    void disconnect();
+    bool discoverServices();
+    std::vector<BluetoothGattService> getServices();
+
+    // void abortReliableWrite(BluetoothDevice mDevice);
+    // void abortReliableWrite();
+    // bool beginReliableWrite();
+    // bool executeReliableWrite();
+    // std::list<BluetoothDevice> getConnectedDevices();
+    // int getConnectionState(BluetoothDevice device);
+    // BluetoothDevice getDevice();
+    // std::list<BluetoothDevice> getDevicesMatchingConnectionStates(std::vector<int>& states);
+    // BluetoothGattService getService(UUID uuid);
+    // std::list<BluetoothGattService> getServices();
+    bool readCharacteristic(BluetoothGattCharacteristic characteristic);
+    bool readDescriptor(BluetoothGattDescriptor descriptor);
+    // void readPhy();
+    // bool readRemoteRssi();
+    bool requestConnectionPriority(int connectionPriority);
+    // bool requestMtu(int mtu);
+    bool setCharacteristicNotification(BluetoothGattCharacteristic characteristic, bool enable);
+    // void setPreferredPhy(int txPhy, int rxPhy, int phyOptions);
+    bool writeCharacteristic(BluetoothGattCharacteristic characteristic);
+    // int writeCharacteristic(BluetoothGattCharacteristic characteristic, std::vector<byte>& value, int writeType);
+    bool writeDescriptor(BluetoothGattDescriptor descriptor);
+    // int writeDescriptor(BluetoothGattDescriptor descriptor, std::vector<byte>& value);
+
+  private:
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_close;
+    static jmethodID _method_connect;
+    static jmethodID _method_disconnect;
+    static jmethodID _method_discoverServices;
+    static jmethodID _method_getServices;
+    static jmethodID _method_readCharacteristic;
+    static jmethodID _method_readDescriptor;
+    static jmethodID _method_setCharacteristicNotification;
+    static jmethodID _method_writeCharacteristic;
+    static jmethodID _method_writeDescriptor;
+    static jmethodID _method_requestConnectionPriority;
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<BluetoothGatt> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/BluetoothGattCharacteristic.cpp

@@ -0,0 +1,142 @@
+//
+// Created by Kevin Dewald on 5/17/24.
+//
+
+#include "BluetoothGattCharacteristic.h"
+#include "types/java/util/UUID.h"
+#include "types/java/util/List.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+// Static JNI resources
+SimpleJNI::GlobalRef<jclass> BluetoothGattCharacteristic::_cls;
+jmethodID BluetoothGattCharacteristic::_method_addDescriptor = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_getDescriptor = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_getDescriptors = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_getInstanceId = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_getPermissions = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_getProperties = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_getService = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_getUuid = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_getWriteType = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_setWriteType = nullptr;
+jmethodID BluetoothGattCharacteristic::_method_setValue = nullptr;
+
+// JNI descriptor for auto-registration
+const SimpleJNI::JNIDescriptor BluetoothGattCharacteristic::descriptor{
+    "android/bluetooth/BluetoothGattCharacteristic", // Java class name
+    &_cls,                                           // Where to store the jclass
+    {                                                // Methods to preload
+     {"addDescriptor", "(Landroid/bluetooth/BluetoothGattDescriptor;)Z", &_method_addDescriptor},
+     {"getDescriptor", "(Ljava/util/UUID;)Landroid/bluetooth/BluetoothGattDescriptor;", &_method_getDescriptor},
+     {"getDescriptors", "()Ljava/util/List;", &_method_getDescriptors},
+     {"getInstanceId", "()I", &_method_getInstanceId},
+     {"getPermissions", "()I", &_method_getPermissions},
+     {"getProperties", "()I", &_method_getProperties},
+     {"getService", "()Landroid/bluetooth/BluetoothGattService;", &_method_getService},
+     {"getUuid", "()Ljava/util/UUID;", &_method_getUuid},
+     {"getWriteType", "()I", &_method_getWriteType},
+     {"setWriteType", "(I)V", &_method_setWriteType},
+     {"setValue", "([B)Z", &_method_setValue}
+    }};
+
+// Auto-register the descriptor
+const SimpleJNI::AutoRegister<BluetoothGattCharacteristic> BluetoothGattCharacteristic::registrar{&descriptor};
+
+BluetoothGattCharacteristic::BluetoothGattCharacteristic() : _obj() {
+    if (!_cls.get()) {
+        throw std::runtime_error("BluetoothGattCharacteristic JNI resources not preloaded. Ensure SimpleJNI::Registrar::preload() is called.");
+    }
+
+    SimpleJNI::Env env;
+    jobject local_obj = env->NewObject(_cls.get(), env->GetMethodID(_cls.get(), "<init>", "()V"));
+    if (local_obj == nullptr) {
+        throw std::runtime_error("Failed to create BluetoothGattCharacteristic Java instance");
+    }
+
+    _obj = SimpleJNI::Object<SimpleJNI::GlobalRef, jobject>(local_obj);
+    env->DeleteLocalRef(local_obj);
+}
+
+BluetoothGattCharacteristic::BluetoothGattCharacteristic(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+// bool BluetoothGattCharacteristic::addDescriptor(BluetoothGattDescriptor descriptor) {
+//     return _obj.call_boolean_method(_method_addDescriptor, descriptor.getObject());
+// }
+//
+// BluetoothGattDescriptor BluetoothGattCharacteristic::getDescriptor(std::string uuid) {
+//     JNI::Env env;
+//     SimpleJNI::Object<SimpleJNI::LocalRef, jobject> descObj = _obj.call_object_method(_method_getDescriptor, env->NewStringUTF(uuid.c_str()));
+//     return BluetoothGattDescriptor(descObj);
+// }
+//
+std::vector<BluetoothGattDescriptor> BluetoothGattCharacteristic::getDescriptors() {
+    if (!_obj) throw std::runtime_error("BluetoothGattCharacteristic is not initialized");
+
+    SimpleJNI::Object<SimpleJNI::LocalRef, jobject> descriptors_obj = _obj.call_object_method(_method_getDescriptors);
+    if (!descriptors_obj) throw std::runtime_error("Failed to get descriptors");
+
+    std::vector<BluetoothGattDescriptor> result;
+    List list(descriptors_obj.to_global());
+    Iterator iterator = list.iterator();
+    while (iterator.hasNext()) {
+        SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> descriptor = iterator.next();
+
+        if (!descriptor) continue;
+        result.push_back(BluetoothGattDescriptor(descriptor));
+    }
+
+    return result;
+}
+
+int BluetoothGattCharacteristic::getInstanceId() {
+    if (!_obj) throw std::runtime_error("BluetoothGattCharacteristic is not initialized");
+    return _obj.call_int_method(_method_getInstanceId);
+}
+
+int BluetoothGattCharacteristic::getPermissions() {
+    if (!_obj) throw std::runtime_error("BluetoothGattCharacteristic is not initialized");
+    return _obj.call_int_method(_method_getPermissions);
+}
+
+int BluetoothGattCharacteristic::getProperties() {
+    if (!_obj) throw std::runtime_error("BluetoothGattCharacteristic is not initialized");
+    return _obj.call_int_method(_method_getProperties);
+}
+
+std::string BluetoothGattCharacteristic::getUuid() {
+    if (!_obj) throw std::runtime_error("BluetoothGattCharacteristic is not initialized");
+
+    SimpleJNI::Object<SimpleJNI::LocalRef, jobject> uuidObj = _obj.call_object_method(_method_getUuid);
+    if (!uuidObj) throw std::runtime_error("Failed to get UUID");
+
+    return UUID(uuidObj.to_global()).toString();
+}
+
+int BluetoothGattCharacteristic::getWriteType() {
+    if (!_obj) throw std::runtime_error("BluetoothGattCharacteristic is not initialized");
+    return _obj.call_int_method(_method_getWriteType);
+}
+
+void BluetoothGattCharacteristic::setWriteType(int writeType) {
+    if (!_obj) throw std::runtime_error("BluetoothGattCharacteristic is not initialized");
+    _obj.call_void_method(_method_setWriteType, writeType);
+}
+
+bool BluetoothGattCharacteristic::setValue(const std::vector<uint8_t>& value) {
+    if (!_obj) throw std::runtime_error("BluetoothGattCharacteristic is not initialized");
+
+    SimpleJNI::ByteArray<SimpleJNI::LocalRef> jni_array_wrapper(value);
+
+    if (!jni_array_wrapper) {
+        throw std::runtime_error("Failed to create Java byte array for setValue using SimpleJNI::ByteArray");
+    }
+
+    bool success = _obj.call_boolean_method(_method_setValue, jni_array_wrapper.get());
+
+    return success;
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE