feat: add sleep/wake resilience, wallpaper shuffle controls, and stability fixes

This commit introduces several features and robustness improvements
to the Hanabi live wallpaper extension:

## Sleep/Wake Resilience
- Add PrepareForSleep D-Bus listener on org.freedesktop.login1.Manager
  to gracefully handle system suspend and resume cycles.
- SIGKILL the renderer process before suspend to avoid stale GStreamer
  pipelines that cause UI freezes on wake.
- Automatically relaunch the renderer and force playback (setPlay) after
  a configurable delay on resume.
- Introduce an _isSuspending guard to prevent autoPause from
  re-launching the renderer during the suspend window.
- Suppress the playbackState mismatch handler during startup and wake to
  prevent the renderer from being force-paused before it is ready.

## Wallpaper Shuffle & Playback Controls
- Add nextWallpaper and previousWallpaper D-Bus methods in dbus.js and
  renderer.js, enabling external scripts and panel controls to cycle
  through wallpapers.
- Implement shuffle history tracking in the renderer so that
  previousWallpaper navigates back through recently played files.
- Add a smooth fade transition between wallpapers using Clutter opacity
  animation, with a user-configurable fade-duration GSettings key.
- Extend panelMenu.js with Previous Wallpaper button and a label
  showing the current wallpaper filename.

## DING Extension Compatibility
- Guard the get_window_actors override in gnomeShellOverride.js so it is
  skipped when the DING (ding@rastersoft.com) extension is enabled,
  preventing 'replaceData.old_get_window_actors is undefined' errors.
- Wrap _updateBackgrounds, _updateWorkspacesViews, and blur-my-shell
  hooks in _reloadBackgrounds with try-catch for defensive error handling.

## Disposed Actor Safety
- Add an _isDestroyed flag to LiveWallpaper in wallpaper.js, set on the
  destroy signal, to guard against operations on disposed Clutter actors.
- Cancel pending timeouts on destroy to prevent use-after-free crashes.
- Wrap get_window_actors(false) calls in _getRenderer with try-catch.

## Preferences & Schema
- Add fade-duration key to GSettings schema (default: 500 ms).
- Add Fade Transition Duration SpinButton to the preferences UI.

## PlaybackState
- Add suppressMismatch flag to playbackState.js to allow the extension
  to temporarily bypass the isPlayingChanged force-pause logic during
  startup and wake recovery windows.

Files changed:
  src/dbus.js
  src/extension.js
  src/gnomeShellOverride.js
  src/panelMenu.js
  src/playbackState.js
  src/prefs.js
  src/renderer/renderer.js
  src/schemas/io.github.jeffshee.hanabi-extension.gschema.xml
  src/wallpaper.js

Author: ziyadhussain23

src/dbus.js

@@ -34,6 +34,8 @@ export class RendererWrapper {
             <interface name="io.github.jeffshee.HanabiRenderer">
                 <method name="setPlay"/>
                 <method name="setPause"/>
+                <method name="nextWallpaper"/>
+                <method name="previousWallpaper"/>
                 <property name="isPlaying" type="b" access="read"/>
                 <signal name="isPlayingChanged">
                     <arg name="isPlaying" type="b"/>
@@ -61,6 +63,22 @@ export class RendererWrapper {
             this._logger.warn(e);
         }
     }
