dbusmessage.cpp

// SPDX-FileCopyrightText: Copyright (C) 2018 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
#include "dbusmessage.h"
 
namespace XSwiftBus
{
 
    CDBusMessage::CDBusMessage(DBusMessage *message) { m_message = dbus_message_ref(message); }
 
    CDBusMessage::CDBusMessage(const CDBusMessage &other)
    {
        m_message = dbus_message_ref(other.m_message);
        m_serial = other.m_serial;
    }
 
    CDBusMessage::CDBusMessage(DBusMessage *message, dbus_uint32_t serial)
    {
        m_message = dbus_message_ref(message);
        m_serial = serial;
    }
 
    CDBusMessage::~CDBusMessage() { dbus_message_unref(m_message); }
 
    CDBusMessage &CDBusMessage::operator=(CDBusMessage other)
    {
        std::swap(m_serial, other.m_serial);
        m_message = dbus_message_ref(other.m_message);
        return *this;
    }
 
    bool CDBusMessage::isMethodCall() const
    {
        return dbus_message_get_type(m_message) == DBUS_MESSAGE_TYPE_METHOD_CALL;
    }
 
    bool CDBusMessage::wantsReply() const { return !dbus_message_get_no_reply(m_message); }
 
    std::string CDBusMessage::getSender() const
    {
        const char *sender = dbus_message_get_sender(m_message);
        return sender ? std::string(sender) : std::string();
    }
 
    dbus_uint32_t CDBusMessage::getSerial() const { return dbus_message_get_serial(m_message); }
 
    std::string_view CDBusMessage::getInterfaceName() const { return dbus_message_get_interface(m_message); }
 
    std::string_view CDBusMessage::getObjectPath() const { return dbus_message_get_path(m_message); }
 
    std::string_view CDBusMessage::getMethodName() const { return dbus_message_get_member(m_message); }
 
    void CDBusMessage::beginArgumentWrite() { dbus_message_iter_init_append(m_message, &m_messageIterator); }
 
    void CDBusMessage::appendArgument(bool value)
    {
        dbus_bool_t boolean = value ? 1 : 0;
        dbus_message_iter_append_basic(&m_messageIterator, DBUS_TYPE_BOOLEAN, &boolean);
    }
 
    void CDBusMessage::appendArgument(const char *value)
    {
        dbus_message_iter_append_basic(&m_messageIterator, DBUS_TYPE_STRING, &value);
    }
 
    void CDBusMessage::appendArgument(const std::string &value)
    {
        const char *ptr = value.c_str();
        dbus_message_iter_append_basic(&m_messageIterator, DBUS_TYPE_STRING, &ptr);
    }
 
    void CDBusMessage::appendArgument(int value)
    {
        dbus_int32_t i = value;
        dbus_message_iter_append_basic(&m_messageIterator, DBUS_TYPE_INT32, &i);
    }
 
    void CDBusMessage::appendArgument(double value)
    {
        dbus_message_iter_append_basic(&m_messageIterator, DBUS_TYPE_DOUBLE, &value);
    }
 
    void CDBusMessage::appendArgument(const std::vector<bool> &array)
    {
        // array.data() not existing for bool
        // changing dbus_message_iter_open_container here affects DBus signature
        // using int16 creates signature "n", mismatch on swift side
        // using int32 creates signature "i"
        // there are also xml files for the signature: src/xswiftbus/org.swift_project.xswiftbus.traffic.xml
        // discussion: https://discordapp.com/channels/539048679160676382/539925070550794240/698552502831939676
 
        DBusMessageIter arrayIterator;
        dbus_message_iter_open_container(&m_messageIterator, DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN_AS_STRING,
                                         &arrayIterator);
 
        const std::vector<unsigned> ints(array.begin(), array.end());
        const unsigned *ptr = ints.data();
        dbus_message_iter_append_fixed_array(&arrayIterator, DBUS_TYPE_BOOLEAN, &ptr, static_cast<int>(array.size()));
        dbus_message_iter_close_container(&m_messageIterator, &arrayIterator);
    }
 
    void CDBusMessage::appendArgument(const std::vector<double> &array)
    {
        DBusMessageIter arrayIterator;
        dbus_message_iter_open_container(&m_messageIterator, DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE_AS_STRING,
                                         &arrayIterator);
        const double *ptr = array.data();
        dbus_message_iter_append_fixed_array(&arrayIterator, DBUS_TYPE_DOUBLE, &ptr, static_cast<int>(array.size()));
        dbus_message_iter_close_container(&m_messageIterator, &arrayIterator);
    }
 
    void CDBusMessage::appendArgument(const std::vector<std::string> &array)
    {
        DBusMessageIter arrayIterator;
        dbus_message_iter_open_container(&m_messageIterator, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING,
                                         &arrayIterator);
        for (const auto &i : array)
        {
            const char *ptr = i.c_str();
            dbus_message_iter_append_basic(&arrayIterator, DBUS_TYPE_STRING, &ptr);
        }
        dbus_message_iter_close_container(&m_messageIterator, &arrayIterator);
    }
 
