simplejsble 0.0.4 → 0.0.6

package/simpleble/src/backends/linux_legacy/src/base/Path.cpp

@@ -0,0 +1,129 @@
+#include "simpledbuslegacy/base/Path.h"
+
+#include <algorithm>
+
+namespace SimpleDBusLegacy {
+
+// TODO: Add path validation and throw exception if invalid
+
+size_t Path::count_elements(const std::string& path) {
+    if (path.empty() || path == "/") {
+        return 0;
+    }
+
+    return std::count(path.begin(), path.end(), '/');
+}
+
+std::vector<std::string> Path::split_elements(const std::string& path) {
+    std::vector<std::string> elements;
+
+    if (path.empty() || path == "/") {
+        return elements;
+    }
+
+    // Note: Skip the first element, which is the root
+    std::string::const_iterator it = path.begin() + 1;
+    std::string::const_iterator end = path.end();
+
+    while (it != end) {
+        std::string::const_iterator next = std::find(it, end, '/');
+        elements.push_back(std::string(it, next));
+        it = next;
+        if (it != end) {
+            ++it;
+        }
+    }
+
+    return elements;
+}
+
+std::string Path::fetch_elements(const std::string& path, size_t count) {
+    if (count == 0) {
+        return "/";
+    }
+
+    if (count > count_elements(path)) {
+        // TODO: Should we throw an exception?
+        return path;
+    }
+
+    std::vector<std::string> elements = split_elements(path);
+    std::string result;
+
+    for (size_t i = 0; i < count; i++) {
+        result += "/" + elements[i];
+    }
+
+    return result;
+}
+
+bool Path::is_descendant(const std::string& base, const std::string& path) {
+    if (base.empty() || path.empty()) {
+        return false;
+    }
+
+    if (base == path) {
+        return false;
+    }
+
+    if (base == "/") {
+        return true;
+    }
+
+    return path.rfind(base) == 0;
+}
+
+bool Path::is_ascendant(const std::string& base, const std::string& path) {
+    if (base.empty() || path.empty()) {
+        return false;
+    }
+
+    if (base == path) {
+        return false;
+    }
+
+    return !is_descendant(base, path);
+}
+
+bool Path::is_child(const std::string& base, const std::string& path) {
+    if (base.empty() || path.empty()) {
+        return false;
+    }
+
+    if (base == path) {
+        return false;
+    }
+
+    if (!is_descendant(base, path)) {
+        return false;
+    }
+
+    return count_elements(base) + 1 == count_elements(path);
+}
+
+bool Path::is_parent(const std::string& base, const std::string& path) {
+    if (base.empty() || path.empty()) {
+        return false;
+    }
+
+    if (base == path) {
+        return false;
+    }
+
+    if (!is_ascendant(base, path)) {
+        return false;
+    }
+
+    return count_elements(base) - 1 == count_elements(path);
+}
+
+std::string Path::next_child(const std::string& base, const std::string& path) {
+    return fetch_elements(path, count_elements(base) + 1);
+}
+
+std::string Path::next_child_strip(const std::string& base, const std::string& path) {
+    const std::string child = next_child(base, path);
+    return child.substr(base.length() + 1);
+}
+
+}  // namespace SimpleDBusLegacy

package/simpleble/src/backends/linux_legacy/src/interfaces/Adapter1.cpp

