def play_video(item, strm=False): logger.info("deportesalacarta.platformcode.platformtools play_video") #logger.debug(item.tostring('\n')) if item.channel == 'descargas': logger.info("Reproducir video local: %s [%s]" % (item.title, item.url)) playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) playlist.clear() playlist.add(item.url) xbmc.Player().play(playlist) return default_action = config.get_setting("default_action") logger.info("default_action=" + default_action) # Abre el diálogo de selección para ver las opciones disponibles opciones, video_urls, seleccion, salir = get_dialogo_opciones( item, default_action, strm) if salir: return # se obtienen la opción predeterminada de la configuración del addon seleccion = get_seleccion(default_action, opciones, seleccion, video_urls) if seleccion < 0: # Cuadro cancelado return logger.info("seleccion=%d" % seleccion) logger.info("seleccion=%s" % opciones[seleccion]) # se ejecuta la opcion disponible, jdwonloader, descarga, favoritos, añadir a la biblioteca... SI NO ES PLAY salir = set_opcion(item, seleccion, opciones, video_urls) if salir: return # obtenemos el video seleccionado mediaurl, view, mpd = get_video_seleccionado(item, seleccion, video_urls) if mediaurl == "": return # se obtiene la información del video. xlistitem = xbmcgui.ListItem(path=mediaurl, thumbnailImage=item.thumbnail) set_infolabels(xlistitem, item) if mpd: xlistitem.setProperty('inputstreamaddon', 'inputstream.adaptive') xlistitem.setProperty('inputstream.adaptive.manifest_type', 'mpd') # se lanza el reproductor info = False if "_ventana" in opciones[seleccion]: info = True set_player(item, xlistitem, mediaurl, view, strm, info) # si es un archivo de la biblioteca enviar a marcar como visto if strm or item.strm_path: from platformcode import library library.mark_auto_as_watched(item)
def is_server_enabled(server): try: server_parameters = get_server_parameters(server) if server_parameters["active"] == "true": if not config.get_setting("hidepremium")=="true": return True else: if server_parameters["free"] == "true": return True if [premium for premium in server_parameters["premium"] if config.get_setting(premium+"premium")=="true"]: return True else: return False else: return False except: import traceback logger.info(traceback.format_exc()) return False
def start(): tecla_guardada = config.get_setting("keymap_edit", "editor_keymap") nuevakey = KeyListener().record_key() if nuevakey and tecla_guardada != nuevakey: from resources.lib.httpkir import filetools from platformcode import platformtools import xbmc file_xml = "special://profile/keymaps/deportesalacarta.xml" data = '<keymap><global><keyboard><key id="%s">' % nuevakey + 'runplugin(plugin://' \ 'plugin.video.dss/?ewogICAgImFjdGlvbiI6ICJzdGFydCIsIAogICAgImNoYW5uZWwiOiAibWF0Y2hjZ' \ 'W50ZXIiLCAKICAgICJpbmZvTGFiZWxzIjoge30KfQ%3D%3D))</key></keyboard></global></keymap>' filetools.write(xbmc.translatePath(file_xml), data) platformtools.dialog_notification( "Tecla guardada", "Reinicia Kodi para que se apliquen los cambios") from resources.lib.httpkir import scrapertools config.set_setting("keymap_edit", nuevakey, "editor_keymap") file_idioma = filetools.join(config.get_runtime_path(), 'resources', 'language', 'Spanish', 'strings.xml') data = filetools.read(file_idioma) value_xml = scrapertools.find_single_match( data, '<string id="31100">([^<]+)<') if "tecla" in value_xml: data = data.replace( value_xml, 'Cambiar tecla/botón para abrir la ventana (Guardada: %s)' % nuevakey) elif "key" in value_xml: data = data.replace( value_xml, 'Change key/button to open the window (Saved: %s)' % nuevakey) else: data = data.replace( value_xml, 'Cambiamento di chiave/pulsante per aprire la finestra (Salvato: %s)' % nuevakey) filetools.write(file_idioma, data) return
def run(): logger.info("dss.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") if item.action != "actualiza": logger.info("dss.platformcode.launcher " + item.tostring()) try: if item.action == "editor_keymap": from platformcode import editor_keymap return editor_keymap.start() # If item has no action, stops here if item.action == "": logger.info("dss.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("updatecheck") == "true": logger.info("Check for plugin updates enabled") from core import updater try: update, version_publicada, message, url_repo, serv = updater.check( ) if update: new_item = Item( title="Descargar versión " + version_publicada, channel="updater", action="actualiza", thumbnail=channelselector.get_thumbnail_path() + "Crystal_Clear_action_info.png", version=version_publicada, url=url_repo, server=serv) if config.get_setting("updateauto") == "true": updater.actualiza(new_item) new_item = Item( title= "Info para ver los cambios en la nueva versión instalada", plot=message, action="", channel="", thumbnail=channelselector.get_thumbnail_path() + "Crystal_Clear_action_info.png", text_color="red") itemlist.insert(0, new_item) else: platformtools.dialog_ok( "Versión " + version_publicada + " disponible", message) itemlist.insert(0, new_item) except: import traceback logger.info(traceback.format_exc()) logger.info( "dss.platformcode.launcher Fallo al verificar la actualización" ) else: logger.info( "dss.platformcode.launcher Check for plugin updates disabled" ) if not config.get_setting("primer_uso_matchcenter"): config.set_setting("primer_uso_matchcenter", "true") platformtools.dialog_ok( "MatchCenter activado", "Reinicia Kodi para usarlo (pulsar tecla U)", "La tecla, botones y otras opciones pueden cambiarse en Configuración -> Preferencias -> MatchCenter" ) file_keyboard = xbmc.translatePath( "special://profile/keymaps/deportesalacarta.xml") if config.get_setting( "matchcenter_enabled" ) == "true" and not os.path.exists(file_keyboard): tecla = "61525" tecla_guardada = config.get_setting("keymap_edit", "editor_keymap") if tecla_guardada: tecla = tecla_guardada from core import filetools data = '<keymap><global><keyboard><key id="%s">' % tecla + 'runplugin(plugin://plugin.video.dss/?ewogICAgImFjdGlvbiI6ICJzdGFydCIsIAogICAgImNoYW5uZWwiOiAibWF0Y2hjZW50ZXIiLCAKICAgICJpbmZvTGFiZWxzIjoge30KfQ%3D%3D))</key></keyboard></global></keymap>' filetools.write(file_keyboard, data) elif config.get_setting( "matchcenter_enabled") == "false" and os.path.exists( file_keyboard): from core import filetools try: filetools.remove(file_keyboard) except: pass platformtools.render_items(itemlist, item) # Action for updating plugin elif item.action == "actualiza": from core import updater updater.actualiza(item) xbmc.executebuiltin("Container.Refresh") # Action for channel listing on channelselector elif item.action == "filterchannels": import channelselector itemlist = channelselector.filterchannels(item.channel_type) platformtools.render_items(itemlist, item) # Action in certain channel specified in "action" and "channel" parameters else: can_open_channel = True # Checks if channel exists channel_file = os.path.join(config.get_runtime_path(), 'channels', item.channel + ".py") logger.info("dss.platformcode.launcher 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( "deportesalacarta.platformcode.launcher running channel " + channel.__name__ + " " + channel.__file__) # Special play action if item.action == "play": logger.info("dss.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( "dss.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 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", "There is nothing to play") # If player don't have a "play" function, not uses the standard play from platformtools else: logger.info( "dss.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( "dss.platformcode.launcher no channel 'findvideos' method, " "executing core method") from core import servertools itemlist = servertools.find_video_items(item) platformtools.render_items(itemlist, item) # Special action for searching, first asks for the words then call the "search" function elif item.action == "search": logger.info("dss.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("dss.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("dss.platformcode.launcher " + traceback.format_exc()) # Grab inner and third party errors if hasattr(e, 'reason'): logger.info("dss.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("dss.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)
def play(url, xlistitem={}, is_view=None, subtitle=""): allocate = True try: import platform xbmc.log( "XXX KODI XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" ) xbmc.log("OS platform: %s %s" % (platform.system(), platform.release())) xbmc.log("xbmc/kodi version: %s" % xbmc.getInfoLabel("System.BuildVersion")) xbmc_version = int(xbmc.getInfoLabel("System.BuildVersion")[:2]) xbmc.log("xbmc/kodi version number: %s" % xbmc_version) xbmc.log( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX KODI XXXX" ) _platform = get_platform() if str(_platform['system']) in [ "android_armv7", "linux_armv6", "linux_armv7" ]: allocate = False # -- log ------------------------------------------------ xbmc.log( "XXX platform XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" ) xbmc.log("_platform['system']: %s" % _platform['system']) xbmc.log("allocate: %s" % allocate) xbmc.log( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX platform XXXX" ) # -- ---------------------------------------------------- except: pass DOWNLOAD_PATH = config.get_setting("downloadpath") # -- adfly: ------------------------------------ if url.startswith("http://adf.ly/"): try: data = scrapertools.downloadpage(url) url = decode_adfly(data) except: ddd = xbmcgui.Dialog() ddd.ok( "pelisalacarta-MCT: Sin soporte adf.ly", "El script no tiene soporte para el acortador de urls adf.ly.", "", "url: " + url) return # -- Necesario para algunas webs ---------------------------- if not url.endswith(".torrent") and not url.startswith("magnet"): t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file # -- Crear dos carpetas en descargas para los archivos ------ save_path_videos = os.path.join(DOWNLOAD_PATH, "torrent-videos") save_path_torrents = os.path.join(DOWNLOAD_PATH, "torrent-torrents") if not os.path.exists(save_path_torrents): os.mkdir(save_path_torrents) # -- Usar - archivo torrent desde web, magnet o HD --------- if not os.path.isfile(url) and not url.startswith("magnet"): # -- http - crear archivo torrent ----------------------- data = url_get(url) # -- El nombre del torrent será el que contiene en los -- # -- datos. - re_name = urllib.unquote( scrapertools.get_match(data, ':name\d+:(.*?)\d+:')) torrent_file = filetools.join(save_path_torrents, filetools.encode(re_name + '.torrent')) f = open(torrent_file, 'wb') f.write(data) f.close() elif os.path.isfile(url): # -- file - para usar torrens desde el HD --------------- torrent_file = url else: # -- magnet --------------------------------------------- torrent_file = url # ----------------------------------------------------------- # -- MCT - MiniClienteTorrent ------------------------------- ses = lt.session() # -- log ---------------------------------------------------- xbmc.log("### Init session ########") xbmc.log(lt.version) xbmc.log("#########################") # -- -------------------------------------------------------- ses.add_dht_router("router.bittorrent.com", 6881) ses.add_dht_router("router.utorrent.com", 6881) ses.add_dht_router("dht.transmissionbt.com", 6881) trackers = [ "udp://tracker.openbittorrent.com:80/announce", "http://tracker.torrentbay.to:6969/announce", "http://tracker.pow7.com/announce", "udp://tracker.ccc.de:80/announce", "udp://open.demonii.com:1337", "http://9.rarbg.com:2710/announce", "http://bt.careland.com.cn:6969/announce", "http://explodie.org:6969/announce", "http://mgtracker.org:2710/announce", "http://tracker.best-torrents.net:6969/announce", "http://tracker.tfile.me/announce", "http://tracker1.wasabii.com.tw:6969/announce", "udp://9.rarbg.com:2710/announce", "udp://9.rarbg.me:2710/announce", "udp://coppersurfer.tk:6969/announce", "http://www.spanishtracker.com:2710/announce", "http://www.todotorrents.com:2710/announce", ] video_file = "" # -- magnet2torrent ----------------------------------------- if torrent_file.startswith("magnet"): try: import zlib btih = hex( zlib.crc32( scrapertools.get_match( torrent_file, 'magnet:\?xt=urn:(?:[A-z0-9:]+|)([A-z0-9]{32})')) & 0xffffffff) files = [ f for f in os.listdir(save_path_torrents) if os.path.isfile(os.path.join(save_path_torrents, f)) ] for file in files: if btih in os.path.basename(file): torrent_file = os.path.join(save_path_torrents, file) except: pass if torrent_file.startswith("magnet"): try: tempdir = tempfile.mkdtemp() except IOError: tempdir = os.path.join(save_path_torrents, "temp") if not os.path.exists(tempdir): os.mkdir(tempdir) params = { 'save_path': tempdir, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate, 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } h = lt.add_magnet_uri(ses, torrent_file, params) dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') while not h.has_metadata(): message, porcent, msg_file, s, download = getProgress( h, "Creando torrent desde magnet") dp.update(porcent, message, msg_file) if s.state == 1: download = 1 if dp.iscanceled(): dp.close() remove_files(download, torrent_file, video_file, ses, h) return h.force_dht_announce() xbmc.sleep(1000) dp.close() info = h.get_torrent_info() data = lt.bencode(lt.create_torrent(info).generate()) torrent_file = os.path.join( save_path_torrents, unicode(info.name() + "-" + btih, "'utf-8'", errors="replace") + ".torrent") f = open(torrent_file, 'wb') f.write(data) f.close() ses.remove_torrent(h) shutil.rmtree(tempdir) # ----------------------------------------------------------- # -- Archivos torrent --------------------------------------- e = lt.bdecode(open(torrent_file, 'rb').read()) info = lt.torrent_info(e) # -- El más gordo o uno de los más gordo se entiende que es - # -- el vídeo o es el vídeo que se usará como referencia - # -- para el tipo de archivo - xbmc.log("##### Archivos ## %s ##" % len(info.files())) _index_file, _video_file, _size_file = get_video_file(info) # -- Prioritarizar/Seleccionar archivo----------------------- _index, video_file, video_size, len_files = get_video_files_sizes(info) if len_files == 0: dp = xbmcgui.Dialog().ok( "No se puede reproducir", "El torrent no contiene ningún archivo de vídeo") if _index == -1: _index = _index_file video_file = _video_file video_size = _size_file _video_file_ext = os.path.splitext(_video_file)[1] xbmc.log("##### _video_file_ext ## %s ##" % _video_file_ext) if (_video_file_ext == ".avi" or _video_file_ext == ".mp4") and allocate: xbmc.log("##### storage_mode_t.storage_mode_allocate (" + _video_file_ext + ") #####") h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate }) else: xbmc.log("##### storage_mode_t.storage_mode_sparse (" + _video_file_ext + ") #####") h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_sparse }) allocate = True # ----------------------------------------------------------- # -- Descarga secuencial - trozo 1, trozo 2, ... ------------ h.set_sequential_download(True) h.force_reannounce() h.force_dht_announce() # -- Inicio de variables para 'pause' automático cuando el - # -- el vídeo se acerca a una pieza sin completar - is_greater_num_pieces = False is_greater_num_pieces_plus = False is_greater_num_pieces_pause = False porcent4first_pieces = int(video_size * 0.000000005) if porcent4first_pieces < 10: porcent4first_pieces = 10 if porcent4first_pieces > 100: porcent4first_pieces = 100 porcent4last_pieces = int(porcent4first_pieces / 2) num_pieces_to_resume = int(video_size * 0.0000000025) if num_pieces_to_resume < 5: num_pieces_to_resume = 5 if num_pieces_to_resume > 25: num_pieces_to_resume = 25 xbmc.log("##### porcent4first_pieces ## %s ##" % porcent4first_pieces) xbmc.log("##### porcent4last_pieces ## %s ##" % porcent4last_pieces) xbmc.log("##### num_pieces_to_resume ## %s ##" % num_pieces_to_resume) # -- Prioritarizar o seleccionar las piezas del archivo que - # -- se desea reproducir con 'file_priorities' - piece_set = set_priority_pieces(h, _index, video_file, video_size, porcent4first_pieces, porcent4last_pieces, allocate) # -- Crear diálogo de progreso para el primer bucle --------- dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') _pieces_info = {} # -- Doble bucle anidado ------------------------------------ # -- Descarga - Primer bucle - while not h.is_seed(): s = h.status() xbmc.sleep(100) # -- Recuperar los datos del progreso ------------------- message, porcent, msg_file, s, download = getProgress(h, video_file, _pf=_pieces_info) # -- Si hace 'checking' existe descarga ----------------- # -- 'download' Se usará para saber si hay datos - # -- descargados para el diálogo de 'remove_files' - if s.state == 1: download = 1 # -- Player - play -------------------------------------- # -- Comprobar si se han completado las piezas para el - # -- inicio del vídeo - first_pieces = True _c = 0 for i in range(piece_set[0], piece_set[porcent4first_pieces]): first_pieces &= h.have_piece(i) if h.have_piece(i): _c += 1 _pieces_info = { 'current': 0, 'continuous': "%s/%s" % (_c, porcent4first_pieces), 'continuous2': "", 'have': h.status().num_pieces, 'len': len(piece_set) } last_pieces = True if not allocate: _c = len(piece_set) - 1 _cc = 0 for i in range( len(piece_set) - porcent4last_pieces, len(piece_set)): last_pieces &= h.have_piece(i) if h.have_piece(i): _c -= 1 _cc += 1 _pieces_info['continuous2'] = "[%s/%s] " % (_cc, porcent4last_pieces) if is_view != "Ok" and first_pieces and last_pieces: _pieces_info['continuous2'] = "" xbmc.log("##### porcent [%.2f%%]" % (s.progress * 100)) is_view = "Ok" dp.close() # -- Player - Ver el vídeo -------------------------- playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) playlist.clear() ren_video_file = os.path.join(save_path_videos, video_file) try: playlist.add(ren_video_file, xlistitem) except: playlist.add(ren_video_file) if xbmc_version < 17: player = play_video(xbmc.PLAYER_CORE_AUTO) else: player = play_video() player.play(playlist) # -- Contador de cancelaciones para la ventana de - # -- 'pause' automático - is_greater_num_pieces_canceled = 0 continuous_pieces = 0 porcent_time = 0.00 current_piece = 0 set_next_continuous_pieces = porcent4first_pieces # -- Impedir que kodi haga 'resume' a un archivo ---- # -- que se reprodujo con anterioridad y que se - # -- eliminó para impedir que intente la reprucción - # -- en una pieza que aún no se ha completado y se - # -- active 'pause' automático - not_resume = True # -- Bandera subTítulos _sub = False # -- Segundo bucle - Player - Control de eventos ---- while player.isPlaying(): xbmc.sleep(100) # -- Añadir subTítulos if subtitle != "" and not _sub: _sub = True player.setSubtitles(subtitle) # -- Impedir que kodi haga 'resume' al inicio --- # -- de la descarga de un archivo conocido - if not_resume: player.seekTime(0) not_resume = False # -- Control 'pause' automático - continuous_pieces = count_completed_continuous_pieces( h, piece_set) if xbmc.Player().isPlaying(): # -- Porcentage del progreso del vídeo ------ player_getTime = player.getTime() player_getTotalTime = player.getTotalTime() porcent_time = player_getTime / player_getTotalTime * 100 # -- Pieza que se está reproduciendo -------- current_piece = int(porcent_time / 100 * len(piece_set)) # -- Banderas de control -------------------- is_greater_num_pieces = ( current_piece > continuous_pieces - num_pieces_to_resume) is_greater_num_pieces_plus = ( current_piece + porcent4first_pieces > continuous_pieces) is_greater_num_pieces_finished = ( current_piece + porcent4first_pieces >= len(piece_set)) # -- Activa 'pause' automático -------------- if is_greater_num_pieces and not player.paused and not is_greater_num_pieces_finished: is_greater_num_pieces_pause = True player.pause() if continuous_pieces >= set_next_continuous_pieces: set_next_continuous_pieces = continuous_pieces + num_pieces_to_resume next_continuous_pieces = str( continuous_pieces - current_piece) + "/" + str(set_next_continuous_pieces - current_piece) _pieces_info = { 'current': current_piece, 'continuous': next_continuous_pieces, 'continuous2': _pieces_info['continuous2'], 'have': h.status().num_pieces, 'len': len(piece_set) } # -- Cerrar el diálogo de progreso -------------- if player.resumed: dp.close() # -- Mostrar el diálogo de progreso ------------- if player.paused: # -- Crear diálogo si no existe ------------- if not player.statusDialogoProgress: dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') player.setDialogoProgress() # -- Diálogos de estado en el visionado ----- if not h.is_seed(): # -- Recuperar los datos del progreso --- message, porcent, msg_file, s, download = getProgress( h, video_file, _pf=_pieces_info) dp.update(porcent, message, msg_file) else: dp.update(100, "Descarga completa: " + video_file) # -- Se canceló el progreso en el visionado - # -- Continuar - if dp.iscanceled(): dp.close() player.pause() # -- Se canceló el progreso en el visionado - # -- en la ventana de 'pause' automático. - # -- Parar si el contador llega a 3 - if dp.iscanceled() and is_greater_num_pieces_pause: is_greater_num_pieces_canceled += 1 if is_greater_num_pieces_canceled == 3: player.stop() # -- Desactiva 'pause' automático y --------- # -- reinicia el contador de cancelaciones - if not dp.iscanceled( ) and not is_greater_num_pieces_plus and is_greater_num_pieces_pause: dp.close() player.pause() is_greater_num_pieces_pause = False is_greater_num_pieces_canceled = 0 # -- El usuario cancelo el visionado -------- # -- Terminar - if player.ended: # -- Diálogo eliminar archivos ---------- remove_files(download, torrent_file, video_file, ses, h) return # -- Kodi - Se cerró el visionado ----------------------- # -- Continuar | Terminar - if is_view == "Ok" and not xbmc.Player().isPlaying(): if info.num_files() == 1: # -- Diálogo continuar o terminar --------------- d = xbmcgui.Dialog() ok = d.yesno('pelisalacarta-MCT', 'XBMC-Kodi Cerró el vídeo.', '¿Continuar con la sesión?') else: ok = False # -- SI --------------------------------------------- if ok: # -- Continuar: --------------------------------- is_view = None else: # -- Terminar: ---------------------------------- # -- Comprobar si el vídeo pertenece a una ------ # -- lista de archivos - _index, video_file, video_size, len_files = get_video_files_sizes( info) if _index == -1 or len_files == 1: # -- Diálogo eliminar archivos -------------- remove_files(download, torrent_file, video_file, ses, h) return else: # -- Lista de archivos. Diálogo de opciones - piece_set = set_priority_pieces(h, _index, video_file, video_size, porcent4first_pieces, porcent4last_pieces, allocate) is_view = None dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') # -- Mostar progeso antes del visionado ----------------- if is_view != "Ok": dp.update(porcent, message, msg_file) # -- Se canceló el progreso antes del visionado --------- # -- Terminar - if dp.iscanceled(): dp.close() # -- Comprobar si el vídeo pertenece a una lista de - # -- archivos - _index, video_file, video_size, len_files = get_video_files_sizes( info) if _index == -1 or len_files == 1: # -- Diálogo eliminar archivos ------------------ remove_files(download, torrent_file, video_file, ses, h) return else: # -- Lista de archivos. Diálogo de opciones ----- piece_set = set_priority_pieces(h, _index, video_file, video_size, porcent4first_pieces, porcent4last_pieces, allocate) is_view = None dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') # -- Kodi - Error? - No debería llegar aquí ----------------- if is_view == "Ok" and not xbmc.Player().isPlaying(): dp.close() # -- Diálogo eliminar archivos -------------------------- remove_files(download, torrent_file, video_file, ses, h) return
def onInit(self): self.getControl(10004).setEnabled(False) self.getControl(10005).setEnabled(False) self.getControl(10006).setEnabled(False) self.ok_enabled = False self.default_enabled = False if xbmcgui.__version__ == "1.2": self.setCoordinateResolution(1) else: self.setCoordinateResolution(5) # Ponemos el título self.getControl(10002).setLabel(self.title) if self.custom_button is not None: if self.custom_button['visible']: self.getControl(10006).setLabel(self.custom_button['label']) else: self.getControl(10006).setVisible(False) self.getControl(10004).setPosition(self.getControl(10004).getPosition()[0] + 80, self.getControl(10004).getPosition()[1]) self.getControl(10005).setPosition(self.getControl(10005).getPosition()[0] + 80, self.getControl(10005).getPosition()[1]) # Obtenemos las dimensiones del area de controles self.controls_width = self.getControl(10007).getWidth() - 20 self.controls_height = self.getControl(10007).getHeight() self.controls_pos_x = self.getControl(10007).getPosition()[0] + self.getControl(10001).getPosition()[0] + 10 self.controls_pos_y = self.getControl(10007).getPosition()[1] + self.getControl(10001).getPosition()[1] self.height_control = 35 self.font = "font12" # En versiones antiguas: creamos 5 controles, de lo conrtario al hacer click al segundo control, # automaticamente cambia el label del tercero a "Short By: Name" no se porque... if xbmcgui.ControlEdit == ControlEdit: for x in range(5): control = xbmcgui.ControlRadioButton(-500, 0, 0, 0, "") self.addControl(control) for c in self.list_controls: # Saltamos controles que no tengan los valores adecuados if "type" not in c: continue if "label" not in c: continue if c["type"] != "label" and "id" not in c: continue if c["type"] == "list" and "lvalues" not in c: continue if c["type"] == "list" and not type(c["lvalues"]) == list: continue if c["type"] == "list" and not len(c["lvalues"]) > 0: continue if c["type"] != "label" and len([control.get("id") for control in self.list_controls if c["id"] == control.get("id")]) > 1: continue # Translation label y lvalues if c['label'].startswith('@') and unicode(c['label'][1:]).isnumeric(): c['label'] = config.get_localized_string(int(c['label'][1:])) if c['type'] == 'list': lvalues = [] for li in c['lvalues']: if li.startswith('@') and unicode(li[1:]).isnumeric(): lvalues.append(config.get_localized_string(int(li[1:]))) else: lvalues.append(li) c['lvalues'] = lvalues # Valores por defecto en caso de que el control no disponga de ellos if c["type"] == "bool" and "default" not in c: c["default"] = False if c["type"] == "text" and "default" not in c: c["default"] = "" if c["type"] == "text" and "hidden" not in c: c["hidden"] = False if c["type"] == "list" and "default" not in c: c["default"] = 0 if c["type"] == "label" and "id" not in c: c["id"] = None if "color" not in c: c["color"] = "0xFF0066CC" if "visible" not in c: c["visible"] = True if "enabled" not in c: c["enabled"] = True if c["type"] == "text" and not type(c["hidden"]) == bool: if c["hidden"].lower() == 'true': c["hidden"] = True else: c["hidden"] = False # Decidimos si usar el valor por defecto o el valor guardado if c["type"] in ["bool", "text", "list"]: if id not in self.values: if not self.callback: self.values[c["id"]] = config.get_setting(c["id"], self.channel) else: self.values[c["id"]] = c["default"] if c["type"] == "bool": c["default"] = bool(c["default"]) self.values[c["id"]] = bool(self.values[c["id"]]) if c["type"] == "bool": self.add_control_bool(c) elif c["type"] == 'text': self.add_control_text(c) elif c["type"] == 'list': self.add_control_list(c) elif c["type"] == 'label': self.add_control_label(c) self.list_controls = [c for c in self.list_controls if "control" in c] self.evaluate_conditions() self.index = -1 self.dispose_controls(0) self.getControl(100010).setVisible(False) self.getControl(10004).setEnabled(True) self.getControl(10005).setEnabled(True) self.getControl(10006).setEnabled(True) self.ok_enabled = True self.default_enabled = True self.check_default() self.check_ok(self.values)
def resolve_video_urls_for_playing(server,url,video_password="",muestra_dialogo=False,encode=False): if not encode: logger.info("deportesalacarta.core.servertools resolve_video_urls_for_playing, server="+server+", url="+url) video_urls = [] torrent = False server = server.lower() # Si el vídeo es "directo", no hay que buscar más if server=="directo" or server=="local": logger.info("deportesalacarta.core.servertools server=directo, la url es la buena") try: import urlparse parsed_url = urlparse.urlparse(url) logger.info("parsed_url="+str(parsed_url)) extension = parsed_url.path[-4:] except: extension = url[-4:] video_urls = [[ "%s [%s]" % (extension,server) , url ]] return video_urls,True,"" # Averigua las URL de los vídeos else: # Carga el conector try: if encode: return [base64.b64decode(url)], True, "" # Muestra un diágo de progreso if muestra_dialogo: from platformcode import platformtools progreso = platformtools.dialog_progress( "pelisalacarta" , "Conectando con "+server) server_parameters = get_server_parameters(server) #Cuenta las opciones disponibles, para calcular el porcentaje opciones = [] if server_parameters["free"] == "true": opciones.append("free") opciones.extend([premium for premium in server_parameters["premium"] if config.get_setting(premium+"premium")=="true"]) logger.info("deportesalacarta.core.servertools opciones disponibles para " + server + ": " + str(len(opciones)) + " "+str(opciones)) # Sustituye el código por otro "Plex compatible" #exec "from servers import "+server+" as server_connector" servers_module = __import__("servers."+server) server_connector = getattr(servers_module,server) if not encode: logger.info("deportesalacarta.core.servertools servidor de "+server+" importado") # Si tiene una función para ver si el vídeo existe, lo comprueba ahora if hasattr(server_connector, 'test_video_exists'): logger.info("deportesalacarta.core.servertools invocando a "+server+".test_video_exists") puedes,motivo = server_connector.test_video_exists( page_url=url ) # Si la funcion dice que no existe, fin if not puedes: logger.info("deportesalacarta.core.servertools test_video_exists dice que el video no existe") if muestra_dialogo: progreso.close() return video_urls,puedes,motivo else: logger.info("deportesalacarta.core.servertools test_video_exists dice que el video SI existe") # Obtiene enlaces free if server_parameters["free"]=="true": if muestra_dialogo: progreso.update((100 / len(opciones)) * opciones.index("free") , "Conectando con "+server) logger.info("deportesalacarta.core.servertools invocando a "+server+".get_video_url") video_urls = server_connector.get_video_url( page_url=url , video_password=video_password ) # Si no se encuentran vídeos en modo free, es porque el vídeo no existe if len(video_urls)==0: if muestra_dialogo: progreso.close() return video_urls,False,"No se puede encontrar el vídeo en "+server # Obtiene enlaces para las diferentes opciones premium error_message = [] for premium in server_parameters["premium"]: if config.get_setting(premium+"premium")=="true": if muestra_dialogo: progreso.update((100 / len(opciones)) * opciones.index(premium) , "Conectando con "+premium) exec "from servers import "+premium+" as premium_conector" if premium == "realdebrid": debrid_urls = premium_conector.get_video_url( page_url=url , premium=True , video_password=video_password ) if not "REAL-DEBRID:" in debrid_urls[0][0]: video_urls.extend(debrid_urls) else: error_message.append(debrid_urls[0][0]) elif premium == "alldebrid": alldebrid_urls = premium_conector.get_video_url( page_url=url , premium=True , user=config.get_setting(premium+"user") , password=config.get_setting(premium+"password"), video_password=video_password ) if not "Alldebrid:" in alldebrid_urls[0][0]: video_urls.extend(alldebrid_urls) else: error_message.append(alldebrid_urls[0][0]) else: video_urls.extend(premium_conector.get_video_url( page_url=url , premium=True , user=config.get_setting(premium+"user") , password=config.get_setting(premium+"password"), video_password=video_password )) if not video_urls and error_message: return video_urls, False, " || ".join(error_message) if muestra_dialogo: progreso.update( 100 , "Proceso finalizado") # Cierra el diálogo de progreso if muestra_dialogo: progreso.close() # Llegas hasta aquí y no tienes ningún enlace para ver, así que no vas a poder ver el vídeo if len(video_urls)==0: # ¿Cual es el motivo? # 1) No existe -> Ya está controlado # 2) No tienes alguna de las cuentas premium compatibles # Lista de las cuentas que soportan este servidor listapremium = [] for premium in server_parameters["premium"]: listapremium.append(get_server_parameters(premium)["name"]) return video_urls,False,"Para ver un vídeo en "+server+" necesitas<br/>una cuenta en "+" o ".join(listapremium) except: if muestra_dialogo: progreso.close() import traceback logger.info(traceback.format_exc()) return video_urls,False,"Se ha producido un error en<br/>el conector con "+server return video_urls,True,""
def render_items(itemlist, parent_item): """ Función encargada de mostrar el itemlist en kodi, se pasa como parametros el itemlist y el item del que procede @type itemlist: list @param itemlist: lista de elementos a mostrar @type parent_item: item @param parent_item: elemento padre """ # Si el itemlist no es un list salimos if not type(itemlist) == list: if config.get_platform() == "boxee": xbmcplugin.endOfDirectory(handle=int(sys.argv[1]), succeeded=True) return # Si no hay ningun item, mostramos un aviso if not len(itemlist): itemlist.append(Item(title="There are no items to show")) # Recorremos el itemlist for item in itemlist: # Si el item no contiene categoria,le ponemos la del item padre if item.category == "": item.category = parent_item.category # Si el item no contiene fanart,le ponemos la del item padre if item.fanart == "": item.fanart = parent_item.fanart # Formatear titulo if item.text_color: item.title = '[COLOR %s]%s[/COLOR]' % (item.text_color, item.title) if item.text_blod: item.title = '[B]%s[/B]' % item.title if item.text_italic: item.title = '[I]%s[/I]' % item.title # IconImage para folder y video if item.folder: icon_image = "DefaultFolder.png" else: icon_image = "DefaultVideo.png" # Creamos el listitem listitem = xbmcgui.ListItem(item.title, iconImage=icon_image, thumbnailImage=item.thumbnail) # Ponemos el fanart if item.fanart: listitem.setProperty('fanart_image', item.fanart) else: listitem.setProperty( 'fanart_image', os.path.join(config.get_runtime_path(), "fanart.jpg")) # TODO: ¿Se puede eliminar esta linea? yo no he visto que haga ningun efecto. xbmcplugin.setPluginFanart( int(sys.argv[1]), os.path.join(config.get_runtime_path(), "fanart.jpg")) # Añadimos los infoLabels set_infolabels(listitem, item) # Montamos el menu contextual context_commands = set_context_commands(item, parent_item) # Añadimos el item if config.get_platform() == "boxee": xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url='%s?%s' % (sys.argv[0], item.tourl()), listitem=listitem, isFolder=item.folder) else: listitem.addContextMenuItems(context_commands, replaceItems=True) if not item.totalItems: item.totalItems = 0 xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url='%s?%s' % (sys.argv[0], item.tourl()), listitem=listitem, isFolder=item.folder, totalItems=item.totalItems) # Vista 5x3 hasta llegar al listado de canales if parent_item.channel not in ["channelselector", ""]: xbmcplugin.setContent(int(sys.argv[1]), "movies") # Fijamos el "breadcrumb" xbmcplugin.setPluginCategory(handle=int(sys.argv[1]), category=parent_item.category.capitalize()) # No ordenar items xbmcplugin.addSortMethod(handle=int(sys.argv[1]), sortMethod=xbmcplugin.SORT_METHOD_NONE) # Viewmodes: # Creo que es mas lógico que al item se le especifique que vista tendra al abrirlo. # El cambio puede provocar que algun canal no muestre los items en la vista deseada, pero es mejor ir corrigiendolo # que arrastrar algo que no tiene sentido if config.get_setting("forceview") == "true": if parent_item.viewmode == "list": xbmc.executebuiltin("Container.SetViewMode(50)") elif parent_item.viewmode == "movie_with_plot": xbmc.executebuiltin("Container.SetViewMode(503)") elif parent_item.viewmode == "movie": xbmc.executebuiltin("Container.SetViewMode(500)") # Cerramos el directorio xbmcplugin.endOfDirectory(handle=int(sys.argv[1]), succeeded=True)
def play_torrent(item, xlistitem, mediaurl): logger.info("platformtools play_torrent") # Opciones disponibles para Reproducir torrents torrent_options = list() torrent_options.append(["Cliente interno (necesario libtorrent)"]) torrent_options.append(["Cliente interno MCT (necesario libtorrent)"]) # Plugins externos se pueden añadir otros if xbmc.getCondVisibility('System.HasAddon("plugin.video.xbmctorrent")'): torrent_options.append([ "Plugin externo: xbmctorrent", "plugin://plugin.video.xbmctorrent/play/%s" ]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.pulsar")'): torrent_options.append([ "Plugin externo: pulsar", "plugin://plugin.video.pulsar/play?uri=%s" ]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.quasar")'): torrent_options.append([ "Plugin externo: quasar", "plugin://plugin.video.quasar/play?uri=%s" ]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.stream")'): torrent_options.append( ["Plugin externo: stream", "plugin://plugin.video.stream/play/%s"]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.torrenter")'): torrent_options.append([ "Plugin externo: torrenter", "plugin://plugin.video.torrenter/?action=playSTRM&url=%s" ]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.torrentin")'): torrent_options.append([ "Plugin externo: torrentin", "plugin://plugin.video.torrentin/?uri=%s&image=" ]) if len(torrent_options) > 1: seleccion = dialog_select("Abrir torrent con...", [opcion[0] for opcion in torrent_options]) else: seleccion = 0 # Plugins externos if seleccion > 1: mediaurl = urllib.quote_plus(item.url) xbmc.executebuiltin("PlayMedia(" + torrent_options[seleccion][1] % mediaurl + ")") if seleccion == 1: from platformcode import mct mct.play(mediaurl, xlistitem, subtitle=item.subtitle) # Reproductor propio (libtorrent) if seleccion == 0: import time played = False debug = (config.get_setting("debug") == "true") # Importamos el cliente from btserver import Client # Iniciamos el cliente: c = Client(url=mediaurl, is_playing_fnc=xbmc.Player().isPlaying, wait_time=None, timeout=10, temp_path=os.path.join(config.get_data_path(), "torrent"), print_status=debug) # Mostramos el progreso progreso = dialog_progress("Pelisalacarta - Torrent", "Iniciando...") # Mientras el progreso no sea cancelado ni el cliente cerrado while not c.closed: try: # Obtenemos el estado del torrent s = c.status if debug: # Montamos las tres lineas con la info del torrent txt = '%.2f%% de %.1fMB %s | %.1f kB/s' % \ (s.progress_file, s.file_size, s.str_state, s._download_rate) txt2 = 'S: %d(%d) P: %d(%d) | DHT:%s (%d) | Trakers: %d' % \ (s.num_seeds, s.num_complete, s.num_peers, s.num_incomplete, s.dht_state, s.dht_nodes, s.trackers) txt3 = 'Origen Peers TRK: %d DHT: %d PEX: %d LSD %d ' % \ (s.trk_peers, s.dht_peers, s.pex_peers, s.lsd_peers) else: txt = '%.2f%% de %.1fMB %s | %.1f kB/s' % \ (s.progress_file, s.file_size, s.str_state, s._download_rate) txt2 = 'S: %d(%d) P: %d(%d)' % ( s.num_seeds, s.num_complete, s.num_peers, s.num_incomplete) try: txt3 = 'Deteniendo automaticamente en: %ss' % (int( s.timeout)) except: txt3 = '' progreso.update(s.buffer, txt, txt2, txt3) time.sleep(0.5) if progreso.iscanceled(): progreso.close() if s.buffer == 100: if dialog_yesno("Pelisalacarta - Torrent", "¿Deseas iniciar la reproduccion?"): played = False progreso = dialog_progress( "Pelisalacarta - Torrent", "") progreso.update(s.buffer, txt, txt2, txt3) else: progreso = dialog_progress( "Pelisalacarta - Torrent", "") break else: if dialog_yesno("Pelisalacarta - Torrent", "¿Deseas cancelar el proceso?"): progreso = dialog_progress( "Pelisalacarta - Torrent", "") break else: progreso = dialog_progress( "Pelisalacarta - Torrent", "") progreso.update(s.buffer, txt, txt2, txt3) # Si el buffer se ha llenado y la reproduccion no ha sido iniciada, se inicia if s.buffer == 100 and not played: # Cerramos el progreso progreso.close() # Obtenemos el playlist del torrent videourl = c.get_play_list() # Iniciamos el reproductor playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) playlist.clear() playlist.add(videourl, xlistitem) xbmc_player = xbmc.Player() xbmc_player.play(playlist) # Marcamos como reproducido para que no se vuelva a iniciar played = True # Y esperamos a que el reproductor se cierre while xbmc.Player().isPlaying(): time.sleep(1) # Cuando este cerrado, Volvemos a mostrar el dialogo progreso = dialog_progress("Pelisalacarta - Torrent", "") progreso.update(s.buffer, txt, txt2, txt3) except: import traceback logger.info(traceback.format_exc()) break progreso.update(100, "Terminando y eliminando datos", " ", " ") # Detenemos el cliente if not c.closed: c.stop() # Y cerramos el progreso progreso.close()
def set_player(item, xlistitem, mediaurl, view, strm, info): logger.info("platformtools set_player") logger.debug("item:\n" + item.tostring('\n')) # Movido del conector "torrent" aqui if item.server == "torrent": play_torrent(item, xlistitem, mediaurl) return # Si es un fichero strm no hace falta el play elif strm: xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xlistitem) if item.subtitle != "": xbmc.sleep(2000) xbmc.Player().setSubtitles(item.subtitle) else: logger.info("player_mode=" + config.get_setting("player_mode")) logger.info("mediaurl=" + mediaurl) if item.server == "p2p" and info: from platformcode import windowinfo return windowinfo.start(item, xlistitem, mediaurl) elif config.get_setting( "player_mode") == "3" or "megacrypter.com" in mediaurl: import download_and_play download_and_play.download_and_play( mediaurl, "download_and_play.tmp", config.get_setting("downloadpath")) return elif config.get_setting("player_mode") == "0" or \ (config.get_setting("player_mode") == "3" and mediaurl.startswith("rtmp")): # Añadimos el listitem a una lista de reproducción (playlist) playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) playlist.clear() playlist.add(mediaurl, xlistitem) # Reproduce playersettings = config.get_setting('player_type') logger.info( "deportesalacarta.platformcode.platformstools playersettings=" + playersettings) if config.get_system_platform() == "xbox": player_type = xbmc.PLAYER_CORE_AUTO if playersettings == "0": player_type = xbmc.PLAYER_CORE_AUTO logger.info( "deportesalacarta.platformcode.platformstools PLAYER_CORE_AUTO" ) elif playersettings == "1": player_type = xbmc.PLAYER_CORE_MPLAYER logger.info( "deportesalacarta.platformcode.platformstools PLAYER_CORE_MPLAYER" ) elif playersettings == "2": player_type = xbmc.PLAYER_CORE_DVDPLAYER logger.info( "deportesalacarta.platformcode.platformstools PLAYER_CORE_DVDPLAYER" ) xbmc_player = xbmc.Player(player_type) else: xbmc_player = xbmc.Player() xbmc_player.play(playlist, xlistitem) elif config.get_setting("player_mode") == "1": logger.info("mediaurl :" + mediaurl) logger.info("Tras setResolvedUrl") xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xbmcgui.ListItem(path=mediaurl)) elif config.get_setting("player_mode") == "2": xbmc.executebuiltin("PlayMedia(" + mediaurl + ")") # TODO MIRAR DE QUITAR VIEW if item.subtitle != "" and view: logger.info("Subtítulos externos: " + item.subtitle) xbmc.sleep(2000) xbmc.Player().setSubtitles(item.subtitle)
def set_opcion(item, seleccion, opciones, video_urls): logger.info("platformtools set_opcion") # logger.debug(item.tostring('\n')) salir = False # No ha elegido nada, lo más probable porque haya dado al ESC # TODO revisar if seleccion == -1: # Para evitar el error "Uno o más elementos fallaron" al cancelar la selección desde fichero strm listitem = xbmcgui.ListItem(item.title, iconImage="DefaultVideo.png", thumbnailImage=item.thumbnail) xbmcplugin.setResolvedUrl(int(sys.argv[1]), False, listitem) # "Enviar a JDownloader" if opciones[seleccion] == config.get_localized_string(30158): from core import scrapertools # TODO comprobar que devuelve 'data' if item.subtitle != "": data = scrapertools.cachePage( config.get_setting("jdownloader") + "/action/add/links/grabber0/start1/web=" + item.url + " " + item.thumbnail + " " + item.subtitle) else: data = scrapertools.cachePage( config.get_setting("jdownloader") + "/action/add/links/grabber0/start1/web=" + item.url + " " + item.thumbnail) salir = True elif opciones[seleccion] == config.get_localized_string( 30164): # Borrar archivo en descargas # En "extra" está el nombre del fichero en favoritos os.remove(item.url) xbmc.executebuiltin("Container.Refresh") salir = True # Descargar elif opciones[seleccion] == config.get_localized_string( 30153): # "Descargar" download_title = item.fulltitle if item.hasContentDetails == "true": download_title = item.contentTitle # El vídeo de más calidad es el último mediaurl = video_urls[len(video_urls) - 1][1] from core import downloadtools keyboard = xbmc.Keyboard(download_title) keyboard.doModal() if (keyboard.isConfirmed()): download_title = keyboard.getText() devuelve = downloadtools.downloadbest(video_urls, download_title) if devuelve == 0: advertencia = xbmcgui.Dialog() resultado = advertencia.ok("plugin", "Descargado con éxito") elif devuelve == -1: advertencia = xbmcgui.Dialog() resultado = advertencia.ok("plugin", "Descarga abortada") else: advertencia = xbmcgui.Dialog() resultado = advertencia.ok("plugin", "Error en la descarga") salir = True elif opciones[seleccion] == config.get_localized_string( 30159): #"Borrar descarga definitivamente" from channels import descargas descargas.delete_error_bookmark(urllib.unquote_plus(item.extra)) advertencia = xbmcgui.Dialog() resultado = advertencia.ok( config.get_localized_string(30101), item.title, config.get_localized_string(30106)) # 'Se ha quitado de la lista' xbmc.executebuiltin("Container.Refresh") salir = True elif opciones[seleccion] == config.get_localized_string( 30160): #"Pasar de nuevo a lista de descargas": from channels import descargas descargas.mover_descarga_error_a_pendiente( urllib.unquote_plus(item.extra)) advertencia = xbmcgui.Dialog() resultado = advertencia.ok( config.get_localized_string(30101), item.title, config.get_localized_string( 30107)) # 'Ha pasado de nuevo a la lista de descargas' salir = True # "Quitar de favoritos" elif opciones[seleccion] == config.get_localized_string(30154): from channels import favoritos favoritos.delFavourite(item) salir = True # "Añadir a favoritos": elif opciones[seleccion] == config.get_localized_string(30155): from channels import favoritos item.from_channel = "favoritos" favoritos.addFavourite(item) salir = True elif opciones[seleccion] == config.get_localized_string( 30156): #"Quitar de lista de descargas": # La categoría es el nombre del fichero en la lista de descargas from channels import descargas descargas.deletebookmark((urllib.unquote_plus(item.extra))) advertencia = xbmcgui.Dialog() resultado = advertencia.ok( config.get_localized_string(30101), item.title, config.get_localized_string( 30106)) # 'Se ha quitado de lista de descargas' xbmc.executebuiltin("Container.Refresh") salir = True elif opciones[seleccion] == config.get_localized_string( 30157): #"Añadir a lista de descargas": from core import downloadtools download_title = item.fulltitle download_thumbnail = item.thumbnail download_plot = item.plot if item.hasContentDetails == "true": download_title = item.contentTitle download_thumbnail = item.contentThumbnail download_plot = item.contentPlot keyboard = xbmc.Keyboard( downloadtools.limpia_nombre_excepto_1(download_title)) keyboard.doModal() if keyboard.isConfirmed(): download_title = keyboard.getText() from channels import descargas descargas.savebookmark(titulo=download_title, url=item.url, thumbnail=download_thumbnail, server=item.server, plot=download_plot, fulltitle=download_title) advertencia = xbmcgui.Dialog() resultado = advertencia.ok( config.get_localized_string(30101), download_title, config.get_localized_string( 30109)) # 'se ha añadido a la lista de descargas' salir = True return salir
def get_dialogo_opciones(item, default_action, strm): logger.info("platformtools get_dialogo_opciones") #logger.debug(item.tostring('\n')) from core import servertools opciones = [] error = False try: item.server = item.server.lower() except AttributeError: item.server = "" if item.server == "": item.server = "directo" # Si no es el modo normal, no muestra el diálogo porque cuelga XBMC muestra_dialogo = (config.get_setting("player_mode") == "0" and not strm) # Extrae las URL de los vídeos, y si no puedes verlo te dice el motivo #Permitir varias calidades para server "directo" if item.video_urls: video_urls, puedes, motivo = item.video_urls, True, "" else: video_urls, puedes, motivo = servertools.resolve_video_urls_for_playing( item.server, item.url, item.password, muestra_dialogo) seleccion = 0 # Si puedes ver el vídeo, presenta las opciones if puedes: for video_url in video_urls: opciones.append( config.get_localized_string(30151) + " " + video_url[0]) if item.server == "local": opciones.append(config.get_localized_string(30164)) else: opcion = config.get_localized_string(30153) opciones.append(opcion) # "Descargar" if item.channel == "favoritos": opciones.append(config.get_localized_string( 30154)) # "Quitar de favoritos" else: opciones.append( config.get_localized_string(30155)) # "Añadir a favoritos" if item.channel != "descargas": opciones.append(config.get_localized_string(30157)) else: if item.category == "errores": opciones.append(config.get_localized_string( 30159)) # "Borrar descarga definitivamente" opciones.append(config.get_localized_string( 30160)) # "Pasar de nuevo a lista de descargas" else: opciones.append(config.get_localized_string( 30156)) # "Quitar de lista de descargas" if config.get_setting("jdownloader_enabled") == "true": # "Enviar a JDownloader" opciones.append(config.get_localized_string(30158)) if default_action == "3": seleccion = len(opciones) - 1 # Si no puedes ver el vídeo te informa else: if item.server != "": if "<br/>" in motivo: dialog_ok("No puedes ver ese vídeo porque...", motivo.split("<br/>")[0], motivo.split("<br/>")[1], item.url) else: dialog_ok("No puedes ver ese vídeo porque...", motivo, item.url) else: dialog_ok("No puedes ver ese vídeo porque...", "El servidor donde está alojado no está", "soportado en pelisalacarta todavía", item.url) if item.channel == "favoritos": opciones.append( config.get_localized_string(30154)) # "Quitar de favoritos" if len(opciones) == 0: error = True return opciones, video_urls, seleccion, error
# version 2.0 # ------------------------------------------------------------ import re import os import sys import urllib import xbmc import xbmcgui import xbmcplugin from resources.lib.httpkir import config from resources.lib.httpkir import logger from resources.lib.httpkir.item import Item DEBUG = config.get_setting("debug") def dialog_ok(heading, line1, line2="", line3=""): dialog = xbmcgui.Dialog() return dialog.ok(heading, line1, line2, line3) def dialog_notification(heading, message, icon=0, time=5000, sound=True): dialog = xbmcgui.Dialog() l_icono = xbmcgui.NOTIFICATION_INFO, xbmcgui.NOTIFICATION_WARNING, xbmcgui.NOTIFICATION_ERROR dialog.notification(heading, message, l_icono[icon], time, sound) def dialog_yesno(heading, line1,