simpleble 0.0.1

data/vendor/simpleble/simpledbus/include/simpledbus/advanced/Interface.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <simpledbus/base/Connection.h>
+
+#include <atomic>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace SimpleDBus {
+
+class Interface {
+  public:
+    Interface(std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path,
+              const std::string& interface_name);
+
+    virtual ~Interface() = default;
+
+    // ----- LIFE CYCLE -----
+    void load(Holder options);
+    void unload();
+    bool is_loaded() const;
+
+    // ----- METHODS -----
+    Message create_method_call(const std::string& method_name);
+
+    // ----- PROPERTIES -----
+    virtual void property_changed(std::string option_name);
+
+    // ! These functions are used by the Properties interface. We need better nomenclature!
+    Holder property_collect();
+    Holder property_collect_single(const std::string& property_name);
+    void property_modify(const std::string& property_name, const Holder& value);
+
+    // ! TODO: We need to figure out a good architecture to let any generic interface access the Properties object of its Proxy.
+    Holder property_get_all();
+    Holder property_get(const std::string& property_name);
+    void property_set(const std::string& property_name, const Holder& value);
+    void property_refresh(const std::string& property_name);
+
+    // ----- SIGNALS -----
+    void signal_property_changed(Holder changed_properties, Holder invalidated_properties);
+
+    // ----- MESSAGES -----
+    virtual void message_handle(Message& msg);
+
+  protected:
+    std::atomic_bool _loaded{true};
+
+    std::string _path;
+    std::string _bus_name;
+    std::string _interface_name;
+    std::shared_ptr<Connection> _conn;
+
+    std::recursive_mutex _property_update_mutex;
+    std::map<std::string, bool> _property_valid_map;
+
+    /**
+     * @brief Dictionary containing all properties.
+     *
+     * @note: When accessing this object, the _property_update_mutex must be locked.
+     */
+    std::map<std::string, Holder> _properties;
+};
+
+}  // namespace SimpleDBus

data/vendor/simpleble/simpledbus/include/simpledbus/advanced/InterfaceRegistry.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <typeindex>
+
+#include <simpledbus/base/Connection.h>
+#include <simpledbus/base/Holder.h>
+#include <simpledbus/base/Logging.h>
+
+namespace SimpleDBus {
+
+class Interface;
+
+using CreatorFunction = std::shared_ptr<Interface> (*)(std::shared_ptr<Connection>, const std::string&,
+                                                       const std::string&, const Holder&);
+
+class InterfaceRegistry {
+  public:
+    static InterfaceRegistry& getInstance() {
+        static InterfaceRegistry instance;
+        return instance;
+    }
+
+    template <typename T>
+    void registerClass(const std::string& key, CreatorFunction creator) {
+        static_assert(std::is_base_of<Interface, T>::value, "T must inherit from Interface");
+        creators[key] = creator;
+    }
+
+    bool isRegistered(const std::string& key) const {
+        return creators.find(key) != creators.end();
+    }
+
+    // NOTES; We need a method inside Interfaces that will automatically retrieve the Interface name for the class.
+    std::shared_ptr<Interface> create(const std::string& key, std::shared_ptr<Connection> conn,
+                                      const std::string& bus_name, const std::string& path,
+                                      const Holder& options) const {
+        auto it = creators.find(key);
+        if (it != creators.end()) {
+            auto iface = it->second(conn, bus_name, path, options);
+            iface->load(options);
+            return iface;
+        }
+        return nullptr;
+    }
+
+  private:
+    std::unordered_map<std::string, CreatorFunction> creators;
+    InterfaceRegistry() = default;
+};
+
+template <typename T>
+struct AutoRegisterInterface {
+    AutoRegisterInterface(const std::string& key, CreatorFunction creator) {
+        static_assert(std::is_base_of<Interface, T>::value, "T must inherit from Interface");
+        InterfaceRegistry::getInstance().registerClass<T>(key, creator);
+        LOG_DEBUG("Registered class with key {}", key);
+    }
+};
+
+}  // namespace SimpleDBus

data/vendor/simpleble/simpledbus/include/simpledbus/advanced/Proxy.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <simpledbus/base/Connection.h>
+
+#include <simpledbus/advanced/Interface.h>
+#include <kvn/kvn_safe_callback.hpp>
+#include <simpledbus/base/Path.h>
+
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace SimpleDBus {
+
+class Interface;
+
+class Proxy {
+  public:
+    Proxy(std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~Proxy();
+
+    bool valid() const;
+    void invalidate();
+    std::string path() const;
+    std::string bus_name() const;
+
+    bool path_exists(const std::string& path);
+    std::shared_ptr<Proxy> path_get(const std::string& path);
+
+    bool interface_exists(const std::string& name);
+    std::shared_ptr<Interface> interface_get(const std::string& name);
+
+    const std::map<std::string, std::shared_ptr<Proxy>>& children();
+    const std::map<std::string, std::shared_ptr<Interface>>& interfaces();
+
+    virtual std::shared_ptr<Proxy> path_create(const std::string& path);
+
+    // ----- PATH HANDLING -----
+    void register_object_path();
+    void unregister_object_path();
+
+    // ----- INTROSPECTION -----
+    // ! TODO: This should be moved to the Introspectable interface.
+    std::string introspect();
+
+    // ----- INTERFACE HANDLING -----
+    // // ! We are making the assumption that the Properties interface is always available.
+    // std::shared_ptr<Properties> properties() {
+    //     return std::dynamic_pointer_cast<Properties>(interface_get("org.freedesktop.DBus.Properties"));
+    // }
+
+    size_t interfaces_count();
+    bool interfaces_loaded();
+    void interfaces_load(Holder managed_interfaces);
+    void interfaces_reload(Holder managed_interfaces);
+    void interfaces_unload(Holder removed_interfaces);
+
+    // ----- CHILD HANDLING -----
+    void path_add(const std::string& path, Holder managed_interfaces);
+    bool path_remove(const std::string& path, Holder removed_interfaces);
+    bool path_prune();
+    Holder path_collect();
+
+    // ----- MANUAL CHILD HANDLING -----
+    // ! This function is used to manually add children to the proxy.
+    void path_append_child(const std::string& path, std::shared_ptr<Proxy> child);
+    void path_remove_child(const std::string& path);
+    // ----- MESSAGE HANDLING -----
+    void message_forward(Message& msg);
+    void message_handle(Message& msg);
+
+    // ----- CALLBACKS -----
+    kvn::safe_callback<void(std::string)> on_child_created;
+    kvn::safe_callback<void()> on_signal_received;
+
+    // ----- TEMPLATE METHODS -----
+    // ! This method returns a Proxy descendant object.
+    template <typename T>
+    std::vector<std::shared_ptr<T>> children_casted() {
+        std::vector<std::shared_ptr<T>> result;
+        std::scoped_lock lock(_child_access_mutex);
+        for (auto& [path, child] : _children) {
+            result.push_back(std::dynamic_pointer_cast<T>(child));
+        }
+        return result;
+    }
+
+    // ! This method returns a Proxy descendant object.
+    template <typename T>
+    std::vector<std::shared_ptr<T>> children_casted_with_prefix(const std::string& prefix) {
+        std::vector<std::shared_ptr<T>> result;
+        std::scoped_lock lock(_child_access_mutex);
+        for (auto& [path, child] : _children) {
+            const std::string next_child = SimpleDBus::Path::next_child_strip(_path, path);
+            if (next_child.find(prefix) == 0) {
+                result.push_back(std::dynamic_pointer_cast<T>(child));
+            }
+        }
+        return result;
+    }
+
+  protected:
+    bool _valid;
+    bool _registered;
+    std::string _path;
+    std::string _bus_name;
+
+    std::shared_ptr<Connection> _conn;
+
+    std::map<std::string, std::shared_ptr<Interface>> _interfaces;
+    std::map<std::string, std::shared_ptr<Proxy>> _children;
+
+    std::recursive_mutex _interface_access_mutex;
+    std::recursive_mutex _child_access_mutex;
+};
+
+}  // namespace SimpleDBus

data/vendor/simpleble/simpledbus/include/simpledbus/base/Connection.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <dbus/dbus.h>
+#include <mutex>
+#include <unordered_map>
+#include <functional>
+#include "Message.h"
+
+namespace SimpleDBus {
+
+class Message;
+
+class Connection {
+  public:
+    Connection(::DBusBusType dbus_bus_type);
+    ~Connection();
+
+    void init();
+    void uninit();
+    bool is_initialized();
+
+    void add_match(std::string rule);
+    void remove_match(std::string rule);
+
+    void read_write();
+    void read_write_dispatch();
+    Message pop_message();
+
+    void send(Message& msg);
+    Message send_with_reply_and_block(Message& msg);
+
+    bool register_object_path(const std::string& path, std::function<void(Message&)> handler);
+    bool unregister_object_path(const std::string& path);
+
+    // ----- PROPERTIES -----
+    std::string unique_name();
+
+  private:
+    bool _initialized = false;
+
+    ::DBusBusType _dbus_bus_type;
+    ::DBusConnection* _conn;
+
+    std::recursive_mutex _mutex;
+
+    static DBusHandlerResult static_message_handler(DBusConnection* connection, DBusMessage* message, void* user_data);
+    std::unordered_map<std::string, std::function<void(Message&)>> _message_handlers;
+};
+
+}  // namespace SimpleDBus

data/vendor/simpleble/simpledbus/include/simpledbus/base/Exceptions.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+namespace SimpleDBus {
+
+namespace Exception {
+
+class BaseException : public std::exception {};
+
+class NotInitialized : public BaseException {
+  public:
+    NotInitialized();
+    const char* what() const noexcept override;
+};
+
+class DBusException : public BaseException {
+  public:
+    DBusException(const std::string& err_name, const std::string& err_message);
+    const char* what() const noexcept override;
+
+  private:
+    std::string _message;
+};
+
+class SendFailed : public BaseException {
+  public:
+    SendFailed(const std::string& err_name, const std::string& err_message, const std::string& msg_str);
+    const char* what() const noexcept override;
+
+  private:
+    std::string _message;
+};
+
+class InterfaceNotFoundException : public BaseException {
+  public:
+    InterfaceNotFoundException(const std::string& path, const std::string& interface);
+    const char* what() const noexcept override;
+
+  private:
+    std::string _message;
+};
+
+class PathNotFoundException : public BaseException {
+  public:
+    PathNotFoundException(const std::string& path, const std::string& subpath);
+    const char* what() const noexcept override;
+
+  private:
+    std::string _message;
+};
+
+}  // namespace Exception
+
+}  // namespace SimpleDBus

data/vendor/simpleble/simpledbus/include/simpledbus/base/Holder.h

@@ -0,0 +1,147 @@
+#pragma once
+
+#include <any>
+#include <optional>
+#include <cstdint>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace SimpleDBus {
+
+class ObjectPath {
+  public:
+    ObjectPath(const std::string& path) : path(path) {}
+    ObjectPath(const char* path) : path(path) {}
+    operator std::string() const { return path; }
+    bool operator<(const ObjectPath& other) const { return path < other.path; }
+
+  private:
+    std::string path;
+};
+
+class Signature {
+  public:
+    Signature(const std::string& signature) : signature(signature) {}
+    Signature(const char* signature) : signature(signature) {}
+    operator std::string() const { return signature; }
+    bool operator<(const Signature& other) const { return signature < other.signature; }
+
+  private:
+    std::string signature;
+};
+
+class Holder;
+
+class Holder {
+  public:
+    Holder();
+    ~Holder();
+
+    bool operator!=(const Holder& rhs) const;
+    bool operator==(const Holder& rhs) const;
+
+    typedef enum {
+        NONE,
+        BYTE,
+        BOOLEAN,
+        INT16,
+        UINT16,
+        INT32,
+        UINT32,
+        INT64,
+        UINT64,
+        DOUBLE,
+        STRING,
+        OBJ_PATH,
+        SIGNATURE,
+        ARRAY,
+        DICT
+    } Type;
+
+    Type type() const;
+    std::string represent() const;
+    std::string signature() const;
+    void signature_override(const std::string& signature);
+
+    // TODO: Deprecate these functions in favor of templated version.
+    static Holder create_boolean(bool value);
+    static Holder create_byte(uint8_t value);
+    static Holder create_int16(int16_t value);
+    static Holder create_uint16(uint16_t value);
+    static Holder create_int32(int32_t value);
+    static Holder create_uint32(uint32_t value);
+    static Holder create_int64(int64_t value);
+    static Holder create_uint64(uint64_t value);
+    static Holder create_double(double value);
+    static Holder create_string(const std::string& str);
+    static Holder create_object_path(const ObjectPath& path);
+    static Holder create_signature(const Signature& signature);
+    static Holder create_array();
+    static Holder create_dict();
+
+    std::any get_contents() const;
+
+    // TODO: Deprecate these functions in favor of templated version.
+    bool get_boolean() const;
+    uint8_t get_byte() const;
+    int16_t get_int16() const;
+    uint16_t get_uint16() const;
+    int32_t get_int32() const;
+    uint32_t get_uint32() const;
+    int64_t get_int64() const;
+    uint64_t get_uint64() const;
+    double get_double() const;
+    std::string get_string() const;
+    std::string get_object_path() const;
+    std::string get_signature() const;
+    std::vector<Holder> get_array() const;
+    std::map<uint8_t, Holder> get_dict_uint8() const;
+    std::map<uint16_t, Holder> get_dict_uint16() const;
+    std::map<uint32_t, Holder> get_dict_uint32() const;
+    std::map<uint64_t, Holder> get_dict_uint64() const;
+    std::map<int16_t, Holder> get_dict_int16() const;
+    std::map<int32_t, Holder> get_dict_int32() const;
+    std::map<int64_t, Holder> get_dict_int64() const;
+    std::map<std::string, Holder> get_dict_string() const;
+    std::map<std::string, Holder> get_dict_object_path() const;
+    std::map<std::string, Holder> get_dict_signature() const;
+
+    void dict_append(Type key_type, std::any key, Holder value);
+    void array_append(Holder holder);
+
+    // Template speciallizations.
+    template <typename T>
+    static Holder create();
+
+    template <typename T>
+    static Holder create(T value);
+
+    template <typename T>
+    T get() const;
+
+  private:
+    Type _type = NONE;
+    std::optional<std::string> _signature;
+
+    bool holder_boolean = false;
+    uint64_t holder_integer = 0;
+    double holder_double = 0;
+    std::string holder_string;
+    std::vector<Holder> holder_array;
+
+    // Dictionaries are stored within a vector as a tuple of <key_type, key, holder>
+    std::vector<std::tuple<Type, std::any, Holder>> holder_dict;
+
+    std::vector<std::string> _represent_container() const;
+    std::string _represent_simple() const;
+    std::string _signature_simple() const;
+
+    template <typename T>
+    std::map<T, Holder> _get_dict(Type key_type) const;
+
+    static std::string _signature_type(Type type) noexcept;
+    static std::string _represent_type(Type type, std::any value) noexcept;
+};
+
+}  // namespace SimpleDBus

