def AddCategories(self, data):
Logger.Info("Performing Pre-Processing")
items = []
if self.parentItem and "code" in self.parentItem.metaData:
self.__currentChannel = self.parentItem.metaData["code"]
Logger.Info("Only showing items for channel: '%s'", self.__currentChannel)
return data, items
cat = mediaitem.MediaItem("\a.: Categoriën :.", "https://www.vrt.be/vrtnu/categorieen/")
cat.fanart = self.fanart
cat.thumb = self.noImage
cat.icon = self.icon
cat.dontGroup = True
items.append(cat)
live = mediaitem.MediaItem("\a.: Live Streams :.", "https://services.vrt.be/videoplayer/r/live.json")
live.fanart = self.fanart
live.thumb = self.noImage
live.icon = self.icon
live.dontGroup = True
live.isLive = True
items.append(live)
channelText = LanguageHelper.GetLocalizedString(30010)
channels = mediaitem.MediaItem(".: %s :." % (channelText, ), "#channels")
channels.fanart = self.fanart
channels.thumb = self.noImage
channels.icon = self.icon
channels.dontGroup = True
items.append(channels)
Logger.Debug("Pre-Processing finished")
return data, items
def GetMainListItems(self, data):
"""
accepts an url and returns an list with items of type CListItem
Items have a name and url. This is used for the filling of the progwindow
"""
items = []
urlPattern = "http://www.dumpert.nl/%s/%s/"
for page in range(1, 3):
item = mediaitem.MediaItem("Toppertjes - Pagina %s" % (page, ),
urlPattern % ('toppers', page))
item.icon = self.icon
items.append(item)
for page in range(1, 11):
item = mediaitem.MediaItem("Filmpjes - Pagina %s" % (page, ),
urlPattern % ('filmpjes', page))
item.icon = self.icon
items.append(item)
item = mediaitem.MediaItem("Zoeken", "searchSite")
item.icon = self.icon
items.append(item)
return data, items
def CreatePageItem(self, resultSet):
"""Creates a MediaItem of type 'page' using the resultSet from the regex.
Arguments:
resultSet : tuple(string) - the resultSet of the self.pageNavigationRegex
Returns:
A new MediaItem of type 'page'
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Debug("Starting CreatePageItem")
total = ''
for result in resultSet:
total = "%s%s" % (total, result)
total = htmlentityhelper.HtmlEntityHelper.StripAmp(total)
if not self.pageNavigationRegexIndex == '':
item = mediaitem.MediaItem(resultSet[self.pageNavigationRegexIndex], urlparse.urljoin(self.baseUrl, total))
else:
item = mediaitem.MediaItem("0", "")
item.type = "page"
item.fanart = self.fanart
item.HttpHeaders = self.httpHeaders
Logger.Debug("Created '%s' for url %s", item.name, item.url)
return item
def SearchSite(self, url=None):
"""Creates an list of items by searching the site
Keyword Arguments:
url : String - Url to use to search with a %s for the search parameters
Returns:
A list of MediaItems that should be displayed.
This method is called when the URL of an item is "searchSite". The channel
calling this should implement the search functionality. This could also include
showing of an input keyboard and following actions.
The %s the url will be replaced with an URL encoded representation of the
text to search for.
"""
items = []
if url is None:
item = mediaitem.MediaItem("Search Not Implented", "", type='video')
item.icon = self.icon
items.append(item)
else:
items = []
needle = XbmcWrapper.ShowKeyBoard()
if needle:
Logger.Debug("Searching for '%s'", needle)
# convert to HTML
needle = htmlentityhelper.HtmlEntityHelper.UrlEncode(needle)
searchUrl = url % (needle, )
temp = mediaitem.MediaItem("Search", searchUrl)
return self.ProcessFolderList(temp)
return items
def AddSearchAndGenres(self, data):
"""Performs pre-process actions for data processing, in this case adding a search
Arguments:
data : string - the retrieve data that was loaded for the current item and URL.
Returns:
A tuple of the data and a list of MediaItems that were generated.
Accepts an data from the ProcessFolderList method, BEFORE the items are
processed. Allows setting of parameters (like title etc) for the channel.
Inside this method the <data> could be changed and additional items can
be created.
The return values should always be instantiated in at least ("", []).
"""
Logger.Info("Performing Pre-Processing")
items = []
if self.parentItem is not None and "genre" in self.parentItem.metaData:
self.__genre = self.parentItem.metaData["genre"]
Logger.Debug("Parsing a specific genre: %s", self.__genre)
return data, items
searchItem = mediaitem.MediaItem("\a.: Sök :.", "searchSite")
searchItem.complete = True
searchItem.thumb = self.noImage
searchItem.dontGroup = True
searchItem.fanart = self.fanart
# searchItem.SetDate(2099, 1, 1, text="")
# -> No items have dates, so adding this will force a date sort in Retrospect
items.append(searchItem)
genresItem = mediaitem.MediaItem("\a.: Genrer :.", "")
genresItem.complete = True
genresItem.thumb = self.noImage
genresItem.dontGroup = True
genresItem.fanart = self.fanart
items.append(genresItem)
# find the actual genres
genreRegex = '<li[^>]+genre[^>]*><button[^>]+data-value="(?<genre>[^"]+)"[^>]*>(?<title>[^>]+)</button></li>'
genreRegex = Regexer.FromExpresso(genreRegex)
genres = Regexer.DoRegex(genreRegex, data)
for genre in genres:
if genre["genre"] == "all":
continue
genreItem = mediaitem.MediaItem(genre["title"], self.mainListUri)
genreItem.complete = True
genreItem.thumb = self.noImage
genreItem.fanart = self.fanart
genreItem.metaData = {"genre": genre["genre"]}
genresItem.items.append(genreItem)
Logger.Debug("Pre-Processing finished")
return data, items
def AddLiveChannels(self, data):
"""Performs pre-process actions for data processing/
Arguments:
data : string - the retrieve data that was loaded for the current item and URL.
Returns:
A tuple of the data and a list of MediaItems that were generated.
Accepts an data from the ProcessFolderList method, BEFORE the items are
processed. Allows setting of parameters (like title etc) for the channel.
Inside this method the <data> could be changed and additional items can
be created.
The return values should always be instantiated in at least ("", []).
"""
Logger.Info("Generating Live channels")
liveChannels = [
{"name": "BBC 1 HD", "code": "bbc_one_hd", "image": "bbc1large.png"},
{"name": "BBC 2 HD", "code": "bbc_two_hd", "image": "bbc2large.png"},
{"name": "BBC 3 HD", "code": "bbc_three_hd", "image": "bbc3large.png"},
{"name": "BBC 4 HD", "code": "bbc_four_hd", "image": "bbc4large.png"},
{"name": "CBBC", "code": "cbbc_hd", "image": "cbbclarge.png"},
{"name": "CBeebies", "code": "cbeebies_hd", "image": "cbeebieslarge.png"},
{"name": "BBC News Channel", "code": "bbc_news24", "image": "bbcnewslarge.png"},
{"name": "BBC Parliament", "code": "bbc_parliament", "image": "bbcparliamentlarge.png"},
{"name": "Alba", "code": "bbc_alba", "image": "bbcalbalarge.png"},
{"name": "S4C", "code": "s4cpbs", "image": "bbchdlarge.png"},
{"name": "BBC One London", "code": "bbc_one_london", "image": "bbchdlarge.png"},
{"name": "BBC One Scotland", "code": "bbc_one_scotland_hd", "image": "bbchdlarge.png"},
{"name": "BBC One Northern Ireland", "code": "bbc_one_northern_ireland_hd", "image": "bbchdlarge.png"},
{"name": "BBC One Wales", "code": "bbc_one_wales_hd", "image": "bbchdlarge.png"},
{"name": "BBC Two Scotland", "code": "bbc_two_scotland", "image": "bbchdlarge.png"},
{"name": "BBC Two Northern Ireland", "code": "bbc_two_northern_ireland_digital", "image": "bbchdlarge.png"},
{"name": "BBC Two Wales", "code": "bbc_two_wales_digital", "image": "bbchdlarge.png"},
]
live = mediaitem.MediaItem("Live Channels", "")
live.dontGroup = True
live.type = "folder"
for channel in liveChannels:
url = "http://a.files.bbci.co.uk/media/live/manifesto/audio_video/simulcast/hds/uk/pc/ak/%(code)s.f4m" % channel
item = mediaitem.MediaItem(channel["name"], url)
item.isGeoLocked = True
item.isLive = True
item.type = "video"
item.complete = False
item.thumb = self.GetImageLocation(channel["image"])
live.items.append(item)
return data, [live, ]
def AddCategories(self, data):
""" Add categories to the main listing
@param data: the Parsed Data
@return: a tuple of data and items
"""
Logger.Info("Performing Pre-Processing")
items = []
cat = mediaitem.MediaItem(
"\b.: Categorieën :.",
"http://m.schooltv.nl/api/v1/categorieen.json?size=100")
cat.thumb = self.noImage
cat.icon = self.icon
cat.fanart = self.fanart
cat.complete = True
cat.dontGroup = True
items.append(cat)
tips = mediaitem.MediaItem(
"\b.: Tips :.",
"http://m.schooltv.nl/api/v1/programmas/tips.json?size=100")
tips.thumb = self.noImage
tips.icon = self.icon
tips.fanart = self.fanart
tips.complete = True
tips.dontGroup = True
items.append(tips)
data = JsonHelper(data)
ages = mediaitem.MediaItem("\b.: Leeftijden :.", "")
ages.thumb = self.noImage
ages.icon = self.icon
ages.fanart = self.fanart
ages.complete = True
ages.dontGroup = True
for age in ("0-4", "5-6", "7-8", "9-12", "13-15", "16-18"):
ageItem = mediaitem.MediaItem(
"%s Jaar" % (age, ),
"http://m.schooltv.nl/api/v1/leeftijdscategorieen/%s/afleveringen.json?"
"size=%s&sort=Nieuwste" % (age, self.__PageSize))
ageItem.thumb = self.noImage
ageItem.icon = self.icon
ageItem.fanart = self.fanart
ageItem.complete = True
ageItem.dontGroup = True
ages.items.append(ageItem)
# We should list programs instead of videos, so just prefill them here.
for program in data.GetValue():
if age in program['ageGroups']:
ageItem.items.append(self.CreateEpisodeItem(program))
items.append(ages)
Logger.Debug("Pre-Processing finished")
return data, items
def SearchSite(self, url=None):
"""Creates an list of items by searching the site
Keyword Arguments:
url : String - Url to use to search with a %s for the search parameters
Returns:
A list of MediaItems that should be displayed.
This method is called when the URL of an item is "searchSite". The channel
calling this should implement the search functionality. This could also include
showing of an input keyboard and following actions.
The %s the url will be replaced with an URL encoded representation of the
text to search for.
"""
if self.primaryChannelId:
shows_url = "https://disco-api.dplay.se/content/shows?" \
"include=genres%%2Cimages%%2CprimaryChannel.images&" \
"filter%%5BprimaryChannel.id%%5D={0}&" \
"page%%5Bsize%%5D={1}&query=%s"\
.format(self.primaryChannelId or "", self.programPageSize)
videos_url = "https://disco-api.dplay.se/content/videos?decorators=viewingHistory&" \
"include=images%%2CprimaryChannel%%2Cshow&" \
"filter%%5BprimaryChannel.id%%5D={0}&" \
"page%%5Bsize%%5D={1}&query=%s"\
.format(self.primaryChannelId or "", self.videoPageSize)
else:
shows_url = "https://disco-api.dplay.se/content/shows?" \
"include=genres%%2Cimages%%2CprimaryChannel.images&" \
"page%%5Bsize%%5D={0}&query=%s" \
.format(self.programPageSize)
videos_url = "https://disco-api.dplay.se/content/videos?decorators=viewingHistory&" \
"include=images%%2CprimaryChannel%%2Cshow&" \
"page%%5Bsize%%5D={0}&query=%s" \
.format(self.videoPageSize)
needle = XbmcWrapper.ShowKeyBoard()
if needle:
Logger.Debug("Searching for '%s'", needle)
needle = HtmlEntityHelper.UrlEncode(needle)
searchUrl = videos_url % (needle, )
temp = mediaitem.MediaItem("Search", searchUrl)
episodes = self.ProcessFolderList(temp)
searchUrl = shows_url % (needle, )
temp = mediaitem.MediaItem("Search", searchUrl)
shows = self.ProcessFolderList(temp)
return shows + episodes
return []
def AddLiveItems(self, data):
""" Adds the Live items, Channels and Last Episodes to the listing.
@param data: The data to use.
Returns a list of MediaItems that were retrieved.
"""
items = []
extraItems = {
"Kanaler": "#kanaler",
"Livesändningar": "http://www.svtplay.se/ajax/live?sida=1",
"Sök": "searchSite",
"Senaste program": "http://www.svtplay.se/senaste?sida=1",
"Sista chansen": "http://www.svtplay.se/sista-chansen?sida=1",
"Populära": "http://www.svtplay.se/populara?sida=1",
}
# http://www.svtplay.se/ajax/dokumentar/titlar?filterAccessibility=&filterRights=
categoryItems = {
"Film & Drama": "http://www.svtplay.se/filmochdrama?tab=titlar",
"Barn": "http://www.svtplay.se/barn?tab=titlar",
"Dokumentär": "http://www.svtplay.se/dokumentar?tab=titlar",
"Kultur & Nöje": "http://www.svtplay.se/kulturochnoje?tab=titlar",
"Nyheter": "http://www.svtplay.se/nyheter?tab=titlar",
"Samhälle & Fakta": "http://www.svtplay.se/samhalleochfakta?tab=titlar",
"Sport": "http://www.svtplay.se/sport?tab=titlar",
}
for title, url in extraItems.iteritems():
newItem = mediaitem.MediaItem("\a.: %s :." % (title, ), url)
newItem.complete = True
newItem.thumb = self.noImage
newItem.dontGroup = True
newItem.SetDate(2099, 1, 1, text="")
items.append(newItem)
newItem = mediaitem.MediaItem("\a.: Genrer :.", "")
newItem.complete = True
newItem.thumb = self.noImage
newItem.dontGroup = True
newItem.SetDate(2099, 1, 1, text="")
for title, url in categoryItems.iteritems():
catItem = mediaitem.MediaItem(title, url)
catItem.complete = True
catItem.thumb = self.noImage
catItem.dontGroup = True
# catItem.SetDate(2099, 1, 1, text="")
newItem.items.append(catItem)
items.append(newItem)
return data, items
def CreateMoreItem(self, resultSet):
"""Creates a MediaItem of type 'folder' using the resultSet from the regex.
Arguments:
resultSet : tuple(strig) - the resultSet of the self.folderItemRegex
Returns:
A new MediaItem of type 'folder'
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Trace(resultSet)
if resultSet == "klipp" and self.__klippUrlIndicator not in self.parentItem.url:
return None
more = LanguageHelper.GetLocalizedString(LanguageHelper.MorePages)
item = mediaitem.MediaItem(more, "%s&sida=2&embed=true" % (self.parentItem.url, ))
item.thumb = self.parentItem.thumb
item.icon = self.parentItem.icon
item.type = 'folder'
item.httpHeaders = self.httpHeaders
item.complete = True
return item
def CreateEpisodeItem(self, resultSet):
"""Creates a new MediaItem for an episode
Arguments:
resultSet : list[string] - the resultSet of the self.episodeItemRegex
Returns:
A new MediaItem of type 'folder'
This method creates a new MediaItem from the Regular Expression
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Trace(resultSet)
url = htmlentityhelper.HtmlEntityHelper.StripAmp(urlparse.urljoin(self.baseUrl, resultSet[1]))
if not self.useAtom:
# if we put page 20, we usually get all items.
# url = "%s?tab=program&sida=100&antal=100" % (url, )
url = "%s?tab=program" % (url, )
# url = "%s?sida=2&tab=helaprogram&embed=true" % (url, )
# url = "%s?sida=100&tab=helaprogram" % (url, )
else:
url = "%s/atom.xml" % (url, )
item = mediaitem.MediaItem(resultSet[2], url)
item.icon = self.icon
item.thumb = self.noImage
return item
def AddPageItems(self, data):
""" Adds page items to the main listing
@param data: the Parsed Data
@return: a tuple of data and items
"""
Logger.Info("Performing Pre-Processing")
items = []
json = JsonHelper(data)
totalResults = json.GetValue("totalResults")
fromValue = json.GetValue("from")
sizeValue = json.GetValue("size")
if fromValue + sizeValue < totalResults:
morePages = LanguageHelper.GetLocalizedString(
LanguageHelper.MorePages)
url = self.parentItem.url.split('?')[0]
url = "%s?size=%s&from=%s&sort=Nieuwste" % (url, sizeValue,
fromValue + sizeValue)
Logger.Debug("Adding next-page item from %s to %s",
fromValue + sizeValue,
fromValue + sizeValue + sizeValue)
nextPage = mediaitem.MediaItem(morePages, url)
nextPage.icon = self.parentItem.icon
nextPage.fanart = self.parentItem.fanart
nextPage.thumb = self.parentItem.thumb
nextPage.dontGroup = True
items.append(nextPage)
Logger.Debug("Pre-Processing finished")
return json, items
def CreateEpisodeItem(self, resultSet):
"""Creates a new MediaItem for an episode
Arguments:
resultSet : list[string] - the resultSet of the self.episodeItemRegex
Returns:
A new MediaItem of type 'folder'
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Trace(resultSet)
url = "http://m.schooltv.nl/api/v1/programmas/%s/afleveringen.json?size=%s&sort=Nieuwste" % (
resultSet['mid'], self.__PageSize)
item = mediaitem.MediaItem(resultSet['title'], url)
item.thumb = resultSet.get('image', self.noImage)
item.icon = self.icon
item.description = resultSet.get('description', None)
ageGroups = resultSet.get('ageGroups', ['Onbekend'])
item.description = "%s\n\nLeeftijden: %s" % (item.description,
", ".join(ageGroups))
return item
def AddNextPage(self, data):
"""Performs pre-process actions for data processing
Arguments:
data : string - the retrieve data that was loaded for the current item and URL.
Returns:
A tuple of the data and a list of MediaItems that were generated.
Accepts an data from the ProcessFolderList method, BEFORE the items are
processed. Allows setting of parameters (like title etc) for the channel.
Inside this method the <data> could be changed and additional items can
be created.
The return values should always be instantiated in at least ("", []).
"""
items = []
# we need to add a "more" item
url = self.parentItem.url
url, page = url.rsplit("/", 1)
url = "%s/%s" % (url, int(page) + 1)
moreItem = mediaitem.MediaItem("Meer", url)
moreItem.HttpHeaders = self.httpHeaders
moreItem.thumb = self.parentItem.thumb
moreItem.dontGroup = True
moreItem.complete = True
items.append(moreItem)
return data, items
def CreateMusicItem(self, resultSet):
"""Creates a MediaItem of type 'audio' using the resultSet from the regex.
Arguments:
resultSet : tuple (string) - the resultSet of the self.videoItemRegex
Returns:
A new MediaItem of type 'video' or 'audio' (despite the method's name)
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.UpdateVideoItem method is called if the item is focussed or selected
for playback.
"""
Logger.Trace(resultSet)
title = "%(composers)s - %(title)s" % resultSet
url = "http://www.24classics.com/app/ajax/auth.php?serial=%(serial)s" % resultSet
item = mediaitem.MediaItem(title, url)
item.icon = self.icon
item.type = "video"
# item.type = "audio" # seems to not really work well with track numbers (not showing)
item.thumb = self.parentItem.thumb
item.complete = False
item.description = "Composers: %(composers)s\nPerformers: %(performers)s" % resultSet
item.SetInfoLabel("TrackNumber", resultSet["order"])
item.SetInfoLabel("AlbumArtist", resultSet["composers"].split(","))
item.SetInfoLabel("Artist", resultSet["performers"].split(","))
return item
def CreateEpisodeItem(self, resultSet):
"""
Accepts an arraylist of results. It returns an item.
"""
Logger.Trace(resultSet)
title = resultSet["title"]
date = resultSet["trailers"][0]["postdate"]
url = resultSet["trailers"][0]["url"]
thumbUrl = resultSet["poster"]
if "http:" not in thumbUrl:
thumbUrl = "%s%s" % (self.baseUrl, thumbUrl)
fanart = thumbUrl.replace("poster.jpg", "background.jpg")
# get the url that shows all trailers/clips. Because the json
# only shows the most recent one.
url = "%s%s" % (self.baseUrl, url)
# Logger.Trace(date)
dates = date.split(" ")
# Logger.Trace(dates)
day = dates[1]
month = datehelper.DateHelper.GetMonthFromName(dates[2], "en")
year = dates[3]
# dummy class
item = mediaitem.MediaItem(title, url)
item.icon = self.icon
item.thumb = thumbUrl.replace("poster.jpg", "poster-xlarge.jpg")
item.fanart = fanart
item.SetDate(year, month, day)
item.complete = True
return item
def CreateEpisodeItemNew(self, resultSet):
"""Creates a new MediaItem for an episode
Arguments:
resultSet : list[string] - the resultSet of the self.episodeItemRegex
Returns:
A new MediaItem of type 'folder'
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Trace(resultSet)
url = "http://il.srgssr.ch/integrationlayer/1.0/ue/srf/assetSet/listByAssetGroup/%s.json?pageSize=100" % (resultSet["id"],)
# url = "http://www.srf.ch/player/webservice/videoprogram/index?id=%s" % (resultSet["id"],)
item = mediaitem.MediaItem(resultSet["title"], url)
item.description = resultSet.get("description", "")
item.icon = self.icon
item.httpHeaders = self.httpHeaders
item.thumb = self.__GetNestedValue(resultSet, "Image", "ImageRepresentations", "ImageRepresentation", 0, "url")
item.complete = True
return item
def CreateSearchResult(self, resultSet):
"""Creates a MediaItem of type 'video' using the resultSet from the regex.
Arguments:
resultSet : tuple (string) - the resultSet of the self.videoItemRegex
Returns:
A new MediaItem of type 'video' or 'audio' (despite the method's name)
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.UpdateVideoItem method is called if the item is focussed or selected
for playback.
"""
Logger.Trace(resultSet)
item = mediaitem.MediaItem(
resultSet["title"], "http://playapi.mtgx.tv/v3/videos/stream/%s" %
(resultSet["url"], ))
item.type = "video"
item.thumb = resultSet["thumburl"]
item.complete = False
# item.description = resultSet["description"]
return item
def CreateShowItem(self, resultSet):
"""
Accepts an arraylist of results. It returns an item.
"""
Logger.Trace(resultSet)
exclude = {
11: "Dagelijkse Kost",
388: "Het journaal",
400: "Karakters",
413: "Het weer"
}
if resultSet["id"] in exclude.keys():
return None
# # dummy class
# url = "http://www.een.be/mediatheek/tag/%s"
item = mediaitem.MediaItem(resultSet["title"], resultSet["url"])
item.icon = self.icon
item.type = "folder"
item.complete = True
if "image" in resultSet and "data" in resultSet["image"]:
item.thumb = resultSet["image"]["data"]["url"]
item.fanart = resultSet["image"]["data"]["url"]
return item
def CreatePageItem(self, resultSet):
"""Creates a MediaItem of type 'page' using the resultSet from the regex.
Arguments:
resultSet : tuple(string) - the resultSet of the self.pageNavigationRegex
Returns:
A new MediaItem of type 'page'
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Debug("Starting CreatePageItem")
Logger.Trace(resultSet)
url = resultSet["href"]
page = url.rsplit("=", 1)[-1]
item = mediaitem.MediaItem(page, url)
item.type = "page"
Logger.Debug("Created '%s' for url %s", item.name, item.url)
return item
def AddSearch(self, data):
"""Performs pre-process actions for data processing/
Arguments:
data : string - the retrieve data that was loaded for the current item and URL.
Returns:
A tuple of the data and a list of MediaItems that were generated.
Accepts an data from the ProcessFolderList method, BEFORE the items are
processed. Allows setting of parameters (like title etc) for the channel.
Inside this method the <data> could be changed and additional items can
be created.
The return values should always be instantiated in at least ("", []).
"""
Logger.Info("Performing Pre-Processing")
items = []
title = "\a.: %s :." % (self.searchInfo.get(
self.language, self.searchInfo["se"])[1], )
Logger.Trace("Adding search item: %s", title)
searchItem = mediaitem.MediaItem(title, "searchSite")
searchItem.thumb = self.noImage
searchItem.fanart = self.fanart
searchItem.dontGroup = True
items.append(searchItem)
Logger.Debug("Pre-Processing finished")
return data, items
def AddClips(self, data):
Logger.Info("Adding Clips Pre-Processing")
items = []
# if the main list was retrieve using json, are the current data is json, just determine
# the clip URL
clipUrl = None
if data.lstrip().startswith("{"):
if self.parentItem.url.endswith("type=program"):
# http://playapi.mtgx.tv/v3/videos?format=6723&order=-airdate&type=program
# http://playapi.mtgx.tv/v3/videos?format=6723&order=-updated&type=clip" % (dataId,)
clipUrl = self.parentItem.url.replace("type=program",
"type=clip")
else:
# now we determine the ID and load the json data
dataId = Regexer.DoRegex('data-format-id="(\d+)"', data)[-1]
Logger.Debug("Found FormatId = %s", dataId)
programUrl = "http://playapi.mtgx.tv/v3/videos?format=%s&order=-airdate&type=program" % (
dataId, )
data = UriHandler.Open(programUrl, proxy=self.proxy)
clipUrl = "http://playapi.mtgx.tv/v3/videos?format=%s&order=-updated&type=clip" % (
dataId, )
if clipUrl is not None:
clipTitle = LanguageHelper.GetLocalizedString(LanguageHelper.Clips)
clipItem = mediaitem.MediaItem("\a.: %s :." % (clipTitle, ),
clipUrl)
clipItem.thumb = self.noImage
items.append(clipItem)
Logger.Debug("Pre-Processing finished")
return data, items
def CreatePageItem(self, resultSet):
"""Creates a MediaItem of type 'page' using the resultSet from the regex.
Arguments:
resultSet : tuple(string) - the resultSet of the self.pageNavigationRegex
Returns:
A new MediaItem of type 'page'
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Trace(resultSet)
nextPage = resultSet["next"]
if not nextPage:
Logger.Debug("No more items available")
return None
more = LanguageHelper.GetLocalizedString(LanguageHelper.MorePages)
url = "%s=%s" % (self.parentItem.url.rsplit("=", 1)[0], nextPage)
item = mediaitem.MediaItem(more, url)
item.thumb = self.parentItem.thumb
item.icon = self.icon
item.fanart = self.parentItem.fanart
item.complete = True
return item
def CreateVideoItem(self, resultSet):
"""Creates a MediaItem of type 'video' using the resultSet from the regex.
Arguments:
resultSet : tuple (string) - the resultSet of the self.videoItemRegex
Returns:
A new MediaItem of type 'video' or 'audio' (despite the method's name)
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
If the item is completely processed an no further data needs to be fetched
the self.complete property should be set to True. If not set to True, the
self.UpdateVideoItem method is called if the item is focussed or selected
for playback.
"""
Logger.Trace(resultSet)
item = mediaitem.MediaItem(resultSet[0], resultSet[1])
item.thumb = self.noImage
item.icon = self.icon
item.type = 'video'
item.thumb = resultSet[2]
item.complete = False
return item
def CreateEpisodeItem(self, resultSet):
"""Creates a new MediaItem for an episode
Arguments:
resultSet : list[string] - the resultSet of the self.episodeItemRegex
Returns:
A new MediaItem of type 'folder'
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Trace(resultSet)
url = "http://il.srgssr.ch/integrationlayer/1.0/ue/srf/assetSet/listByAssetGroup/%s.json" % (resultSet["id"],)
item = mediaitem.MediaItem(resultSet["title"], url)
item.description = resultSet.get("description", "")
item.icon = self.icon
item.httpHeaders = self.httpHeaders
# the 0005 seems to be a quality thing: 0001, 0003, 0004, 0005
# http://www.srf.ch/webservice/picture/videogroup/c60026b7-2ed0-0001-b4b1-1f801a6355d0/0005
# http://www.srfcdn.ch/piccache/vis/videogroup/c6/00/c60026b7-2ed0-0001-b4b1-1f801a6355d0_0005_w_h_m.jpg
# item.thumb = "http://www.srf.ch/webservice/picture/videogroup/%s/0005" % (resultSet["id"],)
item.thumb = "http://www.srfcdn.ch/piccache/vis/videogroup/%s/%s/%s_0005_w_h_m.jpg" \
% (resultSet["id"][0:2], resultSet["id"][2:4], resultSet["id"],)
# item.thumb = resultSet.get("thumbUrl", None)
# item.thumb = "%s/scale/width/288" % (item.thumb, ) # apparently only the 144 return the correct HEAD info
# item.fanart = resultSet.get("imageUrl", None) $# the HEAD will not return a size, so Kodi can't handle it
item.complete = True
return item
def AddLiveItems(self, data):
""" Adds the Live entry to the mainlist
Arguments:
data : string - the retrieve data that was loaded for the current item and URL.
Returns:
A tuple of the data and a list of MediaItems that were generated.
Accepts an data from the ProcessFolderList method, BEFORE the items are
processed. Allows setting of parameters (like title etc) for the channel.
Inside this method the <data> could be changed and additional items can
be created.
The return values should always be instantiated in at least ("", []).
"""
items = []
if self.liveUrl:
Logger.Debug("Adding live item")
liveItem = mediaitem.MediaItem("\aLive TV", self.liveUrl)
liveItem.icon = self.icon
liveItem.thumb = self.noImage
liveItem.dontGroup = True
items.append(liveItem)
return data, items
def CreateEpisodeItem(self, resultSet):
"""Creates a new MediaItem for an episode
Arguments:
resultSet : list[string] - the resultSet of the self.episodeItemRegex
Returns:
A new MediaItem of type 'folder'
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Trace(resultSet)
if resultSet[0]:
title = resultSet[0]
url = resultSet[1]
else:
title = resultSet[2]
url = resultSet[3]
item = mediaitem.MediaItem(title, url)
item.thumb = self.noImage
item.icon = self.icon
return item
def CreateEpisodeItem(self, resultSet):
"""Creates a new MediaItem for an episode
Arguments:
resultSet : list[string] - the resultSet of the self.episodeItemRegex
Returns:
A new MediaItem of type 'folder'
This method creates a new MediaItem from the Regular Expression
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
url = "%s/%s" % (self.baseUrl, resultSet["url"])
item = mediaitem.MediaItem(resultSet["title"], url)
item.thumb = resultSet["thumburl"]
if not item.thumb.startswith("http"):
item.thumb = "%s%s" % (self.baseUrl, item.thumb)
item.thumb = item.thumb.replace("coverart-small", "coverart")
item.icon = self.icon
item.complete = True
return item
def AddLive(self, data):
"""Performs pre-process actions for data processing
Arguments:
data : string - the retrieve data that was loaded for the current item and URL.
Returns:
A tuple of the data and a list of MediaItems that were generated.
Accepts an data from the ProcessFolderList method, BEFORE the items are
processed. Allows setting of parameters (like title etc) for the channel.
Inside this method the <data> could be changed and additional items can
be created.
The return values should always be instantiated in at least ("", []).
"""
Logger.Info("Performing Pre-Processing")
items = []
item = mediaitem.MediaItem(
"\a.: Live TV :.", "http://www.tikilive.com:8080/socket.io/"
"?c=34967&n=TIKISESSID&i=fo84il3e7qs68uet2ql2eav081&EIO=3"
"&transport=polling&t=1428225927102-0")
item.type = 'video'
items.append(item)
Logger.Debug("Pre-Processing finished")
return data, items
def CreateEpisodeItem(self, resultSet):
"""Creates a new MediaItem for an episode
Arguments:
resultSet : list[string] - the resultSet of the self.episodeItemRegex
Returns:
A new MediaItem of type 'folder'
This method creates a new MediaItem from the Regular Expression or Json
results <resultSet>. The method should be implemented by derived classes
and are specific to the channel.
"""
Logger.Trace(resultSet)
title = resultSet["title"]
description = resultSet.get("description", "")
descriptionNL = resultSet.get("introduction_lan1", "")
thumb = resultSet["image_full"]
url = "http://www.24classics.com/app/core/server_load.php?r=default&page=luister&serial=&subserial=&hook=%(hook)s" % resultSet
item = mediaitem.MediaItem(title, url)
item.icon = self.icon
item.thumb = thumb
item.description = "%s\n\n%s" % (descriptionNL, description)
item.description = item.description.strip()
item.complete = True
return item
