Merge lp:~linkinpark342/exaile/exaile-mpris into lp:exaile/0.3.3

[Abhishek Mukherjee]

[Abhishek Mukherjee (linkinpark342)]

This is a plug-in to support the MPRIS D-Bus specification, defined at http://wiki.xmms2.xmms.se/wiki/MPRIS . Many other fancy media players are following this spec (re: VLC, Amarok2), so why not us. This would also allow us to interact with the all of one Ubuntu package (from my quick perusal of apt-cache search) which depends on this for it's sole functionality.

All functions/signals are implemented with the exception of setting repeat on a single track, which I believe we do not support yet. GUI controls for Volume, Random, and Shuffle do not update with the backend, however the calls do effect the player. See bug 355749

[Abhishek Mukherjee (linkinpark342)]

I forgot to mention this branch also has
a) Notification plugin update. fixes bug 355470
  i) Cover are shown
  ii) Replaces stale Notifications
b) Plugin interface update
  i) Configure is only clickable for plugins that allow it

[Johannes Sasongko (sjohannes)]

Thanks, but there are some problems with the proposed merge.

1. Could you submit a clean patch (against trunk) with just the plugin, please. The other things you included in the patch should be reported in other bug reports so they can be reviewed separately. You should also create a new branch from trunk, so the commit history for those other files are not changed.

2. Another thing, please add copyright/licence headers to the source files, similar to the ones in most of Exaile's source code. (I think the preferred licence is GPL version "2 or later".) I know some of the other plugins are missing these headers, but I consider it a bug. This will make it possible for us to contact individual authors if there is ever any licence issues.

review: Needs Resubmitting

[reacocard (reacocard)]

Actually for 0.3 the preferred license is GPLv3 or later.

[lp:~linkinpark342/exaile/exaile-mpris]

1832. By Abhishek Mukherjee on 2009-04-11

Added MPRIS Method calling syntax. Still need to add signals

1833. By Abhishek Mukherjee on 2009-04-11

Added signal declarations. Need to connect to player.

1834. By Abhishek Mukherjee on 2009-04-11

Added signal handling

1835. By Abhishek Mukherjee on 2009-04-11

Added tag error handling

1836. By Abhishek Mukherjee on 2009-04-11

Added ability to enable-disable MPRIS

1837. By Abhishek Mukherjee on 2009-04-11

Added Docstrings to exaile_mpris

1838. By Abhishek Mukherjee on 2009-04-11

Added what we learned from some unit testing

1839. By Abhishek Mukherjee on 2009-04-11

Added the unit test itself

1840. By Abhishek Mukherjee on 2009-04-11

plugins/mpris/test.py: Added docstrings, fixed testPosition

1841. By Abhishek Mukherjee on 2009-04-11

plugins/mpris/mpris_player.py: Added sanity check on PositionSet

1842. By Abhishek Mukherjee on 2009-04-11

Added docstrings, fixed some style. Added GPLv1 headers

1843. By Abhishek Mukherjee on 2009-04-11

Upgraded to GPLv3, fixed one of the copyright headers

[Abhishek Mukherjee (linkinpark342)]

> Thanks, but there are some problems with the proposed merge.
>
> 1. Could you submit a clean patch (against trunk) with just the plugin,
> please. The other things you included in the patch should be reported in other
> bug reports so they can be reviewed separately. You should also create a new
> branch from trunk, so the commit history for those other files are not
> changed.
Heh, i tried to sneak them in without someone noticing. not really. I just forgot to branch properly when i first got the repo. I overwrote the entire history with a new branch without any of the various other fixes.
>
> 2. Another thing, please add copyright/licence headers to the source files,
> similar to the ones in most of Exaile's source code. (I think the preferred
> licence is GPL version "2 or later".) I know some of the other plugins are
> missing these headers, but I consider it a bug. This will make it possible for
> us to contact individual authors if there is ever any licence issues.
I had thought I put them there. I did however upgrade to v3 as Adam mentioned below.

[lp:~linkinpark342/exaile/exaile-mpris]

1844. By Abhishek Mukherjee on 2009-04-11

Added warning on the test

1845. By Abhishek Mukherjee on 2009-04-12

Added conversion for artist tag

=== added directory 'plugins/mpris'
=== added file 'plugins/mpris/PLUGININFO'
--- plugins/mpris/PLUGININFO	1970-01-01 00:00:00 +0000
+++ plugins/mpris/PLUGININFO	2009-04-05 03:55:27 +0000
@@ -0,0 +1,4 @@
+Version="0.0.1"
+Authors=["Abhishek Mukherjee <[e-mail]"]
+Name="MPRIS"
+Description="Creates an MPRIS D-Bus object to control Exaile"

=== added file 'plugins/mpris/__init__.py'
--- plugins/mpris/__init__.py	1970-01-01 00:00:00 +0000
+++ plugins/mpris/__init__.py	2009-04-05 21:01:49 +0000
@@ -0,0 +1,20 @@
+__all__ = ["exaile_mpris"]
+
+import exaile_mpris
+import logging
+
+LOG = logging.getLogger("exaile.plugins.mpris")
+
+_MPRIS = None
+
+def enable(exaile):
+    LOG.debug("Enabling MPRIS")
+    if _MPRIS is None:
+        global _MPRIS
+        _MPRIS = exaile_mpris.ExaileMpris(exaile)
+    _MPRIS.exaile = exaile
+    _MPRIS.acquire()
+
+def disable(exaile):
+    LOG.debug("Disabling MPRIS")
+    _MPRIS.release()

