def bbcode_kodi2html(text):
if config.get_platform().startswith(
"plex") or config.get_platform().startswith("mediaserver"):
import re
text = re.sub(r'\[COLOR\s([^\]]+)\]', r'<span style="color: \1">',
text)
text = text.replace('[/COLOR]', '</span>')
text = text.replace('[CR]', '<br>')
text = re.sub(r'\[([^\]]+)\]', r'<\1>', text)
text = text.replace('"color: white"', '"color: auto"')
return text
def verify_Kodi_video_DB():
logger.info()
import random
platform = {}
path = ''
db_files = []
try:
path = filetools.join("special://masterprofile/", "Database")
if filetools.exists(path):
platform = config.get_platform(full_version=True)
if platform and platform.get('video_db', ''):
db_files = filetools.walk(path)
if filetools.exists(filetools.join(path, platform['video_db'])):
for root, folders, files in db_files:
for file in files:
if platform['video_db'] not in file:
if file.startswith('MyVideos'):
randnum = str(random.randrange(1, 999999))
filetools.rename(filetools.join(path, file), 'OLD_' + randnum +'_' + file)
logger.error('BD obsoleta: ' + file)
else:
logger.error('Video_DB: ' + str(platform['video_db']) + ' para versión Kodi ' + str(platform['num_version']) + ' NO EXISTE. Analizar carpeta: ' + str(db_files))
else:
logger.error('Estructura de get_platform(full_version=True) incorrecta')
else:
logger.error('Path a Userdata/Database (' + path + ') no encontrado')
except:
logger.error('Platform: ' + str(platform) + ' / Path: ' + str(path) + ' / Files: ' + str(db_files))
logger.error(traceback.format_exc())
return
def call_unrar(rar_control):
logger.info(rar_control['status'])
item = Item().fromurl(rar_control['item'])
mediaurl = rar_control['mediaurl']
rar_files = rar_control['rar_files']
torr_client = rar_control['torr_client']
password = rar_control['password']
size = rar_control['size']
# Creamos el listitem
xlistitem = xbmcgui.ListItem(path=item.url)
if config.get_platform(True)['num_version'] >= 16.0:
xlistitem.setArt({
'icon': item.thumbnail,
'thumb': item.thumbnail,
'poster': item.thumbnail,
'fanart': item.thumbnail
})
else:
xlistitem.setIconImage(item.thumbnail)
xlistitem.setThumbnailImage(item.thumbnail)
xlistitem.setProperty('fanart_image', item.thumbnail)
if config.get_setting("player_mode"):
xlistitem.setProperty('IsPlayable', 'true')
platformtools.set_infolabels(xlistitem, item)
return platformtools.rar_control_mng(item, xlistitem, mediaurl, rar_files, \
torr_client, password, size, rar_control)
def setting_channel(item):
if config.get_platform(
True
)['num_version'] >= 17.0: # A partir de Kodi 16 se puede usar multiselect, y de 17 con preselect
return setting_channel_new(item)
else:
return setting_channel_old(item)
def auth_trakt():
item = Item()
folder = (config.get_platform() == "plex")
item.folder = folder
# Autentificación de cuenta Trakt
headers = {'Content-Type': 'application/json', 'trakt-api-key': client_id, 'trakt-api-version': '2'}
try:
post = {'client_id': client_id}
post = jsontools.dump(post)
# Se solicita url y código de verificación para conceder permiso a la app
url = "http://api-v2launch.trakt.tv/oauth/device/code"
data = httptools.downloadpage(url, post=post, headers=headers, replace_headers=True).data
data = jsontools.load(data)
item.verify_url = data["verification_url"]
item.user_code = data["user_code"]
item.device_code = data["device_code"]
item.intervalo = data["interval"]
if not item.folder:
token_trakt(item)
else:
itemlist = []
title = "Accede a esta página: %s" % item.verify_url
itemlist.append(item.clone(title=title, action=""))
title = "Ingresa este código y acepta: %s" % item.user_code
itemlist.append(item.clone(title=title, action=""))
title = "Una vez hecho, pulsa aquí!"
itemlist.append(item.clone(title=title, action="token_trakt"))
return itemlist
except:
import traceback
logger.error(traceback.format_exc())
def check_addon_monitor():
logger.info()
# Obtiene el íntervalo entre actualizaciones y si se quieren mensajes
try:
timer = int(
config.get_setting('addon_update_timer')
) # Intervalo entre actualizaciones, en Ajustes de Alfa
if timer <= 0:
return # 0. No se quieren actualizaciones
verbose = config.get_setting('addon_update_message')
except:
timer = 12 # Por defecto cada 12 horas
verbose = False # Por defecto, sin mensajes
timer = timer * 3600 # Lo pasamos a segundos
if config.get_platform(
True)['num_version'] >= 14: # Si es Kodi, lanzamos el monitor
import xbmc
monitor = xbmc.Monitor()
else: # Lanzamos solo una actualización y salimos
check_addon_updates(verbose) # Lanza la actualización
return
while not monitor.abortRequested(
): # Loop infinito hasta cancelar Kodi
check_addon_updates(verbose) # Lanza la actualización
if monitor.waitForAbort(
timer
): # Espera el tiempo programado o hasta que cancele Kodi
break # Cancelación de Kodi, salimos
return
def check_addon_monitor():
logger.info()
# Obtiene el íntervalo entre actualizaciones y si se quieren mensajes
try:
timer = int(config.get_setting('addon_update_timer')) # Intervalo entre actualizaciones, en Ajustes de Alfa
if timer <= 0:
if base64.b64decode(config.get_setting('proxy_dev')).decode('utf-8') == 'user':
config.set_setting('addon_update_timer', 12) # Si es usuario se fuerza a 12 horas
timer = 12
else:
return # 0. No se quieren actualizaciones
verbose = config.get_setting('addon_update_message')
except:
logger.error(traceback.format_exc())
timer = 12 # Por defecto cada 12 horas
verbose = False # Por defecto, sin mensajes
timer = timer * 3600 # Lo pasamos a segundos
if config.get_platform(True)['num_version'] >= 14: # Si es Kodi, lanzamos el monitor
monitor = xbmc.Monitor()
else: # Lanzamos solo una actualización y salimos
check_addon_updates(verbose) # Lanza la actualización
return
while not monitor.abortRequested(): # Loop infinito hasta cancelar Kodi
check_addon_updates(verbose) # Lanza la actualización
if monitor.waitForAbort(timer): # Espera el tiempo programado o hasta que cancele Kodi
break # Cancelación de Kodi, salimos
check_update_to_others(verbose=False, app=False) # Actualizamos otros add-ons antes de irnos, para el siguiente inicio
return
def plugins_get_latest_packages():
logger.info()
parameters = {
"plugin": config.PLUGIN_NAME,
"platform": config.get_platform()
}
return remote_call("plugins/get_latest_packages.php", parameters)
def seguir(item):
logger.info()
data = httptools.downloadpage(item.url, item.post)
message = "Colección seguida"
if "Dejar" in item.title:
message = "La colección ya no se sigue"
if data.sucess and config.get_platform() != "plex":
platformtools.dialog_notification("Acción correcta", message)
def editar_enlace_thumbnail(item):
logger.info()
alfav = AlfavoritesData()
if not alfav.user_favorites[item.i_perfil]: return False
if not alfav.user_favorites[item.i_perfil]['items'][item.i_enlace]: return False
it = Item().fromurl(alfav.user_favorites[item.i_perfil]['items'][item.i_enlace])
# A partir de Kodi 17 se puede usar xbmcgui.Dialog().select con thumbnails (ListItem & useDetails=True)
is_kodi17 = (config.get_platform(True)['num_version'] >= 17.0)
if is_kodi17:
import xbmcgui
# Diálogo para escoger thumbnail (el del canal o iconos predefinidos)
opciones = []
ids = []
try:
from core import channeltools
channel_parameters = channeltools.get_channel_parameters(it.channel)
if channel_parameters['thumbnail'] != '':
nombre = 'Canal %s' % it.channel
if is_kodi17:
it_thumb = xbmcgui.ListItem(nombre)
it_thumb.setArt({ 'thumb': channel_parameters['thumbnail'] })
opciones.append(it_thumb)
else:
opciones.append(nombre)
ids.append(channel_parameters['thumbnail'])
except:
pass
resource_path = os.path.join(config.get_runtime_path(), 'resources', 'media', 'themes', 'default')
for f in sorted(os.listdir(resource_path)):
if f.startswith('thumb_') and not f.startswith('thumb_intervenido') and f != 'thumb_back.png':
nombre = f.replace('thumb_', '').replace('_', ' ').replace('.png', '')
if is_kodi17:
it_thumb = xbmcgui.ListItem(nombre)
it_thumb.setArt({ 'thumb': os.path.join(resource_path, f) })
opciones.append(it_thumb)
else:
opciones.append(nombre)
ids.append(os.path.join(resource_path, f))
if is_kodi17:
ret = xbmcgui.Dialog().select('Seleccionar thumbnail:', opciones, useDetails=True)
else:
ret = platformtools.dialog_select('Seleccionar thumbnail:', opciones)
if ret == -1: return False # pedido cancel
it.thumbnail = ids[ret]
alfav.user_favorites[item.i_perfil]['items'][item.i_enlace] = it.tourl()
alfav.save()
platformtools.itemlist_refresh()
return True
def editar_enlace_thumbnail(item):
logger.debug()
alfav = KodfavouritesData()
if not alfav.user_favorites[item.i_perfil]: return False
if not alfav.user_favorites[item.i_perfil]['items'][item.i_enlace]: return False
it = Item().fromurl(alfav.user_favorites[item.i_perfil]['items'][item.i_enlace])
# Starting with Kodi 17, you can use xbmcgui.Dialog (). Select with thumbnails (ListItem & useDetails = True)
is_kodi17 = (config.get_platform(True)['num_version'] >= 17.0)
if is_kodi17:
import xbmcgui
# Dialog to choose thumbnail (the channel or predefined icons)
opciones = []
ids = []
try:
from core import channeltools
channel_parameters = channeltools.get_channel_parameters(it.channel)
if channel_parameters['thumbnail'] != '':
nombre = 'Canal %s' % it.channel
if is_kodi17:
it_thumb = xbmcgui.ListItem(nombre)
it_thumb.setArt({ 'thumb': channel_parameters['thumbnail'] })
opciones.append(it_thumb)
else:
opciones.append(nombre)
ids.append(channel_parameters['thumbnail'])
except:
pass
resource_path = os.path.join(config.get_runtime_path(), 'resources', 'media', 'themes', 'default')
for f in sorted(os.listdir(resource_path)):
if f.startswith('thumb_') and not f.startswith('thumb_intervenido') and f != 'thumb_back.png':
nombre = f.replace('thumb_', '').replace('_', ' ').replace('.png', '')
if is_kodi17:
it_thumb = xbmcgui.ListItem(nombre)
it_thumb.setArt({ 'thumb': os.path.join(resource_path, f) })
opciones.append(it_thumb)
else:
opciones.append(nombre)
ids.append(os.path.join(resource_path, f))
if is_kodi17:
ret = xbmcgui.Dialog().select(config.get_localized_string(70554), opciones, useDetails=True)
else:
ret = platformtools.dialog_select(config.get_localized_string(70554), opciones)
if ret == -1: return False # order cancel
it.thumbnail = ids[ret]
alfav.user_favorites[item.i_perfil]['items'][item.i_enlace] = it.tourl()
alfav.save()
platformtools.itemlist_refresh()
return True
def onInit(self):
#### Compatibility with Kodi 18 ####
if config.get_platform(True)['num_version'] < 18:
self.setCoordinateResolution(2)
self.getControl(FANART).setImage(trailers[0].getProperty('fanart'))
self.getControl(NUMBER).setText(trailers[0].getProperty('position'))
self.getControl(TRAILERS).addItems(trailers)
self.setFocusId(TRAILERS)
getFocus(self)
def init_version(json_data):
try:
ret = False
if json_data.get('init_version'): return ret
categoria = config.get_system_platform()
kodi = config.get_platform(full_version=True)
kodi = ',k%s' % str(kodi.get('num_version')).split('.')[0]
assistant = ''
if categoria == 'android':
assistant = config.get_setting('assistant_binary', default=False)
if assistant and assistant != True:
assistant = ',%s' % assistant
elif assistant == True:
assistant = ''
from core import servertools
torrent_json = servertools.get_server_json('torrent').get(
'clients', [])
for client_block in torrent_json:
for client, value in list(client_block.items()):
if client != 'id': continue
if xbmc.getCondVisibility('System.HasAddon("%s")' %
value):
assistant = ',AstOT'
if 'elementum' in value:
assistant = ',AstEL'
break
if assistant:
break
else:
assistant = ''
if filetools.exists(
filetools.join(ADDON_USERDATA_PATH,
'alfa-mobile-assistant.version')):
version = filetools.read(
filetools.join(
ADDON_USERDATA_PATH,
'alfa-mobile-assistant.version')).split('.')
if len(version) == 3:
assistant = ',Ast%s' % version[1]
try:
if not PY3: from lib import alfaresolver
else: from lib import alfaresolver_py3 as alfaresolver
threading.Thread(target=alfaresolver.frequency_count, args=(Item(), \
[ADDON_VERSION, categoria + kodi + assistant])).start()
ret = True
except:
logger.error(traceback.format_exc())
except:
logger.error(traceback.format_exc())
return ret
def test_video_exists(page_url):
logger.info("(page_url='%s')" % page_url)
response = httptools.downloadpage(page_url)
if response.code == 404:
return False, config.get_localized_string(70449) % "RapidVideo"
if not response.data or "urlopen error [Errno 1]" in str(response.code):
if config.is_xbmc():
return False, config.get_localized_string(70302) % "RapidVideo"
elif config.get_platform() == "plex":
return False, config.get_localized_string(70303) % "RapidVideo"
elif config.get_platform() == "mediaserver":
return False, config.get_localized_string(70304) % "RapidVideo"
if "Object not found" in response.data:
return False, config.get_localized_string(70449) % "RapidVideo"
if response.code == 500:
return False, config.get_localized_string(70524) % "RapidVideo"
return True, ""
def editar_enlace_thumbnail(item):
logger.debug()
alfav = KodfavouritesData()
if not alfav.user_favorites[item.i_perfil]: return False
if not alfav.user_favorites[item.i_perfil]['items'][item.i_enlace]:
return False
it = Item().fromurl(
alfav.user_favorites[item.i_perfil]['items'][item.i_enlace])
# Starting with Kodi 17, you can use xbmcgui.Dialog (). Select with thumbnails (ListItem & useDetails = True)
is_kodi17 = (config.get_platform(True)['num_version'] >= 17.0)
if is_kodi17:
import xbmcgui
# Dialog to choose thumbnail (the channel or predefined icons)
opciones = []
ids = []
# try:
# from core import channeltools
# channel_parameters = channeltools.get_channel_parameters(it.channel)
# if channel_parameters['thumbnail'] != '':
# nombre = 'Channel %s' % it.channel
# if is_kodi17:
# it_thumb = xbmcgui.ListItem(nombre)
# it_thumb.setArt({ 'thumb': channel_parameters['thumbnail'] })
# opciones.append(it_thumb)
# else:
# opciones.append(nombre)
# ids.append(channel_parameters['thumbnail'])
# except:
# pass
resource_path = 'https://api.github.com/repos/kodiondemand/media/git/trees/b36040432b9be120f04e986277fd34f09dcdb4db'
for f in sorted(requests.get(resource_path).json().get('tree', []),
key=lambda p: p.get('path')):
nombre = f['path'].replace('thumb_', '').replace('.png', '')
it_thumb = xbmcgui.ListItem(nombre)
it_thumb.setArt({'thumb': support.thumb(nombre)})
opciones.append(it_thumb)
ids.append(support.thumb(nombre))
ret = xbmcgui.Dialog().select(config.get_localized_string(70554),
opciones,
useDetails=True)
if ret == -1: return False # order cancel
it.thumbnail = ids[ret]
alfav.user_favorites[item.i_perfil]['items'][item.i_enlace] = it.tourl()
alfav.save()
platformtools.itemlist_refresh()
return True
def check_addon_monitor():
logger.info()
# Obtiene el íntervalo entre actualizaciones y si se quieren mensajes
try:
timer = int(
config.get_setting('addon_update_timer')
) # Intervalo entre actualizaciones, en Ajustes de Alfa
if timer <= 0:
try:
user_type = base64.b64decode(
config.get_setting('proxy_dev')).decode('utf-8')
except:
user_type = 'user'
if user_type == 'user':
config.set_setting(
'addon_update_timer',
12) # Si es usuario se fuerza a 12 horas
timer = 12
else:
return # 0. No se quieren actualizaciones
verbose = config.get_setting('addon_update_message')
except:
logger.error(traceback.format_exc())
timer = 12 # Por defecto cada 12 horas
verbose = False # Por defecto, sin mensajes
timer = timer * 3600 # Lo pasamos a segundos
if config.get_platform(
True)['num_version'] >= 14: # Si es Kodi, lanzamos el monitor
monitor = xbmc.Monitor()
else: # Lanzamos solo una actualización y salimos
check_addon_updates(verbose) # Lanza la actualización
return
while not monitor.abortRequested(
): # Loop infinito hasta cancelar Kodi
check_addon_updates(verbose) # Lanza la actualización
if monitor.waitForAbort(
timer
): # Espera el tiempo programado o hasta que cancele Kodi
break # Cancelación de Kodi, salimos
check_update_to_others(
verbose=False, app=False
) # Actualizamos otros add-ons antes de irnos, para el siguiente inicio
#Borra el .zip de instalación de Alfa de la carpeta Packages, por si está corrupto, y que así se pueda descargar de nuevo
version = 'plugin.video.alfa-%s.zip' % config.get_addon_version(
with_fix=False, from_xml=True)
packages_path = os.path.join(config.translatePath('special://home'),
'addons', 'packages', version)
if os.path.exists(packages_path):
os.remove(packages_path)
return
def access():
"""
Returns whether or not filtertools can be used
"""
allow = False
if config.is_xbmc() or config.get_platform() == "mediaserver":
allow = True
return allow
def access():
"""
Devuelve si se puede usar o no filtertools
"""
allow = False
if config.is_xbmc() or config.get_platform() == "mediaserver":
allow = True
return allow
def extract_videos(video_id):
url = 'https://www.youtube.com/get_video_info?video_id=%s&eurl=https://youtube.googleapis.com/v/%s&ssl_stream=1' % \
(video_id, video_id)
data = httptools.downloadpage(url).data
video_urls = []
params = dict(urlparse.parse_qsl(data))
if params.get('hlsvp'):
video_urls.append(["(LIVE .m3u8) [youtube]", params['hlsvp']])
return video_urls
if config.is_xbmc():
import xbmc
xbmc_version = config.get_platform(True)['num_version']
if xbmc_version >= 17 and xbmc.getCondVisibility('System.HasAddon(inputstream.adaptive)') \
and params.get('dashmpd'):
if params.get('use_cipher_signature', '') != 'True':
video_urls.append(
['mpd HD [youtube]', params['dashmpd'], 0, '', True])
youtube_page_data = httptools.downloadpage(
"https://www.youtube.com/watch?v=%s" % video_id).data
params = extract_flashvars(youtube_page_data)
if params.get('player_response'):
params = json.load(params.get('player_response'))
data_flashvars = params["streamingData"]
for s_data in data_flashvars:
if s_data in ["adaptiveFormats", "formats"]:
for opt in data_flashvars[s_data]:
opt = dict(opt)
if "audioQuality" not in opt:
continue
if "cipher" in opt:
signature = get_signature(youtube_page_data)
cipher = dict(
urlparse.parse_qsl(urllib.unquote(opt["cipher"])))
url = re.search('url=(.*)', opt["cipher"]).group(1)
s = cipher.get('s')
url = "%s&sig=%s" % (urllib.unquote(url), signature(
[s]))
video_urls.append(
["%s" % itag_list.get(opt["itag"], "audio"), url])
elif opt["itag"] in itag_list:
video_urls.append([
"%s" % itag_list.get(opt["itag"], "video"),
opt["url"]
])
return video_urls
def test_video_exists(page_url):
logger.info("(page_url='%s')" % page_url)
try:
response = httptools.downloadpage(page_url)
except:
pass
if not response.data or "urlopen error [Errno 1]" in str(response.code):
from platformcode import config
if config.is_xbmc():
return False, "[Rapidvideo] Este conector solo funciona a partir de Kodi 17"
elif config.get_platform() == "plex":
return False, "[Rapidvideo] Este conector no funciona con tu versión de Plex, intenta actualizarla"
elif config.get_platform() == "mediaserver":
return False, "[Rapidvideo] Este conector requiere actualizar python a la versión 2.7.9 o superior"
if "Object not found" in response.data:
return False, "[Rapidvideo] El archivo no existe o ha sido borrado"
return True, ""
def onInit(self):
self.MENU = self.getControl(1)
self.SUBMENU = self.getControl(2)
#### Compatibility with Kodi 18 ####
if config.get_platform(True)['num_version'] < 18:
self.setCoordinateResolution(2)
itemlist = self.menulist(channelselector.getmainlist())
self.MENU.addItems(itemlist)
self.setFocusId(1)
self.submenu()
def execute_sql(sql):
logger.debug()
file_db = ""
records = None
# We look for the archive of the video database according to the version of kodi
video_db = config.get_platform(True)['video_db']
if video_db:
file_db = os.path.join(
xbmc.translatePath("special://userdata/Database"), video_db)
# alternative method to locate the database
if not file_db or not os.path.exists(file_db):
file_db = ""
for f in os.path.listdir(
xbmc.translatePath("special://userdata/Database")):
path_f = os.path.join(
xbmc.translatePath("special://userdata/Database"), f)
if os.path.pathoos.pathols.isfile(path_f) and f.lower().startswith(
'myvideos') and f.lower().endswith('.db'):
file_db = path_f
break
if file_db:
logger.debug("DB file: %s" % file_db)
conn = None
try:
import sqlite3
conn = sqlite3.connect(file_db)
cursor = conn.cursor()
logger.debug("Running sql: %s" % sql)
cursor.execute(sql)
conn.commit()
records = cursor.fetchall()
if sql.lower().startswith("select"):
if len(records) == 1 and records[0][0] is None:
records = []
conn.close()
logger.debug("Query executed. Records: %s" % len(records))
except:
logger.error("Error executing sql query")
if conn:
conn.close()
else:
logger.debug("Database not found")
return records
def test_video_exists(page_url):
logger.info("(page_url='%s')" % page_url)
try:
response = httptools.downloadpage(page_url)
except:
pass
if not response.data or "urlopen error [Errno 1]" in str(response.code):
from platformcode import config
if config.is_xbmc():
return False, "[Rapidvideo] Questo connettore funziona solo con versioni le versioni 17 di Kodi"
elif config.get_platform() == "plex":
return False, "[Rapidvideo] Questo connettore non funziona con la tua versione Plex installata"
elif config.get_platform() == "mediaserver":
return False, "[Rapidvideo] Questo connettore richiede la versione di Python 2.7.9 o successive"
if "Object not found" in response.data:
return False, "[Rapidvideo] Il file non esiste oppure e stato cancellato"
if response.code == 500:
return False, "[Rapidvideo] Problemi temporanei nel server"
return True, ""
def test_video_exists(page_url):
logger.info("(page_url='%s')" % page_url)
try:
response = httptools.downloadpage(page_url)
except:
pass
if not response.data or "urlopen error [Errno 1]" in str(response.code):
from platformcode import config
if config.is_xbmc():
return False, "[Rapidvideo] Questo connettore funziona solo con versione di Kodi 17 o successive"
elif config.get_platform() == "plex":
return False, "[Rapidvideo] Questo connettore non funziona con la tua versione di Plex, aggiornamento versione richiesto"
elif config.get_platform() == "mediaserver":
return False, "[Rapidvideo] Questo connettore richiede un aggiornamento di python alla versione 2.7.9 o superiore"
if "Object not found" in response.data:
return False, "[Rapidvideo] File inesistente o e stato cancellato"
if response.code == 500:
return False, "[Rapidvideo] Server error, riprova in seguito"
return True, ""
def onInit(self):
if config.get_platform(True)['num_version'] < 18:
self.setCoordinateResolution(2)
with futures.ThreadPoolExecutor() as executor:
for i, result in enumerate(self.results):
logger.debug(result)
if ('seriesName' in result and result['seriesName']) or ('name' in result and result['name']) or ('title' in result and result['title']):
self.items += [executor.submit(self.make_items, i, result).result()]
self.items.sort(key=lambda it: int(it.getProperty('position')))
self.getControl(SELECT).addItems(self.items)
self.getControl(BACKGROUND).setImage(self.items[0].getProperty('fanart'))
self.getControl(LOADING).setVisible(False)
self.setFocusId(SELECT)
def onInit(self):
#### Compatibilidad con Kodi 18 ####
if config.get_platform(True)['num_version'] < 18:
self.setCoordinateResolution(2)
for menuentry in MAIN_MENU.keys():
item = xbmcgui.ListItem(MAIN_MENU[menuentry]["label"])
item.setProperty("thumb", str(MAIN_MENU[menuentry]["icon"]))
item.setProperty("identifier", str(menuentry))
item.setProperty("order", str(MAIN_MENU[menuentry]["order"]))
self.items.append(item)
self.items.sort(key=lambda it: it.getProperty("order"))
self.getControl(32500).addItems(self.items)
self.setFocusId(32500)
def __init__(self, *args, **kwargs):
self.tmdb = kwargs.get("tmdb", {})
self.imdb = kwargs.get("imdb", {})
self.mal = kwargs.get("mal", {})
self.fanartv = kwargs.get("fanartv", {})
self.image_list = []
for key, value in self.tmdb.items():
for detail in value: self.image_list.append('https://image.tmdb.org/t/p/original' + detail["file_path"])
for image in self.imdb: self.image_list.append(image["src"])
for image, title in self.mal: self.image_list.append(image)
for key, value in self.fanartv.items():
for image in value: self.image_list.append(image["url"])
#### Kodi 18 Compatibility ####
if config.get_platform(True)['num_version'] < 18: self.setCoordinateResolution(2)
log
self.background = xbmcgui.ControlImage(0, 0, 1280, 720, imagepath('white'), colorDiffuse='FF232323')
self.addControl(self.background)
main_image = self.image_list[0] if self.image_list else ''
self.main_image = xbmcgui.ControlImage(0, 0, 1280, 720, main_image, 2)
self.addControl(self.main_image)
if self.image_list:
self.counter = xbmcgui.ControlTextBox(1180, 640, 60, 40, 'font13')
self.addControl(self.counter)
self.counter.setText('%s/%s' % (1,len(self.image_list)))
else:
self.text = xbmcgui.ControlLabel(0, 0, 1280, 720, 'NESSUNA IMMAGINE', 'font13', alignment=2|4)
self.addControl(self.text)
self.close_btn = xbmcgui.ControlButton(0, 0, 1280, 720, '' ,'', '')
self.addControl(self.close_btn)
if len(self.image_list) > 1:
# BUTTON LEFT
self.btn_left = xbmcgui.ControlButton(0, 330, 60, 60, '', imagepath('previous_focus'), imagepath('previous_nofocus'))
self.addControl(self.btn_left)
self.btn_left.setAnimations([('WindowOpen', 'effect=slide start=-60,0 end=0,0 delay=100 time=200'),('WindowClose', 'effect=slide start=0,0 end=-60,0 delay=100 time=200')])
# BUTTON RIGHT
self.btn_right = xbmcgui.ControlButton(1220, 330, 60, 60, '', imagepath('next_focus'), imagepath('next_nofocus'))
self.addControl(self.btn_right)
self.btn_right.setAnimations([('WindowOpen', 'effect=slide start=60,0 end=0,0 delay=100 time=200'),('WindowClose', 'effect=slide start=0,0 end=60,0 delay=100 time=200')])
self.count = 0
def onInit(self):
#### Compatibility with Kodi 18 ####
if config.get_platform(True)['num_version'] < 18:
self.setCoordinateResolution(2)
for menuentry in menu:
if not menuentry.channel: menuentry.channel = prevchannel
item = xbmcgui.ListItem(menuentry.title)
if not submenu and menuentry.channel in ['news', 'channelselector', 'search', 'videolibrary']:
item.setProperty('sub', 'Controls/spinUp-Focus.png')
if menuentry.title != 'Redirect':
for key , value in json.loads(menuentry.tojson()).items():
item.setProperty(key, str(value))
item.setProperty('run', menuentry.tojson())
self.items.append(item)
self.getControl(32500).addItems(self.items)
self.setFocusId(32500)
def onInit(self):
#### Compatibility with Kodi 18 ####
if config.get_platform(True)['num_version'] < 18:
self.setCoordinateResolution(2)
if Info.getProperty('id'): self.items = get_movies(Info)
else: self.items = get_recomendations(Info)
self.cast, self.actors = get_cast(Info)
self.getControl(LOADING).setVisible(False)
self.getControl(RECOMANDED).addItems(self.items)
self.getControl(FANART).setImage(Info.getProperty('fanart'))
self.getControl(ACTORS).addItems(self.actors)
if self.cast:
self.getControl(CAST).setVisible(True)
self.getControl(CAST).addItems(self.cast)
else:
self.getControl(CAST).setVisible(False)
if Info.getProperty('rating'):
self.getControl(RATING).setText(str(Info.getProperty('rating')))
getFocus(self)
def marcar(item):
logger.info()
if "Capítulo" in item.title:
url = "%s/data.php?mode=capitulo_visto&apikey=%s&sid=%s&c_id=%s" % (
host, apikey, sid, item.epi_id)
message = item.title.replace("no", "marcado como").replace(
"ya", "cambiado a no").replace(" ¿Cambiar?", "")
elif "temporada" in item.title.lower():
type_marcado = "1"
if "como vista" in item.title:
message = "Temporada %s marcada como vista" % item.season
else:
type_marcado = "2"
message = "Temporada %s marcada como no vista" % item.season
url = "%s/data.php?mode=temporada_vista&apikey=%s&sid=%s&ficha=%s&t_id=%s&type=%s" \
% (host, apikey, sid, item.ficha, item.season, type_marcado)
else:
message = item.title.replace("Marcar ", "Marcada ").replace(
"Seguir serie", "Serie en seguimiento")
if "favorita" in item.title:
url = "%s/data.php?mode=marcar_ficha&apikey=%s&sid=%s&ficha=%s&tipo=%s" \
% (host, apikey, sid, item.ficha, "3")
elif "pendiente" in item.title:
url = "%s/data.php?mode=marcar_ficha&apikey=%s&sid=%s&ficha=%s&tipo=%s" \
% (host, apikey, sid, item.ficha, "2")
elif "vista" in item.title:
url = "%s/data.php?mode=marcar_ficha&apikey=%s&sid=%s&ficha=%s&tipo=%s" \
% (host, apikey, sid, item.ficha, "4")
elif "Seguir" in item.title:
url = "%s/data.php?mode=marcar_ficha&apikey=%s&sid=%s&ficha=%s&tipo=%s" \
% (host, apikey, sid, item.ficha, "2")
data = httptools.downloadpage(url)
url = "%s/data.php?mode=marcar_ficha&apikey=%s&sid=%s&ficha=%s&tipo=%s" \
% (host, apikey, sid, item.ficha, "1")
data = httptools.downloadpage(url)
if data.sucess and config.get_platform(
) != "plex" and item.action != "play":
from platformcode import platformtools
platformtools.dialog_notification("Acción correcta", message)
