dbus: merge DBusInterfaceBase and IntegratedDBusInterface; add ability to disable config loading

Author: taj-ny

src/CMakeLists.txt

@@ -35,8 +35,7 @@ set(libinputactions_SRCS
     libinputactions/conditions/ConditionGroup.cpp
     libinputactions/conditions/CustomCondition.cpp
     libinputactions/conditions/VariableCondition.cpp
-    libinputactions/dbus/DBusInterfaceBase.cpp
-    libinputactions/dbus/IntegratedDBusInterface.cpp
+    libinputactions/dbus/MainDBusInterface.cpp
     libinputactions/handlers/InputTriggerHandler.cpp
     libinputactions/handlers/KeyboardTriggerHandler.cpp
     libinputactions/handlers/MotionTriggerHandler.cpp

src/libinputactions/InputActionsMain.cpp

@@ -3,6 +3,7 @@
 #include "config/ConfigIssueManager.h"
 #include "config/ConfigLoader.h"
 #include "config/GlobalConfig.h"
+#include "dbus/MainDBusInterface.h"
 #include "input/StrokeRecorder.h"
 #include "input/backends/InputBackend.h"
 #include "interfaces/ConfigProvider.h"
@@ -52,6 +53,7 @@ InputActionsMain::~InputActionsMain()
     g_globalConfig.reset();
     g_configProvider.reset();
     g_inputBackend.reset();
+    g_mainDbusInterface.reset();
     g_scriptingEngine.reset();
     g_strokeRecorder.reset();
     g_variableRegistry.reset();
@@ -98,6 +100,7 @@ void InputActionsMain::setMissingImplementations()
     setMissingImplementation(g_configLoader);
     setMissingImplementation(g_globalConfig);
     setMissingImplementation(g_inputBackend);
+    setMissingImplementation(g_mainDbusInterface);
     setMissingImplementation(g_strokeRecorder);
     setMissingImplementation(g_variableRegistry);
 

src/libinputactions/InputActionsMain.h

@@ -18,7 +18,6 @@
 
 #pragma once
 
-#include "dbus/IntegratedDBusInterface.h"
 #include <QObject>
 
 namespace InputActions
@@ -78,8 +77,6 @@ private slots:
             member = std::make_unique<T>();
         }
     }
-
-    IntegratedDBusInterface m_dbusInterface;
 };
 
 inline InputActionsMain *g_inputActions;

src/libinputactions/dbus/DBusInterfaceBase.cpp

@@ -16,45 +16,52 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-#include "IntegratedDBusInterface.h"
+#include "MainDBusInterface.h"
 #include <QRegularExpression>
 #include <libinputactions/InputActionsMain.h>
 #include <libinputactions/config/ConfigIssueManager.h>
 #include <libinputactions/config/ConfigLoader.h>
+#include <libinputactions/config/GlobalConfig.h>
 #include <libinputactions/helpers/QDBusConnection.h>
 #include <libinputactions/input/StrokeRecorder.h>
 #include <libinputactions/input/backends/InputBackend.h>
+#include <libinputactions/input/devices/InputDevice.h>
 #include <libinputactions/interfaces/OnScreenMessageManager.h>
 #include <libinputactions/triggers/core/StrokeTriggerCore.h>
 #include <libinputactions/variables/VariableRegistry.h>
 
 namespace InputActions
 {
 
-IntegratedDBusInterface::IntegratedDBusInterface()
+MainDBusInterface::MainDBusInterface()
     : m_bus(QDBusConnectionHelpers::sessionBus())
 {
     m_bus.registerService(INPUTACTIONS_DBUS_SERVICE);
     m_bus.registerObject(INPUTACTIONS_DBUS_PATH, this, QDBusConnection::ExportAllSlots);
 }
 
-IntegratedDBusInterface::~IntegratedDBusInterface()
+MainDBusInterface::~MainDBusInterface()
 {
     m_bus.unregisterService(INPUTACTIONS_DBUS_SERVICE);
     m_bus.unregisterObject(INPUTACTIONS_DBUS_PATH);
 }
 
-QString IntegratedDBusInterface::deviceList()
+QString MainDBusInterface::deviceList()
 {
-    return DBusInterfaceBase::deviceList();
+    QStringList result;
+    for (const auto *device : g_inputBackend->devices()) {
+        result.push_back(device->toString());
+    }
+    result.sort();
+    return result.join("\n\n");
 }
 
-QString IntegratedDBusInterface::issues()
+QString MainDBusInterface::issues()
 {
-    return DBusInterfaceBase::issues();
+    return g_configIssueManager->issuesToString();
 }
 
-void IntegratedDBusInterface::recordStroke(const QDBusMessage &message)
+void MainDBusInterface::recordStroke(const QDBusMessage &message)
 {
     if (!g_inputBackend->initialized()) {
         sendErrorReply(QDBusError::Failed, "Stroke recording requires a valid configuration to be active.");
@@ -74,23 +81,60 @@ void IntegratedDBusInterface::recordStroke(const QDBusMessage &message)
     });
 }
 
