def fetch_active_playlist(self):
try:
playlist = Playlist.get(self.active_playlist_id)
return playlist
except:
# The play list have been removed or disapperd use tmpqueue as fallback
self.active_playlist_id = self.tmpqueue_id
self.active_playlists_track_id = 0
playlist = Playlist.get(self.active_playlist_id)
return playlist
def API_removeTrackFromPlaylist(self, playlist_id, track_id):
try:
playlist = Playlist.get(playlist_id)
playlist.remove_track_id(int(track_id))
except ValueError as e:
raise
self.needs_push_update = True
def API_addTrackToPlaylist(self, playlist_id, uri):
track = self.create_track_from_uri(uri)
try:
playlist = Playlist.get(playlist_id)
except ValueError as e:
raise
return playlist.add_track(track)
self.needs_push_update = True
def API_addTracksToPlaylist(self, playlist_id, uri, request):
tracks = self.create_tracks_from_uri(uri)
try:
playlist = Playlist.get(playlist_id)
except ValueError as e:
raise
self.needs_push_update = True
request.finish(playlist.add_tracks(tracks, -1))
def get_all_tracks_in_playlist(self, playlist_id):
try:
playlist = Playlist.get(playlist_id)
except ValueError as e:
raise
tracks = playlist.get_all_tracks()
ret = [track.__dict__ for track in tracks]
return ret
def API_moveTrackInPlaylist(self, playlist_id, track_id, position):
try:
playlist = Playlist.get(playlist_id)
playlist.move_track(int(track_id), int(position))
except ValueError as e:
raise
return 0
self.needs_push_update = True
def API_removeTrack(self, nbr):
nbr = int(nbr)
# For now if we are trying to remove the existing playing track. Do nothing.
if (nbr == self.active_playlist_id):
logging.warning("Not allowed to remove playing track")
return
playlist = Playlist.get(self.tmpqueue_id)
playlist.remove_track_id(nbr)
self.needs_push_update = True
def API_removeTracksFromPlaylist(self, playlist_id, track_ids, request):
try:
playlist = Playlist.get(playlist_id)
for track_id in track_ids.split(','):
# don't crash on railing comma
if track_id != '':
playlist.remove_playlist_tracks_id(int(track_id))
except ValueError as e:
raise
self.needs_push_update = True
request.finish()
def fetch_active_track(self):
# Assume that fetch active playlist alreay been run
playlist = Playlist.get(self.active_playlist_id)
if playlist.length() <= 0:
return None
if self.active_playlists_track_id != -1:
try:
track = playlist.get_track_id(self.active_playlists_track_id)
return track
except:
logging.debug("Could not get active track")
return None
else:
# Try the first active_play_list id
track = playlist.get_track_nbr(0)
self.active_playlists_track_id = track.ptid
return track
class Player(object):
#attr_accessor :current_track, :history, :playlist, :current_track, :backend
attr_accessor(current_track = None)
def __init__(self):
from player_backends.gstreamer import Gstreamer
self.playlist = Playlist()
self.backend = PlayerBackend(self, Gstreamer)
def state(self):
return self.backend.get_state()
@callback_method
def schedule_next_track(self):
self.remove_current_track()
if self.playlist.empty():
#print 'nope, no new track'
self.stop()
return False
return self.next_track_as_current()
@callback_method
def next_track_as_current(self):
self.current_track = self.playlist.get()
#print 'New track: ' + self.current_track.name
def remove_current_track(self):
self.current_track = None
@callback_method
def play(self):
#if still playing, return nothing
if (self.state() == 'playing'): return False
if (self.state() == 'paused'): return self.resume()
if (self.playlist.empty() and not self.current_track): return None
if not self.current_track:
self.next_track_as_current()
print 'play'
result = self.backend.play(self.current_track) #Current track is set
return result
def pause(self):
if self.playing():
return self.backend.pause()
elif self.paused():
return self.resume()
def resume(self):
return self.backend.resume()
@callback_method
def stop(self):
self.backend.stop()
result = self.remove_current_track()
return result
def next(self):
self.schedule_next_track()
return self.backend.play(self.current_track) #Current track is set
def playing(self):
return self.state() == 'playing'
def paused(self):
return self.state() == 'paused'
def stopped(self):
return self.state() == 'stopped'
def register_callback(self, name, callback, permanent=False, priority=0):
return callbacks.RegisterCallback(Player, name, callback, permanent, priority)
def API_queue(self, uri):
track = self.dogvibes.create_track_from_uri(uri)
playlist = Playlist.get(self.tmpqueue_id)
playlist.add_track(track)
self.needs_push_update = True
def API_getAllTracksInPlaylist(self, playlist_id):
try:
playlist = Playlist.get(playlist_id)
except ValueError as e:
raise
return [track.__dict__ for track in playlist.get_all_tracks()]
def change_track(self, tracknbr, relative):
tracknbr = int(tracknbr)
if relative and (tracknbr > 1 or tracknbr < -1):
raise DogError, "Relative change track greater/less than 1 not implemented"
playlist = self.fetch_active_playlist()
track = self.fetch_active_track()
if track == None:
logging.warning("Could not find any active track")
return
# If we are in tmpqueue either removetrack or push it to the top
if self.is_in_tmpqueue():
if relative and (tracknbr == 1):
# Remove track and goto next track
playlist.remove_track_id(self.active_playlists_track_id)
next_position = 0
elif relative and (tracknbr == -1):
# Do nothing since we are always on top in playqueue
return
else:
# Move requested track to top of tmpqueue and play it
self.active_playlists_track_id = tracknbr
playlist.move_track(self.active_playlists_track_id, 1)
next_position = 0
# Check if tmpqueue no longer exists (all tracks has been removed)
if playlist.length() <= 0:
# Check if we used to be in a playlist
if self.fallback_playlist_id != -1:
# Change one track forward in the playlist we used to be in
self.active_playlist_id = self.fallback_playlist_id
self.active_playlists_track_id = self.fallback_playlists_track_id
playlist = Playlist.get(self.active_playlist_id)
next_position = playlist.get_track_id(self.active_playlists_track_id).position - 1
next_position = next_position + 1
if next_position >= playlist.length():
# We were the last song in the playlist we used to be in, just stop everyting
self.set_state(gst.STATE_NULL)
return
else:
# We have not entered any playlist yet, just stop playback
self.set_state(gst.STATE_NULL)
return
elif (Playlist.get(self.tmpqueue_id).length() > 0) and relative:
# Save the playlist that we curently are playing in for later use
self.fallback_playlist_id = self.active_playlist_id
self.fallback_playlists_track_id = self.active_playlists_track_id
# Switch to playqueue
self.active_playlist_id = self.tmpqueue_id
playlist = Playlist.get(self.active_playlist_id)
next_position = 0
else:
# We are inside a playlist
if relative:
next_position = track.position - 1 + tracknbr
else:
try:
next_position = playlist.get_track_id(tracknbr).position - 1
except:
self.set_state(gst.STATE_NULL)
self.active_playlists_track_id = -1
logging.warning("Could not find this id in the active playlist")
self.set_state(gst.STATE_NULL)
return
try:
track = playlist.get_track_nbr(next_position)
except:
self.set_state(gst.STATE_NULL)
self.active_playlists_track_id = -1
logging.debug("Could not get to next posiiton in the active playlist")
return
self.active_playlists_track_id = track.ptid
self.set_state(gst.STATE_NULL)
self.play_only_if_null(playlist.get_track_id(self.active_playlists_track_id))
class Player:
def __init__(self, name, modules, config, serverHttpRequest, serverMq):
self.name = name
self.serverMq = serverMq;
self.playerModules = dict();
for moduleClass in modules:
print "loading player module " + moduleClass["moduleName"]
self.playerModules[moduleClass["moduleName"]] = moduleClass["class"](config, self.next)
self.playlist = Playlist(config.get("Server", "name"), serverHttpRequest);
self.currentPlayer = None;
self.job = None
def getPlayer(self, name):
LOGGER.info("getting player " + name)
return self.playerModules[name]
def switchPlayer(self, name):
next = self.getPlayer(name)
if self.currentPlayer is None or next != self.currentPlayer:
if self.currentPlayer is not None:
self.currentPlayer.pause()
self.currentPlayer = next
def play(self, track=None):
track = track or self.playlist.get()
if track is not None:
LOGGER.info("playing (name: " + str(track.name) + ", uri: " + str(track.uri) + ") on: " + track.source)
self.switchPlayer(track.source)
if self.currentPlayer.play(track) is False:
self.next();
else:
self.serverMq.emit("player:status", {'status':'PLAYING', "playingId": track._id, "track": track.jsonFull})
#self.setSendProgressJob()
else:
if self.job is not None:
self.job.remove()
self.serverMq.emit("player:status", {'status':"PAUSED"})
LOGGER.info("playlist empty")
def resume(self):
LOGGER.info("curent track = " + str(self.currentPlayer.currentTrack));
if self.currentPlayer.currentTrack is None:
self.play()
else:
self.currentPlayer.resume()
LOGGER.info("emit 'player:status' => 'PLAYING'")
self.serverMq.emit("player:status", {'status':'PLAYING'})
self.setSendProgressJob()
def pause(self):
self.currentPlayer.pause()
if self.job is not None:
self.job.remove()
self.serverMq.emit("player:status", {'status':"PAUSED"})
def next(self):
next = self.playlist.next();
if next is None:
LOGGER.info("Nothing after")
self.pause()
return None
else:
LOGGER.info("playing next")
self.play(next)
return next;
def previous(self):
previous = self.playlist.previous();
if previous is not None:
self.play(previous)
else:
self.pause()
def API_removeTrackFromPlaylist(self, playlist_id, track_id):
playlist = Playlist.get(playlist_id)
playlist.remove_track(track_id)
def API_addTrackToPlaylist(self, playlist_id, uri):
track = self.create_track_from_uri(uri)
playlist = Playlist.get(playlist_id)
return playlist.add_track(track)
def API_getAllTracksInPlaylist(self, playlist_id):
playlist = Playlist.get(playlist_id)
return [track.__dict__ for track in playlist.get_all_tracks()]
