simpleble 0.0.1

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

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "BluetoothGattDescriptor.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace SimpleBLE {
+namespace Android {
+
+class BluetoothGattCharacteristic {
+    // See: https://developer.android.com/reference/android/bluetooth/BluetoothGattCharacteristic
+  public:
+    BluetoothGattCharacteristic();
+    BluetoothGattCharacteristic(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+    virtual ~BluetoothGattCharacteristic() = default;
+
+    //    bool addDescriptor(BluetoothGattDescriptor descriptor);
+    //    BluetoothGattDescriptor getDescriptor(std::string uuid);
+    std::vector<BluetoothGattDescriptor> getDescriptors();
+
+    int getInstanceId();
+    int getPermissions();
+    int getProperties();
+    std::string getUuid();
+    int getWriteType();
+    void setWriteType(int writeType);
+
+    bool setValue(const std::vector<uint8_t>& value);
+
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> getObject() const { return _obj; }
+
+    static const int PROPERTY_INDICATE = 0x00000020;
+    static const int PROPERTY_NOTIFY = 0x00000010;
+    static const int PROPERTY_READ = 0x00000002;
+    static const int PROPERTY_WRITE = 0x00000008;
+    static const int PROPERTY_WRITE_NO_RESPONSE = 0x00000004;
+
+    static const int WRITE_TYPE_DEFAULT = 2;
+    static const int WRITE_TYPE_NO_RESPONSE = 1;
+
+  private:
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_addDescriptor;
+    static jmethodID _method_getDescriptor;
+    static jmethodID _method_getDescriptors;
+    static jmethodID _method_getInstanceId;
+    static jmethodID _method_getPermissions;
+    static jmethodID _method_getProperties;
+    static jmethodID _method_getService;
+    static jmethodID _method_getUuid;
+    static jmethodID _method_getWriteType;
+    static jmethodID _method_setWriteType;
+    static jmethodID _method_setValue;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<BluetoothGattCharacteristic> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

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

@@ -0,0 +1,67 @@
+#include "BluetoothGattDescriptor.h"
+#include "types/java/util/UUID.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> BluetoothGattDescriptor::_cls;
+jmethodID BluetoothGattDescriptor::_method_getUuid = nullptr;
+jmethodID BluetoothGattDescriptor::_method_getValue = nullptr;
+jmethodID BluetoothGattDescriptor::_method_setValue = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor BluetoothGattDescriptor::descriptor{
+    "android/bluetooth/BluetoothGattDescriptor", // Java class name
+    &_cls,                                       // Where to store the jclass
+    {                                            // Methods to preload
+     {"getUuid", "()Ljava/util/UUID;", &_method_getUuid},
+     {"getValue", "()[B", &_method_getValue},
+     {"setValue", "([B)Z", &_method_setValue}
+    }};
+
+const SimpleJNI::AutoRegister<BluetoothGattDescriptor> BluetoothGattDescriptor::registrar{&descriptor};
+
+const std::string BluetoothGattDescriptor::CLIENT_CHARACTERISTIC_CONFIG = "00002902-0000-1000-8000-00805f9b34fb";
+const std::vector<uint8_t> BluetoothGattDescriptor::DISABLE_NOTIFICATION_VALUE = {0x00, 0x00};
+const std::vector<uint8_t> BluetoothGattDescriptor::ENABLE_NOTIFICATION_VALUE = {0x01, 0x00};
+const std::vector<uint8_t> BluetoothGattDescriptor::ENABLE_INDICATION_VALUE = {0x02, 0x00};
+
+BluetoothGattDescriptor::BluetoothGattDescriptor() : _obj() {
+    if (!_cls.get()) {
+        throw std::runtime_error("BluetoothGattDescriptor JNI resources not preloaded. Ensure SimpleJNI::Registrar::preload() is called.");
+    }
+}
+
+BluetoothGattDescriptor::BluetoothGattDescriptor(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+std::string BluetoothGattDescriptor::getUuid() {
+    if (!_obj) throw std::runtime_error("BluetoothGattDescriptor 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();
+}
+
+std::vector<uint8_t> BluetoothGattDescriptor::getValue() {
+    if (!_obj) throw std::runtime_error("BluetoothGattDescriptor is not initialized");
+
+    return _obj.call_byte_array_method(_method_getValue);
+}
+
+bool BluetoothGattDescriptor::setValue(const std::vector<uint8_t>& value) {
+    if (!_obj) throw std::runtime_error("BluetoothGattDescriptor is not initialized");
+
+    SimpleJNI::Env env;
+    jbyteArray jbyteArray_obj = env->NewByteArray(value.size());
+    env->SetByteArrayRegion(jbyteArray_obj, 0, value.size(), reinterpret_cast<const jbyte*>(value.data()));
+
+    bool result = _obj.call_boolean_method(_method_setValue, jbyteArray_obj);
+
+    env->DeleteLocalRef(jbyteArray_obj);
+    return result;
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

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

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <simpleble/Types.h>
+#include <string>
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace SimpleBLE {
+namespace Android {
+
+class BluetoothGattDescriptor {
+    // See: https://developer.android.com/reference/android/bluetooth/BluetoothGattDescriptor
+  public:
+    BluetoothGattDescriptor();
+    BluetoothGattDescriptor(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+    virtual ~BluetoothGattDescriptor() = default;
+
+    std::string getUuid();
+
+    std::vector<uint8_t> getValue();
+    bool setValue(const std::vector<uint8_t>& value);
+
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> getObject() const { return _obj; }
+
+    static const std::string CLIENT_CHARACTERISTIC_CONFIG;
+    static const std::vector<uint8_t> DISABLE_NOTIFICATION_VALUE;
+    static const std::vector<uint8_t> ENABLE_NOTIFICATION_VALUE;
+    static const std::vector<uint8_t> ENABLE_INDICATION_VALUE;
+
+  private:
+    // Underlying JNI object - Use SimpleJNI::Object with GlobalRef
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_getUuid;
+    static jmethodID _method_getValue;
+    static jmethodID _method_setValue;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<BluetoothGattDescriptor> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

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

@@ -0,0 +1,106 @@
+//
+// Created by Kevin Dewald on 5/17/24.
+//
+
+#include "BluetoothGattService.h"
+#include "types/java/util/UUID.h"
+#include "types/java/util/List.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+SimpleJNI::GlobalRef<jclass> BluetoothGattService::_cls;
+jmethodID BluetoothGattService::_method_addCharacteristic = nullptr;
+jmethodID BluetoothGattService::_method_addService = nullptr;
+jmethodID BluetoothGattService::_method_getCharacteristic = nullptr;
+jmethodID BluetoothGattService::_method_getCharacteristics = nullptr;
+jmethodID BluetoothGattService::_method_getIncludedServices = nullptr;
+jmethodID BluetoothGattService::_method_getInstanceId = nullptr;
+jmethodID BluetoothGattService::_method_getType = nullptr;
+jmethodID BluetoothGattService::_method_getUuid = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor BluetoothGattService::descriptor{
+    "android/bluetooth/BluetoothGattService", // Java class name
+    &_cls,                                    // Where to store the jclass
+    {                                         // Methods to preload
+     {"addCharacteristic", "(Landroid/bluetooth/BluetoothGattCharacteristic;)Z", &_method_addCharacteristic},
+     {"addService", "(Landroid/bluetooth/BluetoothGattService;)Z", &_method_addService},
+     {"getCharacteristic", "(Ljava/util/UUID;)Landroid/bluetooth/BluetoothGattCharacteristic;", &_method_getCharacteristic},
+     {"getCharacteristics", "()Ljava/util/List;", &_method_getCharacteristics},
+     {"getIncludedServices", "()Ljava/util/List;", &_method_getIncludedServices},
+     {"getInstanceId", "()I", &_method_getInstanceId},
+     {"getType", "()I", &_method_getType},
+     {"getUuid", "()Ljava/util/UUID;", &_method_getUuid}
+    }};
+
+const SimpleJNI::AutoRegister<BluetoothGattService> BluetoothGattService::registrar{&descriptor};
+
+BluetoothGattService::BluetoothGattService() : _obj() {
+    if (!_cls.get()) {
+        throw std::runtime_error("BluetoothGattService JNI resources not preloaded. Ensure SimpleJNI::Registrar::preload() is called.");
+    }
+}
+
+BluetoothGattService::BluetoothGattService(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+// bool BluetoothGattService::addCharacteristic(BluetoothGattCharacteristic characteristic) {
+//     return _obj.call_boolean_method(_method_addCharacteristic, characteristic.getObject());
+// }
+//
+// bool BluetoothGattService::addService(BluetoothGattService service) {
+//     return _obj.call_boolean_method(_method_addService, service.getObject());
+// }
+//
+// BluetoothGattCharacteristic BluetoothGattService::getCharacteristic(std::string uuid) {
+//     JNI::Env env;
+//     SimpleJNI::Object<SimpleJNI::LocalRef, jobject> charObj = _obj.call_object_method(_method_getCharacteristic, env->NewStringUTF(uuid.c_str()));
+//     return BluetoothGattCharacteristic(charObj.to_global());
+// }
+//
+std::vector<BluetoothGattCharacteristic> BluetoothGattService::getCharacteristics() {
+    if (!_obj) throw std::runtime_error("BluetoothGattService is not initialized");
+
+    SimpleJNI::Object<SimpleJNI::LocalRef, jobject> characteristics_obj = _obj.call_object_method(_method_getCharacteristics);
+    if (!characteristics_obj) throw std::runtime_error("Failed to get characteristics");
+
+    std::vector<BluetoothGattCharacteristic> result;
+    List list(characteristics_obj.to_global());
+    Iterator iterator = list.iterator();
+    while (iterator.hasNext()) {
+        SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> characteristic = iterator.next();
+
+        if (!characteristic) continue;  // TODO: Should we throw an error here?
+        result.push_back(BluetoothGattCharacteristic(characteristic));
+    }
+
+    return result;
+}
+//
+// std::vector<BluetoothGattService> BluetoothGattService::getIncludedServices() {
+//    SimpleJNI::Object<SimpleJNI::LocalRef, jobject> listObj = _obj.call_object_method(_method_getIncludedServices);
+//    // TODO: Implement conversion from list to vector of BluetoothGattService
+//    return std::vector<BluetoothGattService>();
+//}
+
+int BluetoothGattService::getInstanceId() {
+    if (!_obj) throw std::runtime_error("BluetoothGattService is not initialized");
+    return _obj.call_int_method(_method_getInstanceId);
+}
+
+int BluetoothGattService::getType() {
+    if (!_obj) throw std::runtime_error("BluetoothGattService is not initialized");
+    return _obj.call_int_method(_method_getType);
+}
+
+std::string BluetoothGattService::getUuid() {
+    if (!_obj) throw std::runtime_error("BluetoothGattService 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();
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

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

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "BluetoothGattCharacteristic.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace SimpleBLE {
+namespace Android {
+
+class BluetoothGattService {
+  public:
+    BluetoothGattService();
+    BluetoothGattService(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    //    bool addCharacteristic(BluetoothGattCharacteristic characteristic);
+    //    bool addService(BluetoothGattService service);
+    //    BluetoothGattCharacteristic getCharacteristic(std::string uuid);
+    std::vector<BluetoothGattCharacteristic> getCharacteristics();
+    //    std::vector<BluetoothGattService> getIncludedServices(); // TODO: This might be necessary if we don't see the
+    //    secondary services in some other way.
+    int getInstanceId();
+    int getType();
+    std::string getUuid();
+
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> getObject() const { return _obj; }
+
+  private:
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_addCharacteristic;
+    static jmethodID _method_addService;
+    static jmethodID _method_getCharacteristic;
+    static jmethodID _method_getCharacteristics;
+    static jmethodID _method_getIncludedServices;
+    static jmethodID _method_getInstanceId;
+    static jmethodID _method_getType;
+    static jmethodID _method_getUuid;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<BluetoothGattService> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/le/BluetoothScanner.cpp

@@ -0,0 +1,47 @@
+#include "BluetoothScanner.h"
+#include <CommonUtils.h>
+#include <android/log.h>
+#include <fmt/format.h>
+
+namespace SimpleBLE {
+namespace Android {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> BluetoothScanner::_cls;
+jmethodID BluetoothScanner::_constructor = nullptr;
+jmethodID BluetoothScanner::_method_startScan = nullptr;
+jmethodID BluetoothScanner::_method_stopScan = nullptr;
+jmethodID BluetoothScanner::_method_toString = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor BluetoothScanner::descriptor{
+    "android/bluetooth/le/BluetoothLeScanner", // Java class name
+    &_cls,                                     // Where to store the jclass
+    {                                          // Methods to preload
+     {"<init>", "()V", &_constructor},
+     {"startScan", "(Landroid/bluetooth/le/ScanCallback;)V", &_method_startScan},
+     {"stopScan", "(Landroid/bluetooth/le/ScanCallback;)V", &_method_stopScan},
+     {"toString", "()Ljava/lang/String;", &_method_toString}
+    }};
+
+const SimpleJNI::AutoRegister<BluetoothScanner> BluetoothScanner::registrar{&descriptor};
+
+BluetoothScanner::BluetoothScanner(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+void BluetoothScanner::startScan(Bridge::ScanCallback& callback) {
+    if (!_obj) throw std::runtime_error("BluetoothScanner is not initialized");
+    _obj.call_void_method(_method_startScan, callback.get());
+}
+
+void BluetoothScanner::stopScan(Bridge::ScanCallback& callback) {
+    if (!_obj) throw std::runtime_error("BluetoothScanner is not initialized");
+    _obj.call_void_method(_method_stopScan, callback.get());
+}
+
+std::string BluetoothScanner::toString() {
+    if (!_obj) throw std::runtime_error("BluetoothScanner is not initialized");
+    return _obj.call_string_method(_method_toString);
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/le/BluetoothScanner.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "bridge/ScanCallback.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+class BluetoothScanner {
+  public:
+    BluetoothScanner(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    void startScan(Bridge::ScanCallback& callback);
+    void stopScan(Bridge::ScanCallback& callback);
+
+    std::string toString();
+
+    jobject get() const { return _obj.get(); }  // TODO: Remove once nothing uses this
+
+  private:
+    // Underlying JNI object - Use SimpleJNI::Object with GlobalRef
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _constructor;
+    static jmethodID _method_startScan;
+    static jmethodID _method_stopScan;
+    static jmethodID _method_toString;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<BluetoothScanner> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/le/ScanRecord.cpp

@@ -0,0 +1,69 @@
+#include "ScanRecord.h"
+#include "types/android/os/ParcelUUID.h"
+#include "types/android/util/SparseArray.h"
+#include "types/java/util/List.h"
+#include "types/java/util/Iterator.h"
+namespace SimpleBLE {
+namespace Android {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> ScanRecord::_cls;
+jmethodID ScanRecord::_method_getServiceUuids = nullptr;
+jmethodID ScanRecord::_method_getManufacturerData = nullptr;
+jmethodID ScanRecord::_method_toString = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor ScanRecord::descriptor{
+    "android/bluetooth/le/ScanRecord", // Java class name
+    &_cls,                             // Where to store the jclass
+    {                                  // Methods to preload
+     {"getServiceUuids", "()Ljava/util/List;", &_method_getServiceUuids},
+     {"getManufacturerSpecificData", "()Landroid/util/SparseArray;", &_method_getManufacturerData},
+     {"toString", "()Ljava/lang/String;", &_method_toString}
+    }};
+
+const SimpleJNI::AutoRegister<ScanRecord> ScanRecord::registrar{&descriptor};
+
+ScanRecord::ScanRecord(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+std::vector<std::string> ScanRecord::getServiceUuids() {
+    if (!_obj) throw std::runtime_error("ScanRecord object is not initialized");
+
+    SimpleJNI::Object<SimpleJNI::LocalRef, jobject> service_uuids_obj = _obj.call_object_method(_method_getServiceUuids);
+    if (!service_uuids_obj) return {};
+
+    std::vector<std::string> result;
+    List list(service_uuids_obj.to_global());
+    Iterator iterator = list.iterator();
+    while (iterator.hasNext()) {
+        ParcelUUID parcel_uuid = ParcelUUID(iterator.next());
+        result.push_back(parcel_uuid.getUuid().toString());
+    }
+
+    return result;
+}
+
+std::map<uint16_t, kvn::bytearray> ScanRecord::getManufacturerData() {
+    if (!_obj) throw std::runtime_error("ScanRecord object is not initialized");
+
+    SimpleJNI::Object<SimpleJNI::LocalRef, jobject> manufacturer_data_obj = _obj.call_object_method(_method_getManufacturerData);
+    if (!manufacturer_data_obj) return {};
+
+    SparseArray<SimpleJNI::ByteArray<SimpleJNI::LocalRef>> sparse_array(manufacturer_data_obj);
+
+    std::map<uint16_t, kvn::bytearray> result;
+    for (int i = 0; i < sparse_array.size(); i++) {
+        uint16_t key = sparse_array.keyAt(i);
+        SimpleJNI::ByteArray<SimpleJNI::LocalRef> value = sparse_array.valueAt(i);
+        result[key] = value.bytes();
+    }
+    return result;
+}
+
+std::string ScanRecord::toString() {
+    if (!_obj) throw std::runtime_error("ScanRecord object is not initialized");
+    return _obj.call_string_method(_method_toString);
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/le/ScanRecord.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+#include "types/java/util/UUID.h"
+#include <map>
+#include <vector>
+#include "kvn/kvn_bytearray.h"
+#include "types/android/os/ParcelUUID.h"
+#include "types/android/util/SparseArray.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+class ScanRecord {
+  public:
+    ScanRecord(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    std::vector<std::string> getServiceUuids();
+    std::map<uint16_t, kvn::bytearray> getManufacturerData();
+
+    std::string toString();
+
+  private:
+    // Underlying JNI object
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_getServiceUuids;
+    static jmethodID _method_getManufacturerData;
+    static jmethodID _method_toString;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<ScanRecord> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/le/ScanResult.cpp

@@ -0,0 +1,63 @@
+#include "ScanResult.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> ScanResult::_cls;
+jmethodID ScanResult::_method_getDevice = nullptr;
+jmethodID ScanResult::_method_getRssi = nullptr;
+jmethodID ScanResult::_method_getTxPower = nullptr;
+jmethodID ScanResult::_method_isConnectable = nullptr;
+jmethodID ScanResult::_method_getScanRecord = nullptr;
+jmethodID ScanResult::_method_toString = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor ScanResult::descriptor{
+    "android/bluetooth/le/ScanResult", // Java class name
+    &_cls,                             // Where to store the jclass
+    {                                  // Methods to preload
+     {"getDevice", "()Landroid/bluetooth/BluetoothDevice;", &_method_getDevice},
+     {"getRssi", "()I", &_method_getRssi},
+     {"getTxPower", "()I", &_method_getTxPower},
+     {"isConnectable", "()Z", &_method_isConnectable},
+     {"getScanRecord", "()Landroid/bluetooth/le/ScanRecord;", &_method_getScanRecord},
+     {"toString", "()Ljava/lang/String;", &_method_toString}
+    }};
+
+const SimpleJNI::AutoRegister<ScanResult> ScanResult::registrar{&descriptor};
+
+ScanResult::ScanResult(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+BluetoothDevice ScanResult::getDevice() {
+    if (!_obj) throw std::runtime_error("ScanResult object is not initialized");
+    return BluetoothDevice(_obj.call_object_method(_method_getDevice));
+}
+
+int16_t ScanResult::getRssi() {
+    if (!_obj) throw std::runtime_error("ScanResult object is not initialized");
+    return _obj.call_int_method(_method_getRssi);
+}
+
+int16_t ScanResult::getTxPower() {
+    if (!_obj) throw std::runtime_error("ScanResult object is not initialized");
+    return _obj.call_int_method(_method_getTxPower);
+}
+
+bool ScanResult::isConnectable() {
+    if (!_obj) throw std::runtime_error("ScanResult object is not initialized");
+    return _obj.call_boolean_method(_method_isConnectable);
+}
+
+ScanRecord ScanResult::getScanRecord() {
+    if (!_obj) throw std::runtime_error("ScanResult object is not initialized");
+    return ScanRecord(_obj.call_object_method(_method_getScanRecord));
+}
+
+std::string ScanResult::toString() {
+    if (!_obj) throw std::runtime_error("ScanResult object is not initialized");
+    return _obj.call_string_method(_method_toString);
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/bluetooth/le/ScanResult.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+#include "types/android/bluetooth/BluetoothDevice.h"
+#include "types/android/bluetooth/le/ScanRecord.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+class ScanResult {
+  public:
+    ScanResult(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    BluetoothDevice getDevice();
+    int16_t getRssi();
+    int16_t getTxPower();
+    bool isConnectable();
+    ScanRecord getScanRecord();
+    std::string toString();
+
+  private:
+    // Underlying JNI object
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_getDevice;
+    static jmethodID _method_getRssi;
+    static jmethodID _method_getTxPower;
+    static jmethodID _method_isConnectable;
+    static jmethodID _method_getScanRecord;
+    static jmethodID _method_toString;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<ScanResult> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/os/ParcelUUID.cpp

@@ -0,0 +1,32 @@
+#include "ParcelUUID.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+// Static members definition
+SimpleJNI::GlobalRef<jclass> ParcelUUID::_cls;
+jmethodID ParcelUUID::_method_getUuid = nullptr;
+
+// JNI Descriptor for ParcelUUID
+const SimpleJNI::JNIDescriptor ParcelUUID::descriptor{
+    "android/os/ParcelUuid",                             // Java class name
+    &_cls,                                               // Pointer to store the jclass
+    {                                                    // Methods to preload
+     {"getUuid", "()Ljava/util/UUID;", &_method_getUuid}
+    }};
+
+// Auto-register the class with SimpleJNI
+const SimpleJNI::AutoRegister<ParcelUUID> ParcelUUID::registrar{&descriptor};
+
+ParcelUUID::ParcelUUID() : _obj() {}
+
+ParcelUUID::ParcelUUID(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+UUID ParcelUUID::getUuid() {
+    if (!_obj) throw std::runtime_error("ParcelUUID is not initialized");
+    SimpleJNI::Object<SimpleJNI::LocalRef, jobject> java_uuid_obj = _obj.call_object_method(_method_getUuid);
+    return UUID(java_uuid_obj);
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE