chrome-mpris2

#!/usr/bin/env python3

import json
import struct
import sys
from collections import defaultdict

from gi.repository import Gio, GLib


def debug(msg):
    print(msg, file=sys.stderr, flush=True)


def make_streams_binary():
    sys.stdin = sys.stdin.detach()
    sys.stdout = sys.stdout.detach()


def escape_object_path(objpath):
    # We basically URI escape but instead of % we use _
    return (GLib.uri_escape_string(objpath, None, False)
            .replace(".", "%2E")
            .replace("-", "%2D")
            .replace("~", "%7E")
            .replace("_", "%5F")
            .replace("%", "_"))


def unescape_object_path(objpath):
    return GLib.uri_unescape_string(objpath.replace("_", "%"))


def encode_msg(msg):
    try:
        text = json.dumps(msg)
    except ValueError:
        return 0

    data = text.encode("utf-8")
    length_bytes = struct.pack("@i", len(data))
    written = sys.stdout.write(length_bytes) + sys.stdout.write(data)

    # We flush to make sure that Chrome gets the message *right now*
    sys.stdout.flush()
    return written


def decode_msg():
    # Read the message length (first 4 bytes).
    length_bytes = sys.stdin.read(4)
    if len(length_bytes) < 4:
        raise ValueError("unexpected end of input")

    # Unpack message length as 4 byte integer.
    length = struct.unpack('@i', length_bytes)[0]

    # Read the text (JSON object) of the message.
    text = sys.stdin.read(length).decode("utf-8")
    return json.loads(text)


class DBusService:
    def __init__(self, conn, name, path, flags=Gio.BusNameOwnerFlags.NONE):
        self._conn = conn
        self._name = name
        self._path = path

        self.__reg_ids = []

        self._properties = {}
        self._methods = {
            # "org.freedesktop.DBus.Properties": {
            #     "Get": ("ss", ("v",)),
            #     "GetAll": ("s", ("a{sv}",)),
            #     "Set": ("ssv", ()),
            # }
        }

        node_info = Gio.DBusNodeInfo.new_for_xml(self.__doc__)
        for iface in node_info.interfaces:
            self._methods[iface.name] = {
                meth.name: (tuple(a.signature for a in meth.out_args),
                            tuple(a.signature for a in meth.in_args))
                for meth in iface.methods
            }

            self._properties[iface.name] = {
                prop.name: prop.signature
                for prop in iface.properties
                if prop.flags & Gio.DBusPropertyInfoFlags.READABLE
            }

            self.__reg_ids.append(
                self._conn.register_object(path, iface, self.on_method_call)
            )

        self.__own_id = Gio.bus_own_name_on_connection(self._conn, name, flags)

    def unpublish(self):
        for i in self.__reg_ids:
            self._conn.unregister_object(i)
        Gio.bus_unown_name(self.__own_id)
        self._conn.close_sync()

    def on_method_call(self, conn, sender, objpath, iface_name, method_name,
                       params, invocation):

        # FIXME: move somewhere else
        if iface_name == "org.freedesktop.DBus.Properties":
            if method_name == "Get":
                self.get_property(conn, sender, objpath, *params, invocation)
            elif method_name == "GetAll":
                self.get_all_properties(conn, sender, objpath, *params,
                                        invocation)
            elif method_name == "Set":
                self.set_property(conn, sender, objpath, *params, invocation)
            return

        in_args, out_args = self._methods[iface_name][method_name]

        fd_list = invocation.get_message().get_unix_fd_list()
        args = [fd_list.get(a) if sig == "h" else a
                for a, sig in zip(params.unpack(), in_args)]

        try:
            res = getattr(self, method_name)(*args)

            if not out_args:
                res = None
            elif len(out_args) == 1:
                res = GLib.Variant("(%s)" % "".join(out_args), (res,))
            else:
                res = GLib.Variant("(%s)" % "".join(out_args), res)

            invocation.return_value(res)

        except Exception as e:
            e_type = type(e).__name__
            if "." not in e_type:
                e_type = "org.python." + e_type
            invocation.return_dbus_error(e_type, str(e))

    def get_property(self, conn, sender, objpath, iface_name, prop_name,
                     invocation):
        typ = self._properties[iface_name][prop_name]
        variant = GLib.Variant(typ, getattr(self, prop_name))
        invocation.return_value(GLib.Variant("(v)", (variant,)))

    def get_all_properties(self, conn, sender, objpath, iface_name,
                           invocation):
        all_props = {p: GLib.Variant(t, getattr(self, p))
                     for p, t in self._properties[iface_name].items()}
        invocation.return_value(GLib.Variant("(a{sv})", (all_props,)))

    def set_property(self, conn, sender, objpath, iface_name, prop_name, value,
                     invocation):
        setattr(self, prop_name, value)
        invocation.return_value(None)

    # SIGNALS
    def PropertiesChanged(self, iface_name, changed_props, invalidated_props):
        # we assume readable properties
        typed_changed_props = {
            p: GLib.Variant(self._properties[iface_name][p], v)
            for p, v in changed_props.items()
        }

        self._conn.emit_signal(
            None,
            self._path,
            "org.freedesktop.DBus.Properties",
            "PropertiesChanged",
            GLib.Variant.new_tuple(
                GLib.Variant("s", iface_name),
                GLib.Variant("a{sv}", typed_changed_props),
                GLib.Variant("as", invalidated_props)))


