dbusconnection.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_DBUSCONNECTION_H
#define SWIFT_SIM_XSWIFTBUS_DBUSCONNECTION_H
 
#ifndef NOMINMAX
// windows.h min/max might be imported via dbus.h
#    define NOMINMAX
#endif
 
#include <dbus/dbus.h>
#include <event2/event.h>
 
#include <memory>
#include <string>
#include <unordered_map>
 
#include "dbuscallbacks.h"
#include "dbusdispatcher.h"
#include "dbuserror.h"
#include "dbusmessage.h"
 
namespace XSwiftBus
{
 
    class CDBusObject;
 
    class CDBusConnection : public IDispatchable
    {
    public:
        enum BusType
        {
            SessionBus
        };
 
        using DisconnectedCallback = std::function<void()>;
 
        CDBusConnection();
 
        CDBusConnection(DBusConnection *connection);
 
        ~CDBusConnection() override;
 
        // The ones below are not implemented yet.
        // If you need them, make sure that connection reference count is correct
        CDBusConnection(const CDBusConnection &) = delete;
        CDBusConnection &operator=(const CDBusConnection &) = delete;
 
        bool connect(BusType type);
 
        void setDispatcher(CDBusDispatcher *dispatcher);
 
        void requestName(const std::string &name);
 
        bool isConnected() const;
 
        void registerDisconnectedCallback(CDBusObject *obj, DisconnectedCallback func);
 
        void unregisterDisconnectedCallback(CDBusObject *obj);
 
        void registerObjectPath(CDBusObject *object, const std::string &interfaceName, const std::string &objectPath,
                                const DBusObjectPathVTable &dbusObjectPathVTable);
 
        void sendMessage(const CDBusMessage &message);
 
        void close();
 
        CDBusError lastError() const { return m_lastError; }
 
    protected:
        // cppcheck-suppress virtualCallInConstructor
        virtual void dispatch() override final;
 
    private:
        void setDispatchStatus(DBusConnection *connection, DBusDispatchStatus status);
        static void setDispatchStatus(DBusConnection *connection, DBusDispatchStatus status, void *data);
        static DBusHandlerResult filterDisconnectedFunction(DBusConnection *connection, DBusMessage *message,
                                                            void *data);
 
        struct DBusConnectionDeleter
        {
            void operator()(DBusConnection *obj) const { dbus_connection_unref(obj); }
        };
 
        CDBusDispatcher *m_dispatcher = nullptr;
        std::unique_ptr<DBusConnection, DBusConnectionDeleter> m_connection;
        CDBusError m_lastError;
        std::unordered_map<CDBusObject *, DisconnectedCallback> m_disconnectedCallbacks;
    };
 
} // namespace XSwiftBus
 
#endif // SWIFT_SIM_XSWIFTBUS_DBUSCONNECTION_H