From abf15e4caf880b87181f2d8e92226018846f22c5 Mon Sep 17 00:00:00 2001 From: Qijia Liu Date: Sun, 27 Oct 2024 10:42:52 -0400 Subject: [PATCH] implement stub EventLoop that can be replaced --- src/lib/fcitx-utils/CMakeLists.txt | 9 +- src/lib/fcitx-utils/event_impl.h | 29 ++++++ src/lib/fcitx-utils/event_stub.cpp | 154 +++++++++++++++++++++++++++++ 3 files changed, 189 insertions(+), 3 deletions(-) create mode 100644 src/lib/fcitx-utils/event_impl.h create mode 100644 src/lib/fcitx-utils/event_stub.cpp diff --git a/src/lib/fcitx-utils/CMakeLists.txt b/src/lib/fcitx-utils/CMakeLists.txt index 8cb4ef838..d88f1154f 100644 --- a/src/lib/fcitx-utils/CMakeLists.txt +++ b/src/lib/fcitx-utils/CMakeLists.txt @@ -27,14 +27,16 @@ if (ENABLE_DBUS) endif() endif() -if (NOT TARGET Systemd::Systemd) +if (TARGET Systemd::Systemd) set(FCITX_UTILS_SOURCES ${FCITX_UTILS_SOURCES} - event_libuv.cpp) + event_sdevent.cpp) +elseif (EMSCRIPTEN) + list(APPEND FCITX_UTILS_SOURCES event_stub.cpp) else() set(FCITX_UTILS_SOURCES ${FCITX_UTILS_SOURCES} - event_sdevent.cpp) + event_libuv.cpp) endif() set(FCITX_UTILS_SOURCES @@ -70,6 +72,7 @@ set(FCITX_UTILS_HEADERS color.h i18nstring.h event.h + event_impl.h eventdispatcher.h library.h cutf8.h diff --git a/src/lib/fcitx-utils/event_impl.h b/src/lib/fcitx-utils/event_impl.h new file mode 100644 index 000000000..ce86ddc01 --- /dev/null +++ b/src/lib/fcitx-utils/event_impl.h @@ -0,0 +1,29 @@ +/* + * SPDX-FileCopyrightText: 2024 Qijia Liu + * + * SPDX-License-Identifier: LGPL-2.1-or-later + * + */ +#ifndef _FCITX_UTILS_EVENT_IMPL_H_ +#define _FCITX_UTILS_EVENT_IMPL_H_ + +#include +namespace fcitx { +class FCITXUTILS_EXPORT EventLoopImpl { +public: + EventLoopImpl() = default; + virtual ~EventLoopImpl() = default; + virtual std::unique_ptr + addIOEvent(int fd, IOEventFlags flags, IOCallback callback); + virtual std::unique_ptr + addTimeEvent(clockid_t clock, uint64_t usec, uint64_t accuracy, + TimeCallback callback); + virtual std::unique_ptr addExitEvent(EventCallback callback); + virtual std::unique_ptr addDeferEvent(EventCallback callback); + virtual std::unique_ptr addPostEvent(EventCallback callback); +}; + +FCITXUTILS_EXPORT void setEventLoopImpl(std::unique_ptr factory); +} // namespace fcitx + +#endif // _FCITX_UTILS_EVENT_H_ diff --git a/src/lib/fcitx-utils/event_stub.cpp b/src/lib/fcitx-utils/event_stub.cpp new file mode 100644 index 000000000..84e828700 --- /dev/null +++ b/src/lib/fcitx-utils/event_stub.cpp @@ -0,0 +1,154 @@ +/* + * SPDX-FileCopyrightText: 2024 Qijia Liu + * + * SPDX-License-Identifier: LGPL-2.1-or-later + * + */ +#include "fcitx-utils/event.h" +#include "fcitx-utils/log.h" +#include "event_impl.h" + +namespace fcitx { + +template +struct StubEventSourceBase : public Interface { +public: + ~StubEventSourceBase() override {} + + bool isEnabled() const override { return false; } + + void setEnabled(bool enabled) override { FCITX_UNUSED(enabled); } + + bool isOneShot() const override { return false; } + + void setOneShot() override {} +}; + +struct StubEventSource : public StubEventSourceBase { + StubEventSource() {} +}; + +struct StubEventSourceIO : public StubEventSourceBase { + StubEventSourceIO() {} + + int fd() const override { return 0; } + + void setFd(int fd) override { FCITX_UNUSED(fd); } + + IOEventFlags events() const override { return IOEventFlag::In; } + + void setEvents(IOEventFlags flags) override { FCITX_UNUSED(flags); } + + IOEventFlags revents() const override { return IOEventFlag::In; } +}; + +struct StubEventSourceTime : public StubEventSourceBase { + StubEventSourceTime() {} + + uint64_t time() const override { return 0; } + + void setTime(uint64_t time) override { FCITX_UNUSED(time); } + + uint64_t accuracy() const override { return 0; } + + void setAccuracy(uint64_t time) override { FCITX_UNUSED(time); } + + clockid_t clock() const override { return 0; } +}; + +static std::shared_ptr eventLoopImpl = nullptr; + +void setEventLoopImpl(std::unique_ptr impl) { + eventLoopImpl = std::move(impl); +} + +class EventLoopPrivate { +public: + EventLoopPrivate() { + if (!eventLoopImpl) { + FCITX_WARN() << "Using stub event loop implementation."; + eventLoopImpl = std::make_shared(); + } + impl_ = eventLoopImpl; + } + ~EventLoopPrivate() {} + + std::shared_ptr impl_; +}; + +EventLoop::EventLoop() : d_ptr(std::make_unique()) {} + +EventLoop::~EventLoop() = default; + +const char *EventLoop::impl() { return "stub"; } + +void *EventLoop::nativeHandle() { return nullptr; } + +bool EventLoop::exec() { return true; } + +void EventLoop::exit() {} + +std::unique_ptr EventLoop::addIOEvent(int fd, IOEventFlags flags, + IOCallback callback) { + FCITX_D(); + return d->impl_->addIOEvent(fd, flags, std::move(callback)); +} + +std::unique_ptr +EventLoop::addTimeEvent(clockid_t clock, uint64_t usec, uint64_t accuracy, + TimeCallback callback) { + FCITX_D(); + return d->impl_->addTimeEvent(clock, usec, accuracy, std::move(callback)); +} + +std::unique_ptr EventLoop::addExitEvent(EventCallback callback) { + FCITX_D(); + return d->impl_->addExitEvent(std::move(callback)); +} + +std::unique_ptr EventLoop::addDeferEvent(EventCallback callback) { + FCITX_D(); + return d->impl_->addDeferEvent(std::move(callback)); +} + +std::unique_ptr EventLoop::addPostEvent(EventCallback callback) { + FCITX_D(); + return d->impl_->addPostEvent(std::move(callback)); +} + +std::unique_ptr +EventLoopImpl::addIOEvent(int fd, IOEventFlags flags, IOCallback callback) { + FCITX_UNUSED(fd); + FCITX_UNUSED(flags); + FCITX_UNUSED(callback); + return std::make_unique(); +} + +std::unique_ptr +EventLoopImpl::addTimeEvent(clockid_t clock, uint64_t usec, uint64_t accuracy, + TimeCallback callback) { + FCITX_UNUSED(clock); + FCITX_UNUSED(usec); + FCITX_UNUSED(accuracy); + FCITX_UNUSED(callback); + return std::make_unique(); +} + +std::unique_ptr +EventLoopImpl::addExitEvent(EventCallback callback) { + FCITX_UNUSED(callback); + return std::make_unique(); +} + +std::unique_ptr +EventLoopImpl::addDeferEvent(EventCallback callback) { + FCITX_UNUSED(callback); + return std::make_unique(); +} + +std::unique_ptr +EventLoopImpl::addPostEvent(EventCallback callback) { + FCITX_UNUSED(callback); + return std::make_unique(); +} +} // namespace fcitx