Cleanup some of the backwards compat crap

Modules/Lock/Lock.qml

@@ -25,7 +25,7 @@ Item {
         target: IdleService
         function onLockRequested() {
             console.log("Lock: Received lock request from IdleService")
-            SessionService.lockSession()
+            loader.activeAsync = true
         }
     }
 

Services/NetworkManagerService.qml

@@ -76,14 +76,15 @@ Singleton {
     signal networksUpdated
     signal connectionChanged
 
-    property var dmsService: null
     property bool subscriptionConnected: false
 
     readonly property string socketPath: Quickshell.env("DMS_SOCKET")
 
     Component.onCompleted: {
         root.userPreference = SettingsData.networkPreference
-        Qt.callLater(initializeDMSConnection)
+        if (socketPath && socketPath.length > 0) {
+            checkDMSCapabilities()
+        }
     }
 
     DankSocket {
@@ -133,65 +134,43 @@ Singleton {
         console.log("NetworkManagerService: Sent network.subscribe request")
     }
 
-    function initializeDMSConnection() {
+    Connections {
-        try {
+        target: DMSService
-            console.log("NetworkManagerService: Initializing DMS connection...")
-            dmsService = Qt.createQmlObject('import QtQuick; import qs.Services; QtObject { property var service: DMSService }', root)
-            if (dmsService && dmsService.service) {
-                console.log("NetworkManagerService: DMS service reference created")
-                checkCapabilities()
-                dmsService.service.connectionStateChanged.connect(onDMSConnectionStateChanged)
-                dmsService.service.capabilitiesChanged.connect(onDMSCapabilitiesChanged)
-                console.log("NetworkManagerService: Callbacks registered, isConnected:", dmsService.service.isConnected, "capabilities:", JSON.stringify(dmsService.service.capabilities))
-            } else {
-                console.warn("NetworkManagerService: Failed to get DMS service reference")
-            }
-        } catch (e) {
-            console.warn("NetworkManagerService: Failed to initialize DMS connection:", e)
-        }
-    }
 
-    function checkCapabilities() {
+        function onConnectionStateChanged() {
-        if (dmsService && dmsService.service && dmsService.service.isConnected) {
+            if (DMSService.isConnected) {
-            onDMSConnected()
+                checkDMSCapabilities()
-        }
-    }
-
-    function onDMSConnectionStateChanged() {
-        if (dmsService && dmsService.service && dmsService.service.isConnected) {
-            onDMSConnected()
-        }
-    }
-
-    function onDMSCapabilitiesChanged() {
-        console.log("NetworkManagerService: onDMSCapabilitiesChanged called, capabilities:", dmsService ? JSON.stringify(dmsService.service.capabilities) : "no service")
-        if (dmsService && dmsService.service && dmsService.service.capabilities.includes("network")) {
-            console.log("NetworkManagerService: Network capability detected!")
-            networkAvailable = true
-            if (dmsService.service.isConnected && !stateInitialized) {
-                console.log("NetworkManagerService: DMS is connected, fetching state and starting subscription socket...")
-                stateInitialized = true
-                getState()
-                subscriptionSocket.connected = true
             }
         }
     }
 
-    function onDMSConnected() {
+    Connections {
-        console.log("NetworkManagerService: onDMSConnected called")
+        target: DMSService
-        if (dmsService && dmsService.service && dmsService.service.capabilities && dmsService.service.capabilities.length > 0) {
+        enabled: DMSService.isConnected
-            console.log("NetworkManagerService: Capabilities:", JSON.stringify(dmsService.service.capabilities))
-            networkAvailable = dmsService.service.capabilities.includes("network")
-            console.log("NetworkManagerService: Network available:", networkAvailable)
 
-            if (networkAvailable && !stateInitialized) {
+        function onCapabilitiesChanged() {
-                console.log("NetworkManagerService: Requesting network state and starting subscription socket...")
+            checkDMSCapabilities()
-                stateInitialized = true
+        }
-                getState()
+    }
-                subscriptionSocket.connected = true
+
-            }
+    function checkDMSCapabilities() {
-        } else {
+        if (!DMSService.isConnected) {
-            console.log("NetworkManagerService: No capabilities yet or service not ready")
+            return
+        }
+
+        if (DMSService.capabilities.length === 0) {
+            return
+        }
+
+        console.log("NetworkManagerService: Capabilities:", JSON.stringify(DMSService.capabilities))
+        networkAvailable = DMSService.capabilities.includes("network")
+        console.log("NetworkManagerService: Network available:", networkAvailable)
+
+        if (networkAvailable && !stateInitialized) {
+            console.log("NetworkManagerService: Requesting network state and starting subscription socket...")
+            stateInitialized = true
+            getState()
+            subscriptionSocket.connected = true
         }
     }
 
@@ -212,9 +191,9 @@ Singleton {
     property bool initialStateFetched: false
 
     function getState() {
-        if (!networkAvailable || !dmsService || !dmsService.service) return
+        if (!networkAvailable) return
 
-        dmsService.service.sendRequest("network.getState", null, response => {
+        DMSService.sendRequest("network.getState", null, response => {
             if (response.result) {
                 updateState(response.result)
                 if (!initialStateFetched && response.result.wifiEnabled && (!response.result.wifiNetworks || response.result.wifiNetworks.length === 0)) {
@@ -277,11 +256,11 @@ Singleton {
     }
 
     function scanWifi() {
-        if (!networkAvailable || isScanning || !wifiEnabled || !dmsService || !dmsService.service) return
+        if (!networkAvailable || isScanning || !wifiEnabled) return
 
         console.log("NetworkManagerService: Starting WiFi scan...")
         isScanning = true
-        dmsService.service.sendRequest("network.wifi.scan", null, response => {
+        DMSService.sendRequest("network.wifi.scan", null, response => {
             isScanning = false
             if (response.error) {
                 console.warn("NetworkManagerService: WiFi scan failed:", response.error)
@@ -297,7 +276,7 @@ Singleton {
     }
 
     function connectToWifi(ssid, password = "", username = "") {
-        if (!networkAvailable || isConnecting || !dmsService || !dmsService.service) return
+        if (!networkAvailable || isConnecting) return
 
         isConnecting = true
         connectingSSID = ssid
@@ -308,7 +287,7 @@ Singleton {
         if (password) params.password = password
         if (username) params.username = username
 
-        dmsService.service.sendRequest("network.wifi.connect", params, response => {
+        DMSService.sendRequest("network.wifi.connect", params, response => {
             if (response.error) {
                 connectionError = response.error
                 lastConnectionError = response.error
@@ -338,9 +317,9 @@ Singleton {
     }
 
     function disconnectWifi() {
-        if (!networkAvailable || !wifiInterface || !dmsService || !dmsService.service) return
+        if (!networkAvailable || !wifiInterface) return
 
-        dmsService.service.sendRequest("network.wifi.disconnect", null, response => {
+        DMSService.sendRequest("network.wifi.disconnect", null, response => {
             if (response.error) {
                 ToastService.showError("Failed to disconnect WiFi")
             } else {
@@ -352,10 +331,10 @@ Singleton {
     }
 
     function forgetWifiNetwork(ssid) {
-        if (!networkAvailable || !dmsService || !dmsService.service) return
+        if (!networkAvailable) return
 
         forgetSSID = ssid
-        dmsService.service.sendRequest("network.wifi.forget", { ssid: ssid }, response => {
+        DMSService.sendRequest("network.wifi.forget", { ssid: ssid }, response => {
             if (response.error) {
                 console.warn("Failed to forget network:", response.error)
             } else {
@@ -382,10 +361,10 @@ Singleton {
     }
 
     function toggleWifiRadio() {
-        if (!networkAvailable || wifiToggling || !dmsService || !dmsService.service) return
+        if (!networkAvailable || wifiToggling) return
 
         wifiToggling = true
-        dmsService.service.sendRequest("network.wifi.toggle", null, response => {
+        DMSService.sendRequest("network.wifi.toggle", null, response => {
             wifiToggling = false
 
             if (response.error) {
@@ -398,9 +377,9 @@ Singleton {
     }
 
     function enableWifiDevice() {
-        if (!networkAvailable || !dmsService || !dmsService.service) return
+        if (!networkAvailable) return
 
-        dmsService.service.sendRequest("network.wifi.enable", null, response => {
+        DMSService.sendRequest("network.wifi.enable", null, response => {
             if (response.error) {
                 ToastService.showError("Failed to enable WiFi")
             } else {
@@ -410,14 +389,14 @@ Singleton {
     }
 
     function setNetworkPreference(preference) {
-        if (!networkAvailable || !dmsService || !dmsService.service) return
+        if (!networkAvailable) return
 
         userPreference = preference
         changingPreference = true
         targetPreference = preference
         SettingsData.setNetworkPreference(preference)
 
-        dmsService.service.sendRequest("network.preference.set", { preference: preference }, response => {
+        DMSService.sendRequest("network.preference.set", { preference: preference }, response => {
             changingPreference = false
             targetPreference = ""
 
@@ -441,13 +420,13 @@ Singleton {
     }
 
     function toggleNetworkConnection(type) {
-        if (!networkAvailable || !dmsService || !dmsService.service) return
+        if (!networkAvailable) return
 
         if (type === "ethernet") {
             if (networkStatus === "ethernet") {
-                dmsService.service.sendRequest("network.ethernet.disconnect", null, null)
+                DMSService.sendRequest("network.ethernet.disconnect", null, null)
             } else {
-                dmsService.service.sendRequest("network.ethernet.connect", null, null)
+                DMSService.sendRequest("network.ethernet.connect", null, null)
             }
         }
     }
@@ -466,13 +445,13 @@ Singleton {
     }
 
     function fetchNetworkInfo(ssid) {
-        if (!networkAvailable || !dmsService || !dmsService.service) return
+        if (!networkAvailable) return
 
         networkInfoSSID = ssid
         networkInfoLoading = true
         networkInfoDetails = "Loading network information..."
 
-        dmsService.service.sendRequest("network.info", { ssid: ssid }, response => {
+        DMSService.sendRequest("network.info", { ssid: ssid }, response => {
             networkInfoLoading = false
 
             if (response.error) {

Services/PortalService.qml

@@ -15,17 +15,18 @@ Singleton {
     property bool settingsPortalAvailable: false
     property int systemColorScheme: 0
 
-    property var dmsService: null
     property bool freedeskAvailable: false
 
+    readonly property string socketPath: Quickshell.env("DMS_SOCKET")
+
     function init() {}
 
     function getSystemProfileImage() {
-        if (freedeskAvailable && dmsService && dmsService.service) {
+        if (freedeskAvailable) {
             const username = Quickshell.env("USER")
             if (!username) return
 
-            dmsService.service.sendRequest("freedesktop.accounts.getUserIconFile", { username: username }, response => {
+            DMSService.sendRequest("freedesktop.accounts.getUserIconFile", { username: username }, response => {
                 if (response.result && response.result.success) {
                     const iconFile = response.result.value || ""
                     if (iconFile && iconFile !== "" && iconFile !== "/var/lib/AccountsService/icons/") {
@@ -51,8 +52,8 @@ Singleton {
             return
         }
 
-        if (freedeskAvailable && dmsService && dmsService.service) {
+        if (freedeskAvailable) {
-            dmsService.service.sendRequest("freedesktop.accounts.getUserIconFile", { username: username }, response => {
+            DMSService.sendRequest("freedesktop.accounts.getUserIconFile", { username: username }, response => {
                 if (response.result && response.result.success) {
                     const icon = response.result.value || ""
                     if (icon && icon !== "" && icon !== "/var/lib/AccountsService/icons/") {
@@ -85,8 +86,8 @@ Singleton {
     }
 
     function getSystemColorScheme() {
-        if (freedeskAvailable && dmsService && dmsService.service) {
+        if (freedeskAvailable) {
-            dmsService.service.sendRequest("freedesktop.settings.getColorScheme", null, response => {
+            DMSService.sendRequest("freedesktop.settings.getColorScheme", null, response => {
                 if (response.result) {
                     systemColorScheme = response.result.value || 0
 
@@ -134,8 +135,8 @@ Singleton {
     function setSystemProfileImage(imagePath) {
         if (!accountsServiceAvailable) return
 
-        if (freedeskAvailable && dmsService && dmsService.service) {
+        if (freedeskAvailable) {
-            dmsService.service.sendRequest("freedesktop.accounts.setIconFile", { path: imagePath || "" }, response => {
+            DMSService.sendRequest("freedesktop.accounts.setIconFile", { path: imagePath || "" }, response => {
                 if (response.error) {
                     console.warn("PortalService: Failed to set icon file:", response.error)
                 } else {
@@ -150,65 +151,58 @@ Singleton {
     }
 
     Component.onCompleted: {
-        Qt.callLater(initializeDMSConnection)
+        if (socketPath && socketPath.length > 0) {
-    }
+            checkDMSCapabilities()
-
+        } else {
-    function initializeDMSConnection() {
+            console.log("PortalService: DMS_SOCKET not set, using fallback methods")
-        try {
-            dmsService = Qt.createQmlObject('import QtQuick; import qs.Services; QtObject { property var service: DMSService }', root)
-            if (dmsService && dmsService.service) {
-                dmsService.service.connectionStateChanged.connect(onDMSConnectionStateChanged)
-                dmsService.service.capabilitiesChanged.connect(onDMSCapabilitiesChanged)
-                if (dmsService.service.isConnected) {
-                    onDMSConnected()
-                } else {
-                    Qt.callLater(checkFallback)
-                }
-            } else {
-                Qt.callLater(checkFallback)
-            }
-        } catch (e) {
-            console.warn("PortalService: Failed to initialize DMS connection:", e)
-            Qt.callLater(checkFallback)
-        }
-    }
-
-    function checkFallback() {
-        if (!freedeskAvailable) {
-            console.log("PortalService: DMS not available, using fallback methods")
             checkAccountsServiceFallback()
             checkSettingsPortalFallback()
         }
     }
 
-    function onDMSConnectionStateChanged() {
+    Connections {
-        if (dmsService && dmsService.service && dmsService.service.isConnected) {
+        target: DMSService
-            onDMSConnected()
-        }
-    }
 
-    function onDMSCapabilitiesChanged() {
+        function onConnectionStateChanged() {
-        if (dmsService && dmsService.service && dmsService.service.capabilities.includes("freedesktop")) {
+            if (DMSService.isConnected) {
-            freedeskAvailable = true
+                checkDMSCapabilities()
-            checkAccountsService()
-            checkSettingsPortal()
-        }
-    }
-
-    function onDMSConnected() {
-        if (dmsService && dmsService.service && dmsService.service.capabilities && dmsService.service.capabilities.length > 0) {
-            freedeskAvailable = dmsService.service.capabilities.includes("freedesktop")
-            if (freedeskAvailable) {
-                checkAccountsService()
-                checkSettingsPortal()
             }
         }
     }
 
-    function checkAccountsService() {
+    Connections {
-        if (!freedeskAvailable || !dmsService || !dmsService.service) return
+        target: DMSService
+        enabled: DMSService.isConnected
 
-        dmsService.service.sendRequest("freedesktop.getState", null, response => {
+        function onCapabilitiesChanged() {
+            checkDMSCapabilities()
+        }
+    }
+
+    function checkDMSCapabilities() {
+        if (!DMSService.isConnected) {
+            return
+        }
+
+        if (DMSService.capabilities.length === 0) {
+            return
+        }
+
+        freedeskAvailable = DMSService.capabilities.includes("freedesktop")
+        if (freedeskAvailable) {
+            checkAccountsService()
+            checkSettingsPortal()
+        } else {
+            console.log("PortalService: freedesktop capability not available in DMS, using fallback methods")
+            checkAccountsServiceFallback()
+            checkSettingsPortalFallback()
+        }
+    }
+
+    function checkAccountsService() {
+        if (!freedeskAvailable) return
+
+        DMSService.sendRequest("freedesktop.getState", null, response => {
             if (response.result && response.result.accounts) {
                 accountsServiceAvailable = response.result.accounts.available || false
                 if (accountsServiceAvailable) {
@@ -219,9 +213,9 @@ Singleton {
     }
 
     function checkSettingsPortal() {
-        if (!freedeskAvailable || !dmsService || !dmsService.service) return
+        if (!freedeskAvailable) return
 
-        dmsService.service.sendRequest("freedesktop.getState", null, response => {
+        DMSService.sendRequest("freedesktop.getState", null, response => {
             if (response.result && response.result.settings) {
                 settingsPortalAvailable = response.result.settings.available || false
                 if (settingsPortalAvailable) {

Services/SessionService.qml

@@ -46,7 +46,6 @@ Singleton {
     signal prepareForSleep()
     signal loginctlStateChanged()
 
-    property var dmsService: null
     property bool subscriptionConnected: false
     property bool stateInitialized: false
 
@@ -62,7 +61,12 @@ Singleton {
             detectHibernateProcess.running = true
             detectPrimeRunProcess.running = true
             console.log("SessionService: Native inhibitor available:", nativeInhibitorAvailable)
-            Qt.callLater(initializeDMSConnection)
+            if (socketPath && socketPath.length > 0) {
+                checkDMSCapabilities()
+            } else {
+                console.log("SessionService: DMS_SOCKET not set, using fallback")
+                initFallbackLoginctl()
+            }
         }
     }
 
@@ -268,6 +272,25 @@ Singleton {
         }
     }
 
+    Connections {
+        target: DMSService
+
+        function onConnectionStateChanged() {
+            if (DMSService.isConnected) {
+                checkDMSCapabilities()
+            }
+        }
+    }
+
+    Connections {
+        target: DMSService
+        enabled: DMSService.isConnected
+
+        function onCapabilitiesChanged() {
+            checkDMSCapabilities()
+        }
+    }
+
     DankSocket {
         id: subscriptionSocket
         path: root.socketPath
@@ -310,76 +333,32 @@ Singleton {
         })
     }
 
-    function initializeDMSConnection() {
+    function checkDMSCapabilities() {
-        if (!socketPath || socketPath.length === 0) {
+        if (!DMSService.isConnected) {
-            console.log("SessionService: DMS_SOCKET not set, using fallback")
-            initFallbackLoginctl()
             return
         }
 
-        try {
+        if (DMSService.capabilities.length === 0) {
-            dmsService = Qt.createQmlObject('import QtQuick; import qs.Services; QtObject { property var service: DMSService }', root)
+            return
-            if (dmsService && dmsService.service) {
-                dmsService.service.connectionStateChanged.connect(onDMSConnectionStateChanged)
-                dmsService.service.capabilitiesChanged.connect(onDMSCapabilitiesChanged)
-                checkCapabilities()
-            } else {
-                console.warn("SessionService: Failed to get DMS service reference, using fallback")
-                initFallbackLoginctl()
-            }
-        } catch (e) {
-            console.warn("SessionService: Failed to initialize DMS connection, using fallback:", e)
-            initFallbackLoginctl()
         }
-    }
 
-    function checkCapabilities() {
+        if (DMSService.capabilities.includes("loginctl")) {
-        if (dmsService && dmsService.service && dmsService.service.isConnected) {
+            loginctlAvailable = true
-            onDMSConnected()
+            if (!stateInitialized) {
-        }
-    }
-
-    function onDMSConnectionStateChanged() {
-        if (dmsService && dmsService.service && dmsService.service.isConnected) {
-            onDMSConnected()
-        }
-    }
-
-    function onDMSCapabilitiesChanged() {
-        if (dmsService && dmsService.service) {
-            if (dmsService.service.capabilities.includes("loginctl")) {
-                loginctlAvailable = true
-                if (dmsService.service.isConnected && !stateInitialized) {
-                    stateInitialized = true
-                    getLoginctlState()
-                    subscriptionSocket.connected = true
-                }
-            } else if (dmsService.service.capabilities.length > 0 && !loginctlAvailable) {
-                console.log("SessionService: loginctl capability not available in DMS, using fallback")
-                initFallbackLoginctl()
-            }
-        }
-    }
-
-    function onDMSConnected() {
-        if (dmsService && dmsService.service && dmsService.service.capabilities && dmsService.service.capabilities.length > 0) {
-            loginctlAvailable = dmsService.service.capabilities.includes("loginctl")
-
-            if (loginctlAvailable && !stateInitialized) {
                 stateInitialized = true
                 getLoginctlState()
                 subscriptionSocket.connected = true
-            } else if (!loginctlAvailable) {
-                console.log("SessionService: loginctl capability not available in DMS, using fallback")
-                initFallbackLoginctl()
             }
+        } else {
+            console.log("SessionService: loginctl capability not available in DMS, using fallback")
+            initFallbackLoginctl()
         }
     }
 
     function getLoginctlState() {
-        if (!loginctlAvailable || !dmsService || !dmsService.service) return
+        if (!loginctlAvailable) return
 
-        dmsService.service.sendRequest("loginctl.getState", null, response => {
+        DMSService.sendRequest("loginctl.getState", null, response => {
             if (response.result) {
                 updateLoginctlState(response.result)
             }
@@ -425,18 +404,6 @@ Singleton {
         }
     }
 
-    function lockSession() {
-        if (loginctlAvailable && dmsService && dmsService.service) {
-            dmsService.service.sendRequest("loginctl.lock", null, response => {
-                if (response.error) {
-                    console.warn("SessionService: Failed to lock session:", response.error)
-                }
-            })
-        } else {
-            lockSessionFallback.running = true
-        }
-    }
-
     function initFallbackLoginctl() {
         getSessionPathFallback.running = true
     }