=== added file 'plugins/mpris/exaile_mpris.py'
--- plugins/mpris/exaile_mpris.py	1970-01-01 00:00:00 +0000
+++ plugins/mpris/exaile_mpris.py	2009-04-05 21:15:43 +0000
@@ -0,0 +1,72 @@
+"""
+An implementation of the MPRIS D-Bus protocol for use with Exaile
+"""
+
+import dbus
+import dbus.service
+import logging
+
+import mpris_root
+import mpris_tracklist
+import mpris_player
+
+LOG = logging.getLogger("exaile.plugins.mpris.exaile_mpris")
+
+OBJECT_NAME = 'org.mpris.exaile'
+
+class ExaileMpris(object):
+
+    """
+        Controller for various MPRIS objects.
+    """
+
+    def __init__(self, exaile=None):
+        """
+            Constructs an MPRIS controller. Note, you must call acquire()
+        """
+        self.exaile = exaile
+        self.mpris_root = None
+        self.mpris_tracklist = None
+        self.mpris_player = None
+        self.bus = None
+
+    def release(self):
+        """
+            Releases all objects from D-Bus and unregisters the bus
+        """
+        for obj in (self.mpris_root, self.mpris_tracklist, self.mpris_player):
+            if obj is not None:
+                obj.remove_from_connection()
+        self.mpris_root = None
+        self.mpris_tracklist = None
+        self.mpris_player = None
+        if self.bus is not None:
+            self.bus.get_bus().release_name(self.bus.get_name())
+
+    def acquire(self):
+        """
+            Connects to D-Bus and registers all components
+        """
+        self._acquire_bus()
+        self._add_interfaces()
+
+    def _acquire_bus(self):
+        """
+            Connect to D-Bus and set self.bus to be a valid connection
+        """
+        if self.bus is not None:
+            self.bus.get_bus().request_name(OBJECT_NAME)
+        else:
+            self.bus = dbus.service.BusName(OBJECT_NAME, bus=dbus.SessionBus())
+
+    def _add_interfaces(self):
+        """
+            Connects all interfaces to D-Bus
+        """
+        self.mpris_root = mpris_root.ExaileMprisRoot(self.exaile, self.bus)
+        self.mpris_tracklist = mpris_tracklist.ExaileMprisTrackList(
+                                                        self.exaile, 
+                                                        self.bus)
+        self.mpris_player = mpris_player.ExaileMprisPlayer(
+                                                        self.exaile,
+                                                        self.bus)

