764 lines
30 KiB
Python
764 lines
30 KiB
Python
# -*- coding: utf-8 -*-
|
||
|
||
#from builtins import str
|
||
import sys
|
||
PY3 = False
|
||
if sys.version_info[0] >= 3: PY3 = True; unicode = str; unichr = chr; long = int
|
||
from builtins import range
|
||
|
||
import os
|
||
|
||
from core import channeltools, jsontools
|
||
from core.item import Item
|
||
from platformcode import config, logger, platformtools, launcher
|
||
from time import sleep
|
||
from platformcode.config import get_setting
|
||
|
||
__channel__ = "autoplay"
|
||
|
||
PLAYED = False
|
||
|
||
autoplay_node = {}
|
||
|
||
colorKOD = '0xFF65B3DA'
|
||
|
||
|
||
def context():
|
||
'''
|
||
Add the Configure AutoPlay option to the context menu
|
||
|
||
:return:
|
||
'''
|
||
|
||
_context = ""
|
||
|
||
if config.is_xbmc():
|
||
_context = [{"title": config.get_localized_string(60071),
|
||
"action": "autoplay_config",
|
||
"channel": "autoplay"}]
|
||
return _context
|
||
|
||
|
||
context = context()
|
||
|
||
|
||
def show_option(channel, itemlist, text_color=colorKOD, thumbnail=None, fanart=None):
|
||
'''
|
||
Add the option Configure AutoPlay in the received list
|
||
|
||
:param channel: str
|
||
:param itemlist: list (lista donde se desea integrar la opcion de configurar AutoPlay)
|
||
:param text_color: str (color for the text of the option Configure Autoplay)
|
||
:param thumbnail: str (address where the thumbnail is for the Configure Autoplay option)
|
||
:return:
|
||
'''
|
||
from channelselector import get_thumb
|
||
from core.support import typo
|
||
logger.info()
|
||
|
||
if not config.is_xbmc():
|
||
return itemlist
|
||
|
||
if thumbnail == None:
|
||
thumbnail = get_thumb('autoplay.png')
|
||
# if fanart == None:
|
||
# fanart = get_thumb('autoplay.png')
|
||
|
||
plot_autoplay = config.get_localized_string(60399)
|
||
itemlist.append(
|
||
Item(channel=__channel__,
|
||
title=typo(config.get_localized_string(60071), 'bold color kod'),
|
||
action="autoplay_config",
|
||
text_color=text_color,
|
||
text_bold=True,
|
||
thumbnail=thumbnail,
|
||
# fanart=fanart,
|
||
plot=plot_autoplay,
|
||
from_channel=channel,
|
||
folder=False
|
||
))
|
||
return itemlist
|
||
|
||
|
||
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
|
||
'''
|
||
logger.info()
|
||
|
||
global PLAYED
|
||
global autoplay_node
|
||
PLAYED = False
|
||
|
||
base_item = item
|
||
|
||
|
||
if not config.is_xbmc():
|
||
# platformtools.dialog_notification('AutoPlay ERROR', 'Sólo disponible para XBMC/Kodi')
|
||
return itemlist
|
||
|
||
if not autoplay_node:
|
||
# Get AUTOPLAY node from json
|
||
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
|
||
|
||
channel_id = item.channel
|
||
if item.channel == 'videolibrary':
|
||
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
|
||
channel_id = item.contentChannel
|
||
# try:
|
||
# active = autoplay_node['status']
|
||
# except:
|
||
# active = is_active(item.channel)
|
||
|
||
if not channel_id in autoplay_node: # or not active:
|
||
return itemlist
|
||
|
||
# Add servers and qualities not listed to autoplay_node
|
||
new_options = check_value(channel_id, itemlist)
|
||
|
||
# Get the channel node from autoplay_node
|
||
channel_node = autoplay_node.get(channel_id, {})
|
||
# Get the autoplay settings for this channel
|
||
settings_node = channel_node.get('settings', {})
|
||
|
||
if get_setting('autoplay') or settings_node['active']:
|
||
url_list_valid = []
|
||
autoplay_list = []
|
||
autoplay_b = []
|
||
favorite_langs = []
|
||
favorite_servers = []
|
||
favorite_quality = []
|
||
|
||
# 2nd lang, see if you want to filter or not
|
||
status_language = config.get_setting("filter_languages", channel_id)
|
||
|
||
|
||
# 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 user_config_setting_action != 2:
|
||
config.set_setting("default_action", 2)
|
||
if user_config_setting_player != 0:
|
||
config.set_setting("player_mode", 0)
|
||
|
||
# Report that AutoPlay is active
|
||
# platformtools.dialog_notification('AutoPlay Activo', '', sound=False)
|
||
|
||
# Priorities when ordering itemlist:
|
||
# 0: Servers and qualities
|
||
# 1: Qualities and servers
|
||
# 2: Servers only
|
||
# 3: Only qualities
|
||
# 4: Do not order
|
||
if (settings_node['custom_servers'] and settings_node['custom_quality']) or get_setting('autoplay'):
|
||
priority = settings_node['priority'] # 0: Servers and qualities or 1: Qualities and servers
|
||
elif settings_node['custom_servers']:
|
||
priority = 2 # Servers only
|
||
elif settings_node['custom_quality']:
|
||
priority = 3 # Only qualities
|
||
else:
|
||
priority = 4 # Do not order
|
||
|
||
# Get server lists, qualities available from AutoPlay json node
|
||
server_list = channel_node.get('servers', [])
|
||
for server in server_list:
|
||
server = server.lower()
|
||
quality_list = channel_node.get('quality', [])
|
||
|
||
# If no qualities are defined, default is assigned as unique quality.
|
||
if len(quality_list) == 0:
|
||
quality_list =['default']
|
||
|
||
# The texts of each server and quality are stored in lists, e.g. favorite_servers = ['verystream', 'openload', 'streamcloud']
|
||
for num in range(1, 4):
|
||
favorite_servers.append(channel_node['servers'][settings_node['server_%s' % num]].lower())
|
||
favorite_quality.append(channel_node['quality'][settings_node['quality_%s' % num]])
|
||
|
||
# Itemlist links are filtered and correspond to autoplay values
|
||
for n, item in enumerate(itemlist):
|
||
autoplay_elem = dict()
|
||
b_dict = dict()
|
||
|
||
# We check that it is a video item
|
||
if 'server' not in item:
|
||
continue
|
||
# 2nd lang language list
|
||
if item.language not in favorite_langs:
|
||
favorite_langs.append(item.language)
|
||
|
||
# Add the option to configure AutoPlay to the context menu
|
||
if 'context' not in item:
|
||
item.context = list()
|
||
if not [x for x in context if x['action'] == 'autoplay_config']:
|
||
item.context.append({"title": config.get_localized_string(60071),
|
||
"action": "autoplay_config",
|
||
"channel": "autoplay",
|
||
"from_channel": channel_id})
|
||
|
||
# If it does not have a defined quality, it assigns a 'default' quality.
|
||
if item.quality == '':
|
||
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 not in favorite_quality \
|
||
or item.url in url_list_valid:
|
||
item.type_b = True
|
||
b_dict['videoitem']= item
|
||
autoplay_b.append(b_dict)
|
||
continue
|
||
autoplay_elem["indice_lang"] = favorite_langs.index(item.language)
|
||
autoplay_elem["indice_server"] = favorite_servers.index(item.server.lower())
|
||
autoplay_elem["indice_quality"] = favorite_quality.index(item.quality)
|
||
|
||
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
|
||
b_dict['videoitem'] = item
|
||
autoplay_b.append(b_dict)
|
||
continue
|
||
autoplay_elem["indice_lang"] = favorite_langs.index(item.language)
|
||
autoplay_elem["indice_server"] = favorite_servers.index(item.server.lower())
|
||
|
||
elif priority == 3: # Solo calidades
|
||
|
||
# if the quality is not in the favorites list or the url is repeated, we discard the item
|
||
if item.quality not in favorite_quality or item.url in url_list_valid:
|
||
item.type_b = True
|
||
b_dict['videoitem'] = item
|
||
autoplay_b.append(b_dict)
|
||
continue
|
||
autoplay_elem["indice_lang"] = favorite_langs.index(item.language)
|
||
autoplay_elem["indice_quality"] = favorite_quality.index(item.quality)
|
||
|
||
else: # Do not order
|
||
|
||
# if the url is repeated, we discard the item
|
||
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
|
||
autoplay_elem['videoitem'] = item
|
||
# autoplay_elem['server'] = item.server
|
||
# autoplay_elem['quality'] = item.quality
|
||
autoplay_list.append(autoplay_elem)
|
||
|
||
# We order according to priority
|
||
if priority == 0: # Servers and qualities
|
||
autoplay_list.sort(key=lambda orden: (orden['indice_lang'], orden['indice_server'], orden['indice_quality']))
|
||
|
||
elif priority == 1: # Qualities and servers
|
||
autoplay_list.sort(key=lambda orden: (orden['indice_lang'], orden['indice_quality'], orden['indice_server']))
|
||
|
||
elif priority == 2: # Servers only
|
||
autoplay_list.sort(key=lambda orden: (orden['indice_lang'], orden['indice_server']))
|
||
|
||
elif priority == 3: # Only qualities
|
||
autoplay_list.sort(key=lambda orden: (orden['indice_lang'], orden['indice_quality']))
|
||
|
||
# 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):
|
||
|
||
# played = False
|
||
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
|
||
|
||
# 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
|
||
|
||
platformtools.dialog_notification("AutoPlay %s" %text_b, "%s%s%s" % (
|
||
videoitem.server.upper(), lang, videoitem.quality.upper()), sound=False)
|
||
# TODO videoitem.server is the id of the server, but it might not be the name !!!
|
||
|
||
# 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]
|
||
|
||
# If not directly reproduce and mark as seen
|
||
|
||
#Check if the item comes from the video library
|
||
try:
|
||
if base_item.contentChannel =='videolibrary':
|
||
# Mark as seen
|
||
from platformcode import xbmc_videolibrary
|
||
xbmc_videolibrary.mark_auto_as_watched(base_item)
|
||
# Fill the video with the data of the main item and play
|
||
play_item = base_item.clone(url=videoitem)
|
||
platformtools.play_video(play_item.url, 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) % videoitem.server.upper()
|
||
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) % videoitem.server.upper())
|
||
|
||
else:
|
||
platformtools.dialog_notification(config.get_localized_string(60074), config.get_localized_string(60075))
|
||
if new_options:
|
||
platformtools.dialog_notification("AutoPlay", config.get_localized_string(60076), sound=False)
|
||
|
||
# Restore if necessary the previous value of "Action and Player Mode" in preferences
|
||
if user_config_setting_action != 2:
|
||
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 init(channel, list_servers, list_quality, reset=False):
|
||
'''
|
||
Check the existence of a channel in the Autoplay configuration file and if it does not exist, add it.
|
||
It is necessary to call this function when entering any channel that includes the Autoplay function.
|
||
|
||
:param channel: (str) channel id
|
||
:param list_servers: (list) initial list of valid servers for the channel. It is not necessary to include them all,
|
||
since the list of valid servers will be updated dynamically.
|
||
:param list_quality: (list) initial list of valid qualities for the channel. It is not necessary to include them all,
|
||
since the list of valid qualities will be updated dynamically.
|
||
:return: (bool) True if the initialization was successful.
|
||
'''
|
||
logger.info()
|
||
change = False
|
||
result = True
|
||
|
||
|
||
if not config.is_xbmc():
|
||
# platformtools.dialog_notification('AutoPlay ERROR', 'Sólo disponible para XBMC/Kodi')
|
||
result = False
|
||
else:
|
||
autoplay_path = os.path.join(config.get_data_path(), "settings_channels", 'autoplay_data.json')
|
||
if os.path.exists(autoplay_path):
|
||
autoplay_node = jsontools.get_node_from_file('autoplay', "AUTOPLAY")
|
||
else:
|
||
change = True
|
||
autoplay_node = {"AUTOPLAY": {}}
|
||
|
||
if channel not in autoplay_node or reset:
|
||
change = True
|
||
|
||
# It is verified that there are no duplicate qualities or servers
|
||
if 'default' not in list_quality:
|
||
list_quality.append('default')
|
||
# list_servers = list(set(list_servers))
|
||
# list_quality = list(set(list_quality))
|
||
|
||
# We create the channel node and add it
|
||
channel_node = {"servers": list_servers,
|
||
"quality": list_quality,
|
||
"settings": {
|
||
"active": False,
|
||
"hide_servers": False,
|
||
"plan_b": True,
|
||
"custom_servers": False,
|
||
"custom_quality": False,
|
||
"priority": 0}}
|
||
for n in range(1, 4):
|
||
s = c = 0
|
||
if len(list_servers) >= n:
|
||
s = n - 1
|
||
if len(list_quality) >= n:
|
||
c = n - 1
|
||
|
||
channel_node["settings"]["server_%s" % n] = s
|
||
channel_node["settings"]["quality_%s" % n] = c
|
||
autoplay_node[channel] = channel_node
|
||
|
||
if change:
|
||
result, json_data = jsontools.update_node(autoplay_node, 'autoplay', 'AUTOPLAY')
|
||
|
||
if not result:
|
||
heading = config.get_localized_string(60077)
|
||
msj = config.get_localized_string(60078)
|
||
|
||
platformtools.dialog_notification(heading, msj, sound=False)
|
||
|
||
return result
|
||
|
||
|
||
def check_value(channel, itemlist):
|
||
'''
|
||
checks the existence of a value in the list of servers or qualities if it does not exist adds them to the list in the json
|
||
|
||
:param channel: str
|
||
:param values: list (one of servers or qualities)
|
||
:param value_type: str (server o quality)
|
||
:return: list
|
||
'''
|
||
logger.info()
|
||
global autoplay_node
|
||
change = False
|
||
|
||
if not autoplay_node:
|
||
# Get AUTOPLAY node from json
|
||
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
|
||
|
||
channel_node = autoplay_node.get(channel)
|
||
|
||
server_list = channel_node.get('servers')
|
||
if not server_list:
|
||
server_list = channel_node['servers'] = list()
|
||
|
||
quality_list = channel_node.get('quality')
|
||
if not quality_list:
|
||
quality_list = channel_node['quality'] = list()
|
||
|
||
for item in itemlist:
|
||
if item.server.lower() not in server_list and item.server !='':
|
||
server_list.append(item.server.lower())
|
||
change = True
|
||
if item.quality not in quality_list and item.quality !='':
|
||
quality_list.append(item.quality)
|
||
change = True
|
||
|
||
if change:
|
||
change, json_data = jsontools.update_node(autoplay_node, 'autoplay', 'AUTOPLAY')
|
||
|
||
return change
|
||
|
||
|
||
def autoplay_config(item):
|
||
logger.info()
|
||
global autoplay_node
|
||
dict_values = {}
|
||
list_controls = []
|
||
channel_parameters = channeltools.get_channel_parameters(item.from_channel)
|
||
channel_name = channel_parameters['title']
|
||
|
||
if not autoplay_node:
|
||
# Get AUTOPLAY node from json
|
||
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
|
||
|
||
channel_node = autoplay_node.get(item.from_channel, {})
|
||
settings_node = channel_node.get('settings', {})
|
||
|
||
allow_option = True
|
||
|
||
active_settings = {"id": "active", "label": config.get_localized_string(60079), "type": "bool",
|
||
"default": False, "enabled": allow_option, "visible": allow_option}
|
||
|
||
list_controls.append(active_settings)
|
||
dict_values['active'] = settings_node.get('active', False)
|
||
|
||
hide_servers = {"id": "hide_servers", "label": config.get_localized_string(70747), "type": "bool",
|
||
"default": False, "enabled": "eq(-" + str(len(list_controls)) + ",true)", "visible": allow_option}
|
||
|
||
list_controls.append(hide_servers)
|
||
dict_values['hide_servers'] = settings_node.get('hide_servers', False)
|
||
|
||
# Language
|
||
status_language = config.get_setting("filter_languages", item.from_channel)
|
||
if not status_language:
|
||
status_language = 0
|
||
|
||
set_language = {"id": "language", "label": config.get_localized_string(60080),
|
||
"type": "list", "default": 0, "enabled": "eq(-" + str(len(list_controls)) + ",true)", "visible": True,
|
||
"lvalues": get_languages(item.from_channel)}
|
||
|
||
list_controls.append(set_language)
|
||
dict_values['language'] = status_language
|
||
|
||
separador = {"id": "label", "label": " "
|
||
"_________________________________________________________________________________________",
|
||
"type": "label", "enabled": True, "visible": True}
|
||
list_controls.append(separador)
|
||
|
||
# Favorite servers section
|
||
server_list = channel_node.get("servers", [])
|
||
if not server_list:
|
||
enabled = False
|
||
server_list = ["No disponible"]
|
||
else:
|
||
enabled = "eq(-" + str(len(list_controls)) + ",true)"
|
||
|
||
custom_servers_settings = {"id": "custom_servers", "label": config.get_localized_string(60081),
|
||
"type": "bool", "default": False, "enabled": enabled, "visible": True}
|
||
custom_servers_pos = len(list_controls)
|
||
list_controls.append(custom_servers_settings)
|
||
if dict_values['active'] and enabled:
|
||
dict_values['custom_servers'] = settings_node.get('custom_servers', False)
|
||
else:
|
||
dict_values['custom_servers'] = False
|
||
|
||
for num in range(1, 4):
|
||
pos1 = num + custom_servers_pos
|
||
default = num - 1
|
||
if default > len(server_list) - 1:
|
||
default = 0
|
||
set_servers = {"id": "server_%s" % num, "label": u" \u2665" + config.get_localized_string(60082) % num,
|
||
"type": "list", "default": default,
|
||
"enabled": "eq(-%s,true)+eq(-%s,true)" % (pos1, num), "visible": True,
|
||
"lvalues": server_list}
|
||
list_controls.append(set_servers)
|
||
|
||
dict_values["server_%s" % num] = settings_node.get("server_%s" % num, 0)
|
||
if settings_node.get("server_%s" % num, 0) > len(server_list) - 1:
|
||
dict_values["server_%s" % num] = 0
|
||
|
||
# Favorite Qualities Section
|
||
quality_list = channel_node.get("quality", [])
|
||
if not quality_list:
|
||
enabled = False
|
||
quality_list = ["No disponible"]
|
||
else:
|
||
enabled = "eq(-" + str(len(list_controls)) + ",true)"
|
||
|
||
custom_quality_settings = {"id": "custom_quality", "label": config.get_localized_string(60083), "type": "bool", "default": False, "enabled": enabled, "visible": True}
|
||
custom_quality_pos = len(list_controls)
|
||
list_controls.append(custom_quality_settings)
|
||
if dict_values['active'] and enabled:
|
||
dict_values['custom_quality'] = settings_node.get('custom_quality', False)
|
||
else:
|
||
dict_values['custom_quality'] = False
|
||
|
||
for num in range(1, 4):
|
||
pos1 = num + custom_quality_pos
|
||
default = num - 1
|
||
if default > len(quality_list) - 1:
|
||
default = 0
|
||
|
||
set_quality = {"id": "quality_%s" % num, "label": u" \u2665 " + config.get_localized_string(707417) + " %s" % num,
|
||
"type": "list", "default": default,
|
||
"enabled": "eq(-%s,true)+eq(-%s,true)" % (pos1, num), "visible": True,
|
||
"lvalues": quality_list}
|
||
list_controls.append(set_quality)
|
||
dict_values["quality_%s" % num] = settings_node.get("quality_%s" % num, 0)
|
||
if settings_node.get("quality_%s" % num, 0) > len(quality_list) - 1:
|
||
dict_values["quality_%s" % num] = 0
|
||
|
||
# Plan B
|
||
dict_values['plan_b'] = settings_node.get('plan_b', False)
|
||
enabled = "eq(-" + str(custom_servers_pos) + ",true)|eq(-" + str(custom_quality_pos) + ",true)"
|
||
plan_b = {"id": "plan_b", "label": config.get_localized_string(70172),"type": "bool", "default": False, "enabled": enabled, "visible": True}
|
||
list_controls.append(plan_b)
|
||
|
||
|
||
# Priorities Section
|
||
priority_list = [config.get_localized_string(70174), config.get_localized_string(70175)]
|
||
set_priority = {"id": "priority", "label": config.get_localized_string(60085), "type": "list", "default": 0,
|
||
"enabled": True, "visible": "eq(-5,true)+eq(-9,true)+eq(-12,true)", "lvalues": priority_list}
|
||
list_controls.append(set_priority)
|
||
dict_values["priority"] = settings_node.get("priority", 0)
|
||
|
||
|
||
|
||
# Open dialog box
|
||
platformtools.show_channel_settings(list_controls=list_controls, dict_values=dict_values, callback='save',
|
||
item=item, caption='%s - AutoPlay' % channel_name,
|
||
custom_button={'visible': True,
|
||
'function': "reset",
|
||
'close': True,
|
||
'label': 'Reset'})
|
||
|
||
|
||
def save(item, dict_data_saved):
|
||
'''
|
||
Save the data from the configuration window
|
||
|
||
:param item: item
|
||
:param dict_data_saved: dict
|
||
:return:
|
||
'''
|
||
logger.info()
|
||
global autoplay_node
|
||
|
||
if not autoplay_node:
|
||
# Get AUTOPLAY node from json
|
||
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
|
||
|
||
new_config = dict_data_saved
|
||
if not new_config['active']:
|
||
new_config['language']=0
|
||
channel_node = autoplay_node.get(item.from_channel)
|
||
config.set_setting("filter_languages", dict_data_saved.pop("language"), item.from_channel)
|
||
channel_node['settings'] = dict_data_saved
|
||
|
||
result, json_data = jsontools.update_node(autoplay_node, 'autoplay', 'AUTOPLAY')
|
||
|
||
|
||
return result
|
||
|
||
|
||
def get_languages(channel):
|
||
'''
|
||
Get the languages from the channel's json
|
||
|
||
:param channel: str
|
||
:return: list
|
||
'''
|
||
logger.info()
|
||
list_language = ['Non filtrare']
|
||
list_controls, dict_settings = channeltools.get_channel_controls_settings(channel)
|
||
for control in list_controls:
|
||
try:
|
||
if control["id"] == 'filter_languages':
|
||
list_language = control["lvalues"]
|
||
except:
|
||
pass
|
||
|
||
return list_language
|
||
|
||
|
||
def is_active(channel):
|
||
'''
|
||
Returns a boolean that indicates whether or not autoplay is active on the channel from which it is called
|
||
|
||
:return:True if autoplay is active for the channel from which it is called, False otherwise.
|
||
'''
|
||
logger.info()
|
||
global autoplay_node
|
||
|
||
if not config.is_xbmc():
|
||
return False
|
||
|
||
if not autoplay_node:
|
||
# Get AUTOPLAY node from json
|
||
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
|
||
|
||
# Get the channel from which the call is made
|
||
#import inspect
|
||
#module = inspect.getmodule(inspect.currentframe().f_back)
|
||
#canal = module.__name__.split('.')[1]
|
||
canal = channel
|
||
|
||
# Get the channel node from autoplay_node
|
||
channel_node = autoplay_node.get(canal, {})
|
||
# Get the autoplay settings for this channel
|
||
settings_node = channel_node.get('settings', {})
|
||
|
||
return settings_node.get('active', False) or get_setting('autoplay')
|
||
|
||
|
||
def reset(item, dict):
|
||
|
||
channel_name = item.from_channel
|
||
channel = __import__('channels.%s' % channel_name, fromlist=["channels.%s" % channel_name])
|
||
list_servers = channel.list_servers
|
||
list_quality = channel.list_quality
|
||
|
||
init(channel_name, list_servers, list_quality, reset=True)
|
||
platformtools.dialog_notification('AutoPlay', config.get_localized_string(70523) % item.category)
|
||
|
||
return
|
||
|
||
# def set_status(status):
|
||
# logger.info()
|
||
# # Get AUTOPLAY node from json
|
||
# autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
|
||
# autoplay_node['status'] = status
|
||
#
|
||
# result, json_data = jsontools.update_node(autoplay_node, 'autoplay', 'AUTOPLAY')
|
||
|
||
# return if item channel has autoplay and hideserver enabled
|
||
def get_channel_AP_HS(item):
|
||
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
|
||
channel_node = autoplay_node.get(item.channel, {})
|
||
if not channel_node: # never opened the channel menu so in autoplay_data.json there is no key
|
||
try:
|
||
channelFile = __import__('channels.' + item.channel, fromlist=["channels.%s" % item.channel])
|
||
except:
|
||
channelFile = __import__('specials.' + item.channel, fromlist=["specials.%s" % item.channel])
|
||
if hasattr(channelFile, 'list_servers') and hasattr(channelFile, 'list_quality'):
|
||
init(item.channel, channelFile.list_servers, channelFile.list_quality)
|
||
|
||
autoplay_node = jsontools.get_node_from_file('autoplay', 'AUTOPLAY')
|
||
channel_node = autoplay_node.get(item.channel, {})
|
||
settings_node = channel_node.get('settings', {})
|
||
AP = get_setting('autoplay') or (settings_node['active'] if 'active' in settings_node else False)
|
||
HS = config.get_setting('hide_servers') or (
|
||
settings_node['hide_servers'] if 'hide_server' in settings_node else False)
|
||
|
||
return AP, HS
|
||
|
||
def play_multi_channel(item, itemlist):
|
||
logger.info()
|
||
global PLAYED
|
||
video_dict = dict()
|
||
# set_status(True)
|
||
|
||
for video_item in itemlist:
|
||
if is_active(video_item.contentChannel):
|
||
if video_item.contentChannel not in video_dict.keys():
|
||
video_dict[video_item.contentChannel] = [video_item]
|
||
else:
|
||
video_dict[video_item.contentChannel].append(video_item)
|
||
|
||
for channel, videos in video_dict.items():
|
||
item.contentChannel = channel
|
||
if not PLAYED:
|
||
start(videos, item)
|
||
else:
|
||
break
|
||
|
||
AP, HS = get_channel_AP_HS(item)
|
||
return HS |