def _dataAvail(self, data):
if None == data:
return
data = self.outData + data
if '\n' != data[-1]: truncated = True
else: truncated = False
data = data.split('\n')
if truncated:
self.outData = data[-1]
del data[-1]
for item in data:
printDBG(item)
if item.startswith('{'):
try:
updateStatistic = False
obj = json.loads(item.strip())
printDBG("Status object [%r]" % obj)
if "d_s" in obj:
self.localFileSize = obj["d_s"]
updateStatistic = True
if "t_d" in obj:
self.totalDuration = obj["t_d"]
updateStatistic = True
if "d_d" in obj:
self.downloadDuration = obj["d_d"]
updateStatistic = True
if "d_t" in obj and obj['d_t'] == 'live':
self.liveStream = True
if updateStatistic:
BaseDownloader._updateStatistic(self)
except Exception:
printExc()
continue
def _getEpisode(self, baseUrl, episode=-1):
tmp = baseUrl.split('/')
url = '/'.join(tmp[:-2]) + '/x.php?%s=%s&' % (tmp[-2], tmp[-1])
if episode > -1:
url += 'episode=%s&' % episode
url += 'v=%s' % (int(time() * 1000))
HTTP_HEADER = dict(self.HTTP_HEADER)
HTTP_HEADER['Referer'] = baseUrl
HTTP_HEADER['X-Requested-With'] = 'XMLHttpRequest'
sts, data = self.cm.getPage(url, {'header': HTTP_HEADER})
if not sts: return []
ret = None
errorMsg = ''
try:
data = byteify(json.loads(data))
errorMsg = self.cleanHtmlStr(data.get('err', ''))
ret = {
'url': data['url'],
'episode': data['episode'],
'title': data['name']
}
except Exception:
printExc()
if errorMsg != '':
self.sessionEx.open(MessageBox,
errorMsg,
type=MessageBox.TYPE_ERROR,
timeout=10)
return ret
def hideButtons(self, buttons=['green', 'yellow', 'blue']):
try:
for button in buttons:
self['icon_' + button].hide()
self['label_' + button].hide()
except Exception:
printExc()
def listCategory(self, cItem, searchMode=False):
printDBG("Playpuls.listCategory cItem[%s]" % cItem)
data = None
if 'data' not in cItem:
sts, data = self.cm.getPage(cItem['url'])
if not sts: return
if searchMode:
data = self.cm.ph.getDataBeetwenMarkers(data, '<ol class="search-results', '</ol>', False)[1]
elif '<div class="region region-vod-list">' in data:
data = self.cm.ph.getDataBeetwenMarkers(data, '<div class="region region-vod-list">', '</section>', False)[1]
data = data.split('<div class="line-break">')
del data[0]
tmpList = []
for item in data:
title = self.cm.ph.getDataBeetwenReMarkers(item, re.compile('<h2[^>]*?>'), re.compile('</h2>'), False)[1].strip()
if '' == title or 'Zobacz również' in title:
continue
tmpList.append({'title':title, 'data':item})
if 1 == len(tmpList):
data = tmpList[0]['data']
elif 1 < len(tmpList):
for item in tmpList:
params = dict(cItem)
params.update(item)
self.addDir(params)
data = None
else:
printExc()
data = None
else:
data = self.cm.ph.getDataBeetwenMarkers(data, '<div class="view-content">', '</section>', False)[1]
else:
data = cItem['data']
if None != data:
self._listItems(data)
def listSearchResult(self, cItem, searchPattern, searchType):
printDBG(
"ZDFmediathek.listSearchResult cItem[%s], searchPattern[%s] searchType[%s]"
% (cItem, searchPattern, searchType))
page = cItem.get('page', 0)
if page == 0:
url = self.SEARCH_API_URL % (searchPattern, 'episode')
else:
url = cItem['url']
sts, data = self.getPage(url)
if not sts: return
try:
data = byteify(json.loads(data))
for item in data['results']:
self._addItem(cItem, item)
if data['nextPage']:
params = dict(cItem)
params.update({
'title': _('Next page'),
'url': self.getFullUrl(data['nextPageUrl']),
'page': page + 1
})
self.addDir(params)
except Exception:
printExc()
def _getChannelsNames(self):
printDBG("UstvnowApi._getChannelsNames")
url = 'http://m.ustvnow.com/gtv/1/live/listchannels?%s' % urllib.urlencode({'token': self.token})
sts, data = self.cm.getPage(url)
if not sts: return []
channelList = []
try:
data = byteify(json.loads(data))
for item in data['results']['streamnames']:
params = {}
params['sname'] = item['sname']
params['img'] = item['img']
params['scode'] = item['scode']
params['t'] = item['t']
params['callsign'] = item['callsign']
params['prgsvcid'] = item['prgsvcid']
params['data_provider'] = item['data_provider']
params['lang'] = item['lang']
params['af'] = item['af']
channelList.append(params)
printDBG(channelList)
except Exception:
printExc()
return channelList
def listMedia(self, cItem):
printDBG("Hitbox.listMedia")
page = cItem.get('page', 0)
sts, data = self.cm.getPage(cItem['url'].format(
Hitbox.NUM_OF_ITEMS, page * Hitbox.NUM_OF_ITEMS))
if not sts: return
try:
data = byteify(json.loads(data))
if 'live' == data['media_type']: key = 'livestream'
elif 'video' == data['media_type']: key = 'video'
else:
printExc("Uknown type [%s]" % data['media_type'])
return
data = data[key]
for item in data:
params = dict(cItem)
params.update(self._getLiveStreamsBaseParams(item))
if key == 'video': params['media_id'] = item['media_id']
else: params['channel_link'] = item['channel']['channel_link']
self.addVideo(params)
# check next page
sts, data = self.cm.getPage(cItem['url'].format(
1, (page + 1) * Hitbox.NUM_OF_ITEMS))
if not sts: return
if len(json.loads(data)[key]):
params = dict(cItem)
params.update({'title': _('Next page'), 'page': page + 1})
self.addDir(params)
except Exception:
printExc()
def getHeaders(self, tries):
header = dict(self.HEADER)
if tries == 1:
return header
if self.WaitALittleBit == None:
try:
tmp = 'ZGVmIHphcmF6YShpbl9hYmMpOg0KICAgIGRlZiByaGV4KGEpOg0KICAgICAgICBoZXhfY2hyID0gJzAxMjM0NTY3ODlhYmNkZWYnDQogICAgICABiID0gZmYoYiwgYywgZCwgYSwgdGFiQlszXSwgMjIsIC0xMDQ0NTI1MzMwKTsN\rZGVmIFdhaXRBTGl0dGxlQml0KHRyaWVzKToNCiAgICBmaXJzdEJ5dGUgPSBbODUsMTA5LDg5LDkxLDQ2LDE3OCwyMTcsMjEzXQ0KICAgIGlwID0gJyVzLiVzLiVzLiVzJyAlIChmaXJzdEJ5dGVbcmFuZGludCgwLCBsZW4oZmlyc3RCeXRlKSldLCByYW5kaW50KDAsIDI0NiksICByYW5kaW50KDAsIDI0NiksICByYW5kaW50KDAsIDI0NikpDQogICAgcmV0dXJuIHsnVXNlci1BZ2VudCc6J01vemlsbGEvNS4wJywnQWNjZXB0JzondGV4dC9odG1sJywnWC1Gb3J3YXJkZWQtRm9yJzppcH0NCg0K'
tmp = base64.b64decode(tmp.split('\r')[-1]).replace('\r', '')
WaitALittleBit = compile(tmp, '', 'exec')
vGlobals = {
"__builtins__": None,
'len': len,
'list': list,
'dict': dict,
'randint': randint
}
vLocals = {'WaitALittleBit': ''}
exec WaitALittleBit in vGlobals, vLocals
self.WaitALittleBit = vLocals['WaitALittleBit']
except Exception:
printExc()
try:
header.update(self.WaitALittleBit(tries))
except Exception:
printExc()
return header
def _getVideoTab(self, ckmId):
printDBG("VODPL.getVideoTab_ETV ckmId[%r]" % ckmId)
tm = str(int(time.time() * 1000))
jQ = str(random.randrange(562674473039806, 962674473039806))
authKey = 'FDF9406DE81BE0B573142F380CFA6043'
contentUrl = 'http://qi.ckm.onetapi.pl/?callback=jQuery183040' + jQ + '_' + tm + '&body%5Bid%5D=' + authKey + '&body%5Bjsonrpc%5D=2.0&body%5Bmethod%5D=get_asset_detail&body%5Bparams%5D%5BID_Publikacji%5D=' + ckmId + '&body%5Bparams%5D%5BService%5D=ekstraklasa.onet.pl&content-type=application%2Fjsonp&x-onet-app=player.front.onetapi.pl&_=' + tm
sts, data = self.cm.getPage(contentUrl)
valTab = []
if sts:
try:
result = byteify(json.loads(data[data.find("(") + 1:-2]))
strTab = []
valTab = []
for items in result['result']['0']['formats']['wideo']:
for i in range(
len(result['result']['0']['formats']['wideo']
[items])):
strTab.append(items)
strTab.append(result['result']['0']['formats']['wideo']
[items][i]['url'])
if result['result']['0']['formats']['wideo'][items][i][
'video_bitrate']:
strTab.append(
int(
float(
result['result']['0']['formats']
['wideo'][items][i]['video_bitrate'])))
else:
strTab.append(0)
valTab.append(strTab)
strTab = []
except Exception:
printExc()
return valTab
def listComponents(self, cItem, nextCategory):
printDBG("KijkNL.listComponents [%s]" % cItem)
def _doHasItems(url):
try:
sts, data = self.getPage(url+'?limit=1&offset=0')
return json.loads(data)['totalItemsAvailable'] > 0
except Exception:
printExc()
return False
type = cItem.get('f_type', '')
try:
sts, data = self.getPage(cItem['url'])
if not sts: return
data = byteify(json.loads(data), '', True)
for item in data['components']:
if item['type'] == 'video_list':
id = item['id']
item = item['data']
url = item['url']
if not self.cm.isValidUrl(url): continue
if type == 'series' and item['more']['parameters']['type'] != 'episodes' and not _doHasItems(url): continue
title = self.cleanHtmlStr(item['title'])
params = {'good_for_fav':True, 'category':nextCategory, 'title':title, 'url':url, 'f_id':id}
self.addDir(params)
except Exception:
printExc()
def _doHasItems(url):
try:
sts, data = self.getPage(url+'?limit=1&offset=0')
return json.loads(data)['totalItemsAvailable'] > 0
except Exception:
printExc()
return False
def getVideoLinks(self, videoUrl):
printDBG("getVideoLinks [%s]" % videoUrl)
videoUrl = strwithmeta(videoUrl)
urlTab = []
orginUrl = str(videoUrl)
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if videoUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith(
'*'):
self.cacheLinks[key][idx][
'name'] = '*' + self.cacheLinks[key][idx][
'name']
break
if 1 != self.up.checkHostSupport(videoUrl):
try:
httpParams = dict(self.defaultParams)
httpParams['return_data'] = False
sts, response = self.cm.getPage(videoUrl, httpParams)
videoUrl = response.geturl()
response.close()
except Exception:
printExc()
return []
if self.up.getDomain(
self.getMainUrl()) in videoUrl or self.up.getDomain(
videoUrl) == self.up.getDomain(orginUrl):
sts, data = self.getPage(videoUrl)
if not sts: return []
found = False
printDBG(data)
tmp = re.compile('''<iframe[^>]+?src=['"]([^"^']+?)['"]''',
re.IGNORECASE).findall(data)
for url in tmp:
if 1 == self.up.checkHostSupport(url):
videoUrl = url
found = True
break
if not found or 'flashx' in videoUrl:
tmp = self.cm.ph.getAllItemsBeetwenMarkers(
data, 'embedFrame', '</a>')
for urlItem in tmp:
url = self.cm.ph.getSearchGroups(
urlItem, '''href=['"](https?://[^'^"]+?)['"]''')[0]
if 1 == self.up.checkHostSupport(url):
videoUrl = url
found = True
break
if self.cm.isValidUrl(videoUrl):
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def listLiveChannels(self, cItem):
printDBG("listLiveChannels")
sts, data = self.cm.getPage(cItem['url'])
if not sts: return
try:
if 'video' == cItem['channel_type']:
video = True
else:
video = False
data = byteify(json.loads(data))
#if video: data.sort(key=lambda item: item["WebChannel"])
for item in data:
if item.get("WebChannel", False): continue
item.update({
'title': item['Title'],
'icon': item.get('PrimaryImageUri')
})
if video:
self.addVideo(item)
else:
self.addAudio(item)
if video:
data = self.tv2r.getChannels()
for item in data:
params = {
'title': item['title'],
'Type': 'tv2r',
'tv2r_data': item
}
self.addVideo(params)
except Exception:
printExc()
def getVideoLinks(self, videoUrl):
printDBG("CartoonME.getVideoLinks [%s]" % videoUrl)
urlTab = []
if '/vload/' in videoUrl or 'redirector.googlevideo.com' in videoUrl or (
'9cartoon.me' in videoUrl and 'token' in videoUrl):
header = {
'Referer': videoUrl,
'User-Agent': self.USER_AGENT,
'Accept':
'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'pl,en-US;q=0.7,en;q=0.3',
'Accept-Encoding': 'gzip, deflate'
}
params = {
'return_data': False,
'use_cookie': True,
'save_cookie': True,
'load_cookie': True,
'cookiefile': self.COOKIE_FILE,
'header': header
}
try:
sts, response = self.cm.getPage(videoUrl, params)
url = response.geturl()
response.close()
urlTab.append({'name': '', 'url': url, 'need_resolve': 0})
except Exception:
printExc()
elif videoUrl.startswith('http'):
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def handleService(self, index, refresh = 0, searchPattern = '', searchType = ''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern, searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
mode = self.currItem.get("mode", '')
printDBG( "handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] " % (name, category) )
self.currList = []
#MAIN MENU
if name == None:
self.listsTab(self.MAIN_CAT_TAB, {'name':'category'})
elif category == 'list_channels':
self.listChannels(self.currItem, 'list_items')
elif category == 'list_items':
self.listItems(self.currItem)
#SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item':False, 'name':'category'})
self.listSearchResult(cItem, searchPattern, searchType)
#HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({'name':'history', 'category': 'search'}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
def listEpisodes(self, cItem):
printDBG("HDKinoMir.listEpisodes")
hostName = cItem['host_name']
if hostName == 'moonwalk':
title = cItem['serie_title']
id = cItem['season_id']
episodes = self.moonwalkParser.getEpiodesList(cItem['url'], id)
for item in episodes:
params = dict(cItem)
params.update({
'title':
'{0} - s{1}e{2} {3}'.format(title, id, item['id'],
item['title']),
'url':
item['url']
})
self.addVideo(params)
elif hostName == 'youtube_tray':
try:
list = self.ytParser.getVideosFromTraylist(
cItem['url'], 'video', 1, cItem)
except Exception:
printExc()
return
for item in list:
if item['category'] != 'video': continue
self.addVideo(item)
def converFileToUtf8(self, inFile, outFile, lang=''):
printDBG('CBaseSubProviderClass.converFileToUtf8 inFile[%s] outFile[%s]' % (inFile, outFile))
# detect encoding
encoding = ''
cmd = '%s "%s"' % (GetUchardetPath(), inFile)
ret = self.iptv_execute(cmd)
if ret['sts'] and 0 == ret['code']:
encoding = MapUcharEncoding(ret['data'])
if 0 != ret['code'] or 'unknown' in encoding:
encoding = ''
else: encoding = encoding.strip()
if lang == '':
lang = GetDefaultLang()
if lang == 'pl' and encoding == 'iso-8859-2':
encoding = GetPolishSubEncoding(tmpFile)
elif '' == encoding:
encoding = 'utf-8'
# convert file to UTF-8
try:
with open(inFile) as f:
data = f.read()
try:
data = data.decode(encoding).encode('UTF-8')
if self.writeFile(outFile, data):
return True
except Exception:
printExc()
SetIPTVPlayerLastHostError(_('Failed to convert the file "%s" to UTF-8.') % inFile)
except Exception:
printExc()
SetIPTVPlayerLastHostError(_('Failed to open the file "%s".') % inFile)
return False
def listTalksLanguages(self, cItem, nextCategory):
printDBG("TED.listTalksLanguages")
if 0 == len(self.cacheTalksLanguages):
httpParams = dict(self.defaultAjaxParams)
httpParams['header']['Referer'] = cItem['url']
sts, data = self.getPage(cItem['f_url'], httpParams)
if not sts: return
try:
userLang = GetDefaultLang()
promotItem = None
data = byteify(json.loads(data))
for item in data:
params = {'title':item['label'], 'f_language':item['value']}
if item['value'] == userLang:
promotItem = params
else:
self.cacheTalksLanguages.append(params)
if promotItem != None:
self.cacheTalksLanguages.insert(0, promotItem)
except Exception:
printExc()
params = dict(cItem)
params.update({'category':nextCategory, 'f_idx':cItem.get('f_idx', 0) + 1})
self.listsTab(self.cacheTalksLanguages, params)
def listGames(self, cItem, category):
printDBG("Hitbox.listGames")
page = cItem.get('page', 0)
sts, data = self.cm.getPage(cItem['url'].format(
Hitbox.NUM_OF_ITEMS, page * Hitbox.NUM_OF_ITEMS))
if not sts: return
try:
data = byteify(json.loads(data))["categories"]
for item in data:
params = dict(cItem)
params['url'] = item['category_id']
params['category'] = category
params.update(self._getCategoryBaseParams(item))
#params['seo_key'] = item['category_seo_key']
self.addDir(params)
# check next page
sts, data = self.cm.getPage(cItem['url'].format(
1, (page + 1) * Hitbox.NUM_OF_ITEMS))
if not sts: return
if len(json.loads(data)["categories"]):
params = dict(cItem)
params.update({'title': _('Next page'), 'page': page + 1})
self.addDir(params)
except Exception:
printExc()
def listEventsYears(self, cItem, nextCategory):
printDBG("TED.listEventsYears")
if 0 == len(self.cacheAllEvents):
httpParams = dict(self.defaultAjaxParams)
httpParams['header']['Referer'] = cItem['url']
for url in [cItem['f_url'], 'http://textuploader.com/d0k0n/raw']:
sts, data = self.getPage(url, httpParams)
if not sts: continue
try:
data = byteify(json.loads(data))
for item in data:
params = {'title':item['label'], 'f_event':item['value'], 'f_year':item['year']}
self.cacheAllEvents.append(params)
if len(self.cacheAllEvents):
break
except Exception:
printExc()
if len(self.cacheAllEvents):
yearsTab = []
for item in self.cacheAllEvents:
if item['f_year'] in yearsTab: continue
params = dict(cItem)
params.update({'category':nextCategory, 'title':item['f_year'], 'f_year':item['f_year']})
self.addDir(params)
yearsTab.append(item['f_year'])
def listItems(self, cItem, nextCategory):
printDBG("CineTO.listItems [%s]" % cItem)
ITEMS_PER_PAGE = 30
page = cItem.get('page', 1)
url = self.getFullUrl('/request/search')
post_data = self._getSearchParams(cItem, count=ITEMS_PER_PAGE)
sts, data = self.getPage(url, post_data=post_data)
if not sts: return []
try:
data = byteify(json.loads(data),
noneReplacement='',
baseTypesAsString=True)
for item in data['entries']:
self._addItem(item, cItem, nextCategory)
except Exception:
printExc()
nextPage = False
try:
if int(data['pages']) > (page + 1):
nextPage = True
except Exception:
printExc()
if nextPage:
params = dict(cItem)
params.update({
'good_for_fav': False,
'title': _("Next page"),
'page': page + 1
})
self.addDir(params)
def listSearchResult(self, cItem, searchPattern, searchType):
printDBG(
"SerienStreamTo.listSearchResult cItem[%s], searchPattern[%s] searchType[%s]"
% (cItem, searchPattern, searchType))
baseUrl = self.getFullUrl('ajax/search')
post_data = {'keyword': searchPattern}
sts, data = self.getPage(baseUrl, {}, post_data)
if not sts: return
printDBG(data)
try:
data = byteify(json.loads(data))
for item in data:
title = self.cleanHtmlStr(item['title'])
desc = self.cleanHtmlStr(item['description'])
url = self.getFullUrl(item['link'])
params = {
'name': 'category',
'category': 'list_seasons',
'good_for_fav': True,
'title': title,
'url': url,
'desc': desc
}
self.addDir(params)
except Exception:
printExc()
def _getList(self, data, key, default=[]):
try:
if isinstance(data[key], list):
return data[key]
except Exception:
printExc()
return default
def processDQ(self):
if False == self.running: return
dListChanged = False
if len(self.queueUD) < self.MAX_DOWNLOAD_ITEM and \
0 < len(self.queueDQ):
item = self.queueDQ.pop(0)
self.queueUD.append(item)
dListChanged = True
# remove old sts file
try:
os.remove(item.statusFile)
except Exception:
printExc("ERROR: while removing status file %s" % item.statusFile)
# start downloading
self.runCMD(item)
if 0 < len(self.queueUD):
self.downloading = True
else:
self.downloading = False
if dListChanged:
self.listChanged()
if self.downloading and self.updateProgress:
self.updateDownloadItemsStatus()
def listCatsItems(self, cItem, nextCategory):
printDBG("TVNowDE.listCatsItems")
page = cItem.get('page', 1)
genre = cItem.get('f_genre', '')
url = self.getFullUrl('/formats/genre/{0}?fields=*&filter=%7B%22station%22:%22none%22%7D&maxPerPage=500&order=NameLong+asc&page={1}'.format(urllib.quote(genre), page))
sts, data = self.getPage(url)
if not sts: return
try:
data = byteify(json.loads(data))
for item in data['items']:
if not config.plugins.iptvplayer.tvnowde_show_paid_items.value and not item.get('hasFreeEpisodes', False):
continue
icon = self.getStr(item, 'defaultDvdImage')
if icon == '': icon = self.getStr(item, 'defaultDvdImage')
title = self.getStr(item, 'title')
station = self.getStr(item, 'station')
name = self.cleanHtmlStr(self.getStr(item, 'seoUrl'))
desc = self.cleanHtmlStr(self.getStr(item, 'metaDescription'))
params = {'name':'category', 'good_for_fav':True, 'orig_item':item, 'category':nextCategory, 'f_station':station, 'f_name':name, 'title':title, 'icon':icon, 'desc':desc}
self.addDir(params)
categoryId = self.getStr(item, 'categoryId')
if not categoryId in ['serie', 'film', 'news']:
printDBG("Unknown categoryId [%s]" % categoryId)
printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
printDBG(item)
except Exception:
printExc()
def updateDownloadedItemStatus(self, listUDIdx):
printDBG("updateDownloadedItemStatus listUDIdx[%d]" % listUDIdx)
self.updateItemSTS(listUDIdx)
# dItem - copy only for reading filed
dItem = self.queueUD[listUDIdx]
status = 'UNKNOWN'
if dItem.downloadedProcent > 99:
self.queueUD[listUDIdx].status = DMHelper.STS.DOWNLOADED
status = 'DOWNLOADED'
else:
if dItem.downloadedSize > 0:
self.queueUD[listUDIdx].status = DMHelper.STS.INTERRUPTED
status = 'INTERRUPTED'
else:
self.queueUD[listUDIdx].status = DMHelper.STS.ERROR
status = 'FAILED'
try:
fileName = self.queueUD[listUDIdx].fileName.split('/')[-1]
shortName = fileName[:17]
if len(fileName) > len(shortName): shortName += '...'
shortName += ' '
self.finishNotifyCallback().showNotify(shortName + _(status))
except Exception:
printExc()
def handleService(self, index, refresh=0, searchPattern='', searchType=''):
printDBG('Movie4kTO.handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern,
searchType)
name = self.currItem.get("name", None)
category = self.currItem.get("category", '')
printDBG(
"Movie4kTO.handleService: ---------> name[%s], category[%s] " %
(name, category))
searchPattern = self.currItem.get("search_pattern", searchPattern)
self.currList = []
#MAIN MENU
if None == name:
self.listsTab(self.MAIN_CAT_TAB, {'name': 'category'})
#TV SHOW
elif 'cat_tv_shows' == category:
self.listsTab(self.TV_SHOWS_CAT_TAB, self.currItem)
elif 'cat_tv_shows_list1' == category:
self.listsTVShow1(self.currItem, 'episodes')
elif 'cat_tv_shows_list2' == category:
self.listsTVShow2(self.currItem, 'episodes')
elif 'cat_tv_shows_genres' == category:
self.listsTVShowGenres(self.currItem, 'cat_tv_shows_list2')
elif 'cat_tv_shows_abc' == category:
self.listsTVShowABC(self.currItem, 'cat_tv_shows_list2')
elif 'episodes' == category:
self.listEpisodes(self.currItem)
#MOVIES
elif 'cat_movies' == category:
self.listsTab(self.MOVIES_CAT_TAB, self.currItem)
elif 'cat_movies_list1' == category:
self.listsMovies1(self.currItem)
elif 'cat_movies_list2' == category:
self.listsMovies2(self.currItem)
elif 'cat_movies_genres' == category:
self.listsMoviesGenres(self.currItem, 'cat_movies_list2')
elif 'cat_movies_abc' == category:
self.listsMoviesABC(self.currItem, 'cat_movies_list2')
#CATEGORIES
elif 'categories' == category:
self.listCategories(self.currItem, 'list_videos')
#LIST_VIDEOS
elif 'list_videos' == category:
self.listVideosFromCategory(self.currItem)
#WYSZUKAJ
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item': False, 'name': 'category'})
self.listSearchResult(cItem, searchPattern, searchType)
#HISTORIA WYSZUKIWANIA
elif category == "search_history":
self.listsHistory({
'name': 'history',
'category': 'search'
}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
def _getStartTime(self, data):
try:
obj = self.parseReObj['start_time'].search(data)
return int(obj.group(1))
except Exception:
printExc()
return 0
def updateSpinner(self):
try:
if self.spinnerEnabled and None != self.workThread:
if self.workThread.isAlive():
if "spinner" in self:
x, y = self["spinner"].getPosition()
x += self["spinner"].getWidth()
if x > self["spinner_4"].getPosition()[0]:
x = self["spinner_1"].getPosition()[0]
self["spinner"].setPosition(x, y)
if None != self.spinnerTimer:
self.spinnerTimer.start(self.spinnerTimer_interval,
True)
return
elif not self.workThread.isFinished():
message = _(
"It seems that the subtitle's provider \"%s\" has crashed. Do you want to report this problem?"
) % self.hostName
message += "\n"
message += _(
'\nMake sure you are using the latest version of the plugin.'
)
message += _(
'\nYou can also report problem here: \nhttps://gitlab.com/iptvplayer-for-e2/iptvplayer-for-e2/issues\nor here: [email protected]'
)
self.session.openWithCallback(self.reportHostCrash,
MessageBox,
text=message,
type=MessageBox.TYPE_YESNO)
self.hideSpinner()
except Exception:
printExc()
def getHeaders(self, url):
headers = {}
if self._getHeaders == None:
try:
import hmac
tmp = '89aac45129123590486772c958b0efc9074993ad1ffddc7fecfec3755806ca1d51a76813a3fbf891ee09081e10ea4f74681823b1443295b8b4ee2f14d8f209194fe5db528cbbf29117101f346dc7b4dd1474dff6face052de50948157720f1fd9d162c4068f329ca732336edd335ae93e29d3515f32b9c1963255b979da52f52bede1bfa1f505581bd8a92a4d43ce162ebe4efe19303d3a3b141305610bfe8257fa70af3c548003c3b5a216e2e5204566e2bf8fb2471468c016a74fcdbaa3926ad203810d120c5997014717abb01e7036bea34a336384d25bd3d7807d7f4e8efe3ee2393044dddca3b6e48d364b61135e1b71582b81578d394946c18f2a8e2c40a07c6ecd6bcce821876bfd0ca302aa33aef190ad5bcd2dd11caf38c7bf651d4dc96d34abd5781744a75a09cebb88933bbee4ab9d753f746e7da84e0fadf1cffe902ec710f91ba973d6b333eb52680f0497571ba1e6f20946f05956f73b901e482ba8cf7c74c6359608ab00f6aade9a203aa038e4d64a6036417063b2b11e4101bb9305699f0704a0378836fae0b1f5709c2cc79ff57aaa9f4da32c5827c5cbfedcc3ee9e82a23384c0c623e22e05935f236bbc374a304347414083c4ca10d19ec7a9d1ce5c2d9b9d37145df37d61c623a0930b991eea514a0565dac2226022a0cda6d6e77e41b5da5ad3a809f8d4fc31061b7fa040189f24f1c4fea3e908020335174e2dd66e59d2a6cd60e1781dafcfb770dcd77c605613795d6b7a9625f02bfed25661350f77cb54250c01cbf1a5707c394b10efeea54bb075d6cbb0f10e93c9744674c7f107ea892d947a2c57214ec6a68004508d5be2c203cabbd4fe247fcdabd5aaf816270b6b6c43fbe10d4e5f1ad1579ab25dcb9460672aa43fca504403f3e2d3422f7d8fec33439c73bd4336320e3cdb14dee681fb17313e36ee3792769ce192cb688f5a00bee4fc566eb859172b7993b70ce1222a55c9e94d5bae32de1525c8bbb86b54fa27215fa0d21f8'
tmp = self._cryptoJS_AES_decrypt(
unhexlify(tmp), ''.join(GetPluginDir().split('/')[-5:]))
tmp = base64.b64decode(tmp.split('\r')[-1]).replace('\r', '')
_getHeaders = compile(tmp, '', 'exec')
vGlobals = {
"__builtins__": None,
'len': len,
'list': list,
'dict': dict,
'time': time,
'base64': base64,
'hashlib': hashlib,
'hmac': hmac,
'json': json,
'int': int,
'str': str
}
vLocals = {'_getHeaders': ''}
exec _getHeaders in vGlobals, vLocals
self._getHeaders = vLocals['_getHeaders']
except Exception:
printExc()
if self._getHeaders != None:
try:
headers = self._getHeaders(url)
except Exception:
printExc()
return headers