@@ -0,0 +1,123 @@
+#include "simplebluezlegacy/interfaces/Adapter1.h"
+
+using namespace SimpleBluezLegacy;
+
+const SimpleDBusLegacy::AutoRegisterInterface<Adapter1> Adapter1::registry{
+    "org.bluez.Adapter1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBusLegacy::Holder& options) -> std::shared_ptr<SimpleDBusLegacy::Interface> {
+        return std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<Adapter1>(conn, path));
+    }
+    // clang-format on
+};
+
+Adapter1::Adapter1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path)
+    : SimpleDBusLegacy::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.
+}
+
+SimpleDBusLegacy::Holder Adapter1::GetDiscoveryFilters() {
+    auto msg = create_method_call("GetDiscoveryFilters");
+    SimpleDBusLegacy::Message reply_msg = _conn->send_with_reply_and_block(msg);
+    SimpleDBusLegacy::Holder discovery_filters = reply_msg.extract();
+    return discovery_filters;
+}
+
+void Adapter1::SetDiscoveryFilter(DiscoveryFilter filter) {
+    SimpleDBusLegacy::Holder properties = SimpleDBusLegacy::Holder::create_dict();
+
+    if (filter.UUIDs.size() > 0) {
+        SimpleDBusLegacy::Holder uuids = SimpleDBusLegacy::Holder::create_array();
+        for (size_t i = 0; i < filter.UUIDs.size(); i++) {
+            uuids.array_append(SimpleDBusLegacy::Holder::create_string(filter.UUIDs.at(i)));
+        }
+        properties.dict_append(SimpleDBusLegacy::Holder::Type::ARRAY, "UUIDs", uuids);
+    }
+
+    if (filter.RSSI.has_value()) {
+        properties.dict_append(SimpleDBusLegacy::Holder::Type::INT16, "RSSI",
+                               SimpleDBusLegacy::Holder::create_int16(filter.RSSI.value()));
+    }
+
+    if (filter.Pathloss.has_value()) {
+        properties.dict_append(SimpleDBusLegacy::Holder::Type::UINT16, "Pathloss",
+                               SimpleDBusLegacy::Holder::create_uint16(filter.Pathloss.value()));
+    }
+
+    switch (filter.Transport) {
+        case DiscoveryFilter::TransportType::AUTO: {
+            properties.dict_append(SimpleDBusLegacy::Holder::Type::STRING, "Transport",
+                                   SimpleDBusLegacy::Holder::create_string("auto"));
+            break;
+        }
+        case DiscoveryFilter::TransportType::BREDR: {
+            properties.dict_append(SimpleDBusLegacy::Holder::Type::STRING, "Transport",
+                                   SimpleDBusLegacy::Holder::create_string("bredr"));
+            break;
+        }
+        case DiscoveryFilter::TransportType::LE: {
+            properties.dict_append(SimpleDBusLegacy::Holder::Type::STRING, "Transport",
+                                   SimpleDBusLegacy::Holder::create_string("le"));
+            break;
+        }
+    }
+
+    if (!filter.DuplicateData) {
+        properties.dict_append(SimpleDBusLegacy::Holder::Type::BOOLEAN, "DuplicateData",
+                               SimpleDBusLegacy::Holder::create_boolean(false));
+    }
+
+    if (filter.Discoverable) {
+        properties.dict_append(SimpleDBusLegacy::Holder::Type::BOOLEAN, "Discoverable",
+                               SimpleDBusLegacy::Holder::create_boolean(false));
+    }
+
+    if (filter.Pattern.size() > 0) {
+        properties.dict_append(SimpleDBusLegacy::Holder::Type::STRING, "Pattern",
+                               SimpleDBusLegacy::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(SimpleDBusLegacy::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) {}

package/simpleble/src/backends/linux_legacy/src/interfaces/Agent1.cpp

@@ -0,0 +1,143 @@
+#include "simplebluezlegacy/interfaces/Agent1.h"
+
+using namespace SimpleBluezLegacy;
+
+const SimpleDBusLegacy::AutoRegisterInterface<Agent1> Agent1::registry{
+    "org.bluez.Agent1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBusLegacy::Holder& options) -> std::shared_ptr<SimpleDBusLegacy::Interface> {
+        return std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<Agent1>(conn, path));
+    }
+    // clang-format on
+};
+
+Agent1::Agent1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path)
+    : SimpleDBusLegacy::Interface(conn, "org.bluez", path, "org.bluez.Agent1") {}
+
+void Agent1::message_handle(SimpleDBusLegacy::Message& msg) {
+    if (msg.get_type() == SimpleDBusLegacy::Message::Type::METHOD_CALL) {
+        // To minimize the amount of repeated code, create a method return object that will be
+        // used to send the reply.
+        SimpleDBusLegacy::Message reply = SimpleDBusLegacy::Message::create_method_return(msg);
+
+        if (msg.get_member() == "Release") {
+            // Nothing to do
+
+        } else if (msg.get_member() == "RequestPinCode") {
+            // std::cout << "Agent1::message_handle() RequestPinCode" << std::endl;
+
+            std::string pin_code = "abc123";
+            if (OnRequestPinCode) {
+                pin_code = OnRequestPinCode();
+            }
+
+            if (!pin_code.empty()) {
+                reply.append_argument(SimpleDBusLegacy::Holder::create_string(pin_code), DBUS_TYPE_STRING_AS_STRING);
+            } else {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "RequestPasskey") {
+            // std::cout << "Agent1::message_handle() RequestPasskey" << std::endl;
+
+            int32_t passkey = 123456;
+            if (OnRequestPasskey) {
+                passkey = OnRequestPasskey();
+            }
+
+            if (passkey >= 0 && passkey <= 999999) {
+                reply.append_argument(SimpleDBusLegacy::Holder::create_uint32(static_cast<uint32_t>(passkey)),
+                                      DBUS_TYPE_UINT32_AS_STRING);
+            } else {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "DisplayPinCode") {
+            // std::cout << "Agent1::message_handle() DisplayPinCode" << std::endl;
+            SimpleDBusLegacy::Holder arg_device = msg.extract();
+            SimpleDBusLegacy::Holder arg_pin_code = msg.extract();
+
+            bool success = true;
+            if (OnDisplayPinCode) {
+                success = OnDisplayPinCode(arg_pin_code.get_string());
+            }
+
+            if (!success) {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "DisplayPasskey") {
+            // std::cout << "Agent1::message_handle() DisplayPasskey" << std::endl;
+            SimpleDBusLegacy::Holder arg_device = msg.extract();
+            SimpleDBusLegacy::Holder arg_passkey = msg.extract();
+            SimpleDBusLegacy::Holder arg_entered = msg.extract();
+
+            if (OnDisplayPasskey) {
+                OnDisplayPasskey(arg_passkey.get_uint32(), arg_entered.get_uint16());
+            }
+
+        } else if (msg.get_member() == "RequestConfirmation") {
+            // std::cout << "Agent1::message_handle() RequestConfirmation" << std::endl;
+            SimpleDBusLegacy::Holder arg_device = msg.extract();
+            SimpleDBusLegacy::Holder arg_passkey = msg.extract();
+
+            bool success = true;
+            if (OnRequestConfirmation) {
+                success = OnRequestConfirmation(arg_passkey.get_uint32());
+            }
+
+            if (!success) {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "RequestAuthorization") {
+            // std::cout << "Agent1::message_handle() RequestAuthorization" << std::endl;
+            SimpleDBusLegacy::Holder arg_device = msg.extract();
+
+            bool success = true;
+            if (OnRequestAuthorization) {
+                success = OnRequestAuthorization();
+            }
+
+            if (!success) {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "AuthorizeService") {
+            // std::cout << "Agent1::message_handle() AuthorizeService" << std::endl;
+
+            SimpleDBusLegacy::Holder arg_device = msg.extract();
+            SimpleDBusLegacy::Holder arg_uuid = msg.extract();
+
+            bool success = true;
+            if (OnAuthorizeService) {
+                success = OnAuthorizeService(arg_uuid.get_string());
+            }
+
+            if (!success) {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "Cancel") {
+            // std::cout << "Agent1::message_handle() Cancel" << std::endl;
+            // NOTE: Due to the blocking nature of this interface, the Cancel method won't
+            //       have any real impact on any of the callbacks, and thus will be ignored.
+
+        } else {
+            // std::cout << "Agent1::message_handle() Unknown method: " << msg.get_member() << std::endl;
+        }
+
+        _conn->send(reply);
+    }
+}
+
+void Agent1::reply_error(SimpleDBusLegacy::Message& msg, const std::string& error_name, const std::string& error_message) {
+    SimpleDBusLegacy::Message reply = SimpleDBusLegacy::Message::create_error(msg, error_name, error_message);
+    _conn->send(reply);
+}

package/simpleble/src/backends/linux_legacy/src/interfaces/AgentManager1.cpp

@@ -0,0 +1,34 @@
+#include <simplebluezlegacy/interfaces/AgentManager1.h>
+
+using namespace SimpleBluezLegacy;
+
+const SimpleDBusLegacy::AutoRegisterInterface<AgentManager1> AgentManager1::registry{
+    "org.bluez.AgentManager1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBusLegacy::Holder& options) -> std::shared_ptr<SimpleDBusLegacy::Interface> {
+        return std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<AgentManager1>(conn, path));
+    }
+    // clang-format on
+};
+
+AgentManager1::AgentManager1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path)
+    : SimpleDBusLegacy::Interface(conn, "org.bluez", path, "org.bluez.AgentManager1") {}
+
+void AgentManager1::RegisterAgent(std::string agent, std::string capability) {
+    auto msg = create_method_call("RegisterAgent");
+    msg.append_argument(SimpleDBusLegacy::Holder::create_object_path(agent), "o");
+    msg.append_argument(SimpleDBusLegacy::Holder::create_string(capability), "s");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void AgentManager1::RequestDefaultAgent(std::string agent) {
+    auto msg = create_method_call("RequestDefaultAgent");
+    msg.append_argument(SimpleDBusLegacy::Holder::create_object_path(agent), "o");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void AgentManager1::UnregisterAgent(std::string agent) {
+    auto msg = create_method_call("UnregisterAgent");
+    msg.append_argument(SimpleDBusLegacy::Holder::create_object_path(agent), "o");
+    _conn->send_with_reply_and_block(msg);
+}

package/simpleble/src/backends/linux_legacy/src/interfaces/Battery1.cpp

@@ -0,0 +1,30 @@
+#include "simplebluezlegacy/interfaces/Battery1.h"
+
+#include <iostream>
+
+using namespace SimpleBluezLegacy;
+
+const SimpleDBusLegacy::AutoRegisterInterface<Battery1> Battery1::registry{
+    "org.bluez.Battery1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBusLegacy::Holder& options) -> std::shared_ptr<SimpleDBusLegacy::Interface> {
+        return std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<Battery1>(conn, path));
+    }
+    // clang-format on
+};
+
+Battery1::Battery1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path)
+    : SimpleDBusLegacy::Interface(conn, "org.bluez", path, "org.bluez.Battery1") {}
+
+Battery1::~Battery1() { OnPercentageChanged.unload(); }
+
+uint8_t Battery1::Percentage() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Percentage"].get_byte();
+}
+
+void Battery1::property_changed(std::string option_name) {
+    if (option_name == "Percentage") {
+        OnPercentageChanged();
+    }
+}

package/simpleble/src/backends/linux_legacy/src/interfaces/Device1.cpp

@@ -0,0 +1,170 @@
+#include "simplebluezlegacy/interfaces/Device1.h"
+
+using namespace SimpleBluezLegacy;
+
+const SimpleDBusLegacy::AutoRegisterInterface<Device1> Device1::registry{
+    "org.bluez.Device1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBusLegacy::Holder& options) -> std::shared_ptr<SimpleDBusLegacy::Interface> {
+        return std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<Device1>(conn, path));
+    }
+    // clang-format on
+};
+
+Device1::Device1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path)
+    : SimpleDBusLegacy::Interface(conn, "org.bluez", path, "org.bluez.Device1") {}
+
+Device1::~Device1() {
+    OnDisconnected.unload();
+    OnServicesResolved.unload();
+}
+
+void Device1::Connect() {
+    auto msg = create_method_call("Connect");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void Device1::Disconnect() {
+    auto msg = create_method_call("Disconnect");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void Device1::Pair() {
+    auto msg = create_method_call("Pair");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void Device1::CancelPairing() {
+    auto msg = create_method_call("CancelPairing");
+    _conn->send_with_reply_and_block(msg);
+}
+
+int16_t Device1::RSSI() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["RSSI"].get_int16();
+}
+
+int16_t Device1::TxPower() { return _tx_power; }
+
+uint16_t Device1::Appearance() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Appearance"].get_uint16();
+}
+
+std::string Device1::Address() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Address"].get_string();
+}
+
+std::string Device1::AddressType() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["AddressType"].get_string();
+}
+
+std::string Device1::Alias() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Alias"].get_string();
+}
+
+std::string Device1::Name() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Name"].get_string();
+}
+
+std::vector<std::string> Device1::UUIDs() {
+    std::scoped_lock lock(_property_update_mutex);
+
+    std::vector<std::string> uuids;
+    for (SimpleDBusLegacy::Holder& uuid : _properties["UUIDs"].get_array()) {
+        uuids.push_back(uuid.get_string());
+    }
+
+    return uuids;
+}
+
+std::map<uint16_t, ByteArray> Device1::ManufacturerData(bool refresh) {
+    if (refresh) {
+        property_refresh("ManufacturerData");
+    }
+
+    // Use the locally cached version to avoid parsing the map multiple times.
+    std::scoped_lock lock(_property_update_mutex);
+    return _manufacturer_data;
+}
+
+std::map<std::string, ByteArray> Device1::ServiceData(bool refresh) {
+    if (refresh) {
+        property_refresh("ServiceData");
+    }
+
+    // Use the locally cached version to avoid parsing the map multiple times.
+    std::scoped_lock lock(_property_update_mutex);
+    return _service_data;
+}
+
+bool Device1::Paired(bool refresh) {
+    if (refresh) {
+        property_refresh("Paired");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Paired"].get_boolean();
+}
+
+bool Device1::Connected(bool refresh) {
+    if (refresh) {
+        property_refresh("Connected");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Connected"].get_boolean();
+}
+
+bool Device1::ServicesResolved(bool refresh) {
+    if (refresh) {
+        property_refresh("ServicesResolved");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["ServicesResolved"].get_boolean();
+}
+
+void Device1::property_changed(std::string option_name) {
+    if (option_name == "Connected") {
+        if (!Connected(false)) {
+            OnDisconnected();
+        }
+    } else if (option_name == "ServicesResolved") {
+        if (ServicesResolved(false)) {
+            OnServicesResolved();
+        }
+    } else if (option_name == "ManufacturerData") {
+        std::scoped_lock lock(_property_update_mutex);
+
+        _manufacturer_data.clear();
+        std::map<uint16_t, SimpleDBusLegacy::Holder> manuf_data = _properties["ManufacturerData"].get_dict_uint16();
+        // Loop through all received keys and store them.
+        for (auto& [key, value_array] : manuf_data) {
+            ByteArray raw_manuf_data;
+            for (auto& elem : value_array.get_array()) {
+                raw_manuf_data.push_back(elem.get_byte());
+            }
+            _manufacturer_data[key] = raw_manuf_data;
+        }
+    } else if (option_name == "ServiceData") {
+        std::scoped_lock lock(_property_update_mutex);
+
+        _service_data.clear();
+        std::map<std::string, SimpleDBusLegacy::Holder> service_data = _properties["ServiceData"].get_dict_string();
+        // Loop through all received keys and store them.
+        for (auto& [key, value_array] : service_data) {
+            ByteArray raw_service_data;
+            for (auto& elem : value_array.get_array()) {
+                raw_service_data.push_back(elem.get_byte());
+            }
+            _service_data[key] = raw_service_data;
+        }
+    } else if (option_name == "TxPower") {
+        _tx_power = _properties["TxPower"].get_int16();
+    }
+}