loop.cpp

/*
 *     .============.
 *    //  M A K E  / \
 *   //  C++ DEV  /   \
 *  //  E A S Y  /  \/ \
 * ++ ----------.  \/\  .
 *  \\     \     \ /\  /
 *   \\     \     \   /
 *    \\     \     \ /
 *     -============'
 *
 * Copyright (c) 2023 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */

#include "loop.h"

#include <tbox/base/log.h>
#include <tbox/base/assert.h>
#include <tbox/event/fd_event.h>
#include <tbox/event/timer_event.h>

namespace tbox {
namespace dbus {

namespace {

class Context {
 public:
  Context(event::Loop *loop, DBusConnection *dbus_conn)
    : loop_(loop), dbus_conn_(dbus_conn)
  {
      ::dbus_connection_ref(dbus_conn_);
  }

  ~Context()
  {
      ::dbus_connection_unref(dbus_conn_);
  }

  inline event::Loop* loop() const { return loop_; }
  inline DBusConnection* dbus_conn() const { return dbus_conn_; }

 private:
  event::Loop *loop_;
  DBusConnection *dbus_conn_;
};

void _ContextDeleter(void *p)
{
    TBOX_ASSERT(p != nullptr);
    delete static_cast<Context*>(p);
}

//////////////////////////////////////////////////////////////////////
// 异步派发动作
//////////////////////////////////////////////////////////////////////

void _QueueDispatch(Context *ctx, DBusDispatchStatus status)
{
    if (status == DBUS_DISPATCH_DATA_REMAINS) {
        auto dbus_conn = ctx->dbus_conn();
        dbus_connection_ref(dbus_conn);
        ctx->loop()->runNext(
            [dbus_conn] {
                while (dbus_connection_dispatch(dbus_conn) == DBUS_DISPATCH_DATA_REMAINS);
                dbus_connection_unref(dbus_conn);
            },
            "dbus_dispatch"
        );
    }
}

void _DispatchStatus(DBusConnection *dbus_conn, DBusDispatchStatus status, void *data)
{
    TBOX_ASSERT(dbus_conn != nullptr);
    TBOX_ASSERT(data != nullptr);

    if (dbus_connection_get_is_connected(dbus_conn)) {
        Context *ctx = static_cast<Context*>(data);
        _QueueDispatch(ctx, status);
    }
}

//////////////////////////////////////////////////////////////////////////////
// 文件读写事件
//////////////////////////////////////////////////////////////////////////////

class WatchHandler {
  public:
    WatchHandler(Context *ctx, DBusWatch *dbus_watch)
      : ctx_(ctx)
      , dbus_watch_(dbus_watch)
      , tbox_fd_(ctx->loop()->newFdEvent("dbus_watch"))
    {
        auto fd = ::dbus_watch_get_unix_fd(dbus_watch);
        auto dbus_flags = ::dbus_watch_get_flags(dbus_watch);

        //! 仅允许读事件或写事件中二选一，不能同时两种事件
        TBOX_ASSERT((dbus_flags & (dbus_flags - 1)) == 0);

        short tbox_flags = 0;
        event::Event::Mode mode;

        if (dbus_flags & DBUS_WATCH_READABLE) {
            tbox_flags |= tbox::event::FdEvent::kReadEvent;
            mode = event::Event::Mode::kPersist;
        }

        if (dbus_flags & DBUS_WATCH_WRITABLE) {
            tbox_flags |= tbox::event::FdEvent::kWriteEvent;
            mode = event::Event::Mode::kOneshot;
        }

        tbox_fd_->initialize(fd, tbox_flags, mode);
        tbox_fd_->setCallback([this](short events) { onWatch(events); });
    }

    ~WatchHandler()
    {
        delete tbox_fd_;
    }

    void enable() { tbox_fd_->enable(); }
    void disable() { tbox_fd_->disable(); }

  protected:
    void onWatch(short events)
    {
        unsigned int dbus_flags = 0;
        if (events & tbox::event::FdEvent::kReadEvent)
            dbus_flags |= DBUS_WATCH_READABLE;
        if (events & tbox::event::FdEvent::kWriteEvent)
            dbus_flags |= DBUS_WATCH_WRITABLE;
        if (events & tbox::event::FdEvent::kExceptEvent)
            dbus_flags |= DBUS_WATCH_ERROR;

        dbus_watch_handle(dbus_watch_, dbus_flags);

        dbus_connection_ref(ctx_->dbus_conn());
        auto status = dbus_connection_get_dispatch_status(ctx_->dbus_conn());
        _QueueDispatch(ctx_, status);
        dbus_connection_unref(ctx_->dbus_conn());
    }

