refactor: dbus monitor/signal and executable DataSource

- port dbus calls to org.kde.plasma.workspace.dbus
- move executable DataSource to separate component
- adds DBusSignalMonitor

pref: port lock screen dbus method polling to `ActiveChanged` signal

Author: luisbocanegra

package/contents/ui/DBusFallback.qml

@@ -0,0 +1,47 @@
+pragma ComponentBehavior: Bound
+pragma ValueTypeBehavior: Addressable
+
+import QtQuick
+
+Item {
+    id: root
+    property string busType
+    property string service: ""
+    property string objectPath: ""
+    property string iface: ""
+    property string method: ""
+    property var arguments: []
+    property var signature: null
+    property var inSignature: null
+    signal callFinished(reply: var)
+
+    function builCmd() {
+        let cmd = "gdbus call --session --dest " + service + " --object-path " + objectPath + " --method " + iface + "." + method;
+        if (root.arguments.length !== 0) {
+            cmd += ` '${root.arguments.join(" ")}'`;
+        }
+        return cmd;
+    }
+
+    RunCommand {
+        id: runCommand
+        onExited: (cmd, exitCode, exitStatus, stdout, stderr) => {
+            if (exitCode !== 0) {
+                console.error(cmd, exitCode, exitStatus, stdout, stderr);
+                return;
+            }
+            stdout = stdout.trim().replace(/^\([']?/, "") // starting ( or ('
+            .replace(/[']?,\)$/, ""); // ending ,) or ',)
+            const reply = {
+                value: stdout
+            };
+            root.callFinished(reply);
+        }
+    }
+
+    function call(callback) {
+        runCommand.run(builCmd());
+        if (callback)
+            callFinished.connect(callback);
+    }
+}

package/contents/ui/DBusMethodCall.qml

@@ -0,0 +1,46 @@
+import QtQuick
+
+Item {
+    id: root
+
+    property string busType
+    property string service: ""
+    property string objectPath: ""
+    property string iface: ""
+    property string method: ""
+    property var arguments: []
+    property var signature: null
+    property var inSignature: null
+    property bool useGdbus: false
+
+    function call(callback) {
+        if (dbusLoader.item && typeof dbusLoader.item.call === "function")
+            dbusLoader.item.call(callback);
+        else
+            console.error("No valid DBus implementation loaded.");
+    }
+
+    onArgumentsChanged: {
+        if (dbusLoader.status === Loader.Ready)
+            dbusLoader.item.arguments = root.arguments;
+    }
+
+    Loader {
+        id: dbusLoader
+
+        source: root.useGdbus ? "DBusFallback.qml" : "DBusPrimary.qml"
+        onStatusChanged: {
+            if (status === Loader.Error)
+                dbusLoader.source = "DBusFallback.qml";
+        }
+        onLoaded: {
+            dbusLoader.item.service = root.service;
+            dbusLoader.item.objectPath = root.objectPath;
+            dbusLoader.item.iface = root.iface;
+            dbusLoader.item.method = root.method;
+            dbusLoader.item.arguments = root.arguments;
+            dbusLoader.item.signature = root.signature;
+            dbusLoader.item.inSignature = root.inSignature;
+        }
+    }
+}

package/contents/ui/DBusPrimary.qml

@@ -0,0 +1,40 @@
+pragma ComponentBehavior: Bound
+pragma ValueTypeBehavior: Addressable
+
+import QtQuick
+import org.kde.plasma.workspace.dbus as DBus
+
+QtObject {
+    id: root
+    property string busType: DBus.BusType.Session
+    property string service: ""
+    property string objectPath: ""
+    property string iface: ""
+    property string method: ""
+    property var arguments: []
+    property var signature: null
+    property var inSignature: null
+
+    property DBus.dbusMessage msg: {
+        "service": root.service,
+        "path": root.objectPath,
+        "iface": root.iface,
+        "member": root.method,
+        "arguments": root.arguments,
+        "signature": root.signature,
+        "inSignature": root.inSignature
+    }
+
+    function call(callback) {
+        const reply = DBus.SessionBus.asyncCall(root.msg) as DBus.DBusPendingReply;
+        if (callback) {
+            reply.finished.connect(() => {
+                callback(reply);
+                // Make sure to destroy after the reply is finished otherwise it may get leaked because the connected signal
+                // holds a reference and prevents garbage collection.
+                // https://discuss.kde.org/t/high-memory-usage-from-plasmashell-is-it-a-memory-leak/29105
+                reply.destroy();
+            });
+        }
+    }
+}

package/contents/ui/DBusSignalMonitor.qml

@@ -0,0 +1,54 @@
+pragma ComponentBehavior: Bound
+pragma ValueTypeBehavior: Addressable
+
+import QtQuick
+import "code/utils.js" as Utils
+
+Item {
+    id: root
+    property bool enabled: false
+    property string busType: "session"
+    property string service: ""
+    property string path: ""
+    property string iface: service
+    property string method: ""
+
+    readonly property string toolsDir: Qt.resolvedUrl("./tools").toString().substring(7) + "/"
+    readonly property string dbusMessageTool: "'" + toolsDir + "gdbus_get_signal.sh'"
+    readonly property string monitorCmd: `${dbusMessageTool} ${busType} ${service} ${iface} ${path} ${method}`
+
+    signal signalReceived(message: string)
+
+    function getMessage(rawOutput) {
+        let [path, interfaceAndMember, ...message] = rawOutput.split(" ");
+
+        return message.join(" ").replace(/^\([']?/, "") // starting ( or ('
+        .replace(/[']?,\)$/, ""); // ending ,) or ',)
+    }
+
+    RunCommand {
+        id: runCommand
+        onExited: (cmd, exitCode, exitStatus, stdout, stderr) => {
+            if (exitCode !== 130) {
+                console.error(cmd, exitCode, exitStatus, stdout, stderr);
+                return;
+            }
+            root.signalReceived(root.getMessage(stdout.trim()));
+            // for some reason it won't restart without a delay???
+            Utils.delay(50, () => {
+                runCommand.run(root.monitorCmd);
+            }, root);
+        }
+    }
+
+    function toggleMontitor() {
+        if (enabled) {
+            runCommand.run(monitorCmd);
+        } else {
+            runCommand.terminate(monitorCmd);
+        }
+    }
+
+    onEnabledChanged: toggleMontitor()
+    Component.onCompleted: toggleMontitor()
+}

package/contents/ui/EffectsModel.qml

@@ -1,107 +1,75 @@
-/*
- *  Copyright 2024 Luis Bocanegra <[email protected]>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  2.010-1301, USA.
- */
-
 import QtQuick
-import org.kde.plasma.plasma5support as P5Support
 
 Item {
-    id: effectsModel
+    id: root
     property var activeEffects: []
     property var loadedEffects: []
-    // sed -e "s|^(\(.*\),)$|\1|;s|^<\(.*\)>$|\1|;s|'|\"|g"
-    property string sed: "sed -e \"s|^(\\(.*\\),)$|\\1|;s|^<\\(.*\\)>$|\\1|;s|'|\\\"|g;s|@as ||g\""
-    property string activeEffectsCmd: "gdbus call --session --dest org.kde.KWin.Effect.WindowView1 --object-path /Effects --method org.freedesktop.DBus.Properties.Get org.kde.kwin.Effects activeEffects | " + sed
-    property bool activeEffectsCmdRunning: false
-    property string loadedEffectsCmd: "gdbus call --session --dest org.kde.KWin.Effect.WindowView1 --object-path /Effects --method org.freedesktop.DBus.Properties.Get org.kde.kwin.Effects loadedEffects | " + sed
-    property bool loadedEffectsCmdRunning: false
-    property bool active: false
+    property bool activeEffectsCallRunning: false
+    property bool loadedEffectsCallRunning: false
+    property bool monitorActive: false
+    property bool monitorLoaded: false
 
     function isEffectActive(effectId) {
         return activeEffects.includes(effectId);
     }
 
-    P5Support.DataSource {
-        id: runCommand
-        engine: "executable"
-        connectedSources: []
+    DBusMethodCall {
+        id: dbusKWinActiveEffects
+        service: "org.kde.KWin"
+        objectPath: "/Effects"
+        iface: "org.freedesktop.DBus.Properties"
+        method: "Get"
+        arguments: ["org.kde.kwin.Effects", "activeEffects"]
+    }
 
-        onNewData: function (source, data) {
-            var exitCode = data["exit code"];
-            var exitStatus = data["exit status"];
-            var stdout = data["stdout"];
-            var stderr = data["stderr"];
-            exited(source, exitCode, exitStatus, stdout, stderr);
-            disconnectSource(source); // cmd finished
-            sourceConnected(source);
-        }
+    DBusMethodCall {
+        id: dbusKWinLoadedEffects
+        service: "org.kde.KWin"
+        objectPath: "/Effects"
+        iface: "org.freedesktop.DBus.Properties"
+        method: "Get"
+        arguments: ["org.kde.kwin.Effects", "loadedEffects"]
+    }
 
-        function exec(cmd) {
-            if (cmd === activeEffectsCmd)
-                activeEffectsCmdRunning = true;
-            runCommand.connectSource(cmd);
+    function updateActiveEffects() {
+        if (!activeEffectsCallRunning) {
+            activeEffectsCallRunning = true;
+            dbusKWinActiveEffects.call(reply => {
+                activeEffectsCallRunning = false;
+                if (reply?.value) {
+                    activeEffects = reply.value;
+                }
+            });
         }
-
-        signal exited(string cmd, int exitCode, int exitStatus, string stdout, string stderr)
     }
 
-    Connections {
-        target: runCommand
-        function onExited(cmd, exitCode, exitStatus, stdout, stderr) {
-            if (cmd === activeEffectsCmd) {
-                activeEffectsCmdRunning = false;
-                if (exitCode !== 0)
-                    return;
-                if (stdout.length > 0) {
-                    try {
-                        activeEffects = JSON.parse(stdout.trim());
-                        // console.log("ACTIVE EFFECTS:", activeEffects);
-                    } catch (e) {
-                        console.error(e, e.stack);
-                    }
+    function updateLoadedEffects() {
+        if (!loadedEffectsCallRunning) {
+            loadedEffectsCallRunning = true;
+            dbusKWinActiveEffects.call(reply => {
+                loadedEffectsCallRunning = false;
+                if (reply?.value) {
+                    loadedEffects = reply.value;
                 }
-            }
-            if (cmd === loadedEffectsCmd) {
-                loadedEffectsCmdRunning = false;
-                if (exitCode !== 0)
-                    return;
-                if (stdout.length > 0) {
-                    try {
-                        loadedEffects = JSON.parse(stdout.trim());
-                        // console.log("LOADED EFFECTS:", loadedEffects);
-                    } catch (e) {
-                        console.error(e, e.stack);
-                    }
-                }
-            }
+            });
         }
     }
 
-    function updateActiveEffects() {
-        if (!activeEffectsCmdRunning)
-            runCommand.exec(activeEffectsCmd);
+    Timer {
+        running: root.monitorLoaded
+        repeat: true
+        interval: 1000
+        onTriggered: {
+            root.updateLoadedEffects();
+        }
     }
 
     Timer {
-        running: active
+        running: root.monitorActive
         repeat: true
         interval: 100
         onTriggered: {
-            updateActiveEffects();
+            root.updateActiveEffects();
         }
     }
 }