fix(quickshell): restore night mode and OSD surfaces after resume (#2254)

2026-05-02 02:22:06 -04:00 · 2026-04-22 16:08:50 +02:00
parent 8d49a5cbfc
commit 1cf0dd1031
4 changed files with 251 additions and 72 deletions
--- a/quickshell/Common/Theme.qml
+++ b/quickshell/Common/Theme.qml
@@ -346,12 +346,11 @@ Singleton {
        function onLoginctlEvent(event) {
            if (!SessionData.themeModeAutoEnabled)
                return;
-            if (event.event === "unlock" || event.event === "resume") {
-                if (!themeAutoBackendAvailable()) {
-                    root.evaluateThemeMode();
-                    return;
-                }
-                DMSService.sendRequest("theme.auto.trigger", {});
+            if (typeof SettingsData !== "undefined" && SettingsData.loginctlLockIntegration)
+                return;
+            const eventType = String(event?.type || event?.event || "").toLowerCase();
+            if (eventType === "unlock") {
+                root.triggerThemeAutomationRefresh();
            }
        }

@@ -414,6 +413,27 @@ Singleton {
        }
    }

+    Connections {
+        target: SessionService
+        enabled: typeof SessionService !== "undefined" && typeof SessionData !== "undefined" && SessionData.themeModeAutoEnabled
+
+        function onSessionUnlocked() {
+            root.triggerThemeAutomationRefresh();
+        }
+
+        function onSessionResumed() {
+            root.triggerThemeAutomationRefresh();
+        }
+    }
+
+    function triggerThemeAutomationRefresh() {
+        if (!themeAutoBackendAvailable()) {
+            root.evaluateThemeMode();
+            return;
+        }
+        DMSService.sendRequest("theme.auto.trigger", {});
+    }
+
    function applyGreeterTheme(themeName) {
        switchTheme(themeName, false, false);
        if (themeName === dynamic && dynamicColorsFileView.path) {
--- a/quickshell/DMSShell.qml
+++ b/quickshell/DMSShell.qml
@@ -27,6 +27,15 @@ import qs.Services
 Item {
    id: root

+    property bool osdSurfacesLoaded: true
+    property int pendingOsdResumeReloads: 0
+
+    function recreateOsdSurfaces() {
+        OSDManager.currentOSDsByScreen = ({});
+        osdSurfacesLoaded = false;
+        osdSurfaceReloadTimer.restart();
+    }
+
    Instantiator {
        id: daemonPluginInstantiator
        asynchronous: true
@@ -221,6 +230,33 @@ Item {
        }
    }

+    Timer {
+        id: osdResumeRecreateTimer
+        interval: 400
+        repeat: false
+        onTriggered: {
+            root.recreateOsdSurfaces();
+
+            if (root.pendingOsdResumeReloads > 1) {
+                root.pendingOsdResumeReloads--;
+                interval = 1400;
+                restart();
+                return;
+            }
+
+            root.pendingOsdResumeReloads = 0;
+            interval = 400;
+        }
+    }
+
+    Timer {
+        id: osdSurfaceReloadTimer
+        interval: 120
+        repeat: false
+        onTriggered: root.osdSurfacesLoaded = true
+    }
+
+
    Component.onCompleted: {
        dockRecreateDebounce.start();
        // Force PolkitService singleton to initialize
@@ -716,6 +752,16 @@ Item {
        }
    }

+    Connections {
+        target: SessionService
+
+        function onSessionResumed() {
+            root.pendingOsdResumeReloads = 2;
+            osdResumeRecreateTimer.interval = 400;
+            osdResumeRecreateTimer.restart();
+        }
+    }
+
    DankColorPickerModal {
        id: colorPickerModal

@@ -890,51 +936,85 @@ Item {
        }
    }

-    Variants {
-        model: SettingsData.getFilteredScreens("osd")
+    Loader {
+        id: osdSurfacesLoader
+        active: root.osdSurfacesLoaded
+        asynchronous: false

-        delegate: VolumeOSD {
-            modelData: item
-        }
-    }
+        sourceComponent: Component {
+            Item {
+                Variants {
+                    model: SettingsData.getFilteredScreens("osd")

-    Variants {
-        model: SettingsData.getFilteredScreens("osd")
+                    delegate: VolumeOSD {
+                        modelData: item
+                    }
+                }

-        delegate: MediaVolumeOSD {
-            modelData: item
-        }
-    }
+                Variants {
+                    model: SettingsData.getFilteredScreens("osd")

-    Variants {
-        model: SettingsData.getFilteredScreens("osd")
+                    delegate: MediaVolumeOSD {
+                        modelData: item
+                    }
+                }

-        delegate: MediaPlaybackOSD {
-            modelData: item
-        }
-    }
+                Variants {
+                    model: SettingsData.getFilteredScreens("osd")

-    Variants {
-        model: SettingsData.getFilteredScreens("osd")
+                    delegate: MediaPlaybackOSD {
+                        modelData: item
+                    }
+                }

-        delegate: MicMuteOSD {
-            modelData: item
-        }
-    }
+                Variants {
+                    model: SettingsData.getFilteredScreens("osd")

-    Variants {
-        model: SettingsData.getFilteredScreens("osd")
+                    delegate: MicMuteOSD {
+                        modelData: item
+                    }
+                }

-        delegate: BrightnessOSD {
-            modelData: item
-        }
-    }
+                Variants {
+                    model: SettingsData.getFilteredScreens("osd")

-    Variants {
-        model: SettingsData.getFilteredScreens("osd")
+                    delegate: BrightnessOSD {
+                        modelData: item
+                    }
+                }

-        delegate: IdleInhibitorOSD {
-            modelData: item
+                Variants {
+                    model: SettingsData.getFilteredScreens("osd")
+
+                    delegate: IdleInhibitorOSD {
+                        modelData: item
+                    }
+                }
+
+                Variants {
+                    model: SettingsData.osdPowerProfileEnabled ? SettingsData.getFilteredScreens("osd") : []
+
+                    delegate: PowerProfileOSD {
+                        modelData: item
+                    }
+                }
+
+                Variants {
+                    model: SettingsData.getFilteredScreens("osd")
+
+                    delegate: CapsLockOSD {
+                        modelData: item
+                    }
+                }
+
+                Variants {
+                    model: SettingsData.getFilteredScreens("osd")
+
+                    delegate: AudioOutputOSD {
+                        modelData: item
+                    }
+                }
+            }
        }
    }

@@ -944,30 +1024,6 @@ Item {
        source: "Services/PowerProfileWatcher.qml"
    }

-    Variants {
-        model: SettingsData.osdPowerProfileEnabled ? SettingsData.getFilteredScreens("osd") : []
-
-        delegate: PowerProfileOSD {
-            modelData: item
-        }
-    }
-
-    Variants {
-        model: SettingsData.getFilteredScreens("osd")
-
-        delegate: CapsLockOSD {
-            modelData: item
-        }
-    }
-
-    Variants {
-        model: SettingsData.getFilteredScreens("osd")
-
-        delegate: AudioOutputOSD {
-            modelData: item
-        }
-    }
-
    LazyLoader {
        id: hyprlandOverviewLoader
        active: CompositorService.isHyprland
--- a/quickshell/Services/DisplayService.qml
+++ b/quickshell/Services/DisplayService.qml
@@ -40,6 +40,7 @@ Singleton {
    property bool nightModeEnabled: false
    property bool automationAvailable: false
    property bool gammaControlAvailable: false
+    property int resumeRecoveryAttempt: 0

    property var gammaState: ({})
    property int gammaCurrentTemp: gammaState?.currentTemp ?? 0
@@ -672,6 +673,15 @@ Singleton {
        }
    }

+    function runResumeRecoveryPass() {
+        checkGammaControlAvailability();
+        rescanDevices();
+
+        if (nightModeEnabled) {
+            evaluateNightMode();
+        }
+    }
+
    function checkGammaControlAvailability() {
        if (!DMSService.isConnected) {
            return;
@@ -730,6 +740,26 @@ Singleton {
        }
    }

+    Timer {
+        id: resumeRecoveryTimer
+        interval: 400
+        repeat: false
+
+        onTriggered: {
+            runResumeRecoveryPass();
+            resumeRecoveryAttempt++;
+
+            if (resumeRecoveryAttempt < 3) {
+                interval = resumeRecoveryAttempt === 1 ? 1400 : 2600;
+                restart();
+                return;
+            }
+
+            resumeRecoveryAttempt = 0;
+            interval = 400;
+        }
+    }
+
    function rescanDevices() {
        if (!DMSService.isConnected) {
            return;
@@ -815,18 +845,23 @@ Singleton {
            updateSingleDevice(device);
        }

-        function onLoginctlEvent(event) {
-            if (event.event === "unlock" || event.event === "resume") {
-                suppressOsd = true;
-                osdSuppressTimer.restart();
-            }
-        }
-
        function onGammaStateUpdate(data) {
            root.gammaState = data;
        }
    }

+    Connections {
+        target: SessionService
+
+        function onSessionResumed() {
+            suppressOsd = true;
+            osdSuppressTimer.restart();
+            resumeRecoveryAttempt = 0;
+            resumeRecoveryTimer.interval = 400;
+            resumeRecoveryTimer.restart();
+        }
+    }
+
    // Session Data Connections
    Connections {
        target: SessionData
--- a/quickshell/Services/SessionService.qml
+++ b/quickshell/Services/SessionService.qml
@@ -48,6 +48,9 @@ Singleton {
    signal loginctlStateChanged

    property bool stateInitialized: false
+    property string prepareForSleepSubscriptionId: ""
+    property bool prepareForSleepSubscriptionPending: false
+    property double lastResumeSignalTimestamp: 0

    readonly property string socketPath: Quickshell.env("DMS_SOCKET")

@@ -457,10 +460,13 @@ Singleton {
        function onConnectionStateChanged() {
            if (DMSService.isConnected) {
                checkDMSCapabilities();
+            } else {
+                clearPrepareForSleepSubscriptionState();
            }
        }

        function onCapabilitiesReceived() {
+            checkDMSCapabilities();
            syncSleepInhibitor();
        }
    }
@@ -472,6 +478,13 @@ Singleton {
        function onCapabilitiesChanged() {
            checkDMSCapabilities();
        }
+
+        function onDbusSignalReceived(subscriptionId, data) {
+            if (subscriptionId !== prepareForSleepSubscriptionId) {
+                return;
+            }
+            handlePrepareForSleepSignal(data);
+        }
    }

    Connections {
@@ -533,6 +546,61 @@ Singleton {
            loginctlAvailable = false;
            console.log("SessionService: loginctl capability not available in DMS");
        }
+
+        if (DMSService.capabilities.includes("dbus")) {
+            ensurePrepareForSleepSubscription();
+        } else {
+            clearPrepareForSleepSubscriptionState();
+        }
+    }
+
+    function clearPrepareForSleepSubscriptionState() {
+        prepareForSleepSubscriptionId = "";
+        prepareForSleepSubscriptionPending = false;
+    }
+
+    function ensurePrepareForSleepSubscription() {
+        if (!DMSService.isConnected || !DMSService.capabilities.includes("dbus")) {
+            return;
+        }
+
+        if (prepareForSleepSubscriptionId || prepareForSleepSubscriptionPending) {
+            return;
+        }
+
+        prepareForSleepSubscriptionPending = true;
+        DMSService.dbusSubscribe("system", "org.freedesktop.login1", "/org/freedesktop/login1", "org.freedesktop.login1.Manager", "PrepareForSleep", response => {
+            prepareForSleepSubscriptionPending = false;
+
+            if (response.error) {
+                console.warn("SessionService: Failed to subscribe to PrepareForSleep:", response.error);
+                return;
+            }
+
+            prepareForSleepSubscriptionId = response.result?.subscriptionId || "";
+        });
+    }
+
+    function emitSessionResumedOnce() {
+        const now = Date.now();
+        if ((now - lastResumeSignalTimestamp) < 1000) {
+            return;
+        }
+        lastResumeSignalTimestamp = now;
+        sessionResumed();
+    }
+
+    function handlePrepareForSleepSignal(data) {
+        if (!data?.body || data.body.length === 0) {
+            return;
+        }
+
+        const wasSleeping = preparingForSleep;
+        preparingForSleep = data.body[0] === true;
+
+        if (wasSleeping && !preparingForSleep) {
+            emitSessionResumedOnce();
+        }
    }

    function getLoginctlState() {
@@ -598,7 +666,7 @@ Singleton {
        }

        if (wasSleeping && !preparingForSleep) {
-            sessionResumed();
+            emitSessionResumedOnce();
        }

        loginctlStateChanged();