class MediaPlayer2(DBusService):
    """
    <node>
    <interface name="org.mpris.MediaPlayer2">
        <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="true"/>

        <method name="Raise"/>
        <method name="Quit"/>

        <property name="Identity"            type="s"  access="read"/>
        <!--
        <property name="DesktopEntry"        type="s"  access="read">
            <annotation name="org.mpris.MediaPlayer2.property.optional" value="true"/>
        </property>
        -->

        <property name="CanRaise"            type="b"  access="read"/>
        <property name="CanQuit"             type="b"  access="read"/>
        <property name="Fullscreen"          type="b"  access="readwrite"/>
        <property name="CanSetFullscreen"    type="b"  access="read"/>
        <property name="SupportedUriSchemes" type="as" access="read"/>
        <property name="SupportedMimeTypes"  type="as" access="read"/>
        <property name="HasTrackList"        type="b"  access="read"/>
    </interface>

    <interface name="org.mpris.MediaPlayer2.Player">
        <method name="Play"/>
        <method name="Pause"/>
        <method name="PlayPause"/>
        <method name="Stop"/>

        <method name="Next"/>
        <method name="Previous"/>

        <method name="Seek">
            <arg direction="in" type="x" name="Offset"/>
        </method>

        <method name="SetPosition">
            <arg direction="in" type="o" name="TrackId"/>
            <arg direction="in" type="x" name="Position"/>
        </method>

        <method name="OpenUri">
            <arg direction="in" type="s" name="Uri"/>
        </method>

        <property name="PlaybackStatus" type="s"     access="read"/>

        <property name="Position"       type="x"     access="read">
            <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="false"/>
        </property>

        <property name="Metadata"       type="a{sv}" access="read"/>
        <property name="Volume"         type="d"     access="readwrite"/>
        <property name="Rate"           type="d"     access="readwrite"/>
        <property name="MinimumRate"    type="d"     access="read"/>
        <property name="MaximumRate"    type="d"     access="read"/>
        <property name="CanGoNext"      type="b"     access="read"/>
        <property name="CanGoPrevious"  type="b"     access="read"/>
        <property name="CanPlay"        type="b"     access="read"/>
        <property name="CanPause"       type="b"     access="read"/>
        <property name="CanSeek"        type="b"     access="read"/>
        <property name="CanControl"     type="b"     access="read">
            <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="false"/>
        </property>

        <property name="Shuffle"        type="b"     access="readwrite">
            <annotation name="org.mpris.MediaPlayer2.property.optional" value="true"/>
        </property>
        <property name="LoopStatus"     type="s"     access="readwrite">
            <annotation name="org.mpris.MediaPlayer2.property.optional" value="true"/>
        </property>

        <signal name="Seeked">
            <arg name="Position" type="x"/>
        </signal>
    </interface>
    </node>
    """

    def __init__(self, conn, tabid, name, objpath):
        self.__tabid = tabid
        self.__callbacks = defaultdict(list)

        self.CanRaise = False
        self.CanQuit = False
        self.SupportedUriSchemes = ["http", "https", "ftp", "file"]
        self.SupportedMimeTypes = [
            "audio/mpeg",
            "audio/x-flac",
            # TODO: add more
        ]
        self.HasTrackList = False

        self.Fullscreen = False
        self.Metadata = {}
        self.PlaybackStatus = "Stopped"
        self.Rate = 1
        self.Volume = 1
        self.Shuffle = False
        self.LoopStatus = "None"

        super().__init__(conn, name, objpath)

    def _set_callback_on(self, prop, callback):
        self.__callbacks[prop].append(callback)

    # PROPERTIES
    def get_property(self, conn, sender, objpath, iface_name, prop_name,
                     invocation):
        if (iface_name == "org.mpris.MediaPlayer2.Player"
                and prop_name == "Position"):

            def callback(pos):
                variant = GLib.Variant("x", pos)
                invocation.return_value(GLib.Variant("(v)", (variant,)))

            self._set_callback_on("position", callback)
            self._send_message("query", "position")

        else:
            super().get_property(conn, sender, objpath, iface_name, prop_name,
                                 invocation)

    def get_all_properties(self, conn, sender, objpath, iface_name,
                           invocation):
        if iface_name == "org.mpris.MediaPlayer2.Player":
            non_async = {p: GLib.Variant(t, getattr(self, p))
                         for p, t in self._properties[iface_name].items()
                         if p != "Position"}

            def callback(pos):
                non_async["Position"] = GLib.Variant("x", pos)
                invocation.return_value(GLib.Variant("(a{sv})", (non_async,)))

            self._set_callback_on("position", callback)
            self._send_message("query", "position")

        else:
            super().get_all_properties(conn, sender, objpath, iface_name,
                                       invocation)

    def set_property(self, conn, sender, objpath, iface_name, prop_name, value,
                     invocation):
        if prop_name in ("Fullscreen", "Volume", "LoopStatus", "Shuffle", "Rate"):
            self._send_message(prop_name, value)
        else:
            setattr(self, prop_name, value)
        invocation.return_value(None)

    # SIGNALS
    def Seeked(self, position):
        self._conn.emit_signal(
            None,
            # FIXME: don't hardcode these
            "/org/mpris/MediaPlayer2",
            "org.mpris.MediaPlayer2.Player",
            "Seeked",
            GLib.Variant.new_tuple(GLib.Variant("x", position)))

    # METHODS
    def Raise(self):
        pass

    def Quit(self):
        pass

    def OpenUri(self, url):
        pass

    def Play(self):
        self._send_message("Play")

    def Pause(self):
        self._send_message("Pause")

    def PlayPause(self):
        self._send_message("PlayPause")

    def Stop(self):
        self._send_message("Stop")

    def Seek(self, offset):
        self._send_message("Seek", offset)

    def SetPosition(self, trackid, position):
        if trackid != "/org/mpris/MediaPlayer2/TrackList/NoTrack":
            ytid = unescape_object_path(trackid[4:])
            self._send_message("SetPosition",
                               {"id": ytid, "position": position})

    def Next(self):
        self._send_message("Next")

    def Previous(self):
        self._send_message("Prev")

    def _send_message(self, cmd, data=None):
        msg = {
            "tabId": self.__tabid,
            "cmd": cmd,
        }
        if data is not None:
            msg["data"] = data
        encode_msg(msg)

    def _handle_msg(self, msg):
        changes = []

        for key, val in msg["data"].items():
            if key == "id":
                track_path = "/ID/" + escape_object_path(val)
                self.Metadata["mpris:trackid"] = GLib.Variant("o", track_path)
                changes.append("Metadata")
            elif key == "url":
                self.Metadata["xesam:url"] = GLib.Variant("s", val)
                changes.append("Metadata")
            elif key == "thumb":
                self.Metadata["mpris:artUrl"] = GLib.Variant("s", val)
                changes.append("Metadata")
            elif key == "title":
                self.Metadata["xesam:title"] = GLib.Variant("s", val)
                changes.append("Metadata")
            elif key == "duration":
                self.Metadata["mpris:length"] = GLib.Variant("x", val)
                changes.append("Metadata")

            elif key == "position":
                pass
                # Position should *not* emit a Changed signal
            elif key == "seekedTo":
                self.Seeked(val)

            else:
                setattr(self, key, val)
                changes.append(key)

            if key in self.__callbacks:
                for cb in self.__callbacks[key]:
                    cb(val)
                del self.__callbacks[key]

        if "Fullscreen" in changes:
            changes.remove("Fullscreen")
            self.PropertiesChanged("org.mpris.MediaPlayer2",
                                   {"Fullscreen": self.Fullscreen}, [])

        if changes:
            self.PropertiesChanged("org.mpris.MediaPlayer2.Player",
                                   {c: getattr(self, c) for c in changes}, [])