=== added file 'plugins/mpris/mpris_player.py'
--- plugins/mpris/mpris_player.py	1970-01-01 00:00:00 +0000
+++ plugins/mpris/mpris_player.py	2009-04-08 05:37:35 +0000
@@ -0,0 +1,227 @@
+from __future__ import division
+
+import dbus
+import dbus.service
+
+import xl.event
+
+import mpris_tag_converter
+
+INTERFACE_NAME = 'org.freedesktop.MediaPlayer'
+
+class MprisCaps(object):
+    """
+        Specification for the capabilities field in MPRIS
+    """
+    NONE                  = 0
+    CAN_GO_NEXT           = 1 << 0
+    CAN_GO_PREV           = 1 << 1
+    CAN_PAUSE             = 1 << 2
+    CAN_PLAY              = 1 << 3
+    CAN_SEEK              = 1 << 4
+    CAN_PROVIDE_METADATA  = 1 << 5
+    CAN_HAS_TRACKLIST     = 1 << 6
+
+EXAILE_CAPS = (MprisCaps.CAN_GO_NEXT
+                | MprisCaps.CAN_GO_PREV
+                | MprisCaps.CAN_PAUSE
+                | MprisCaps.CAN_PLAY
+                | MprisCaps.CAN_SEEK
+                | MprisCaps.CAN_PROVIDE_METADATA
+                | MprisCaps.CAN_HAS_TRACKLIST)
+
+class ExaileMprisPlayer(dbus.service.Object):
+
+    """
+        /Player (Root) object methods
+    """
+
+    def __init__(self, exaile, bus):
+        dbus.service.Object.__init__(self, bus, '/Player')
+        self.exaile = exaile
+        self._tag_converter = mpris_tag_converter.ExaileTagConverter(exaile)
+        xl.event.add_callback(self.track_change_cb, 'playback_start')
+        # FIXME: Does not watch for shuffle, repeat
+        # TODO: playback_start does not distinguish if play button was pressed
+        #       or we simply moved to a new track
+        for event in ('stop_track', 'playback_start', 'playback_toggle_pause'):
+            xl.event.add_callback(self.status_change_cb, event)
+
+
+    @dbus.service.method(INTERFACE_NAME)
+    def Next(self):
+        """
+            Goes to the next element
+        """
+        self.exaile.queue.next()
+
+    @dbus.service.method(INTERFACE_NAME)
+    def Prev(self):
+        """
+            Goes to the previous element
+        """
+        self.exaile.queue.prev()
+
+    @dbus.service.method(INTERFACE_NAME)
+    def Pause(self):
+        """
+            If playing, pause. If paused, unpause.
+        """
+        self.exaile.player.toggle_pause()
+
+    @dbus.service.method(INTERFACE_NAME)
+    def Stop(self):
+        """
+            Stop playing
+        """
+        self.exaile.player.stop()
+
+    @dbus.service.method(INTERFACE_NAME)
+    def Play(self):
+        """
+            If Playing, rewind to the beginning of the current track, else.
+            start playing
+        """
+        if self.exaile.player.is_playing():
+            self.exaile.player.play(self.exaile.player.current)
+        else:
+            self.exaile.queue.play()
+
+    @dbus.service.method(INTERFACE_NAME, in_signature="b")
+    def Repeat(self, repeat):
+        """
+            Toggle the current track repeat
+        """
+        pass
+
+    @dbus.service.method(INTERFACE_NAME, out_signature="(iiii)")
+    def GetStatus(self):
+        """
+            Return the status of "Media Player" as a struct of 4 ints: 
+              * First integer: 0 = Playing, 1 = Paused, 2 = Stopped. 
+              * Second interger: 0 = Playing linearly , 1 = Playing randomly. 
+              * Third integer: 0 = Go to the next element once the current has
+                finished playing , 1 = Repeat the current element 
+              * Fourth integer: 0 = Stop playing once the last element has been
+                played, 1 = Never give up playing
+        """
+        if self.exaile.player.is_playing():
+            playing = 0
+        elif self.exaile.player.is_paused():
+            playing = 1
+        else:
+            playing = 2
+
+        if not self.exaile.queue.current_playlist.random_enabled:
+            random = 0
+        else:
+            random = 1
+
+        go_to_next = 0 # Do not have ability to repeat single track
+        
+        if not self.exaile.queue.current_playlist.repeat_enabled:
+            repeat = 0
+        else:
+            repeat = 1
+
+        return (playing, random, go_to_next, repeat)
+
+    @dbus.service.method(INTERFACE_NAME, out_signature="a{sv}")
+    def GetMetadata(self):
+        """
+            Gives all meta data available for the currently played element.
+        """
+        if self.exaile.player.current is None:
+            return []
+        return self._tag_converter.get_metadata(self.exaile.player.current)
+
+    @dbus.service.method(INTERFACE_NAME, out_signature="i")
+    def GetCaps(self):
+        """
+            Returns the "Media player"'s current capabilities, see MprisCaps
+        """
+        return EXAILE_CAPS
+
+    @dbus.service.method(INTERFACE_NAME, in_signature="i")
+    def VolumeSet(self, volume):
+        """
+            Sets the volume, arument in the range [0, 100]
+        """
+        if volume < 0 or volume > 100:
+            pass
+
+        self.exaile.settings['player/volume'] = volume / 100
+
+    @dbus.service.method(INTERFACE_NAME, out_signature="i")
+    def VolumeGet(self):
+        """
+            Returns the current volume (must be in [0;100])
+        """
+        return self.exaile.settings['player/volume'] * 100
+
+    @dbus.service.method(INTERFACE_NAME, in_signature="i")
+    def PositionSet(self, millisec):
+        """
+            Sets the playing position (argument must be in [0, <track_length>]
+            in milliseconds)
+        """
+        if millisec > self.exaile.player.current.tags['length'] * 1000 \
+                or millisec < 0:
+            return
+        self.exaile.player.seek(millisec / 1000)
+
+    @dbus.service.method(INTERFACE_NAME, out_signature="i")
+    def PositionGet(self):
+        """
+            Returns the playing position (will be [0, track_length] in
+            milliseconds)
+        """
+        return int(self.exaile.player.get_position() / 1000000)
+
+    def track_change_cb(self, type, object, data):
+        """
+            Callback will emit the dbus signal TrackChange with the current
+            songs metadata
+        """
+        metadata = self.GetMetadata()
+        self.TrackChange(metadata)
+
+    def status_change_cb(self, type, object, data):
+        """
+            Callback will emit the dbus signal StatusChange with the current
+            status
+        """
+        struct = self.GetStatus()
+        self.StatusChange(struct)
+
+    def caps_change_cb(self, type, object, data):
+        """
+            Callback will emit the dbus signal CapsChange with the current Caps
+        """
+        caps = self.GetCaps()
+        self.CapsChange(caps)
+
+    @dbus.service.signal(INTERFACE_NAME, signature="a{sv}")
+    def TrackChange(self, metadata):
+        """
+            Signal is emitted when the "Media Player" plays another "Track".
+            Argument of the signal is the metadata attached to the new "Track"
+        """
+        pass
+
+    @dbus.service.signal(INTERFACE_NAME, signature="(iiii)")
+    def StatusChange(self, struct):
+        """
+            Signal is emitted when the status of the "Media Player" change. The
+            argument has the same meaning as the value returned by GetStatus.
+        """
+        pass
+
+    @dbus.service.signal(INTERFACE_NAME)
+    def CapsChange(self):
+        """
+            Signal is emitted when the "Media Player" changes capabilities, see
+            GetCaps method.
+        """
+        pass
+

