def populate_model(self):
action = AuthenticationAction(self)
action.connect('name-changed', self._action_name_changed_cb)
model = [
action,
]
return defer.succeed(model)
def liberateca_decorator(controller):
"""
Internet video decorator.
"""
controller.append_plugin('liberateca', 'Liberateca',
'/poblesec/liberateca/main')
return defer.succeed(None)
def spotify_decorator(controller):
"""
Adds a link to the main controller of the Spotify plugin.
"""
link = Link(controller_path='/poblesec/spotify/main', label=_('Spotify'))
controller.model.append(link)
return defer.succeed(None)
def get(self, media_uri, context_model=None, title="", uri=""):
"""
Retrieves a uri model
"""
if context_model == None:
result_model = LiberatecaVideoModel(title, uri)
else:
result_model = context_model
return result_model, defer.succeed(result_model)
def get(self, media_uri, context_model = None, title = "", uri = ""):
"""
Retrieves a uri model
"""
if context_model == None:
result_model = LiberatecaVideoModel(title, uri)
else:
result_model = context_model
return result_model, defer.succeed(result_model)
def play_this(video, frontend):
controllers = frontend.retrieve_controllers('/poblesec/video_player')
player = controllers[0]
player.player.play_model(video)
controllers = frontend.retrieve_controllers('/poblesec')
main = controllers[0]
main.show_video_player()
return defer.succeed(video)
def populate_model(self):
link_playlists = Link(
controller_path='/poblesec/spotify/playlists',
label=_('Playlists')
)
link_search = Link(
controller_path='/poblesec/spotify/search',
label=_('Search')
)
return defer.succeed([link_playlists, link_search])
def login(self, username = None, password = None):
"""
Loads API username and password.
@param username: API user
@type username: C{str}
@param password: API password
@type password: C{str}
"""
self.user = username
self.password = password
return defer.succeed(None)
def login(self, username=None, password=None):
"""
Loads API username and password.
@param username: API user
@type username: C{str}
@param password: API password
@type password: C{str}
"""
self.user = username
self.password = password
return defer.succeed(None)
def execute(self, item):
provider = get_spotify_provider()
if provider.is_logged_in():
self.name = _("Log in")
provider.logout()
dfr = defer.succeed(None)
else:
def controller_appended(result):
self.name = _("Log out")
return result
browser = self.controller.frontend.retrieve_controllers('/poblesec/browser')[0]
path = "/poblesec/spotify/login"
title = _("Log in")
dfr = browser.history.append_controller(path, title)
dfr.addCallback(controller_appended)
return dfr
def populate_model(self):
p = get_liberateca_provider()
if p.user == None:
return defer.fail('No se han introducido los datos')
l = liberateca(p.user, p.password)
model = []
try:
list = l.getSerieList()
except Exception as e:
return defer.fail('Error descargando lista de series [%s]' %
str(e))
# Ordena la lista alfabéticamente
slist = orderSerieList(list)
for i in slist:
action = serieButton(self, i['name'], i['id'])
action.connect('name-changed', self._action_name_changed_cb)
model.append(action)
return defer.succeed(model)
def populate_model(self):
p = get_liberateca_provider()
if p.user == None:
return defer.fail('No se han introducido los datos')
l = liberateca(p.user, p.password)
model = []
try:
list = l.getSerieT(p.serie)
except Exception as e:
return defer.fail('Error descargando lista de temporadas [%s]' %
str(e))
for i in list:
num = i['url'].split("/")[-2]
action = seasonButton(self, 'Temporada ' + num, num)
action.connect('name-changed', self._action_name_changed_cb)
model.append(action)
self.refresing = False
return defer.succeed(model)
def execute(self, item):
self.controller.debug("SpotifyTrackAction triggered")
def play_track(model):
self.controller.debug("SpotifyTrackAction play_track")
play_ctl = self.controller.frontend.retrieve_controllers(
'/poblesec/video_player'
)[0]
resource_provider = get_spotify_provider()
# When a gst source element is created to handle the
# appsrc:// uri this callback sets it up to get data from
# the spotify client.
play_ctl.player.pipeline.connect(
'notify::source',
resource_provider.client.gst_setup_source
)
# This callback handles start/stop/pause in the spotify client
play_ctl.player.connect(
'status-changed',
resource_provider.client.gst_state_changed
)
self.controller.debug("Start playing model via gst")
play_ctl.player.play_model(model)
# Set up the client to feed the track data to gst
self.controller.debug("Load track in spotify client")
resource_provider.client.load_track(model.playable_uri)
main = self.controller.frontend.retrieve_controllers('/poblesec')[0]
main.show_video_player()
dfr = defer.succeed(item)
dfr.addCallback(play_track)
return dfr
def populate_model(self):
p = get_liberateca_provider()
if p.user == None:
return defer.fail('No se han introducido los datos')
l = liberateca(p.user, p.password)
model = []
try:
list = l.getSerieT(p.serie, p.temporada)
except Exception as e:
return defer.fail('Error descargando lista de episodios [%s]' %
str(e))
slist = orderCapList(list)
for i in slist:
num = i['episode']
action = chapterButton(self, i['title'], i['episode'])
action.connect('name-changed', self._action_name_changed_cb)
model.append(action)
return defer.succeed(model)
def get_playable_model(self):
"""
Return a deferred that will return an instance of
L{elisa.plugins.base.models.media.PlayableModel} for the video.
@rtype: L{elisa.core.utils.defer.Deferred}
"""
def got_playable(model):
dfr = defer.succeed(model)
return dfr
model = None
if self.playable_model:
model = self.playable_model
dfr = defer.succeed(self.playable_model)
else:
muri = self.playable_uri
pro = get_liberateca_provider()
model, dfr = \
pro.get(muri, self, self.title, self.plain_uri)
dfr.addCallback(got_playable)
dfr.addErrback(lambda failure: stderr.write("[liberateca] >:/ %s" % failure))
return dfr
def liberateca_settings_decorator(controller):
controller.append_plugin('liberateca', 'Liberateca',
'/poblesec/liberateca/settings')
return defer.succeed(None)
def get_sublabel(self, item):
return defer.succeed(','.join([str(a) for a in item.artists]))
def populate_model(self):
return defer.succeed(self.playlist_model)
def got_playable(model):
dfr = defer.succeed(model)
return dfr
def get_label(self, item):
return defer.succeed(item.title)
def liberateca_decorator(controller):
"""
Internet video decorator.
"""
controller.append_plugin('liberateca', 'Liberateca', '/poblesec/liberateca/main')
return defer.succeed(None)
def get_playable_model(self):
model = SpotifyPlayableModel()
model.uri = MediaUri("appsrc://")
model.title = self.title
return defer.succeed(model)
def get_artists(self):
return defer.succeed(self.artists)
def populate_model(self):
action = AuthenticationAction(self)
action.connect('name-changed', self._action_name_changed_cb)
model = [action,]
return defer.succeed(model)
def spotify_settings_decorator(controller):
controller.append_plugin('spotify', _('Spotify'), '/poblesec/spotify/settings')
return defer.succeed(None)
def get_poster(self):
"""
Return a deferred that will return the local path of the video poster
(not available yet)
"""
return defer.succeed(None)
def liberateca_settings_decorator(controller):
controller.append_plugin('liberateca', 'Liberateca', '/poblesec/liberateca/settings')
return defer.succeed(None)
def get_image(self, item, theme):
return defer.succeed(None)
