Create a shared event dispatcher for instance, so we can save some re…

…source Every EventDispatcher will create a new pipe, which is not really need if EventDispatcher is shared.
fcitx · Apr 21, 2024 · c069a4c · c069a4c
1 parent 6824c95
commit c069a4c
Show file tree

Hide file tree

Showing 9 changed files with 38 additions and 21 deletions.
diff --git a/src/lib/fcitx/instance.cpp b/src/lib/fcitx/instance.cpp
@@ -10,6 +10,7 @@
 #include <signal.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <memory>
 #include <stdexcept>
 #include <unordered_map>
 #include <utility>
@@ -18,6 +19,7 @@
 #include "fcitx-config/iniparser.h"
 #include "fcitx-utils/capabilityflags.h"
 #include "fcitx-utils/event.h"
+#include "fcitx-utils/eventdispatcher.h"
 #include "fcitx-utils/i18n.h"
 #include "fcitx-utils/log.h"
 #include "fcitx-utils/misc.h"
@@ -641,9 +643,10 @@ Instance::Instance(int argc, char **argv) {
     }
 
     // we need fork before this
-    d_ptr.reset(new InstancePrivate(this));
+    d_ptr = std::make_unique<InstancePrivate>(this);
     FCITX_D();
     d->arg_ = arg;
+    d->eventDispatcher_.attach(&d->eventLoop_);
     d->addonManager_.setInstance(this);
     d->addonManager_.setAddonOptions(arg.addonOptions_);
     d->icManager_.setInstance(this);
@@ -1519,6 +1522,11 @@ EventLoop &Instance::eventLoop() {
     return d->eventLoop_;
 }
 