=== added file 'plugins/mpris/mpris_root.py'
--- plugins/mpris/mpris_root.py	1970-01-01 00:00:00 +0000
+++ plugins/mpris/mpris_root.py	2009-04-05 21:01:49 +0000
@@ -0,0 +1,38 @@
+import dbus
+import dbus.service
+
+from xl.nls import gettext as _
+
+INTERFACE_NAME = 'org.freedesktop.MediaPlayer'
+
+class ExaileMprisRoot(dbus.service.Object):
+
+    """
+        / (Root) object methods
+    """
+
+    def __init__(self, exaile, bus):
+        dbus.service.Object.__init__(self, bus, '/')
+        self.exaile = exaile
+
+    @dbus.service.method(INTERFACE_NAME, out_signature="s")
+    def Identity(self):
+        """
+            Identify the "media player"
+        """
+        return _("Exaile %(version)s") % {'version': self.exaile.get_version()}
+
+    @dbus.service.method(INTERFACE_NAME)
+    def Quit(self):
+        """
+            Makes the "Media Player" exit.
+        """
+        self.exaile.quit()
+
+    @dbus.service.method(INTERFACE_NAME, out_signature="(qq)")
+    def MprisVersion(self):
+        """
+            Makes the "Media Player" exit.
+        """
+        return (1, 0)
+

=== added file 'plugins/mpris/mpris_tag_converter.py'
--- plugins/mpris/mpris_tag_converter.py	1970-01-01 00:00:00 +0000
+++ plugins/mpris/mpris_tag_converter.py	2009-04-07 23:55:02 +0000
@@ -0,0 +1,176 @@
+"""
+A converter utility to convert from exaile tags to mpris Metadata
+"""
+
+import logging
+_LOG = logging.getLogger('exaile.plugins.mpris.mpris_tag_converter')
+
+# Dictionary to map MPRIS tags to Exaile Tags
+# Each key is the mpris tag, each value is a dictionary with possible keys:
+#   * out_type: REQUIRED, function that will convert to the MPRIS type
+#   * exaile_tag: the name of the tag in exaile, defaults to the mpris tag
+#   * conv: a conversion function to call on the exaile metadata, defaults to
+#           lambda x: x
+#   * desc: a description of what's in the tag
+#   * constructor: a function to call that takes (exaile, track) and returns
+#                  the value for the key. If it returns None, the tag is not
+#                  set
+MPRIS_TAG_INFORMATION = {
+        'location'   : {'out_type'  : unicode,
+                        'exaile_tag': 'loc',
+                        'conv'      : lambda x: "file://" + x,
+                        'desc'      : 'Name',
+                        },
+        'title'      : {'out_type'  : unicode,
+                        'desc'      : 'Name of artist or band',
+                        },
+        'album'      : {'out_type'  : unicode,
+                        'desc'      : 'Name of compilation',
+                        },
+        'tracknumber': {'out_type'  : unicode,
+                        'desc'      : 'The position in album',
+                        },
+        'time'       : {'out_type'  : int,
+                        'exaile_tag': 'length',
+                        'desc'      : 'The duration in seconds',
+                        },
+        'mtime'      : {'out_type'  : int, 
+                        'desc'      : 'The duration in milliseconds',
+                        },
+        'genre'      : {'out_type'  : unicode,
+                        'desc'      : 'The genre',
+                        },
+        'comment'    : {'out_type'  : unicode,
+                        'desc'      : 'A comment about the work',
+                        },
+        'rating'     : {'out_type'  : int,
+                        'desc'      : 'A "taste" rate value, out of 5',
+                        },
+        'year'       : {'out_type'  : int,
+                        'exaile_tag': 'date',
+                        'conv'      : lambda x: x.split('-')[0],
+                        'desc'      : 'The year of performing',
+                        },
+        'date'       : {'out_type'  : int,
+                        'exaile_tag': None,
+                        'desc'      : 'When the performing was realized, '
+                                      'since epoch',
+                        },
+        'arturl'     : {'out_type'  : unicode,
+                        'desc'      : 'an URI to an image',
+                        },
+        'audio-bitrate': {'out_type': int,
+                        'exaile_tag': 'bitrate',
+                        'desc'      : 'The number of bits per second',
+                        },
+        'audio-samplerate': {'out_type': int,
+                        'desc'      : 'The number of samples per second',
+                        },
+        }
+EXAILE_TAG_INFORMATION = {}
+def __fill_exaile_tag_information():
+    """
+        Fille EXAILE_TAG_INFORMATION with the exaile_tag: mpris_tag, the
+        inverse of MPRIS_TAG_INFORMATION
+    """
+    for mpris_tag in MPRIS_TAG_INFORMATION:
+        if 'exaile_tag' in MPRIS_TAG_INFORMATION[mpris_tag]:
+            exaile_tag = MPRIS_TAG_INFORMATION[mpris_tag]['exaile_tag']
+        else:
+            exaile_tag = mpris_tag
+        if exaile_tag is None:
+            continue
+        EXAILE_TAG_INFORMATION[exaile_tag] = mpris_tag
+__fill_exaile_tag_information()
+
+class OutputTypeMismatchException(Exception):
+    def __init__(self, exaile_tag, mpris_tag, val):
+        Exception.__init__(self,
+                "Could not convert tag exaile:'%s' to mpris:'%s':"
+                "Error converting '%s' to type '%s"
+                % (exaile_tag, mpris_tag, val,
+                    MPRIS_TAG_INFORMATION[mpris_tag]['out_type']))
+
+class ExaileTagConverter(object):
+
+    """
+    Class to convert tags from Exaile to Metadata for MPRIS
+    """
+
+    def __init__(self, exaile):
+        self.exaile = exaile
+
+    def get_metadata(self, track):
+        """
+            Returns the Metadata for track as defined by MPRIS standard
+        """
+        metadata = {}
+        for exaile_tag in track.tags:
+            if exaile_tag not in EXAILE_TAG_INFORMATION:
+                continue
+            val = ExaileTagConverter.__get_first_item(track.tags[exaile_tag])
+            try:
+                mpris_tag, mpris_val = ExaileTagConverter.convert_tag(
+                        exaile_tag, val)
+            except OutputTypeMismatchException, e:
+                _LOG.exception(e)
+                continue
+            if mpris_tag is None:
+                continue
+            metadata[mpris_tag] = mpris_val
+
+        for mpris_tag in MPRIS_TAG_INFORMATION:
+            if 'constructor' in MPRIS_TAG_INFORMATION[mpris_tag]:
+                val = MPRIS_TAG_INFORMATION[mpris_tag]['constructor'](
+                            self.exaile,
+                            track
+                        )
+                if val is not None:
+                    try:
+                        metadata[mpris_tag] = \
+                            MPRIS_TAG_INFORMATION[mpris_tag]['out_type'](val)
+                    except ValueError:
+                        raise OutputTypeMismatchException(exaile_tag,
+                                                          mpris_tag,
+                                                          val,
+                                                          )
+
+                        
+        return metadata
+
+    @staticmethod
+    def __get_first_item(value):
+        """
+            Unlists lists and returns the first value, if not a lists,
+            returns value
+        """
+        if not isinstance(value, basestring) and hasattr(value, "__getitem__"):
+            if len(value):
+                return value[0]
+            return None
+        return value
+
+    @staticmethod
+    def convert_tag(exaile_tag, exaile_value):
+        """
+            Converts a single tag into MPRIS form, return a 2-tuple of
+            (mpris_tag, mpris_val). Returns (None, None) if there is no
+            translation
+        """
+        if exaile_tag not in EXAILE_TAG_INFORMATION:
+            return (None, None)
+        mpris_tag = EXAILE_TAG_INFORMATION[exaile_tag]
+        info = MPRIS_TAG_INFORMATION[mpris_tag]
+        if 'conv' in info:
+            mpris_value = info['conv'](exaile_value)
+        else:
+            mpris_value = exaile_value
+        try:
+            mpris_value = info['out_type'](mpris_value)
+        except ValueError:
+            raise OutputTypeMismatchException(exaile_tag,
+                                              mpris_tag,
+                                              exaile_value,
+                                              )
+        return (mpris_tag, mpris_value)
+