data/vendor/simpleble/simpledbus/include/simpledbus/base/Logging.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <fmt/core.h>
+#include <cstdint>
+#include <string>
+
+namespace SimpleDBus {
+
+// clang-format off
+
+void log_fatal(const std::string& file, uint32_t line, const std::string& function, const std::string& message);
+void log_error(const std::string& file, uint32_t line, const std::string& function, const std::string& message);
+void log_warn(const std::string& file, uint32_t line, const std::string& function, const std::string& message);
+void log_info(const std::string& file, uint32_t line, const std::string& function, const std::string& message);
+void log_debug(const std::string& file, uint32_t line, const std::string& function, const std::string& message);
+void log_verbose(const std::string& file, uint32_t line, const std::string& function, const std::string& message);
+
+template <typename T, typename... Args>
+void log_fatal(const std::string& file, uint32_t line, const std::string& function, const T& t, const Args&... args) {
+    log_fatal(file, line, function, fmt::format(t, args...));
+}
+
+template <typename T, typename... Args>
+void log_error(const std::string& file, uint32_t line, const std::string& function, const T& t, const Args&... args) {
+    log_error(file, line, function, fmt::format(t, args...));
+}
+
+template <typename T, typename... Args>
+void log_warn(const std::string& file, uint32_t line, const std::string& function, const T& t, const Args&... args) {
+    log_warn(file, line, function, fmt::format(t, args...));
+}
+
+template <typename T, typename... Args>
+void log_info(const std::string& file, uint32_t line, const std::string& function, const T& t, const Args&... args) {
+    log_info(file, line, function, fmt::format(t, args...));
+}
+
+template <typename T, typename... Args>
+void log_debug(const std::string& file, uint32_t line, const std::string& function, const T& t, const Args&... args) {
+    log_debug(file, line, function, fmt::format(t, args...));
+}
+
+template <typename T, typename... Args>
+void log_verbose(const std::string& file, uint32_t line, const std::string& function, const T& t, const Args&... args) {
+    log_verbose(file, line, function, fmt::format(t, args...));
+}
+
+// clang-format on
+
+}  // namespace SimpleDBus
+
+#define LOG_FATAL(...) SimpleDBus::log_fatal(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_ERROR(...) SimpleDBus::log_error(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_WARN(...) SimpleDBus::log_warn(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_INFO(...) SimpleDBus::log_info(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_DEBUG(...) SimpleDBus::log_debug(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_VERBOSE(...) SimpleDBus::log_verbose(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)