    void CDBusMessage::beginArgumentRead() { dbus_message_iter_init(m_message, &m_messageIterator); }
 
    void CDBusMessage::getArgument(int &value)
    {
        if (dbus_message_iter_get_arg_type(&m_messageIterator) != DBUS_TYPE_INT32) { return; }
        dbus_int32_t i;
        dbus_message_iter_get_basic(&m_messageIterator, &i);
        value = i;
        dbus_message_iter_next(&m_messageIterator);
    }
 
    void CDBusMessage::getArgument(bool &value)
    {
        if (dbus_message_iter_get_arg_type(&m_messageIterator) != DBUS_TYPE_BOOLEAN) { return; }
        dbus_bool_t v;
        dbus_message_iter_get_basic(&m_messageIterator, &v);
        if (v == TRUE) { value = true; }
        else { value = false; }
        dbus_message_iter_next(&m_messageIterator);
    }
 
    void CDBusMessage::getArgument(double &value)
    {
        if (dbus_message_iter_get_arg_type(&m_messageIterator) != DBUS_TYPE_DOUBLE) { return; }
        dbus_message_iter_get_basic(&m_messageIterator, &value);
        dbus_message_iter_next(&m_messageIterator);
    }
 
    void CDBusMessage::getArgument(std::string &value)
    {
        const char *str = nullptr;
        if (dbus_message_iter_get_arg_type(&m_messageIterator) != DBUS_TYPE_STRING) { return; }
        dbus_message_iter_get_basic(&m_messageIterator, &str);
        dbus_message_iter_next(&m_messageIterator);
        value = std::string(str);
    }
 
    void CDBusMessage::getArgument(std::vector<int> &value)
    {
        DBusMessageIter arrayIterator;
        dbus_message_iter_recurse(&m_messageIterator, &arrayIterator);
        do {
            if (dbus_message_iter_get_arg_type(&arrayIterator) != DBUS_TYPE_INT32) { return; }
            dbus_int32_t i;
            dbus_message_iter_get_basic(&arrayIterator, &i);
            value.push_back(i);
        }
        while (dbus_message_iter_next(&arrayIterator));
        dbus_message_iter_next(&m_messageIterator);
    }
 
    void CDBusMessage::getArgument(std::vector<bool> &value)
    {
        if (dbus_message_iter_get_arg_type(&m_messageIterator) != DBUS_TYPE_ARRAY) { return; }
        DBusMessageIter arrayIterator;
        dbus_message_iter_recurse(&m_messageIterator, &arrayIterator);
        do {
            if (dbus_message_iter_get_arg_type(&arrayIterator) != DBUS_TYPE_BOOLEAN) { return; }
            dbus_bool_t b;
            dbus_message_iter_get_basic(&arrayIterator, &b);
            if (b == TRUE) { value.push_back(true); }
            else { value.push_back(false); }
        }
        while (dbus_message_iter_next(&arrayIterator));
        dbus_message_iter_next(&m_messageIterator);
    }
 
    void CDBusMessage::getArgument(std::vector<double> &value)
    {
        DBusMessageIter arrayIterator;
        dbus_message_iter_recurse(&m_messageIterator, &arrayIterator);
        do {
            if (dbus_message_iter_get_arg_type(&arrayIterator) != DBUS_TYPE_DOUBLE) { return; }
            double d;
            dbus_message_iter_get_basic(&arrayIterator, &d);
            value.push_back(d);
        }
        while (dbus_message_iter_next(&arrayIterator));
        dbus_message_iter_next(&m_messageIterator);
    }
 
    void CDBusMessage::getArgument(std::vector<std::string> &value)
    {
        DBusMessageIter arrayIterator;
        dbus_message_iter_recurse(&m_messageIterator, &arrayIterator);
        do {
            if (dbus_message_iter_get_arg_type(&arrayIterator) != DBUS_TYPE_STRING) { return; }
            const char *str = nullptr;
            dbus_message_iter_get_basic(&arrayIterator, &str);
            value.push_back(std::string(str));
        }
        while (dbus_message_iter_next(&arrayIterator));
        dbus_message_iter_next(&m_messageIterator);
    }
 
    CDBusMessage CDBusMessage::createSignal(const std::string &path, const std::string &interfaceName,
                                            const std::string &signalName)
    {
        DBusMessage *signal = dbus_message_new_signal(path.c_str(), interfaceName.c_str(), signalName.c_str());
        return CDBusMessage(signal);
    }
 
    CDBusMessage CDBusMessage::createReply(const std::string &destination, dbus_uint32_t serial)
    {
        DBusMessage *reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
        dbus_message_set_no_reply(reply, TRUE);
        if (!destination.empty()) { dbus_message_set_destination(reply, destination.c_str()); }
        dbus_message_set_reply_serial(reply, serial);
        CDBusMessage msg(reply);
        dbus_message_unref(reply);
        return msg;
    }
 
} // namespace XSwiftBus