MPRIS: Switching from python-sdbus to jeepney, no functionality.

wobuzz/mpris/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/python3
+
+from .server import MPRISServer
+

wobuzz/mpris/dbus_properties.py

@@ -0,0 +1,67 @@
+#!/usr/bin/python3
+
+from jeepney import Header, MessageType, Endianness, MessageFlag, new_method_return
+from jeepney.bus_messages import message_bus
+from jeepney.io.blocking import open_dbus_connection
+from jeepney.wrappers import new_header
+
+from .utils import *
+
+
+class DBusProperties(DBusInterface):
+    def get_all(self):
+        body = ({},)
+        return body
+
+    def properties_changed(self, interface: str):
+        body = None
+
+        if interface == MPRIS_ROOT_INTERFACE:
+            body = (MPRIS_ROOT_INTERFACE,) + self.server.root_interface.get_all()
+
+        elif interface == MPRIS_PLAYER_INTERFACE:
+            body = (MPRIS_PLAYER_INTERFACE,) + self.server.player_interface.get_all()
+
+        signature = "" if body is None else "sa{sv}"
+
+        msg = new_signal(
+            self.server.bus_address.with_interface("org.freedesktop.DBus"),
+            "PropertiesChanged",
+            signature,
+            body
+        )
+        self.server.bus.send(msg)
+
+    def Get(self, msg: Message):
+        interface_name = msg.body[0]
+
+        return_msg = None
+
+        if interface_name == PROPERTIES_INTERFACE:
+            return self.get(msg)
+
+        elif interface_name == MPRIS_ROOT_INTERFACE:
+            return self.server.root_interface.get(msg)
+
+        elif interface_name == MPRIS_PLAYER_INTERFACE:
+            return self.server.player_interface.get(msg)
+
+        else:
+            return new_error(msg, *DBusErrors.invalidArgs(interface=interface_name))
+
+    def GetAll(self, msg: Message):
+        interface = msg.body[0]
+
+        if interface == PROPERTIES_INTERFACE:
+            body = self.get_all()
+
+        elif interface == MPRIS_ROOT_INTERFACE:
+            body = self.server.root_interface.get_all()
+
+        elif interface == MPRIS_PLAYER_INTERFACE:
+            body = self.server.player_interface.get_all()
+
+        else:
+            return new_error(msg, *DBusErrors.invalidArgs(interface=interface))
+
+        return new_method_return(msg, "a{sv}", body)

wobuzz/mpris/mpris_player.py

@@ -0,0 +1,34 @@
+#!/usr/bin/python3
+
+from jeepney import new_method_return
+
+from .utils import *
+
+
+class MPRISPlayer(DBusInterface):
+    def __init__(self, server, interface):
+        super().__init__(server, interface)
+
+        self.metadata = {
+            "mpris:trackid": ("o", "/org/mpris/MediaPlayer2/murx"),  # random junk, no functionality
+            "xesam:title": ("s", "Huggenburgl")
+        }
+
+    def get_all(self):
+        body = ({
+            "CanPlay": ("b", True),
+            "Metadata": ("a{sv}", self.metadata)
+        },)
+
+        return body
+
+    def Play(self, msg: Message):
+        print("Play!")
+
+    def PlayPause(self, msg: Message):
+        print("Play/Pause!")
+
+    def Metadata(self, msg: Message):
+        body = (self.metadata,)
+
+        return new_method_return(msg, "a{sv}", body)

wobuzz/mpris/mpris_root.py

@@ -0,0 +1,16 @@
+#!/usr/bin/python3
+
+from .utils import *
+
+
+class MPRISRoot(DBusInterface):
+    def get_all(self):
+        body = ({
+            "CanQuit": ("b", True),
+            "CanRaise": ("b", True)
+        },)
+
+        return body
+
+    def Raise(self, msg):
+        print("Raise!")

wobuzz/mpris/server.py