data/vendor/simpleble/simpledbus/include/simpledbus/base/Message.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <dbus/dbus.h>
+#include <atomic>
+#include <string>
+#include <vector>
+#include "Holder.h"
+
+namespace SimpleDBus {
+
+class Message {
+  public:
+    enum class Type {
+        INVALID = DBUS_MESSAGE_TYPE_INVALID,
+        METHOD_CALL = DBUS_MESSAGE_TYPE_METHOD_CALL,
+        METHOD_RETURN = DBUS_MESSAGE_TYPE_METHOD_RETURN,
+        ERROR = DBUS_MESSAGE_TYPE_ERROR,
+        SIGNAL = DBUS_MESSAGE_TYPE_SIGNAL,
+    };
+
+    static constexpr int INVALID_UNIQUE_ID = -1;
+
+    Message();
+    Message(Message&& other) noexcept;
+    Message(const Message& other);
+    Message& operator=(Message&& other) noexcept;
+    Message& operator=(const Message& other);
+    ~Message();
+
+    operator DBusMessage*() const;
+
+    bool is_valid() const;
+    void append_argument(const Holder& argument, const std::string& signature);
+    Holder extract();
+    void extract_reset();
+    bool extract_has_next();
+    void extract_next();
+    std::string to_string(bool append_arguments = false) const;
+
+    uint32_t get_ref_count() const;
+    int32_t get_unique_id() const;
+    uint32_t get_serial() const;
+    std::string get_signature();
+    std::string get_interface() const;
+    std::string get_path() const;
+    std::string get_member() const;
+    Type get_type() const;
+
+    bool is_signal(const std::string& interface, const std::string& signal_name) const;
+    bool is_method_call(const std::string& interface, const std::string& method) const;
+
+    static Message from_retained(DBusMessage* msg);
+    static Message from_acquired(DBusMessage* msg);
+    static Message create_method_call(const std::string& bus_name, const std::string& path,
+                                      const std::string& interface, const std::string& method);
+    static Message create_method_return(const Message& msg);
+    static Message create_error(const Message& msg, const std::string& error_name, const std::string& error_message);
+    static Message create_signal(const std::string& path, const std::string& interface, const std::string& signal);
+
+  private:
+    static std::atomic_int32_t _creation_counter;
+
+    int _indent = 0;
+    int32_t _unique_id = INVALID_UNIQUE_ID;
+    DBusMessageIter _iter;
+    bool _iter_initialized = false;
+    bool _is_extracted = false;
+    Holder _extracted;
+    DBusMessage* _msg = nullptr;
+    std::vector<Holder> _arguments;
+
+    Holder _extract_bytearray(DBusMessageIter* iter);
+    Holder _extract_array(DBusMessageIter* iter);
+    Holder _extract_dict(DBusMessageIter* iter);
+    Holder _extract_generic(DBusMessageIter* iter);
+
+    /**
+     * @brief Append argument to the DBus message iterator.
+     * @param iter      DBus message iterator.
+     * @param argument  Argument to append.
+     * @param signature Signature of the argument.
+     */
+    void _append_argument(DBusMessageIter* iter, const Holder& argument, const std::string& signature);
+
+    void _invalidate();
+    void _safe_delete();
+};
+
+}  // namespace SimpleDBus

data/vendor/simpleble/simpledbus/include/simpledbus/base/Path.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace SimpleDBus {
+
+class Path {
+  public:
+    static size_t count_elements(const std::string& path);
+    static std::string fetch_elements(const std::string& path, size_t count);
+    static std::vector<std::string> split_elements(const std::string& path);
+
+    static bool is_descendant(const std::string& base, const std::string& path);
+    static bool is_ascendant(const std::string& base, const std::string& path);
+
+    static bool is_child(const std::string& base, const std::string& path);
+    static bool is_parent(const std::string& base, const std::string& path);
+
+    static std::string next_child(const std::string& base, const std::string& path);
+    static std::string next_child_strip(const std::string& base, const std::string& path);
+};
+
+}  // namespace SimpleDBus