Source code for mopidy.core.playback

from __future__ import absolute_import, unicode_literals

import logging
import urlparse

from mopidy import models
from mopidy.audio import PlaybackState
from mopidy.core import listener
from mopidy.internal import deprecation, validation

logger = logging.getLogger(__name__)


[docs]class PlaybackController(object): pykka_traversable = True def __init__(self, backends, core): self.backends = backends self.core = core self._current_tl_track = None self._stream_title = None self._state = PlaybackState.STOPPED def _get_backend(self): # TODO: take in track instead track = self.get_current_track() if track is None: return None uri = track.uri uri_scheme = urlparse.urlparse(uri).scheme return self.backends.with_playback.get(uri_scheme, None) # Properties
[docs] def get_current_tl_track(self): """Get the currently playing or selected track. Returns a :class:`mopidy.models.TlTrack` or :class:`None`. """ return self._current_tl_track
def _set_current_tl_track(self, value): """Set the currently playing or selected track. *Internal:* This is only for use by Mopidy's test suite. """ self._current_tl_track = value current_tl_track = deprecation.deprecated_property(get_current_tl_track) """ .. deprecated:: 1.0 Use :meth:`get_current_tl_track` instead. """
[docs] def get_current_track(self): """ Get the currently playing or selected track. Extracted from :meth:`get_current_tl_track` for convenience. Returns a :class:`mopidy.models.Track` or :class:`None`. """ return getattr(self.get_current_tl_track(), 'track', None)
current_track = deprecation.deprecated_property(get_current_track) """ .. deprecated:: 1.0 Use :meth:`get_current_track` instead. """ def get_current_tlid(self): """ Get the currently playing or selected TLID. Extracted from :meth:`get_current_tl_track` for convenience. Returns a :class:`int` or :class:`None`. .. versionadded:: 1.1 """ return getattr(self.get_current_tl_track(), 'tlid', None)
[docs] def get_stream_title(self): """Get the current stream title or :class:`None`.""" return self._stream_title
[docs] def get_state(self): """Get The playback state.""" return self._state
[docs] def set_state(self, new_state): """Set the playback state. Must be :attr:`PLAYING`, :attr:`PAUSED`, or :attr:`STOPPED`. Possible states and transitions: .. digraph:: state_transitions "STOPPED" -> "PLAYING" [ label="play" ] "STOPPED" -> "PAUSED" [ label="pause" ] "PLAYING" -> "STOPPED" [ label="stop" ] "PLAYING" -> "PAUSED" [ label="pause" ] "PLAYING" -> "PLAYING" [ label="play" ] "PAUSED" -> "PLAYING" [ label="resume" ] "PAUSED" -> "STOPPED" [ label="stop" ] """ validation.check_choice(new_state, validation.PLAYBACK_STATES) (old_state, self._state) = (self.get_state(), new_state) logger.debug('Changing state: %s -> %s', old_state, new_state) self._trigger_playback_state_changed(old_state, new_state)
state = deprecation.deprecated_property(get_state, set_state) """ .. deprecated:: 1.0 Use :meth:`get_state` and :meth:`set_state` instead. """
[docs] def get_time_position(self): """Get time position in milliseconds.""" backend = self._get_backend() if backend: return backend.playback.get_time_position().get() else: return 0
time_position = deprecation.deprecated_property(get_time_position) """ .. deprecated:: 1.0 Use :meth:`get_time_position` instead. """
[docs] def get_volume(self): """ .. deprecated:: 1.0 Use :meth:`core.mixer.get_volume() <mopidy.core.MixerController.get_volume>` instead. """ deprecation.warn('core.playback.get_volume') return self.core.mixer.get_volume()
def set_volume(self, volume): """ .. deprecated:: 1.0 Use :meth:`core.mixer.set_volume() <mopidy.core.MixerController.set_volume>` instead. """ deprecation.warn('core.playback.set_volume') return self.core.mixer.set_volume(volume) volume = deprecation.deprecated_property(get_volume, set_volume) """ .. deprecated:: 1.0 Use :meth:`core.mixer.get_volume() <mopidy.core.MixerController.get_volume>` and :meth:`core.mixer.set_volume() <mopidy.core.MixerController.set_volume>` instead. """
[docs] def get_mute(self): """ .. deprecated:: 1.0 Use :meth:`core.mixer.get_mute() <mopidy.core.MixerController.get_mute>` instead. """ deprecation.warn('core.playback.get_mute') return self.core.mixer.get_mute()
def set_mute(self, mute): """ .. deprecated:: 1.0 Use :meth:`core.mixer.set_mute() <mopidy.core.MixerController.set_mute>` instead. """ deprecation.warn('core.playback.set_mute') return self.core.mixer.set_mute(mute) mute = deprecation.deprecated_property(get_mute, set_mute) """ .. deprecated:: 1.0 Use :meth:`core.mixer.get_mute() <mopidy.core.MixerController.get_mute>` and :meth:`core.mixer.set_mute() <mopidy.core.MixerController.set_mute>` instead. """ # Methods # TODO: remove this. def _change_track(self, tl_track, on_error_step=1): """ Change to the given track, keeping the current playback state. :param tl_track: track to change to :type tl_track: :class:`mopidy.models.TlTrack` or :class:`None` :param on_error_step: direction to step at play error, 1 for next track (default), -1 for previous track. **INTERNAL** :type on_error_step: int, -1 or 1 """ old_state = self.get_state() self.stop() self._set_current_tl_track(tl_track) if old_state == PlaybackState.PLAYING: self._play(on_error_step=on_error_step) elif old_state == PlaybackState.PAUSED: # NOTE: this is just a quick hack to fix #1177 as this code has # already been killed in the gapless branch. backend = self._get_backend() if backend: backend.playback.prepare_change() backend.playback.change_track(tl_track.track).get() self.pause() # TODO: this is not really end of track, this is on_need_next_track def _on_end_of_track(self): """ Tell the playback controller that end of track is reached. Used by event handler in :class:`mopidy.core.Core`. """ if self.get_state() == PlaybackState.STOPPED: return original_tl_track = self.get_current_tl_track() next_tl_track = self.core.tracklist.eot_track(original_tl_track) if next_tl_track: self._change_track(next_tl_track) else: self.stop() self._set_current_tl_track(None) self.core.tracklist._mark_played(original_tl_track) def _on_tracklist_change(self): """ Tell the playback controller that the current playlist has changed. Used by :class:`mopidy.core.TracklistController`. """ tracklist = self.core.tracklist.get_tl_tracks() if self.get_current_tl_track() not in tracklist: self.stop() self._set_current_tl_track(None) def _on_stream_changed(self, uri): self._stream_title = None
[docs] def next(self): """ Change to the next track. The current playback state will be kept. If it was playing, playing will continue. If it was paused, it will still be paused, etc. """ original_tl_track = self.get_current_tl_track() next_tl_track = self.core.tracklist.next_track(original_tl_track) if next_tl_track: # TODO: switch to: # backend.play(track) # wait for state change? self._change_track(next_tl_track) else: self.stop() self._set_current_tl_track(None) self.core.tracklist._mark_played(original_tl_track)
[docs] def pause(self): """Pause playback.""" backend = self._get_backend() if not backend or backend.playback.pause().get(): # TODO: switch to: # backend.track(pause) # wait for state change? self.set_state(PlaybackState.PAUSED) self._trigger_track_playback_paused()
[docs] def play(self, tl_track=None, tlid=None): """ Play the given track, or if the given tl_track and tlid is :class:`None`, play the currently active track. Note that the track **must** already be in the tracklist. :param tl_track: track to play :type tl_track: :class:`mopidy.models.TlTrack` or :class:`None` :param tlid: TLID of the track to play :type tlid: :class:`int` or :class:`None` """ if sum(o is not None for o in [tl_track, tlid]) > 1: raise ValueError('At most one of "tl_track" and "tlid" may be set') tl_track is None or validation.check_instance(tl_track, models.TlTrack) tlid is None or validation.check_integer(tlid, min=0) if tl_track: deprecation.warn('core.playback.play:tl_track_kwarg', pending=True) self._play(tl_track=tl_track, tlid=tlid, on_error_step=1)
def _play(self, tl_track=None, tlid=None, on_error_step=1): if tl_track is None and tlid is not None: for tl_track in self.core.tracklist.get_tl_tracks(): if tl_track.tlid == tlid: break else: tl_track = None if tl_track is None: if self.get_state() == PlaybackState.PAUSED: return self.resume() if self.get_current_tl_track() is not None: tl_track = self.get_current_tl_track() else: if on_error_step == 1: tl_track = self.core.tracklist.next_track(tl_track) elif on_error_step == -1: tl_track = self.core.tracklist.previous_track(tl_track) if tl_track is None: return assert tl_track in self.core.tracklist.get_tl_tracks() # TODO: switch to: # backend.play(track) # wait for state change? if self.get_state() == PlaybackState.PLAYING: self.stop() self._set_current_tl_track(tl_track) self.set_state(PlaybackState.PLAYING) backend = self._get_backend() success = False if backend: backend.playback.prepare_change() try: success = ( backend.playback.change_track(tl_track.track).get() and backend.playback.play().get()) except TypeError: logger.error( '%s needs to be updated to work with this ' 'version of Mopidy.', backend.actor_ref.actor_class.__name__) logger.debug('Backend exception', exc_info=True) if success: self.core.tracklist._mark_playing(tl_track) self.core.history._add_track(tl_track.track) # TODO: replace with stream-changed self._trigger_track_playback_started() else: self.core.tracklist._mark_unplayable(tl_track) if on_error_step == 1: # TODO: can cause an endless loop for single track repeat. self.next() elif on_error_step == -1: self.previous()
[docs] def previous(self): """ Change to the previous track. The current playback state will be kept. If it was playing, playing will continue. If it was paused, it will still be paused, etc. """ tl_track = self.get_current_tl_track() # TODO: switch to: # self.play(....) # wait for state change? self._change_track( self.core.tracklist.previous_track(tl_track), on_error_step=-1)
[docs] def resume(self): """If paused, resume playing the current track.""" if self.get_state() != PlaybackState.PAUSED: return backend = self._get_backend() if backend and backend.playback.resume().get(): self.set_state(PlaybackState.PLAYING) # TODO: trigger via gst messages self._trigger_track_playback_resumed() # TODO: switch to: # backend.resume() # wait for state change?
[docs] def seek(self, time_position): """ Seeks to time position given in milliseconds. :param time_position: time position in milliseconds :type time_position: int :rtype: :class:`True` if successful, else :class:`False` """ validation.check_integer(time_position) if time_position < 0: logger.debug( 'Client seeked to negative position. Seeking to zero.') time_position = 0 if not self.core.tracklist.tracks: return False if self.current_track and self.current_track.length is None: return False if self.get_state() == PlaybackState.STOPPED: self.play() if time_position < 0: time_position = 0 elif time_position > self.current_track.length: self.next() return True backend = self._get_backend() if not backend: return False success = backend.playback.seek(time_position).get() if success: self._trigger_seeked(time_position) return success
[docs] def stop(self): """Stop playing.""" if self.get_state() != PlaybackState.STOPPED: backend = self._get_backend() time_position_before_stop = self.get_time_position() if not backend or backend.playback.stop().get(): self.set_state(PlaybackState.STOPPED) self._trigger_track_playback_ended(time_position_before_stop)
def _trigger_track_playback_paused(self): logger.debug('Triggering track playback paused event') if self.current_track is None: return listener.CoreListener.send( 'track_playback_paused', tl_track=self.get_current_tl_track(), time_position=self.get_time_position()) def _trigger_track_playback_resumed(self): logger.debug('Triggering track playback resumed event') if self.current_track is None: return listener.CoreListener.send( 'track_playback_resumed', tl_track=self.get_current_tl_track(), time_position=self.get_time_position()) def _trigger_track_playback_started(self): logger.debug('Triggering track playback started event') if self.get_current_tl_track() is None: return listener.CoreListener.send( 'track_playback_started', tl_track=self.get_current_tl_track()) def _trigger_track_playback_ended(self, time_position_before_stop): logger.debug('Triggering track playback ended event') if self.get_current_tl_track() is None: return listener.CoreListener.send( 'track_playback_ended', tl_track=self.get_current_tl_track(), time_position=time_position_before_stop) def _trigger_playback_state_changed(self, old_state, new_state): logger.debug('Triggering playback state change event') listener.CoreListener.send( 'playback_state_changed', old_state=old_state, new_state=new_state) def _trigger_seeked(self, time_position): logger.debug('Triggering seeked event') listener.CoreListener.send('seeked', time_position=time_position)