=== added file 'plugins/mpris/mpris_tracklist.py'
--- plugins/mpris/mpris_tracklist.py	1970-01-01 00:00:00 +0000
+++ plugins/mpris/mpris_tracklist.py	2009-04-07 23:55:02 +0000
@@ -0,0 +1,122 @@
+import dbus
+import dbus.service
+
+import xl.track
+import xl.event
+
+import mpris_tag_converter
+
+INTERFACE_NAME = 'org.freedesktop.MediaPlayer'
+
+class ExaileMprisTrackList(dbus.service.Object):
+
+    """
+        /TrackList object methods
+    """
+
+    def __init__(self, exaile, bus):
+        dbus.service.Object.__init__(self, bus, '/TrackList')
+        self.exaile = exaile
+        self.tag_converter = mpris_tag_converter.ExaileTagConverter(exaile)
+        for event in ('tracks_removed', 'tracks_added'):
+            xl.event.add_callback(self.tracklist_change_cb, event)
+
+    def __get_playlist(self):
+        """
+            Returns the list of tracks in the current playlist
+        """
+        return self.exaile.queue.current_playlist.get_ordered_tracks()
+
+    @dbus.service.method(INTERFACE_NAME,
+            in_signature="i", out_signature="a{sv}")
+    def GetMetadata(self, pos):
+        """
+            Gives all meta data available for element at given position in the
+            TrackList, counting from 0
+
+            Each dict entry is organized as follows
+              * string: Metadata item name
+              * variant: Metadata value
+        """
+        track = self.__get_playlist()[pos]
+        return self.tag_converter.get_metadata(track)
+
+    @dbus.service.method(INTERFACE_NAME, out_signature="i")
+    def GetCurrentTrack(self):
+        """
+            Return the position of current URI in the TrackList The return
+            value is zero-based, so the position of the first URI in the
+            TrackList is 0. The behavior of this method is unspecified if
+            there are zero elements in the TrackList.
+        """
+        try:
+            return self.exaile.queue.current_playlist.index(
+                    self.exaile.player.current)
+        except ValueError:
+            return -1
+
+    @dbus.service.method(INTERFACE_NAME, out_signature="i")
+    def GetLength(self):
+        """
+            Number of elements in the TrackList
+        """
+        return len(self.exaile.queue.current_playlist)
+
+    @dbus.service.method(INTERFACE_NAME,
+            in_signature="sb", out_signature="i")
+    def AddTrack(self, uri, play_immediately):
+        """
+            Appends an URI in the TrackList.
+        """
+        if not uri.startswith("file://"):
+            return -1
+        uri = uri[7:]
+        track = self.exaile.collection.get_track_by_loc(unicode(uri))
+        if track is None:
+            track = xl.track.Track(uri)
+        self.exaile.queue.current_playlist.add(track)
+        if play_immediately:
+            self.exaile.queue.play(track)
+        return 0
+
+    @dbus.service.method(INTERFACE_NAME, in_signature="i")
+    def DelTrack(self, pos):
+        """
+            Appends an URI in the TrackList.
+        """
+        self.exaile.queue.current_playlist.remove(pos)
+
+    @dbus.service.method(INTERFACE_NAME, in_signature="b")
+    def SetLoop(self, loop):
+        """
+            Sets the player's "repeat" or "loop" setting
+        """
+        self.exaile.queue.current_playlist.set_repeat(loop)
+
+    @dbus.service.method(INTERFACE_NAME, in_signature="b")
+    def SetRandom(self, random):
+        """
+            Sets the player's "random" setting
+        """
+        self.exaile.queue.current_playlist.set_random(random)
+
+    def tracklist_change_cb(self, type, object, data):
+        """
+            Callback for a track list change
+        """
+        len = self.GetLength()
+        self.TrackListChange(len)
+
+    @dbus.service.signal(INTERFACE_NAME, signature="i")
+    def TrackListChange(self, num_of_elements):
+        """
+            Signal is emitted when the "TrackList" content has changed: 
+              * When one or more elements have been added 
+              * When one or more elements have been removed 
+              * When the ordering of elements has changed 
+
+            The argument is the number of elements in the TrackList after the
+            change happened.
+        """
+        pass
+

