def __getElsFromUrl(self, url):
result = None
hasMore = False
data = self.getJson(url)
kodiutils.log('__getElsFromUrl: {}'.format(str(data)), 4)
if data and 'isOk' in data and data['isOk']:
if 'response' in data:
response = data['response']
metadata = response[
'metadata'] if 'metadata' in response else {}
if 'error' in metadata and metadata['error']:
kodiutils.log('Error: {}'.format(str(metadata['error'])),
1)
kodiutils.notify('Timeout caricamento dati',
icon=kodiutils.getMedia('notify.png'))
return [], None
if 'hasMore' in response:
hasMore = response['hasMore']
elif 'pagination' in metadata:
pagination = metadata['pagination']
hitsPerPage = int(pagination['hitsPerPage']
) if 'hitsPerPage' in pagination else 0
totalHits = int(pagination['totalHits']
) if 'totalHits' in pagination else 0
if totalHits and totalHits == hitsPerPage:
hasMore = totalHits
if 'entries' in response:
result = response['entries']
else:
result = response
elif 'entries' in data:
result = data['entries']
return result, hasMore
def menuItems(self,
isDeletable=False,
delete_list='',
item_id='',
guid='',
context_ui=''):
kodiutils.log(
'menuItems: isDeletable={},delete_list={},item_id={},guid={},context_ui={}'
.format(isDeletable, delete_list, item_id, guid, context_ui))
menuItems = []
if self.isAnonimous:
return menuItems
if isDeletable:
if delete_list == 'favorites' and item_id:
menuItems.append((
'Rimuovi (MediasetPlay)',
"RunPlugin(plugin://{}/?mode=contextmenu&context_menu={}&context_action=del&context_id={}&context_ui={})"
.format(kodiutils.ID, delete_list, item_id, context_ui)))
elif delete_list == 'watchlist' and guid:
menuItems.append((
'Rimuovi (MediasetPlay)',
"RunPlugin(plugin://{}/?mode=contextmenu&context_menu={}&context_action=del&context_id={}&context_ui={})"
.format(kodiutils.ID, delete_list, guid, context_ui)))
else:
if guid:
menuItems.append((
'Guarda Dopo (MediasetPlay)',
"RunPlugin(plugin://{}/?mode=contextmenu&context_menu=watchlist&context_action=add&context_id={}&context_ui={})"
.format(kodiutils.ID, guid, context_ui)))
elif item_id:
menuItems.append((
'Preferiti (MediasetPlay)',
"RunPlugin(plugin://{}/?mode=contextmenu&context_menu=favorites&context_action=add&context_id={}&context_ui={})"
.format(kodiutils.ID, item_id, context_ui)))
return menuItems
def __init__(self):
self.med = Mediaset()
self.med.setUserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36'
self.med.log = kodiutils.log
self.scrobblingInterval = kodiutils.getSettingAsNum(
"scrobblingInterval")
kodiutils.log('[mediasetservice] monitorService init')
def __getTime(self):
try:
activePlayers = kodiutils.kodiJsonRequest({
"jsonrpc": "2.0",
"method": "Player.GetActivePlayers",
"id": 1
})
playerId = int(
activePlayers[0]['playerid']) if activePlayers else 0
if playerId:
result = kodiutils.kodiJsonRequest({
'jsonrpc': '2.0',
'method': 'Player.GetProperties',
'params': {
'playerid': playerId,
"properties": ["time", "totaltime"]
},
'id': 1
})
timeData = result['time'] if 'time' in result else None
totalTime = result[
'totaltime'] if 'totaltime' in result else None
return self.__calculateSeconds(
timeData), self.__calculateSeconds(totalTime)
except Exception as ex:
kodiutils.log(kodiutils.createError(ex), 1)
return self._position, self._duration
def run(self):
# startup_delay = kodiutils.getSettingAsNum('startup_delay')
# if startup_delay:
# kodiutils.log("Delaying startup by {} seconds.".format(startup_delay), 4)
# xbmc.sleep(startup_delay * 1000)
kodiutils.log("mediasetservice started", 1)
# setup event driven classes
self.player = Player(action=self._dispatchQueue)
self.monitor = Monitor(action=self._dispatchQueue)
# start loop for events
while not self.monitor.abortRequested():
while len(self.dispatchQueue) and (
not self.monitor.abortRequested()):
data = self.dispatchQueue.get()
self._dispatch(data)
if self.monitor.waitForAbort(self.scrobblingInterval):
# Abort was requested while waiting. We should exit
break
else:
self.player.transitionCheck()
# we are shutting down
kodiutils.log("[mediasetservice] monitorService shut down.", 1)
# delete player/monitor
del self.player
del self.monitor
def elenco_magazine(self, newsFeedUrl, page_action=""):
arts = self.__getDirectoryArt()
els, nextPage, prevPage = self.med.OttieniMagazine(
newsFeedUrl, self.iperpage)
update_listing = (page_action == 'next' or page_action == 'prev')
if nextPage:
kodiutils.addListItem(kodiutils.LANGUAGE(32130), {
'mode': 'magazine',
'newsFeedUrl': nextPage,
'page_action': 'next'
},
properties={'SpecialSort': 'top'},
arts=self.__getForwardArt())
if prevPage:
kodiutils.addListItem(kodiutils.LANGUAGE(32129), {
'mode': 'magazine',
'newsFeedUrl': prevPage,
'page_action': 'prev'
},
properties={'SpecialSort': 'top'},
arts=self.__getBackwardArt())
for sec in els:
if 'metainfo' in sec and 'ddg_url' in sec['metainfo']:
kodiutils.addListItem(sec["title"], {
'mode': 'magazine',
'ddg_url': sec['metainfo']['ddg_url']
},
arts=arts)
kodiutils.log(('update_listing: {}').format(str(update_listing)), 4)
kodiutils.endScript(update_listing=update_listing)
def transitionCheck(self):
try:
if self.isScrobbling() and self.isPlayingVideo():
if self._filenamePath == self.getPlayingFile():
self.__checkTime()
# kodiutils.log("[mediasetservice] transitionCheck: guid={}, position={}, duration={}, offset={}".format(self._guid,self._position,self._duration,self._offset), 4)
self.__trySeek()
except Exception as ex:
kodiutils.log(kodiutils.createError(ex), 1)
def elenco_sezioni_list(self, brandId, sort='mediasetprogram$order|asc'):
kodiutils.log("[main] elenco_sezioni_list: brandId={},sort={}".format(
str(brandId), str(sort)))
els, _ = self.med.OttieniSezioniProgramma(brandId, sort=sort)
if len(els) == 2:
self.elenco_video_list(els[1]['mediasetprogram$subBrandId'])
else:
els.pop(0)
self.__analizza_elenco(els)
kodiutils.endScript()
def onNotification(self, sender, method, data):
if sender != kodiutils.ID:
return
kodiutils.log("[mediasetservice] onNotification {}, {}".format(
sender, method))
if method and data:
action = method.split('.')[-1]
data = json.loads(data)
data['action'] = action
self.action(data)
def _dispatch(self, data):
try:
# kodiutils.log("[mediasetservice] Dispatch: %s" % data)
actionName = data['action']
if actionName in self._actionMap:
method_name = self._actionMap[actionName]
if hasattr(self, method_name):
method = getattr(self, method_name)
method(**data)
except Exception as ex:
kodiutils.log(kodiutils.createError(ex), 1)
def riproduci_guid(self, guid='', offset=None):
kodiutils.log('riproduci_guid: guid={}, offset={}'.format(
guid, offset))
res = self.med.OttieniInfoDaGuid(guid)
if not res or 'media' not in res:
kodiutils.showOkDialog(kodiutils.LANGUAGE(32132),
kodiutils.LANGUAGE(32136))
kodiutils.setResolvedUrl(solved=False)
return
self.riproduci_video(guid=guid,
pid=res['media'][0]['pid'],
offset=offset)
def scrobble(self, **data):
guid = data['guid'] if 'guid' in data else ''
position = data['position'] if 'position' in data else 0
duration = data['duration'] if 'duration' in data else 0
action = data['action'] if 'action' in data else ''
kodiutils.log(
"[mediasetservice] scrobble: action={}, guid={}, position={}, duration={}"
.format(action, guid, position, duration))
if position and guid and duration:
user = kodiutils.getSetting('email')
password = kodiutils.getSetting('password')
if user and password and self.med.login(user, password):
self.med.setProgress(guid, position, duration)
def __trySeek(self):
if self._offset:
offset = float(self._offset)
if offset and offset > self._position:
try:
self.seekTime(offset)
except Exception as ex:
kodiutils.log(kodiutils.createError(ex), 1)
position, _ = self.__getTime()
if position < offset:
data = {'action': 'offset'}
self.action(data)
else:
self._offset = ''
def check(self, **data):
guid = data['guid'] if 'guid' in data else None
url = data['url'] if 'url' in data else None
path = data['path'] if 'path' in data else None
offset = data['offset'] if 'offset' in data else None
kodiutils.log(
"[mediasetservice] check: action={}, guid={}, offset={}, url={}, path={}"
.format(data['action'], guid, offset, url, path))
if guid and url and path:
self.player._clear(guid=guid,
filename_url=url,
filename_path=path,
offset=offset,
playing=True)
self.player.transitionCheck()
def riproduci_video(self, pid, live=False):
from inputstreamhelper import Helper # pylint: disable=import-error
kodiutils.log("Trying to get the video from pid" + pid)
data = self.med.OttieniDatiVideo(pid, live)
if data['type'] == 'video/mp4':
kodiutils.setResolvedUrl(data['url'])
return
is_helper = Helper('mpd',
'com.widevine.alpha' if data['security'] else None)
if not is_helper.check_inputstream():
kodiutils.showOkDialog(kodiutils.LANGUAGE(32132),
kodiutils.LANGUAGE(32133))
kodiutils.setResolvedUrl(solved=False)
return
headers = '&User-Agent={useragent}'.format(useragent=self.ua)
props = {'manifest_type': 'mpd', 'stream_headers': headers}
if data['security']:
user = kodiutils.getSetting('email')
password = kodiutils.getSetting('password')
if user == '' or password == '':
kodiutils.showOkDialog(kodiutils.LANGUAGE(32132),
kodiutils.LANGUAGE(32134))
kodiutils.setResolvedUrl(solved=False)
return
if not self.med.login(user, password):
kodiutils.showOkDialog(kodiutils.LANGUAGE(32132),
kodiutils.LANGUAGE(32135))
kodiutils.setResolvedUrl(solved=False)
return
headers += '&Accept=*/*&Content-Type='
props['license_type'] = 'com.widevine.alpha'
props['stream_headers'] = headers
url = self.med.OttieniWidevineAuthUrl(data['pid'])
props['license_key'] = '{url}|{headers}|R{{SSM}}|'.format(
url=url, headers=headers)
headers = {
'user-agent': self.ua,
't-apigw': self.med.apigw,
't-cts': self.med.cts
}
kodiutils.setResolvedUrl(data['url'],
headers=headers,
ins=is_helper.inputstream_addon,
insdata=props)
def elenco_video_list(self,
sub_brand_id,
mode='programma',
sort='',
page=0,
size=0):
kodiutils.log(
"[main] elenco_video_list: sub_brand_id={},mode={},sort={},page={},size={}"
.format(str(sub_brand_id), str(mode), str(sort), str(page),
str(size)))
# sort = 'mediasetprogram$publishInfo_lastPublished|{}'.format(order)
page = int(page)
size = int(size)
update_listing = (page > 0)
page = page if page else 1
if not size:
size = self.iperpage
els, hasMore = self.med.OttieniVideoSezione(sub_brand_id,
sort=sort,
page=page,
size=size)
if hasMore:
kodiutils.addListItem(kodiutils.LANGUAGE(32130), {
'mode': mode,
'sub_brand_id': sub_brand_id,
'sort': sort,
'page': page + 1,
'size': size
},
properties={'SpecialSort': 'top'},
arts=self.__getForwardArt())
if page > 1:
kodiutils.addListItem(kodiutils.LANGUAGE(32129), {
'mode': mode,
'sub_brand_id': sub_brand_id,
'sort': sort,
'page': page - 1,
'size': size
},
properties={'SpecialSort': 'top'},
arts=self.__getBackwardArt())
self.__analizza_elenco(els, True)
kodiutils.endScript(update_listing=update_listing)
def guida_tv_root(self):
kodiutils.setContent('videos')
els, _ = self.med.OttieniCanaliLive(sort='ShortTitle')
for prog in els:
kodiutils.log(('prog: {}').format(str(prog)), 4)
infos = _gather_info(prog)
arts = _gather_art(prog)
if 'tuningInstruction' in prog:
if prog['tuningInstruction'] and not prog[
'mediasetstation$eventBased']:
kodiutils.addListItem(
prog["title"], {
'mode': 'guida_tv',
'id': prog['callSign'],
'week': staticutils.get_timestamp_midnight()
},
videoInfo=infos,
arts=arts)
kodiutils.endScript()
def elenco_sezione(self,
id,
page=0,
sort='mediasetprogram$seasonTitle',
order='asc',
size=20):
kodiutils.log(
"[main] elenco_sezione: id={},page={},sort={},order={}".format(
str(id), str(page), str(sort), str(order)))
els, hasmore = self.med.OttieniProgrammiGenere(id, size, page, sort,
order)
kodiutils.log(
'elenco_sezione size={},hasmore={}: {}'.format(
str(size), str(hasmore), str(els)), 4)
update_listing = int(page) > 0 if page else False
page = int(page) if page else 1
if els:
if hasmore:
kodiutils.addListItem(kodiutils.LANGUAGE(32130), {
'mode': 'sezione',
'id': id,
'page': page + 1
},
properties={'SpecialSort': 'top'},
arts=self.__getForwardArt())
if page > 1:
kodiutils.addListItem(kodiutils.LANGUAGE(32129), {
'mode': 'sezione',
'id': id,
'page': page - 1
},
properties={'SpecialSort': 'top'},
arts=self.__getBackwardArt())
self.__analizza_elenco(els, True)
# else:
# kodiutils.addListItem('Ordina {}'.format('DESC' if sort and order == 'asc' else 'ASC'), {
# 'mode': 'sezione', 'id': id,
# 'sort': sort if sort else 'title',
# 'order': 'desc' if sort and order == 'asc' else 'asc'})
kodiutils.endScript(update_listing=update_listing)
def elenco_cult(self, feedurl, page_action=""):
els, nextPage, prevPage = self.med.OttieniCult(feedurl, self.iperpage)
update_listing = (page_action == 'next' or page_action == 'prev')
kodiutils.log(('elenco_cult: {}').format(str(update_listing)), 4)
if nextPage:
kodiutils.addListItem(kodiutils.LANGUAGE(32130), {
'mode': 'cult',
'feedurl': nextPage,
'page_action': 'next'
},
properties={'SpecialSort': 'top'},
arts=self.__getForwardArt())
if prevPage:
kodiutils.addListItem(kodiutils.LANGUAGE(32129), {
'mode': 'cult',
'feedurl': prevPage,
'page_action': 'prev'
},
properties={'SpecialSort': 'top'},
arts=self.__getBackwardArt())
self.__analizza_elenco(els, True)
kodiutils.endScript(update_listing=update_listing)
def elenco_ondemand(self, id, template=None, sort='', order='asc'):
kodiutils.log(
('elenco_ondemand: id={},template={},sort={},order={}').format(
str(id), str(template), str(sort), str(order)), 4)
arts = self.__getDirectoryArt()
for sec in self.med.OttieniOnDemandGeneri(id, sort, order):
if template and (('template' in sec and
not str(sec['template']) in template.split('|'))
or not 'template' in sec):
continue
if "uxReference" in sec:
kodiutils.log(
('elenco_ondemand uxReference: {}').format(str(sec)), 4)
kodiutils.addListItem(sec["title"], {
'mode': 'sezione',
'id': sec['uxReference']
},
arts=arts)
elif "newsFeedUrl" in sec:
kodiutils.log(
('elenco_ondemand newsFeedUrl: {}').format(str(sec)), 4)
kodiutils.addListItem(sec["title"], {
'mode': 'magazine',
'newsFeedUrl': sec['newsFeedUrl']
},
arts=arts)
elif "feedurl" in sec:
kodiutils.log(('elenco_ondemand feedurl: {}').format(str(sec)),
4)
kodiutils.addListItem(sec["title"], {
'mode': 'cult',
'feedurl': sec['feedurl']
},
arts=arts)
# kodiutils.addListItem('Ordina {}'.format('DESC' if sort and order == 'asc' else 'ASC'), {
# 'mode': 'ondemand',
# 'id': id,
# 'sort': sort if sort else 'title',
# 'order': 'desc' if sort and order == 'asc' else 'asc'
# })
kodiutils.endScript(closedir=True)
def elenco_stagioni_list(self, series_id, title, sort=None, order='asc'):
title = kodiutils.py2_encode(title)
kodiutils.log(
"[main] elenco_stagioni_list: series_id={},title={},sort={},order={}"
.format(series_id, title, sort, order))
els, _ = self.med.OttieniStagioni(series_id, sort, order)
if len(els) == 1:
self.elenco_sezioni_list(els[0]['mediasettvseason$brandId'])
else:
# workaround per controllare se è già una stagione e non una serie
brandId = -1
for el in els:
kodiutils.log(('el: {}').format(str(el)), 4)
if kodiutils.py2_encode(el['title']) == title:
brandId = el['mediasettvseason$brandId']
break
kodiutils.log(('brandId: {}').format(str(brandId)), 4)
if brandId == -1:
self.__analizza_elenco(els)
kodiutils.endScript()
else:
if sort:
kodiutils.addListItem('Tutte le Stagioni', {
'mode': 'programma',
'series_id': series_id,
'title': '*',
'sort': sort,
'order': order
},
properties={'SpecialSort': 'top'},
arts=self.__getDirectoryArt())
else:
kodiutils.addListItem('Tutte le Stagioni', {
'mode': 'programma',
'series_id': series_id,
'title': '*'
},
properties={'SpecialSort': 'top'},
arts=self.__getDirectoryArt())
self.elenco_sezioni_list(brandId)
def main(self):
# parameter values
params = staticutils.getParams()
kodiutils.log("[main] params: {}".format(str(params)))
if 'mode' in params:
page = None
if 'page' in params:
try:
page = int(params['page'])
except ValueError:
pass
self.iperpage = min(kodiutils.getSettingAsNum('itemsperpage'), 10)
if params['mode'] == "cerca":
if 'type' in params:
if 'search' in params:
self.elenco_cerca_sezione(params['type'],
params['search'], page)
else:
self.apri_ricerca(params['type'])
else:
self.elenco_cerca_root()
if params['mode'] == "sezione":
self.elenco_sezione(
**self.sliceParams(params, ('id', 'page', 'sort',
'order')))
if params['mode'] == "ondemand":
if 'id' in params:
self.elenco_ondemand(
**self.sliceParams(params, ('id', 'template', 'sort',
'order')))
else:
self.elenco_ondemand_root()
if params['mode'] == "cult":
if 'feedurl' in params:
self.elenco_cult(
**self.sliceParams(params, ('feedurl', 'page_action')))
else:
self.elenco_cult_root()
if params['mode'] == "magazine":
if 'newsFeedUrl' in params:
self.elenco_magazine(
**self.sliceParams(params, ('newsFeedUrl',
'page_action')))
elif 'ddg_url' in params:
self.elenco_news(params['ddg_url'])
if params['mode'] == "programma":
if 'series_id' in params:
self.elenco_stagioni_list(
**self.sliceParams(params, ('series_id', 'title',
'sort', 'order')))
elif 'sub_brand_id' in params:
self.elenco_video_list(
**self.sliceParams(params, ('sub_brand_id', 'mode',
'sort', 'page', 'size')))
elif 'brand_id' in params:
self.elenco_sezioni_list(params['brand_id'])
if params['mode'] == "video":
if 'pid' in params:
self.riproduci_video(
**self.sliceParams(params, ('guid', 'pid', 'offset')))
else:
self.riproduci_guid(
**self.sliceParams(params, ('guid', 'offset')))
if params['mode'] == "live":
if 'id' in params:
self.riproduci_video(pid=params['id'], live=True)
else:
self.canali_live_play(params['guid'])
if params['mode'] == "tv":
self.tv_root()
if params['mode'] == "personal":
self.personal_root()
elif params['mode'] == "continuewatch":
self.continuewatch()
elif params['mode'] == "favorites":
self.favorites()
elif params['mode'] == "watchlist":
self.watchlist()
elif params['mode'] == "contextmenu":
self.contextMenu(
**self.sliceParams(params, ('context_menu',
'context_action', 'context_id',
'context_ui')))
elif params['mode'] == "canali_live":
self.canali_live_root()
elif params['mode'] == "guida_tv":
if 'id' in params:
if 'week' in params:
self.guida_tv_canale_settimana(params['id'],
int(params['week']))
elif 'day' in params:
self.guida_tv_canale_giorno(params['id'],
int(params['day']))
self.guida_tv_root()
else:
self.root()
# -*- coding: utf-8 -*-
from resources.lib.monitor import MediasetService
from phate89lib import kodiutils # pyright: reportMissingImports=false
scrobbling = kodiutils.getSettingAsNum("scrobbling")
if scrobbling:
kodiutils.log(
'Addon {} starting {} scrobbling service (version {})'.format(
kodiutils.ID, kodiutils.NAME, kodiutils.VERSION))
try:
MediasetService().run()
except Exception as exc:
kodiutils.log('[mediasetservice] Exception: {}'.format(str(exc)))
kodiutils.log(
'Addon {} shutting down {} scrobbling service (version {})'.format(
kodiutils.ID, kodiutils.NAME, kodiutils.VERSION))
def __analizza_elenco(self,
progs,
setcontent=False,
titlewd=False,
isDeletable=False,
delete_list='',
context_ui=''):
if not progs:
return
if setcontent:
self.__imposta_tipo_media(progs[0])
defaultArt = self.__getDirectoryArt()
for prog in progs:
infos = _gather_info(prog,
titlewd=titlewd,
lookup_fullplot=self.lookup_fullplot)
arts = _gather_art(prog) or defaultArt
kodiutils.log('__analizza_elenco infos: {}'.format(infos))
kodiutils.log('__analizza_elenco arts: {}'.format(arts))
item_id = ''
guid = ''
args = {}
properties = {}
if 'media' in prog:
kodiutils.log('__analizza_elenco media: {}'.format(str(prog)),
4)
args['mode'] = 'video'
# salta se non ha un media ma ha il tag perchè non riproducibile
if prog['media']:
media = prog['media'][0]
if 'position' in prog:
args['offset'] = prog['position']
if 'pid' in media:
args['pid'] = media['pid']
elif 'publicUrl' in media:
args['pid'] = media['publicUrl'].split('/')[-1]
if 'guid' in media:
args['guid'] = media['guid']
guid = media['guid']
if 'mediasetprogram$duration' in prog:
properties['TotalTime'] = str(
prog['mediasetprogram$duration'])
if 'mediasetprogram$brandId' in prog:
item_id = prog['mediasetprogram$brandId']
properties['ResumeTime'] = '0.0'
menuItems = self.menuItems(isDeletable=isDeletable,
delete_list=delete_list,
item_id=item_id,
guid=guid,
context_ui=context_ui)
kodiutils.addListItem(infos["title"],
args,
videoInfo=infos,
arts=arts,
isFolder=False,
properties=properties,
menuItems=menuItems)
elif 'tuningInstruction' in prog:
kodiutils.log(
'__analizza_elenco tuningInstruction: {}'.format(
str(prog)), 4)
args['mode'] = 'live'
if prog['tuningInstruction'] and not prog[
'mediasetstation$eventBased']:
vdata = prog['tuningInstruction'][
'urn:theplatform:tv:location:any']
for v in vdata:
if v['format'] == 'application/x-mpegURL':
args['id'] = v['releasePids'][0]
else:
args['mid'] = v['releasePids'][0]
kodiutils.addListItem(prog["title"],
args,
videoInfo=infos,
arts=arts,
isFolder=False)
elif 'mediasetprogram$subBrandId' in prog:
kodiutils.log(
'__analizza_elenco subBrandId: {}'.format(str(prog)), 4)
item_id = prog['mediasetprogram$brandId'] if prog[
'mediasetprogram$brandId'] else ''
args['mode'] = 'programma'
args['sub_brand_id'] = prog['mediasetprogram$subBrandId']
menuItems = self.menuItems(isDeletable=isDeletable,
delete_list=delete_list,
item_id=item_id,
guid=guid,
context_ui=context_ui)
kodiutils.addListItem(infos["title"],
args,
videoInfo=infos,
arts=arts,
menuItems=menuItems)
elif 'mediasettvseason$brandId' in prog:
kodiutils.log(
'__analizza_elenco brandId: {}'.format(str(prog)), 4)
# title = prog['title']
# if 'mediasettvseason$displaySeason' in prog and 'mediasetprogram$seasonTitle' in prog:
item_id = prog['mediasettvseason$brandId'] if prog[
'mediasettvseason$brandId'] else ''
args['mode'] = 'programma'
args['brand_id'] = prog['mediasettvseason$brandId']
menuItems = self.menuItems(isDeletable=isDeletable,
delete_list=delete_list,
item_id=item_id,
guid=guid,
context_ui=context_ui)
kodiutils.addListItem(prog["title"],
args,
videoInfo=infos,
arts=arts,
menuItems=menuItems)
elif 'seriesId' in prog:
kodiutils.log(
'__analizza_elenco seriesId: {}'.format(str(prog)), 4)
title = prog['title']
seriesTitle = prog['title']
sort = 'tvSeasonNumber'
order = 'asc'
item_id = prog['mediasetprogram$brandId'] if prog[
'mediasetprogram$brandId'] else ''
if 'mediasetprogram$pageUrl' in prog and 'programmi-tv' in str(
prog['mediasetprogram$pageUrl'].encode(
'utf-8')).lower():
if 'mediasetprogram$seasonTitle' in prog and 'mediasetprogram$displaySeason' in prog:
seasonTitle = str(
prog['mediasetprogram$seasonTitle'].encode(
'utf-8'))
# displaySeason = str(prog['mediasetprogram$displaySeason'].encode('utf-8'))
seriesTitle = seasonTitle
title = seriesTitle
args['mode'] = 'programma'
args['series_id'] = prog['seriesId']
args['sort'] = sort
args['order'] = order
args['title'] = seriesTitle
menuItems = self.menuItems(isDeletable=isDeletable,
delete_list=delete_list,
item_id=item_id,
guid=guid,
context_ui=context_ui)
kodiutils.addListItem(title,
args,
videoInfo=infos,
arts=arts,
menuItems=menuItems)
else:
kodiutils.log('__analizza_elenco other: {}'.format(str(prog)),
4)
item_id = prog['mediasetprogram$brandId'] if prog[
'mediasetprogram$brandId'] else ''
args['mode'] = 'programma'
args['brand_id'] = prog['mediasetprogram$brandId']
menuItems = self.menuItems(isDeletable=isDeletable,
delete_list=delete_list,
item_id=item_id,
guid=guid,
context_ui=context_ui)
kodiutils.addListItem(prog["title"],
args,
videoInfo=infos,
arts=arts,
menuItems=menuItems)
def canali_live_root(self):
kodiutils.setContent('videos')
now = staticutils.get_timestamp()
els, _ = self.med.OttieniProgrammiLive() # (sort='title')
chans = {}
for chan in els:
if 'listings' in chan and chan['listings']:
for prog in chan['listings']:
if prog['startTime'] <= now <= prog['endTime']:
guid = chan['guid']
title = '{} - {}'.format(
chan['title'],
kodiutils.py2_encode(
prog["mediasetlisting$epgTitle"]))
chans[guid] = {
'title':
title,
'infos':
_gather_info(prog, infos={'title': title}),
'arts':
_gather_art(prog),
'restartAllowed':
prog['mediasetlisting$restartAllowed']
}
kodiutils.log(('chans: {}').format(str(chans)))
els, _ = self.med.OttieniCanaliLive(sort='shortTitle|asc')
for prog in els:
if ('callSign' in prog and prog['callSign'] in chans
and 'tuningInstruction' in prog
and prog['tuningInstruction']):
chn = chans[prog['callSign']]
if not chn['arts']:
chn['arts'] = _gather_art(prog)
if chn['restartAllowed']:
if kodiutils.getSettingAsBool('splitlive'):
kodiutils.addListItem(chn['title'], {
'mode': 'live',
'guid': prog['callSign']
},
videoInfo=chn['infos'],
arts=chn['arts'])
continue
vid = self.__ottieni_vid_restart(prog['callSign'])
if vid:
kodiutils.addListItem(chn['title'], {
'mode': 'video',
'pid': vid
},
videoInfo=chn['infos'],
arts=chn['arts'],
properties={'ResumeTime': '0.0'},
isFolder=False)
continue
data = {'mode': 'live'}
vdata = prog['tuningInstruction'][
'urn:theplatform:tv:location:any']
for v in vdata:
if v['format'] == 'application/x-mpegURL':
data['id'] = v['releasePids'][0]
else:
data['mid'] = v['releasePids'][0]
kodiutils.addListItem(prog['title'],
data,
videoInfo=chn['infos'],
arts=chn['arts'],
isFolder=False)
kodiutils.endScript()
def riproduci_video(self, guid=None, pid=None, live=False, offset=None):
from inputstreamhelper import Helper # pylint: disable=import-error
# kodiutils.log("Trying to get the video from pid %s" % pid)
kodiutils.log(
'riproduci_video: guid={}, pid={}, live={}, offset={}'.format(
guid, pid, live, offset))
data = self.med.OttieniDatiVideo(pid, live)
kodiutils.log('riproduci_video: data={}'.format(str(data)))
if data['type'] == 'video/mp4':
kodiutils.setResolvedUrl(data['url'])
return
is_helper = Helper('mpd',
'com.widevine.alpha' if data['security'] else None)
if not is_helper.check_inputstream():
kodiutils.showOkDialog(kodiutils.LANGUAGE(32132),
kodiutils.LANGUAGE(32133))
kodiutils.setResolvedUrl(solved=False)
return
headers = '&User-Agent={useragent}'.format(useragent=self.ua)
props = {'manifest_type': 'mpd', 'stream_headers': headers}
properties = {'ResumeTime': '0.0'}
isAutenticated = False
scrobbling = kodiutils.getSettingAsNum('scrobbling')
if scrobbling and not self.isAnonimous:
properties['guid'] = guid
if scrobbling == self.ADDON_SCROBBLING_CUSTOM:
if offset:
properties['offset'] = str(offset)
else:
user = kodiutils.getSetting('email')
password = kodiutils.getSetting('password')
isAutenticated = self.med.login(user, password)
if isAutenticated:
offset = self.med.getProgress(guid)
if offset:
properties['offset'] = str(offset)
if data['security']:
if not isAutenticated:
user = kodiutils.getSetting('email')
password = kodiutils.getSetting('password')
if user == '' or password == '':
kodiutils.showOkDialog(kodiutils.LANGUAGE(32132),
kodiutils.LANGUAGE(32134))
kodiutils.setResolvedUrl(solved=False)
return
if not self.med.login(user, password):
kodiutils.showOkDialog(kodiutils.LANGUAGE(32132),
kodiutils.LANGUAGE(32135))
kodiutils.setResolvedUrl(solved=False)
return
headers += '&Accept=*/*&Content-Type='
props['license_type'] = 'com.widevine.alpha'
props['stream_headers'] = headers
url = self.med.OttieniWidevineAuthUrl(data['pid'])
props['license_key'] = '{url}|{headers}|R{{SSM}}|'.format(
url=url, headers=headers)
headers = {
'user-agent': self.ua,
't-apigw': self.med.apigw,
't-cts': self.med.cts
}
kodiutils.log("riproduci_video properties: %s" % properties)
kodiutils.setResolvedUrl(data['url'],
headers=headers,
ins=is_helper.inputstream_addon,
insdata=props,
properties=properties)
def __imposta_tipo_media(self, prog):
kodiutils.log('__analizza_elenco mediatype: {}'.format(
_gather_media_type(prog)))
if self.detect_media_type:
kodiutils.setContent(_gather_media_type(prog) + 's')
def __init__(self, *args, **kwargs):
kodiutils.log("[mediasetservice] monitor initialiazed")
self.action = kwargs['action']
def __init__(self, *args, **kwargs):
self.action = kwargs['action']
self._scrobbling = kodiutils.getSettingAsNum("scrobbling")
self._clear()
kodiutils.log("[mediasetservice] player initialiazed")
