def canal2(item): logger.info() #url_source = "http://visionperuanatv.com/2013/03/frecuencia-latina-en-vivo.html" url_source = "http://www.fulltelevisionhd.net/2013/02/frecuencia-latina-en-vivo-por-internet.html" #item.url = server_pxstream("http://canalesenvivo.ucoz.com/Frecuencia_Latina.html") item.url = server_playerfs("http://fulltvhd.fi/peru/latina.php") platformtools.play_video(item)
def canal5_2(item): logger.info() data = httptools.downloadpage("https://panamericana.pe/tvenvivo/sd").data item.url = scrapertools.find_single_match( data, '<iframe frameborder.*?src="([^"]+)') item.server = "dailymotion" platformtools.play_video(item)
def canalfoxsport3(item): logger.info() url_source = "http://latino-webtv.com/Fox-Sports-3-en-vivo/" item.url = provider_lw( "http://embed.latino-webtv.com/channels/Fox-Sports-3.html", res=item.res) platformtools.play_video(item)
def play_from_library(item): """ Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener más items, como mucho se puede colocar un dialogo de seleccion. Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante "Container.Update()" cargamos el strm como si un item desde dentro de pelisalacarta se tratara, quitando todas las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para la biblioteca. @type item: item @param item: elemento con información """ logger.info("pelisalacarta.platformcode.launcher play_from_library") # logger.debug("item: \n" + item.tostring('\n')) import xbmcgui import xbmcplugin import xbmc # Intentamos reproducir una imagen (esto no hace nada y ademas no da error) xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "icon.png"))) # Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion xbmc.Player().stop() # modificamos el action (actualmente la biblioteca necesita "findvideos" ya que es donde se buscan las fuentes item.action = "findvideos" # y volvemos a lanzar kodi if xbmc.getCondVisibility('Window.IsMedia'): xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")") else: from channels import biblioteca from platformcode import xbmc_library p_dialog = platformtools.dialog_progress_bg('pelisalacarta', 'Cargando...') p_dialog.update(0, '') itemlist = biblioteca.findvideos(item) p_dialog.update(50, '') if len(itemlist) > 0: # El usuario elige el mirror opciones = [] for item in itemlist: opciones.append(item.title) seleccion = platformtools.dialog_select(config.get_localized_string(30163), opciones) if seleccion == -1: return item = biblioteca.play(itemlist[seleccion])[0] p_dialog.update(100, '') platformtools.play_video(item) p_dialog.close() xbmc_library.mark_auto_as_watched(itemlist[seleccion])
def play_from_library(item): """ Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener más items, como mucho se puede colocar un dialogo de seleccion. Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante "Container.Update()" cargamos el strm como si un item desde dentro de pelisalacarta se tratara, quitando todas las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para la biblioteca. @type item: item @param item: elemento con información """ logger.info("streamondemand.platformcode.launcher play_from_library") # logger.debug("item: \n" + item.tostring('\n')) import xbmcgui import xbmcplugin import xbmc # Intentamos reproducir una imagen (esto no hace nada y ademas no da error) xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "icon.png"))) # Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion xbmc.Player().stop() # modificamos el action (actualmente la biblioteca necesita "findvideos" ya que es donde se buscan las fuentes item.action = "findvideos" # y volvemos a lanzar kodi if xbmc.getCondVisibility('Window.IsMedia'): xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")") else: from channels import biblioteca from platformcode import xbmc_library p_dialog = platformtools.dialog_progress_bg('streamondemand', 'Caricamento in corso...') p_dialog.update(0, '') itemlist = biblioteca.findvideos(item) p_dialog.update(50, '') if len(itemlist) > 0: # El usuario elige el mirror opciones = [] for item in itemlist: opciones.append(item.title) seleccion = platformtools.dialog_select(config.get_localized_string(30163), opciones) if seleccion == -1: return item = biblioteca.play(itemlist[seleccion])[0] p_dialog.update(100, '') platformtools.play_video(item) p_dialog.close() xbmc_library.mark_auto_as_watched(itemlist[seleccion])
def canal4(item): logger.info() #url_source = "http://visionperuanatv.com/2013/03/frecuencia-latina-en-vivo.html" # item.url = server_playerfs("http://tvenvivo.online/americatreve.php") # if not item.url: # item.url = server_pxstream("http://tvenvivo.online/americatreve.php") url_source = "http://www.fulltelevisionhd.li/america-television-en-vivo-por-internet/" item.url = server_playerfs("http://www.fulltvhd.fi/peru/america.php") platformtools.play_video(item)
def canal9(item): logger.info() url_channel = "http://tele-on.com/atv_en_vivo.html" data = httptools.downloadpage(url_channel).data item.url = scrapertools.find_single_match(data, '<video id="player".*?src="([^"]+)"') referer = scrapertools.find_single_match(data, '<iframe f.*?src="([^"]+)"') host = scrapertoolsV2.get_domain_from_url(item.url) item.url += "|Referer=%s" %referer item.url += "&Host=%s" %host platformtools.play_video(item)
def onClick(self, control_id): setFocus(self) if control_id in [TRAILERS]: selected = self.getControl(TRAILERS).getSelectedItem() platformtools.play_video(Item(title=selected.getProperty('title'), action='play', url=selected.getProperty('url'), server='youtube')) while not xbmc.Player().isPlaying(): xbmc.sleep(100) self.close() while xbmc.Player().isPlaying(): xbmc.sleep(100) modal()
def canala9(item): logger.info() url_channel = "http://www.televisionparatodos.tv/canal-9-player/" data = httptools.downloadpage(url_channel).data item.url = scrapertools.find_single_match(data, '<iframe id=.*?src="([^"]+)') data = httptools.downloadpage(item.url).data item.url = scrapertools.find_single_match(data, "file: '([^']+)") referer = item.url host = scrapertoolsV2.get_domain_from_url(item.url) item.url += "|Referer=%s" %referer item.url += "&Host=%s" %host platformtools.play_video(item)
def canala1(item): logger.info() url_channel = "http://television-internet.com.ar/america-tv.html" data = httptools.downloadpage(url_channel).data url_stream = scrapertools.find_single_match(data, '<iframe id.*?src="([^"]+)') data = httptools.downloadpage(url_stream).data url_stream = scrapertools.find_single_match(data, '<iframe src="([^"]+)') data = httptools.downloadpage(url_stream).data encode = scrapertools.find_single_match(data, 'atob\("([^"]+)"') decode = base64.b64decode(encode) item.url = scrapertools.find_single_match(decode, 'appPlaylist":"([^"]+)"') item.url += "|Referer=%s" %url_stream platformtools.play_video(item)
def play_item(item): plugintools.log("navigation.play_item Channel code (" + item.channel + "." + item.action + ")") try: exec "import channels." + item.channel + " as channel" except: exec "import core." + item.channel + " as channel" from platformcode import platformtools plugintools.log("navigation.get_next_items play") # Si el canal tiene una acción "play" tiene prioridad if hasattr(channel, 'play'): plugintools.log( "navigation.get_next_items play Channel has its own 'play' method") itemlist = channel.play(item) if len(itemlist) > 0: item = itemlist[0] plugintools.log("item=" + repr(item)) try: platformtools.play_video(item) except: import traceback plugintools.log(traceback.format_exc()) import xbmcgui ventana_error = xbmcgui.Dialog() ok = ventana_error.ok("plugin", "No hay nada para reproducir") else: import xbmcgui ventana_error = xbmcgui.Dialog() ok = ventana_error.ok("plugin", "No hay nada para reproducir") else: plugintools.log( "navigation.get_next_items play No channel 'play' method, executing core method" ) # FIXME: Este error ha que tratarlo de otra manera, por al dar a volver sin ver el vídeo falla # Mejor hacer el play desde la ventana try: platformtools.play_video(item) except: import traceback plugintools.log(traceback.format_exc()) import xbmcgui ventana_error = xbmcgui.Dialog() ok = ventana_error.ok("plugin", "No hay nada para reproducir")
def onClick(self, control_id): setFocus(self) if control_id == COMMANDS: from platformcode.launcher import run pos = self.getControl(COMMANDS).getSelectedPosition() if self.commands[pos].action == 'save_download' and self.commands[ pos].contentType == 'tvshow': actions = [ self.commands[-1].clone(), self.commands[-1].clone(download='season') ] options = [ config.get_localized_string(60355), config.get_localized_string(60357) ] run(actions[platformtools.dialog_select( config.get_localized_string(60498), options)]) else: run(self.commands[pos]) else: action = self.getControl(RECOMANDED).getSelectedItem().getProperty( 'action') channel = self.getControl( RECOMANDED).getSelectedItem().getProperty('channel') url = self.getControl(RECOMANDED).getSelectedItem().getProperty( 'url') item = Item(channel=channel, action=action, url=url) if action == 'play': item.server = self.getControl( RECOMANDED).getSelectedItem().getProperty('server') self.close() platformtools.play_video(item) xbmc.sleep(500) while xbmc.Player().isPlaying(): xbmc.sleep(500) modal() elif config.get_setting('autoplay'): item.quality = self.getControl( RECOMANDED).getSelectedItem().getProperty('quality') getattr(self.channel, item.action)(item) self.close() xbmc.sleep(500) while xbmc.Player().isPlaying(): xbmc.sleep(500) modal() else: pos = self.getControl(RECOMANDED).getSelectedPosition() self.close() if self.itemlist[pos].mode: remove() Search(self.itemlist[pos])
def p2p(item): if "Sopcast" in item.title: texto = dialog_input(default='sop://broker.sopcast.com:3912/', heading="Introduce la url de sopcast") titulo = "[Sopcast]" else: texto = dialog_input(default='acestream://', heading="Introduce la url de acestream") titulo = "[Acestream]" if texto != "": url = texto + "|" + titulo from platformcode import platformtools item_play = item.clone() item_play.url = url item_play.server = "p2p" platformtools.play_video(item_play)
def halfplayer(item): support.log() url = item.url # Correggo il link con il lin del POST url = url.replace("/v/", "/api/source/").replace("/p/", "/api/source/") postData = urllib.urlencode({ "r": "", "d": "modolunatico.tk", }) block = httptools.downloadpage(url, post=postData).data patron = r'"file":".*?\/(r[^"]+)' matches = re.compile(patron, re.DOTALL).findall(block) for scrapedurl in matches: item.url = "https://fvs.io/" + scrapedurl item.server = "" itemlist = platformtools.play_video(item, force_direct=True, autoplay=True) return itemlist
def menu(item): logger.info() # Opciones disponibles para el menu op = ["Descargar", "Eliminar de la lista", "Reiniciar descarga", "Descargar desde...", "Reproducir"] opciones = [] # Opciones para el menu if item.downloadStatus == 0: # Sin descargar opciones.append(op[0]) # Descargar opciones.append(op[3]) # Descargar desde... opciones.append(op[1]) # Eliminar de la lista if item.downloadStatus == 1: # descarga parcial opciones.append(op[0]) # Descargar opciones.append(op[2]) # Reiniciar descarga opciones.append(op[1]) # Eliminar de la lista if item.downloadStatus == 2: # descarga completada opciones.append(op[4]) # Reproducir opciones.append(op[1]) # Eliminar de la lista opciones.append(op[2]) # Reiniciar descarga if item.downloadStatus == 3: # descarga con error opciones.append(op[2]) # Reiniciar descarga opciones.append(op[1]) # Eliminar de la lista # Mostramos el dialogo seleccion = platformtools.dialog_select("Scegliere un'opzione", opciones) # -1 es cancelar if seleccion == -1: return logger.info("opcion=%s" % (opciones[seleccion])) # Opcion Eliminar if opciones[seleccion] == op[1]: filetools.remove(item.path) # Opcion inicaiar descarga if opciones[seleccion] == op[0]: start_download(item) # Opcion inicaiar descarga desde... if opciones[seleccion] == op[3]: start_download(item, ask=True) # Reiniciar descarga if opciones[seleccion] == op[2]: if filetools.isfile(os.path.join(config.get_setting("downloadpath"), item.downloadFilename)): filetools.remove(os.path.join(config.get_setting("downloadpath"), item.downloadFilename)) update_json(item.path, {"downloadStatus": STATUS_CODES.stoped, "downloadComplete": 0, "downloadProgress": 0}) # Reproducir if opciones[seleccion] == op[4]: item.url = filetools.join(DOWNLOAD_PATH, item.downloadFilename) return platformtools.play_video(item) platformtools.itemlist_refresh()
def canaltoros2(item): logger.info() url_source = "http://latelete.tv/canal-plus-toros-en-directo-gratis-por-internet/" url_channel = "http://verdirectotv.com/tv/digitales2/plustoros.html" data = httptools.downloadpage(url_channel).data url = scrapertools.find_single_match(data, '<iframe scrolling.*?src="([^"]+)') headers = [ ["Referer", url_channel], ["host", scrapertoolsV2.get_domain_from_url(url)], ] data = httptools.downloadpage(url, headers = headers).data url = scrapertools.find_single_match(data, "source: '([^']+)") host = scrapertoolsV2.get_domain_from_url(url) item.url = url + "|Referer=%s" %url item.url += "&Host=%s" %host item.url += "&User-Agent=%s" %_useragent platformtools.play_video(item)
def canalhistory2(item): logger.info() url_source = "http://www.tutv-gratis.com" url_channel = "http://www.tv-en-vivo.org/history/" data = httptools.downloadpage(url_channel).data url = scrapertools.find_single_match(data, 'source: "([^"]+)"') host = scrapertoolsV2.get_domain_from_url(url) if item.HD == True: quality = '05' else: quality = '02' url = url.replace("index.m3u8", "Stream(%s)/index.m3u8" % quality) item.url = url + "|Referer=%s" % url item.url += "&Host=%s" % host item.url += "&User-Agent=%s" % _useragent headers = [["Referer", url], ["Host", host]] platformtools.play_video(item)
def onAction(self, action): if action.getId( ) == ACTION_SELECT_ITEM and not controlId() == OPTIONS_OK: xbmc.executebuiltin('xbmc.PlayMedia(Stop)') self.list = self.getControl(6) selecitem = self.list.getSelectedItem() url = selecitem.getProperty("url") data = scrapertools.cache_page(url) url = servertools.findvideosbyserver(data, "p2p") if url: url = url[0][1] #Creamos el item para platformtools item = Item() item.fulltitle = self.fulltitle item.url = url + "|" + item.fulltitle item.server = "p2p" self.close() check_skin = xbmc.getSkinDir() if not "confluence" in check_skin: xbmc.sleep(300) xbmc.executebuiltin('Action(PreviousMenu)') xbmc.sleep(300) platformtools.play_video(item) self.close() check_skin = xbmc.getSkinDir() if "confluence" in check_skin: if xbmc.Player().isPlayingVideo(): #xbmc.sleep(300) xbmc.executebuiltin('Action(PreviousMenu)') else: xbmc.executebuiltin('Action(PreviousMenu)') else: xbmc.executebuiltin('Action(PreviousMenu)') elif action.getId() == ACTION_PREVIOUS_MENU or action.getId( ) == ACTION_MOUSE_RIGHT_CLICK or action == 92: self.close() xbmc.sleep(300) xbmc.executebuiltin('Action(PreviousMenu)')
def onClick(self, controlId): if controlId == OPTION_PANEL: xbmc.executebuiltin('xbmc.PlayMedia(Stop)') self.list = self.getControl(6) selecitem = self.list.getSelectedItem() url = selecitem.getProperty("url") data = scrapertools.cache_page(url) url = servertools.findvideosbyserver(data, "p2p") if url: url = url[0][1] #Creamos el item para platformtools item = Item() item.fulltitle = self.fulltitle item.url = url + "|" + item.fulltitle item.server = "p2p" self.close() check_skin = xbmc.getSkinDir() if not "confluence" in check_skin: xbmc.sleep(300) xbmc.executebuiltin('Action(PreviousMenu)') xbmc.sleep(300) platformtools.play_video(item) check_skin = xbmc.getSkinDir() if "confluence" in check_skin: if xbmc.Player().isPlayingVideo(): #xbmc.sleep(300) xbmc.executebuiltin('Action(PreviousMenu)') else: xbmc.executebuiltin('Action(PreviousMenu)') else: xbmc.executebuiltin('Action(PreviousMenu)') elif controlId == OPTIONS_OK: self.close() TESTPYDESTFILE = xbmc.translatePath( 'special://skin/720p/DialogSelect2.xml') xbmc.sleep(300) xbmc.executebuiltin('Action(PreviousMenu)')
def play(item): channel = importChannel(item) # define info for trakt try: from core import trakt_tools trakt_tools.set_trakt_info(item) except: pass logger.debug('item.action=', item.action.upper()) # First checks if channel has a "play" function if hasattr(channel, 'play'): logger.debug('Executing channel "play" method') itemlist = channel.play(item) # Play should return a list of playable URLS if len(itemlist) > 0 and isinstance(itemlist[0], Item): item = itemlist[0] platformtools.play_video(item) # Allow several qualities from Play in El Channel elif len(itemlist) > 0 and isinstance(itemlist[0], list): item.video_urls = itemlist platformtools.play_video(item) # If not, shows user an error message else: platformtools.dialog_ok(config.get_localized_string(20000), config.get_localized_string(60339)) # If player don't have a "play" function, not uses the standard play from platformtools else: logger.debug('Executing core "play" method') platformtools.play_video(item)
def onAction(self, action): global window_select, result if action == 92 or action == 110: self.result = "no_video" result = "no_video" self.close() window_select.pop() if not window_select: if not self.item.windowed: del window_select else: window_select[-1].doModal() try: if (action == 7 or action == 100) and self.getFocusId() == 6: selectitem = self.control_list.getSelectedItem() item = Item().fromurl(selectitem.getProperty("item_copy")) if item.action == "play" and self.item.windowed: video_urls, puede, motivo = servertools.resolve_video_urls_for_playing( item.server, item.url) self.close() xbmc.sleep(200) if puede: result = video_urls[-1][1] self.result = video_urls[-1][1] else: result = None self.result = None elif item.action == "play" and not self.item.windowed: for window in window_select: window.close() retorna = platformtools.play_video(item, force_direct=True) if not retorna: while True: xbmc.sleep(1000) if not xbmc.Player().isPlaying(): break window_select[-1].doModal() else: self.close() buscartrailer(item) except: import traceback logger.error(traceback.format_exc())
def onAction(self,action): global window_select, result if action == 92 or action == 110: self.result = "no_video" result = "no_video" self.close() window_select.pop() if not window_select: if not self.item.windowed: del window_select else: window_select[-1].doModal() try: if (action == 7 or action == 100) and self.getFocusId() == 6: selectitem = self.control_list.getSelectedItem() item = Item().fromurl(selectitem.getProperty("item_copy")) if item.action == "play" and self.item.windowed: video_urls, puede, motivo = servertools.resolve_video_urls_for_playing(item.server, item.url) self.close() xbmc.sleep(200) if puede: result = video_urls[-1][1] self.result = video_urls[-1][1] else: result = None self.result = None elif item.action == "play" and not self.item.windowed: for window in window_select: window.close() retorna = platformtools.play_video(item) if not retorna: while True: xbmc.sleep(1000) if not xbmc.Player().isPlaying(): break window_select[-1].doModal() else: self.close() buscartrailer(item) except: import traceback logger.info(traceback.format_exc())
def play_from_library(item): """ Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener más items, como mucho se puede colocar un dialogo de seleccion. Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante "Container.Update()" cargamos el strm como si un item desde dentro del addon se tratara, quitando todas las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para la videoteca. @type item: item @param item: elemento con información """ logger.info() # logger.debug("item: \n" + item.tostring('\n')) import xbmcgui import xbmcplugin import xbmc # Intentamos reproducir una imagen (esto no hace nada y ademas no da error) xbmcplugin.setResolvedUrl( int(sys.argv[1]), True, xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "resources", "subtitle.mp4"))) # Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion xbmc.Player().stop() # modificamos el action (actualmente la videoteca necesita "findvideos" ya que es donde se buscan las fuentes item.action = "findvideos" window_type = config.get_setting("window_type", "videolibrary") # y volvemos a lanzar kodi if xbmc.getCondVisibility('Window.IsMedia') and not window_type == 1: # Ventana convencional xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")") else: # Ventana emergente from channels import videolibrary p_dialog = platformtools.dialog_progress_bg('alfa', 'Cargando...') p_dialog.update(0, '') itemlist = videolibrary.findvideos(item) while platformtools.is_playing(): # Ventana convencional from time import sleep sleep(5) p_dialog.update(50, '') '''# Se filtran los enlaces segun la lista negra if config.get_setting('filter_servers', "servers"): itemlist = servertools.filter_servers(itemlist)''' # Se limita la cantidad de enlaces a mostrar if config.get_setting("max_links", "videolibrary") != 0: itemlist = limit_itemlist(itemlist) # Se "limpia" ligeramente la lista de enlaces if config.get_setting("replace_VD", "videolibrary") == 1: itemlist = reorder_itemlist(itemlist) p_dialog.update(100, '') xbmc.sleep(500) p_dialog.close() if len(itemlist) > 0: # El usuario elige el mirror opciones = [] for item in itemlist: opciones.append(item.title) # Se abre la ventana de seleccion if (item.contentSerieName != "" and item.contentSeason != "" and item.contentEpisodeNumber != ""): cabecera = ("%s - %sx%s -- %s" % (item.contentSerieName, item.contentSeason, item.contentEpisodeNumber, config.get_localized_string(30163))) else: cabecera = config.get_localized_string(30163) seleccion = platformtools.dialog_select(cabecera, opciones) if seleccion == -1: return else: item = videolibrary.play(itemlist[seleccion])[0] platformtools.play_video(item)
def run(item=None): logger.info() if not item: # Extract item from sys.argv if sys.argv[2]: item = Item().fromurl(sys.argv[2]) # If no item, this is mainlist else: if config.get_setting("start_page"): if not config.get_setting("custom_start"): category = config.get_setting("category").lower() item = Item(channel="news", action="novedades", extra=category, mode='silent') else: from channels import side_menu item = Item() item = side_menu.check_user_home(item) item.start = True else: item = Item(channel="channelselector", action="getmainlist", viewmode="movie") if not config.get_setting('show_once'): from platformcode import xbmc_videolibrary xbmc_videolibrary.ask_set_content(1) config.set_setting('show_once', True) logger.info(item.tostring()) try: # If item has no action, stops here if item.action == "": logger.info("Item sin accion") return # Action for main menu in channelselector elif item.action == "getmainlist": import channelselector itemlist = channelselector.getmainlist() platformtools.render_items(itemlist, item) # Action for channel types on channelselector: movies, series, etc. elif item.action == "getchanneltypes": import channelselector itemlist = channelselector.getchanneltypes() platformtools.render_items(itemlist, item) # Action for channel listing on channelselector elif item.action == "filterchannels": import channelselector itemlist = channelselector.filterchannels(item.channel_type) platformtools.render_items(itemlist, item) # Special action for playing a video from the library elif item.action == "play_from_library": play_from_library(item) return elif item.action == "keymap": from platformcode import keymaptools if item.open: return keymaptools.open_shortcut_menu() else: return keymaptools.set_key() elif item.action == "script": from core import tmdb if tmdb.drop_bd(): platformtools.dialog_notification("Alfa", "caché eliminada", time=2000, sound=False) # Action in certain channel specified in "action" and "channel" parameters else: # Entry point for a channel is the "mainlist" action, so here we check parental control if item.action == "mainlist": # Parental control # If it is an adult channel, and user has configured pin, asks for it if channeltools.is_adult(item.channel) and config.get_setting( "adult_request_password"): tecleado = platformtools.dialog_input( "", "Contraseña para canales de adultos", True) if tecleado is None or tecleado != config.get_setting( "adult_password"): return # # Actualiza el canal individual # if (item.action == "mainlist" and item.channel != "channelselector" and # config.get_setting("check_for_channel_updates") == True): # from core import updater # updater.update_channel(item.channel) # Checks if channel exists channel_file = os.path.join(config.get_runtime_path(), 'channels', item.channel + ".py") logger.info("channel_file=%s" % channel_file) channel = None if os.path.exists(channel_file): try: channel = __import__('channels.%s' % item.channel, None, None, ["channels.%s" % item.channel]) except ImportError: exec "import channels." + item.channel + " as channel" logger.info("Running channel %s | %s" % (channel.__name__, channel.__file__)) # Special play action if item.action == "play": #define la info para trakt try: trakt_tools.set_trakt_info(item) except: pass logger.info("item.action=%s" % item.action.upper()) # logger.debug("item_toPlay: " + "\n" + item.tostring('\n')) # First checks if channel has a "play" function if hasattr(channel, 'play'): logger.info("Executing channel 'play' method") itemlist = channel.play(item) b_favourite = item.isFavourite # Play should return a list of playable URLS if len(itemlist) > 0 and isinstance(itemlist[0], Item): item = itemlist[0] if b_favourite: item.isFavourite = True platformtools.play_video(item) # Permitir varias calidades desde play en el canal elif len(itemlist) > 0 and isinstance(itemlist[0], list): item.video_urls = itemlist platformtools.play_video(item) # If not, shows user an error message else: platformtools.dialog_ok("alfa", "No hay nada para reproducir") # If player don't have a "play" function, not uses the standard play from platformtools else: logger.info("Executing core 'play' method") platformtools.play_video(item) # Special action for findvideos, where the plugin looks for known urls elif item.action == "findvideos": # First checks if channel has a "findvideos" function if hasattr(channel, 'findvideos'): itemlist = getattr(channel, item.action)(item) itemlist = servertools.filter_servers(itemlist) # If not, uses the generic findvideos function else: logger.info("No channel 'findvideos' method, " "executing core method") itemlist = servertools.find_video_items(item) if config.get_setting("max_links", "videolibrary") != 0: itemlist = limit_itemlist(itemlist) from platformcode import subtitletools subtitletools.saveSubtitleName(item) platformtools.render_items(itemlist, item) # Special action for adding a movie to the library elif item.action == "add_pelicula_to_library": videolibrarytools.add_movie(item) # Special action for adding a serie to the library elif item.action == "add_serie_to_library": videolibrarytools.add_tvshow(item, channel) # Special action for downloading all episodes from a serie elif item.action == "download_all_episodes": from channels import downloads item.action = item.extra del item.extra downloads.save_download(item) # Special action for searching, first asks for the words then call the "search" function elif item.action == "search": logger.info("item.action=%s" % item.action.upper()) last_search = "" last_search_active = config.get_setting( "last_search", "search") if last_search_active: try: current_saved_searches_list = list( config.get_setting("saved_searches_list", "search")) last_search = current_saved_searches_list[0] except: pass tecleado = platformtools.dialog_input(last_search) if tecleado is not None: if last_search_active and not tecleado.startswith("http"): from channels import search search.save_search(tecleado) itemlist = channel.search(item, tecleado) else: return platformtools.render_items(itemlist, item) # For all other actions else: logger.info("Executing channel '%s' method" % item.action) itemlist = getattr(channel, item.action)(item) if config.get_setting('trakt_sync'): token_auth = config.get_setting("token_trakt", "trakt") if not token_auth: trakt_tools.auth_trakt() else: import xbmc if not xbmc.getCondVisibility( 'System.HasAddon(script.trakt)' ) and config.get_setting('install_trakt'): trakt_tools.ask_install_script() itemlist = trakt_tools.trakt_check(itemlist) else: config.set_setting('install_trakt', True) platformtools.render_items(itemlist, item) except urllib2.URLError, e: import traceback logger.error(traceback.format_exc()) # Grab inner and third party errors if hasattr(e, 'reason'): logger.error("Razon del error, codigo: %s | Razon: %s" % (str(e.reason[0]), str(e.reason[1]))) texto = config.get_localized_string( 30050) # "No se puede conectar con el sitio web" platformtools.dialog_ok("alfa", texto) # Grab server response errors elif hasattr(e, 'code'): logger.error("Codigo de error HTTP : %d" % e.code) # "El sitio web no funciona correctamente (error http %d)" platformtools.dialog_ok( "alfa", config.get_localized_string(30051) % e.code)
def start(itemlist, item): ''' Metodo principal desde donde se reproduce automaticamente los enlaces - En caso la opcion de personalizar activa utilizara las opciones definidas por el usuario. - En caso contrario intentara reproducir cualquier enlace que cuente con el idioma preferido. :param itemlist: list (lista de items listos para reproducir, o sea con action='play') :param item: item (el item principal del canal) :return: intenta autoreproducir, en caso de fallar devuelve el itemlist que recibio en un principio ''' logger.info() global autoplay_node if not config.is_xbmc(): platformtools.dialog_notification('AutoPlay ERROR', 'Sólo disponible para XBMC/Kodi') return itemlist else: if not autoplay_node: # Obtiene el nodo AUTOPLAY desde el json autoplay_node = jsontools.get_node_from_data_json( 'autoplay', 'AUTOPLAY') # Agrega servidores y calidades que no estaban listados a autoplay_node new_options = check_value(item.channel, itemlist) # Obtiene el nodo del canal desde autoplay_node channel_node = autoplay_node.get(item.channel, {}) # Obtiene los ajustes des autoplay para este canal settings_node = channel_node.get('settings', {}) if settings_node['active']: url_list_valid = [] autoplay_list = [] favorite_servers = [] favorite_quality = [] # Guarda el valor actual de "Accion al seleccionar vídeo:" en preferencias user_config_setting = config.get_setting("default_action") # Habilita la accion "Ver en calidad alta" (si el servidor devuelve más de una calidad p.e. gdrive) if user_config_setting != 2: config.set_setting("default_action", 2) # Informa que AutoPlay esta activo platformtools.dialog_notification('AutoPlay Activo', '', sound=False) # Prioridades a la hora de ordenar itemlist: # 0: Servidores y calidades # 1: Calidades y servidores # 2: Solo servidores # 3: Solo calidades # 4: No ordenar if settings_node['custom_servers'] and settings_node[ 'custom_quality']: priority = settings_node[ 'priority'] # 0: Servidores y calidades o 1: Calidades y servidores elif settings_node['custom_servers']: priority = 2 # Solo servidores elif settings_node['custom_quality']: priority = 3 # Solo calidades else: priority = 4 # No ordenar # Obtiene las listas servidores, calidades disponibles desde el nodo del json de AutoPlay server_list = channel_node.get('servers', []) quality_list = channel_node.get('quality', []) # Se guardan los textos de cada servidor y calidad en listas p.e. favorite_servers = ['openload', # 'streamcloud'] for num in range(1, 4): favorite_servers.append( channel_node['servers'][settings_node['server_%s' % num]]) favorite_quality.append( channel_node['quality'][settings_node['quality_%s' % num]]) # Se filtran los enlaces de itemlist y que se correspondan con los valores de autoplay for item in itemlist: autoplay_elem = dict() # Comprobamos q se trata de un item de video if 'server' not in item: continue # Agrega la opcion configurar AutoPlay al menu contextual if 'context' not in item: item.context = list() if not filter(lambda x: x['action'] == 'autoplay_config', context): item.context.append({ "title": "Configurar AutoPlay", "action": "autoplay_config", "channel": "autoplay", "from_channel": item.channel }) # Si no tiene calidad definida le asigna calidad 'default' if item.quality == '': item.quality = 'default' # Se crea la lista para configuracion personalizada if priority < 2: # 0: Servidores y calidades o 1: Calidades y servidores # si el servidor y la calidad no se encuentran en las listas de favoritos o la url esta repetida, # descartamos el item if item.server not in favorite_servers or item.quality not in favorite_quality \ or item.url in url_list_valid: continue autoplay_elem["indice_server"] = favorite_servers.index( item.server) autoplay_elem["indice_quality"] = favorite_quality.index( item.quality) elif priority == 2: # Solo servidores # si el servidor no se encuentra en la lista de favoritos o la url esta repetida, # descartamos el item if item.server not in favorite_servers or item.url in url_list_valid: continue autoplay_elem["indice_server"] = favorite_servers.index( item.server) elif priority == 3: # Solo calidades # si la calidad no se encuentra en la lista de favoritos o la url esta repetida, # descartamos el item if item.quality not in favorite_quality or item.url in url_list_valid: continue autoplay_elem["indice_quality"] = favorite_quality.index( item.quality) else: # No ordenar # si la url esta repetida, descartamos el item if item.url in url_list_valid: continue # Si el item llega hasta aqui lo añadimos al listado de urls validas y a autoplay_list url_list_valid.append(item.url) autoplay_elem['videoitem'] = item #autoplay_elem['server'] = item.server #autoplay_elem['quality'] = item.quality autoplay_list.append(autoplay_elem) # Ordenamos segun la prioridad if priority == 0: # Servidores y calidades autoplay_list.sort(key=lambda orden: (orden['indice_server'], orden['indice_quality'])) elif priority == 1: # Calidades y servidores autoplay_list.sort(key=lambda orden: (orden['indice_quality'], orden['indice_server'])) elif priority == 2: # Solo servidores autoplay_list.sort(key=lambda orden: orden['indice_server']) elif priority == 3: # Solo calidades autoplay_list.sort(key=lambda orden: orden['indice_quality']) # Si hay elementos en la lista de autoplay se intenta reproducir cada elemento, hasta encontrar uno # funcional o fallen todos if autoplay_list: played = False max_intentos = 5 max_intentos_servers = {} # Si se esta reproduciendo algo detiene la reproduccion if platformtools.is_playing(): platformtools.stop_video() for autoplay_elem in autoplay_list: if not platformtools.is_playing() and not played: videoitem = autoplay_elem['videoitem'] if videoitem.server not in max_intentos_servers: max_intentos_servers[ videoitem.server] = max_intentos # Si se han alcanzado el numero maximo de intentos de este servidor saltamos al siguiente if max_intentos_servers[videoitem.server] == 0: continue lang = " " if hasattr(videoitem, 'language') and videoitem.language != "": lang = " '%s' " % videoitem.language platformtools.dialog_notification( "AutoPlay", "%s%s%s" % (videoitem.server.upper(), lang, videoitem.quality.upper()), sound=False) #TODO videoitem.server es el id del server, pero podria no ser el nombre!!! # Intenta reproducir los enlaces # Si el canal tiene metodo play propio lo utiliza channel = __import__('channels.%s' % item.channel, None, None, ["channels.%s" % item.channel]) if hasattr(channel, 'play'): resolved_item = getattr(channel, 'play')(videoitem) if len(resolved_item) > 0: if isinstance(resolved_item[0], list): videoitem.video_urls = resolved_item else: videoitem = resolved_item[0] # si no directamente reproduce platformtools.play_video(videoitem) try: if platformtools.is_playing(): played = True break except: # TODO evitar el informe de que el conector fallo o el video no se encuentra logger.debug(str(len(autoplay_list))) # Si hemos llegado hasta aqui es por q no se ha podido reproducir max_intentos_servers[videoitem.server] -= 1 # Si se han alcanzado el numero maximo de intentos de este servidor # preguntar si queremos seguir probando o lo ignoramos if max_intentos_servers[videoitem.server] == 0: text = "Parece que los enlaces de %s no estan funcionando." % videoitem.server.upper( ) if not platformtools.dialog_yesno( "AutoPlay", text, "¿Desea ignorar todos los enlaces de este servidor?" ): max_intentos_servers[ videoitem.server] = max_intentos else: platformtools.dialog_notification('AutoPlay No Fue Posible', 'No Hubo Coincidencias') if new_options: platformtools.dialog_notification( "AutoPlay", "Nueva Calidad/Servidor disponible en la " "configuracion", sound=False) # Restaura si es necesario el valor previo de "Accion al seleccionar vídeo:" en preferencias if user_config_setting != 2: config.set_setting("default_action", user_config_setting) # devuelve la lista de enlaces para la eleccion manual return itemlist
def findvideos(item): logger.info() # logger.debug("item:\n" + item.tostring('\n')) itemlist = [] list_canales = {} item_local = None if not item.contentTitle or not item.strm_path: logger.debug("No se pueden buscar videos por falta de parametros") return [] content_title = filter(lambda c: c not in ":*?<>|\/", item.contentTitle).strip().lower() if item.contentType == 'movie': item.strm_path = filetools.join(library.MOVIES_PATH, item.strm_path.strip('\/')) path_dir = os.path.dirname(item.strm_path) item.nfo = filetools.join(path_dir, os.path.basename(path_dir) + ".nfo") else: item.strm_path = filetools.join(library.TVSHOWS_PATH, item.strm_path.strip('\/')) path_dir = os.path.dirname(item.strm_path) item.nfo = filetools.join(path_dir, 'tvshow.nfo') for fd in filetools.listdir(path_dir): if fd.endswith('.json'): contenido, nom_canal = fd[:-6].split('[') if (content_title in contenido.strip() or item.contentType == 'movie') and nom_canal not in \ list_canales.keys(): list_canales[nom_canal] = filetools.join(path_dir, fd) num_canales = len(list_canales) if 'descargas' in list_canales: json_path = list_canales['descargas'] item_json = Item().fromjson(filetools.read(json_path)) del list_canales['descargas'] # Comprobar q el video no haya sido borrado if filetools.exists(item_json.url): item_local = item_json.clone(action='play') itemlist.append(item_local) else: num_canales -= 1 filtro_canal = '' if num_canales > 1 and config.get_setting("ask_channel", "biblioteca") == True: opciones = ["Mostrar solo los enlaces de %s" % k.capitalize() for k in list_canales.keys()] opciones.insert(0, "Mostrar todos los enlaces") if item_local: opciones.append(item_local.title) from platformcode import platformtools index = platformtools.dialog_select(config.get_localized_string(30163), opciones) if index < 0: return [] elif item_local and index == len(opciones) - 1: filtro_canal = 'descargas' platformtools.play_video(item_local) elif index > 0: filtro_canal = opciones[index].replace("Mostrar solo los enlaces de ", "") itemlist = [] for nom_canal, json_path in list_canales.items(): if filtro_canal and filtro_canal != nom_canal.capitalize(): continue # Importamos el canal de la parte seleccionada try: channel = __import__('channels.%s' % nom_canal, fromlist=["channels.%s" % nom_canal]) except ImportError: exec "import channels." + nom_canal + " as channel" item_json = Item().fromjson(filetools.read(json_path)) list_servers = [] try: # FILTERTOOLS # si el canal tiene filtro se le pasa el nombre que tiene guardado para que filtre correctamente. if "list_idiomas" in item_json: # si se viene desde la biblioteca de pelisalacarta if "library_filter_show" in item: item_json.show = item.library_filter_show.get(nom_canal, "") # Ejecutamos find_videos, del canal o común if hasattr(channel, 'findvideos'): list_servers = getattr(channel, 'findvideos')(item_json) else: from core import servertools list_servers = servertools.find_video_items(item_json) except Exception as ex: logger.error("Ha fallado la funcion findvideos para el canal %s" % nom_canal) template = "An exception of type {0} occured. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) logger.error(message) # Cambiarle el titulo a los servers añadiendoles el nombre del canal delante y # las infoLabels y las imagenes del item si el server no tiene for server in list_servers: if not server.action: # Ignorar las etiquetas continue server.contentChannel = server.channel server.channel = "biblioteca" server.nfo = item.nfo server.strm_path = item.strm_path server.title = "%s: %s" % (nom_canal.capitalize(), server.title) server.infoLabels = item_json.infoLabels if not server.thumbnail: server.thumbnail = item.thumbnail # logger.debug("server:\n%s" % server.tostring('\n')) itemlist.append(server) # return sorted(itemlist, key=lambda it: it.title.lower()) return itemlist
def play_video(item): platformtools.play_video(item)
def start(itemlist, item): ''' Main method from which the links are automatically reproduced - In case the option to activate it will use the options defined by the user. - Otherwise it will try to reproduce any link that has the preferred language. :param itemlist: list (list of items ready to play, ie with action = 'play') :param item: item (the main item of the channel) :return: try to auto-reproduce, in case of failure it returns the itemlist that it received in the beginning ''' if item.global_search: return itemlist logger.debug() global PLAYED PLAYED = False base_item = item if not config.is_xbmc(): return itemlist if config.get_setting('autoplay'): url_list_valid = [] autoplay_list = [] autoplay_b = [] favorite_quality = [] favorite_servers = [] blacklisted_servers = config.get_setting("black_list", server='servers') if not blacklisted_servers: blacklisted_servers = [] from core import servertools servers_list = list(servertools.get_servers_list().items()) for server, server_parameters in servers_list: if config.get_setting('favorites_servers_list', server=server): favorite_servers.append(server.lower()) if not favorite_servers: config.set_setting('favorites_servers_list', [], server='servers') favorite_servers = [] else: favorite_servers = list( set(favorite_servers) - set(blacklisted_servers)) # Save the current value of "Action and Player Mode" in preferences user_config_setting_action = config.get_setting("default_action") # user_config_setting_player = config.get_setting("player_mode") # Enable the "View in high quality" action (if the server returns more than one quality, eg gdrive) if not user_config_setting_action: config.set_setting("default_action", 2) # if user_config_setting_player != 0: config.set_setting("player_mode", 0) # Priorities when ordering itemlist: # 0: Servers and qualities # 1: Qualities and servers # 2: Servers only # 3: Only qualities # 4: Do not order if config.get_setting('favorites_servers' ) and favorite_servers and config.get_setting( 'default_action'): priority = 0 # 0: Servers and qualities or 1: Qualities and servers elif config.get_setting('favorites_servers') and favorite_servers: priority = 2 # Servers only elif config.get_setting('default_action'): priority = 3 # Only qualities else: priority = 4 # Do not order if config.get_setting('default_action') == 1: quality_list.reverse() favorite_quality = quality_list for item in itemlist: autoplay_elem = dict() b_dict = dict() # We check that it is a video item if 'server' not in item: continue if item.server.lower() in blacklisted_servers: continue # If it does not have a defined quality, it assigns a 'default' quality. if item.quality.lower() not in quality_list: item.quality = 'default' # The list for custom settings is created if priority < 2: # 0: Servers and qualities or 1: Qualities and servers # if the server and the quality are not in the favorites lists or the url is repeated, we discard the item if item.server.lower( ) not in favorite_servers or item.quality.lower( ) not in favorite_quality or item.url in url_list_valid: item.type_b = True item.play_from = base_item.play_from b_dict['videoitem'] = item autoplay_b.append(b_dict) continue autoplay_elem["indice_server"] = favorite_servers.index( item.server.lower()) autoplay_elem["indice_quality"] = favorite_quality.index( item.quality.lower()) elif priority == 2: # Servers only # if the server is not in the favorites list or the url is repeated, we discard the item if item.server.lower( ) not in favorite_servers or item.url in url_list_valid: item.type_b = True item.play_from = base_item.play_from b_dict['videoitem'] = item autoplay_b.append(b_dict) continue autoplay_elem["indice_server"] = favorite_servers.index( item.server.lower()) elif priority == 3: # Only qualities # if the quality is not in the favorites list or the url is repeated, we discard the item if item.quality.lower( ) not in favorite_quality or item.url in url_list_valid: item.type_b = True item.play_from = base_item.play_from b_dict['videoitem'] = item autoplay_b.append(b_dict) continue autoplay_elem["indice_quality"] = favorite_quality.index( item.quality.lower()) else: # Do not order # if the url is repeated, we discard the item item.play_from = base_item.play_from if item.url in url_list_valid: continue # If the item reaches here we add it to the list of valid urls and to autoplay_list url_list_valid.append(item.url) item.plan_b = True item.play_from = base_item.play_from autoplay_elem['videoitem'] = item autoplay_list.append(autoplay_elem) # We order according to priority if priority == 0: autoplay_list.sort(key=lambda orden: ( (orden['indice_server'], orden['indice_quality'])) ) # Servers and qualities elif priority == 1: autoplay_list.sort(key=lambda orden: (orden['indice_quality'], orden['indice_server'] )) # Qualities and servers elif priority == 2: autoplay_list.sort(key=lambda orden: (orden['indice_server'])) # Servers only elif priority == 3: autoplay_list.sort(key=lambda orden: (orden['indice_quality'])) # Only qualities logger.debug('PRIORITY', priority, autoplay_list) # if quality priority is active if priority == 0 and config.get_setting('quality_priority'): max_quality = autoplay_list[0][ "indice_quality"] if autoplay_list and "indice_quality" in autoplay_list[ 0] else 0 for n, item in enumerate(itemlist): if 'server' not in item: continue if item.server.lower() in blacklisted_servers: continue # If it does not have a defined quality, it assigns a 'default' quality. if item.quality == '': item.quality = 'default' if favorite_quality.index(item.quality.lower()) < max_quality: item.type_b = False autoplay_elem["indice_server"] = n autoplay_elem["indice_quality"] = favorite_quality.index( item.quality.lower()) autoplay_elem['videoitem'] = item autoplay_list.append(autoplay_elem) autoplay_list.sort(key=lambda orden: (orden['indice_quality'], orden['indice_server'])) # Plan b is prepared, in case it is active the non-favorite elements are added at the end # try: plan_b = settings_node['plan_b'] # except: plan_b = True text_b = '' if plan_b: autoplay_list.extend(autoplay_b) # If there are elements in the autoplay list, an attempt is made to reproduce each element, until one is found or all fail. if autoplay_list or (plan_b and autoplay_b): max_intentos = 5 max_intentos_servers = {} # If something is playing it stops playing if platformtools.is_playing(): platformtools.stop_video() for autoplay_elem in autoplay_list: play_item = Item channel_id = autoplay_elem['videoitem'].channel if autoplay_elem['videoitem'].channel == 'videolibrary': channel_id = autoplay_elem['videoitem'].contentChannel # If it is not a favorite element if you add the text plan b if autoplay_elem['videoitem'].type_b: text_b = '(Plan B)' if not platformtools.is_playing() and not PLAYED: videoitem = autoplay_elem['videoitem'] if videoitem.server.lower() not in max_intentos_servers: max_intentos_servers[ videoitem.server.lower()] = max_intentos # If the maximum number of attempts of this server have been reached, we jump to the next if max_intentos_servers[videoitem.server.lower()] == 0: continue lang = " " if hasattr(videoitem, 'language') and videoitem.language != "": lang = " '%s' " % videoitem.language name = servername(videoitem.server) platformtools.dialog_notification( "AutoPlay %s" % text_b, "%s%s%s" % (name, lang, videoitem.quality.upper()), sound=False) # Try to play the links If the channel has its own play method, use it try: channel = __import__('channels.%s' % channel_id, None, None, ["channels.%s" % channel_id]) except: channel = __import__('specials.%s' % channel_id, None, None, ["specials.%s" % channel_id]) if hasattr(channel, 'play'): resolved_item = getattr(channel, 'play')(videoitem) if len(resolved_item) > 0: if isinstance(resolved_item[0], list): videoitem.video_urls = resolved_item else: videoitem = resolved_item[0] play_item.autoplay = True # If not directly reproduce and mark as seen # Check if the item comes from the video library try: if base_item.contentChannel == 'videolibrary' or base_item.nfo: # Fill the video with the data of the main item and play play_item = base_item.clone(**videoitem.__dict__) platformtools.play_video(play_item, autoplay=True) else: # If it doesn't come from the video library, just play platformtools.play_video(videoitem, autoplay=True) except: pass sleep(3) try: if platformtools.is_playing(): PLAYED = True break except: logger.debug(str(len(autoplay_list))) # If we have come this far, it is because it could not be reproduced max_intentos_servers[videoitem.server.lower()] -= 1 # If the maximum number of attempts of this server has been reached, ask if we want to continue testing or ignore it. if max_intentos_servers[videoitem.server.lower()] == 0: text = config.get_localized_string(60072) % name if not platformtools.dialog_yesno( "AutoPlay", text, config.get_localized_string(60073)): max_intentos_servers[ videoitem.server.lower()] = max_intentos # If there are no items in the list, it is reported if autoplay_elem == autoplay_list[-1]: platformtools.dialog_notification( 'AutoPlay', config.get_localized_string(60072) % name) else: platformtools.dialog_notification( config.get_localized_string(60074), config.get_localized_string(60075)) # Restore if necessary the previous value of "Action and Player Mode" in preferences if not user_config_setting_action: config.set_setting("default_action", user_config_setting_action) # if user_config_setting_player != 0: config.set_setting("player_mode", user_config_setting_player) return itemlist
def get_next_items( item ): plugintools.log("navigation.get_next_items item="+item.tostring()) try: # ---------------------------------------------------------------- # Main menu # ---------------------------------------------------------------- if item.channel=="navigation": if item.action=="mainlist": plugintools.log("navigation.get_next_items Main menu") itemlist = channelselector.getmainlist("bannermenu") elif item.channel=="channelselector": if item.action=="channeltypes": plugintools.log("navigation.get_next_items Channel types menu") itemlist = channelselector.getchanneltypes("bannermenu") elif item.action=="listchannels": plugintools.log("navigation.get_next_items Channel list menu") itemlist = channelselector.filterchannels(item.category,"bannermenu") else: if item.action=="": item.action="mainlist" plugintools.log("navigation.get_next_items Channel code ("+item.channel+"."+item.action+")") try: exec "import channels."+item.channel+" as channel" except: exec "import core."+item.channel+" as channel" from platformcode import platformtools if item.action=="play": plugintools.log("navigation.get_next_items play") # Si el canal tiene una acción "play" tiene prioridad if hasattr(channel, 'play'): plugintools.log("navigation.get_next_items play Channel has its own 'play' method") itemlist = channel.play(item) if len(itemlist)>0: item = itemlist[0] # FIXME: Este error ha que tratarlo de otra manera, al dar a volver sin ver el vídeo falla try: platformtools.play_video(item) except: pass else: import xbmcgui ventana_error = xbmcgui.Dialog() ok = ventana_error.ok ("plugin", "No hay nada para reproducir") else: plugintools.log("navigation.get_next_items play No channel 'play' method, executing core method") # FIXME: Este error ha que tratarlo de otra manera, por al dar a volver sin ver el vídeo falla # Mejor hacer el play desde la ventana try: platformtools.play_video(item) except: import traceback plugintools.log(traceback.format_exc()) pass return [] elif item.action=="findvideos": plugintools.log("navigation.get_next_items findvideos") # Si el canal tiene una acción "findvideos" tiene prioridad if hasattr(channel, 'findvideos'): plugintools.log("navigation.get_next_items play Channel has its own 'findvideos' method") itemlist = channel.findvideos(item) else: itemlist = [] if len(itemlist)==0: from core import servertools itemlist = servertools.find_video_items(item) if len(itemlist)==0: itemlist = [ Item(title="No se han encontrado vídeos", thumbnail="http://media.tvalacarta.info/pelisalacarta/thumb_error.png") ] else: if item.action=="search": tecleado = plugintools.keyboard_input() if tecleado!="": tecleado = tecleado.replace(" ", "+") itemlist = channel.search(item,tecleado) elif item.channel=="novedades" and item.action=="mainlist": itemlist = channel.mainlist(item,"bannermenu") elif item.channel=="buscador" and item.action=="mainlist": itemlist = channel.mainlist(item,"bannermenu") else: exec "itemlist = channel."+item.action+"(item)" for loaded_item in itemlist: if loaded_item.thumbnail=="": if loaded_item.folder: loaded_item.thumbnail = "http://media.tvalacarta.info/pelisalacarta/thumb_folder.png" else: loaded_item.thumbnail = "http://media.tvalacarta.info/pelisalacarta/thumb_nofolder.png" if len(itemlist)==0: itemlist = [ Item(title="No hay elementos para mostrar", thumbnail="http://media.tvalacarta.info/pelisalacarta/thumb_error.png" ) ] except: import traceback plugintools.log("navigation.get_next_items "+traceback.format_exc()) itemlist = [ Item(title="Se ha producido un error", thumbnail="http://media.tvalacarta.info/pelisalacarta/thumb_error.png") ] return itemlist
def play_from_library(item): """ Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener más items, como mucho se puede colocar un dialogo de seleccion. Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante "Container.Update()" cargamos el strm como si un item desde dentro de pelisalacarta se tratara, quitando todas las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para la biblioteca. @type item: item @param item: elemento con información """ logger.info() # logger.debug("item: \n" + item.tostring('\n')) import xbmcgui import xbmcplugin import xbmc # Intentamos reproducir una imagen (esto no hace nada y ademas no da error) xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "icon.png"))) # Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion xbmc.Player().stop() # modificamos el action (actualmente la biblioteca necesita "findvideos" ya que es donde se buscan las fuentes item.action = "findvideos" window_type = config.get_setting("window_type", "biblioteca") # y volvemos a lanzar kodi if xbmc.getCondVisibility('Window.IsMedia') and not window_type == 1: # Ventana convencional xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")") else: # Ventana emergente from channels import biblioteca p_dialog = platformtools.dialog_progress_bg('streamondemand', 'Caricamento in corso...') p_dialog.update(0, '') itemlist = biblioteca.findvideos(item) p_dialog.update(50, '') # Se filtran los enlaces segun la lista blanca y negra if config.get_setting('filter_servers') == 'true': itemlist = filtered_servers(itemlist) # Se limita la cantidad de enlaces a mostrar if config.get_setting("max_links", "biblioteca") != 0: itemlist = limit_itemlist(itemlist) # Se "limpia" ligeramente la lista de enlaces if config.get_setting("replace_VD", "biblioteca") == 1: itemlist = reorder_itemlist(itemlist) p_dialog.update(100, '') xbmc.sleep(500) p_dialog.close() if len(itemlist) > 0: # El usuario elige el mirror opciones = [] for item in itemlist: opciones.append(item.title) # Se abre la ventana de seleccion if (item.contentSerieName != "" and item.contentSeason != "" and item.contentEpisodeNumber != ""): cabecera = ("%s - %sx%s -- %s" % (item.contentSerieName, item.contentSeason, item.contentEpisodeNumber, config.get_localized_string(30163))) else: cabecera = config.get_localized_string(30163) seleccion = platformtools.dialog_select(cabecera, opciones) if seleccion == -1: return else: item = biblioteca.play(itemlist[seleccion])[0] platformtools.play_video(item)
def run(item=None): # from core.support import dbg;dbg() logger.debug() if not item: # Extract item from sys.argv if sys.argv[2]: sp = sys.argv[2].split('&') url = sp[0] item = Item().fromurl(url) if len(sp) > 1: for e in sp[1:]: key, val = e.split('=') item.__setattr__(key, val) # If no item, this is mainlist else: item = Item(channel="channelselector", action="getmainlist", viewmode="movie") if not config.get_setting('show_once'): if not config.get_all_settings_addon(): logger.error('corrupted settings.xml!!') settings_xml = os.path.join(config.get_data_path(), "settings.xml") settings_bak = os.path.join(config.get_data_path(), "settings.bak") if filetools.exists(settings_bak): filetools.copy(settings_bak, settings_xml, True) logger.info('restored settings.xml from backup') else: filetools.write(settings_xml, '<settings version="2">\n</settings>' ) # resetted settings else: from platformcode import xbmc_videolibrary xbmc_videolibrary.ask_set_content(silent=False) config.set_setting('show_once', True) logger.info(item.tostring()) try: if not config.get_setting('tmdb_active'): config.set_setting('tmdb_active', True) # If item has no action, stops here if item.action == "": logger.debug("Item without action") return # Action for main menu in channelselector elif item.action == "getmainlist": import channelselector itemlist = channelselector.getmainlist() platformtools.render_items(itemlist, item) # Action for channel types on channelselector: movies, series, etc. elif item.action == "getchanneltypes": import channelselector itemlist = channelselector.getchanneltypes() platformtools.render_items(itemlist, item) # Action for channel listing on channelselector elif item.action == "filterchannels": import channelselector itemlist = channelselector.filterchannels(item.channel_type) platformtools.render_items(itemlist, item) # Special action for playing a video from the library elif item.action == "play_from_library": play_from_library(item) return elif item.action == "keymap": from platformcode import keymaptools if item.open: return keymaptools.open_shortcut_menu() else: return keymaptools.set_key() elif item.channel == "infoplus": from platformcode import infoplus return infoplus.Main(item) elif item.channel == "backup": from platformcode import backup return getattr(backup, item.action)(item) elif item.channel == "elementum_download": from platformcode import elementum_download return getattr(elementum_download, item.action)(item) elif item.channel == "shortcuts": from platformcode import shortcuts return getattr(shortcuts, item.action)(item) elif item.channel == "autorenumber": from platformcode import autorenumber return getattr(autorenumber, item.action)(item) elif item.action == "delete_key": from platformcode import keymaptools return keymaptools.delete_key() elif item.action == "script": from core import tmdb if tmdb.drop_bd(): platformtools.dialog_notification( config.get_localized_string(20000), config.get_localized_string(60011), time=2000, sound=False) elif item.action == "itemInfo": platformtools.dialog_textviewer('Item info', item.parent) elif item.action == "open_browser": import webbrowser if not webbrowser.open(item.url): import xbmc if xbmc.getCondVisibility( 'system.platform.linux') and xbmc.getCondVisibility( 'system.platform.android'): # android xbmc.executebuiltin( 'StartAndroidActivity("", "android.intent.action.VIEW", "", "%s")' % (item.url)) else: try: import urllib.request as urllib except ImportError: import urllib short = urllib.urlopen( 'https://u.nu/api.php?action=shorturl&format=simple&url=' + item.url).read().decode('utf-8') platformtools.dialog_ok( config.get_localized_string(20000), config.get_localized_string(70740) % short) # Action in certain channel specified in "action" and "channel" parameters elif item.action == "check_channels": from platformcode import checkhost checkhost.check_channels() else: # Checks if channel exists if os.path.isfile( os.path.join(config.get_runtime_path(), 'channels', item.channel + ".py")): CHANNELS = 'channels' else: CHANNELS = 'specials' channel_file = os.path.join(config.get_runtime_path(), CHANNELS, item.channel + ".py") logger.debug("channel_file= " + channel_file + ' - ' + CHANNELS + ' - ' + item.channel) channel = None if os.path.exists(channel_file): try: channel = __import__('%s.%s' % (CHANNELS, item.channel), None, None, ['%s.%s' % (CHANNELS, item.channel)]) except ImportError: exec("import " + CHANNELS + "." + item.channel + " as channel") logger.info("Running channel %s | %s" % (channel.__name__, channel.__file__)) # Special play action if item.action == "play": # define la info para trakt try: from core import trakt_tools trakt_tools.set_trakt_info(item) except: pass logger.debug("item.action=%s" % item.action.upper()) # logger.debug("item_toPlay: " + "\n" + item.tostring('\n')) # First checks if channel has a "play" function if hasattr(channel, 'play'): logger.debug("Executing channel 'play' method") itemlist = channel.play(item) b_favourite = item.isFavourite # Play should return a list of playable URLS if len(itemlist) > 0 and isinstance(itemlist[0], Item): item = itemlist[0] if b_favourite: item.isFavourite = True platformtools.play_video(item) # Permitir varias calidades desde play en el Channel elif len(itemlist) > 0 and isinstance(itemlist[0], list): item.video_urls = itemlist platformtools.play_video(item) # If not, shows user an error message else: platformtools.dialog_ok( config.get_localized_string(20000), config.get_localized_string(60339)) # If player don't have a "play" function, not uses the standard play from platformtools else: logger.debug("Executing core 'play' method") platformtools.play_video(item) # Special action for findvideos, where the plugin looks for known urls elif item.action == "findvideos": from core import servertools # First checks if channel has a "findvideos" function if hasattr(channel, 'findvideos'): itemlist = getattr(channel, item.action)(item) # If not, uses the generic findvideos function else: logger.debug("No channel 'findvideos' method, " "executing core method") itemlist = servertools.find_video_items(item) if config.get_setting("max_links", "videolibrary") != 0: itemlist = limit_itemlist(itemlist) from platformcode import subtitletools subtitletools.saveSubtitleName(item) platformtools.render_items(itemlist, item) # Special action for adding a movie to the library elif item.action == "add_pelicula_to_library": from core import videolibrarytools videolibrarytools.add_movie(item) # Special action for adding a serie to the library elif item.action == "add_serie_to_library": from core import videolibrarytools videolibrarytools.add_tvshow(item, channel) # Special action for downloading all episodes from a serie elif item.action == "download_all_episodes": from specials import downloads item.action = item.extra del item.extra downloads.save_download(item) # Special action for searching, first asks for the words then call the "search" function elif item.action == "search": # from core.support import dbg;dbg() if filetools.isfile(temp_search_file) and config.get_setting( 'videolibrary_kodi'): itemlist = [] f = filetools.read(temp_search_file) strList = f.split(',') if strList[0] == '[V]' and strList[1] == item.channel: for it in strList: if it and it not in ['[V]', item.channel]: itemlist.append(Item().fromurl(it)) filetools.write(temp_search_file, f[4:]) return platformtools.render_items(itemlist, item) else: filetools.remove(temp_search_file) logger.debug("item.action=%s" % item.action.upper()) from core import channeltools if config.get_setting('last_search'): last_search = channeltools.get_channel_setting( 'Last_searched', 'search', '') else: last_search = '' search_text = platformtools.dialog_input(last_search) if search_text is not None: channeltools.set_channel_setting('Last_searched', search_text, 'search') itemlist = new_search(item.clone(text=search_text), channel) else: return platformtools.render_items(itemlist, item) # For all other actions else: # import web_pdb; web_pdb.set_trace() logger.debug("Executing channel '%s' method" % item.action) itemlist = getattr(channel, item.action)(item) if config.get_setting('trakt_sync'): from core import trakt_tools token_auth = config.get_setting("token_trakt", "trakt") if not token_auth: trakt_tools.auth_trakt() else: import xbmc if not xbmc.getCondVisibility( 'System.HasAddon(script.trakt)' ) and config.get_setting('install_trakt'): trakt_tools.ask_install_script() itemlist = trakt_tools.trakt_check(itemlist) else: config.set_setting('install_trakt', True) platformtools.render_items(itemlist, item) except WebErrorException as e: import traceback from core import scrapertools logger.error(traceback.format_exc()) platformtools.dialog_ok( config.get_localized_string(59985) % e.channel, config.get_localized_string(60013) % e.url) except Exception as e: import traceback from core import scrapertools logger.error(traceback.format_exc()) patron = 'File "' + os.path.join(config.get_runtime_path(), "channels", "").replace("\\", "\\\\") + r'([^.]+)\.py"' Channel = scrapertools.find_single_match(traceback.format_exc(), patron) if Channel or e.__class__ == logger.ChannelScraperException: if item.url: if platformtools.dialog_yesno( config.get_localized_string(60087) % Channel, config.get_localized_string(60014), nolabel='ok', yeslabel=config.get_localized_string(70739)): run(Item(action="open_browser", url=item.url)) else: platformtools.dialog_ok( config.get_localized_string(60087) % Channel, config.get_localized_string(60014)) else: if platformtools.dialog_yesno(config.get_localized_string(60038), config.get_localized_string(60015)): run(Item(channel="setting", action="report_menu"))
def buscartrailer(item): logger.info("pelisalacarta.channels.trailertools buscartrailer") # Se elimina la opciçon de Buscar Trailer del menú contextual para evitar redundancias if type(item.context) is str and "buscar_trailer" in item.context: item.context = item.context.replace("buscar_trailer", "") elif type(item.context) is list and "buscar_trailer" in item.context: item.context.remove("buscar_trailer") item.text_color = "" # Si no se indica el parámetro contextual se entiende que no se ejecuta desde este mení if item.contextual == "": item.contextual = False itemlist = [] if item.contentTitle != "": item.contentTitle = item.contentTitle.strip() elif keyboard: fulltitle = re.sub('\[\/*(B|I|COLOR)\s*[^\]]*\]', '', item.fulltitle.strip()) item.contentTitle = platformtools.dialog_input(default=fulltitle, heading="Introduce el título a buscar") if item.contentTitle is None: item.contentTitle = fulltitle else: item.contentTitle = item.contentTitle.strip() else: fulltitle = re.sub('\[\/*(B|I|COLOR)\s*[^\]]*\]', '', item.fulltitle.strip()) item.contentTitle = fulltitle if "year" in item.infoLabels: item.year = item.infoLabels['year'] else: item.year = "" logger.info("pelisalacarta.channels.trailertools Búsqueda: %s" % item.contentTitle) logger.info("pelisalacarta.channels.trailertools Año: %s" % item.year) # Lista de acciones si se ejecuta desde el menú contextual if item.action == "manual_search": itemlist = manual_search(item) item.contentTitle = itemlist[0].contentTitle elif item.action == "youtube_search": itemlist = youtube_search(item) elif item.action == "filmaffinity_search": itemlist = filmaffinity_search(item) elif item.action == "abandomoviez_search": itemlist = abandomoviez_search(item) elif item.action == "jayhap_search": itemlist = jayhap_search(item) else: if item.infoLabels['trailer']: url = item.infoLabels['trailer'] if "youtube" in url: url = url.replace("embed/", "watch?v=") titulo, url, server = servertools.findvideos(url)[0] title = "Trailer por defecto [" + server + "]" itemlist.append(item.clone(title=title, url=url, server=server, action="play")) if item.show != "" or ("tvshowtitle" in item.infoLabels and item.infoLabels['tvshowtitle'] != ""): tipo = "tv" else: tipo = "movie" try: itemlist.extend(tmdb_trailers(item, tipo)) except: import traceback logger.error(traceback.format_exc()) if item.contextual: title = "[COLOR green]%s[/COLOR]" else: title = "%s" itemlist.append(item.clone(title=title % "Búsqueda en Youtube", action="youtube_search", text_color="green")) itemlist.append(item.clone(title=title % "Búsqueda en Filmaffinity", action="filmaffinity_search", text_color="green")) # Si se trata de una serie, no se incluye la opción de buscar en Abandomoviez if item.show == "" and ("tvshowtitle" not in item.infoLabels or item.infoLabels['tvshowtitle'] == ""): itemlist.append(item.clone(title=title % "Búsqueda en Abandomoviez", action="abandomoviez_search", text_color="green")) itemlist.append(item.clone(title=title % "Búsqueda en Jayhap (Youtube, Vimeo & Dailymotion)", action="jayhap_search", text_color="green")) if item.contextual: opciones = [] if itemlist: for video_url in itemlist: opciones.append(video_url.title) seleccion = platformtools.dialog_select("Buscando: "+item.contentTitle, opciones) logger.info("seleccion=%d" % seleccion) logger.info("seleccion=%s" % opciones[seleccion]) if seleccion < 0: return else: item = itemlist[seleccion] if "search" in item.action: buscartrailer(item) else: if item.action == "play": platformtools.play_video(item) return else: return itemlist
def findvideos(item): logger.info() # logger.debug("item:\n" + item.tostring('\n')) itemlist = [] list_canales = {} item_local = None if not item.contentTitle or not item.strm_path: logger.debug("No se pueden buscar videos por falta de parametros") return [] content_title = filter(lambda c: c not in ":*?<>|\/", item.contentTitle.strip().lower()) if item.contentType == 'movie': item.strm_path = filetools.join(videolibrarytools.MOVIES_PATH, item.strm_path) path_dir = os.path.dirname(item.strm_path) item.nfo = filetools.join(path_dir, os.path.basename(path_dir) + ".nfo") else: item.strm_path = filetools.join(videolibrarytools.TVSHOWS_PATH, item.strm_path) path_dir = os.path.dirname(item.strm_path) item.nfo = filetools.join(path_dir, 'tvshow.nfo') for fd in filetools.listdir(path_dir): if fd.endswith('.json'): contenido, nom_canal = fd[:-6].split('[') if (contenido.startswith(content_title) or item.contentType == 'movie') and nom_canal not in \ list_canales.keys(): list_canales[nom_canal] = filetools.join(path_dir, fd) num_canales = len(list_canales) # logger.debug(str(list_canales)) if 'downloads' in list_canales: json_path = list_canales['downloads'] item_json = Item().fromjson(filetools.read(json_path)) item_json.contentChannel = "local" # Soporte para rutas relativas en descargas if filetools.is_relative(item_json.url): item_json.url = filetools.join(videolibrarytools.VIDEOLIBRARY_PATH, item_json.url) del list_canales['downloads'] # Comprobar q el video no haya sido borrado if filetools.exists(item_json.url): item_local = item_json.clone(action='play') itemlist.append(item_local) else: num_canales -= 1 filtro_canal = '' if num_canales > 1 and config.get_setting("ask_channel", "videolibrary"): opciones = [ "Mostrar solo los enlaces de %s" % k.capitalize() for k in list_canales.keys() ] opciones.insert(0, "Mostrar todos los enlaces") if item_local: opciones.append(item_local.title) from platformcode import platformtools index = platformtools.dialog_select(config.get_localized_string(30163), opciones) if index < 0: return [] elif item_local and index == len(opciones) - 1: filtro_canal = 'downloads' platformtools.play_video(item_local) elif index > 0: filtro_canal = opciones[index].replace( "Mostrar solo los enlaces de ", "") itemlist = [] for nom_canal, json_path in list_canales.items(): if filtro_canal and filtro_canal != nom_canal.capitalize(): continue # Importamos el canal de la parte seleccionada try: channel = __import__('channels.%s' % nom_canal, fromlist=["channels.%s" % nom_canal]) except ImportError: exec "import channels." + nom_canal + " as channel" item_json = Item().fromjson(filetools.read(json_path)) list_servers = [] try: # FILTERTOOLS # si el canal tiene filtro se le pasa el nombre que tiene guardado para que filtre correctamente. if "list_language" in item_json: # si se viene desde la videoteca del addon if "library_filter_show" in item: item_json.show = item.library_filter_show.get( nom_canal, "") # Ejecutamos find_videos, del canal o común item_json.contentChannel = 'videolibrary' if hasattr(channel, 'findvideos'): from core import servertools list_servers = getattr(channel, 'findvideos')(item_json) list_servers = servertools.filter_servers(list_servers) else: from core import servertools list_servers = servertools.find_video_items(item_json) except Exception, ex: logger.error("Ha fallado la funcion findvideos para el canal %s" % nom_canal) template = "An exception of type %s occured. Arguments:\n%r" message = template % (type(ex).__name__, ex.args) logger.error(message) # Cambiarle el titulo a los servers añadiendoles el nombre del canal delante y # las infoLabels y las imagenes del item si el server no tiene for server in list_servers: if not server.action: # Ignorar las etiquetas continue server.contentChannel = server.channel server.channel = "videolibrary" server.nfo = item.nfo server.strm_path = item.strm_path # Se añade el nombre del canal si se desea if config.get_setting("quit_channel_name", "videolibrary") == 0: server.title = "%s: %s" % (nom_canal.capitalize(), server.title) server.infoLabels = item_json.infoLabels if not server.thumbnail: server.thumbnail = item.thumbnail # logger.debug("server:\n%s" % server.tostring('\n')) itemlist.append(server)
def run(item=None): logger.info() if not item: # Extract item from sys.argv if sys.argv[2]: sp = sys.argv[2].split('&') url = sp[0] item = Item().fromurl(url) if len(sp) > 1: for e in sp[1:]: key, val = e.split('=') item.__setattr__(key, val) # If no item, this is mainlist else: if config.get_setting("start_page"): if not config.get_setting("custom_start"): category = config.get_setting("category") if isinstance(category, int): category = config.get_localized_string( config.get_setting("category")).lower() item = Item(channel="news", action="news", news=category.lower(), startpage=True) else: from channels import side_menu item = Item() item = side_menu.check_user_home(item) item.startpage = True else: item = Item(channel="channelselector", action="getmainlist", viewmode="movie") if not config.get_setting('show_once'): from platformcode import configurator configurator.show_window() logger.info(item.tostring()) # If item has no action, stops here if item.action == "": logger.info("Item sin accion") return # Cleans infoLabels["playcount"] if set by generictools if item.video_path: item.infoLabels["playcount"] = 1 del item.infoLabels["playcount"] try: if not config.get_setting('tmdb_active'): config.set_setting('tmdb_active', True) # Special action for playing a video from the library if item.action == "play_from_library": play_from_library(item) return elif item.channel == 'channelselector': import channelselector # Action for addon install on channelselector if item.action == "install_alfa": channelselector.install_alfa() else: # Action for main menu in channelselector if item.action == "getmainlist": itemlist = channelselector.getmainlist() # Action for channel types on channelselector: movies, series, etc. elif item.action == "getchanneltypes": itemlist = channelselector.getchanneltypes() # Action for channel listing on channelselector elif item.action == "filterchannels": itemlist = channelselector.filterchannels( item.channel_type) platformtools.render_items(itemlist, item) elif item.action == "keymap": from platformcode import keymaptools if item.open: return keymaptools.open_shortcut_menu() else: return keymaptools.set_key() elif item.action == "script": from core import tmdb if tmdb.drop_bd(): platformtools.dialog_notification( config.get_localized_string(20000), config.get_localized_string(60011), time=2000, sound=False) elif item.action == "function": """ { "action": "function", "folder": "lib", "function": "alfa_assistant", "method": "install_alfa_assistant", "options": "auto" } """ # Checks if function file exists function_file = os.path.join(config.get_runtime_path(), item.folder, item.function + ".py") logger.info("function_file=%s" % function_file) function = None if os.path.exists(function_file): try: function = __import__( '%s.%s' % (item.folder, item.function), None, None, ["%s.%s" % (item.folder, item.function)]) except ImportError: exec("import %s." + item.function + " as function") logger.info( "Running function %s(%s) | %s" % (function.__name__, item.options, function.__file__)) getattr(function, item.method)(item.options) else: logger.error( "ERROR Running function %s(%s) | %s" % (function.__name__, item.options, function.__file__)) # Action in certain channel specified in "action" and "channel" parameters else: # Entry point for a channel is the "mainlist" action, so here we check parental control if item.action == "mainlist": # Parental control # If it is an adult channel, and user has configured pin, asks for it if channeltools.is_adult(item.channel) and config.get_setting( "adult_request_password"): tecleado = platformtools.dialog_input( "", config.get_localized_string(60334), True) if tecleado is None or tecleado != config.get_setting( "adult_password"): return # # Actualiza el canal individual # if (item.action == "mainlist" and item.channel != "channelselector" and # config.get_setting("check_for_channel_updates") == True): # from core import updater # updater.update_channel(item.channel) # Checks if channel exists channel_file = os.path.join(config.get_runtime_path(), 'channels', item.channel + ".py") logger.info("channel_file=%s" % channel_file) channel = None if os.path.exists(channel_file): try: channel = __import__('channels.%s' % item.channel, None, None, ["channels.%s" % item.channel]) except ImportError: exec("import channels." + item.channel + " as channel") logger.info("Running channel %s | %s" % (channel.__name__, channel.__file__)) if item.channel == "test" and item.contentChannel: if item.parameters == "test_channel": getattr(channel, item.action)(item.contentChannel) # Calls redirection if Alfavorites findvideos, episodios, seasons if item.context and 'alfavorites' in str(item.context) \ and item.action in ['findvideos', 'episodios', 'seasons', 'play']: try: from lib import generictools item, it, overwrite = generictools.redirect_clone_newpct1( item) except: import traceback logger.error(traceback.format_exc()) # Special play action if item.action == "play": #define la info para trakt try: trakt_tools.set_trakt_info(item) except: pass logger.info("item.action=%s" % item.action.upper()) # logger.debug("item_toPlay: " + "\n" + item.tostring('\n')) # First checks if channel has a "play" function if hasattr(channel, 'play'): logger.info("Executing channel 'play' method") itemlist = channel.play(item) b_favourite = item.isFavourite # Play should return a list of playable URLS if len(itemlist) > 0 and isinstance(itemlist[0], Item): item = itemlist[0] if b_favourite: item.isFavourite = True platformtools.play_video(item) # Permitir varias calidades desde play en el canal elif len(itemlist) > 0 and isinstance(itemlist[0], list): item.video_urls = itemlist platformtools.play_video(item) # If not, shows user an error message else: platformtools.dialog_ok( config.get_localized_string(20000), config.get_localized_string(60339)) # If player don't have a "play" function, not uses the standard play from platformtools else: logger.info("Executing core 'play' method") platformtools.play_video(item) # Special action for findvideos, where the plugin looks for known urls elif item.action == "findvideos": # First checks if channel has a "findvideos" function if hasattr(channel, 'findvideos'): itemlist = getattr(channel, item.action)(item) itemlist = servertools.filter_servers(itemlist) # If not, uses the generic findvideos function else: logger.info("No channel 'findvideos' method, " "executing core method") itemlist = servertools.find_video_items(item) if config.get_setting("max_links", "videolibrary") != 0: itemlist = limit_itemlist(itemlist) from platformcode import subtitletools subtitletools.saveSubtitleName(item) platformtools.render_items(itemlist, item) # Special action for adding a movie to the library elif item.action == "add_pelicula_to_library": videolibrarytools.add_movie(item) # Special action for adding a serie to the library elif item.action == "add_serie_to_library": videolibrarytools.add_tvshow(item, channel) # Special action for downloading all episodes from a serie elif item.action == "download_all_episodes": from channels import downloads item.action = item.extra del item.extra downloads.save_download(item) # Special action for searching, first asks for the words then call the "search" function elif item.action == "search": logger.info("item.action=%s" % item.action.upper()) # last_search = "" # last_search_active = config.get_setting("last_search", "search") # if last_search_active: # try: # current_saved_searches_list = list(config.get_setting("saved_searches_list", "search")) # last_search = current_saved_searches_list[0] # except: # pass last_search = channeltools.get_channel_setting( 'Last_searched', 'search', '') tecleado = platformtools.dialog_input(last_search) if tecleado is not None: if "http" not in tecleado: channeltools.set_channel_setting( 'Last_searched', tecleado, 'search') itemlist = channel.search(item, tecleado) else: return platformtools.render_items(itemlist, item) # For all other actions else: logger.info("Executing channel '%s' method" % item.action) itemlist = getattr(channel, item.action)(item) if config.get_setting('trakt_sync'): token_auth = config.get_setting("token_trakt", "trakt") if not token_auth: trakt_tools.auth_trakt() else: import xbmc if not xbmc.getCondVisibility( 'System.HasAddon(script.trakt)' ) and config.get_setting('install_trakt'): trakt_tools.ask_install_script() itemlist = trakt_tools.trakt_check(itemlist) elif not config.get_setting('install_trakt'): config.set_setting('install_trakt', True) platformtools.render_items(itemlist, item) except urllib2.URLError as e: import traceback logger.error(traceback.format_exc()) # Grab inner and third party errors if hasattr(e, 'reason'): logger.error("Razon del error, codigo: %s | Razon: %s" % (str(e.reason[0]), str(e.reason[1]))) texto = config.get_localized_string( 30050) # "No se puede conectar con el sitio web" platformtools.dialog_ok("alfa", texto) # Grab server response errors elif hasattr(e, 'code'): logger.error("Codigo de error HTTP : %d" % e.code) # "El sitio web no funciona correctamente (error http %d)" platformtools.dialog_ok( "alfa", config.get_localized_string(30051) % e.code) except WebErrorException as e: import traceback logger.error(traceback.format_exc()) patron = 'File "' + os.path.join(config.get_runtime_path(), "channels", "").replace("\\", "\\\\") + '([^.]+)\.py"' canal = scrapertools.find_single_match(traceback.format_exc(), patron) platformtools.dialog_ok( config.get_localized_string(59985) + canal, config.get_localized_string(60013) % (e)) except: import traceback logger.error(traceback.format_exc()) patron = 'File "' + os.path.join(config.get_runtime_path(), "channels", "").replace("\\", "\\\\") + '([^.]+)\.py"' canal = scrapertools.find_single_match(traceback.format_exc(), patron) try: if config.get_platform(True)['num_version'] < 14: log_name = "xbmc.log" else: log_name = "kodi.log" log_message = config.get_localized_string( 50004) + config.translatePath("special://logpath") + log_name except: log_message = "" if canal: platformtools.dialog_ok( config.get_localized_string(60087) % canal, config.get_localized_string(60014), log_message) else: platformtools.dialog_ok(config.get_localized_string(60038), config.get_localized_string(60015), log_message)
def findvideos(item): from core import autoplay logger.info() # logger.debug("item:\n" + item.tostring('\n')) videolibrarytools.check_renumber_options(item) itemlist = [] list_canales = {} item_local = None # Disable autoplay # autoplay.set_status(False) if not item.contentTitle or not item.strm_path: logger.debug("Unable to search for videos due to lack of parameters") return [] content_title = str(item.contentSeason) + 'x' + (str(item.contentEpisodeNumber) if item.contentEpisodeNumber > 9 else '0' + str(item.contentEpisodeNumber)) if item.contentType == 'movie': item.strm_path = filetools.join(videolibrarytools.MOVIES_PATH, item.strm_path) path_dir = filetools.dirname(item.strm_path) item.nfo = filetools.join(path_dir, filetools.basename(path_dir) + ".nfo") else: item.strm_path = filetools.join(videolibrarytools.TVSHOWS_PATH, item.strm_path) path_dir = filetools.dirname(item.strm_path) item.nfo = filetools.join(path_dir, 'tvshow.nfo') for fd in filetools.listdir(path_dir): if fd.endswith('.json'): contenido, nom_canal = fd[:-6].split('[') if (contenido.startswith(content_title) or item.contentType == 'movie') and nom_canal not in list(list_canales.keys()): list_canales[nom_canal] = filetools.join(path_dir, fd) num_canales = len(list_canales) if 'downloads' in list_canales: json_path = list_canales['downloads'] item_json = Item().fromjson(filetools.read(json_path)) item_json.contentChannel = "local" # Support for relative paths in downloads if filetools.is_relative(item_json.url): item_json.url = filetools.join(videolibrarytools.VIDEOLIBRARY_PATH, item_json.url) del list_canales['downloads'] # Check that the video has not been deleted if filetools.exists(item_json.url): item_local = item_json.clone(action='play') itemlist.append(item_local) else: num_canales -= 1 filtro_canal = '' if num_canales > 1 and config.get_setting("ask_channel", "videolibrary"): opciones = [config.get_localized_string(70089) % k.capitalize() for k in list(list_canales.keys())] opciones.insert(0, config.get_localized_string(70083)) if item_local: opciones.append(item_local.title) from platformcode import platformtools index = platformtools.dialog_select(config.get_localized_string(30163), opciones) if index < 0: return [] elif item_local and index == len(opciones) - 1: filtro_canal = 'downloads' platformtools.play_video(item_local) elif index > 0: filtro_canal = opciones[index].replace(config.get_localized_string(70078), "").strip() itemlist = [] for nom_canal, json_path in list(list_canales.items()): if filtro_canal and filtro_canal != nom_canal.capitalize(): continue item_canal = Item() # We import the channel of the selected part try: if nom_canal == 'community': channel = __import__('specials.%s' % nom_canal, fromlist=["channels.%s" % nom_canal]) else: channel = __import__('channels.%s' % nom_canal, fromlist=["channels.%s" % nom_canal]) except ImportError: exec("import channels." + nom_canal + " as channel") item_json = Item().fromjson(filetools.read(json_path)) list_servers = [] # from core.support import dbg;dbg() try: # FILTERTOOLS # if the channel has a filter, the name it has saved is passed to it so that it filters correctly. if "list_language" in item_json: # if it comes from the addon video library if "library_filter_show" in item: item_json.show = item.library_filter_show.get(nom_canal, "") # We run find_videos, from the channel or common item_json.contentChannel = 'videolibrary' item_json.play_from = item.play_from item_json.nfo = item.nfo item_json.strm_path = item.strm_path if hasattr(channel, 'findvideos'): from core import servertools if item_json.videolibray_emergency_urls: del item_json.videolibray_emergency_urls list_servers = getattr(channel, 'findvideos')(item_json) elif item_json.action == 'play': from platformcode import platformtools # autoplay.set_status(True) item_json.contentChannel = item_json.channel item_json.channel = "videolibrary" platformtools.play_video(item_json) return '' else: from core import servertools list_servers = servertools.find_video_items(item_json) except Exception as ex: logger.error("The findvideos function for the channel %s failed" % nom_canal) template = "An exception of type %s occured. Arguments:\n%r" message = template % (type(ex).__name__, ex.args) logger.error(message) logger.error(traceback.format_exc()) # Change the title to the servers adding the name of the channel in front and the infoLabels and the images of the item if the server does not have for server in list_servers: server.contentChannel = server.channel server.channel = "videolibrary" server.nfo = item.nfo server.strm_path = item.strm_path server.play_from = item.play_from # Kodi 18 Compatibility - Prevents wheel from spinning around in Direct Links if server.action == 'play': server.folder = False # Channel name is added if desired if config.get_setting("quit_channel_name", "videolibrary") == 0: server.title = "%s: %s" % (nom_canal.capitalize(), server.title) if not server.thumbnail: server.thumbnail = item.thumbnail # logger.debug("server:\n%s" % server.tostring('\n')) itemlist.append(server) if autoplay.play_multi_channel(item, itemlist): # hideserver return [] add_download_items(item, itemlist) return itemlist
def run(): logger.info() # Extract item from sys.argv if sys.argv[2]: item = Item().fromurl(sys.argv[2]) # If no item, this is mainlist else: item = Item(channel="channelselector", action="getmainlist", viewmode="movie") logger.info(item.tostring()) try: # If item has no action, stops here if item.action == "": logger.info("Item sin accion") return # Action for main menu in channelselector if item.action == "getmainlist": import channelselector # Check for updates only on first screen if config.get_setting("check_for_plugin_updates") == "true": logger.info("Check for plugin updates enabled") from core import updater try: config.set_setting("plugin_updates_available","0") version = updater.checkforupdates() itemlist = channelselector.getmainlist() if version: config.set_setting("plugin_updates_available","1") platformtools.dialog_ok("Versione "+version+" disponible", "E' possibile fare il download della nuova versione\n" "selezionare la relativa voce nel menu principale") itemlist = channelselector.getmainlist() itemlist.insert(0, Item(title="Download versione "+version, version=version, channel="updater", action="update", thumbnail=os.path.join(config.get_runtime_path() , "resources" , "images", "service_update.png"))) except: import traceback logger.info(traceback.format_exc()) platformtools.dialog_ok("Impossibile connettersi", "Non è stato possibile verificare", "aggiornamenti") logger.info("Fallo al verificar la actualización") config.set_setting("plugin_updates_available","0") itemlist = channelselector.getmainlist() else: logger.info("Check for plugin updates disabled") config.set_setting("plugin_updates_available","0") itemlist = channelselector.getmainlist() platformtools.render_items(itemlist, item) # Action for updating plugin elif item.action == "update": from core import updater updater.update(item) config.set_setting("plugin_updates_available","0") if config.get_system_platform() != "xbox": import xbmc xbmc.executebuiltin("Container.Refresh") # Action for channel types on channelselector: movies, series, etc. elif item.action == "getchanneltypes": import channelselector itemlist = channelselector.getchanneltypes() platformtools.render_items(itemlist, item) # Action for channel listing on channelselector elif item.action == "filterchannels": import channelselector itemlist = channelselector.filterchannels(item.channel_type) platformtools.render_items(itemlist, item) # Special action for playing a video from the library elif item.action == "play_from_library": play_from_library(item) return # Action in certain channel specified in "action" and "channel" parameters else: # Entry point for a channel is the "mainlist" action, so here we check parental control if item.action == "mainlist": # Parental control can_open_channel = False # If it is an adult channel, and user has configured pin, asks for it if channeltools.is_adult(item.channel) and config.get_setting("adult_pin") != "": tecleado = platformtools.dialog_input("", "PIN per canali per adulti", True) if tecleado is not None: if tecleado == config.get_setting("adult_pin"): can_open_channel = True # All the other cases can open the channel else: can_open_channel = True if not can_open_channel: return # Actualiza el canal individual if (item.action == "mainlist" and item.channel != "channelselector" and config.get_setting("check_for_channel_updates") == "true"): from core import updater updater.update_channel(item.channel) # Checks if channel exists channel_file = os.path.join(config.get_runtime_path(), 'channels', item.channel + ".py") logger.info("channel_file=%s" % channel_file) channel = None if item.channel in ["personal", "personal2", "personal3", "personal4", "personal5"]: import channels.personal as channel elif os.path.exists(channel_file): try: channel = __import__('channels.%s' % item.channel, None, None, ["channels.%s" % item.channel]) except ImportError: exec "import channels." + item.channel + " as channel" logger.info("Running channel %s | %s" % (channel.__name__, channel.__file__)) # Special play action if item.action == "play": logger.info("item.action=%s" % item.action.upper()) # logger.debug("item_toPlay: " + "\n" + item.tostring('\n')) # First checks if channel has a "play" function if hasattr(channel, 'play'): logger.info("Executing channel 'play' method") itemlist = channel.play(item) b_favourite = item.isFavourite # Play should return a list of playable URLS if len(itemlist) > 0 and isinstance(itemlist[0], Item): item = itemlist[0] if b_favourite: item.isFavourite = True platformtools.play_video(item) # Permitir varias calidades desde play en el canal elif len(itemlist) > 0 and isinstance(itemlist[0], list): item.video_urls = itemlist platformtools.play_video(item) # If not, shows user an error message else: platformtools.dialog_ok("plugin", "Niente da riprodurre") # If player don't have a "play" function, not uses the standard play from platformtools else: logger.info("Executing core 'play' method") platformtools.play_video(item) # Special action for findvideos, where the plugin looks for known urls elif item.action == "findvideos": # First checks if channel has a "findvideos" function if hasattr(channel, 'findvideos'): itemlist = getattr(channel, item.action)(item) # If not, uses the generic findvideos function else: logger.info("No channel 'findvideos' method, " "executing core method") from core import servertools itemlist = servertools.find_video_items(item) if config.get_setting('filter_servers') == 'true': itemlist = filtered_servers(itemlist) if config.get_setting("max_links", "biblioteca") != 0: itemlist = limit_itemlist(itemlist) from platformcode import subtitletools subtitletools.saveSubtitleName(item) platformtools.render_items(itemlist, item) # Special action for adding a movie to the library elif item.action == "add_pelicula_to_library": library.add_pelicula_to_library(item) # Special action for adding a serie to the library elif item.action == "add_serie_to_library": library.add_serie_to_library(item, channel) # Special action for downloading all episodes from a serie elif item.action == "download_all_episodes": from channels import descargas item.action = item.extra del item.extra descargas.save_download(item) # Special action for searching, first asks for the words then call the "search" function elif item.action == "search": logger.info("item.action=%s" % item.action.upper()) tecleado = platformtools.dialog_input('') if tecleado is not None: # TODO revisar 'personal.py' porque no tiene función search y daría problemas # DrZ3r0 itemlist = channel.search(item, tecleado.replace(" ", "+")) else: return platformtools.render_items(itemlist, item) # For all other actions else: logger.info("Executing channel '%s' method" % item.action) itemlist = getattr(channel, item.action)(item) platformtools.render_items(itemlist, item) except urllib2.URLError, e: import traceback logger.error(traceback.format_exc()) # Grab inner and third party errors if hasattr(e, 'reason'): logger.info("Razon del error, codigo: %s | Razon: %s" % (str(e.reason[0]), str(e.reason[1]))) texto = config.get_localized_string(30050) # "No se puede conectar con el sitio web" platformtools.dialog_ok("plugin", texto) # Grab server response errors elif hasattr(e, 'code'): logger.info("Codigo de error HTTP : %d" % e.code) # "El sitio web no funciona correctamente (error http %d)" platformtools.dialog_ok("plugin", config.get_localized_string(30051) % e.code)
def play_from_library(item): """ The .strm files when played from kodi, this expects it to be a "playable" file so it cannot contain more items, at most a selection dialog can be placed. We solve this by "cheating kodi" and making him believe that something has been reproduced, so later by "Container.Update ()" we load the strm as if an item from inside the addon were treated, removing all the limitations and allowing to reproduce through the general function without having to create new methods to the video library. @type item: item @param item: item with information """ def get_played_time(item): if item.contentType == 'movie': nfo_path = item.nfo else: nfo_path = item.strm_path.replace('strm', 'nfo') if nfo_path and filetools.isfile(nfo_path): from core import videolibrarytools head_nfo, item_nfo = videolibrarytools.read_nfo(nfo_path) sleep(1) played_time = platformtools.get_played_time(item_nfo) else: played_time = 0 return played_time import xbmcgui, xbmcplugin, xbmc from time import sleep # logger.debug("item: \n" + item.tostring('\n')) platformtools.prevent_busy(item) itemlist = [] item.fromLibrary = True item.window = True logger.debug() # Modify the action (currently the video library needs "findvideos" since this is where the sources are searched item.action = "findvideos" window_type = config.get_setting("window_type", "videolibrary") # and launch kodi again if xbmc.getCondVisibility('Window.IsMedia') and not window_type == 1: xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")") else: # Pop-up window from specials import videolibrary p_dialog = platformtools.dialog_progress_bg( config.get_localized_string(20000), config.get_localized_string(60683)) p_dialog.update(0, '') item.play_from = 'window' itemlist = videolibrary.findvideos(item) p_dialog.update(100, '') sleep(0.5) p_dialog.close() played = False # The number of links to show is limited if config.get_setting("max_links", "videolibrary") != 0: itemlist = limit_itemlist(itemlist) # The list of links is slightly "cleaned" if config.get_setting("replace_VD", "videolibrary") == 1: itemlist = reorder_itemlist(itemlist) # from core.support import dbg;dbg() if len(itemlist) > 0: reopen = False while not xbmc.Monitor().abortRequested(): played = True # The user chooses the mirror if not platformtools.is_playing(): # from core.support import dbg;dbg() if config.get_setting('autoplay') or reopen: played_time = get_played_time(item) if not played_time and played: return options = [] selection_implementation = 0 for item in itemlist: item.thumbnail = config.get_online_server_thumb( item.server) quality = '[B][' + item.quality + '][/B]' if item.quality else '' if item.server: path = filetools.join( config.get_runtime_path(), 'servers', item.server.lower() + '.json') name = jsontools.load(open(path, "r").read())['name'] if name.startswith('@'): name = config.get_localized_string( int(name.replace('@', ''))) it = xbmcgui.ListItem( '\n[B]%s[/B] %s - %s' % (name, quality, item.contentTitle)) it.setArt({'thumb': item.thumbnail}) options.append(it) else: selection_implementation += 1 # The selection window opens if (item.contentSerieName and item.contentSeason and item.contentEpisodeNumber): head = ("%s - %sx%s | %s" % (item.contentSerieName, item.contentSeason, item.contentEpisodeNumber, config.get_localized_string(30163))) else: head = config.get_localized_string(30163) selection = platformtools.dialog_select(head, options, preselect=-1, useDetails=True) if selection == -1: return else: item = videolibrary.play( itemlist[selection + selection_implementation])[0] platformtools.play_video(item) reopen = True
def run(): logger.info("pelisalacarta.platformcode.launcher run") # Extract item from sys.argv if sys.argv[2]: item = Item().fromurl(sys.argv[2]) # If no item, this is mainlist else: item = Item(channel="channelselector", action="getmainlist", viewmode="movie") logger.info("pelisalacarta.platformcode.launcher "+item.tostring()) try: # If item has no action, stops here if item.action == "": logger.info("pelisalacarta.platformcode.launcher Item sin accion") return # Action for main menu in channelselector if item.action == "getmainlist": import channelselector itemlist = channelselector.getmainlist() # Check for updates only on first screen if config.get_setting("updatecheck2") == "true": logger.info("pelisalacarta.platformcode.launcher Check for plugin updates enabled") from core import updater try: version = updater.checkforupdates() if version: platformtools.dialog_ok("Versión "+version+" disponible", "Ya puedes descargar la nueva versión del plugin\n" "desde el listado principal") itemlist.insert(0, Item(title="Descargar version "+version, version=version, channel="updater", action="update", thumbnail=channelselector.get_thumbnail_path() + "Crystal_Clear_action_info.png")) except: platformtools.dialog_ok("No se puede conectar", "No ha sido posible comprobar", "si hay actualizaciones") logger.info("cpelisalacarta.platformcode.launcher Fallo al verificar la actualización") else: logger.info("pelisalacarta.platformcode.launcher Check for plugin updates disabled") platformtools.render_items(itemlist, item) # Action for updating plugin elif item.action == "update": from core import updater updater.update(item) if config.get_system_platform() != "xbox": import xbmc xbmc.executebuiltin("Container.Refresh") # Action for channel types on channelselector: movies, series, etc. elif item.action == "getchanneltypes": import channelselector itemlist = channelselector.getchanneltypes() platformtools.render_items(itemlist, item) # Action for channel listing on channelselector elif item.action == "filterchannels": import channelselector itemlist = channelselector.filterchannels(item.channel_type) platformtools.render_items(itemlist, item) # Special action for playing a video from the library elif item.action == "play_from_library": play_from_library(item) return # Action in certain channel specified in "action" and "channel" parameters else: # Entry point for a channel is the "mainlist" action, so here we check parental control if item.action == "mainlist": # Parental control can_open_channel = False # If it is an adult channel, and user has configured pin, asks for it if channeltools.is_adult(item.channel) and config.get_setting("adult_pin") != "": tecleado = platformtools.dialog_input("", "PIN para canales de adultos", True) if tecleado is not None: if tecleado == config.get_setting("adult_pin"): can_open_channel = True # All the other cases can open the channel else: can_open_channel = True if not can_open_channel: return # Checks if channel exists channel_file = os.path.join(config.get_runtime_path(), 'channels', item.channel+".py") logger.info("pelisalacarta.platformcode.launcher channel_file=%s" % channel_file) channel = None if item.channel in ["personal", "personal2", "personal3", "personal4", "personal5"]: import channels.personal as channel elif os.path.exists(channel_file): try: channel = __import__('channels.%s' % item.channel, None, None, ["channels.%s" % item.channel]) except ImportError: exec "import channels."+item.channel+" as channel" logger.info("pelisalacarta.platformcode.launcher running channel "+channel.__name__+" "+channel.__file__) # Special play action if item.action == "play": logger.info("pelisalacarta.platformcode.launcher play") # logger.debug("item_toPlay: " + "\n" + item.tostring('\n')) # First checks if channel has a "play" function if hasattr(channel, 'play'): logger.info("pelisalacarta.platformcode.launcher executing channel 'play' method") itemlist = channel.play(item) b_favourite = item.isFavourite # Play should return a list of playable URLS if len(itemlist) > 0: item = itemlist[0] if b_favourite: item.isFavourite = True platformtools.play_video(item) # If not, shows user an error message else: platformtools.dialog_ok("plugin", "No hay nada para reproducir") # If player don't have a "play" function, not uses the standard play from platformtools else: logger.info("pelisalacarta.platformcode.launcher executing core 'play' method") platformtools.play_video(item) # Special action for findvideos, where the plugin looks for known urls elif item.action == "findvideos": # First checks if channel has a "findvideos" function if hasattr(channel, 'findvideos'): itemlist = getattr(channel, item.action)(item) # If not, uses the generic findvideos function else: logger.info("pelisalacarta.platformcode.launcher no channel 'findvideos' method, " "executing core method") from core import servertools itemlist = servertools.find_video_items(item) if config.get_setting('filter_servers') == 'true': itemlist = filtered_servers(itemlist) from platformcode import subtitletools subtitletools.saveSubtitleName(item) platformtools.render_items(itemlist, item) # Special action for adding a movie to the library elif item.action == "add_pelicula_to_library": library.add_pelicula_to_library(item) # Special action for adding a serie to the library elif item.action == "add_serie_to_library": library.add_serie_to_library(item, channel) # Special action for downloading all episodes from a serie elif item.action == "download_all_episodes": from channels import descargas item.action = item.extra del item.extra descargas.save_download(item) # Special action for searching, first asks for the words then call the "search" function elif item.action == "search": logger.info("pelisalacarta.platformcode.launcher search") tecleado = platformtools.dialog_input("") if tecleado is not None: tecleado = tecleado.replace(" ", "+") # TODO revisar 'personal.py' porque no tiene función search y daría problemas itemlist = channel.search(item, tecleado) else: itemlist = [] platformtools.render_items(itemlist, item) # For all other actions else: logger.info("pelisalacarta.platformcode.launcher executing channel '"+item.action+"' method") itemlist = getattr(channel, item.action)(item) platformtools.render_items(itemlist, item) except urllib2.URLError, e: import traceback logger.error("pelisalacarta.platformcode.launcher "+traceback.format_exc()) # Grab inner and third party errors if hasattr(e, 'reason'): logger.info("pelisalacarta.platformcode.launcher Razon del error, codigo: "+str(e.reason[0])+", Razon: " + str(e.reason[1])) texto = config.get_localized_string(30050) # "No se puede conectar con el sitio web" platformtools.dialog_ok("plugin", texto) # Grab server response errors elif hasattr(e, 'code'): logger.info("pelisalacarta.platformcode.launcher codigo de error HTTP : %d" % e.code) # "El sitio web no funciona correctamente (error http %d)" platformtools.dialog_ok("plugin", config.get_localized_string(30051) % e.code)