=== added file 'plugins/mpris/test.py'
--- plugins/mpris/test.py	1970-01-01 00:00:00 +0000
+++ plugins/mpris/test.py	2009-04-08 05:37:12 +0000
@@ -0,0 +1,305 @@
+"""
+Simple test case for MPRIS. Make sure you set the global variable FILE with an
+absolute path to a valid playable, local music piece before running this test
+"""
+import unittest
+import dbus
+import os
+import time
+
+OBJECT_NAME = 'org.mpris.exaile'
+INTERFACE = 'org.freedesktop.MediaPlayer'
+FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.path.pardir, os.path.pardir,
+                    'tests', 'data', 'music', 'delerium', 'chimera',
+                    '05 - Truly.mp3')
+assert os.path.isfile(FILE), FILE + " must be a valid musical piece"
+FILE = "file://" + FILE
+print "Test file will be: " + FILE
+
+class TestExaileMpris(unittest.TestCase):
+
+    """
+        Tests Exaile MPRIS plugin
+    """
+
+    def setUp(self):
+        """
+            Simple setUp that makes dbus connections and assigns them to
+            self.player, self.track_list, and self.root. Also begins playing
+            a song so every test case can assume that a song is playing
+        """
+        bus = dbus.SessionBus()
+        objects = {'root': '/',
+                   'player': '/Player',
+                   'track_list': '/TrackList',
+                   }
+        intfs = {}
+        for key in objects:
+            object = bus.get_object(OBJECT_NAME, objects[key])
+            intfs[key] = dbus.Interface(object, INTERFACE)
+        self.root = intfs['root']
+        self.player = intfs['player']
+        self.track_list = intfs['track_list']
+        self.player.Play()
+        time.sleep(0.5)
+
+    def __wait_after(function):
+        """
+            Decorator to add a delay after a function call
+        """
+        def inner(*args, **kwargs):
+            function(*args, **kwargs)
+            time.sleep(0.5)
+        return inner
+
+    @__wait_after
+    def _stop(self):
+        """
+            Stops playing w/ delay
+        """
+        self.player.Stop()
+
+    @__wait_after
+    def _play(self):
+        """
+            Starts playing w/ delay
+        """
+        self.player.Play()
+
+    @__wait_after
+    def _pause(self):
+        """
+            Pauses playing w/ delay
+        """
+        self.player.Pause()
+
+
+class TestMprisRoot(TestExaileMpris):
+
+    """
+        Check / (Root) object functions for MPRIS. Does not check Quit
+    """
+
+    def testIdentity(self):
+        """
+            Make sure we output Exaile with our identity
+        """
+        id = self.root.Identity()
+        self.assertEqual(id, self.root.Identity())
+        self.assertTrue(id.startswith("Exaile"))
+
+    def testMprisVersion(self):
+        """
+            Checks that we are using MPRIS version 1.0
+        """
+        version = self.root.MprisVersion()
+        self.assertEqual(dbus.UInt16(1), version[0])
+        self.assertEqual(dbus.UInt16(0), version[1])
+
+class TestTrackList(TestExaileMpris):
+
+    """
+        Tests the /TrackList object for MPRIS
+    """
+
+    def testGetMetadata(self):
+        """
+            Make sure we can get metadata. Also makes sure that locations will
+            not change randomly
+        """
+        md = self.track_list.GetMetadata(0)
+        md_2 = self.track_list.GetMetadata(0)
+        self.assertEqual(md, md_2)
+
+    def testAppendDelWithoutPlay(self):
+        """
+            Tests appending and deleting songs from the playlist without
+            playing them
+        """
+        cur_track = self.track_list.GetCurrentTrack()
+        len = self.track_list.GetLength()
+
+        self.assertEqual(0, self.track_list.AddTrack(FILE, False))
+        self.assertEqual(len + 1, self.track_list.GetLength())
+        self.assertEqual(cur_track, self.track_list.GetCurrentTrack())
+
+        md = self.track_list.GetMetadata(len)
+        self.assertEqual(FILE, md['location'])
+
+        self.track_list.DelTrack(len)
+        self.assertEqual(len, self.track_list.GetLength())
+        self.assertEqual(cur_track, self.track_list.GetCurrentTrack())
+
+    def testAppendDelWithPlay(self):
+        """
+            Tests appending songs into the playlist with playing the songs
+        """
+        cur_track = self.track_list.GetCurrentTrack()
+        cur_md = self.track_list.GetMetadata(cur_track)
+        len = self.track_list.GetLength()
+
+        self.assertEqual(0, self.track_list.AddTrack(FILE, True))
+        self.assertEqual(len + 1, self.track_list.GetLength())
+
+        md = self.track_list.GetMetadata(len)
+        self.assertEqual(FILE, md['location'])
+        self.assertEqual(len, self.track_list.GetCurrentTrack())
+
+        self.track_list.DelTrack(len)
+        self.assertEqual(len, self.track_list.GetLength())
+
+        self.track_list.AddTrack(cur_md['location'], True)
+
+    def testGetCurrentTrack(self):
+        """
+            Check the GetCurrentTrack information
+        """
+        cur_track = self.track_list.GetCurrentTrack()
+        self.assertTrue(cur_track >= 0, "Tests start with playing music")
+
+        self._stop()
+        self.assertEqual(dbus.Int32(-1), self.track_list.GetCurrentTrack(),
+                    "Our implementation returns -1 if no tracks are playing")
+
+        self._play()
+        self.assertEqual(cur_track, self.track_list.GetCurrentTrack(),
+                "After a stop and play, we should be at the same track")
+
+    def __test_bools(self, getter, setter):
+        """
+            Generic function for checking that a boolean value changes
+        """
+        cur_val = getter()
+        if cur_val == dbus.Int32(0):
+            val = False
+        elif cur_val == dbus.Int32(1):
+            val = True
+        else:
+            self.fail("Got an invalid value from status")
+
+        setter(False)
+        status = getter()
+        self.assertEqual(dbus.Int32(0), status)
+
+        setter(True)
+        status = getter()
+        self.assertEqual(dbus.Int32(1), status)
+
+        setter(val)
+        self.track_list.SetLoop(val)
+
+    def testLoop(self):
+        """
+            Tests that you can change the loop settings
+        """
+        self.__test_bools(lambda: self.player.GetStatus()[3],
+                        lambda x: self.track_list.SetLoop(x))
+
+    def testRandom(self):
+        """
+            Tests that you can change the random settings
+        """
+        self.__test_bools(lambda: self.player.GetStatus()[1],
+                        lambda x: self.track_list.SetRandom(x))
+
+class TestPlayer(TestExaileMpris):
+
+    """
+        Tests the /Player object for MPRIS
+    """
+
+    def testNextPrev(self):
+        """
+            Make sure you can skip back and forward
+        """
+        cur_track = self.track_list.GetCurrentTrack()
+        self.player.Next()
+        new_track = self.track_list.GetCurrentTrack()
+        self.assertNotEqual(cur_track, new_track)
+        self.player.Prev()
+        self.assertEqual(cur_track, self.track_list.GetCurrentTrack())
+
+    def testStopPlayPause(self):
+        """
+            Make sure play, pause, and stop behaive as designed
+        """
+        self._stop()
+        self.assertEqual(dbus.Int32(2), self.player.GetStatus()[0])
+
+        self._play()
+        self.assertEqual(dbus.Int32(0), self.player.GetStatus()[0])
+        self._play()
+        self.assertEqual(dbus.Int32(0), self.player.GetStatus()[0])
+        
+        self._pause()
+        self.assertEqual(dbus.Int32(1), self.player.GetStatus()[0])
+        self._pause()
+        self.assertEqual(dbus.Int32(0), self.player.GetStatus()[0])
+
+        self._stop()
+        self.assertEqual(dbus.Int32(2), self.player.GetStatus()[0])
+        self._pause()
+        self.assertEqual(dbus.Int32(2), self.player.GetStatus()[0])
+
+    def testVolume(self):
+        """
+            Test to make sure volumes are set happily
+        """
+        vol = self.player.VolumeGet()
+        self.player.VolumeSet(1 - vol)
+        self.assertEqual(1 - vol, self.player.VolumeGet())
+        self.player.VolumeSet(vol)
+        self.assertEqual(vol, self.player.VolumeGet())
+
+    def testPosition(self):
+        """
+            Test the PositionGet and PositionSet functions. Unfortuantely this
+            is very time sensitive and thus has about a 10 second sleep in the
+            function
+        """
+        time.sleep(3)
+        self._pause()
+
+        pos = self.player.PositionGet()
+        time.sleep(1)
+        self.assertEqual(pos, self.player.PositionGet(),
+                "Position shouldn't move while paused")
+
+        self._pause()
+        time.sleep(4)
+        last_pos = self.player.PositionGet()
+        self.assertTrue(pos < last_pos,
+                "Position shouldn't advance while paused: %d >= %d" %
+                    (pos, last_pos))
+
+        self.player.PositionSet(pos)
+        time.sleep(2)
+        self._pause()
+        mid_pos = self.player.PositionGet(),
+        self.assertTrue(mid_pos[0] < last_pos,
+                "Resetting to position %d, %d should be between that at %d"
+                         % (pos, mid_pos[0], last_pos))
+
+        self._pause()
+        time.sleep(0.5)
+        self.assertTrue(pos < self.player.PositionGet(),
+                "Make sure it still advances")
+
+        self.player.PositionSet(-1)
+        self.assertTrue(pos < self.player.PositionGet(),
+                "Don't move to invalid position")
+        
+
+def suite():
+    sub_test = [TestMprisRoot, TestTrackList]
+
+    suites = []
+
+    for test in sub_test:
+        suites.append(unittest.defaultTestLoader.loadTestsFromTestCase(test))
+
+    return unittest.TestSuite(suites)
+
+if __name__ == "__main__":
+    unittest.main()
+