@@ -0,0 +1,68 @@
+#!/usr/bin/python3
+
+from threading import Thread
+from jeepney.bus_messages import message_bus
+from jeepney.io.blocking import DBusConnection, open_dbus_connection
+
+from .utils import *
+from .dbus_properties import DBusProperties
+from .mpris_root import MPRISRoot
+from .mpris_player import MPRISPlayer
+
+
+class MPRISServer:
+    def __init__(self, app):
+        self.app = app
+
+        self.properties_interface = DBusProperties(self, PROPERTIES_INTERFACE)
+        self.root_interface = MPRISRoot(self, MPRIS_ROOT_INTERFACE)
+        self.player_interface = MPRISPlayer(self, MPRIS_PLAYER_INTERFACE)
+
+        self.bus_address = DBusAddress(OBJECT_PATH, SERVICE_NAME, PROPERTIES_INTERFACE)
+        self.bus: DBusConnection = None
+
+    def start(self):
+        self.bus = open_dbus_connection()
+
+        reply = self.bus.send_and_get_reply(message_bus.RequestName(SERVICE_NAME))
+        if reply.body[0] == 1:
+            print("MPRIS Server connected to DBus: ", SERVICE_NAME)
+
+        Thread(target=self.run_event_loop, daemon=True).start()
+
+    def run_event_loop(self):
+        while True:
+            msg = self.bus.receive()
+            self.app.gui.window.mpris_signal.emit(msg)  # queue message in the PyQt event loop
+
+    def handle_event(self, event):  # called by app.gui.window.mpris_signal
+        self.handle_message(event)
+
+    def handle_message(self, msg: Message):
+        object_path = msg.header.fields[HeaderFields.path]
+
+        if not object_path == OBJECT_PATH:  # only accept messages for "/org/mpris/MediaPlayer2"
+            self.bus.send_message(new_error(msg, *DBusErrors.unknownObject(object_path)))
+            return
+
+        interface = msg.header.fields[HeaderFields.interface]
+
+        # let the corresponding interface handle the message
+        if interface == PROPERTIES_INTERFACE:
+            self.properties_interface.handle_message(msg)
+
+        elif interface == MPRIS_ROOT_INTERFACE:
+            self.root_interface.handle_message(msg)
+
+        elif interface == MPRIS_PLAYER_INTERFACE:
+            self.player_interface.handle_message(msg)
+
+    def on_playstate_update(self):
+        current_playlist = self.app.player.current_playlist
+
+        if current_playlist is not None and current_playlist.current_track is not None:
+            current_track = current_playlist.current_track
+
+            self.player_interface.metadata["xesam:title"] = ("s", current_track.metadata.title)
+
+        self.properties_interface.properties_changed(MPRIS_PLAYER_INTERFACE)

wobuzz/mpris/utils.py

@@ -0,0 +1,96 @@
+#!/usr/bin/python3
+
+from jeepney import DBusAddress, Message, MessageType, HeaderFields, new_error, new_signal
+
+
+SERVICE_NAME = "org.mpris.MediaPlayer2.wobuzz"
+OBJECT_PATH = "/org/mpris/MediaPlayer2"
+PROPERTIES_INTERFACE = "org.freedesktop.DBus.Properties"
+MPRIS_ROOT_INTERFACE = "org.mpris.MediaPlayer2"
+MPRIS_PLAYER_INTERFACE = "org.mpris.MediaPlayer2.Player"
+
+
+class DBusErrors:
+    @classmethod
+    def unknownMethod(cls, method: str) -> tuple[str, str, tuple[str]]:
+        return "org.freedesktop.DBus.Error.UnknownMethod", "s", (f"No such method '{method}'.",)
+
+    @classmethod
+    def unknownProperty(cls, prop: str) -> tuple[str, str, tuple[str]]:
+        return "org.freedesktop.DBus.Error.InvalidArgs", "s", (f"No such property '{prop}'",)
+
+    @classmethod
+    def invalidArgs(cls, prop: str=None, interface: str=None):
+        if prop is None and interface is None:
+            return "org.freedesktop.DBus.Error.InvalidArgs"
+
+        if interface is None:
+            return "org.freedesktop.DBus.Error.InvalidArgs", "s", (f"No such property '{prop}'.",)
+
+        if prop is None:
+            return "org.freedesktop.DBus.Error.InvalidArgs", "s", (f"No such interface '{interface}'.",)
+
+        return (
+            "org.freedesktop.DBus.Error.InvalidArgs",
+            "s",
+            (f"No such property '{prop}' on interface '{interface}'.",)
+        )
+
+    @classmethod
+    def unknownObject(cls, path: str):
+        return "org.freedesktop.DBus.Error.UnknownObject", "s", (f"No such object on path '{path}'.",)
+
+
+class DBusInterface:
+    def __init__(self, server, interface: str):
+        self.server = server
+        self.interface = interface
+
+    def __setattr__(self, key: str, value) -> None:
+        super().__setattr__(key, value)
+
+        if not key[0].isupper() and not callable(value) and hasattr(self, key.title()):
+            getter = getattr(self, key.title())
+
+            if callable(getter):
+                if hasattr(self.server, "bus"):
+                    self.server.properties_interface.properties_changed(self.interface)
+
+    def handle_message(self, msg: Message):
+        return_msg = None
+
+        match msg.header.message_type:
+            case MessageType.method_call:
+                method_name: str = msg.header.fields[HeaderFields.member]
+
+                if hasattr(self, method_name) and method_name[0].isupper():
+                    method = getattr(self, msg.header.fields[HeaderFields.member])
+
+                    if callable(method):
+                        return_msg = method(msg)
+
+                    else:
+                        return_msg = new_error(msg, *DBusErrors.unknownMethod(method_name))
+
+                else:
+                    return_msg = new_error(msg, *DBusErrors.unknownMethod(method_name))
+
+        if return_msg is not None:
+            self.server.bus.send_message(return_msg)
+
+    def get(self, msg: Message):
+        prop_name: str = msg.body[1]
+
+        if prop_name[0].isupper() and hasattr(self, prop_name):
+            prop = getattr(self, prop_name)
+
+            if callable(prop):
+                return prop()
+
+            return new_error(msg, *DBusErrors.unknownProperty(prop_name))
+
+        else:
+            return new_error(msg, *DBusErrors.unknownProperty(prop_name))
+
+    def get_all(self) -> tuple[dict[str: tuple[str: any]]]:
+        raise NotImplementedError