openclaw/deskflow
1
0
Fork 0
Code Issues Pull Requests Actions 17 Packages Projects Releases Wiki Activity

refactor: make APP:m_events private access via exsisting getEvents method

Browse Source
This commit is contained in:
sithlord48
2025-08-02 08:44:18 -04:00
committed by Nick Bolton
parent 92ae41852d
commit 4e01e3f337
3 changed files with 76 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/lib/deskflow/App.h
View File

@ -114,9 +114,8 @@ public:
protected:
void runEventsLoop(void *);
IEventQueue *m_events = nullptr;
private:
IEventQueue *m_events = nullptr;
deskflow::ArgsBase *m_args;
static App *s_instance;
FileLogOutputter *m_fileLog = nullptr;

53
src/lib/deskflow/ClientApp.cpp
View File

@ -156,8 +156,10 @@ deskflow::Screen *ClientApp::createScreen()
{
#if WINAPI_MSWINDOWS
return new deskflow::Screen(
new MSWindowsScreen(false, args().m_noHooks, m_events, args().m_enableLangSync, args().m_clientScrollDirection),
m_events
new MSWindowsScreen(
false, args().m_noHooks, getEvents(), args().m_enableLangSync, args().m_clientScrollDirection
),
getEvents()
);
#endif
@ -165,7 +167,7 @@ deskflow::Screen *ClientApp::createScreen()
if (deskflow::platform::isWayland()) {
#if WINAPI_LIBEI
LOG((CLOG_INFO "using ei screen for wayland"));
return new deskflow::Screen(new deskflow::EiScreen(false, m_events, true), m_events);
return new deskflow::Screen(new deskflow::EiScreen(false, getEvents(), true), getEvents());
#else
throw XNoEiSupport();
#endif
@ -175,14 +177,15 @@ deskflow::Screen *ClientApp::createScreen()
#if WINAPI_XWINDOWS
LOG((CLOG_INFO "using legacy x windows screen"));
return new deskflow::Screen(
new XWindowsScreen(args().m_display, false, args().m_yscroll, m_events, args().m_clientScrollDirection), m_events
new XWindowsScreen(args().m_display, false, args().m_yscroll, getEvents(), args().m_clientScrollDirection),
getEvents()
);
#endif
#if WINAPI_CARBON
return new deskflow::Screen(
new OSXScreen(m_events, false, args().m_enableLangSync, args().m_clientScrollDirection), m_events
new OSXScreen(getEvents(), false, args().m_enableLangSync, args().m_clientScrollDirection), getEvents()
);
#endif
}
@ -200,13 +203,13 @@ void ClientApp::updateStatus(const std::string_view &) const
void ClientApp::handleScreenError()
{
LOG((CLOG_CRIT "error on screen"));
m_events->addEvent(Event(EventTypes::Quit));
getEvents()->addEvent(Event(EventTypes::Quit));
}
deskflow::Screen *ClientApp::openClientScreen()
{
deskflow::Screen *screen = createScreen();
m_events->addHandler(EventTypes::ScreenError, screen->getEventTarget(), [this](const auto &) {
getEvents()->addHandler(EventTypes::ScreenError, screen->getEventTarget(), [this](const auto &) {
handleScreenError();
});
return screen;
@ -215,7 +218,7 @@ deskflow::Screen *ClientApp::openClientScreen()
void ClientApp::closeClientScreen(deskflow::Screen *screen)
{
if (screen != nullptr) {
m_events->removeHandler(EventTypes::ScreenError, screen->getEventTarget());
getEvents()->removeHandler(EventTypes::ScreenError, screen->getEventTarget());
delete screen;
}
}
@ -223,8 +226,8 @@ void ClientApp::closeClientScreen(deskflow::Screen *screen)
void ClientApp::handleClientRestart(const Event &, EventQueueTimer *timer)
{
// discard old timer
m_events->deleteTimer(timer);
m_events->removeHandler(EventTypes::Timer, timer);
getEvents()->deleteTimer(timer);
getEvents()->removeHandler(EventTypes::Timer, timer);
// reconnect
startClient();
@ -234,8 +237,8 @@ void ClientApp::scheduleClientRestart(double retryTime)
{
// install a timer and handler to retry later
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
EventQueueTimer *timer = m_events->newOneShotTimer(retryTime, nullptr);
m_events->addHandler(EventTypes::Timer, timer, [this, timer](const auto &e) { handleClientRestart(e, timer); });
EventQueueTimer *timer = getEvents()->newOneShotTimer(retryTime, nullptr);
getEvents()->addHandler(EventTypes::Timer, timer, [this, timer](const auto &e) { handleClientRestart(e, timer); });
}
void ClientApp::handleClientConnected() const
@ -267,7 +270,7 @@ void ClientApp::handleClientRefused(const Event &e)
updateStatus(std::string("Failed to connect to server: ") + info->m_what);
if (!args().m_restartable || !info->m_retry) {
LOG((CLOG_ERR "failed to connect to server: %s", info->m_what.c_str()));
m_events->addEvent(Event(EventTypes::Quit));
getEvents()->addEvent(Event(EventTypes::Quit));
} else {
LOG((CLOG_WARN "failed to connect to server: %s", info->m_what.c_str()));
if (!m_suspended) {
@ -280,7 +283,7 @@ void ClientApp::handleClientDisconnected()
{
LOG((CLOG_NOTE "disconnected from server"));
if (!args().m_restartable) {
m_events->addEvent(Event(EventTypes::Quit));
getEvents()->addEvent(Event(EventTypes::Quit));
} else if (!m_suspended) {
scheduleClientRestart(s_retryTime);
}
@ -289,19 +292,19 @@ void ClientApp::handleClientDisconnected()
Client *ClientApp::openClient(const std::string &name, const NetworkAddress &address, deskflow::Screen *screen)
{
auto *client = new Client(m_events, name, address, getSocketFactory(), screen, args());
auto *client = new Client(getEvents(), name, address, getSocketFactory(), screen, args());
try {
m_events->addHandler(EventTypes::ClientConnected, client->getEventTarget(), [this](const auto &) {
getEvents()->addHandler(EventTypes::ClientConnected, client->getEventTarget(), [this](const auto &) {
handleClientConnected();
});
m_events->addHandler(EventTypes::ClientConnectionFailed, client->getEventTarget(), [this](const auto &e) {
getEvents()->addHandler(EventTypes::ClientConnectionFailed, client->getEventTarget(), [this](const auto &e) {
handleClientFailed(e);
});
m_events->addHandler(EventTypes::ClientConnectionRefused, client->getEventTarget(), [this](const auto &e) {
getEvents()->addHandler(EventTypes::ClientConnectionRefused, client->getEventTarget(), [this](const auto &e) {
handleClientRefused(e);
});
m_events->addHandler(EventTypes::ClientDisconnected, client->getEventTarget(), [this](const auto &) {
getEvents()->addHandler(EventTypes::ClientDisconnected, client->getEventTarget(), [this](const auto &) {
handleClientDisconnected();
});
@ -319,10 +322,10 @@ void ClientApp::closeClient(Client *client)
return;
}
using enum EventTypes;
m_events->removeHandler(ClientConnected, client);
m_events->removeHandler(ClientConnectionFailed, client);
m_events->removeHandler(ClientConnectionRefused, client);
m_events->removeHandler(ClientDisconnected, client);
getEvents()->removeHandler(ClientConnected, client);
getEvents()->removeHandler(ClientConnectionFailed, client);
getEvents()->removeHandler(ClientConnectionRefused, client);
getEvents()->removeHandler(ClientDisconnected, client);
delete client;
}
@ -406,7 +409,7 @@ int ClientApp::mainLoop()
runCocoaApp();
#else
m_events->loop();
getEvents()->loop();
#endif
DAEMON_RUNNING(false);
@ -468,5 +471,5 @@ void ClientApp::startNode()
ISocketFactory *ClientApp::getSocketFactory() const
{
return new TCPSocketFactory(m_events, getSocketMultiplexer());
return new TCPSocketFactory(getEvents(), getSocketMultiplexer());
}

90
src/lib/deskflow/ServerApp.cpp
View File

@ -218,17 +218,19 @@ void ServerApp::closeServer(Server *server)
// wait for clients to disconnect for up to timeout seconds
double timeout = 3.0;
EventQueueTimer *timer = m_events->newOneShotTimer(timeout, nullptr);
m_events->addHandler(EventTypes::Timer, timer, [this](const auto &) { m_events->addEvent(Event(EventTypes::Quit)); });
m_events->addHandler(EventTypes::ServerDisconnected, server, [this](const auto &) {
m_events->addEvent(Event(EventTypes::Quit));
EventQueueTimer *timer = getEvents()->newOneShotTimer(timeout, nullptr);
getEvents()->addHandler(EventTypes::Timer, timer, [this](const auto &) {
getEvents()->addEvent(Event(EventTypes::Quit));
});
getEvents()->addHandler(EventTypes::ServerDisconnected, server, [this](const auto &) {
getEvents()->addEvent(Event(EventTypes::Quit));
});
m_events->loop();
getEvents()->loop();
m_events->removeHandler(EventTypes::Timer, timer);
m_events->deleteTimer(timer);
m_events->removeHandler(EventTypes::ServerDisconnected, server);
getEvents()->removeHandler(EventTypes::Timer, timer);
getEvents()->deleteTimer(timer);
getEvents()->removeHandler(EventTypes::ServerDisconnected, server);
// done with server
delete server;
@ -237,8 +239,8 @@ void ServerApp::closeServer(Server *server)
void ServerApp::stopRetryTimer()
{
if (m_timer != nullptr) {
m_events->removeHandler(EventTypes::Timer, m_timer);
m_events->deleteTimer(m_timer);
getEvents()->removeHandler(EventTypes::Timer, m_timer);
getEvents()->deleteTimer(m_timer);
m_timer = nullptr;
}
}
@ -256,7 +258,7 @@ void ServerApp::updateStatus(const std::string_view &msg) const
void ServerApp::closeClientListener(ClientListener *listen)
{
if (listen != nullptr) {
m_events->removeHandler(EventTypes::ClientListenerAccepted, listen);
getEvents()->removeHandler(EventTypes::ClientListenerAccepted, listen);
delete listen;
}
}
@ -287,9 +289,9 @@ void ServerApp::closeServerScreen(deskflow::Screen *screen)
{
if (screen != nullptr) {
using enum EventTypes;
m_events->removeHandler(ScreenError, screen->getEventTarget());
m_events->removeHandler(ScreenSuspend, screen->getEventTarget());
m_events->removeHandler(ScreenResume, screen->getEventTarget());
getEvents()->removeHandler(ScreenError, screen->getEventTarget());
getEvents()->removeHandler(ScreenSuspend, screen->getEventTarget());
getEvents()->removeHandler(ScreenResume, screen->getEventTarget());
delete screen;
}
}
@ -332,7 +334,7 @@ void ServerApp::retryHandler()
LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = Uninitialized;
if (!initServer()) {
m_events->addEvent(Event(EventTypes::Quit));
getEvents()->addEvent(Event(EventTypes::Quit));
}
break;
@ -340,11 +342,11 @@ void ServerApp::retryHandler()
LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = Uninitialized;
if (!initServer()) {
m_events->addEvent(Event(EventTypes::Quit));
getEvents()->addEvent(Event(EventTypes::Quit));
} else if (m_serverState == Initialized) {
LOG((CLOG_DEBUG1 "starting server"));
if (!startServer()) {
m_events->addEvent(Event(EventTypes::Quit));
getEvents()->addEvent(Event(EventTypes::Quit));
}
}
break;
@ -353,7 +355,7 @@ void ServerApp::retryHandler()
LOG((CLOG_DEBUG1 "retry starting server"));
m_serverState = Initialized;
if (!startServer()) {
m_events->addEvent(Event(EventTypes::Quit));
getEvents()->addEvent(Event(EventTypes::Quit));
}
break;
}
@ -401,8 +403,8 @@ bool ServerApp::initServer()
// install a timer and handler to retry later
assert(m_timer == nullptr);
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
m_timer = m_events->newOneShotTimer(retryTime, nullptr);
m_events->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); });
m_timer = getEvents()->newOneShotTimer(retryTime, nullptr);
getEvents()->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); });
m_serverState = Initializing;
return true;
} else {
@ -414,11 +416,13 @@ bool ServerApp::initServer()
deskflow::Screen *ServerApp::openServerScreen()
{
deskflow::Screen *screen = createScreen();
m_events->addHandler(EventTypes::ScreenError, screen->getEventTarget(), [this](const auto &) {
getEvents()->addHandler(EventTypes::ScreenError, screen->getEventTarget(), [this](const auto &) {
handleScreenError();
});
m_events->addHandler(EventTypes::ScreenSuspend, screen->getEventTarget(), [this](const auto &) { handleSuspend(); });
m_events->addHandler(EventTypes::ScreenResume, screen->getEventTarget(), [this](const auto &) { handleResume(); });
getEvents()->addHandler(EventTypes::ScreenSuspend, screen->getEventTarget(), [this](const auto &) {
handleSuspend();
});
getEvents()->addHandler(EventTypes::ScreenResume, screen->getEventTarget(), [this](const auto &) { handleResume(); });
return screen;
}
@ -474,8 +478,8 @@ bool ServerApp::startServer()
assert(m_timer == nullptr);
const auto retryTime = 10.0;
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
m_timer = m_events->newOneShotTimer(retryTime, nullptr);
m_events->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); });
m_timer = getEvents()->newOneShotTimer(retryTime, nullptr);
getEvents()->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); });
m_serverState = Starting;
return true;
} else {
@ -487,14 +491,14 @@ bool ServerApp::startServer()
deskflow::Screen *ServerApp::createScreen()
{
#if WINAPI_MSWINDOWS
return new deskflow::Screen(new MSWindowsScreen(true, args().m_noHooks, m_events), m_events);
return new deskflow::Screen(new MSWindowsScreen(true, args().m_noHooks, getEvents()), getEvents());
#endif
#if defined(WINAPI_XWINDOWS) or defined(WINAPI_LIBEI)
if (deskflow::platform::isWayland()) {
#if WINAPI_LIBEI
LOG((CLOG_INFO "using ei screen for wayland"));
return new deskflow::Screen(new deskflow::EiScreen(true, m_events, true), m_events);
return new deskflow::Screen(new deskflow::EiScreen(true, getEvents(), true), getEvents());
#else
throw XNoEiSupport();
#endif
@ -503,9 +507,9 @@ deskflow::Screen *ServerApp::createScreen()
#if WINAPI_XWINDOWS
LOG((CLOG_INFO "using legacy x windows screen"));
return new deskflow::Screen(new XWindowsScreen(args().m_display, true, 0, m_events), m_events);
return new deskflow::Screen(new XWindowsScreen(args().m_display, true, 0, getEvents()), getEvents());
#elif WINAPI_CARBON
return new deskflow::Screen(new OSXScreen(m_events, true), m_events);
return new deskflow::Screen(new OSXScreen(getEvents(), true), getEvents());
#endif
}
@ -518,7 +522,7 @@ PrimaryClient *ServerApp::openPrimaryClient(const std::string &name, deskflow::S
void ServerApp::handleScreenError()
{
LOG((CLOG_CRIT "error on screen"));
m_events->addEvent(Event(EventTypes::Quit));
getEvents()->addEvent(Event(EventTypes::Quit));
}
void ServerApp::handleSuspend()
@ -551,9 +555,9 @@ ClientListener *ServerApp::openClientListener(const NetworkAddress &address)
}
}
auto *listen = new ClientListener(getAddress(address), getSocketFactory(), m_events, securityLevel);
auto *listen = new ClientListener(getAddress(address), getSocketFactory(), getEvents(), securityLevel);
m_events->addHandler(EventTypes::ClientListenerAccepted, listen, [this, listen](const auto &e) {
getEvents()->addHandler(EventTypes::ClientListenerAccepted, listen, [this, listen](const auto &e) {
handleClientConnected(e, listen);
});
@ -562,10 +566,10 @@ ClientListener *ServerApp::openClientListener(const NetworkAddress &address)
Server *ServerApp::openServer(ServerConfig &config, PrimaryClient *primaryClient)
{
auto *server = new Server(config, primaryClient, m_serverScreen, m_events, args());
auto *server = new Server(config, primaryClient, m_serverScreen, getEvents(), args());
try {
m_events->addHandler(EventTypes::ServerDisconnected, server, [this](const auto &) { updateStatus(); });
m_events->addHandler(EventTypes::ServerScreenSwitched, server, [this](const auto &) { handleScreenSwitched(); });
getEvents()->addHandler(EventTypes::ServerDisconnected, server, [this](const auto &) { updateStatus(); });
getEvents()->addHandler(EventTypes::ServerScreenSwitched, server, [this](const auto &) { handleScreenSwitched(); });
} catch (std::bad_alloc &ba) {
delete server;
@ -582,7 +586,7 @@ void ServerApp::handleScreenSwitched() const
std::unique_ptr<ISocketFactory> ServerApp::getSocketFactory() const
{
return std::make_unique<TCPSocketFactory>(m_events, getSocketMultiplexer());
return std::make_unique<TCPSocketFactory>(getEvents(), getSocketMultiplexer());
}
NetworkAddress ServerApp::getAddress(const NetworkAddress &address) const
@ -622,19 +626,19 @@ int ServerApp::mainLoop()
// handle hangup signal by reloading the server's configuration
ARCH->setSignalHandler(Arch::ThreadSignal::Hangup, &reloadSignalHandler, nullptr);
m_events->addHandler(EventTypes::ServerAppReloadConfig, m_events->getSystemTarget(), [this](const auto &) {
getEvents()->addHandler(EventTypes::ServerAppReloadConfig, getEvents()->getSystemTarget(), [this](const auto &) {
reloadConfig();
});
// handle force reconnect event by disconnecting clients. they'll
// reconnect automatically.
m_events->addHandler(EventTypes::ServerAppForceReconnect, m_events->getSystemTarget(), [this](const auto &) {
getEvents()->addHandler(EventTypes::ServerAppForceReconnect, getEvents()->getSystemTarget(), [this](const auto &) {
forceReconnect();
});
// to work around the sticky meta keys problem, we'll give users
// the option to reset the state of the server.
m_events->addHandler(EventTypes::ServerAppResetServer, m_events->getSystemTarget(), [this](const auto &) {
getEvents()->addHandler(EventTypes::ServerAppResetServer, getEvents()->getSystemTarget(), [this](const auto &) {
resetServer();
});
@ -653,15 +657,15 @@ int ServerApp::mainLoop()
runCocoaApp();
#else
m_events->loop();
getEvents()->loop();
#endif
DAEMON_RUNNING(false);
// close down
LOG((CLOG_DEBUG1 "stopping server"));
m_events->removeHandler(EventTypes::ServerAppForceReconnect, m_events->getSystemTarget());
m_events->removeHandler(EventTypes::ServerAppReloadConfig, m_events->getSystemTarget());
getEvents()->removeHandler(EventTypes::ServerAppForceReconnect, getEvents()->getSystemTarget());
getEvents()->removeHandler(EventTypes::ServerAppReloadConfig, getEvents()->getSystemTarget());
cleanupServer();
updateStatus();
LOG((CLOG_NOTE "stopped server"));
@ -681,7 +685,7 @@ int ServerApp::runInner(int argc, char **argv, StartupFunc startup)
{
// general initialization
m_deskflowAddress = new NetworkAddress;
args().m_config = std::make_shared<Config>(m_events);
args().m_config = std::make_shared<Config>(getEvents());
args().m_pname = QFileInfo(argv[0]).fileName().toLocal8Bit().constData();
// run