+
+    async nextWallpaper() {
+        try {
+            await this.proxy.nextWallpaperAsync();
+        } catch (e) {
+            this._logger.warn(e);
+        }
+    }
+
+    async previousWallpaper() {
+        try {
+            await this.proxy.previousWallpaperAsync();
+        } catch (e) {
+            this._logger.warn(e);
+        }
+    }
 }
 
 export class UPowerWrapper {

src/extension.js

@@ -34,6 +34,7 @@ export default class HanabiExtension extends Extension {
         this.launchRendererId = 0;
         this.currentProcess = null;
         this.reloadTime = 100;
+        this._isSuspending = false;
 
         /**
          * This is a safeguard measure for the case of Gnome Shell being relaunched
@@ -106,13 +107,135 @@ export default class HanabiExtension extends Extension {
     innerEnable() {
         this.override.enable();
         this.manager.enable();
-        this.autoPause.enable();
 
         this.isEnabled = true;
         if (this.launchRendererId)
             GLib.source_remove(this.launchRendererId);
 
+        // Launch renderer FIRST, then delay autoPause enable by 3 seconds.
+        // This prevents the Pause on Maximize/Fullscreen module from pausing
+        // the video at startup before the renderer has a chance to start playing.
+        // (Session-restored maximized windows would otherwise trigger autoPause
+        //  while the renderer is still starting, and the PlaybackState mismatch
+        //  handler would immediately pause it.)
         this.launchRenderer();
+
+        this.playbackState.suppressMismatch = true;
+        this._autoPauseDelayId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 5000, () => {
+            this._autoPauseDelayId = null;
+            this.playbackState.suppressMismatch = false;
+            if (this.isEnabled)
+                this.autoPause.enable();
+            return false;
+        });
+
+        // Watch for sleep/wake to restart the renderer on resume.
+        // After sleep, the GStreamer pipeline may stall and take a long time to recover.
+        // Killing and relaunching the renderer ensures a fresh pipeline on wake.
+        this._setupSleepWatch();
+    }
+
+    _setupSleepWatch() {
+        if (this._sleepWatchId)
+            return;
+        try {
+            this._loginProxy = Gio.DBusProxy.new_for_bus_sync(
+                Gio.BusType.SYSTEM,
+                Gio.DBusProxyFlags.NONE,
+                null,
+                'org.freedesktop.login1',
+                '/org/freedesktop/login1',
+                'org.freedesktop.login1.Manager',
+                null
+            );
+            this._sleepWatchId = this._loginProxy.connect('g-signal', (_proxy, _sender, signalName, params) => {
+                if (signalName === 'PrepareForSleep') {
+                    let goingToSleep = params.get_child_value(0).get_boolean();
+                    if (goingToSleep && this.isEnabled) {
+                        this._isSuspending = true;
+                        // Going to sleep - disable autoPause and force-kill renderer
+                        // BEFORE suspend to prevent GStreamer pipeline from freezing
+                        // the UI on wake.
+                        this.autoPause.disable();
+                        this._forceKillRenderer();
+                    } else if (!goingToSleep && this.isEnabled) {
+                        this._isSuspending = false;
+                        // Waking up - relaunch renderer with a fresh pipeline.
+                        this.playbackState.reset();
+                        if (this.launchRendererId) {
+                            GLib.source_remove(this.launchRendererId);
+                            this.launchRendererId = 0;
+                        }
+                        this.launchRenderer();
+
+                        // Cancel any existing autoPause delay
+                        if (this._autoPauseDelayId) {
+                            GLib.source_remove(this._autoPauseDelayId);
+                            this._autoPauseDelayId = null;
+                        }
+                        this._cancelRendererWait();
+
+                        // Suppress the mismatch handler so the renderer isn't
+                        // force-paused while starting up.
+                        this.playbackState.suppressMismatch = true;
+
+                        // After 5 seconds, force-sync: directly tell renderer to
+                        // play via D-Bus (bypassing state machine which has no
+                        // transition from 'playing'), then re-enable autoPause.
+                        this._autoPauseDelayId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 5000, () => {
+                            this._autoPauseDelayId = null;
+                            this.playbackState.suppressMismatch = false;
+                            // Force renderer to play - reset() set state to 'playing'
+                            // but never sent a D-Bus command.
+                            this.playbackState._renderer.setPlay();
+                            if (this.isEnabled && !this._isSuspending)
+                                this.autoPause.enable();
+                            return false;
+                        });
+                    }
+                }
+            });
+        } catch (e) {
+            Logger.Logger.prototype.warn?.call(null, `Failed to setup sleep watch: ${e}`);
+        }
+    }
+
+    _teardownSleepWatch() {
+        if (this._sleepWatchId && this._loginProxy) {
+            this._loginProxy.disconnect(this._sleepWatchId);
+            this._sleepWatchId = null;
+        }
+        this._loginProxy = null;
+    }
+
+    /**
+     * Force-kill the renderer process immediately using SIGKILL.
+     * Used before sleep to ensure the GStreamer pipeline is completely dead
+     * before the system suspends. Also cancels any pending relaunch timer
+     * so the renderer doesn't restart before suspend completes.
+     */
+    _forceKillRenderer() {
+        // Cancel any pending relaunch so renderer doesn't restart before suspend
+        if (this.launchRendererId) {
+            GLib.source_remove(this.launchRendererId);
+            this.launchRendererId = 0;
+        }
+
+        if (this.currentProcess && this.currentProcess.subprocess) {
+            this.currentProcess.cancellable.cancel();
+            // SIGKILL (9) for immediate termination - no graceful shutdown
+            this.currentProcess.subprocess.send_signal(9);
+        }
+
+        this.currentProcess = null;
+        this.manager.set_wayland_client(null);
+    }
+
+    _cancelRendererWait() {
+        if (this._rendererWaitCleanup) {
+            this._rendererWaitCleanup();
+            this._rendererWaitCleanup = null;
+        }
     }
 
     getPlaybackState() {
@@ -163,7 +286,7 @@ export default class HanabiExtension extends Extension {
             }
             this.currentProcess = null;
             this.manager.set_wayland_client(null);
-            if (this.isEnabled) {
+            if (this.isEnabled && !this._isSuspending) {
                 if (this.launchRendererId)
                     GLib.source_remove(this.launchRendererId);
 
@@ -188,6 +311,16 @@ export default class HanabiExtension extends Extension {
         this.manager.disable();
         this.autoPause.disable();
 
+        // Cancel any pending autoPause delay
+        if (this._autoPauseDelayId) {
+            GLib.source_remove(this._autoPauseDelayId);
+            this._autoPauseDelayId = null;
+        }
+
+        this._cancelRendererWait();
+        this._teardownSleepWatch();
+        this._isSuspending = false;
+
         this.isEnabled = false;
         this.killCurrentProcess();
     }

src/gnomeShellOverride.js

@@ -48,25 +48,41 @@ export class GnomeShellOverride {
         this._wallpaperActors.forEach(actor => actor.destroy());
         this._wallpaperActors.clear();
 
-        Main.layoutManager._updateBackgrounds();
+        try {
+            Main.layoutManager._updateBackgrounds();
+        } catch (e) {
+            logger.warn(`Failed to update backgrounds: ${e}`);
+        }
         // `Main.screenShield` is null if the user doesn't use Gnome Shell locking.
-        if (Main.screenShield?._dialog?._updateBackgrounds != null)
-            Main.screenShield._dialog._updateBackgrounds();
+        try {
+            if (Main.screenShield?._dialog?._updateBackgrounds != null)
+                Main.screenShield._dialog._updateBackgrounds();
+        } catch (e) {
+            logger.warn(`Failed to update lockscreen backgrounds: ${e}`);
+        }
 
         /**
          * WorkspaceBackground has its own bgManager,
          * we have to recreate it to use our actors, so it can set radius to our actor.
          */
-        Main.overview._overview._controls._workspacesDisplay._updateWorkspacesViews();
+        try {
+            Main.overview._overview._controls._workspacesDisplay._updateWorkspacesViews();
+        } catch (e) {
+            logger.warn(`Failed to update workspace views: ${e}`);
+        }
 
         /**
          *  Blur My Shell
          */
-        if (Main.extensionManager._enabledExtensions.includes('blur-my-shell@aunetx')) {
-            // This will trigger the `update_backgrounds` method of overview, sceenshot and coverflow alt tab.
-            Main.layoutManager.emit('monitors-changed');
-            // This will trigger the `reset` method of panel.
-            global.display.emit('workareas-changed');
+        try {
+            if (Main.extensionManager._enabledExtensions.includes('blur-my-shell@aunetx')) {
+                // This will trigger the `update_backgrounds` method of overview, sceenshot and coverflow alt tab.
+                Main.layoutManager.emit('monitors-changed');
+                // This will trigger the `reset` method of panel.
+                global.display.emit('workareas-changed');
+            }
+        } catch (e) {
+            logger.warn(`Failed to notify blur-my-shell hooks: ${e}`);
         }
     }
 
@@ -119,20 +135,25 @@ export class GnomeShellOverride {
 
         // This removes the renderer from the window actor list.
         // Call `global.get_window_actors(false)` explicitly to bypass the override.
-        this._injectionManager.overrideMethod(Shell.Global.prototype, 'get_window_actors',
-            originalMethod => {
-                // TODO: pass originalMethod to wallpaper instead
-                return function (hideRenderer = true) {
-                    let windowActors = originalMethod.call(this);
-                    let result = hideRenderer
-                        ? windowActors.filter(
-                            window => !window.meta_window.title?.includes(applicationId)
-                        )
-                        : windowActors;
-                    return result;
-                };
-            }
-        );
+        // NOTE: Desktop Icons NG (DING) also overrides this API and can conflict,
+        // causing GNOME Shell errors/freezes on some systems.
+        const isDingEnabled = Main.extensionManager?._enabledExtensions?.includes('ding@rastersoft.com');
+        if (!isDingEnabled) {
+            this._injectionManager.overrideMethod(Shell.Global.prototype, 'get_window_actors',
+                originalMethod => {
+                    // TODO: pass originalMethod to wallpaper instead
+                    return function (hideRenderer = true) {
+                        let windowActors = originalMethod.call(this);
+                        let result = hideRenderer
+                            ? windowActors.filter(
+                                window => !window.meta_window.title?.includes(applicationId)
+                            )
+                            : windowActors;
+                        return result;
+                    };
+                }
+            );
+        }
 
         // These remove the renderer's window preview in overview.
         this._injectionManager.overrideMethod(Workspace.Workspace.prototype, '_isOverviewWindow',