=== modified file 'plugins/notify/__init__.py'
--- plugins/notify/__init__.py	2008-10-17 04:04:50 +0000
+++ plugins/notify/__init__.py	2009-04-05 05:48:03 +0000
@@ -4,27 +4,41 @@
 
 pynotify.init('exailenotify')
 
-def on_play(type, player, track):
-    title = " / ".join(track['title'] or _("Unknown"))
-    artist = " / ".join(track['artist'] or "")
-    album = " / ".join(track['album'] or "")
-    summary = cgi.escape(title)
-    if artist and album:
-        body = _("by %(artist)s\nfrom <i>%(album)s</i>") % {
-            'artist' : cgi.escape(artist), 
-            'album' : cgi.escape(album)}
-    elif artist:
-        body = _("by %(artist)s") % {'artist' : cgi.escape(artist)}
-    elif album:
-        body = _("from %(album)s") % {'album' : cgi.escape(album)}
-    else:
-        body = ""
-    notify = pynotify.Notification(summary, body)
-
-    notify.show()
+class ExaileNotification(object):
+    def __init__(self):
+        self.notification = pynotify.Notification("Exaile")
+        self.exaile = None
+
+    def on_play(self, type, player, track):
+        title = " / ".join(track['title'] or _("Unknown"))
+        artist = " / ".join(track['artist'] or "")
+        album = " / ".join(track['album'] or "")
+        summary = cgi.escape(title)
+        if artist and album:
+            body = _("by %(artist)s\nfrom <i>%(album)s</i>") % {
+                'artist' : cgi.escape(artist), 
+                'album' : cgi.escape(album)}
+        elif artist:
+            body = _("by %(artist)s") % {'artist' : cgi.escape(artist)}
+        elif album:
+            body = _("from %(album)s") % {'album' : cgi.escape(album)}
+        else:
+            body = ""
+        self.notification.update(summary, body)
+        item = track.get_album_tuple()
+        image = None
+        if all(item) and hasattr(self.exaile, 'covers'):
+            image = self.exaile.covers.coverdb.get_cover(*item)
+        if image is None:
+            image = 'exaile'
+        self.notification.set_property('icon-name', image)
+        self.notification.show()
+
+EXAILE_NOTIFICATION = ExaileNotification()
 
 def enable(exaile):