-QString IntegratedDBusInterface::reloadConfig()
+QString MainDBusInterface::reloadConfig()
 {
+    if (!m_allowConfigLoading) {
+        sendErrorReply(QDBusError::Failed, "Loading the configuration is not allowed while the client is inactive.");
+        return {};
+    }
+
     g_configLoader->load({
         .manual = true,
     });
     return g_configIssueManager->issuesToString();
 }
 
-QString IntegratedDBusInterface::suspend()
+QString MainDBusInterface::suspend()
 {
+    if (m_allowConfigLoading) {
+        sendErrorReply(QDBusError::Failed, "Suspending is not allowed while the client is inactive.");
+        return {};
+    }
+
     g_inputActions->suspend();
     return "success";
 }
 
-QString IntegratedDBusInterface::variables(QString filter)
+QString MainDBusInterface::variables(QString filter)
+{
+    if (!g_globalConfig->allowExternalVariableAccess()) {
+        return "External variable access has been disabled. Set 'external_variable_access' to 'true' to enable.";
+    }
+
+    QStringList result;
+    const QRegularExpression filterRegex(filter);
+    for (const auto &[name, variable] : g_variableRegistry->variables()) {
+        if (variable->hidden() || !filterRegex.match(name).hasMatch()) {
+            continue;
+        }
+        result.push_back(QString("%1: %2").arg(name, variable->operations()->toString()));
+    }
+    return result.join('\n');
+}
+
+QString MainDBusInterface::strokeToBase64(const Stroke &stroke)
 {
-    return variableList(g_variableRegistry.get(), filter);
+    QByteArray bytes;
+    const auto &points = stroke.points();
+    for (size_t i = 0; i < points.size(); i++) {
+        // All values range from -1 to 1
+        bytes.push_back(static_cast<char>(points[i].x * 100));
+        bytes.push_back(static_cast<char>(points[i].y * 100));
+        bytes.push_back(static_cast<char>(points[i].t * 100));
+        bytes.push_back(static_cast<char>(points[i].alpha * 100));
+    }
+
+    return QString("'%1'").arg(bytes.toBase64());
 }
 
 }

src/libinputactions/dbus/DBusInterfaceBase.h

@@ -18,7 +18,6 @@
 
 #pragma once
 
-#include "DBusInterfaceBase.h"
 #include <QDBusConnection>
 #include <QDBusContext>
 #include <QDBusMessage>
@@ -30,8 +29,10 @@ namespace InputActions
 static const QString INPUTACTIONS_DBUS_SERVICE = "org.inputactions";
 static const QString INPUTACTIONS_DBUS_PATH = "/";
 
-class IntegratedDBusInterface
-    : public DBusInterfaceBase
+class Stroke;
+
+class MainDBusInterface
+    : public QObject
     , protected QDBusContext
 {
     Q_OBJECT
@@ -41,12 +42,17 @@ class IntegratedDBusInterface
     /**
      * Registers the interface.
      */
-    IntegratedDBusInterface();
+    MainDBusInterface();
 
     /**
      * Unregisters the interface.
      */
-    ~IntegratedDBusInterface() override;
+    ~MainDBusInterface() override;
+
+    /**
+     * Sets whether loading the config and suspending InputActions through the DBus interface is allowed. This is only used in the standalone implementation.
+     */
+    void setAllowConfigLoading(bool value) { m_allowConfigLoading = value; }
 
 public slots:
     QString deviceList();
@@ -57,8 +63,14 @@ public slots:
     QString variables(QString filter = "");
 
 private:
+    static QString strokeToBase64(const Stroke &stroke);
+
     QDBusConnection m_bus;
     QDBusMessage m_reply;
+
+    bool m_allowConfigLoading = true;
 };
 
+inline std::shared_ptr<MainDBusInterface> g_mainDbusInterface;
+
 }

…actions/dbus/IntegratedDBusInterface.cpp …binputactions/dbus/MainDBusInterface.cppsrc/libinputactions/dbus/IntegratedDBusInterface.cpp renamed to src/libinputactions/dbus/MainDBusInterface.cpp src/libinputactions/dbus/IntegratedDBusInterface.cpp renamed to src/libinputactions/dbus/MainDBusInterface.cpp

@@ -26,7 +26,7 @@ namespace InputActions::QDBusConnectionHelpers
 /**
  * Same as QDBusConnection::sessionBus, but uses QDBusConnection::connectToBus with the address specified in the DBUS_SESSION_BUS_ADDRESS environment variable
  * for setgid binaries.
- * 
+ *
  * Connection is cached.
  */
 const QDBusConnection &sessionBus();