dbusobject.h

// SPDX-FileCopyrightText: Copyright (C) 2018 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
#ifndef SWIFT_SIM_XSWIFTBUS_DBUSOBJECT_H
#define SWIFT_SIM_XSWIFTBUS_DBUSOBJECT_H
// clang-format off
#include <deque>
#include <mutex>
 
#include "dbusconnection.h"
#include "settings.h"
 
#include <XPLM/XPLMDisplay.h>
// clang-format on
 
namespace XSwiftBus
{
    class CDBusObject : public CSettingsAware
    {
    public:
        CDBusObject(CSettingsProvider *settingsProvider);
 
        virtual ~CDBusObject();
 
        void setDBusConnection(const std::shared_ptr<CDBusConnection> &dbusConnection);
 
        void registerDBusObjectPath(const std::string &interfaceName, const std::string &objectPath);
 
    protected:
        virtual void dbusConnectedHandler() {}
 
        virtual DBusHandlerResult dbusMessageHandler(const CDBusMessage &message) = 0;
 
        virtual void dbusDisconnectedHandler() {}
 
        void sendDBusSignal(const std::string &name);
 
        void sendDBusMessage(const CDBusMessage &message);
 
        void maybeSendEmptyDBusReply(bool wantsReply, const std::string &destination, dbus_uint32_t serial);
 
        template <typename T>
        void sendDBusReply(const std::string &destination, dbus_uint32_t serial, const T &argument)
        {
            CDBusMessage reply = CDBusMessage::createReply(destination, serial);
            reply.beginArgumentWrite();
            reply.appendArgument(argument);
            m_dbusConnection->sendMessage(reply);
        }
 
        template <typename T>
        void sendDBusReply(const std::string &destination, dbus_uint32_t serial, const std::vector<T> &array)
        {
            CDBusMessage reply = CDBusMessage::createReply(destination, serial);
            reply.beginArgumentWrite();
            reply.appendArgument(array);
            m_dbusConnection->sendMessage(reply);
        }
 
        void queueDBusCall(const std::function<void()> &func);
 
        void invokeQueuedDBusCalls();
 
    private:
        static void dbusObjectPathUnregisterFunction(DBusConnection *connection, void *data);
        static DBusHandlerResult dbusObjectPathMessageFunction(DBusConnection *connection, DBusMessage *message,
                                                               void *data);
 
        std::shared_ptr<CDBusConnection> m_dbusConnection;
        std::string m_interfaceName;
        std::string m_objectPath;
 
        std::mutex m_mutex; 
        std::deque<std::function<void()>> m_qeuedDBusCalls;
 
        const DBusObjectPathVTable m_dbusObjectPathVTable = {
            dbusObjectPathUnregisterFunction, dbusObjectPathMessageFunction, nullptr, nullptr, nullptr, nullptr
        };
    };
} // namespace XSwiftBus
 
#endif // SWIFT_SIM_XSWIFTBUS_DBUSOBJECT_H