class Youtube(MediaPlayer2):
    # FIXME:
    __doc__ = MediaPlayer2.__doc__

    def __init__(self, conn, tabid, name, objpath):
        super().__init__(conn, tabid, name, objpath)

        self.Identity = "youtube"

        self.CanControl = True
        self.CanPlay = True
        self.CanPause = True
        self.CanSeek = True
        self.CanSetFullscreen = False

        self.MinimumRate = 0.25
        self.MaximumRate = 2

        # these are set correctly on song change
        self.CanGoNext = False
        self.CanGoPrevious = False

        self.Shuffle = False
        self.LoopStatus = "None"


def main():
    mainloop = GLib.MainLoop()

    make_streams_binary()

    players = {}

    def message_handler(chan, condition):
        msg = decode_msg()
        debug(msg)

        if msg["type"] not in ("change", "update", "quit"):
            return True

        tabid = msg["tabId"]

        try:
            player = players[tabid]
        except KeyError:
            # Many terrible things can happen to tabs; they can crash or be
            # discarded.  For these cases out background.js should still inform
            # us.  However it may be that that tab has already quit e.g. it may
            # be in YouTube's main page when it crashes.  In these cases we
            # don't want to create a player just to immediately destroy it.
            if msg["type"] == "quit":
                return True

            connflags = (Gio.DBusConnectionFlags.AUTHENTICATION_CLIENT
                         | Gio.DBusConnectionFlags.MESSAGE_BUS_CONNECTION)

            addr = Gio.dbus_address_get_for_bus_sync(Gio.BusType.SESSION)
            conn = Gio.DBusConnection.new_for_address_sync(addr, connflags)
            conn.set_exit_on_close(True)

            name = "org.mpris.MediaPlayer2.chrome"
            if players:
                # if we are exposing more than one player we need to give them
                # unique names
                name += ".tab%d" % tabid

            player = Youtube(conn, tabid, name, "/org/mpris/MediaPlayer2")
            players[tabid] = player

        if msg["type"] == "change":
            player._handle_msg(msg)

        if msg["type"] == "update":
            player._handle_msg(msg)

        if msg["type"] == "quit":
            players[tabid].unpublish()
            del players[tabid]

        # otherwise GLib will remove our watch
        return True

    chan = GLib.IOChannel.unix_new(sys.stdin.fileno())
    chan.add_watch(GLib.IOCondition.IN, message_handler)
    chan.add_watch(GLib.IOCondition.HUP, lambda *_: mainloop.quit())

    mainloop.run()

if __name__ == '__main__':
    main()