def register_provider(self, servicename, provider, target=None):
        """
            Registers a provider for a service. The provider object is used
            by consumers of the service.

            Services can be targeted for a specific use. For example, if you
            have a widget that uses a service 'foo', if your object can perform
            a service only for a specific type of widget, then target would be
            set to the widget type.

            If you had a service that could perform 'foo' for all widgets, then
            target would be set to None, and all widgets could use your service.

            It is intended that most services should set target to None, with
            some narrow exceptions.

            :param servicename: the name of the service [string]
            :type servicename: string
            :param provider: the object that is the provider [object]
            :type provider: object
            :param target: a specific target for the service [object]
            :type target: object
        """
        service = self.services.setdefault(servicename, {})
        providers = service.setdefault(target, [])
        if provider not in providers:
            providers.append(provider)
            logger.debug(
                "Provider %(provider)s registered for service %(service)s "
                "with target %(target)s"
                % {'provider': provider.name, 'service': servicename, 'target': target}
            )
            event.log_event("%s_provider_added" % servicename, self, (provider, target))

    def get_cddb_info(self):
        try:
            disc = DiscID.open(self.device)
            self.info = DiscID.disc_id(disc)
            status, info = CDDB.query(self.info)
        except IOError:
            return

        if status in (210, 211):
            info = info[0]
            status = 200
        if status != 200:
            return

        (status, info) = CDDB.read(info['category'], info['disc_id'])

        title = info['DTITLE'].split(" / ")
        for i in range(self.info[1]):
            tr = self[i]
            tr.set_tag_raw('title',
                    info['TTITLE' + `i`].decode('iso-8859-15', 'replace'))
            tr.set_tag_raw('album',
                    title[1].decode('iso-8859-15', 'replace'))
            tr.set_tag_raw('artist',
                    title[0].decode('iso-8859-15', 'replace'))
            tr.set_tag_raw('year',
                    info['EXTD'].replace("YEAR: ", ""))
            tr.set_tag_raw('genre',
                    info['DGENRE'])

        self.name = title[1].decode('iso-8859-15', 'replace')
        event.log_event('cddb_info_retrieved', self, True)

    def set_tag_raw(self, tag, values, notify_changed=True):
        """
            Set the raw value of a tag.

            :param tag: The name of the tag to set.
            :param values: The value or values to set the tag to.
            :param notify_changed: whether to send a signal to let other
                parts of Exaile know there has been an update. Only set
                this to False if you know that no other parts of Exaile
                need to be updated.
        """
        # handle values that aren't lists
        if not isinstance(values, list):
            if not tag.startswith("__"): # internal tags dont have to be lists
                values = [values]

        # TODO: is this needed? why?
        # for lists, filter out empty values and convert to unicode
        if isinstance(values, list):
            values = [common.to_unicode(x, self.__tags.get('__encoding'))
                for x in values if x not in (None, '')]

        # save some memory by not storing null values.
        if not values:
            try:
                del self.__tags[tag]
            except KeyError:
                pass
        else:
            self.__tags[tag] = values

        self._dirty = True
        if notify_changed:
            event.log_event("track_tags_changed", self, tag)

    def remove_library(self, library):
        """
            Remove a library from the collection

            :param library: the library to remove
            :type library: :class:`Library`
        """
        for k, v in self.libraries.iteritems():
            if v == library:
                del self.libraries[k]
                break

        to_rem = []
        if not "://" in library.location:
            location = u"file://" + library.location
        else:
            location = library.location
        for tr in self.tracks:
            if tr.startswith(location):
                to_rem.append(self.tracks[tr]._track)
        self.remove_tracks(to_rem)

        self.serialize_libraries()
        self._dirty = True

        if self._frozen:
            self._libraries_dirty = True
        else:
            event.log_event('libraries_modified', self, None)

    def transfer(self):
        """
            Tranfer the queued tracks to the library.

            This is NOT asynchronous
        """
        self.transferring = True
        self.current_pos += 1
        try:
            while self.current_pos  < len(self.queue) and not self._stop:
                track = self.queue[self.current_pos]
                loc = track.get_loc_for_io()
                self.library.add(loc)

                # TODO: make this be based on filesize not count
                progress = self.current_pos * 100 / len(self.queue)
                event.log_event('track_transfer_progress', self, progress)

                self.current_pos += 1
        finally:
            self.queue = []
            self.transferring = False
            self.current_pos = -1
            self._stop = False
            event.log_event('track_transfer_progress', self, 100)

    def unregister_provider(self, servicename, provider, target=None):
        """
            Unregisters a provider.

            :param servicename: the name of the service
            :type servicename: string
            :param provider: the provider to be removed
            :type provider: object
            :param target: a specific target for the service [object]
            :type target: object
        """
        if servicename not in self.services:
            return
        try:
            service = self.services[servicename]
            if provider in service[target]:
                service[target].remove(provider)
                logger.debug(
                    "Provider %(provider)s unregistered from "
                    "service %(service)s with target %(target)s" % {
                        'provider' : provider.name,
                        'service' : servicename,
                        'target' : target
                    }
                )
                event.log_event("%s_provider_removed" % servicename, self, (provider, target))
                if not service[target]: #no values for target key then del it
                    del service[target]
        except KeyError:
            return

    def get_cddb_info(self):
        try:
            disc = DiscID.open(self.device)
            self.info = DiscID.disc_id(disc)
            status, info = CDDB.query(self.info)
        except IOError:
            return

        if status in (210, 211):
            info = info[0]
            status = 200
        if status != 200:
            return

        (status, info) = CDDB.read(info["category"], info["disc_id"])

        title = info["DTITLE"].split(" / ")
        for i in range(self.info[1]):
            tr = self[i]
            tr.set_tag_raw("title", info["TTITLE" + str(i)].decode("iso-8859-15", "replace"))
            tr.set_tag_raw("album", title[1].decode("iso-8859-15", "replace"))
            tr.set_tag_raw("artist", title[0].decode("iso-8859-15", "replace"))
            tr.set_tag_raw("year", info["EXTD"].replace("YEAR: ", ""))
            tr.set_tag_raw("genre", info["DGENRE"])

        self.name = title[1].decode("iso-8859-15", "replace")
        event.log_event("cddb_info_retrieved", self, True)

    def set_option(self, option, value, save=True):
        """
            Set an option (in ``section/key`` syntax) to the specified value

            :param option: the full path to an option
            :type option: string
            :param value: the value the option should be assigned
            :type value: any
            :param save: If True, cause the settings to be written to file
        """
        value = self._val_to_str(value)
        splitvals = option.split('/')
        section, key = "/".join(splitvals[:-1]), splitvals[-1]

        try:
            self.set(section, key, value)
        except NoSectionError:
            self.add_section(section)
            self.set(section, key, value)

        self._dirty = True
        
        if save:
            self.delayed_save()

        section = section.replace('/', '_')

        event.log_event('option_set', self, option)
        event.log_event('%s_option_set' % section, self, option)

 def _on_message(self, bus, message, reading_tag=False):
     handled = self._handle_message(bus, message, reading_tag)
     if handled:
         pass
     elif message.type == gst.MESSAGE_TAG:
         """ Update track length and optionally metadata from gstreamer's parser.
             Useful for streams and files mutagen doesn't understand. """
         parsed = message.parse_tag()
         event.log_event('tags_parsed', self, (self.current, parsed))
         if self.current and not self.current.get_tag_raw('__length'):
             try:
                 raw_duration = self._pipe.query_duration(gst.FORMAT_TIME, None)[0]
             except gst.QueryError:
                 logger.error("Couldn't query duration")
                 raw_duration = 0
             duration = float(raw_duration)/gst.SECOND
             if duration > 0:
                 self.current.set_tag_raw('__length', duration)
     elif message.type == gst.MESSAGE_EOS and not self.is_paused():
         self._eos_func()
     elif message.type == gst.MESSAGE_ERROR:
         logger.error("%s %s" %(message, dir(message)) )
         message_text = message.parse_error()[1]
         # The most readable part is always the last..
         message_text = message_text[message_text.rfind(':') + 1:]
         # .. unless there's nothing in it.
         if ' ' not in message_text:
             if message_text.startswith('playsink'):
                 message_text += _(': Possible audio device error, is it plugged in?')
         event.log_event('playback_error', self, message_text)
         self._error_func()
     return True

    def _restore_player_state(self, location):
        if not settings.get_option("%s/resume_playback" % self.player._name, True):
            return

        try:
            f = open(location, 'rb')
            state = pickle.load(f)
            f.close()
        except:
            return

        for req in ['state', 'position', '_playtime_stamp']:
            if req not in state:
                return

        if state['state'] in ['playing', 'paused']:
            event.log_event("playback_player_resume", self.player, None)
            vol = self.player._get_volume()
            self.player._set_volume(0)
            self.play(self.get_current())

            if self.player.current:
                self.player.seek(state['position'])
                if state['state'] == 'paused' or \
                        settings.get_option("%s/resume_paused" % self.player._name, False):
                    self.player.toggle_pause()
                self.player._playtime_stamp = state['_playtime_stamp']

            self.player._set_volume(vol)

    def play(self, track):
        """
            plays the specified track, overriding any currently playing track

            if the track cannot be played, playback stops completely
        """
        if track is None:
            self.stop()
            return False
        else:
            self.stop(fire=False)

        playing = self.is_playing()

        self._current = track

        uri = track.get_loc_for_io()
        logger.info("Playing %s" % uri)
        self.reset_playtime_stamp()

        self.playbin.set_property("uri", uri)
        if urlparse.urlsplit(uri)[0] == "cdda":
            self.notify_id = self.playbin.connect('notify::source',
                    self.__notify_source)

        self.playbin.set_state(gst.STATE_PLAYING)
        if not playing:
            event.log_event('playback_player_start', self, track)
        event.log_event('playback_track_start', self, track)

        return True

 def update_field(self, name, *params):
     try:
         self[name] = getattr(self, '_'+name.replace('-', '_'))(*params)
     except:
         self[name] = ''
     if name in [f[0] for f in self.get_template_fields()]:
         event.log_event('field_refresh', self, (name, self[name]))

    def rescan(self, notify_interval=None, force_update=False):
        '''
            Called when a library needs to refresh its track list.

            The force_update parameter is not applicable and is ignored.
        '''
        if self.collection is None:
            return True

        if self.scanning:
            return
        t = time.time()
        logger.info('Scanning library: %s' % self.daap_share.name)
        self.scanning = True
        db = self.collection

        # DAAP gives us all the tracks in one dump
        self.daap_share.reload()
        if self.daap_share.all:
            count = len(self.daap_share.all)
        else:
            count = 0

        if count > 0:
            logger.info('Adding %d tracks from %s. (%f s)' % (count, 
                                    self.daap_share.name, time.time()-t))
            self.collection.add_tracks(self.daap_share.all)


        if notify_interval is not None:
            event.log_event('tracks_scanned', self, count)

        # track removal?
        self.scanning = False

    def seek(self, value):
        """
            seek to the given position in the current stream
        """
        self.streams[self._current_stream].seek(value)
        self._reset_crossfade_timer()

        event.log_event('playback_seeked', self, value)

 def __set_connected(self, val):
     prior = self._connected
     self._connected = val
     if prior != val:
         if val:
             event.log_event("device_connected", self, self)
         else:
             event.log_event("device_disconnected", self, self)

 def remove_device(self, device):
     try:
         if device.connected:
             device.disconnect()
         del self.devices[device.get_name()]
     except KeyError:
         pass
     event.log_event("device_removed", self, device)

 def do_rating_changed(self, rating):
     """
         Updates the rating of the currently playing track
     """
     if player.PLAYER.current is not None:
         player.PLAYER.current.set_rating(rating)
         maximum = settings.get_option('rating/maximum', 5)
         event.log_event('rating_changed', self, rating / maximum * 100)

 def link_clicked(self, link):
     if link[0] == 'rate':
         self.track.set_rating(int(link[1]))
         self.refresh_rating()
         for field in ['rating', 'track-info']:
             if field in self.get_template_fields():
                 event.log_event('field_refresh', self, (field, str(self[field])))
         return True

 def __set_queue_has_tracks(self, value):
     if value != self.__queue_has_tracks_val:
         oldpos = self.current_position
         self.__queue_has_tracks_val = value
         event.log_event(
             "playlist_current_position_changed",
             self,
             (self.current_position, oldpos),
         )

    def SetRating(self, value):
        """
            Sets the current track's rating

            :param value: the new rating
            :type value: int
        """
        self.SetTrackAttr('__rating', value)
        event.log_event('rating_changed', self, value)