simplejsble 0.0.4 → 0.0.6

package/simpleble/src/backends/linux_legacy/include/simpledbuslegacy/base/Message.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <dbus/dbus.h>
+#include <atomic>
+#include <string>
+#include <vector>
+#include "Holder.h"
+
+namespace SimpleDBusLegacy {
+
+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 SimpleDBusLegacy

package/simpleble/src/backends/linux_legacy/include/simpledbuslegacy/base/Path.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace SimpleDBusLegacy {
+
+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 SimpleDBusLegacy

package/simpleble/src/backends/linux_legacy/include/simpledbuslegacy/interfaces/ObjectManager.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Interface.h>
+#include <simpledbuslegacy/advanced/InterfaceRegistry.h>
+
+#include <functional>
+
+namespace SimpleDBusLegacy {
+
+class ObjectManager : public Interface {
+  public:
+    ObjectManager(std::shared_ptr<Connection> conn, std::string bus_name, std::string path);
+    virtual ~ObjectManager() = default;
+
+    // Names are made matching the ones from the DBus specification
+    Holder GetManagedObjects(bool use_callbacks = false);
+    std::function<void(std::string path, Holder options)> InterfacesAdded;
+    std::function<void(std::string path, Holder options)> InterfacesRemoved;
+
+    void message_handle(Message& msg) override;
+
+  private:
+    static const SimpleDBusLegacy::AutoRegisterInterface<ObjectManager> registry;
+};
+
+}  // namespace SimpleDBusLegacy

package/simpleble/src/backends/linux_legacy/src/Adapter.cpp

@@ -0,0 +1,78 @@
+#include <simplebluezlegacy/Adapter.h>
+#include <simplebluezlegacy/Device.h>
+
+#include <simplebluezlegacy/interfaces/Adapter1.h>
+
+using namespace SimpleBluezLegacy;
+
+Adapter::Adapter(std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+Adapter::~Adapter() {}
+
+std::shared_ptr<SimpleDBusLegacy::Proxy> Adapter::path_create(const std::string& path) {
+    auto child = std::make_shared<Device>(_conn, _bus_name, path);
+    child->on_signal_received.load([this, child]() { _on_device_updated(child); });
+    return std::static_pointer_cast<SimpleDBusLegacy::Proxy>(child);
+}
+
+std::shared_ptr<Adapter1> Adapter::adapter1() {
+    return std::dynamic_pointer_cast<Adapter1>(interface_get("org.bluez.Adapter1"));
+}
+
+std::string Adapter::identifier() const {
+    std::size_t start = _path.find_last_of("/");
+    return _path.substr(start + 1);
+}
+
+std::string Adapter::address() { return adapter1()->Address(); }
+
+bool Adapter::discovering() { return adapter1()->Discovering(); }
+
+bool Adapter::powered() { return adapter1()->Powered(); }
+
+void Adapter::discovery_filter(const DiscoveryFilter& filter) { adapter1()->SetDiscoveryFilter(filter); }
+
+void Adapter::discovery_start() { adapter1()->StartDiscovery(); }
+
+void Adapter::discovery_stop() { adapter1()->StopDiscovery(); }
+
+std::shared_ptr<Device> Adapter::device_get(const std::string& path) {
+    return std::dynamic_pointer_cast<Device>(path_get(path));
+}
+
+void Adapter::device_remove(const std::string& path) { adapter1()->RemoveDevice(path); }
+
+void Adapter::device_remove(const std::shared_ptr<Device>& device) { adapter1()->RemoveDevice(device->path()); }
+
+std::vector<std::shared_ptr<Device>> Adapter::device_paired_get() {
+    // Traverse all child paths and return only those that are paired.
+    std::vector<std::shared_ptr<Device>> paired_devices;
+
+    for (auto& [path, child] : _children) {
+        if (!child->valid()) continue;
+
+        std::shared_ptr<Device> device = std::dynamic_pointer_cast<Device>(child);
+        if (device->paired()) {
+            paired_devices.push_back(device);
+        }
+    }
+
+    return paired_devices;
+}
+
+void Adapter::set_on_device_updated(std::function<void(std::shared_ptr<Device> device)> callback) {
+    _on_device_updated.load(callback);
+
+    on_child_created.load([this, callback](std::string child_path) {
+        auto device = device_get(child_path);
+        if (device) {
+            _on_device_updated(device);
+        }
+    });
+}
+
+void Adapter::clear_on_device_updated() {
+    _on_device_updated.unload();
+    on_child_created.unload();
+}

package/simpleble/src/backends/linux_legacy/src/Agent.cpp

@@ -0,0 +1,72 @@
+#include <simplebluezlegacy/Agent.h>
+
+#include <iostream>
+
+using namespace SimpleBluezLegacy;
+
+Agent::Agent(std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path)
+    : Proxy(conn, bus_name, path) {
+    _interfaces.emplace(std::make_pair(
+        "org.bluez.Agent1", std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<Agent1>(_conn, _path))));
+}
+
+std::string Agent::capabilities() const {
+    switch (_capabilities) {
+        case DisplayOnly:
+            return "DisplayOnly";
+        case DisplayYesNo:
+            return "DisplayYesNo";
+        case KeyboardOnly:
+            return "KeyboardOnly";
+        case NoInputNoOutput:
+            return "NoInputNoOutput";
+        case KeyboardDisplay:
+            return "KeyboardDisplay";
+        default:
+            return "";
+    }
+}
+
+void Agent::set_capabilities(Agent::Capabilities capabilities) { _capabilities = capabilities; }
+
+void Agent::set_on_request_pin_code(std::function<std::string()> callback) {
+    agent1()->OnRequestPinCode.load(callback);
+}
+
+void Agent::clear_on_request_pin_code() { agent1()->OnRequestPinCode.unload(); }
+
+void Agent::set_on_display_pin_code(std::function<bool(const std::string&)> callback) {
+    agent1()->OnDisplayPinCode.load(callback);
+}
+
+void Agent::clear_on_display_pin_code() { agent1()->OnDisplayPinCode.unload(); }
+
+void Agent::set_on_request_passkey(std::function<uint32_t()> callback) { agent1()->OnRequestPasskey.load(callback); }
+
+void Agent::clear_on_request_passkey() { agent1()->OnRequestPasskey.unload(); }
+
+void Agent::set_on_display_passkey(std::function<void(uint32_t, uint16_t)> callback) {
+    agent1()->OnDisplayPasskey.load(callback);
+}
+
+void Agent::clear_on_display_passkey() { agent1()->OnDisplayPasskey.unload(); }
+
+void Agent::set_on_request_confirmation(std::function<bool(uint32_t)> callback) {
+    agent1()->OnRequestConfirmation.load(callback);
+}
+
+void Agent::clear_on_request_confirmation() { agent1()->OnRequestConfirmation.unload(); }
+
+void Agent::set_on_request_authorization(std::function<bool()> callback) {
+    agent1()->OnRequestAuthorization.load(callback);
+}
+
+void Agent::clear_on_request_authorization() { agent1()->OnRequestAuthorization.unload(); }
+
+void Agent::set_on_authorize_service(std::function<bool(const std::string&)> callback) {
+    agent1()->OnAuthorizeService.load(callback);
+}
+
+void Agent::clear_on_authorize_service() { agent1()->OnAuthorizeService.unload(); }
+
+std::shared_ptr<Agent1> Agent::agent1() { return std::dynamic_pointer_cast<Agent1>(interface_get("org.bluez.Agent1")); }

package/simpleble/src/backends/linux_legacy/src/Bluez.cpp

@@ -0,0 +1,45 @@
+#include <simplebluezlegacy/Bluez.h>
+#include <simpledbuslegacy/interfaces/ObjectManager.h>
+
+using namespace SimpleBluezLegacy;
+
+#ifdef SIMPLEBLUEZ_USE_SESSION_DBUS
+#define DBUS_BUS DBUS_BUS_SESSION
+#else
+#define DBUS_BUS DBUS_BUS_SYSTEM
+#endif
+
+Bluez::Bluez() : _conn(std::make_shared<SimpleDBusLegacy::Connection>(DBUS_BUS)) {}
+
+Bluez::~Bluez() {
+    if (_conn->is_initialized()) {
+        _conn->remove_match("type='signal',sender='org.bluez'");
+    }
+}
+
+void Bluez::init() {
+    _conn->init();
+    _conn->add_match("type='signal',sender='org.bluez'");
+
+    _bluez_root = std::make_shared<BluezRoot>(_conn, "org.bluez", "/");
+    _bluez_root->load_managed_objects();
+}
+
+void Bluez::run_async() {
+    // TODO: UNCOMMENT THIS WHEN MIGRATING TO NEW PROXY FORWARDING LOGIC
+    //_conn->read_write_dispatch();
+
+    // BELOW IS THE LEGACY LOGIC
+    _conn->read_write();
+    SimpleDBusLegacy::Message message = _conn->pop_message();
+    while (message.is_valid()) {
+        _bluez_root->message_forward(message);
+        message = _conn->pop_message();
+    }
+}
+
+std::vector<std::shared_ptr<Adapter>> Bluez::get_adapters() { return _bluez_root->get_adapters(); }
+
+std::shared_ptr<Agent> Bluez::get_agent() { return _bluez_root->get_agent(); }
+
+void Bluez::register_agent() { _bluez_root->register_agent(); }

package/simpleble/src/backends/linux_legacy/src/BluezOrg.cpp

@@ -0,0 +1,20 @@
+#include <simplebluezlegacy/BluezOrg.h>
+#include <simplebluezlegacy/BluezOrgBluez.h>
+
+using namespace SimpleBluezLegacy;
+
+BluezOrg::BluezOrg(std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+std::vector<std::shared_ptr<Adapter>> BluezOrg::get_adapters() {
+    return std::dynamic_pointer_cast<BluezOrgBluez>(path_get("/org/bluez"))->get_adapters();
+}
+
+void BluezOrg::register_agent(std::shared_ptr<Agent> agent) {
+    std::dynamic_pointer_cast<BluezOrgBluez>(path_get("/org/bluez"))->register_agent(agent);
+}
+
+std::shared_ptr<SimpleDBusLegacy::Proxy> BluezOrg::path_create(const std::string& path) {
+    auto child = std::make_shared<BluezOrgBluez>(_conn, _bus_name, path);
+    return std::static_pointer_cast<SimpleDBusLegacy::Proxy>(child);
+}

package/simpleble/src/backends/linux_legacy/src/BluezOrgBluez.cpp

@@ -0,0 +1,23 @@
+#include <simplebluezlegacy/Adapter.h>
+#include <simplebluezlegacy/BluezOrgBluez.h>
+
+using namespace SimpleBluezLegacy;
+
+BluezOrgBluez::BluezOrgBluez(std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name,
+                             const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+std::shared_ptr<SimpleDBusLegacy::Proxy> BluezOrgBluez::path_create(const std::string& path) {
+    auto child = std::make_shared<Adapter>(_conn, _bus_name, path);
+    return std::static_pointer_cast<SimpleDBusLegacy::Proxy>(child);
+}
+
+std::shared_ptr<AgentManager1> BluezOrgBluez::agentmanager1() {
+    return std::dynamic_pointer_cast<AgentManager1>(interface_get("org.bluez.AgentManager1"));
+}
+
+void BluezOrgBluez::register_agent(std::shared_ptr<Agent> agent) {
+    agentmanager1()->RegisterAgent(agent->path(), agent->capabilities());
+}
+
+std::vector<std::shared_ptr<Adapter>> BluezOrgBluez::get_adapters() { return children_casted<Adapter>(); }

package/simpleble/src/backends/linux_legacy/src/BluezRoot.cpp

@@ -0,0 +1,44 @@
+#include <simplebluezlegacy/BluezRoot.h>
+#include <simplebluezlegacy/BluezOrg.h>
+#include <simpledbuslegacy/interfaces/ObjectManager.h>
+
+using namespace SimpleBluezLegacy;
+
+BluezRoot::BluezRoot(std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path)
+    : Proxy(conn, bus_name, path) {
+
+    _interfaces.emplace(std::make_pair("org.freedesktop.DBus.ObjectManager", std::make_shared<SimpleDBusLegacy::ObjectManager>(conn, _bus_name, _path)));
+
+    object_manager()->InterfacesAdded = [&](std::string path, SimpleDBusLegacy::Holder options) { path_add(path, options); };
+    object_manager()->InterfacesRemoved = [&](std::string path, SimpleDBusLegacy::Holder options) {
+        path_remove(path, options);
+    };
+
+    // Create the agent that will handle pairing.
+    _agent = std::make_shared<Agent>(_conn, "org.bluez", "/agent");
+    path_append_child("/agent", std::static_pointer_cast<SimpleDBusLegacy::Proxy>(_agent));
+}
+
+void BluezRoot::load_managed_objects() {
+    SimpleDBusLegacy::Holder managed_objects = object_manager()->GetManagedObjects();
+    for (auto& [path, managed_interfaces] : managed_objects.get_dict_object_path()) {
+        path_add(path, managed_interfaces);
+    }
+}
+
+std::vector<std::shared_ptr<Adapter>> BluezRoot::get_adapters() {
+    return std::dynamic_pointer_cast<BluezOrg>(path_get("/org"))->get_adapters();
+}
+
+std::shared_ptr<Agent> BluezRoot::get_agent() { return std::dynamic_pointer_cast<Agent>(path_get("/agent")); }
+
+void BluezRoot::register_agent() { std::dynamic_pointer_cast<BluezOrg>(path_get("/org"))->register_agent(_agent); }
+
+std::shared_ptr<SimpleDBusLegacy::Proxy> BluezRoot::path_create(const std::string& path) {
+    auto child = std::make_shared<BluezOrg>(_conn, _bus_name, path);
+    return std::static_pointer_cast<SimpleDBusLegacy::Proxy>(child);
+}
+
+std::shared_ptr<SimpleDBusLegacy::ObjectManager> BluezRoot::object_manager() {
+    return std::dynamic_pointer_cast<SimpleDBusLegacy::ObjectManager>(interface_get("org.freedesktop.DBus.ObjectManager"));
+}

package/simpleble/src/backends/linux_legacy/src/Characteristic.cpp

@@ -0,0 +1,64 @@
+#include <simplebluezlegacy/Characteristic.h>
+#include <simplebluezlegacy/Descriptor.h>
+#include <simplebluezlegacy/Exceptions.h>
+
+using namespace SimpleBluezLegacy;
+
+Characteristic::Characteristic(std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name,
+                               const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+Characteristic::~Characteristic() {}
+
+std::shared_ptr<SimpleDBusLegacy::Proxy> Characteristic::path_create(const std::string& path) {
+    auto child = std::make_shared<Descriptor>(_conn, _bus_name, path);
+    return std::static_pointer_cast<SimpleDBusLegacy::Proxy>(child);
+}
+
+std::vector<std::shared_ptr<Descriptor>> Characteristic::descriptors() { return children_casted<Descriptor>(); }
+
+std::shared_ptr<GattCharacteristic1> Characteristic::gattcharacteristic1() {
+    return std::dynamic_pointer_cast<GattCharacteristic1>(interface_get("org.bluez.GattCharacteristic1"));
+}
+
+bool Characteristic::notifying() { return gattcharacteristic1()->Notifying(); }
+
+std::string Characteristic::uuid() { return gattcharacteristic1()->UUID(); }
+
+ByteArray Characteristic::value() { return gattcharacteristic1()->Value(); }
+
+std::vector<std::string> Characteristic::flags() { return gattcharacteristic1()->Flags(); }
+
+uint16_t Characteristic::mtu() { return gattcharacteristic1()->MTU(); }
+
+ByteArray Characteristic::read() { return gattcharacteristic1()->ReadValue(); }
+
+void Characteristic::write_request(ByteArray value) {
+    gattcharacteristic1()->WriteValue(value, GattCharacteristic1::WriteType::REQUEST);
+}
+
+void Characteristic::write_command(ByteArray value) {
+    gattcharacteristic1()->WriteValue(value, GattCharacteristic1::WriteType::COMMAND);
+}
+
+void Characteristic::start_notify() { gattcharacteristic1()->StartNotify(); }
+
+void Characteristic::stop_notify() { gattcharacteristic1()->StopNotify(); }
+
+std::shared_ptr<Descriptor> Characteristic::get_descriptor(const std::string& uuid) {
+    auto descriptors_all = descriptors();
+
+    for (auto& descriptor : descriptors_all) {
+        if (descriptor->uuid() == uuid) {
+            return descriptor;
+        }
+    }
+
+    throw Exception::DescriptorNotFoundException(uuid);
+}
+
+void Characteristic::set_on_value_changed(std::function<void(ByteArray new_value)> callback) {
+    gattcharacteristic1()->OnValueChanged.load([this, callback]() { callback(gattcharacteristic1()->Value()); });
+}
+
+void Characteristic::clear_on_value_changed() { gattcharacteristic1()->OnValueChanged.unload(); }

package/simpleble/src/backends/linux_legacy/src/Descriptor.cpp

@@ -0,0 +1,27 @@
+#include <simplebluezlegacy/Descriptor.h>
+
+using namespace SimpleBluezLegacy;
+
+Descriptor::Descriptor(std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name,
+                       const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+Descriptor::~Descriptor() {}
+
+std::shared_ptr<GattDescriptor1> Descriptor::gattdescriptor1() {
+    return std::dynamic_pointer_cast<GattDescriptor1>(interface_get("org.bluez.GattDescriptor1"));
+}
+
+std::string Descriptor::uuid() { return gattdescriptor1()->UUID(); }
+
+ByteArray Descriptor::value() { return gattdescriptor1()->Value(); }
+
+ByteArray Descriptor::read() { return gattdescriptor1()->ReadValue(); }
+
+void Descriptor::write(ByteArray value) { gattdescriptor1()->WriteValue(value); }
+
+void Descriptor::set_on_value_changed(std::function<void(ByteArray new_value)> callback) {
+    gattdescriptor1()->OnValueChanged.load([this, callback]() { callback(gattdescriptor1()->Value()); });
+}
+
+void Descriptor::clear_on_value_changed() { gattdescriptor1()->OnValueChanged.unload(); }

package/simpleble/src/backends/linux_legacy/src/Device.cpp

@@ -0,0 +1,104 @@
+#include <simplebluezlegacy/Device.h>
+#include <simplebluezlegacy/Exceptions.h>
+#include <simplebluezlegacy/Service.h>
+
+#include <simpledbuslegacy/base/Path.h>
+
+using namespace SimpleBluezLegacy;
+
+Device::Device(std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+Device::~Device() {}
+
+std::shared_ptr<SimpleDBusLegacy::Proxy> Device::path_create(const std::string& path) {
+    const std::string next_child = SimpleDBusLegacy::Path::next_child_strip(_path, path);
+
+    if (next_child.find("service") == 0) {
+        auto child = std::make_shared<Service>(_conn, _bus_name, path);
+        return std::static_pointer_cast<SimpleDBusLegacy::Proxy>(child);
+    } else {
+        return std::make_shared<Proxy>(_conn, _bus_name, path);
+    }
+}
+
+std::shared_ptr<Device1> Device::device1() {
+    return std::dynamic_pointer_cast<Device1>(interface_get("org.bluez.Device1"));
+}
+
+std::shared_ptr<Battery1> Device::battery1() {
+    return std::dynamic_pointer_cast<Battery1>(interface_get("org.bluez.Battery1"));
+}
+
+std::vector<std::shared_ptr<Service>> Device::services() { return children_casted_with_prefix<Service>("service"); }
+
+std::shared_ptr<Service> Device::get_service(const std::string& uuid) {
+    auto services_all = services();
+
+    for (auto& service : services_all) {
+        if (service->uuid() == uuid) {
+            return service;
+        }
+    }
+
+    throw Exception::ServiceNotFoundException(uuid);
+}
+
+std::shared_ptr<Characteristic> Device::get_characteristic(const std::string& service_uuid,
+                                                           const std::string& characteristic_uuid) {
+    auto service = get_service(service_uuid);
+    return service->get_characteristic(characteristic_uuid);
+}
+
+void Device::pair() { device1()->Pair(); }
+
+void Device::cancel_pairing() { device1()->CancelPairing(); }
+
+void Device::connect() { device1()->Connect(); }
+
+void Device::disconnect() { device1()->Disconnect(); }
+
+std::string Device::address() { return device1()->Address(); }
+
+std::string Device::address_type() { return device1()->AddressType(); }
+
+std::string Device::name() { return device1()->Name(); }
+
+std::string Device::alias() { return device1()->Alias(); }
+
+int16_t Device::rssi() { return device1()->RSSI(); }
+
+int16_t Device::tx_power() { return device1()->TxPower(); }
+
+std::vector<std::string> Device::uuids() { return device1()->UUIDs(); }
+
+std::map<uint16_t, ByteArray> Device::manufacturer_data() { return device1()->ManufacturerData(); }
+
+std::map<std::string, ByteArray> Device::service_data() { return device1()->ServiceData(); }
+
+bool Device::paired() { return device1()->Paired(); }
+
+bool Device::connected() { return device1()->Connected(); }
+
+bool Device::services_resolved() { return device1()->ServicesResolved(); }
+
+void Device::set_on_disconnected(std::function<void()> callback) { device1()->OnDisconnected.load(callback); }
+
+void Device::clear_on_disconnected() { device1()->OnDisconnected.unload(); }
+
+void Device::set_on_services_resolved(std::function<void()> callback) { device1()->OnServicesResolved.load(callback); }
+
+void Device::clear_on_services_resolved() { device1()->OnServicesResolved.unload(); }
+
+bool Device::has_battery_interface() { return interface_exists("org.bluez.Battery1"); }
+
+uint8_t Device::battery_percentage() { return battery1()->Percentage(); }
+
+void Device::set_on_battery_percentage_changed(std::function<void(uint8_t new_value)> callback) {
+    battery1()->OnPercentageChanged.load([this, callback]() { callback(battery1()->Percentage()); });
+    // As the `property_changed` callback only occurs when the property is changed, we need to manually
+    // call the callback once to make sure the callback is called with the current value.
+    battery1()->OnPercentageChanged();
+}
+
+void Device::clear_on_battery_percentage_changed() { battery1()->OnPercentageChanged.unload(); }

package/simpleble/src/backends/linux_legacy/src/Exceptions.cpp

@@ -0,0 +1,29 @@
+#include <simplebluezlegacy/Exceptions.h>
+
+#include <fmt/core.h>
+
+namespace SimpleBluezLegacy {
+
+namespace Exception {
+
+ServiceNotFoundException::ServiceNotFoundException(const std::string& service) {
+    _message = fmt::format("Service {} not found.", service);
+}
+
+const char* ServiceNotFoundException::what() const noexcept { return _message.c_str(); }
+
+CharacteristicNotFoundException::CharacteristicNotFoundException(const std::string& characteristic) {
+    _message = fmt::format("Characteristic {} not found.", characteristic);
+}
+
+const char* CharacteristicNotFoundException::what() const noexcept { return _message.c_str(); }
+
+DescriptorNotFoundException::DescriptorNotFoundException(const std::string& descriptor) {
+    _message = fmt::format("Descriptor {} not found.", descriptor);
+}
+
+const char* DescriptorNotFoundException::what() const noexcept { return _message.c_str(); }
+
+}  // namespace Exception
+
+}  // namespace SimpleBluezLegacy