def restore_state(self):
"""
Restore player state
"""
try:
if App().settings.get_value("save-state"):
current_track_id = load(open(LOLLYPOP_DATA_PATH +
"/track_id.bin", "rb"))
self.set_queue(load(open(LOLLYPOP_DATA_PATH +
"/queue.bin", "rb")))
albums = load(open(LOLLYPOP_DATA_PATH + "/Albums.bin", "rb"))
playlist_ids = load(open(LOLLYPOP_DATA_PATH +
"/playlist_ids.bin", "rb"))
(is_playing, was_party) = load(open(LOLLYPOP_DATA_PATH +
"/player.bin", "rb"))
if playlist_ids and playlist_ids[0] == Type.RADIOS:
radios = Radios()
track = Track()
name = radios.get_name(current_track_id)
url = radios.get_url(name)
track.set_radio(name, url)
self.load(track, is_playing)
elif App().tracks.get_uri(current_track_id) != "":
if albums:
if was_party:
App().lookup_action("party").change_state(
GLib.Variant("b", True))
else:
self._albums = load(open(
LOLLYPOP_DATA_PATH +
"/Albums.bin",
"rb"))
# Load track from player albums
current_track = Track(current_track_id)
index = self.album_ids.index(current_track.album.id)
for track in self._albums[index].tracks:
if track.id == current_track_id:
self._load_track(track)
break
else:
for playlist_id in playlist_ids:
tracks = App().playlists.get_tracks(playlist_id)
App().player.populate_playlist_by_tracks(
tracks, playlist_ids)
for track in tracks:
if track.id == current_track_id:
self._load_track(track)
break
if is_playing:
self.play()
else:
self.pause()
position = load(open(LOLLYPOP_DATA_PATH + "/position.bin",
"rb"))
self.seek(position / Gst.SECOND)
else:
Logger.info("Player::restore_state(): track missing")
self.emit("playlist-changed")
except Exception as e:
Logger.error("Player::restore_state(): %s" % e)
def restore_state(self):
"""
Restore player state
"""
try:
if Lp().settings.get_value('save-state'):
track_id = load(open(DataPath + "/track_id.bin", "rb"))
playlist_ids = load(open(DataPath + "/playlist_ids.bin", "rb"))
if playlist_ids and playlist_ids[0] == Type.RADIOS:
radios = Radios()
track = Track()
name = radios.get_name(track_id)
url = radios.get_url(name)
track.set_radio(name, url)
self.load(track)
elif Lp().tracks.get_uri(track_id) != "":
track = Track(track_id)
if Lp().notify is not None:
Lp().notify.inhibit()
self._load_track(track)
# We set this initial state
# because seek while failed otherwise
self.pause()
if playlist_ids:
pids = []
for playlist_id in playlist_ids:
pids.append(int(playlist_id))
track_ids = []
for playlist_id in playlist_ids:
if playlist_id == Type.POPULARS:
tracks = Lp().tracks.get_populars()
elif playlist_id == Type.RECENTS:
tracks = Lp().tracks.get_recently_listened_to()
elif playlist_id == Type.NEVER:
tracks = Lp().tracks.get_never_listened_to()
elif playlist_id == Type.RANDOMS:
tracks = Lp().tracks.get_randoms()
else:
tracks = Lp().playlists.get_track_ids(
playlist_id)
for track_id in tracks:
if track_id not in track_ids:
track_ids.append(track_id)
self.populate_user_playlist_by_tracks(
track_ids, pids)
else:
self._albums = load(
open(DataPath + "/albums.bin", "rb"))
self.shuffle_albums(True)
self._context.genre_ids = load(
open(DataPath + "/genre_ids.bin", "rb"))
self._context.artist_ids = load(
open(DataPath + "/artist_ids.bin", "rb"))
self.set_next()
self.set_prev()
else:
print("Player::restore_state(): track missing")
except Exception as e:
print("Player::restore_state()", e)
def restore_state(self):
"""
Restore player state
"""
if Lp().settings.get_value('save-state'):
track_id = Lp().settings.get_value('track-id').get_int32()
playlist_ids = Lp().settings.get_value('playlist-ids')
if playlist_ids and playlist_ids[0] == Type.RADIOS:
radios = Radios()
track = Track()
name = radios.get_name(track_id)
url = radios.get_url(name)
track.set_radio(name, url)
self.load(track)
elif Lp().tracks.get_path(track_id) != "":
track = Track(track_id)
self._load_track(track)
if playlist_ids:
try:
pids = []
for playlist_id in playlist_ids:
pids.append(int(playlist_id))
track_ids = []
for playlist_id in playlist_ids:
if playlist_id == Type.POPULARS:
tracks = Lp().tracks.get_populars()
elif playlist_id == Type.RECENTS:
tracks = Lp().tracks.get_recently_listened_to()
elif playlist_id == Type.NEVER:
tracks = Lp().tracks.get_never_listened_to()
elif playlist_id == Type.RANDOMS:
tracks = Lp().tracks.get_randoms()
else:
tracks = Lp().playlists.get_tracks_ids(
playlist_id)
for track_id in tracks:
if track_id not in track_ids:
track_ids.append(track_id)
self.populate_user_playlist_by_tracks(track_ids,
pids)
except:
pass # User set non int in gsettings
else:
self._albums = Lp().artists.get_albums(
track.album_artist_ids)
for album_id in self._albums:
self.context.genre_ids[album_id] = []
self.context.artist_ids[album_id] = []
self.set_next()
self.set_prev()
if Lp().settings.get_value('repeat'):
self.context.next = NextContext.NONE
else:
self.context.next = NextContext.STOP_ALL
self.emit('current-changed')
else:
print("Player::restore_state(): track missing")
def restore_state(self):
"""
Restore player state
"""
if Lp().settings.get_value('save-state'):
track_id = Lp().settings.get_value('track-id').get_int32()
playlist_ids = Lp().settings.get_value('playlist-ids')
if playlist_ids and playlist_ids[0] == Type.RADIOS:
radios = Radios()
track = Track()
name = radios.get_name(track_id)
url = radios.get_url(name)
track.set_radio(name, url)
self.load(track)
elif Lp().tracks.get_path(track_id) != "":
track = Track(track_id)
self._load_track(track)
if playlist_ids:
try:
pids = []
for playlist_id in playlist_ids:
pids.append(int(playlist_id))
track_ids = []
for playlist_id in playlist_ids:
if playlist_id == Type.POPULARS:
tracks = Lp().tracks.get_populars()
elif playlist_id == Type.RECENTS:
tracks = Lp().tracks.get_recently_listened_to()
elif playlist_id == Type.NEVER:
tracks = Lp().tracks.get_never_listened_to()
elif playlist_id == Type.RANDOMS:
tracks = Lp().tracks.get_randoms()
else:
tracks = Lp().playlists.get_tracks_ids(
playlist_id)
for track_id in tracks:
if track_id not in track_ids:
track_ids.append(track_id)
self.populate_user_playlist_by_tracks(track_ids,
pids)
except:
pass # User set non int in gsettings
else:
self._albums = Lp().artists.get_albums(
track.album_artist_ids)
for album_id in self._albums:
self.context.genre_ids[album_id] = []
self.context.artist_ids[album_id] = []
self.set_next()
self.set_prev()
if Lp().settings.get_value('repeat'):
self.context.next = NextContext.NONE
else:
self.context.next = NextContext.STOP_ALL
self.emit('current-changed')
else:
print("Player::restore_state(): track missing")
def set_radio_id(self, radio_id):
"""
Set radio id
@param radio_id as int
"""
from lollypop.radios import Radios
radios = Radios()
name = radios.get_name(radio_id)
uri = radios.get_uri(radio_id)
self.set_radio(name, uri)
def set_radio_id(self, radio_id):
"""
Set radio id
@param radio_id as int
"""
from lollypop.radios import Radios
radios = Radios()
self.id = Type.RADIOS
self._radio_id = radio_id
self._radio_name = radios.get_name(radio_id)
self._uri = radios.get_uri(radio_id)
def restore_state(self):
"""
Restore player state
"""
try:
if Lp().settings.get_value('save-state'):
track_id = load(open(DataPath + "/track_id.bin", "rb"))
playlist_ids = load(open(DataPath + "/playlist_ids.bin",
"rb"))
if playlist_ids and playlist_ids[0] == Type.RADIOS:
radios = Radios()
track = Track()
name = radios.get_name(track_id)
url = radios.get_url(name)
track.set_radio(name, url)
self.load(track)
elif Lp().tracks.get_path(track_id) != "":
track = Track(track_id)
if Lp().notify is not None:
Lp().notify.inhibit()
self._load_track(track)
# We set this initial state
# because seek while failed otherwise
self.pause()
if playlist_ids:
pids = []
for playlist_id in playlist_ids:
pids.append(int(playlist_id))
track_ids = []
for playlist_id in playlist_ids:
if playlist_id == Type.POPULARS:
tracks = Lp().tracks.get_populars()
elif playlist_id == Type.RECENTS:
tracks = Lp().tracks.get_recently_listened_to()
elif playlist_id == Type.NEVER:
tracks = Lp().tracks.get_never_listened_to()
elif playlist_id == Type.RANDOMS:
tracks = Lp().tracks.get_randoms()
else:
tracks = Lp().playlists.get_track_ids(
playlist_id)
for track_id in tracks:
if track_id not in track_ids:
track_ids.append(track_id)
self.populate_user_playlist_by_tracks(track_ids,
pids)
else:
self._albums = load(open(
DataPath + "/albums.bin",
"rb"))
self.shuffle_albums(True)
self._context.genre_ids = load(open(
DataPath + "/genre_ids.bin",
"rb"))
self._context.artist_ids = load(open(
DataPath + "/artist_ids.bin",
"rb"))
self.set_next()
self.set_prev()
if Lp().settings.get_value('repeat'):
self._context.next = NextContext.NONE
else:
self._context.next = NextContext.STOP_ALL
else:
print("Player::restore_state(): track missing")
except Exception as e:
print("Player::restore_state()", e)
class RadiosView(FlowBoxView, ViewController):
"""
Show radios flow box
"""
def __init__(self):
"""
Init view
"""
FlowBoxView.__init__(self)
ViewController.__init__(self, ViewControllerType.RADIO)
self._widget_class = RadioWidget
self.__radios = Radios()
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Lollypop/RadiosView.ui")
builder.connect_signals(self)
self.insert_row(0)
self.attach(builder.get_object("widget"), 0, 0, 1, 1)
self.__pop_tunein = TuneinPopover(self.__radios)
self.__pop_tunein.set_relative_to(builder.get_object("search_btn"))
def populate(self, radio_ids):
"""
Add radio widgets
@param radio_ids as [int]
"""
if radio_ids:
FlowBoxView.populate(self, radio_ids)
else:
self._scrolled.hide()
view = MessageView(_("No favorite radios"))
view.show()
self.add(view)
#######################
# PROTECTED #
#######################
def _add_items(self, radio_ids):
"""
Add radios to the view
Start lazy loading
@param radio ids as [int]
"""
widget = FlowBoxView._add_items(self, radio_ids, self.__radios)
if widget is not None:
widget.connect("overlayed", self.on_overlayed)
def _on_new_clicked(self, widget):
"""
Show popover for adding a new radio
@param widget as Gtk.Widget
"""
from lollypop.pop_radio import RadioPopover
popover = RadioPopover(None, self.__radios)
popover.set_relative_to(widget)
popover.popup()
def _on_search_clicked(self, widget):
"""
Show popover for searching radios
@param widget as Gtk.Widget
"""
self.__pop_tunein.populate()
self.__pop_tunein.show()
def _on_artwork_changed(self, artwork, name):
"""
Update children artwork if matching name
@param artwork as Artwork
@param name as str
"""
for child in self._box.get_children():
if name == child.name:
child.set_artwork()
def _on_map(self, widget):
"""
Set active ids
"""
self.__signal_id = self.__radios.connect("radio-changed",
self.__on_radio_changed)
App().settings.set_value("state-one-ids",
GLib.Variant("ai", [Type.RADIOS]))
App().settings.set_value("state-two-ids", GLib.Variant("ai", []))
def _on_unmap(self, widget):
"""
Destroy popover
@param widget as Gtk.Widget
"""
if self.__signal_id is not None:
self.__radios.disconnect(self.__signal_id)
self.__signal_id = None
self.__pop_tunein.destroy()
#######################
# PRIVATE #
#######################
def __add_radio(self, radio_id):
"""
Add radio
@param radio_id as int
"""
widget = RadioWidget(radio_id, self.__radios)
self._box.insert(widget, 0)
widget.populate()
widget.show()
def __on_radio_changed(self, radios, radio_id):
"""
Update view based on radio_id status
@param radios as Radios
@param radio_id as int
"""
exists = radios.exists(radio_id)
if exists:
item = None
for child in self._box.get_children():
if child.id == radio_id:
item = child
break
if item is None:
self.__add_radio(radio_id)
else:
name = self.__radios.get_name(radio_id)
item.rename(name)
else:
for child in self._box.get_children():
if child.id == radio_id:
child.destroy()
class RadiosView(FlowBoxView, ViewController):
"""
Show radios flow box
"""
def __init__(self, view_type=ViewType.SCROLLED):
"""
Init view
@param view_type as ViewType
"""
FlowBoxView.__init__(self, view_type)
ViewController.__init__(self, ViewControllerType.RADIO)
self._widget_class = RadioWidget
self._empty_icon_name = get_icon_name(Type.RADIOS)
self.__radios = Radios()
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Lollypop/RadiosView.ui")
builder.connect_signals(self)
self.insert_row(0)
self.attach(builder.get_object("widget"), 0, 0, 1, 1)
self.__pop_tunein = None
if not get_network_available("TUNEIN"):
builder.get_object("search_btn").hide()
def populate(self, radio_ids):
"""
Add radio widgets
@param radio_ids as [int]
"""
FlowBoxView.populate(self, radio_ids)
#######################
# PROTECTED #
#######################
def _add_items(self, radio_ids):
"""
Add radios to the view
Start lazy loading
@param radio ids as [int]
"""
self._remove_placeholder()
widget = FlowBoxView._add_items(self, radio_ids, self.__radios,
self._view_type)
if widget is not None:
widget.connect("overlayed", self.on_overlayed)
def _on_new_clicked(self, widget):
"""
Show popover for adding a new radio
@param widget as Gtk.Widget
"""
from lollypop.pop_radio import RadioPopover
popover = RadioPopover(None, self.__radios)
popover.set_relative_to(widget)
popover.popup()
def _on_search_clicked(self, widget):
"""
Show popover for searching radios
@param widget as Gtk.Widget
"""
if self.__pop_tunein is None:
self.__pop_tunein = TuneinPopover(self.__radios)
self.__pop_tunein.populate()
self.__pop_tunein.set_relative_to(widget)
self.__pop_tunein.popup()
def _on_artwork_changed(self, artwork, name):
"""
Update children artwork if matching name
@param artwork as Artwork
@param name as str
"""
for child in self._box.get_children():
if name == child.name:
child.set_artwork()
def _on_map(self, widget):
"""
Set active ids
"""
FlowBoxView._on_map(self, widget)
if not App().settings.get_value("show-sidebar"):
App().window.emit("show-can-go-back", True)
App().window.emit("can-go-back-changed", True)
self.__signal_id = self.__radios.connect("radio-changed",
self.__on_radio_changed)
App().settings.set_value("state-one-ids",
GLib.Variant("ai", [Type.RADIOS]))
App().settings.set_value("state-two-ids", GLib.Variant("ai", []))
App().settings.set_value("state-three-ids", GLib.Variant("ai", []))
def _on_unmap(self, widget):
"""
Destroy popover
@param widget as Gtk.Widget
"""
FlowBoxView._on_unmap(self, widget)
if self.__signal_id is not None:
self.__radios.disconnect(self.__signal_id)
self.__signal_id = None
if self.__pop_tunein is not None:
self.__pop_tunein.destroy()
self.__pop_tunein = None
#######################
# PRIVATE #
#######################
def __on_radio_changed(self, radios, radio_id):
"""
Update view based on radio_id status
@param radios as Radios
@param radio_id as int
"""
exists = radios.exists(radio_id)
if exists:
item = None
for child in self._box.get_children():
if child.id == radio_id:
item = child
break
if item is None:
self._add_items([radio_id])
else:
name = self.__radios.get_name(radio_id)
item.rename(name)
else:
for child in self._box.get_children():
if child.id == radio_id:
child.destroy()