-    event.add_callback(on_play, 'playback_start')
+    EXAILE_NOTIFICATION.exaile = exaile
+    event.add_callback(EXAILE_NOTIFICATION.on_play, 'playback_start')
 
 def disable(exaile):
-    event.remove_callback(on_play, 'playback_start')
+    event.remove_callback(EXAILE_NOTIFICATION.on_play, 'playback_start')

=== modified file 'xlgui/plugins.py'
--- xlgui/plugins.py	2009-01-05 23:30:31 +0000
+++ xlgui/plugins.py	2009-04-04 21:10:41 +0000
@@ -106,18 +106,26 @@
         (model, iter) = self.list.get_selection().get_selected()
         if not iter: return
 
-        pluginname = model.get_value(iter, 2)
-        if not pluginname in self.plugins.enabled_plugins:
-            return
-
-        plugin = self.plugins.enabled_plugins[pluginname]
-        if not hasattr(plugin, 'get_prefs_pane'):
+        pluginname = model.get_value(iter, 2)[0]
+        if not self.__configure_available(pluginname):
             commondialogs.error(self.parent, _("The selected " 
                 "plugin doesn't have any configuration options"))
             return
 
         self.guimain.show_preferences(plugin_page=pluginname)
 
+    def __configure_available(self, pluginname):
+        """
+            Returns if a plugin given by pluginname has the ability to open a
+            configure dialog
+        """
+        if pluginname not in self.plugins.enabled_plugins:
+            return False
+        plugin = self.plugins.enabled_plugins[pluginname]
+        if not hasattr(plugin, 'get_prefs_pane'):
+            return False
+        return True
+
     def row_selected(self, selection, user_data=None):
         """
             Called when a row is selected
@@ -132,6 +140,12 @@
         self.description.get_buffer().set_text(
             info['Description'].replace(r'\n', "\n"))
         self.name_label.set_markup("<b>%s</b>" % info['Name'])
+        (model, iter) = selection.get_selected()
+        pluginname = model.get(iter, 2)[0]
+        if self.__configure_available(pluginname):
+            self.configure_button.set_sensitive(True)
+        else:
+            self.configure_button.set_sensitive(False)
 
     def toggle_cb(self, cell, path, model):
         """
@@ -150,8 +164,8 @@
                 commondialogs.error(self.parent, _('Could '
                     'not disable plugin.'))
                 return
-
         model[path][1] = enable
+        self.row_selected(self.list.get_selection())
 
     def destroy(self, *e):
         self.dialog.destroy()