Active window wayland

[TheOddPirate]

Had some problems with the active window module not working with wayland on ubuntu, and using x11 fucked up video playback in kodi so i ended up with a new module to fix this

the module is slapped together in 2 minutes and i do not know python so it can probably be made in a better way but it is what it is

The module uses this gnome extension
https://github.com/flexagoon/focused-window-dbus

"""Gets the active window"""
from lnxlink.modules.scripts.helpers import import_install_package
import subprocess
import ast



class Addon:
    """Addon module"""

    def __init__(self, lnxlink):
        """Setup addon"""
        self.name = "Active Window"
        self.lnxlink = lnxlink


    def exposed_controls(self):
        """Exposes to home assistant"""
        return {
            "Active Window": {
                "type": "sensor",
                "icon": "mdi:book-open-page-variant",
            },
        }

    def get_info(self):
        """Gather information from the system"""
        app_command = ("gdbus call --session --dest org.gnome.Shell --object-path /org/gnome/shell/extensions/FocusedWindow --method org.gnome.shell.extensions.FocusedWindow.Get")
        app_process = subprocess.Popen(app_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        app_retval = app_process.stdout.read()
        app_retcode = app_process.wait()

        app_tuple_string = app_retval.decode('utf-8').strip()
        x = app_tuple_string.split(":")
        title = x[1].replace("\"","")
        title = title.replace(",wm_class","")
        return title

[bkbilly]

Thank you for this custom module, but could you explain further what is the issue with the current active_window module?

PS: The gdbus command returns a json with a few issues. I am just writing it as a suggestion how I would read the output:

import json
title = json.loads(app_retval.strip("(),'"))["title"]

[TheOddPirate]

With wayland enabled on ubuntu 24.04 i dont get anything from the current active window

this is the result from default active_window

this is with my module

I tried to apply your json fix for reading it but i always get this error here

Aug 31 15:46:53 n0tDesktop lnxlink[114287]:   File "/usr/lib/python3.12/json/__init__.py", line 346, in loads
Aug 31 15:46:53 n0tDesktop lnxlink[114287]:     return _default_decoder.decode(s)
Aug 31 15:46:53 n0tDesktop lnxlink[114287]:            ^^^^^^^^^^^^^^^^^^^^^^^^^^
Aug 31 15:46:53 n0tDesktop lnxlink[114287]:   File "/usr/lib/python3.12/json/decoder.py", line 340, in decode
Aug 31 15:46:53 n0tDesktop lnxlink[114287]:     raise JSONDecodeError("Extra data", s, end)
Aug 31 15:46:53 n0tDesktop lnxlink[114287]: json.decoder.JSONDecodeError: Extra data: line 1 column 476 (char 475)

[TheOddPirate]

So i changed to manjaro with kde a couple days ago and ended up updating this active window module again, now it got support for x11 via the default method in lnxlink, wayland gnome with a self installing gnome extension and kde wayland via kdotool (this needs to be manually installed)

it probably needs some cleanup in the code, but it works.

"""Gets the active window"""
import os
import json
import logging
from lnxlink.modules.scripts.helpers import import_install_package, syscommand

logger = logging.getLogger("lnxlink")

class Addon:
    """Addon module"""

    def __init__(self, lnxlink):
        """Setup addon"""
        self.name = "Active Window"
        self.lnxlink = lnxlink
        self.display_type = self._detect_environment()
        self._requirements()

    def _requirements(self):
        if self.display_type in ("x11", "kde_x11"):
            self.lib = {
                "ewmh": import_install_package("ewmh", ">=0.1.6"),
                "xlib": import_install_package("python-xlib", ">=0.33", "Xlib.display"),
            }
        elif self.display_type == "gnome_wayland":
            self.jeepney = import_install_package(
                "jeepney",
                ">=0.9.0",
                (
                    "jeepney",
                    [
                        "DBusAddress",
                        "new_method_call",
                        "io.blocking.open_dbus_connection",
                    ],
                ),
            )
            if not self._is_extension_installed():
                logger.info("Installing focused-window-dbus extension...")
                self.gnome_ext = import_install_package(
                    "gnome-extensions-cli",
                    ">=0.3.0",
                    (
                        "gnome_extensions_cli",
                        ["GnomeExtensions"],
                    ),
                )
                try:
                    ge = self.gnome_ext.GnomeExtensions()
                    extension_uuid = "focused-window-dbus@flexagoon.com"
                    ge.install(extension_uuid)
                    ge.enable(extension_uuid)
                    logger.info("Extension installed and enabled. Reboot may be required.")
                except Exception as e:
                    logger.error(f"Error installing GNOME extension: {e}")

    def _detect_environment(self):
        desktop = os.environ.get("XDG_CURRENT_DESKTOP", "").lower()
        session = os.environ.get("XDG_SESSION_TYPE", "").lower()
        wayland_display = os.environ.get("WAYLAND_DISPLAY")

        logger.debug(f"Desktop: {desktop}, Session: {session}")

        if "gnome" in desktop:
            if wayland_display:
                return "gnome_wayland"
            else:
                return "x11"
        elif "kde" in desktop:
            if wayland_display:
                return "kde_wayland"
            else:
                return "kde_x11"
        return "x11" if session == "x11" else "unknown"

    def _is_extension_installed(self, extension_name="focused-window-dbus@flexagoon.com"):
        stdout, _, returncode = syscommand("gnome-extensions list")
        if returncode == 0:
            return extension_name in stdout.splitlines()
        logger.error("Failed to run `gnome-extensions list`")
        return False

    def exposed_controls(self):
        return {
            "Active Window": {
                "type": "sensor",
                "icon": "mdi:book-open-page-variant",
            },
        }

    def get_info(self):
        try:
            if self.display_type in ("x11", "kde_x11"):
                if self.lnxlink.display is None:
                    return ""
                display = self.lib["xlib"].display.Display(self.lnxlink.display)
                ewmh = self.lib["ewmh"].EWMH(_display=display)
                win = ewmh.getActiveWindow()
                window_name = ewmh.getWmName(win)
                return window_name.decode() if window_name else "No active window"

            elif self.display_type == "gnome_wayland":
                connection = self.jeepney.io.blocking.open_dbus_connection(bus="SESSION")
                address = self.jeepney.DBusAddress(
                    bus_name="org.gnome.Shell",
                    object_path="/org/gnome/shell/extensions/FocusedWindow",
                    interface="org.gnome.shell.extensions.FocusedWindow"
                )
                message = self.jeepney.new_method_call(address, "Get", "")
                reply = connection.send_and_get_reply(message)
                connection.close()

                if reply.body:
                    try:
                        data = json.loads(reply.body[0])
                        return data.get("title", "Unknown")
                    except Exception as e:
                        logger.warning(f"GNOME Wayland: Failed to parse window info: {e}")
                return "No active window"

            elif self.display_type == "kde_wayland":
                stdout, stderr, returncode = syscommand("kdotool getwindowname $(kdotool getactivewindow)")
                if returncode == 0:
                    return stdout.strip()
                else:
                    logger.error(f"KDE Wayland: kdotool failed: {stderr.strip()}")
                    return "Unknown"

            else:
                logger.warning(f"Unknown display environment: {self.display_type}")
                return "Unknown"

        except Exception as e:
            logger.error(f"Unhandled error in get_info(): {e}")
            return "Unknown"

[AroPix]

I just wanted to write my own module using kdotool but your module works great, this should be upstreamed to the repo imo. :)

[TheOddPirate]

Im happy to hear its been working for you. Ive run into a bug where it thinks its on x11 instead of wayland so ive moved the check for this until i get the time to rewrite it

uploaded as txt file so rename before use
active_window_wayland.txt