simpleble 0.0.1

data/vendor/simpleble/simplebluez/include/simplebluez/Service.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <simpledbus/advanced/Proxy.h>
+
+#include <simplebluez/Characteristic.h>
+#include <simplebluez/interfaces/GattService1.h>
+
+namespace SimpleBluez {
+
+class Service : public SimpleDBus::Proxy {
+  public:
+    Service(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~Service() = default;
+
+    std::shared_ptr<Characteristic> get_characteristic(const std::string& uuid);
+
+    // ----- PROPERTIES -----
+    std::vector<std::shared_ptr<Characteristic>> characteristics();
+
+    std::string uuid();
+
+  private:
+    std::shared_ptr<SimpleDBus::Proxy> path_create(const std::string& path) override;
+    std::shared_ptr<GattService1> gattservice1();
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/Types.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "kvn/kvn_bytearray.h"
+
+namespace SimpleBluez {
+
+using ByteArray = kvn::bytearray;
+
+}

data/vendor/simpleble/simplebluez/include/simplebluez/interfaces/Adapter1.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <simpledbus/advanced/Interface.h>
+#include <simpledbus/advanced/InterfaceRegistry.h>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace SimpleBluez {
+
+class Adapter1 : public SimpleDBus::Interface {
+  public:
+    // ----- TYPES -----
+    struct DiscoveryFilter {
+        typedef enum { AUTO, BREDR, LE } TransportType;
+        std::vector<std::string> UUIDs = {};
+        std::optional<int16_t> RSSI;
+        std::optional<uint16_t> Pathloss;
+        TransportType Transport = TransportType::AUTO;
+        bool DuplicateData = true;
+        bool Discoverable = false;
+        std::string Pattern = "";
+    };
+
+    // ----- CONSTRUCTORS -----
+    Adapter1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path);
+    virtual ~Adapter1() = default;
+
+    // ----- METHODS -----
+    void RemoveDevice(std::string device_path);
+    void StartDiscovery();
+    void StopDiscovery();
+    void SetDiscoveryFilter(DiscoveryFilter filter);
+    SimpleDBus::Holder GetDiscoveryFilters();
+
+    // ----- PROPERTIES -----
+    bool Discovering(bool refresh = true);
+    bool Powered(bool refresh = true);
+    std::string Address();
+
+  protected:
+    void property_changed(std::string option_name) override;
+
+  private:
+    static const SimpleDBus::AutoRegisterInterface<Adapter1> registry;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/interfaces/Agent1.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <simpledbus/advanced/Interface.h>
+#include <simpledbus/advanced/InterfaceRegistry.h>
+
+#include "kvn/kvn_safe_callback.hpp"
+
+#include <cstdint>
+#include <string>
+
+namespace SimpleBluez {
+
+class Agent1 : public SimpleDBus::Interface {
+  public:
+    Agent1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path);
+    virtual ~Agent1() = default;
+
+    // ----- METHODS -----
+
+    // ----- PROPERTIES -----
+
+    // ----- CALLBACKS -----
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to get the passkey for an authentication.
+     *        The return value should be a string of 1-16 characters
+     *        length. The string can be alphanumeric.
+     *
+     * @note: Invalid values will cause a rejection of the request
+     *        be returned.
+     */
+    kvn::safe_callback<std::string()> OnRequestPinCode;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to display a pincode for an authentication.
+     *        Note that the PIN will always be a 6-digit number,
+     *        zero-padded to 6 digits.
+     *
+     * @return false if the request should be rejected.
+     */
+    kvn::safe_callback<bool(const std::string&)> OnDisplayPinCode;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to get the passkey for an authentication.
+     *        The return value should be a numeric value
+     *        between 0 and 999999.
+     *
+     * @note: Invalid values will cause a rejection of the request
+     *        be returned.
+     */
+    kvn::safe_callback<int32_t()> OnRequestPasskey;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to display a passkey for an authentication.
+     *        The entered parameter indicates the number of already
+     *        typed keys on the remote side.
+     */
+    kvn::safe_callback<void(uint32_t, uint16_t)> OnDisplayPasskey;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to confirm a passkey for an authentication.
+     *
+     * @return false if the request should be rejected.
+     */
+    kvn::safe_callback<bool(uint32_t)> OnRequestConfirmation;
+
+    /**
+     * @brief This method gets called to request the user to
+     *        authorize an incoming pairing attempt which
+     *        would in other circumstances trigger the just-works
+     *        model, or when the user plugged in a device that
+     *        implements cable pairing.
+     *
+     * @return false if the request should be rejected.
+     */
+    kvn::safe_callback<bool()> OnRequestAuthorization;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to authorize a connection/service request.
+     *
+     * @return false if the request should be rejected.
+     */
+    kvn::safe_callback<bool(const std::string&)> OnAuthorizeService;
+
+  protected:
+    void message_handle(SimpleDBus::Message& msg) override;
+
+    void reply_error(SimpleDBus::Message& msg, const std::string& error_name, const std::string& error_message);
+
+  private:
+    static const SimpleDBus::AutoRegisterInterface<Agent1> registry;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/interfaces/AgentManager1.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <simpledbus/advanced/Interface.h>
+#include <simpledbus/advanced/InterfaceRegistry.h>
+
+#include <string>
+
+namespace SimpleBluez {
+
+class AgentManager1 : public SimpleDBus::Interface {
+  public:
+    AgentManager1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path);
+    virtual ~AgentManager1() = default;
+
+    // ----- METHODS -----
+    void RegisterAgent(std::string agent, std::string capability);
+    void RequestDefaultAgent(std::string agent);
+    void UnregisterAgent(std::string agent);
+
+  private:
+    static const SimpleDBus::AutoRegisterInterface<AgentManager1> registry;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/interfaces/Battery1.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <simpledbus/advanced/Interface.h>
+#include <simpledbus/advanced/InterfaceRegistry.h>
+
+#include "kvn/kvn_safe_callback.hpp"
+
+#include <string>
+
+namespace SimpleBluez {
+
+class Battery1 : public SimpleDBus::Interface {
+  public:
+    Battery1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path);
+    virtual ~Battery1();
+
+    // ----- METHODS -----
+
+    // ----- PROPERTIES -----
+    uint8_t Percentage();
+
+    // ----- CALLBACKS -----
+    kvn::safe_callback<void()> OnPercentageChanged;
+
+  protected:
+    void property_changed(std::string option_name) override;
+
+  private:
+    static const SimpleDBus::AutoRegisterInterface<Battery1> registry;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/interfaces/Device1.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <simpledbus/advanced/Interface.h>
+#include <simpledbus/advanced/InterfaceRegistry.h>
+
+#include "kvn/kvn_safe_callback.hpp"
+
+#include <string>
+
+#include "simplebluez/Types.h"
+
+namespace SimpleBluez {
+
+class Device1 : public SimpleDBus::Interface {
+  public:
+    Device1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path);
+    virtual ~Device1();
+
+    // ----- METHODS -----
+    void Connect();
+    void Disconnect();
+    void Pair();
+    void CancelPairing();
+
+    // ----- PROPERTIES -----
+    int16_t RSSI();
+    int16_t TxPower();
+    uint16_t Appearance();  // On Bluez 5.53, this always returns 0.
+    std::string Address();
+    std::string AddressType();
+    std::string Alias();
+    std::string Name();
+    std::vector<std::string> UUIDs();
+    std::map<uint16_t, ByteArray> ManufacturerData(bool refresh = true);
+    std::map<std::string, ByteArray> ServiceData(bool refresh = true);
+    bool Paired(bool refresh = true);
+    bool Connected(bool refresh = true);
+    bool ServicesResolved(bool refresh = true);
+
+    // ----- CALLBACKS -----
+    kvn::safe_callback<void()> OnServicesResolved;
+    kvn::safe_callback<void()> OnDisconnected;
+
+  protected:
+    void property_changed(std::string option_name) override;
+
+    int16_t _rssi = INT16_MIN;
+    int16_t _tx_power = INT16_MIN;
+    std::string _name;
+    std::string _alias;
+    std::string _address;
+    std::string _address_type;
+    bool _connected;
+    bool _services_resolved;
+    std::map<uint16_t, ByteArray> _manufacturer_data;
+    std::map<std::string, ByteArray> _service_data;
+
+  private:
+    static const SimpleDBus::AutoRegisterInterface<Device1> registry;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/interfaces/GattCharacteristic1.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <simpledbus/advanced/Interface.h>
+#include <simpledbus/advanced/InterfaceRegistry.h>
+
+#include "kvn/kvn_safe_callback.hpp"
+
+#include <simplebluez/Types.h>
+
+#include <string>
+
+namespace SimpleBluez {
+
+class GattCharacteristic1 : public SimpleDBus::Interface {
+  public:
+    typedef enum { REQUEST = 0, COMMAND } WriteType;
+
+    GattCharacteristic1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path);
+    virtual ~GattCharacteristic1();
+
+    // ----- METHODS -----
+    void StartNotify();
+    void StopNotify();
+    void WriteValue(const ByteArray& value, WriteType type);
+    ByteArray ReadValue();
+
+    // ----- PROPERTIES -----
+    std::string UUID();
+    ByteArray Value();
+    bool Notifying(bool refresh = true);
+    std::vector<std::string> Flags();
+    uint16_t MTU();
+
+    // ----- CALLBACKS -----
+    kvn::safe_callback<void()> OnValueChanged;
+
+  protected:
+    void property_changed(std::string option_name) override;
+    void update_value(SimpleDBus::Holder& new_value);
+
+    std::string _uuid;
+    ByteArray _value;
+
+  private:
+    static const SimpleDBus::AutoRegisterInterface<GattCharacteristic1> registry;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/interfaces/GattDescriptor1.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <simpledbus/advanced/Interface.h>
+#include <simpledbus/advanced/InterfaceRegistry.h>
+
+#include "kvn/kvn_safe_callback.hpp"
+
+#include <simplebluez/Types.h>
+
+#include <string>
+
+namespace SimpleBluez {
+
+class GattDescriptor1 : public SimpleDBus::Interface {
+  public:
+    GattDescriptor1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path);
+    virtual ~GattDescriptor1();
+
+    // ----- METHODS -----
+    void WriteValue(const ByteArray& value);
+    ByteArray ReadValue();
+
+    // ----- PROPERTIES -----
+    std::string UUID();
+    ByteArray Value();
+
+    // ----- CALLBACKS -----
+    kvn::safe_callback<void()> OnValueChanged;
+
+  protected:
+    void property_changed(std::string option_name) override;
+    void update_value(SimpleDBus::Holder& new_value);
+
+    std::string _uuid;
+    ByteArray _value;
+
+  private:
+    static const SimpleDBus::AutoRegisterInterface<GattDescriptor1> registry;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/interfaces/GattService1.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <simpledbus/advanced/Interface.h>
+#include <simpledbus/advanced/InterfaceRegistry.h>
+#include <string>
+
+namespace SimpleBluez {
+
+class GattService1 : public SimpleDBus::Interface {
+  public:
+    GattService1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path);
+    virtual ~GattService1() = default;
+
+    // ----- METHODS -----
+
+    // ----- PROPERTIES -----
+    std::string UUID();
+
+  protected:
+    void property_changed(std::string option_name) override;
+
+    std::string _uuid;
+
+  private:
+    static const SimpleDBus::AutoRegisterInterface<GattService1> registry;
+};
+
+}  // namespace SimpleBluez

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

@@ -0,0 +1,78 @@
+#include <simplebluez/Adapter.h>
+#include <simplebluez/Device.h>
+
+#include <simplebluez/interfaces/Adapter1.h>
+
+using namespace SimpleBluez;
+
+Adapter::Adapter(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path)
+    : Proxy(conn, bus_name, path) {}
+
+Adapter::~Adapter() {}
+
+std::shared_ptr<SimpleDBus::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<SimpleDBus::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();
+}

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

@@ -0,0 +1,72 @@
+#include <simplebluez/Agent.h>
+
+#include <iostream>
+
+using namespace SimpleBluez;
+
+Agent::Agent(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.bluez.Agent1", std::static_pointer_cast<SimpleDBus::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")); }

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

@@ -0,0 +1,45 @@
+#include <simplebluez/Bluez.h>
+#include <simpledbus/interfaces/ObjectManager.h>
+
+using namespace SimpleBluez;
+
+#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<SimpleDBus::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();
+    SimpleDBus::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(); }

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

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

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

@@ -0,0 +1,23 @@
+#include <simplebluez/Adapter.h>
+#include <simplebluez/BluezOrgBluez.h>
+
+using namespace SimpleBluez;
+
+BluezOrgBluez::BluezOrgBluez(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> BluezOrgBluez::path_create(const std::string& path) {
+    auto child = std::make_shared<Adapter>(_conn, _bus_name, path);
+    return std::static_pointer_cast<SimpleDBus::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>(); }