def add_live_streams(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
items = []
if self.parentItem is None:
live_item = MediaItem(
"\a.: Live TV :.",
"https://d5ms27yy6exnf.cloudfront.net/live/omroepflevoland/tv/index.m3u8"
)
live_item.icon = self.icon
live_item.thumb = self.noImage
live_item.type = 'video'
live_item.dontGroup = True
now = datetime.datetime.now()
live_item.set_date(now.year, now.month, now.day, now.hour,
now.minute, now.second)
items.append(live_item)
live_item = MediaItem(
"\a.: Live Radio :.",
"https://d5ms27yy6exnf.cloudfront.net/live/omroepflevoland/radio/index.m3u8"
)
live_item.icon = self.icon
live_item.thumb = self.noImage
live_item.type = 'video'
live_item.dontGroup = True
now = datetime.datetime.now()
live_item.set_date(now.year, now.month, now.day, now.hour,
now.minute, now.second)
items.append(live_item)
# add "More"
more = LanguageHelper.get_localized_string(LanguageHelper.MorePages)
current_url = self.parentItem.url if self.parentItem is not None else self.mainListUri
url, page = current_url.rsplit("=", 1)
url = "{}={}".format(url, int(page) + 1)
item = MediaItem(more, url)
item.thumb = self.noImage
item.icon = self.icon
item.fanart = self.fanart
item.complete = True
items.append(item)
return data, items
def add_recent_items(self, data):
""" Builds the "Recent" folder for this channel.
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
items = []
recent = MediaItem("\a .: Recent :.", "")
recent.type = "folder"
recent.complete = True
recent.dontGroup = True
items.append(recent)
today = datetime.datetime.now()
days = [
"Maandag", "Dinsdag", "Woensdag", "Donderdag", "Vrijdag",
"Zaterdag", "Zondag"
]
for i in range(0, 7, 1):
air_date = today - datetime.timedelta(i)
Logger.trace("Adding item for: %s", air_date)
# Determine a nice display date
day = days[air_date.weekday()]
if i == 0:
day = "Vandaag"
elif i == 1:
day = "Gisteren"
elif i == 2:
day = "Eergisteren"
title = "%04d-%02d-%02d - %s" % (air_date.year, air_date.month,
air_date.day, day)
# url = "https://www.npostart.nl/media/series?page=1&dateFrom=%04d-%02d-%02d&tileMapping=normal&tileType=teaser&pageType=catalogue" % \
url = "https://xlapi.rtl.nl/version=1/fun=gemist/model=svod/bcdate=" \
"{0:04d}{1:02d}{2:02d}/".format(air_date.year, air_date.month, air_date.day)
extra = MediaItem(title, url)
extra.complete = True
extra.icon = self.icon
extra.thumb = self.noImage
extra.dontGroup = True
extra.set_date(air_date.year,
air_date.month,
air_date.day,
text="")
recent.items.append(extra)
news = MediaItem("\a .: Zoeken :.", "#searchSite")
news.type = "folder"
news.complete = True
news.dontGroup = True
items.append(news)
return data, items
def add_search_and_genres(self, data):
""" Performs pre-process actions for data processing and adds a search option and genres.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
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
search_item = MediaItem("\a.: Sök :.", "searchSite")
search_item.complete = True
search_item.thumb = self.noImage
search_item.dontGroup = True
search_item.fanart = self.fanart
# search_item.set_date(2099, 1, 1, text="")
# -> No items have dates, so adding this will force a date sort in Retrospect
items.append(search_item)
genres_item = MediaItem("\a.: Genrer :.", "")
genres_item.complete = True
genres_item.thumb = self.noImage
genres_item.dontGroup = True
genres_item.fanart = self.fanart
items.append(genres_item)
# find the actual genres
genre_regex = '<li[^>]+genre[^>]*><button[^>]+data-value="(?<genre>[^"]+)"[^>]*>' \
'(?<title>[^>]+)</button></li>'
genre_regex = Regexer.from_expresso(genre_regex)
genres = Regexer.do_regex(genre_regex, data)
for genre in genres:
if genre["genre"] == "all":
continue
genre_item = MediaItem(genre["title"], self.mainListUri)
genre_item.complete = True
genre_item.thumb = self.noImage
genre_item.fanart = self.fanart
genre_item.metaData = {"genre": genre["genre"]}
genres_item.items.append(genre_item)
Logger.debug("Pre-Processing finished")
return data, items
def add_live_streams_and_recent(self, data):
""" Adds the live streams for RTL-Z.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
items = []
# let's add the RTL-Z live stream
rtlz_live = MediaItem("RTL Z Live Stream", "")
rtlz_live.icon = self.icon
rtlz_live.thumb = self.noImage
rtlz_live.complete = True
rtlz_live.isLive = True
rtlz_live.dontGroup = True
stream_item = MediaItem(
"RTL Z: Live Stream",
"http://www.rtl.nl/(config=RTLXLV2,channel=rtlxl,progid=rtlz,zone=inlineplayer.rtl.nl/rtlz,ord=0)/system/video/wvx/components/financien/rtlz/miMedia/livestream/rtlz_livestream.xml/1500.wvx"
)
stream_item.icon = self.icon
stream_item.thumb = self.noImage
stream_item.complete = True
stream_item.type = "video"
stream_item.dontGroup = True
stream_item.append_single_stream("http://mss6.rtl7.nl/rtlzbroad", 1200)
stream_item.append_single_stream("http://mss26.rtl7.nl/rtlzbroad",
1200)
stream_item.append_single_stream("http://mss4.rtl7.nl/rtlzbroad", 1200)
stream_item.append_single_stream("http://mss5.rtl7.nl/rtlzbroad", 1200)
stream_item.append_single_stream("http://mss3.rtl7.nl/rtlzbroad", 1200)
rtlz_live.items.append(stream_item)
items.append(rtlz_live)
# Add recent items
data, recent_items = self.add_recent_items(data)
return data, recent_items
def add_categories(self, data):
""" Adds categories to the main listings.
The return values should always be instantiated in at least ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
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("\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("\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)
channel_text = LanguageHelper.get_localized_string(30010)
channels = MediaItem("\a.: %s :." % (channel_text, ), "#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 AddLiveChannel(self, data):
Logger.Info("Performing Pre-Processing")
# if self.channelCode != "vtm":
# return data, []
username = AddonSettings.GetSetting("mediaan_username")
if not username:
return data, []
items = []
if self.channelCode == "vtm":
item = MediaItem("Live VTM", "#livestream")
else:
item = MediaItem("Live Q2", "#livestream")
item.type = "video"
item.isLive = True
item.fanart = self.fanart
item.thumb = self.noImage
now = datetime.datetime.now()
item.SetDate(now.year, now.month, now.day, now.hour, now.minute, now.second)
items.append(item)
if self.channelCode == "vtm":
recent = MediaItem("\a.: Recent :.", "https://vtm.be/video/volledige-afleveringen/id")
item.fanart = self.fanart
item.thumb = self.noImage
item.dontGroup = True
items.append(recent)
Logger.Debug("Pre-Processing finished")
return data, items
def add_live_items(self, data):
""" Performs pre-process actions for data processing and adds the live channels if present.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
items = []
if self.liveUrl:
Logger.debug("Adding live item")
live_item = MediaItem("\aLive TV", self.liveUrl)
live_item.icon = self.icon
live_item.thumb = self.noImage
live_item.dontGroup = True
items.append(live_item)
return data, items
def add_search(self, data):
""" Adds a search item.
The return values should always be instantiated in at least ("", []).
:param JsonHelper data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
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)
search_item = MediaItem(title, "searchSite")
search_item.thumb = self.noImage
search_item.fanart = self.fanart
search_item.dontGroup = True
items.append(search_item)
Logger.debug("Pre-Processing finished")
return data, items
def alpha_listing(self, data):
""" Creates a alpha listing with items pointing to the alpha listing on line.
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Generating an Alpha list for BBC")
items = []
# https://www.bbc.co.uk/iplayer/a-z/a
title_format = LanguageHelper.get_localized_string(
LanguageHelper.StartWith)
url_format = "https://www.bbc.co.uk/iplayer/a-z/%s"
for char in "abcdefghijklmnopqrstuvwxyz0":
if char == "0":
char = "0-9"
sub_item = MediaItem(title_format % (char.upper(), ),
url_format % (char, ))
sub_item.complete = True
sub_item.icon = self.icon
sub_item.thumb = self.noImage
sub_item.dontGroup = True
sub_item.HttpHeaders = {"X-Requested-With": "XMLHttpRequest"}
items.append(sub_item)
return data, items
def list_channels(self, data):
""" Lists all the available channels.
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
items = []
for name, meta in self.__channelData.items():
if "metaCode" not in meta:
continue
channel = MediaItem(meta["title"], self.mainListUri)
# noinspection PyArgumentList
channel.fanart = meta.get("fanart", self.fanart)
# noinspection PyArgumentList
channel.thumb = meta.get("icon", self.icon)
# noinspection PyArgumentList
channel.icon = meta.get("icon", self.icon)
channel.dontGroup = True
channel.metaData["code"] = meta["metaCode"]
items.append(channel)
return data, items
def add_categories_and_search(self, data):
""" Adds some generic items such as search and categories to the main listing.
The return values should always be instantiated in at least ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Performing Pre-Processing")
items = []
max_items = 200
categories = {
# "\a.: Mest spelade :.": "https://urplay.se/Mest-spelade",
"\a.: Mest delade :.": "https://urplay.se/sok?product_type=program&query=&view=most_viewed&rows=%s&start=0" % (max_items, ),
"\a.: Senaste :.": "https://urplay.se/sok?product_type=program&query=&view=latest&rows=%s&start=0" % (max_items, ),
"\a.: Sista chansen :.": "https://urplay.se/sok?product_type=program&query=&view=default&rows=%s&start=0" % (max_items, ),
"\a.: Kategorier :.": "https://urplay.se/",
"\a.: Sök :.": "searchSite"
}
for cat in categories:
item = MediaItem(cat, categories[cat])
item.thumb = self.noImage
item.complete = True
item.icon = self.icon
item.dontGroup = True
items.append(item)
Logger.debug("Pre-Processing finished")
return data, items
def StievieMenu(self, data):
""" Creates the main Stievie menu """
items = []
if not self.__dashStreamsSupported:
return data, items
programs = MediaItem("\b.: Programma's :.", "https://vod.medialaan.io/vod/v2/programs?offset=0&limit=0")
programs.dontGroup = True
items.append(programs)
search = MediaItem("Zoeken", "searchSite")
search.complete = True
search.icon = self.icon
search.thumb = self.noImage
search.dontGroup = True
search.SetDate(2200, 1, 1, text="")
items.append(search)
return data, items
def StievieChannelMenu(self, data):
items = []
live = MediaItem("Live %s" % (self.parentItem.name, ), "#livestream")
live.isLive = True
live.type = "video"
live.description = self.parentItem.description
live.metaData = self.parentItem.metaData
live.thumb = self.parentItem.thumb
items.append(live)
if not self.__dashStreamsSupported:
# Only list the channel content if DASH is supported
return data, items
# https://epg.medialaan.io/epg/v2/schedule?date=2017-04-25&channels%5B%5D=vtm&channels%5B%5D=2be&channels%5B%5D=vitaya&channels%5B%5D=caz&channels%5B%5D=kzoom&channels%5B%5D=kadet&channels%5B%5D=qmusic
# https://epg.medialaan.io/epg/v2/schedule?date=2017-04-25&channels[]=vtm&channels[]=2be&channels[]=vitaya&channels[]=caz&channels[]=kzoom&channels[]=kadet&channels[]=qmusic
# https://epg.medialaan.io/epg/v2/schedule?date=2017-05-04&channels[]=vtm&channels[]=2be&channels[]=vitaya&channels[]=caz&channels[]=kzoom&channels[]=kadet&channels[]=qmusic
channelId = self.parentItem.metaData["channelId"]
channels = (channelId, )
query = "&channels%%5B%%5D=%s" % ("&channels%5B%5D=".join(channels), )
today = datetime.datetime.now()
days = [
"Maandag", "Dinsdag", "Woensdag", "Donderdag", "Vrijdag",
"Zaterdag", "Zondag"
]
for i in range(0, 7, 1):
airDate = today - datetime.timedelta(i)
Logger.Trace("Adding item for: %s", airDate)
day = days[airDate.weekday()]
if i == 0:
day = "Vandaag"
elif i == 1:
day = "Gisteren"
elif i == 2:
day = "Eergisteren"
title = "%04d-%02d-%02d - %s" % (airDate.year, airDate.month,
airDate.day, day)
url = "https://epg.medialaan.io/epg/v2/schedule?date=%d-%02d-%02d%s" % (
airDate.year, airDate.month, airDate.day, query)
extra = MediaItem(title, url)
extra.complete = True
extra.icon = self.icon
extra.thumb = self.noImage
extra.dontGroup = True
extra.SetDate(airDate.year, airDate.month, airDate.day, text="")
extra.metaData["airDate"] = airDate
items.append(extra)
return data, items
def __ShowEmptyInformation(self, items, favs=False):
""" Adds an empty item to a list or just shows a message.
@type favs: boolean indicating that we are dealing with favourites
@param items: the list of items
@rtype : boolean indicating succes or not
"""
if self.channelObject:
Statistics.RegisterError(self.channelObject)
if favs:
title = LanguageHelper.GetLocalizedString(LanguageHelper.NoFavsId)
else:
title = LanguageHelper.GetLocalizedString(LanguageHelper.ErrorNoEpisodes)
behaviour = AddonSettings.GetEmptyListBehaviour()
Logger.Debug("Showing empty info for mode (favs=%s): [%s]", favs, behaviour)
if behaviour == "error":
# show error
ok = False
elif behaviour == "dummy" and not favs:
# We should add a dummy items, but not for favs
emptyListItem = MediaItem("- %s -" % (title.strip("."), ), "", type='video')
emptyListItem.icon = self.channelObject.icon
emptyListItem.thumb = self.channelObject.noImage
emptyListItem.fanart = self.channelObject.fanart
emptyListItem.dontGroup = True
emptyListItem.description = "This listing was left empty intentionally."
emptyListItem.complete = True
emptyListItem.fanart = self.channelObject.fanart
# add funny stream here?
# part = emptyListItem.CreateNewEmptyMediaPart()
# for s, b in YouTube.GetStreamsFromYouTube("", self.channelObject.proxy):
# part.AppendMediaStream(s, b)
# if we add one, set OK to True
ok = True
items.append(emptyListItem)
else:
ok = True
XbmcWrapper.ShowNotification(LanguageHelper.GetLocalizedString(LanguageHelper.ErrorId),
title, XbmcWrapper.Error, 2500)
return ok
def extract_json(self, data):
""" Extracts JSON data from pages
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
items = []
recent = MediaItem("\a .: Recent :.", "https://www.een.be/deze-week")
recent.type = "folder"
recent.complete = True
recent.dontGroup = True
items.append(recent)
data = Regexer.do_regex(r'epgAZ\W+({"data"[\w\W]+?);<', data)[0]
return data, items
def add_page_items(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Performing Pre-Processing")
items = []
json = JsonHelper(data)
total_results = json.get_value("totalResults")
from_value = json.get_value("from")
size_value = json.get_value("size")
if from_value + size_value < total_results:
more_pages = LanguageHelper.get_localized_string(
LanguageHelper.MorePages)
url = self.parentItem.url.split('?')[0]
url = "%s?size=%s&from=%s&sort=Nieuwste" % (
url, size_value, from_value + size_value)
Logger.debug("Adding next-page item from %s to %s",
from_value + size_value,
from_value + size_value + size_value)
next_page = MediaItem(more_pages, url)
next_page.icon = self.parentItem.icon
next_page.fanart = self.parentItem.fanart
next_page.thumb = self.parentItem.thumb
next_page.dontGroup = True
items.append(next_page)
Logger.debug("Pre-Processing finished")
return json, items
def add_live_channel(self, data):
""" Adds the live channel.
The return values should always be instantiated in at least ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
# Only get the first bit
items = []
item = MediaItem("\a.: Live :.", "http://sporza.be/cm/sporza/matchcenter/mc_livestream")
item.type = "folder"
item.dontGroup = True
item.complete = False
items.append(item)
return data, items
def add_pages(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Adding pages")
# extract the current page from:
# http://www.foxsports.nl/video/filter/fragments/1/alle/tennis/
current_pages = Regexer.do_regex(r'(.+filter/fragments)/(\d+)/(.+)',
self.parentItem.url)
if not current_pages:
return data, []
current_page = current_pages[0]
items = []
url = "%s/%s/%s" % (current_page[0], int(current_page[1]) + 1,
current_page[2])
page_item = MediaItem(
LanguageHelper.get_localized_string(LanguageHelper.MorePages), url)
page_item.fanart = self.parentItem.fanart
page_item.thumb = self.parentItem.thumb
page_item.dontGroup = True
items.append(page_item)
return data, items
def add_category_and_live_items(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Performing Pre-Processing")
items = []
sub_items = {
"\a.: Direct :.":
"%s/auvio/direct/" % (self.baseUrl, ),
"\a.: Catégories :.":
"http://www.rtbf.be/news/api/menu?site=media"
}
for k, v in sub_items.items():
item = MediaItem(k, v)
item.complete = True
item.dontGroup = True
items.append(item)
item.isLive = v.endswith('/direct/')
Logger.debug("Pre-Processing finished")
return data, items
def add_live_items_and_genres(self, data):
""" Adds the Live items, Channels and Last Episodes to the listing.
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
items = []
extra_items = {
LanguageHelper.get_localized_string(LanguageHelper.LiveTv):
"https://www.svtplay.se/kanaler",
LanguageHelper.get_localized_string(LanguageHelper.CurrentlyPlayingEpisodes):
"https://www.svtplay.se/direkt?sida=1",
LanguageHelper.get_localized_string(LanguageHelper.Search):
"searchSite",
LanguageHelper.get_localized_string(LanguageHelper.Recent):
"https://www.svtplay.se/senaste?sida=1",
LanguageHelper.get_localized_string(LanguageHelper.LastChance):
"https://www.svtplay.se/sista-chansen?sida=1",
LanguageHelper.get_localized_string(LanguageHelper.MostViewedEpisodes):
"https://www.svtplay.se/populara?sida=1",
}
for title, url in extra_items.items():
new_item = MediaItem("\a.: %s :." % (title, ), url)
new_item.complete = True
new_item.thumb = self.noImage
new_item.dontGroup = True
items.append(new_item)
# https://www.svtplay.se/ajax/dokumentar/titlar?filterAccessibility=&filterRights=
category_items = {
"Drama":
("https://www.svtplay.se/genre/drama",
"https://www.svtstatic.se/play/play5/images/categories/posters/drama-d75cd2da2eecde36b3d60fad6b92ad42.jpg"
),
"Dokumentär":
("https://www.svtplay.se/genre/dokumentar",
"https://www.svtstatic.se/play/play5/images/categories/posters/dokumentar-00599af62aa8009dbc13577eff894b8e.jpg"
),
"Humor":
("https://www.svtplay.se/genre/humor",
"https://www.svtstatic.se/play/play5/images/categories/posters/humor-abc329317eedf789d2cca76151213188.jpg"
),
"Livsstil":
("https://www.svtplay.se/genre/livsstil",
"https://www.svtstatic.se/play/play5/images/categories/posters/livsstil-2d9cd77d86c086fb8908ce4905b488b7.jpg"
),
"Underhållning":
("https://www.svtplay.se/genre/underhallning",
"https://www.svtstatic.se/play/play5/images/categories/posters/underhallning-a60da5125e715d74500a200bd4416841.jpg"
),
"Kultur":
("https://www.svtplay.se/genre/kultur",
"https://www.svtstatic.se/play/play5/images/categories/posters/kultur-93dca50ed1d6f25d316ac1621393851a.jpg"
),
"Samhälle & Fakta":
("https://www.svtplay.se/genre/samhalle-och-fakta",
"https://www.svtstatic.se/play/play5/images/categories/posters/samhalle-och-fakta-3750657f72529a572f3698e01452f348.jpg"
),
"Film":
("https://www.svtplay.se/genre/film",
"https://www.svtstatic.se/image-cms/svtse/1436202866/svtplay/article2952281.svt/ALTERNATES/large/film1280-jpg"
),
"Barn":
("https://www.svtplay.se/genre/barn",
"https://www.svtstatic.se/play/play5/images/categories/posters/barn-c17302a6f7a9a458e0043b58bbe8ab79.jpg"
),
"Nyheter":
("https://www.svtplay.se/genre/nyheter",
"https://www.svtstatic.se/play/play6/images/categories/posters/nyheter.e67ff1b5770152af4690ad188546f9e9.jpg"
),
"Sport":
("https://www.svtplay.se/genre/sport",
"https://www.svtstatic.se/play/play6/images/categories/posters/sport.98b65f6627e4addbc4177542035ea504.jpg"
)
}
category_title = "\a.: {} :.".format(
LanguageHelper.get_localized_string(LanguageHelper.Categories))
new_item = MediaItem(category_title, "https://www.svtplay.se/genre")
new_item.complete = True
new_item.thumb = self.noImage
new_item.dontGroup = True
for title, (url, thumb) in category_items.items():
cat_item = MediaItem(title, url)
cat_item.complete = True
cat_item.thumb = thumb or self.noImage
cat_item.dontGroup = True
new_item.items.append(cat_item)
items.append(new_item)
genre_tags = "\a.: {}/{} :.".format(
LanguageHelper.get_localized_string(LanguageHelper.Genres),
LanguageHelper.get_localized_string(LanguageHelper.Tags))
new_item = MediaItem(genre_tags, "https://www.svtplay.se/api/clusters")
new_item.complete = True
new_item.thumb = self.noImage
new_item.dontGroup = True
items.append(new_item)
return data, items
def add_live_channels_and_folders(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Generating Live channels")
items = []
live_channels = [
{
"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("Live Channels", "")
live.dontGroup = True
live.type = "folder"
items.append(live)
for channel in live_channels:
url = "http://a.files.bbci.co.uk/media/live/manifesto/audio_video/simulcast/hds/uk/pc/ak/%(code)s.f4m" % channel
item = MediaItem(channel["name"], url)
item.isGeoLocked = True
item.isLive = True
item.type = "video"
item.complete = False
item.thumb = self.get_image_location(channel["image"])
live.items.append(item)
extra = MediaItem("Shows (A-Z)", "#alphalisting")
extra.complete = True
extra.icon = self.icon
extra.thumb = self.noImage
extra.description = "Alphabetical show listing of BBC shows"
extra.dontGroup = True
extra.set_date(2200, 1, 1, text="")
items.append(extra)
return data, items
def add_categories(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Performing Pre-Processing")
items = []
cat = 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(
"\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("\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"):
age_item = MediaItem(
"%s Jaar" % (age, ),
"http://m.schooltv.nl/api/v1/leeftijdscategorieen/%s/afleveringen.json?"
"size=%s&sort=Nieuwste" % (age, self.__PageSize))
age_item.thumb = self.noImage
age_item.icon = self.icon
age_item.fanart = self.fanart
age_item.complete = True
age_item.dontGroup = True
ages.items.append(age_item)
# We should list programs instead of videos, so just prefill them here.
for program in data.get_value():
if age in program['ageGroups']:
age_item.items.append(self.create_episode_item(program))
items.append(ages)
Logger.debug("Pre-Processing finished")
return data, items
def load_programs(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
items = []
# fetch al pages
p = 1
url_format = "https://{0}/content/shows?" \
"include=images" \
"&page%5Bsize%5D=100&page%5Bnumber%5D={{0}}".format(self.baseUrlApi)
# "include=images%2CprimaryChannel" \
url = url_format.format(p)
data = UriHandler.open(url, proxy=self.proxy)
json = JsonHelper(data)
pages = json.get_value("meta", "totalPages")
programs = json.get_value("data") or []
# extract the images
self.__update_image_lookup(json)
for p in range(2, pages + 1, 1):
url = url_format.format(p)
Logger.debug("Loading: %s", url)
data = UriHandler.open(url, proxy=self.proxy)
json = JsonHelper(data)
programs += json.get_value("data") or []
# extract the images
self.__update_image_lookup(json)
Logger.debug("Found a total of %s items over %s pages", len(programs),
pages)
for p in programs:
item = self.create_program_item(p)
if item is not None:
items.append(item)
if self.recentUrl:
recent_text = LanguageHelper.get_localized_string(
LanguageHelper.Recent)
recent = MediaItem("\b.: {} :.".format(recent_text),
self.recentUrl)
recent.dontGroup = True
recent.fanart = self.fanart
items.append(recent)
# live items
if self.liveUrl:
live = MediaItem("\b.: Live :.", self.liveUrl)
live.type = "video"
live.dontGroup = True
live.isGeoLocked = True
live.isLive = True
live.fanart = self.fanart
items.append(live)
search = MediaItem("\a.: Sök :.", "searchSite")
search.type = "folder"
search.dontGroup = True
search.fanart = self.fanart
items.append(search)
return data, items
def __show_empty_information(self, items, favs=False):
""" Adds an empty item to a list or just shows a message.
@type favs: boolean
@param items:
:param list[MediaItem] items: The list of items.
:param bool favs: Indicating that we are dealing with favourites.
:return: boolean indicating to report the listing as succes or not.
:rtype: ok
"""
if favs:
title = LanguageHelper.get_localized_string(
LanguageHelper.NoFavsId)
else:
title = LanguageHelper.get_localized_string(
LanguageHelper.ErrorNoEpisodes)
behaviour = AddonSettings.get_empty_list_behaviour()
Logger.debug("Showing empty info for mode (favs=%s): [%s]", favs,
behaviour)
if behaviour == "error":
# show error
ok = False
elif behaviour == "dummy" and not favs:
# We should add a dummy items, but not for favs
empty_list_item = MediaItem("- %s -" % (title.strip("."), ),
"",
type='video')
if self.channelObject:
empty_list_item.icon = self.channelObject.icon
empty_list_item.thumb = self.channelObject.noImage
empty_list_item.fanart = self.channelObject.fanart
else:
icon = os.path.join(Config.rootDir, "icon.png")
fanart = os.path.join(Config.rootDir, "fanart.jpg")
empty_list_item.icon = icon
empty_list_item.thumb = fanart
empty_list_item.fanart = fanart
empty_list_item.dontGroup = True
empty_list_item.description = "This listing was left empty intentionally."
empty_list_item.complete = True
# add funny stream here?
# part = empty_list_item.create_new_empty_media_part()
# for s, b in YouTube.get_streams_from_you_tube("", self.channelObject.proxy):
# part.append_media_stream(s, b)
# if we add one, set OK to True
ok = True
items.append(empty_list_item)
else:
ok = True
XbmcWrapper.show_notification(
LanguageHelper.get_localized_string(LanguageHelper.ErrorId), title,
XbmcWrapper.Error, 2500)
return ok
def add_categories_and_specials(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Performing Pre-Processing")
items = []
extras = {
LanguageHelper.get_localized_string(LanguageHelper.Search):
("searchSite", None, False),
LanguageHelper.get_localized_string(LanguageHelper.TvShows):
("http://webapi.tv4play.se/play/programs?is_active=true&platform=tablet"
"&per_page=1000&fl=nid,name,program_image,is_premium,updated_at,channel&start=0",
None, False)
}
# Channel 4 specific items
if self.channelCode == "tv4se":
extras.update({
LanguageHelper.get_localized_string(LanguageHelper.Categories):
("http://webapi.tv4play.se/play/categories.json", None, False),
LanguageHelper.get_localized_string(LanguageHelper.MostViewedEpisodes):
("http://webapi.tv4play.se/play/video_assets/most_viewed?type=episode"
"&platform=tablet&is_live=false&per_page=%s&start=0" %
(self.maxPageSize, ), None, False),
})
# if self.loggedOn:
# extras.update({
# "\a.: Favoriter :.": (
# "http://www.tv4play.se/program/favourites",
# None, True
# ),
# })
today = datetime.datetime.now()
days = [
LanguageHelper.get_localized_string(LanguageHelper.Monday),
LanguageHelper.get_localized_string(LanguageHelper.Tuesday),
LanguageHelper.get_localized_string(LanguageHelper.Wednesday),
LanguageHelper.get_localized_string(LanguageHelper.Thursday),
LanguageHelper.get_localized_string(LanguageHelper.Friday),
LanguageHelper.get_localized_string(LanguageHelper.Saturday),
LanguageHelper.get_localized_string(LanguageHelper.Sunday)
]
for i in range(0, 7, 1):
start_date = today - datetime.timedelta(i)
end_date = start_date + datetime.timedelta(1)
day = days[start_date.weekday()]
if i == 0:
day = LanguageHelper.get_localized_string(
LanguageHelper.Today)
elif i == 1:
day = LanguageHelper.get_localized_string(
LanguageHelper.Yesterday)
Logger.trace("Adding item for: %s - %s", start_date, end_date)
# Old URL:
# url = "http://webapi.tv4play.se/play/video_assets?exclude_node_nids=" \
# "nyheterna,v%C3%A4der,ekonomi,lotto,sporten,nyheterna-blekinge,nyheterna-bor%C3%A5s," \
# "nyheterna-dalarna,nyheterna-g%C3%A4vle,nyheterna-g%C3%B6teborg,nyheterna-halland," \
# "nyheterna-helsingborg,nyheterna-j%C3%B6nk%C3%B6ping,nyheterna-kalmar,nyheterna-link%C3%B6ping," \
# "nyheterna-lule%C3%A5,nyheterna-malm%C3%B6,nyheterna-norrk%C3%B6ping,nyheterna-skaraborg," \
# "nyheterna-skellefte%C3%A5,nyheterna-stockholm,nyheterna-sundsvall,nyheterna-ume%C3%A5," \
# "nyheterna-uppsala,nyheterna-v%C3%A4rmland,nyheterna-v%C3%A4st,nyheterna-v%C3%A4ster%C3%A5s," \
# "nyheterna-v%C3%A4xj%C3%B6,nyheterna-%C3%B6rebro,nyheterna-%C3%B6stersund,tv4-tolken," \
# "fotbollskanalen-europa" \
# "&platform=tablet&per_page=32&is_live=false&product_groups=2&type=episode&per_page=100"
url = "http://webapi.tv4play.se/play/video_assets?exclude_node_nids=" \
"&platform=tablet&per_page=32&is_live=false&product_groups=2&type=episode&per_page=100"
url = "%s&broadcast_from=%s&broadcast_to=%s&" % (
url, start_date.strftime("%Y%m%d"),
end_date.strftime("%Y%m%d"))
extras[day] = (url, start_date, False)
extras[LanguageHelper.get_localized_string(
LanguageHelper.CurrentlyPlayingEpisodes
)] = (
"http://webapi.tv4play.se/play/video_assets?exclude_node_nids=&platform=tablet&"
"per_page=32&is_live=true&product_groups=2&type=episode&per_page=100",
None, False)
for name in extras:
title = name
url, date, is_live = extras[name]
item = MediaItem(title, url)
item.dontGroup = True
item.complete = True
item.thumb = self.noImage
item.HttpHeaders = self.httpHeaders
item.isLive = is_live
if date is not None:
item.set_date(date.year,
date.month,
date.day,
0,
0,
0,
text=date.strftime("%Y-%m-%d"))
else:
item.set_date(1901, 1, 1, 0, 0, 0, text="")
items.append(item)
if not self.channelCode == "tv4se":
return data, items
# Add Live TV
# live = MediaItem("\a.: Live-TV :.",
# "http://tv4events1-lh.akamaihd.net/i/EXTRAEVENT5_1@324055/master.m3u8",
# type="video")
# live.dontGroup = True
# # live.isDrmProtected = True
# live.isGeoLocked = True
# live.isLive = True
# items.append(live)
Logger.debug("Pre-Processing finished")
return data, items
def add_others(self, data):
""" Performs pre-process actions for data processing.
Accepts an data from the process_folder_list 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 ("", []).
:param str data: The retrieve data that was loaded for the current item and URL.
:return: A tuple of the data and a list of MediaItems that were generated.
:rtype: tuple[str|JsonHelper,list[MediaItem]]
"""
Logger.info("Performing Pre-Processing")
items = []
others = MediaItem(
"\b.: Populair :.",
"https://api.kijk.nl/v2/default/sections/popular_PopularVODs?offset=0"
)
items.append(others)
days = MediaItem("\b.: Deze week :.", "#lastweek")
items.append(days)
search = MediaItem("\b.: Zoeken :.", "searchSite")
search.complete = True
search.icon = self.icon
search.thumb = self.noImage
search.dontGroup = True
search.HttpHeaders = {"X-Requested-With": "XMLHttpRequest"}
items.append(search)
if self.channelCode == "veronica":
live = LanguageHelper.get_localized_string(
LanguageHelper.LiveStreamTitleId)
live_radio = MediaItem("Radio Veronica {}".format(live), "")
live_radio.type = "video"
live_radio.icon = self.icon
live_radio.thumb = self.noImage
live_radio.dontGroup = True
part = live_radio.create_new_empty_media_part()
live_stream = "https://talparadiohls-i.akamaihd.net/hls/live/585615/VR-Veronica-1/playlist.m3u8"
if AddonSettings.use_adaptive_stream_add_on(with_encryption=False,
channel=self):
stream = part.append_media_stream(live_stream, 0)
M3u8.set_input_stream_addon_input(stream, self.proxy)
live_radio.complete = True
else:
for s, b in M3u8.get_streams_from_m3u8(live_stream,
self.proxy):
live_radio.complete = True
part.append_media_stream(s, b)
items.append(live_radio)
Logger.debug("Pre-Processing finished")
return data, items
