simpleble 0.0.1

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "types/java/util/UUID.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace SimpleBLE {
+namespace Android {
+
+class ParcelUUID {
+  public:
+    ParcelUUID();
+    ParcelUUID(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    UUID getUuid();
+
+    jobject get() const { return _obj.get(); }  // TODO: Remove once nothing uses this
+
+  private:
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_getUuid;
+
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<ParcelUUID> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/util/SparseArray.cpp

@@ -0,0 +1,54 @@
+#include "SparseArray.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> SparseArrayBase::_cls;
+jmethodID SparseArrayBase::_method_size = nullptr;
+jmethodID SparseArrayBase::_method_keyAt = nullptr;
+jmethodID SparseArrayBase::_method_valueAt = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor SparseArrayBase::descriptor{
+    "android/util/SparseArray", // Java class name
+    &_cls,                      // Where to store the jclass
+    {                           // Methods to preload
+     {"size", "()I", &_method_size},
+     {"keyAt", "(I)I", &_method_keyAt},
+     {"valueAt", "(I)Ljava/lang/Object;", &_method_valueAt}
+    }};
+
+const SimpleJNI::AutoRegister<SparseArrayBase> SparseArrayBase::registrar{&descriptor};
+
+template <typename T>
+SparseArray<T>::SparseArray() {}
+
+template <typename T>
+SparseArray<T>::SparseArray(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+
+template <typename T>
+int SparseArray<T>::size() {
+    if (!_obj) throw std::runtime_error("SparseArray is not initialized");
+    return _obj.call_int_method(_method_size);
+}
+
+template <typename T>
+int SparseArray<T>::keyAt(int index) {
+    if (!_obj) throw std::runtime_error("SparseArray is not initialized");
+    return _obj.call_int_method(_method_keyAt, index);
+}
+
+template <typename T>
+T SparseArray<T>::valueAt(int index) {
+    if (!_obj) throw std::runtime_error("SparseArray is not initialized");
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> value = _obj.call_object_method(_method_valueAt, index);
+    return T(value.get());
+}
+
+template class SparseArray<SimpleJNI::ByteArray<SimpleJNI::LocalRef>>;
+template class SparseArray<SimpleJNI::Object<SimpleJNI::LocalRef, jobject>>;
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/android/util/SparseArray.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace SimpleBLE {
+namespace Android {
+
+class SparseArrayBase {
+  public:
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_size;
+    static jmethodID _method_keyAt;
+    static jmethodID _method_valueAt;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<SparseArrayBase> registrar;
+};
+
+template <typename T>
+class SparseArray : public SparseArrayBase {
+  public:
+    SparseArray();
+    SparseArray(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    int size();
+    int keyAt(int index);
+    T valueAt(int index);
+
+  private:
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/java/util/Iterator.cpp

@@ -0,0 +1,36 @@
+#include "Iterator.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> Iterator::_cls;
+jmethodID Iterator::_method_hasNext = nullptr;
+jmethodID Iterator::_method_next = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor Iterator::descriptor{
+    "java/util/Iterator",             // Java class name
+    &_cls,                            // Where to store the jclass
+    {                                 // Methods to preload
+     {"hasNext", "()Z", &_method_hasNext},
+     {"next", "()Ljava/lang/Object;", &_method_next}
+    }
+};
+
+const SimpleJNI::AutoRegister<Iterator> Iterator::registrar{&descriptor};
+
+Iterator::Iterator(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+bool Iterator::hasNext() {
+    if (!_obj) throw std::runtime_error("Iterator is not initialized");
+    return _obj.call_boolean_method(_method_hasNext);
+}
+
+SimpleJNI::Object<SimpleJNI::LocalRef> Iterator::next() {
+    if (!_obj) throw std::runtime_error("Iterator is not initialized");
+    return _obj.call_object_method(_method_next);
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/java/util/Iterator.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+#include <vector>
+
+namespace SimpleBLE {
+namespace Android {
+
+class Iterator {
+  public:
+    Iterator(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    bool hasNext();
+    SimpleJNI::Object<SimpleJNI::LocalRef> next();
+
+  private:
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_hasNext;
+    static jmethodID _method_next;
+
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<Iterator> registrar;
+
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+};
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/java/util/List.cpp

@@ -0,0 +1,29 @@
+#include "List.h"
+#include "Iterator.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+SimpleJNI::GlobalRef<jclass> List::_cls;
+jmethodID List::_method_iterator = nullptr;
+
+const SimpleJNI::JNIDescriptor List::descriptor{
+    "java/util/List", // Java class name
+    &_cls,            // Where to store the jclass
+    {                 // Methods to preload
+     {"iterator", "()Ljava/util/Iterator;", &_method_iterator}
+    }
+};
+
+const SimpleJNI::AutoRegister<List> List::registrar{&descriptor};
+
+List::List(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+Iterator List::iterator() {
+    if (!_obj) throw std::runtime_error("List is not initialized");
+    SimpleJNI::Object<SimpleJNI::LocalRef> iterator_obj = _obj.call_object_method(_method_iterator);
+    return Iterator(iterator_obj.to_global());
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/java/util/List.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+#include "Iterator.h"
+#include <vector>
+
+namespace SimpleBLE {
+namespace Android {
+
+class List {
+  public:
+    List(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    Iterator iterator();
+
+  private:
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_iterator;
+
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<List> registrar;
+
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+};
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/java/util/Set.cpp

@@ -0,0 +1,33 @@
+#include "Set.h"
+#include "Iterator.h" // Ensure Iterator.h is correctly included
+
+namespace SimpleBLE {
+namespace Android { // Changed namespace
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> Set::_cls;
+jmethodID Set::_method_iterator = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor Set::descriptor{
+    "java/util/Set",              // Java class name
+    &_cls,                        // Where to store the jclass
+    {                             // Methods to preload
+     {"iterator", "()Ljava/util/Iterator;", &_method_iterator}
+    }
+};
+
+const SimpleJNI::AutoRegister<Set> Set::registrar{&descriptor};
+
+Set::Set(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+Iterator Set::iterator() {
+    if (!_obj) throw std::runtime_error("Set is not initialized");
+    SimpleJNI::Object<SimpleJNI::LocalRef> iterator_obj = _obj.call_object_method(_method_iterator);
+    // Assuming Iterator's constructor now accepts SimpleJNI::Object<SimpleJNI::LocalRef>
+    // or SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> as per previous refactoring.
+    return Iterator(iterator_obj.to_global()); // Convert to GlobalRef if Iterator stores it as such
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/java/util/Set.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+#include "Iterator.h"
+#include <vector>
+
+namespace SimpleBLE {
+namespace Android {
+class Set {
+  public:
+    Set(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    Iterator iterator();
+
+  private:
+    // Static JNI resources managed by Registrar
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_iterator;
+
+    // JNI descriptor for auto-registration
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<Set> registrar;
+
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+};
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/java/util/UUID.cpp

@@ -0,0 +1,26 @@
+#include "UUID.h"
+
+namespace SimpleBLE {
+namespace Android {
+
+SimpleJNI::GlobalRef<jclass> UUID::_cls;
+jmethodID UUID::_method_toString = nullptr;
+
+const SimpleJNI::JNIDescriptor UUID::descriptor{"java/util/UUID",  // Java class name
+                                                &_cls,             // Pointer to store the jclass
+                                                {                  // Methods to preload
+                                                 {"toString", "()Ljava/lang/String;", &_method_toString}}};
+
+const SimpleJNI::AutoRegister<UUID> UUID::registrar{&descriptor};
+
+UUID::UUID() : _obj() {}
+
+UUID::UUID(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj) : _obj(obj) {}
+
+std::string UUID::toString() {
+    if (!_obj) throw std::runtime_error("UUID is not initialized");
+    return _obj.call_string_method(_method_toString);
+}
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/types/java/util/UUID.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace SimpleBLE {
+namespace Android {
+
+class UUID {
+  public:
+    UUID();
+    UUID(SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> obj);
+
+    std::string toString();
+
+    jobject get() const { return _obj.get(); }  // TODO: Remove once nothing uses this
+
+  private:
+    SimpleJNI::Object<SimpleJNI::GlobalRef, jobject> _obj;
+
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_toString;
+
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<UUID> registrar;
+};
+
+}  // namespace Android
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/common/AdapterBase.cpp

@@ -0,0 +1,53 @@
+#include "AdapterBase.h"
+
+namespace SimpleBLE {
+
+void AdapterBase::set_callback_on_power_on(std::function<void()> on_power_on) {
+    if (on_power_on) {
+        _callback_on_power_on.load(on_power_on);
+    } else {
+        _callback_on_power_on.unload();
+    }
+}
+
+void AdapterBase::set_callback_on_power_off(std::function<void()> on_power_off) {
+    if (on_power_off) {
+        _callback_on_power_off.load(on_power_off);
+    } else {
+        _callback_on_power_off.unload();
+    }
+}
+
+void AdapterBase::set_callback_on_scan_start(std::function<void()> on_scan_start) {
+    if (on_scan_start) {
+        _callback_on_scan_start.load(on_scan_start);
+    } else {
+        _callback_on_scan_start.unload();
+    }
+}
+
+void AdapterBase::set_callback_on_scan_stop(std::function<void()> on_scan_stop) {
+    if (on_scan_stop) {
+        _callback_on_scan_stop.load(on_scan_stop);
+    } else {
+        _callback_on_scan_stop.unload();
+    }
+}
+
+void AdapterBase::set_callback_on_scan_updated(std::function<void(Peripheral)> on_scan_updated) {
+    if (on_scan_updated) {
+        _callback_on_scan_updated.load(on_scan_updated);
+    } else {
+        _callback_on_scan_updated.unload();
+    }
+}
+
+void AdapterBase::set_callback_on_scan_found(std::function<void(Peripheral)> on_scan_found) {
+    if (on_scan_found) {
+        _callback_on_scan_found.load(on_scan_found);
+    } else {
+        _callback_on_scan_found.unload();
+    }
+}
+
+}

data/vendor/simpleble/simpleble/src/backends/common/AdapterBase.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+#include <kvn_safe_callback.hpp>
+
+namespace SimpleBLE {
+
+class Peripheral;
+class PeripheralBase;
+
+/**
+ * Abstract base class for Bluetooth adapter implementations.
+ *
+ * Each backend must implement this class.
+ *
+ * Notes for implementers:
+ *
+ * - The methods here return shared pointers to AdapterBase, PeripheralBase,
+ *   etc. The code in Adapter.cpp will automatically wrap these in Adapter,
+ *   Peripheral, etc. objects.
+ * - Do not use Adapter, Peripheral, etc. Those are for the user.
+ * - Methods that require the adapter to be enabled will not be called by the
+ *   frontend if `bluetooth_enabled()` returns false.
+ */
+class AdapterBase {
+  public:
+    virtual ~AdapterBase() = default;
+
+    virtual void* underlying() const = 0;
+
+    virtual std::string identifier() = 0;
+    virtual BluetoothAddress address() = 0;
+
+    virtual void power_on() = 0;
+    virtual void power_off() = 0;
+    virtual bool is_powered() = 0;
+    virtual void set_callback_on_power_on(std::function<void()> on_power_on);
+    virtual void set_callback_on_power_off(std::function<void()> on_power_off);
+
+    virtual void scan_start() = 0;
+    virtual void scan_stop() = 0;
+    virtual void scan_for(int timeout_ms) = 0;
+    virtual bool scan_is_active() = 0;
+    virtual std::vector<std::shared_ptr<PeripheralBase>> scan_get_results() = 0;
+
+    virtual void set_callback_on_scan_start(std::function<void()> on_scan_start);
+    virtual void set_callback_on_scan_stop(std::function<void()> on_scan_stop);
+    virtual void set_callback_on_scan_updated(std::function<void(Peripheral)> on_scan_updated);
+    virtual void set_callback_on_scan_found(std::function<void(Peripheral)> on_scan_found);
+
+    virtual std::vector<std::shared_ptr<PeripheralBase>> get_paired_peripherals() = 0;
+    virtual std::vector<std::shared_ptr<PeripheralBase>> get_connected_peripherals() { return {}; };
+
+    /**
+     * Checks if Bluetooth is enabled.
+     *
+     * The enabled state may be a global setting for the system/backend, or
+     * it may be specific to the adapter.
+     */
+    virtual bool bluetooth_enabled() = 0;
+
+  protected:
+    AdapterBase() = default;
+
+    kvn::safe_callback<void()> _callback_on_power_on;
+    kvn::safe_callback<void()> _callback_on_power_off;
+
+    kvn::safe_callback<void()> _callback_on_scan_start;
+    kvn::safe_callback<void()> _callback_on_scan_stop;
+    kvn::safe_callback<void(Peripheral)> _callback_on_scan_updated;
+    kvn::safe_callback<void(Peripheral)> _callback_on_scan_found;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/common/AdapterBaseTypes.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <simpleble/Types.h>
+#include <cstdint>
+#include <map>
+#include <string>
+
+namespace SimpleBLE {
+
+struct advertising_data_t {
+    std::string identifier;
+    BluetoothAddressType address_type;
+    BluetoothAddress mac_address;
+    bool connectable;
+    int16_t rssi;
+    int16_t tx_power;
+
+    std::map<uint16_t, ByteArray> manufacturer_data;
+    std::map<BluetoothUUID, ByteArray> service_data;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/common/BackendBase.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace SimpleBLE {
+
+class AdapterBase;
+
+class BackendBase {
+  public:
+    virtual ~BackendBase() = default;
+
+    virtual std::vector<std::shared_ptr<AdapterBase>> get_adapters() = 0;
+    virtual bool bluetooth_enabled() = 0;
+    virtual std::string name() const noexcept = 0;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/common/BackendUtils.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <memory>
+
+#include "BackendBase.h"
+
+namespace SimpleBLE {
+
+/**
+ * Convenience CRTP class to have a Backend that is a singleton.
+ *
+ * REQUIRES: T must be default-constructible.
+ */
+template <typename T>
+class BackendSingleton : public BackendBase, public std::enable_shared_from_this<T> {
+  public:
+    static std::shared_ptr<T> get() {
+        static T instance(buildToken{});
+        return std::shared_ptr<T>(&instance, [](T*) {});
+    }
+
+    BackendSingleton(const BackendSingleton& other) = delete;  // Remove the copy constructor
+    T& operator=(const T&) = delete;                           // Remove the copy assignment
+
+  protected:
+    // Derived classes should have a constructor that takes a buildToken to
+    // ensure that the class is only constructed through the get() method.
+    struct buildToken {};
+
+    BackendSingleton() = default;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/common/CharacteristicBase.cpp

@@ -0,0 +1,28 @@
+#include <simpleble/Characteristic.h>
+
+#include "CharacteristicBase.h"
+#include "CommonUtils.h"
+#include "DescriptorBase.h"
+
+using namespace SimpleBLE;
+
+CharacteristicBase::CharacteristicBase(const BluetoothUUID& uuid, SharedPtrVector<DescriptorBase> descriptors,
+                                       bool can_read, bool can_write_request, bool can_write_command, bool can_notify,
+                                       bool can_indicate)
+    : uuid_(uuid),
+      descriptors_(descriptors),
+      can_read_(can_read),
+      can_write_request_(can_write_request),
+      can_write_command_(can_write_command),
+      can_notify_(can_notify),
+      can_indicate_(can_indicate) {}
+
+BluetoothUUID CharacteristicBase::uuid() { return uuid_; }
+
+SharedPtrVector<DescriptorBase> CharacteristicBase::descriptors() { return descriptors_; }
+
+bool CharacteristicBase::can_read() { return can_read_; }
+bool CharacteristicBase::can_write_request() { return can_write_request_; }
+bool CharacteristicBase::can_write_command() { return can_write_command_; }
+bool CharacteristicBase::can_notify() { return can_notify_; }
+bool CharacteristicBase::can_indicate() { return can_indicate_; }

data/vendor/simpleble/simpleble/src/backends/common/CharacteristicBase.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+#include <memory>
+
+namespace SimpleBLE {
+
+class DescriptorBase;
+
+class CharacteristicBase {
+  public:
+    CharacteristicBase(const BluetoothUUID& uuid, std::vector<std::shared_ptr<DescriptorBase>> descriptors,
+                       bool can_read, bool can_write_request, bool can_write_command, bool can_notify,
+                       bool can_indicate);
+    virtual ~CharacteristicBase() = default;
+
+    BluetoothUUID uuid();
+    std::vector<std::shared_ptr<DescriptorBase>> descriptors();
+
+    bool can_read();
+    bool can_write_request();
+    bool can_write_command();
+    bool can_notify();
+    bool can_indicate();
+
+  protected:
+    BluetoothUUID uuid_;
+    std::vector<std::shared_ptr<DescriptorBase>> descriptors_;
+
+    bool can_read_ = false;
+    bool can_write_request_ = false;
+    bool can_write_command_ = false;
+    bool can_notify_ = false;
+    bool can_indicate_ = false;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/common/DescriptorBase.cpp

@@ -0,0 +1,7 @@
+#include "DescriptorBase.h"
+
+using namespace SimpleBLE;
+
+DescriptorBase::DescriptorBase(const BluetoothUUID& uuid) : uuid_(uuid) {}
+
+BluetoothUUID DescriptorBase::uuid() { return uuid_; }

data/vendor/simpleble/simpleble/src/backends/common/DescriptorBase.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+class DescriptorBase {
+  public:
+    DescriptorBase(const BluetoothUUID& uuid);
+    virtual ~DescriptorBase() = default;
+
+    BluetoothUUID uuid();
+
+  protected:
+    BluetoothUUID uuid_;
+};
+
+}  // namespace SimpleBLE