+EventDispatcher &Instance::eventDispatcher() {
+    FCITX_D();
+    return d->eventDispatcher_;
+}
+
 InputContextManager &Instance::inputContextManager() {
     FCITX_D();
     return d->icManager_;

diff --git a/src/lib/fcitx/instance.h b/src/lib/fcitx/instance.h
@@ -13,6 +13,7 @@
 #include <fcitx/event.h>
 #include <fcitx/globalconfig.h>
 #include <fcitx/text.h>
+#include "fcitx-utils/eventdispatcher.h"
 #include "fcitxcore_export.h"
 
 #define FCITX_INVALID_COMPOSE_RESULT 0xffffffff
@@ -154,6 +155,15 @@ class FCITXCORE_EXPORT Instance : public ConnectableObject {
     /// Get the fcitx event loop.
     EventLoop &eventLoop();
 
+    /**
+     * Return a shared event dispatcher that is already attached to instance's
+     * event loop.
+     *
+     * @return shared event dispatcher.
+     * @since 5.1.9
+     */
+    EventDispatcher &eventDispatcher();
+
     /// Get the addon manager.
     AddonManager &addonManager();
 

diff --git a/src/lib/fcitx/instance_p.h b/src/lib/fcitx/instance_p.h
@@ -12,6 +12,7 @@
 #include <string>
 #include <unordered_map>
 #include "fcitx-utils/event.h"
+#include "fcitx-utils/eventdispatcher.h"
 #include "fcitx-utils/handlertable.h"
 #include "fcitx-utils/misc.h"
 #include "fcitx-utils/trackableobject.h"
@@ -161,6 +162,7 @@ class InstancePrivate : public QPtrHolder<Instance> {
                                            : InputMethodMode::PhysicalKeyboard;
 
     EventLoop eventLoop_;
+    EventDispatcher eventDispatcher_;
     std::unique_ptr<EventSourceIO> signalPipeEvent_;
     std::unique_ptr<EventSourceTime> preloadInputMethodEvent_;
     std::unique_ptr<EventSource> exitEvent_;

diff --git a/src/modules/clipboard/waylandclipboard.cpp b/src/modules/clipboard/waylandclipboard.cpp
@@ -170,7 +170,8 @@ void DataOffer::receiveDataForMime(const std::string &mime,
 
 DataDevice::DataDevice(WaylandClipboard *clipboard,
                        wayland::ZwlrDataControlDeviceV1 *device)
-    : clipboard_(clipboard), device_(device), thread_(clipboard_->eventLoop()) {
+    : clipboard_(clipboard), device_(device),
+      thread_(clipboard_->parent()->instance()->eventDispatcher()) {
     conns_.emplace_back(device_->dataOffer().connect(
         [this](wayland::ZwlrDataControlOfferV1 *offer) {
             new DataOffer(offer, *clipboard_->parent()
@@ -271,10 +272,6 @@ void WaylandClipboard::refreshSeat() {
     }
 }
 
-EventLoop *WaylandClipboard::eventLoop() {
-    return &parent_->instance()->eventLoop();
-}
-
 void WaylandClipboard::setClipboard(const std::string &str, bool password) {
     parent_->setClipboardV2(name_, str, password);
 }

diff --git a/src/modules/clipboard/waylandclipboard.h b/src/modules/clipboard/waylandclipboard.h
@@ -39,7 +39,8 @@ struct DataOfferTask {
 
 class DataReaderThread {
 public:
-    DataReaderThread(EventLoop *main) { dispatcherToMain_.attach(main); }
+    DataReaderThread(EventDispatcher &dispatcherToMain)
+        : dispatcherToMain_(dispatcherToMain) {}
 
     ~DataReaderThread() {
         if (thread_ && thread_->joinable()) {
@@ -65,7 +66,7 @@ class DataReaderThread {
 private:
     void realRun();
 
-    EventDispatcher dispatcherToMain_;
+    EventDispatcher &dispatcherToMain_;
     EventDispatcher dispatcherToWorker_;
     std::unique_ptr<std::thread> thread_;
     // Value only handled by the reader thread.
@@ -121,7 +122,6 @@ class WaylandClipboard {
 
     void setClipboard(const std::string &str, bool password);
     void setPrimary(const std::string &str, bool password);
-    EventLoop *eventLoop();
     auto display() const { return display_; }
     auto parent() const { return parent_; }
 

diff --git a/src/modules/wayland/waylandeventreader.cpp b/src/modules/wayland/waylandeventreader.cpp
@@ -13,7 +13,8 @@
 namespace fcitx {
 
 WaylandEventReader::WaylandEventReader(WaylandConnection *conn)
-    : module_(conn->parent()), conn_(conn), display_(*conn_->display()) {
+    : module_(conn->parent()), conn_(conn), display_(*conn_->display()),
+      dispatcherToMain_(module_->instance()->eventDispatcher()) {
     postEvent_ = module_->instance()->eventLoop().addPostEvent(
         [this](EventSource *source) {
             if (wl_display_get_error(display_)) {
@@ -24,7 +25,6 @@ WaylandEventReader::WaylandEventReader(WaylandConnection *conn)
             display_.flush();
             return true;
         });
-    dispatcherToMain_.attach(&conn->parent()->instance()->eventLoop());
     // Actively trigger an initial dispatch so we can make sure:
     // 1. depending even before this WaylandEventReader are handled.
     // 2. prepare_read is called.
@@ -33,8 +33,6 @@ WaylandEventReader::WaylandEventReader(WaylandConnection *conn)
         std::make_unique<std::thread>(&WaylandEventReader::runThread, this);
 }
 WaylandEventReader::~WaylandEventReader() {
-    // Prevent that dispatcherToMain_ to deliver removeConnection.
-    dispatcherToMain_.detach();
     if (thread_->joinable()) {
         quit();
         thread_->join();
@@ -110,9 +108,10 @@ void WaylandEventReader::quit() {
 
     // Make sure the connection will be removed.
     // The destructor will join the reader thread so it's ok.
-    dispatcherToMain_.schedule([module = module_, name = conn_->name()]() {
-        module->removeConnection(name);
-    });
+    dispatcherToMain_.scheduleWithContext(
+        this->watch(), [module = module_, name = conn_->name()]() {
+            module->removeConnection(name);
+        });
 }
 
 void WaylandEventReader::dispatch() {

diff --git a/src/modules/wayland/waylandeventreader.h b/src/modules/wayland/waylandeventreader.h
@@ -12,14 +12,15 @@
 #include <thread>
 #include "fcitx-utils/event.h"
 #include "fcitx-utils/eventdispatcher.h"
+#include "fcitx-utils/trackableobject.h"
 #include "display.h"
 
 namespace fcitx {
 
 class WaylandConnection;
 class WaylandModule;
 
-class WaylandEventReader {
+class WaylandEventReader : public TrackableObject<WaylandEventReader> {
 public:
     WaylandEventReader(WaylandConnection *conn);
     ~WaylandEventReader();
@@ -34,7 +35,7 @@ class WaylandEventReader {
     WaylandModule *module_;
     WaylandConnection *conn_;
     wayland::Display &display_;
-    EventDispatcher dispatcherToMain_;
+    EventDispatcher &dispatcherToMain_;
     EventDispatcher dispatcherToWorker_;
     std::unique_ptr<EventSource> postEvent_;
 

diff --git a/src/modules/xcb/xcbeventreader.cpp b/src/modules/xcb/xcbeventreader.cpp
@@ -11,7 +11,8 @@
 #include "xcbmodule.h"
 
 namespace fcitx {
-XCBEventReader::XCBEventReader(XCBConnection *conn) : conn_(conn) {
+XCBEventReader::XCBEventReader(XCBConnection *conn)
+    : conn_(conn), dispatcherToMain_(conn->instance()->eventDispatcher()) {
     postEvent_ =
         conn->instance()->eventLoop().addPostEvent([this](EventSource *source) {
             if (xcb_connection_has_error(conn_->connection())) {
@@ -22,7 +23,6 @@ XCBEventReader::XCBEventReader(XCBConnection *conn) : conn_(conn) {
             xcb_flush(conn_->connection());
             return true;
         });
-    dispatcherToMain_.attach(&conn->instance()->eventLoop());
     thread_ = std::make_unique<std::thread>(&XCBEventReader::runThread, this);
 }
 

diff --git a/src/modules/xcb/xcbeventreader.h b/src/modules/xcb/xcbeventreader.h
@@ -37,7 +37,7 @@ class XCBEventReader {
     void run();
     bool onIOEvent(IOEventFlags flags);
     XCBConnection *conn_;
-    EventDispatcher dispatcherToMain_;
+    EventDispatcher &dispatcherToMain_;
     EventDispatcher dispatcherToWorker_;
     bool hadError_ = false;
     std::unique_ptr<EventSource> deferEvent_;