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 _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 __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 __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 __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_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, 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 """ 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)