  private:
    Context *ctx_;
    DBusWatch *dbus_watch_;
    event::FdEvent *tbox_fd_;
};

void _WatchHandlerDeleter(void *p)
{
    TBOX_ASSERT(p != nullptr);
    delete static_cast<WatchHandler*>(p);
}

dbus_bool_t _AddWatch(DBusWatch *watch, void *data)
{
    TBOX_ASSERT(watch != nullptr);
    TBOX_ASSERT(data != nullptr);

    auto handler = static_cast<WatchHandler*>(::dbus_watch_get_data(watch));
    if (handler == nullptr) {
        auto ctx = static_cast<Context*>(data);
        handler = new WatchHandler(ctx, watch);
        ::dbus_watch_set_data(watch, handler, _WatchHandlerDeleter);
    }

    handler->enable();
    return true;
}

void _RemoveWatch(DBusWatch *watch, void *)
{
    TBOX_ASSERT(watch != nullptr);

    auto handler = static_cast<WatchHandler*>(::dbus_watch_get_data(watch));
    TBOX_ASSERT(handler != nullptr);

    handler->disable();
}

void _ToggledWatch(DBusWatch *watch, void *)
{
    TBOX_ASSERT(watch != nullptr);

    auto handler = static_cast<WatchHandler*>(::dbus_watch_get_data(watch));
    TBOX_ASSERT(handler != nullptr);

    if (::dbus_watch_get_enabled(watch))
        handler->enable();
    else
        handler->disable();
}

//////////////////////////////////////////////////////////////////////
// 超时事件
//////////////////////////////////////////////////////////////////////

class TimeoutHandler {
  public:
    TimeoutHandler(event::Loop *loop, DBusTimeout *dbus_timeout)
      : tbox_timer_(loop->newTimerEvent("dbus_timeout"))
      , dbus_timeout_(dbus_timeout)
    {
        int interval_ms = ::dbus_timeout_get_interval(dbus_timeout);
        tbox_timer_->initialize(std::chrono::milliseconds(interval_ms), event::Event::Mode::kOneshot);
        tbox_timer_->setCallback([this] { onTimeout(); });
    }

    ~TimeoutHandler()
    {
        tbox_timer_->disable();
        delete tbox_timer_;
    }

    void enable() { tbox_timer_->enable(); }
    void disable() { tbox_timer_->disable(); }

  protected:
    void onTimeout()
    {
        if (dbus_timeout_get_enabled(dbus_timeout_)) {
            dbus_timeout_handle(dbus_timeout_);
        }
    }

  private:
    event::TimerEvent *tbox_timer_;
    DBusTimeout *dbus_timeout_;
};

void _TimeoutHandlerDeleter(void *p)
{
    TBOX_ASSERT(p != nullptr);
    delete static_cast<TimeoutHandler*>(p);
}

dbus_bool_t _AddTimeout(DBusTimeout *timeout, void *data)
{
    TBOX_ASSERT(timeout != nullptr);
    TBOX_ASSERT(data != nullptr);

    auto handler = static_cast<TimeoutHandler*>(::dbus_timeout_get_data(timeout));
    if (handler == nullptr) {
        auto ctx = static_cast<Context*>(data);
        handler = new TimeoutHandler(ctx->loop(), timeout);
        ::dbus_timeout_set_data(timeout, handler, _TimeoutHandlerDeleter);
    }

    handler->enable();
    return true;
}

void _RemoveTimeout(DBusTimeout *timeout, void *)
{
    TBOX_ASSERT(timeout != nullptr);

    auto handler = static_cast<TimeoutHandler*>(::dbus_timeout_get_data(timeout));
    TBOX_ASSERT(handler != nullptr);

    handler->disable();
}

void _ToggledTimeout(DBusTimeout *timeout, void *)
{
    TBOX_ASSERT(timeout != nullptr);

    auto handler = static_cast<TimeoutHandler*>(::dbus_timeout_get_data(timeout));
    TBOX_ASSERT(handler != nullptr);

    if (::dbus_timeout_get_enabled(timeout))
        handler->enable();
    else
        handler->disable();
}

}

//////////////////////////////////////////////////////////////////////
// AttachLoop() 与 DetachLoop() 实现
//////////////////////////////////////////////////////////////////////

void AttachLoop(DBusConnection *dbus_conn, event::Loop *loop)
{
    TBOX_ASSERT(dbus_conn != nullptr);
    TBOX_ASSERT(loop != nullptr);

    //! 注册文件读写事件的创建与删除方法函数与数据
    auto watch_ctx = new Context(loop, dbus_conn);
    ::dbus_connection_set_watch_functions(dbus_conn,
            _AddWatch, _RemoveWatch, _ToggledWatch,
            watch_ctx, _ContextDeleter);

    //! 注册超时事件的创建与删除方法函数与数据
    auto timeout_ctx = new Context(loop, dbus_conn);
    ::dbus_connection_set_timeout_functions(dbus_conn,
            _AddTimeout, _RemoveTimeout, _ToggledTimeout,
            timeout_ctx, _ContextDeleter);

    //! 注册异步派发动作的方法函数与数据
    auto dispatch_ctx = new Context(loop, dbus_conn);
    ::dbus_connection_set_dispatch_status_function(dbus_conn,
            _DispatchStatus, dispatch_ctx, _ContextDeleter);

    //! 尝试处理队列中的事件
    auto dispatch_status = dbus_connection_get_dispatch_status(dbus_conn);
    _QueueDispatch(dispatch_ctx, dispatch_status);
}

void DetachLoop(DBusConnection *dbus_conn)
{
    TBOX_ASSERT(dbus_conn != nullptr);

    //! 逐一清空AttachLoop()中设置的内容
    ::dbus_connection_set_watch_functions(dbus_conn, nullptr, nullptr, nullptr, nullptr, nullptr);
    ::dbus_connection_set_timeout_functions(dbus_conn, nullptr, nullptr, nullptr, nullptr, nullptr);
    ::dbus_connection_set_dispatch_status_function(dbus_conn, nullptr, nullptr, nullptr);
}

}
}