def __init__(self, download_path, prebuffer_seconds=0, prebuffer_percent=0):
self.video_player = None
self.session = None
self.istreamed = None
# where we want to save download
self.download_path = download_path
# where is gstreamer downloading
self.gst_download_path = None
# pre-buffering
self.prebuffer_percent = prebuffer_percent
self.prebuffer_seconds = prebuffer_seconds
self.prebufferred_seconds = 0
self.prebuffered_percent = 0
self.prebuffering = (self.prebuffer_percent != 0 or self.prebuffer_seconds != 0)
# seek-limit percent
self.seek_limit_percent = 2
# download/buffer state
self.download_percent = 0
self.download_speed = 0
self.download_finished = False
self.buffered_percent = 0
self.buffer_size = 0
self.temp_length = 0
log.debug("GstreamerDownloadController started")
# register download/buffer events
self.__event_tracker = None
def hideList(self):
try:
log.debug('hiding list')
self["menu"].hide()
except:
log.logError("Action [hideList] failed.\n%s"%traceback.format_exc())
pass
def refreshList(self, restoreLastPosition=True):
log.debug("refreshing screen of %s item" , self.parent_it.name)
self.refreshing = True
if restoreLastPosition:
self.contentHandler.open_item(self.parent_it, position=self.getSelectedIndex())
else:
self.contentHandler.open_item(self.parent_it)
def info_item(self, item, mode=None, *args, **kwargs):
"""opens info about item according to defined mode"""
self.item = item
if mode in INFO_HANDLERS and mode in self.info_modes:
self._init_info(item)
log.debug("%s opening info of %s", repr(self), repr(item))
INFO_HANDLERS[mode](self.session, item)
def __init__(self, addon, languages_dir):
self.addon = addon
self._languages_dir = languages_dir
self._language_filename = 'strings.xml'
self.current_language = {}
self.default_language_id = 'en'
self.current_language_id = 'en'
self.languages = {}
log.debug("initializing %s - languages", addon)
if not os.path.isdir(languages_dir):
log.error("%s cannot load languages, missing %s directory", self, os.path.basename(languages_dir))
return
for language_dir in os.listdir(languages_dir):
language_id = self.get_language_id(language_dir)
if language_id is None:
log.error("%s unknown language %s, you need to update Language map to use it, skipping..", self, language_dir)
continue
language_dir_path = os.path.join(languages_dir, language_dir)
language_file_path = os.path.join(language_dir_path, self._language_filename)
if os.path.isfile(language_file_path):
self.languages[language_id] = None
else:
log.error("%s cannot find language file %s, skipping %s language..", self, language_file_path, language_dir)
def __init__(self, addon, languages_dir):
self.addon = addon
self._languages_dir = languages_dir
self._language_filename = 'strings.xml'
self.current_language = {}
self.default_language_id = 'en'
self.current_language_id = 'en'
self.languages = {}
log.debug("initializing %s - languages", addon)
if not os.path.isdir(languages_dir):
log.error("%s cannot load languages, missing %s directory", self,
os.path.basename(languages_dir))
return
for language_dir in os.listdir(languages_dir):
language_id = self.get_language_id(language_dir)
if language_id is None:
log.error(
"%s unknown language %s, you need to update Language map to use it, skipping..",
self, language_dir)
continue
language_dir_path = os.path.join(languages_dir, language_dir)
language_file_path = os.path.join(language_dir_path,
self._language_filename)
if os.path.isfile(language_file_path):
self.languages[language_id] = None
else:
log.error(
"%s cannot find language file %s, skipping %s language..",
self, language_file_path, language_dir)
def _download_update_xml(self):
"""downloads update xml of repository"""
# hack for https github urls
# since some receivers have have problems with https
if self.update_xml_url.find('{commit}') != -1:
from Plugins.Extensions.archivCZSK.settings import PLUGIN_PATH
try:
commit = open(os.path.join(PLUGIN_PATH,
'commit')).readline()[:-1]
except Exception:
commit = '4ff9ac15d461a885f13125125ea501f3b12eb05d'
self.update_xml_url = self.update_xml_url.replace(
'{commit}', commit)
if self.update_xml_url.find('https://raw.github.com') == 0:
update_xml_url = self.update_xml_url.replace(
'https://raw.github.com', 'http://rawgithub.com')
else:
update_xml_url = self.update_xml_url
try:
util.download_to_file(update_xml_url,
self.update_xml_file,
debugfnc=log.debug)
except Exception:
log.debug('cannot download %s update xml', self.repository.name)
raise UpdateXMLVersionError()
def remove_download(self, item):
if item is not None and isinstance(item, PDownload):
log.debug('removing item %s from disk' % item.name)
os.remove(item.path.encode('utf-8'))
else:
log.info('cannot remove item %s from disk, not PDownload instance',
str(item))
def download(self,
item,
startCB,
finishCB,
playDownload=False,
mode="",
overrideCB=None):
"""Downloads item PVideo itemem calls startCB when download starts
and finishCB when download finishes
"""
quiet = False
headers = item.settings['extra-headers']
log.debug("Download headers %s", headers)
downloadManager = DownloadManager.getInstance()
d = downloadManager.createDownload(name=item.name,
url=item.url,
stream=item.stream,
filename=item.filename,
live=item.live,
destination=self.downloads_path,
startCB=startCB,
finishCB=finishCB,
quiet=quiet,
playDownload=playDownload,
headers=headers,
mode=mode)
if item.subs is not None and item.subs != '':
log.debug('subtitles link: %s', item.subs)
subs_file_path = os.path.splitext(d.local)[0] + '.srt'
util.download_to_file(item.subs, subs_file_path)
downloadManager.addDownload(d, overrideCB)
def __del__(self):
log.debug("PosterImageHandler.__del__")
self.retry_timer.stop()
del self.retry_timer_conn
del self.retry_timer
del self.picload_conn
del self.picload
def __init__(self, download_path, prebuffer_seconds=0, prebuffer_percent=0):
self.video_player = None
self.session = None
self.istreamed = None
# where we want to save download
self.download_path = download_path
# where is gstreamer downloading
self.gst_download_path = None
# pre-buffering
self.prebuffer_percent = prebuffer_percent
self.prebuffer_seconds = prebuffer_seconds
self.prebufferred_seconds = 0
self.prebuffered_percent = 0
self.prebuffering = (self.prebuffer_percent != 0 or self.prebuffer_seconds != 0)
# seek-limit percent
self.seek_limit_percent = 2
# download/buffer state
self.download_percent = 0
self.download_speed = 0
self.download_finished = False
self.buffered_percent = 0
self.buffer_size = 0
self.temp_length = 0
log.debug("GstreamerDownloadController started")
# register download/buffer events
self.__event_tracker = None
def info_item(self, item, mode=None, *args, **kwargs):
"""opens info about item according to defined mode"""
self.item = item
if mode in INFO_HANDLERS and mode in self.info_modes:
self._init_info(item)
log.debug("%s opening info of %s", repr(self), repr(item))
INFO_HANDLERS[mode](self.session, item)
def _get_root_content(self):
log.debug("%s getting root content", str(self))
content_provider = self.content_provider
if content_provider:
parent_item = PRoot()
list_items = content_provider.get_content()
return {'lst_items':list_items, 'parent_it':parent_item, 'index':0, 'refresh':False}
def menu_item(self, item, global_context=None, *args, **kwargs):
self.item = item
self.global_context = global_context
self._init_menu(item)
if item.context or global_context:
log.debug("%s opening context menu of %s", repr(self), repr(item))
context.showContextMenu(self.session, item.name, item.thumb, item.context, global_context, self._menu_item_cb)
def removePyOC(pyfile):
if os.path.isfile(pyfile + 'c'):
log.debug('removing %s', (pyfile + 'c'))
os.remove(pyfile + 'c')
elif os.path.isfile(pyfile + 'o'):
log.debug('removing %s', (pyfile + 'o'))
os.remove(pyfile + 'o')
def showList(self):
try:
log.debug('showing list')
self["menu"].show()
except:
log.logError("Action [showList] failed.\n%s"%traceback.format_exc())
pass
def start_video_check(self):
log.debug('starting video_checking')
self.check_timer.start(self.video_check_interval)
self.check_timer_running = True
self.download_interval_check = self.video_check_interval
self.check_position()
def create_xml_item(self, item):
log.logDebug("%s create xml item - %s" % (self, item))
log.debug("{0} create xml item - {1}".format(self, toString(item)))
import time
from datetime import datetime
t = datetime.now()
t1 = t.timetuple()
uid = int(time.mktime(t1))
if item.id:
item.id = uid
#log.logDebug("%s create xml item - %s already exists, skipping"%(self,item))
#log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
#return
item_id = item.get_id()
if self.find_item_by_id(item_id):
item_id = uid
item.id = uid
#log.logDebug("%s create xml item - %s already exists (2), skipping"%(self,item))
#log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
#return
addon_id = item.addon_id
xml_item = SubElement(self.xml_root_element.find('items'), 'item')
xml_item.set('id', toUnicode(item_id))
xml_item.set('ctime', str(datetime.now()))
if addon_id:
xml_item.set('addon_id', toUnicode(addon_id))
name = SubElement(xml_item, 'name')
name.text = toUnicode(item.name)
params = SubElement(xml_item, 'params')
for key, value in item.params.iteritems():
params.set(toUnicode(key), toUnicode(value))
item.id = item_id
return xml_item
def create_xml_item(self, item):
log.logDebug("%s create xml item - %s"%(self,item))
log.debug("{0} create xml item - {1}".format(self, toString(item)))
import time
from datetime import datetime
t = datetime.now()
t1 = t.timetuple()
uid = int(time.mktime(t1))
if item.id:
item.id = uid
#log.logDebug("%s create xml item - %s already exists, skipping"%(self,item))
#log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
#return
item_id = item.get_id()
if self.find_item_by_id(item_id):
item_id = uid
item.id = uid
#log.logDebug("%s create xml item - %s already exists (2), skipping"%(self,item))
#log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item)))
#return
addon_id = item.addon_id
xml_item = SubElement(self.xml_root_element.find('items'), 'item')
xml_item.set('id', toUnicode(item_id))
xml_item.set('ctime', str(datetime.now()))
if addon_id:
xml_item.set('addon_id', toUnicode(addon_id))
name = SubElement(xml_item, 'name')
name.text = toUnicode(item.name)
params = SubElement(xml_item, 'params')
for key, value in item.params.iteritems():
params.set(toUnicode(key), toUnicode(value))
item.id = item_id
return xml_item
def load(self, params):
"""
Loads content of screen from params
params = {'lst_items': list of GUI items which
will be loaded in menulist,
'parent_it': parent item from which
was this content retrieved,
'refresh' : if we want to refresh menulist
from parent item,
'index' : position which will
be selected in menulist after load
}
"""
self.refresh = False
self.input = None
self.lst_items = params['lst_items']
self.parent_it = params['parent_it']
if params['refresh']:
self.refreshList()
else:
log.debug("loading screen of %s item", repr(self.parent_it))
index = 'index' in params and params['index'] or 0
if self.enabled_path and not self.refreshing:
self.updatePath()
self.updateMenuList(index)
def _evUpdatedBufferInfo(self):
if self.playAndDownload:
return
streamed = self.session.nav.getCurrentService().streamed()
bufferInfo = getBufferInfo(streamed)
if (bufferInfo['percentage'] > 95):
self.bufferFull()
if (bufferInfo['percentage'] == 0
and (bufferInfo['avg_in_rate'] != 0
and bufferInfo['avg_out_rate'] != 0)):
self.bufferEmpty()
info = {
'bitrate': 0,
'buffer_percent': bufferInfo['percentage'],
'buffer_secondsleft': bufferInfo['space'],
'buffer_size': bufferInfo['size'],
'download_speed': bufferInfo['avg_in_rate'],
'buffer_slider': 0
}
log.debug(
"BufferPercent %d\nAvgInRate %d\nAvgOutRate %d\nBufferingLeft %d\nBufferSize %d",
bufferInfo['percentage'], bufferInfo['avg_in_rate'],
bufferInfo['avg_out_rate'], bufferInfo['space'],
bufferInfo['size'])
self.updateInfobar(info)
def load(self, params):
"""
Loads content of screen from params
params = {'lst_items': list of GUI items which
will be loaded in menulist,
'parent_it': parent item from which
was this content retrieved,
'refresh' : if we want to refresh menulist
from parent item,
'index' : position which will
be selected in menulist after load
}
"""
self.refresh = False
self.input = None
self.lst_items = params['lst_items']
self.parent_it = params['parent_it']
if params['refresh']:
self.refreshList()
else:
log.debug("loading screen of %s item" , repr(self.parent_it))
index = 'index' in params and params['index'] or 0
if self.enabled_path and not self.refreshing:
self.updatePath()
self.updateMenuList(index)
def setBufferMode(self, mode=None):
if self.playAndDownload:
return
if mode == 3:
log.debug("manual buffer control")
self.useBufferControl = True
def _get_handler(self, item):
for handler in self._handlers:
if handler.can_handle(item):
log.debug("found handler %s" % (handler))
return handler
else:
log.debug("%s cannot handle %s" % (handler, item))
def removePyOC(pyfile):
if os.path.isfile(pyfile + 'c'):
log.debug('removing %s', (pyfile + 'c'))
os.remove(pyfile + 'c')
elif os.path.isfile(pyfile + 'o'):
log.debug('removing %s', (pyfile + 'o'))
os.remove(pyfile + 'o')
def check_addon(self, addon, update_xml=True):
"""
check if addon needs update and if its broken
"""
try:
log.debug("checking updates for %s", addon.name)
self._get_server_addon(addon, update_xml)
broken = self.remote_addons_dict[addon.id]['broken']
remote_version = self.remote_addons_dict[addon.id]['version']
local_version = addon.version
if util.check_version(local_version, remote_version):
log.logDebug("Addon '%s' need update (local %s < remote %s)." % (addon.name, local_version, remote_version))
log.debug("%s local version %s < remote version %s", addon.name, local_version, remote_version)
log.debug("%s is not up to date", addon.name)
return True, broken
else:
log.logDebug("Addon '%s' (%s) is up to date." % (addon.name, local_version))
log.debug("%s local version %s >= remote version %s", addon.name, local_version, remote_version)
log.debug("%s is up to date", addon.name)
return False, broken
except:
log.logError("Check addon '%s' update failed.\n%s" % (addon.name, traceback.format_exc()))
raise
def setBufferMode(self, mode=None):
if self.playAndDownload:
return
if mode == 3:
log.debug("manual buffer control")
self.useBufferControl = True
def save(self):
"""saves current screen to stack"""
log.debug("saving current screen to stack")
self.stack.append({'lst_items':self.lst_items,
'parent_it':copy.copy(self.parent_it),
'refresh':self.refresh,
'index':self["menu"].index})
def showList(self):
try:
log.debug("<%s>: showList"%(self.__class__.__name__))
self.__listboxRenderer.show()
except:
log.logError("Action [showList] failed.\n%s"%traceback.format_exc())
pass
def start_video_check(self):
log.debug('starting video_checking')
self.check_timer.start(self.video_check_interval)
self.check_timer_running = True
self.download_interval_check = self.video_check_interval
self.check_position()
def check_addon(self, addon, update_xml=True):
"""
check if addon needs update and if its broken
"""
try:
log.debug("checking updates for %s", addon.name)
self._get_server_addon(addon, update_xml)
broken = self.remote_addons_dict[addon.id]['broken']
remote_version = self.remote_addons_dict[addon.id]['version']
local_version = addon.version
if util.check_version(local_version, remote_version):
log.logDebug("Addon '%s' need update (local %s < remote %s)." %
(addon.name, local_version, remote_version))
log.debug("%s local version %s < remote version %s",
addon.name, local_version, remote_version)
log.debug("%s is not up to date", addon.name)
return True, broken
else:
log.logDebug("Addon '%s' (%s) is up to date." %
(addon.name, local_version))
log.debug("%s local version %s >= remote version %s",
addon.name, local_version, remote_version)
log.debug("%s is up to date", addon.name)
return False, broken
except:
log.logError("Check addon '%s' update failed.\n%s" %
(addon.name, traceback.format_exc()))
raise
def __init__(self, info_file):
log.info("initializing info of addon from %s" , info_file)
pars = parser.XBMCAddonXMLParser(info_file)
addon_dict = pars.parse()
self.id = addon_dict['id']
self.name = addon_dict['name']
self.version = addon_dict['version']
self.author = addon_dict['author']
self.type = addon_dict['type']
self.broken = addon_dict['broken']
self.path = os.path.dirname(info_file)
self.library = addon_dict['library']
self.script = addon_dict['script']
self.tmp_path = settings.TMP_PATH
self.data_path = os.path.join(config.plugins.archivCZSK.dataPath.getValue(), self.id)
self.profile = self.data_path
# create data_path(profile folder)
util.make_path(self.data_path)
if settings.LANGUAGE_SETTINGS_ID in addon_dict['description']:
self.description = addon_dict['description'][settings.LANGUAGE_SETTINGS_ID]
elif settings.LANGUAGE_SETTINGS_ID == 'sk' and 'cs' in addon_dict['description']:
self.description = addon_dict['description']['cs']
else:
if not 'en' in addon_dict['description']:
self.description = u''
else:
self.description = addon_dict['description']['en']
self.requires = addon_dict['requires']
self.image = os.path.join(self.path, 'icon.png')
#changelog
changelog_path = None
if os.path.isfile(os.path.join(self.path, 'changelog.txt')):
changelog_path = os.path.join(self.path, 'changelog.txt')
elif os.path.isfile(os.path.join(self.path, 'Changelog.txt')):
changelog_path = os.path.join(self.path, 'Changelog.txt')
else:
changelog_path = None
if changelog_path is not None:
with open(changelog_path, 'r') as f:
text = f.read()
try:
self.changelog = text.decode('windows-1250')
except Exception:
log.debug('cannot decode c[C]angleog.txt')
self.changelog = u''
pass
else:
log.debug('c[C]hangelog.txt missing')
self.changelog = u''
def _resolve_video_items(self, result):
def all_done(result_list):
for __, (data, item) in result_list:
tmp_list = []
for stream_dict in get_streams_from_manifest(item.url, data):
video_item = PVideoResolved()
video_item.subs = item.subs
video_item.settings = item.settings.copy()
video_item.url = stream_dict['url']
video_item.quality = "%s b/s" % stream_dict['bandwidth']
video_item.bandwidth = int(stream_dict['bandwidth'])
if 'resolution' in stream_dict:
video_item.quality = stream_dict['resolution'].split(
'x')[1] + "p"
# TODO remove workaround of embedding
# quality in title in addons
video_item.name = name = item.name
quality = video_item.quality
if quality and quality not in name:
if "[???]" in name:
video_item.name = name.replace(
"[???]", "[%s]" % (quality))
else:
video_item.name = "[%s] %s" % (i.quality, i.name)
tmp_list.append(video_item)
tmp_list.sort(key=operator.attrgetter('bandwidth'),
reverse=True)
if tmp_list:
log.info("%s __resolve_video_items: found %d streams" %
(self, len(tmp_list)))
item_list.remove(item)
item_list.extend(tmp_list)
return result
def get_result(res, item):
if isinstance(res, failure.Failure):
log.error("%s _resolve_video_items: %s - %s" %
(self, item.url, res.value))
else:
log.debug("%s _resolve_video_items: %s - %dB" %
(self, item.url, len(res)))
return res, item
item_list, __, __ = result
video_list = [
i for i in item_list
if isinstance(i, PVideoResolved) and is_hls_url(i.url)
]
log.debug("%s _resolve_video_items: found %d resolvable video items" %
(self, len(video_list)))
d_list = []
for item in video_list:
d = url_get_data_async(toString(item.url),
headers=item.settings["extra-headers"],
timeout=5)
d.addBoth(get_result, item)
d_list.append(d)
return defer.DeferredList(d_list,
consumeErrors=True).addCallback(all_done)
def showList(self):
try:
log.debug('showing list')
self["menu"].show()
except:
log.logError("Action [showList] failed.\n%s" %
traceback.format_exc())
pass
def get_localized_string(self, string_id):
if string_id in self.current_language:
return self.current_language[string_id]
else:
log.debug(
"%s cannot find language id %s in %s language, returning id of language",
self, string_id, self.current_language_id)
return str(string_id)
def hideList(self):
try:
log.debug('hiding list')
self["menu"].hide()
except:
log.logError("Action [hideList] failed.\n%s" %
traceback.format_exc())
pass
def showList(self):
try:
log.debug("<%s>: showList" % (self.__class__.__name__))
self.__listboxRenderer.show()
except:
log.logError("Action [showList] failed.\n%s" %
traceback.format_exc())
pass
def get_download_position(self):
if self.video_length_total is None or self.download.length == 0:
return None
download_pts = long(float(self.download.getCurrentLength()) / float(self.download.length) * self.video_length_total)
log.debug('download_time: %dh:%02dm:%02ds' , self.pts_to_hms(download_pts))
self.video_length = download_pts
return download_pts
def _do_eof_internal(self, playing):
log.debug('stopping timers_eof')
if self.check_timer_running and hasattr(self, "check_timer"):
self.check_timer.stop()
if self.buffering_timer_running and hasattr(self, "buffering_timer"):
self.buffering_timer.stop()
log.debug('do_eof_internal')
self.video_player._doEofInternal(playing)
def get_download_position(self):
if self.video_length_total is None or self.download.length == 0:
return None
download_pts = long(float(self.download.getCurrentLength()) / float(self.download.length) * self.video_length_total)
log.debug('download_time: %dh:%02dm:%02ds' , self.pts_to_hms(download_pts))
self.video_length = download_pts
return download_pts
def _do_eof_internal(self, playing):
log.debug('stopping timers_eof')
if self.check_timer_running and hasattr(self, "check_timer"):
self.check_timer.stop()
if self.buffering_timer_running and hasattr(self, "buffering_timer"):
self.buffering_timer.stop()
log.debug('do_eof_internal')
self.video_player._doEofInternal(playing)
def _prebuffer(self):
if self.prebuffering:
self.prebufferred_seconds += 1
self.prebuffered_percent = int(
float(self.download_percent) / float(self.prebuffer_percent) *
100)
log.debug("Prebuffered seconds : %ds, Prebuffered percent %d%%",
self.prebufferred_second, self.prebuffered_percent)
def get_result(res, item):
if isinstance(res, failure.Failure):
log.error("%s _resolve_video_items: %s - %s" %
(self, item.url, res.value))
else:
log.debug("%s _resolve_video_items: %s - %dB" %
(self, item.url, len(res)))
return res, item
def get_result(res, item):
if isinstance(res, failure.Failure):
log.error("%s _resolve_video_items: %s - %s"%(
self, item.url, res.value))
else:
log.debug("%s _resolve_video_items: %s - %dB"%(
self, item.url, len(res)))
return res, item
def create_video_it(name,
url,
subs=None,
image=None,
infoLabels={},
menuItems={},
filename=None,
live=False,
stream=None,
settings=None):
it = PVideoResolved()
it.name = toUnicode(name)
it.url = toUnicode(url)
if subs is not None and subs != "":
it.subs = toUnicode(subs)
it.image = toUnicode(image)
infolabel_uni = {}
for key, value in infoLabels.iteritems():
infolabel_uni[key] = toUnicode(value)
if not 'Title' in infolabel_uni:
infolabel_uni["Title"] = it.name
it.info = infolabel_uni
for key, value in menuItems.iteritems():
item_name = decode_string(key)
thumb = None
if isinstance(value, dict):
params = value
thumb = None
if isinstance(value, list):
thumb = value[0]
params = value[1]
it.add_context_menu_item(item_name, thumb=thumb, params=params)
if filename is not None:
it.filename = toUnicode(filename)
it.live = live
if stream is not None and isinstance(Stream):
it.add_stream(stream)
if settings is not None:
if not isinstance(settings, dict):
log.error("Cannot load settings %s class, it has to be dict class",
settings.__class__.__name__)
else:
if 'user-agent' not in settings:
settings['user-agent'] = ""
if 'extra-headers' not in settings:
settings['extra-headers'] = {}
log.debug("Settings: %s", settings)
it.settings = settings
it.resolved = True
return it
def start(self):
if self.__started:
log.debug("[%s] cannot start, provider is already started", self)
return
self.__started = True
self.__paused = False
for f in self.on_start:
f()
log.debug("[%s] started", self)
def remove_item(self, item):
xml_items = self.xml_root_element.find('items')
xml_item = self.find_item_by_id(item.id)
if xml_item is None:
log.debug('{0} remove_item - {1} not found'.format(self, toString(item)))
else:
xml_items.remove(xml_item)
log.debug('{0} remove_item - {1} successfully removed'.format(self, toString(item)))
item.id = None
def get_info(self, info):
try:
atr = getattr(self.info, '%s' % info)
except Exception:
print traceback.print_exc()
log.debug("get_info cannot retrieve info")
return None
else:
return atr
def remove_item(self, item):
xml_items = self.xml_root_element.find('items')
xml_item = self.find_item_by_id(item.id)
if xml_item is None:
log.debug('{0} remove_item - {1} not found'.format(self, item))
else:
xml_items.remove(xml_item)
log.debug('{0} remove_item - {1} successfully removed'.format(self, item))
item.id = None
def set_language(self, language_id):
if self.has_language(language_id):
if self.languages[language_id] is None:
self.load_language(language_id)
log.debug("setting current language %s to %s", self.current_language_id, language_id)
self.current_language_id = language_id
self.current_language = self.languages[language_id]
else:
log.debug("%s cannot set language %s, language is not available", self, language_id)
def update_addons(self, addons):
"""update addons in repository, according to their state"""
log.debug('updating addons')
update_success = []
for addon in addons:
if addon.need_update():
if addon.update():
update_success.append(update_success)
return update_success
def update_addons(self, addons):
"""update addons in repository, according to their state"""
log.debug('updating addons')
update_success = []
for addon in addons:
if addon.need_update():
if addon.update():
update_success.append(update_success)
return update_success
def stop(self):
if not self.__started:
log.debug("[%s] cannot stop, provider is already stopped", self)
return
self.__started = False
self.__paused = False
for f in self.on_stop:
f()
log.debug("[%s] stopped", self)
def save(self):
"""saves current screen to stack"""
log.debug("saving current screen to stack")
self.old_stack_len = len(self.stack)
self.stack.append({'lst_items':self.lst_items,
'parent_it':copy.copy(self.parent_it),
'refresh':self.refresh,
'index':self["menu"].index})
def __ev_updated_download_status(self):
if self.istreamed is None:
return
info = getBufferInfo(self.istreamed)
self.download_speed = info['avg_in_rate']
self.download_percent = info['download_percent']
self.buffered_percent = info['percentage']
self.buffer_size = info['size']
log.debug('download_percent: %d, buffer_size %lu', self.download_percent, self.buffer_size)
self._update()
def get_setting(self, setting_id):
try:
setting = getattr(self.main, '%s' % setting_id)
except (ValueError, KeyError):
log.debug('%s cannot retrieve setting %s, Invalid setting id', self, setting_id)
return ""
else:
if isinstance(setting, ConfigIP):
return setting.getText()
return setting.getValue()
def set_setting(self, setting_id, value):
try:
setting = getattr(self.main, '%s' % setting_id)
except ValueError:
log.debug('%s cannot retrieve setting %s, Invalid setting id', self, setting_id)
return False
else:
setting.setValue(value)
setting.save()
return True
def resolveCommand(self, command, arg):
print arg
log.debug("resolving %s command " , str(command))
if command is None:
pass
elif command == 'refreshnow':
self.refreshList()
else:
log.debug("unknown command %s" , command)
def toggleCancelLoading(self):
if Task.getInstance() is not None and not Task.getInstance().isCancelling():
self["status_label"].setText("Canceling...")
Task.getInstance().setCancel()
elif Task.getInstance() is not None and Task.getInstance().isCancelling():
self["status_label"].setText("Loading...")
Task.getInstance().setResume()
else:
log.debug("Task is not running")
def _exit_video_player(self):
log.debug('stopping timers_exit')
if self.check_timer_running:
self.check_timer.stop()
if self.buffering_timer_running:
self.buffering_timer.stop()
del self.check_timer
del self.buffering_timer
log.debug('exiting service')
self.video_player._exitVideoPlayer()
