def __init__(self):
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
UserPlaylistPlayer.__init__(self)
TagReader.__init__(self)
def set_albums(self, track_id, artist_ids, genre_ids):
"""
Set album list (for next/prev)
@param track id as int
@param artist id as int
@param genre id as int
"""
# Invalid track
if track_id is None:
return
album = Track(track_id).album
self._albums = []
ShufflePlayer.reset_history(self)
# We are not playing a user playlist anymore
self._user_playlist = []
self._user_playlist_id = None
# We are in all artists
if (genre_ids and genre_ids[0] == Type.ALL) or\
(artist_ids and artist_ids[0] == Type.ALL):
self._albums = Lp().albums.get_compilations()
self._albums += Lp().albums.get_ids()
# We are in populars view, add popular albums
elif genre_ids and genre_ids[0] == Type.POPULARS:
if self._shuffle in [Shuffle.TRACKS_ARTIST, Shuffle.ALBUMS_ARTIST]:
self._albums = []
self.next_track = Track()
for album_id in Lp().albums.get_populars():
if Lp().albums.get_artist_id(album_id) == \
album.artist_id:
self._albums.append(album_id)
else:
self._albums = Lp().albums.get_populars()
# We are in recents view, add recent albums
elif genre_ids and genre_ids[0] == Type.RECENTS:
self._albums = Lp().albums.get_recents()
# We are in randoms view, add random albums
elif genre_ids and genre_ids[0] == Type.RANDOMS:
self._albums = Lp().albums.get_cached_randoms()
# We are in compilation view without genre
elif genre_ids and genre_ids[0] == Type.COMPILATIONS:
self._albums = Lp().albums.get_compilations()
# Random tracks/albums for artist
elif self._shuffle in [Shuffle.TRACKS_ARTIST, Shuffle.ALBUMS_ARTIST]:
self._albums = Lp().albums.get_ids([album.artist_id], genre_ids)
# Add all albums for genre
else:
if not artist_ids:
self._albums = Lp().albums.get_compilations(genre_ids)
self._albums += Lp().albums.get_ids(artist_ids, genre_ids)
album.set_genre(genre_ids)
if track_id in album.tracks_ids:
self.context.artist_ids = artist_ids
self.context.genre_ids = genre_ids
# Shuffle album list if needed
self._shuffle_albums()
else: # Error
self.stop()
def __init__(self):
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
UserPlaylistPlayer.__init__(self)
RadioPlayer.__init__(self)
ExternalsPlayer.__init__(self)
def set_party(self, party):
"""
Set party mode on if party is True
Play a new random track if not already playing
@param party as bool
"""
ShufflePlayer.set_party(self, party)
self.update_crossfading()
def set_albums(self, track_id, artist_ids, genre_ids):
"""
Set album list (for next/prev)
@param track id as int
@param artist id as int
@param genre id as int
"""
# Invalid track
if track_id is None:
return
album = Track(track_id).album
self._albums = []
ShufflePlayer.reset_history(self)
# We are not playing a user playlist anymore
self._user_playlist = []
self._user_playlist_id = None
# We are in all artists
if (genre_ids and genre_ids[0] == Type.ALL) or\
(artist_ids and artist_ids[0] == Type.ALL):
self._albums = Lp().albums.get_compilations()
self._albums += Lp().albums.get_ids()
# We are in populars view, add popular albums
elif genre_ids and genre_ids[0] == Type.POPULARS:
if self._shuffle in [Shuffle.TRACKS_ARTIST, Shuffle.ALBUMS_ARTIST]:
self._albums = []
for album_id in Lp().albums.get_populars():
if Lp().albums.get_artist_id(album_id) in artist_ids:
self._albums.append(album_id)
else:
self._albums = Lp().albums.get_populars()
# We are in recents view, add recent albums
elif genre_ids and genre_ids[0] == Type.RECENTS:
self._albums = Lp().albums.get_recents()
# We are in randoms view, add random albums
elif genre_ids and genre_ids[0] == Type.RANDOMS:
self._albums = Lp().albums.get_cached_randoms()
# We are in compilation view without genre
elif genre_ids and genre_ids[0] == Type.COMPILATIONS:
self._albums = Lp().albums.get_compilations()
# Random tracks/albums for artist
elif self._shuffle in [Shuffle.TRACKS_ARTIST, Shuffle.ALBUMS_ARTIST]:
self._albums = Lp().albums.get_ids([album.artist_id], genre_ids)
# Add all albums for genre
else:
if not artist_ids:
self._albums = Lp().albums.get_compilations(genre_ids)
self._albums += Lp().albums.get_ids(artist_ids, genre_ids)
album.set_genre(genre_ids)
if track_id in album.tracks_ids:
self.context.artist_ids = artist_ids
self.context.genre_ids = genre_ids
# Shuffle album list if needed
self._shuffle_albums()
else: # Error
self.stop()
def set_party(self, party):
"""
Set party mode on if party is True
Play a new random track if not already playing
@param party as bool
"""
ShufflePlayer.set_party(self, party)
self.set_next()
self.set_prev()
self.update_crossfading()
def set_party(self, party):
"""
Set party mode on if party is True
Play a new random track if not already playing
@param party as bool
"""
ShufflePlayer.set_party(self, party)
self.set_next()
self.set_prev()
if self.is_playing():
self.emit('next-changed')
def __init__(self):
"""
Create all objects
"""
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
UserPlaylistPlayer.__init__(self)
RadioPlayer.__init__(self)
ExternalsPlayer.__init__(self)
def set_party(self, party):
"""
Set party mode on if party is True
Play a new random track if not already playing
@param party as bool
"""
ShufflePlayer.set_party(self, party)
self.set_next()
self.set_prev()
if self.is_playing():
self.emit('next-changed')
def __init__(self):
"""
Create all objects
"""
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
UserPlaylistPlayer.__init__(self)
RadioPlayer.__init__(self)
ExternalsPlayer.__init__(self)
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if not Lp().scanner.is_locked():
Lp().window.pulse(False)
if self._current_track.id >= 0:
ShufflePlayer._on_stream_start(self, bus, message)
self.set_next()
self.set_prev()
BinPlayer._on_stream_start(self, bus, message)
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if self.is_in_queue(self._current_track.id):
self.remove_from_queue(self._current_track.id)
ShufflePlayer._on_stream_start(self, bus, message)
BinPlayer._on_stream_start(self, bus, message)
AutoSimilarPlayer._on_stream_start(self, bus, message)
self.set_next()
self.set_prev()
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if self.track_in_queue(self._current_track):
self.remove_from_queue(self._current_track.id)
else:
self._current_playback_track = self._current_track
ShufflePlayer._on_stream_start(self, bus, message)
BinPlayer._on_stream_start(self, bus, message)
self.set_prev()
self.set_next()
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if self.current_track.id >= 0:
ShufflePlayer._on_stream_start(self, bus, message)
if self._queue and self.current_track.id == self._queue[0]:
self._queue.pop(0)
self.emit("queue-changed")
self.set_next()
self.set_prev()
BinPlayer._on_stream_start(self, bus, message)
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if self.current_track.id >= 0:
ShufflePlayer._on_stream_start(self, bus, message)
if self._queue and self.current_track.id == self._queue[0]:
self._queue.pop(0)
self.emit("queue-changed")
self.set_next()
self.set_prev()
BinPlayer._on_stream_start(self, bus, message)
def __init__(self):
"""
Init player
"""
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
UserPlaylistPlayer.__init__(self)
RadioPlayer.__init__(self)
ExternalsPlayer.__init__(self)
self.update_crossfading()
def __init__(self):
"""
Init player
"""
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
UserPlaylistPlayer.__init__(self)
RadioPlayer.__init__(self)
ExternalsPlayer.__init__(self)
self.update_crossfading()
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if not Lp().scanner.is_locked():
Lp().window.pulse(False)
if self._current_track.id is not None and self._current_track.id >= 0:
ShufflePlayer._on_stream_start(self, bus, message)
if not self.__do_not_update_next:
self.set_next()
self.__do_not_update_next = False
self.set_prev()
BinPlayer._on_stream_start(self, bus, message)
def set_albums(self, track_id, artist_id, genre_id):
# Invalid track
if track_id is None:
return
album_id = Lp.tracks.get_album_id(track_id)
self._albums = None
ShufflePlayer.reset_history(self)
self.context.genre_id = genre_id
# When shuffle from artist is active, we want only artist's albums,
# we need to ignore genre
# Do not set genre_id directly as it will changes current context
if self._shuffle in [Shuffle.TRACKS_ARTIST, Shuffle.ALBUMS_ARTIST]:
genre_id_lookup = None
else:
genre_id_lookup = genre_id
# We are not playing a user playlist anymore
self._user_playlist = None
# We are in all artists
if genre_id_lookup == Type.ALL or artist_id == Type.ALL:
self._albums = Lp.albums.get_compilations(Type.ALL)
self._albums += Lp.albums.get_ids()
# We are in populars view, add popular albums
elif genre_id_lookup == Type.POPULARS:
self._albums = Lp.albums.get_populars()
# We are in recents view, add recent albums
elif genre_id_lookup == Type.RECENTS:
self._albums = Lp.albums.get_recents()
# We are in randoms view, add random albums
elif genre_id_lookup == Type.RANDOMS:
self._albums = Lp.albums.get_cached_randoms()
# We are in compilation view without genre
elif genre_id_lookup == Type.COMPILATIONS:
self._albums = Lp.albums.get_compilations(None)
# Random tracks/albums for artist
elif self._shuffle in [Shuffle.TRACKS_ARTIST, Shuffle.ALBUMS_ARTIST]:
self._albums = Lp.albums.get_ids(artist_id, genre_id_lookup)
# Add all albums for genre
else:
self._albums = Lp.albums.get_compilations(genre_id_lookup)
self._albums += Lp.albums.get_ids(None, genre_id_lookup)
tracks = Lp.albums.get_tracks(album_id, genre_id_lookup)
if track_id in tracks:
self.context.position = tracks.index(track_id)
self.context.genre_id = genre_id
# Shuffle album list if needed
self._shuffle_albums()
elif self.current_track.id != Type.RADIOS:
self.stop()
def __init__(self):
"""
Init player
"""
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
UserPlaylistPlayer.__init__(self)
RadioPlayer.__init__(self)
ExternalsPlayer.__init__(self)
self.update_crossfading()
self.__do_not_update_next = False
Lp().settings.connect("changed::playback", self.__on_playback_changed)
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if not Lp().scanner.is_locked():
Lp().window.pulse(False)
if self.current_track.id >= 0:
ShufflePlayer._on_stream_start(self, bus, message)
if self._queue and self.current_track.id == self._queue[0]:
self._queue.pop(0)
self.emit("queue-changed")
self.set_next()
self.set_prev()
BinPlayer._on_stream_start(self, bus, message)
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if not Lp().scanner.is_locked():
Lp().window.pulse(False)
if self.current_track.id >= 0:
ShufflePlayer._on_stream_start(self, bus, message)
if self._queue and self.current_track.id == self._queue[0]:
self._queue.pop(0)
self.emit("queue-changed")
self.set_next()
self.set_prev()
BinPlayer._on_stream_start(self, bus, message)
def __init__(self):
"""
Init player
"""
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
UserPlaylistPlayer.__init__(self)
RadioPlayer.__init__(self)
ExternalsPlayer.__init__(self)
self.update_crossfading()
self.__do_not_update_next = False
Lp().settings.connect('changed::playback', self.__on_playback_changed)
def set_albums(self, track_id, artist_id, genre_id):
"""
Set album list (for next/prev)
@param track id as int
@param artist id as int
@param genre id as int
"""
# Invalid track
if track_id is None:
return
album = Track(track_id).album
self._albums = None
ShufflePlayer.reset_history(self)
# We are not playing a user playlist anymore
self._user_playlist = None
self._user_playlist_id = None
# We are in all artists
if genre_id == Type.ALL or artist_id == Type.ALL:
self._albums = Lp.albums.get_compilations(Type.ALL)
self._albums += Lp.albums.get_ids()
# We are in populars view, add popular albums
elif genre_id == Type.POPULARS:
self._albums = Lp.albums.get_populars()
# We are in recents view, add recent albums
elif genre_id == Type.RECENTS:
self._albums = Lp.albums.get_recents()
# We are in randoms view, add random albums
elif genre_id == Type.RANDOMS:
self._albums = Lp.albums.get_cached_randoms()
# We are in compilation view without genre
elif genre_id == Type.COMPILATIONS:
self._albums = Lp.albums.get_compilations(None)
# Random tracks/albums for artist
elif self._shuffle in [Shuffle.TRACKS_ARTIST, Shuffle.ALBUMS_ARTIST]:
self._albums = Lp.albums.get_ids(artist_id, genre_id)
# Add all albums for genre
else:
self._albums = Lp.albums.get_compilations(genre_id)
self._albums += Lp.albums.get_ids(None, genre_id)
album.set_genre(genre_id)
if track_id in album.tracks_ids:
self.context.position = album.tracks_ids.index(track_id)
self.context.genre_id = genre_id
# Shuffle album list if needed
self._shuffle_albums()
else: # Error
self.stop()
def set_albums(self, track_id, artist_id, genre_id):
"""
Set album list (for next/prev)
@param track id as int
@param artist id as int
@param genre id as int
"""
# Invalid track
if track_id is None:
return
album = Track(track_id).album
self._albums = None
ShufflePlayer.reset_history(self)
# We are not playing a user playlist anymore
self._user_playlist = None
self._user_playlist_id = None
# We are in all artists
if genre_id == Type.ALL or artist_id == Type.ALL:
self._albums = Lp.albums.get_compilations(Type.ALL)
self._albums += Lp.albums.get_ids()
# We are in populars view, add popular albums
elif genre_id == Type.POPULARS:
self._albums = Lp.albums.get_populars()
# We are in recents view, add recent albums
elif genre_id == Type.RECENTS:
self._albums = Lp.albums.get_recents()
# We are in randoms view, add random albums
elif genre_id == Type.RANDOMS:
self._albums = Lp.albums.get_cached_randoms()
# We are in compilation view without genre
elif genre_id == Type.COMPILATIONS:
self._albums = Lp.albums.get_compilations(None)
# Random tracks/albums for artist
elif self._shuffle in [Shuffle.TRACKS_ARTIST, Shuffle.ALBUMS_ARTIST]:
self._albums = Lp.albums.get_ids(artist_id, genre_id)
# Add all albums for genre
else:
self._albums = Lp.albums.get_compilations(genre_id)
self._albums += Lp.albums.get_ids(None, genre_id)
album.set_genre(genre_id)
if track_id in album.tracks_ids:
self.context.position = album.tracks_ids.index(track_id)
self.context.genre_id = genre_id
# Shuffle album list if needed
self._shuffle_albums()
else: # Error
self.stop()
def __init__(self):
"""
Init player
"""
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
PlaylistPlayer.__init__(self)
RadioPlayer.__init__(self)
SimilarsPlayer.__init__(self)
self.__stop_after_track_id = None
self.update_crossfading()
App().settings.connect("changed::repeat", self.__on_repeat_changed)
self._albums_backup = []
def __init__(self):
"""
Init player
"""
GObject.GObject.__init__(self)
AlbumsPlayer.__init__(self)
AutoRandomPlayer.__init__(self)
AutoSimilarPlayer.__init__(self)
BinPlayer.__init__(self)
QueuePlayer.__init__(self)
LinearPlayer.__init__(self)
ShufflePlayer.__init__(self)
TransitionsPlayer.__init__(self)
self.__stop_after_track_id = None
App().settings.connect("changed::repeat", self.update_next_prev)
def set_next(self):
"""
Play next track
@param sql as sqlite cursor
"""
# Reset finished context
self._finished = NextContext.NONE
# Look at externals
self._next_track = ExternalsPlayer.next(self)
# Look at radio
if self._next_track.id is None:
self._next_track = RadioPlayer.next(self)
# Look first at user queue
if self._next_track.id is None:
self._next_track = QueuePlayer.next(self)
# Look at user playlist then
if self._next_track.id is None:
self._next_track = UserPlaylistPlayer.next(self)
# Get a random album/track then
if self._next_track.id is None:
self._next_track = ShufflePlayer.next(self)
# Get a linear track then
if self._next_track.id is None:
self._next_track = LinearPlayer.next(self)
self.emit('next-changed')
def set_next(self):
"""
Play next track
"""
if self._current_track.id is None:
return
if self._current_track.id == self.__stop_after_track_id:
self._next_track = Track()
return
try:
next_track = QueuePlayer.next(self)
if next_track.id is None:
# Diverge current track to restore playback from queue
diverge_current_track = None
if self._queue_current_track is not None:
diverge_current_track = self._current_track
self._current_track = self._queue_current_track
if App().settings.get_value("shuffle") or self.is_party:
next_track = ShufflePlayer.next(self)
else:
next_track = LinearPlayer.next(self)
# Restore current track
if diverge_current_track is not None:
self._current_track = diverge_current_track
self._queue_current_track = None
self._next_track = next_track
emit_signal(self, "next-changed")
except Exception as e:
Logger.error("Player::set_next(): %s" % e)
def set_prev(self):
"""
Set previous track
"""
try:
# Look at externals
self._prev_track = ExternalsPlayer.prev(self)
# Look at radio
if self._prev_track.id is None:
self._prev_track = RadioPlayer.prev(self)
# Look at user playlist then
if self._prev_track.id is None:
self._prev_track = UserPlaylistPlayer.prev(self)
# Look at shuffle
if self._prev_track.id is None:
self._prev_track = ShufflePlayer.prev(self)
# Get a linear track then
if self._prev_track.id is None:
self._prev_track = LinearPlayer.prev(self)
self.emit('prev-changed')
except Exception as e:
print("Player::set_prev", e)
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if not App().scanner.is_locked():
App().window.container.pulse(False)
if self._current_track.id is not None and self._current_track.id >= 0:
ShufflePlayer._on_stream_start(self, bus, message)
if self.track_in_queue(self._current_track):
self.remove_from_queue(self._current_track.id)
else:
if self.shuffle_has_next or not self.__do_not_update_next:
self.set_next()
self.__do_not_update_next = False
self.set_prev()
BinPlayer._on_stream_start(self, bus, message)
def set_prev(self):
"""
Set previous track
"""
try:
# Look at externals
self._prev_track = ExternalsPlayer.prev(self)
# Look at radio
if self._prev_track.id is None:
self._prev_track = RadioPlayer.prev(self)
# Look at user playlist then
if self._prev_track.id is None:
self._prev_track = UserPlaylistPlayer.prev(self)
# Look at shuffle
if self._prev_track.id is None:
self._prev_track = ShufflePlayer.prev(self)
# Get a linear track then
if self._prev_track.id is None:
self._prev_track = LinearPlayer.prev(self)
self.emit('prev-changed')
except Exception as e:
print("Player::set_prev", e)
def set_next(self):
"""
Play next track
"""
if self.current_track.id == Type.RADIOS or\
self._current_track.id == self.__stop_after_track_id:
self.__stop_after_track_id = None
self._next_track = Track()
return
try:
next_track = QueuePlayer.next(self)
# Look at shuffle
if next_track.id is None:
next_track = ShufflePlayer.next(self)
# Look at user playlist then
if next_track.id is None:
next_track = PlaylistPlayer.next(self)
# Get a linear track then
if next_track.id is None:
next_track = LinearPlayer.next(self)
self._next_track = next_track
if next_track.is_web:
App().task_helper.run(self._load_from_web, next_track, False)
self.emit("next-changed")
except Exception as e:
Logger.error("Player::set_next(): %s" % e)
def set_next(self):
"""
Play next track
@param sql as sqlite cursor
"""
# Look at externals
self.next_track = ExternalsPlayer.next(self)
# Look at radio
if self.next_track.id is None:
self.next_track = RadioPlayer.next(self)
# Look first at user queue
if self.next_track.id is None:
self.next_track = QueuePlayer.next(self)
# Look at user playlist then
if self.next_track.id is None:
self.next_track = UserPlaylistPlayer.next(self)
# Get a random album/track then
if self.next_track.id is None:
self.next_track = ShufflePlayer.next(self)
# Get a linear track then
if self.next_track.id is None:
self.next_track = LinearPlayer.next(self)
def set_next(self):
"""
Play next track
@param sql as sqlite cursor
"""
# Look at externals
self.next_track = ExternalsPlayer.next(self)
# Look at radio
if self.next_track.id is None:
self.next_track = RadioPlayer.next(self)
# Look first at user queue
if self.next_track.id is None:
self.next_track = QueuePlayer.next(self)
if self.next_track.id is not None:
self.context.next_track = LinearPlayer.next(self)
# Look at user playlist then
if self.next_track.id is None:
self.next_track = UserPlaylistPlayer.next(self)
# Get a random album/track then
if self.next_track.id is None:
self.next_track = ShufflePlayer.next(self)
# Get a linear track then
if self.next_track.id is None:
if self.context.next_track is not None:
self.next_track = self.context.next_track
self.context.next_track = None
else:
self.next_track = LinearPlayer.next(self)
self.emit('next-changed')
def set_prev(self):
"""
Set previous track
"""
try:
if Lp().settings.get_enum('playback') == NextContext.REPEAT_TRACK:
self._prev_track = self.current_track
else:
# Look at externals
self._prev_track = ExternalsPlayer.prev(self)
# Look at radio
if self._prev_track.id is None:
self._prev_track = RadioPlayer.prev(self)
# Look at user playlist then
if self._prev_track.id is None:
self._prev_track = UserPlaylistPlayer.prev(self)
# Look at shuffle
if self._prev_track.id is None:
self._prev_track = ShufflePlayer.prev(self)
# Get a linear track then
if self._prev_track.id is None:
self._prev_track = LinearPlayer.prev(self)
self.emit('prev-changed')
except Exception as e:
print("Player::set_prev", e)
def set_next(self):
"""
Play next track
@param sql as sqlite cursor
"""
# Look at externals
self.next_track = ExternalsPlayer.next(self)
# Look at radio
if self.next_track.id is None:
self.next_track = RadioPlayer.next(self)
# Look first at user queue
if self.next_track.id is None:
self.next_track = QueuePlayer.next(self)
# Look at user playlist then
if self.next_track.id is None:
self.next_track = UserPlaylistPlayer.next(self)
# Get a random album/track then
if self.next_track.id is None:
self.next_track = ShufflePlayer.next(self)
# Get a linear track then
if self.next_track.id is None:
self.next_track = LinearPlayer.next(self)
def set_next(self):
"""
Play next track
@param sql as sqlite cursor
"""
# Look at externals
self.next_track = ExternalsPlayer.next(self)
# Look at radio
if self.next_track.id is None:
self.next_track = RadioPlayer.next(self)
# Look first at user queue
if self.next_track.id is None:
self.next_track = QueuePlayer.next(self)
if self.next_track.id is not None:
self.context.next_track = LinearPlayer.next(self)
# Look at user playlist then
if self.next_track.id is None:
self.next_track = UserPlaylistPlayer.next(self)
# Get a random album/track then
if self.next_track.id is None:
self.next_track = ShufflePlayer.next(self)
# Get a linear track then
if self.next_track.id is None:
if self.context.next_track is not None:
self.next_track = self.context.next_track
self.context.next_track = None
else:
self.next_track = LinearPlayer.next(self)
self.emit('next-changed')
def set_next(self, force=False):
"""
Play next track
@param sql as sqlite cursor
@param force as bool
"""
try:
# Reset finished context
self._next_context = NextContext.NONE
# Same track
if App().settings.get_enum("playback") == NextContext.REPEAT_TRACK:
next_track = self._current_track
# Look first at user queue
else:
next_track = QueuePlayer.next(self)
# Look at shuffle
if next_track.id is None:
next_track = ShufflePlayer.next(self)
# Look at user playlist then
if next_track.id is None:
next_track = PlaylistPlayer.next(self, force)
# Get a linear track then
if next_track.id is None:
next_track = LinearPlayer.next(self)
self._next_track = next_track
self.emit("next-changed")
except Exception as e:
Logger.error("Player::set_next(): %s" % e)
def set_prev(self):
"""
Set previous track
"""
# Special case to return from queue
if self._queue and self.context.prev_track.id is None:
self.context.prev_track = self.current_track
elif not self._queue and self.context.prev_track.id is not None:
self.prev_track = self.context.prev_track
self.context.prev_track = Track()
self.emit('prev-changed')
return
# Look at externals
self.prev_track = ExternalsPlayer.prev(self)
# Look at radio
if self.prev_track.id is None:
self.prev_track = RadioPlayer.prev(self)
# Look at user playlist then
if self.prev_track.id is None:
self.prev_track = UserPlaylistPlayer.prev(self)
# Look at shuffle
if self.prev_track.id is None:
self.prev_track = ShufflePlayer.prev(self)
# Get a linear track then
if self.prev_track.id is None:
self.prev_track = LinearPlayer.prev(self)
self.emit('prev-changed')
def set_prev(self):
"""
Set previous track
"""
# Special case to return from queue
if self._queue and self.context.prev_track.id is None:
self.context.prev_track = self.current_track
elif not self._queue and self.context.prev_track.id is not None:
self.prev_track = self.context.prev_track
self.context.prev_track = Track()
self.emit('prev-changed')
return
# Look at externals
self.prev_track = ExternalsPlayer.prev(self)
# Look at radio
if self.prev_track.id is None:
self.prev_track = RadioPlayer.prev(self)
# Look at user playlist then
if self.prev_track.id is None:
self.prev_track = UserPlaylistPlayer.prev(self)
# Look at shuffle
if self.prev_track.id is None:
self.prev_track = ShufflePlayer.prev(self)
# Get a linear track then
if self.prev_track.id is None:
self.prev_track = LinearPlayer.prev(self)
self.emit('prev-changed')
def set_prev(self):
"""
Set previous track
"""
try:
if Lp().settings.get_enum("playback") == NextContext.REPEAT_TRACK:
self._prev_track = self._current_track
else:
# Look at externals
self._prev_track = ExternalsPlayer.prev(self)
# Look at radio
if self._prev_track.id is None:
self._prev_track = RadioPlayer.prev(self)
# Look at user playlist then
if self._prev_track.id is None:
self._prev_track = UserPlaylistPlayer.prev(self)
# Look at shuffle
if self._prev_track.id is None:
self._prev_track = ShufflePlayer.prev(self)
# Get a linear track then
if self._prev_track.id is None:
self._prev_track = LinearPlayer.prev(self)
self.emit("prev-changed")
except Exception as e:
print("Player::set_prev():", e)
def _on_stream_start(self, bus, message):
"""
On stream start, set next and previous track
"""
if not Lp().scanner.is_locked():
Lp().window.pulse(False)
if self.current_track.id >= 0:
ShufflePlayer._on_stream_start(self, bus, message)
if self._queue and self.current_track.id == self._queue[0]:
self._queue.pop(0)
self.emit("queue-changed")
# Only set next if needed, not when user load a track in shuffle mode
if (not self._is_party and self._shuffle != Shuffle.TRACKS_ARTIST and
self._shuffle != Shuffle.TRACKS) or\
self.current_track == self.next_track or\
self.current_track.id == Type.RADIOS or\
self.next_track.id is None:
self.set_next()
self.set_prev()
BinPlayer._on_stream_start(self, bus, message)
def prev(self):
# Look at user playlist then
track_id = UserPlaylistPlayer.prev(self)
# Look at shuffle
if track_id is None:
track_id = ShufflePlayer.prev(self)
if track_id is None:
track_id = LinearPlayer.prev(self)
if track_id is not None:
self.load(track_id)
def set_prev(self):
"""
Set previous track
"""
if self._current_track.id is None:
return
try:
if App().settings.get_value("shuffle") or self.is_party:
prev_track = ShufflePlayer.prev(self)
else:
prev_track = LinearPlayer.prev(self)
self._prev_track = prev_track
emit_signal(self, "prev-changed")
except Exception as e:
Logger.error("Player::set_prev(): %s" % e)
def _set_prev(self):
# Look at externals
self.prev_track = ExternalsPlayer.prev(self)
# Look at radio
if self.prev_track.id is None:
self.prev_track = RadioPlayer.prev(self)
# Look at user playlist then
if self.prev_track.id is None:
self.prev_track = UserPlaylistPlayer.prev(self)
# Look at shuffle
if self.prev_track.id is None:
self.prev_track = ShufflePlayer.prev(self)
# Get a linear track then
if self.prev_track.id is None:
self.prev_track = LinearPlayer.prev(self)
def set_prev(self):
"""
Set previous track
"""
if self.current_track.id == Type.RADIOS:
return
try:
prev_track = ShufflePlayer.prev(self)
# Look at user playlist then
if prev_track.id is None:
prev_track = PlaylistPlayer.prev(self)
# Get a linear track then
if prev_track.id is None:
prev_track = LinearPlayer.prev(self)
self._prev_track = prev_track
self.emit("prev-changed")
except Exception as e:
Logger.error("Player::set_prev(): %s" % e)
def set_next(self, force=False):
"""
Play next track
@param sql as sqlite cursor
@param force as bool
"""
try:
# Reset finished context
self._next_context = NextContext.NONE
if Lp().settings.get_enum('playback') == NextContext.REPEAT_TRACK:
next_track = self.current_track
else:
# Look at externals
next_track = ExternalsPlayer.next(self)
# Look at radio
if next_track.id is None:
next_track = RadioPlayer.next(self)
# Look first at user queue
if next_track.id is None:
next_track = QueuePlayer.next(self)
# Look at user playlist then
if next_track.id is None:
next_track = UserPlaylistPlayer.next(self, force)
# Get a random album/track then
if next_track.id is None:
next_track = ShufflePlayer.next(self)
# Get a linear track then
if next_track.id is None:
next_track = LinearPlayer.next(self)
if next_track.is_web:
self._load_web(next_track, False)
self._next_track = next_track
self.emit('next-changed')
except Exception as e:
print("Player::set_next", e)
def set_next(self):
"""
Play next track
@param sql as sqlite cursor
"""
# Reset finished context
self._finished = NextContext.NONE
# Special case to return from queue
if self._queue and self.context.next_track.id is None:
self.context.next_track = self.next_track
elif not self._queue and self.context.next_track.id is not None:
self.next_track = self.context.next_track
self.context.next_track = Track()
self.emit('next-changed')
return
# Look at externals
self.next_track = ExternalsPlayer.next(self)
# Look at radio
if self.next_track.id is None:
self.next_track = RadioPlayer.next(self)
# Look first at user queue
if self.next_track.id is None:
self.next_track = QueuePlayer.next(self)
# Look at user playlist then
if self.next_track.id is None:
self.next_track = UserPlaylistPlayer.next(self)
# Get a random album/track then
if self.next_track.id is None:
self.next_track = ShufflePlayer.next(self)
# Get a linear track then
if self.next_track.id is None:
self.next_track = LinearPlayer.next(self)
self.emit('next-changed')
def set_next(self, force=False):
"""
Play next track
@param sql as sqlite cursor
@param force as bool
"""
try:
# Reset finished context
self._next_context = NextContext.NONE
if Lp().settings.get_enum('playback') == NextContext.REPEAT_TRACK:
next_track = self._current_track
else:
# Look at externals
next_track = ExternalsPlayer.next(self)
# Look at radio
if next_track.id is None:
next_track = RadioPlayer.next(self)
# Look first at user queue
if next_track.id is None:
next_track = QueuePlayer.next(self)
# Look at user playlist then
if next_track.id is None:
next_track = UserPlaylistPlayer.next(self, force)
# Get a random album/track then
if next_track.id is None:
next_track = ShufflePlayer.next(self)
# Get a linear track then
if next_track.id is None:
next_track = LinearPlayer.next(self)
if next_track.is_web:
self._load_web(next_track, False)
self._next_track = next_track
self.emit('next-changed')
except Exception as e:
print("Player::set_next():", e)
def next(self, force=True, sql=None):
# Look first at user queue
track_id = QueuePlayer.next(self)
# Look at user playlist then
if track_id is None:
track_id = UserPlaylistPlayer.next(self)
# Get a random album/track
if track_id is None:
track_id = ShufflePlayer.next(self, sql)
# Get a linear track
if track_id is None:
track_id = LinearPlayer.next(self, sql)
if track_id is not None:
if force:
self.load(track_id)
else:
self._load_track(track_id, sql)
def set_prev(self):
"""
Set previous track
"""
# Look at externals
self.prev_track = ExternalsPlayer.prev(self)
# Look at radio
if self.prev_track.id is None:
self.prev_track = RadioPlayer.prev(self)
# Look at user playlist then
if self.prev_track.id is None:
self.prev_track = UserPlaylistPlayer.prev(self)
# Look at shuffle
if self.prev_track.id is None:
self.prev_track = ShufflePlayer.prev(self)
# Get a linear track then
if self.prev_track.id is None:
self.prev_track = LinearPlayer.prev(self)
self.emit('prev-changed')
def _on_stream_start(self, bus, message):
if self.current_track.id >= 0:
ShufflePlayer._on_stream_start(self, bus, message)
self._set_next()
self._set_prev()
BinPlayer._on_stream_start(self, bus, message)
def set_party(self, party):
ShufflePlayer.set_party(self, party)
self._set_next()
self._set_prev()
def set_albums(self, track_id, artist_ids, genre_ids):
"""
Set album list (for next/prev)
@param track id as int
@param artist id as int
@param genre id as int
"""
# Invalid track
if track_id is None:
return
self._albums = []
self._context.genre_ids = {}
self._context.aritst_ids = {}
self._context.prev_track = Track()
self._context.next_track = Track()
ShufflePlayer.reset_history(self)
# We are not playing a user playlist anymore
self._user_playlist = []
self._user_playlist_ids = []
# We are in all artists
if (genre_ids and genre_ids[0] == Type.ALL) or\
(artist_ids and artist_ids[0] == Type.ALL):
# Genres: all, Artists: compilations
if artist_ids and artist_ids[0] == Type.COMPILATIONS:
self._albums += Lp().albums.get_compilations()
# Genres: all, Artists: ids
elif artist_ids and artist_ids[0] != Type.ALL:
self._albums += Lp().albums.get_ids(artist_ids)
# Genres: all, Artists: all
else:
if Lp().settings.get_value('show-compilations'):
self._albums += Lp().albums.get_compilations()
self._albums += Lp().albums.get_ids()
# We are in populars view, add popular albums
elif genre_ids and genre_ids[0] == Type.POPULARS:
self._albums = Lp().albums.get_populars()
# We are in recents view, add recent albums
elif genre_ids and genre_ids[0] == Type.RECENTS:
self._albums = Lp().albums.get_recents()
# We are in randoms view, add random albums
elif genre_ids and genre_ids[0] == Type.RANDOMS:
self._albums = Lp().albums.get_cached_randoms()
# We are in compilation view without genre
elif genre_ids and genre_ids[0] == Type.COMPILATIONS:
self._albums = Lp().albums.get_compilations()
# Add albums for artists/genres
else:
# If we are not in compilation view and show compilation is on,
# add compilations
if artist_ids and artist_ids[0] == Type.COMPILATIONS:
self._albums += Lp().albums.get_compilations(genre_ids)
else:
if not artist_ids and\
Lp().settings.get_value('show-compilations'):
self._albums += Lp().albums.get_compilations(genre_ids)
self._albums += Lp().albums.get_ids(artist_ids, genre_ids)
if Lp().settings.get_value('repeat'):
self._context.next = NextContext.NONE
else:
self._context.next = NextContext.STOP_ALL
# We do not store genre_ids for ALL/POPULARS/...
if genre_ids and genre_ids[0] < 0:
genre_ids = []
# Set context for each album
for album_id in self._albums:
self._context.genre_ids[album_id] = []
self._context.artist_ids[album_id] = []
for genre_id in genre_ids:
if genre_id >= 0:
self._context.genre_ids[album_id].append(genre_id)
for artist_id in artist_ids:
if artist_id >= 0:
self._context.artist_ids[album_id].append(artist_id)
# Shuffle album list if needed
self.shuffle_albums(True)
def _on_stream_start(self, bus, message):
BinPlayer._on_stream_start(self, bus, message)
ShufflePlayer._on_stream_start(self, bus, message)
