simpleble 0.0.1

data/vendor/simpleble/simplebluez/src/BluezRoot.cpp

@@ -0,0 +1,44 @@
+#include <simplebluez/BluezRoot.h>
+#include <simplebluez/BluezOrg.h>
+#include <simpledbus/interfaces/ObjectManager.h>
+
+using namespace SimpleBluez;
+
+BluezRoot::BluezRoot(std::shared_ptr<SimpleDBus::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<SimpleDBus::ObjectManager>(conn, _bus_name, _path)));
+
+    object_manager()->InterfacesAdded = [&](std::string path, SimpleDBus::Holder options) { path_add(path, options); };
+    object_manager()->InterfacesRemoved = [&](std::string path, SimpleDBus::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<SimpleDBus::Proxy>(_agent));
+}
+
+void BluezRoot::load_managed_objects() {
+    SimpleDBus::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<SimpleDBus::Proxy> BluezRoot::path_create(const std::string& path) {
+    auto child = std::make_shared<BluezOrg>(_conn, _bus_name, path);
+    return std::static_pointer_cast<SimpleDBus::Proxy>(child);
+}
+
+std::shared_ptr<SimpleDBus::ObjectManager> BluezRoot::object_manager() {
+    return std::dynamic_pointer_cast<SimpleDBus::ObjectManager>(interface_get("org.freedesktop.DBus.ObjectManager"));
+}

data/vendor/simpleble/simplebluez/src/Characteristic.cpp

@@ -0,0 +1,64 @@
+#include <simplebluez/Characteristic.h>
+#include <simplebluez/Descriptor.h>
+#include <simplebluez/Exceptions.h>
+
+using namespace SimpleBluez;
+
+Characteristic::Characteristic(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name,
+                               const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+Characteristic::~Characteristic() {}
+
+std::shared_ptr<SimpleDBus::Proxy> Characteristic::path_create(const std::string& path) {
+    auto child = std::make_shared<Descriptor>(_conn, _bus_name, path);
+    return std::static_pointer_cast<SimpleDBus::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(); }

data/vendor/simpleble/simplebluez/src/Descriptor.cpp

@@ -0,0 +1,27 @@
+#include <simplebluez/Descriptor.h>
+
+using namespace SimpleBluez;
+
+Descriptor::Descriptor(std::shared_ptr<SimpleDBus::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(); }

data/vendor/simpleble/simplebluez/src/Device.cpp

@@ -0,0 +1,104 @@
+#include <simplebluez/Device.h>
+#include <simplebluez/Exceptions.h>
+#include <simplebluez/Service.h>
+
+#include <simpledbus/base/Path.h>
+
+using namespace SimpleBluez;
+
+Device::Device(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+Device::~Device() {}
+
+std::shared_ptr<SimpleDBus::Proxy> Device::path_create(const std::string& path) {
+    const std::string next_child = SimpleDBus::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<SimpleDBus::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(); }

data/vendor/simpleble/simplebluez/src/Exceptions.cpp

@@ -0,0 +1,29 @@
+#include <simplebluez/Exceptions.h>
+
+#include <fmt/core.h>
+
+namespace SimpleBluez {
+
+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 SimpleBluez

data/vendor/simpleble/simplebluez/src/Logging.cpp

@@ -0,0 +1,52 @@
+#include "Logging.h"
+#include "kvn/logfwd.hpp"
+
+#ifndef SIMPLEBLUEZ_LOG_LEVEL
+#warning "SIMPLEBLUEZ_LOG_LEVEL not defined, using default value: FATAL"
+#define SIMPLEBLUEZ_LOG_LEVEL FATAL
+#endif
+
+static const logfwd::level log_level = logfwd::level::SIMPLEBLUEZ_LOG_LEVEL;
+
+namespace SimpleBluez {
+
+void log_fatal(const std::string& file, uint32_t line, const std::string& function, const std::string& message) {
+    if (log_level >= logfwd::level::FATAL) {
+        logfwd::receive(logfwd::level::FATAL, "SimpleBluez", file, line, function, message);
+    }
+}
+
+void log_error(const std::string& file, uint32_t line, const std::string& function, const std::string& message) {
+    if (log_level >= logfwd::level::ERROR) {
+        logfwd::receive(logfwd::level::ERROR, "SimpleBluez", file, line, function, message);
+    }
+}
+
+void log_warn(const std::string& file, uint32_t line, const std::string& function, const std::string& message) {
+    if (log_level >= logfwd::level::WARN) {
+        logfwd::receive(logfwd::level::WARN, "SimpleBluez", file, line, function, message);
+    }
+}
+
+void log_info(const std::string& file, uint32_t line, const std::string& function, const std::string& message) {
+    if (log_level >= logfwd::level::INFO) {
+        logfwd::receive(logfwd::level::INFO, "SimpleBluez", file, line, function, message);
+    }
+}
+
+void log_debug(const std::string& file, uint32_t line, const std::string& function, const std::string& message) {
+    if (log_level >= logfwd::level::DEBUG) {
+        logfwd::receive(logfwd::level::DEBUG, "SimpleBluez", file, line, function, message);
+    }
+}
+
+void log_verbose(const std::string& file, uint32_t line, const std::string& function, const std::string& message) {
+    if (log_level >= logfwd::level::VERBOSE) {
+        logfwd::receive(logfwd::level::VERBOSE, "SimpleBluez", file, line, function, message);
+    }
+}
+
+}  // namespace SimpleBluez
+
+__attribute__((weak)) void logfwd::receive(logfwd::level level, const std::string& module, const std::string& file,
+                                           uint32_t line, const std::string& function, const std::string& message) {}

data/vendor/simpleble/simplebluez/src/Logging.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <fmt/core.h>
+#include <cstdint>
+#include <string>
+
+namespace SimpleBluez {
+
+// 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 SimpleBluez
+
+#define LOG_FATAL(...) SimpleBluez::log_fatal(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_ERROR(...) SimpleBluez::log_error(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_WARN(...) SimpleBluez::log_warn(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_INFO(...) SimpleBluez::log_info(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_DEBUG(...) SimpleBluez::log_debug(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define LOG_VERBOSE(...) SimpleBluez::log_verbose(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)

data/vendor/simpleble/simplebluez/src/Service.cpp

@@ -0,0 +1,33 @@
+#include <simplebluez/Characteristic.h>
+#include <simplebluez/Exceptions.h>
+#include <simplebluez/Service.h>
+
+using namespace SimpleBluez;
+
+Service::Service(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+std::shared_ptr<SimpleDBus::Proxy> Service::path_create(const std::string& path) {
+    auto child = std::make_shared<Characteristic>(_conn, _bus_name, path);
+    return std::static_pointer_cast<SimpleDBus::Proxy>(child);
+}
+
+std::shared_ptr<GattService1> Service::gattservice1() {
+    return std::dynamic_pointer_cast<GattService1>(interface_get("org.bluez.GattService1"));
+}
+
+std::vector<std::shared_ptr<Characteristic>> Service::characteristics() { return children_casted<Characteristic>(); }
+
+std::shared_ptr<Characteristic> Service::get_characteristic(const std::string& uuid) {
+    auto characteristics_all = characteristics();
+
+    for (auto& characteristic : characteristics_all) {
+        if (characteristic->uuid() == uuid) {
+            return characteristic;
+        }
+    }
+
+    throw Exception::CharacteristicNotFoundException(uuid);
+}
+
+std::string Service::uuid() { return gattservice1()->UUID(); }

data/vendor/simpleble/simplebluez/src/interfaces/Adapter1.cpp

@@ -0,0 +1,123 @@
+#include "simplebluez/interfaces/Adapter1.h"
+
+using namespace SimpleBluez;
+
+const SimpleDBus::AutoRegisterInterface<Adapter1> Adapter1::registry{
+    "org.bluez.Adapter1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBus::Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::static_pointer_cast<SimpleDBus::Interface>(std::make_shared<Adapter1>(conn, path));
+    }
+    // clang-format on
+};
+
+Adapter1::Adapter1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path)
+    : SimpleDBus::Interface(conn, "org.bluez", path, "org.bluez.Adapter1") {}
+
+void Adapter1::StartDiscovery() {
+    auto msg = create_method_call("StartDiscovery");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void Adapter1::StopDiscovery() {
+    auto msg = create_method_call("StopDiscovery");
+    _conn->send_with_reply_and_block(msg);
+    // NOTE: It might take a few seconds until the peripheral reports that is has actually stopped discovering.
+}
+
+SimpleDBus::Holder Adapter1::GetDiscoveryFilters() {
+    auto msg = create_method_call("GetDiscoveryFilters");
+    SimpleDBus::Message reply_msg = _conn->send_with_reply_and_block(msg);
+    SimpleDBus::Holder discovery_filters = reply_msg.extract();
+    return discovery_filters;
+}
+
+void Adapter1::SetDiscoveryFilter(DiscoveryFilter filter) {
+    SimpleDBus::Holder properties = SimpleDBus::Holder::create_dict();
+
+    if (filter.UUIDs.size() > 0) {
+        SimpleDBus::Holder uuids = SimpleDBus::Holder::create_array();
+        for (size_t i = 0; i < filter.UUIDs.size(); i++) {
+            uuids.array_append(SimpleDBus::Holder::create_string(filter.UUIDs.at(i)));
+        }
+        properties.dict_append(SimpleDBus::Holder::Type::ARRAY, "UUIDs", uuids);
+    }
+
+    if (filter.RSSI.has_value()) {
+        properties.dict_append(SimpleDBus::Holder::Type::INT16, "RSSI",
+                               SimpleDBus::Holder::create_int16(filter.RSSI.value()));
+    }
+
+    if (filter.Pathloss.has_value()) {
+        properties.dict_append(SimpleDBus::Holder::Type::UINT16, "Pathloss",
+                               SimpleDBus::Holder::create_uint16(filter.Pathloss.value()));
+    }
+
+    switch (filter.Transport) {
+        case DiscoveryFilter::TransportType::AUTO: {
+            properties.dict_append(SimpleDBus::Holder::Type::STRING, "Transport",
+                                   SimpleDBus::Holder::create_string("auto"));
+            break;
+        }
+        case DiscoveryFilter::TransportType::BREDR: {
+            properties.dict_append(SimpleDBus::Holder::Type::STRING, "Transport",
+                                   SimpleDBus::Holder::create_string("bredr"));
+            break;
+        }
+        case DiscoveryFilter::TransportType::LE: {
+            properties.dict_append(SimpleDBus::Holder::Type::STRING, "Transport",
+                                   SimpleDBus::Holder::create_string("le"));
+            break;
+        }
+    }
+
+    if (!filter.DuplicateData) {
+        properties.dict_append(SimpleDBus::Holder::Type::BOOLEAN, "DuplicateData",
+                               SimpleDBus::Holder::create_boolean(false));
+    }
+
+    if (filter.Discoverable) {
+        properties.dict_append(SimpleDBus::Holder::Type::BOOLEAN, "Discoverable",
+                               SimpleDBus::Holder::create_boolean(false));
+    }
+
+    if (filter.Pattern.size() > 0) {
+        properties.dict_append(SimpleDBus::Holder::Type::STRING, "Pattern",
+                               SimpleDBus::Holder::create_string(filter.Pattern));
+    }
+
+    auto msg = create_method_call("SetDiscoveryFilter");
+    msg.append_argument(properties, "a{sv}");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void Adapter1::RemoveDevice(std::string device_path) {
+    auto msg = create_method_call("RemoveDevice");
+    msg.append_argument(SimpleDBus::Holder::create_object_path(device_path), "o");
+    _conn->send_with_reply_and_block(msg);
+}
+
+bool Adapter1::Discovering(bool refresh) {
+    if (refresh) {
+        property_refresh("Discovering");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Discovering"].get_boolean();
+}
+
+bool Adapter1::Powered(bool refresh) {
+    if (refresh) {
+        property_refresh("Powered");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Powered"].get_boolean();
+}
+
+std::string Adapter1::Address() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Address"].get_string();
+}
+
+void Adapter1::property_changed(std::string option_name) {}