def __init__( self ):
# parse argv for any params
params = self._parse_argv()
# get users preference
self._get_settings()
# sort methods
sortmethods = ( xbmcplugin.SORT_METHOD_LABEL, xbmcplugin.SORT_METHOD_SIZE, xbmcplugin.SORT_METHOD_DATE,
xbmcplugin.SORT_METHOD_VIDEO_RUNTIME, xbmcplugin.SORT_METHOD_VIDEO_YEAR, xbmcplugin.SORT_METHOD_GENRE,
xbmcplugin.SORT_METHOD_MPAA_RATING, xbmcplugin.SORT_METHOD_STUDIO, )
# initialize buttons, we only need to set these once
buttons = None
# fetch items
if ( params[ "category" ] is None ):
# skin buttons
buttons = ( 21866,
(
( "Recently Added", "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"recent: Recently Added" ) ), ), None, None, None, ),
( 135, "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"genres" ) ), ), None, None, None, ),
( 20388, "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"studios" ) ), ), None, None, None, ),
( 20348, "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"directors" ) ), ), None, None, None, ),
( 344, "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"actors" ) ), ), None, None, None, ),
),
)
# set category
else:
self.PluginCategory = params[ "category" ].replace( "genres", xbmc.getLocalizedString( 135 ) ).replace( "studios", xbmc.getLocalizedString( 20388 ) ).replace( "directors", xbmc.getLocalizedString( 20348 ) ).replace( "actors", xbmc.getLocalizedString( 344 ) ).replace( "recent: ", "" )
# helper functions
self.MediaWindow = MediaWindow( int( sys.argv[ 1 ] ), category=self.PluginCategory, content="movies", sortmethods=sortmethods, fanart=( self.settings[ "fanart_image" ], self.Fanart, ), buttons=buttons )
# fetch videos
self.MediaWindow.end( self.fetch_trailers( params[ "category" ] ) )
def __init__(self, *args, **kwargs):
# set our passed addon object
self.m_addon = kwargs["addon"]
# set database object
self.m_database = Database(addon=self.m_addon)
# setup
self._setup()
# get default category
category, categories = self._set_category(
self.m_addon.params.get("category", None)
)
# media window helper functions
self.media_window = MediaWindow(
hId=self.m_addon.params["handle"],
addon=self.m_addon,
content=["movies", "addoncategories"][categories],
links=self._get_quick_links(category)
)
# fetch list and end directory
self.media_window.end(
succeeded=self._set_list(category),
cacheToDisc=categories
)
# close database
self.m_database.close()
def __init__( self , url_source, item):
# get users preference
self.BASE_CURRENT_URL = url_source
self.ITEM_CURRENT_URL = item
self._get_settings()
# sort methods
sortmethods = ( xbmcplugin.SORT_METHOD_LABEL, xbmcplugin.SORT_METHOD_SIZE, xbmcplugin.SORT_METHOD_DATE,
xbmcplugin.SORT_METHOD_VIDEO_RUNTIME, xbmcplugin.SORT_METHOD_VIDEO_YEAR, xbmcplugin.SORT_METHOD_GENRE,
xbmcplugin.SORT_METHOD_STUDIO, )
# skin buttons
buttons = ( ( 1045, "XBMC.RunPlugin(%s?OpenSettings)" % ( sys.argv[ 0 ], ), None, None, 2, ), )
# helper functions
self.MediaWindow = MediaWindow( int( sys.argv[ 1 ] ),
category=self.PluginCategory,
content="movies",
sortmethods=sortmethods,
fanart=self.settings[ "fanart_image" ], buttons=buttons )
# fetch videos
self.MediaWindow.end( self.get_videos() )
class Main:
Addon = xbmcaddon.Addon( id=__plugin__)
# base paths
BASE_CURRENT_URL = ""
ITEM_CURRENT_URL = ""
BASE_DATA_PATH = os.path.join( xbmc.translatePath( "special://profile/" ), "addon_data", os.path.basename( Addon.getAddonInfo('path') ), "cache" )
BASE_CURRENT_SOURCE_PATH = os.path.join( xbmc.translatePath( "special://profile/" ), "addon_data", os.path.basename( Addon.getAddonInfo('path')), "cache" , "trailer_%s.xml" )
title_option = ""
type_filter = ""
quality_filter = ""
debug_on = False
def __init__( self , url_source, item):
# get users preference
self.BASE_CURRENT_URL = url_source
self.ITEM_CURRENT_URL = item
self._get_settings()
# sort methods
sortmethods = ( xbmcplugin.SORT_METHOD_LABEL, xbmcplugin.SORT_METHOD_SIZE, xbmcplugin.SORT_METHOD_DATE,
xbmcplugin.SORT_METHOD_VIDEO_RUNTIME, xbmcplugin.SORT_METHOD_VIDEO_YEAR, xbmcplugin.SORT_METHOD_GENRE,
xbmcplugin.SORT_METHOD_STUDIO, )
# skin buttons
buttons = ( ( 1045, "XBMC.RunPlugin(%s?OpenSettings)" % ( sys.argv[ 0 ], ), None, None, 2, ), )
# helper functions
self.MediaWindow = MediaWindow( int( sys.argv[ 1 ] ),
category=self.PluginCategory,
content="movies",
sortmethods=sortmethods,
fanart=self.settings[ "fanart_image" ], buttons=buttons )
# fetch videos
self.MediaWindow.end( self.get_videos() )
def _get_settings( self ):
self.settings = {}
self.settings[ "channel_id" ] = "391100379-1"
self.settings[ "product" ] = "Cinema"
self.PluginCategory = ( self.Addon.getLocalizedString( 30800 ), self.Addon.getLocalizedString( 30801 ), self.Addon.getLocalizedString( 30802 ), self.Addon.getLocalizedString( 30803 ), self.Addon.getLocalizedString( 30804 ),self.Addon.getLocalizedString( 30805 ),self.Addon.getLocalizedString( 30806 ),self.Addon.getLocalizedString( 30807 ),self.Addon.getLocalizedString( 30808 ),self.Addon.getLocalizedString( 30809 ), )[ int( self.Addon.getSetting( "quality" ) ) ]
self.Fanart = ( "normal", "normal", "normal", "normal", "normal", "HD", "HD", "HD", "max", )[ int( self.Addon.getSetting( "quality" ) ) ]
self.settings[ "fanart_image" ] = None
self.settings[ "quality" ] = ( "small", "medium", "large", "xlarge", "xxlarge", "HD 480p", "HD 720p", "HD 1080p", "max", )[ int( self.Addon.getSetting( "quality" ) ) ]
self.settings[ "type" ] = ( "flv", "mov", "wmv", "mp4", "3gp", "all", )[ int( self.Addon.getSetting( "type" ) ) ]
self.settings[ "poster" ] = int( self.Addon.getSetting( "poster" ) )
self.settings[ "download_path" ] = self.Addon.getSetting( "download_path" )
self.settings[ "play_mode" ] = int( self.Addon.getSetting( "play_mode" ) )
if ( self.settings[ "play_mode" ] == 2 and self.settings[ "download_path" ] == "" ):
self.settings[ "play_mode" ] = 1
self.settings[ "use_title" ] = ( self.Addon.getSetting( "use_title" ) == "true")
self.settings[ "use_trailer" ] = ( self.settings[ "download_path" ] != "" )
self.settings[ "play_existing" ] = ( self.Addon.getSetting( "play_existing" ) == "true" and self.settings[ "download_path" ] != "" )
self.settings[ "extra" ] = ( self.Addon.getSetting( "extra" ) == "true" )
self.settings[ "originaltitle" ] = ( self.Addon.getSetting( "originaltitle" ) == "true" )
self.settings[ "showtype" ] = ( self.Addon.getSetting( "showtype" ) == "true" )
self.settings[ "max_previews" ] = self.Addon.getSetting( "max_previews" )
if (self.settings[ "type" ] == "all" and self.settings[ "quality" ] == "all"):
self.settings[ "showtype" ] = True
self.settings[ "country" ] = [ int( self.Addon.getSetting( "country" ) ) ]
self.settings[ "region" ] = ( "uk", "fr", "de", "es", "it", "ch", "ch-fr", "nl", "dk", "se", "fi", )[ int( self.Addon.getSetting( "country" ) ) ]
if ( self.Addon.getSetting( "hdplus" ) == "true" ):
self.settings[ "hdplus" ] = "hdplus"
else:
self.settings[ "hdplus" ] = "feed"
self.settings[ "debug" ] = ( self.Addon.getSetting( "debug" ) == "true")
def getKeyboard(self, default = '', heading = '', hidden = False):
kboard = xbmc.Keyboard(default, heading, hidden)
kboard.doModal()
if kboard.isConfirmed():
return urllib.quote_plus(kboard.getText())
return ''
def get_videos( self ):
ok = False
# fetch xml source
xmlSource = self.get_xml_source()
# parse source and add our items
if ( xmlSource ):
ok = self.parse_xml_source( xmlSource )
return ok
def get_xml_source( self ):
try:
ok = True
debug_on = self.settings["debug"]
# set proper source
extension = self.settings[ "region" ]+self.settings[ "product" ]+self.ITEM_CURRENT_URL
base_path = self.BASE_CURRENT_SOURCE_PATH % extension
if debug_on:
print "DEBUG: base_current_url= %s" % self.BASE_CURRENT_URL
if self.ITEM_CURRENT_URL == '99':
curr_phrase = ''
search_phrase = self.getKeyboard(default = curr_phrase, heading = self.Addon.getLocalizedString(30102))
if search_phrase == '':
return -1
curr_phrase = search_phrase
base_url = self.BASE_CURRENT_URL % (self.settings[ "region" ],self.settings[ "hdplus" ],self.settings[ "product" ],self.settings[ "max_previews" ],self.settings[ "channel_id" ],search_phrase)
else:
base_url = self.BASE_CURRENT_URL % (self.settings[ "region" ],self.settings[ "hdplus" ],self.settings[ "product" ],self.settings[ "max_previews" ],self.settings[ "channel_id" ])
# print di url for get lists of video previews
if debug_on:
print "DEBUG: base_url= %s" % base_url
# get the source files date if it exists
try: date = os.path.getmtime( base_path )
except: date = 0
# we only refresh if it's been more than a day, 24hr * 60min * 60sec
if self.ITEM_CURRENT_URL == '99':
refresh = True
else:
refresh = ( ( time.time() - ( 24 * 60 * 60 ) ) >= date )
# only fetch source if it's been more than a day
if debug_on:
print "DEBUG: open %s" % time.asctime ()
if ( refresh or debug_on):
# open url
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
headers = { 'User-Agent' : user_agent }
req = urllib2.Request(base_url, None, headers)
try:
usock = urllib2.urlopen( req , timeout = 60)
except urllib2.HTTPError, e:
print "URLLIB2 HTTPError: code=%s msg=%s header=%s fp.read=%s" % (e.code , e.msg , e.headers , e.fp.read())
# save file versione
# urllib.urlretrieve(base_url,base_path)
# usock = open( base_path, "r" )
else:
class Main:
# base url
BASE_CURRENT_URL = "http://www.apple.com/trailers/home/xml/%s"
# base paths
BASE_CURRENT_SOURCE_PATH = os.path.join( xbmc.translatePath( "special://profile/" ), "plugin_data", "video", os.path.basename( os.getcwd() ) )
def __init__( self ):
# parse argv for any params
params = self._parse_argv()
# get users preference
self._get_settings()
# sort methods
sortmethods = ( xbmcplugin.SORT_METHOD_LABEL, xbmcplugin.SORT_METHOD_SIZE, xbmcplugin.SORT_METHOD_DATE,
xbmcplugin.SORT_METHOD_VIDEO_RUNTIME, xbmcplugin.SORT_METHOD_VIDEO_YEAR, xbmcplugin.SORT_METHOD_GENRE,
xbmcplugin.SORT_METHOD_MPAA_RATING, xbmcplugin.SORT_METHOD_STUDIO, )
# initialize buttons, we only need to set these once
buttons = None
# fetch items
if ( params[ "category" ] is None ):
# skin buttons
buttons = ( 21866,
(
( "Recently Added", "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"recent: Recently Added" ) ), ), None, None, None, ),
( 135, "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"genres" ) ), ), None, None, None, ),
( 20388, "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"studios" ) ), ), None, None, None, ),
( 20348, "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"directors" ) ), ), None, None, None, ),
( 344, "Container.Update(%s?category=%s,replace)" % ( sys.argv[ 0 ], urllib.quote_plus( repr( u"actors" ) ), ), None, None, None, ),
),
)
# set category
else:
self.PluginCategory = params[ "category" ].replace( "genres", xbmc.getLocalizedString( 135 ) ).replace( "studios", xbmc.getLocalizedString( 20388 ) ).replace( "directors", xbmc.getLocalizedString( 20348 ) ).replace( "actors", xbmc.getLocalizedString( 344 ) ).replace( "recent: ", "" )
# helper functions
self.MediaWindow = MediaWindow( int( sys.argv[ 1 ] ), category=self.PluginCategory, content="movies", sortmethods=sortmethods, fanart=( self.settings[ "fanart_image" ], self.Fanart, ), buttons=buttons )
# fetch videos
self.MediaWindow.end( self.fetch_trailers( params[ "category" ] ) )
def _parse_argv( self ):
try:
# parse sys.argv for params and return result
params = dict( urllib.unquote_plus( arg ).split( "=" ) for arg in sys.argv[ 2 ][ 1 : ].split( "&" ) )
# we need to do this as quote_plus and unicode do not work well together
params[ "category" ] = eval( params[ "category" ] )
except:
# no params passed
params = { "category": None }
# return params
return params
def _get_settings( self ):
self.settings = {}
self.PluginCategory = ( xbmc.getLocalizedString( 30800 ), xbmc.getLocalizedString( 30801 ), xbmc.getLocalizedString( 30802 ), xbmc.getLocalizedString( 30803 ), )[ int( xbmcplugin.getSetting( "trailer_quality" ) ) ]
self.Fanart = ( "standard", "480p", "720p", "1080p", )[ int( xbmcplugin.getSetting( "trailer_quality" ) ) ]
self.settings[ "trailer_quality" ] = int( xbmcplugin.getSetting( "trailer_quality" ) )
self.settings[ "trailer_hd_only" ] = ( xbmcplugin.getSetting( "trailer_hd_only" ) == "true" )
##self.settings[ "poster" ] = ( xbmcplugin.getSetting( "poster" ) == "true" )
self.settings[ "rating" ] = int( xbmcplugin.getSetting( "rating" ) )
self.settings[ "not_rated_rating" ] = int( xbmcplugin.getSetting( "not_rated_rating" ) )
self.settings[ "download_path" ] = xbmcplugin.getSetting( "download_path" )
self.settings[ "play_mode" ] = int( xbmcplugin.getSetting( "play_mode" ) )
if ( self.settings[ "play_mode" ] == 2 and self.settings[ "download_path" ] == "" ):
self.settings[ "play_mode" ] = 1
self.settings[ "use_title" ] = ( xbmcplugin.getSetting( "use_title" ) == "true" and self.settings[ "play_mode" ] == 2 )
self.settings[ "use_trailer" ] = ( xbmcplugin.getSetting( "use_trailer" ) == "true" and self.settings[ "play_mode" ] == 2 )
self.settings[ "create_nfo" ] = ( xbmcplugin.getSetting( "create_nfo" ) == "true" )
self.settings[ "play_existing" ] = ( xbmcplugin.getSetting( "play_existing" ) == "true" and self.settings[ "download_path" ] != "" )
self.settings[ "fanart_image" ] = xbmcplugin.getSetting( "fanart_image" )
def fetch_trailers( self, category=None ):
# spam log file
LOG( ">>> fetch_trailers(category: %s, rating: %s, quality: %s)" % ( repr( category ), ( "G", "PG", "PG-13", "R", "NC-17", "No Limit", )[ self.settings[ "rating" ] ], self.Fanart, ), heading=True )
ok = False
# initialize trailers list
trailers = []
# fetch source
xmlSource = self._get_xml_source()
# parse source and add our items
if ( xmlSource ):
ok = self._parse_xml_source( xmlSource, category )
# spam log file
LOG( "<<< fetch_trailers()", heading=True )
# return result
return ok
def _get_xml_source( self ):
try:
xmlSource = []
# grab all xml sources
for source in ( "current.xml", "current_480p.xml", "current_720p.xml", ):
# set path and url
base_path = os.path.join( self.BASE_CURRENT_SOURCE_PATH, source )
base_url = self.BASE_CURRENT_URL % ( source, )
# get the source files date if it exists
try: date = os.path.getmtime( base_path )
except: date = 0
# we only refresh if it's been more than a day, 24hr * 60min * 60sec
refresh = ( ( time.time() - ( 24 * 60 * 60 ) ) >= date )
# only fetch source if it's been more than a day
if ( refresh ):
# open url
usock = urllib.urlopen( base_url )
else:
# open path
usock = open( base_path, "r" )
# read source
xmlSource += [ usock.read() ]
# close socket
usock.close()
# save the xmlSource for future parsing
if ( refresh ):
ok = self._save_xml_source( xmlSource[ -1 ], base_path )
# return source
return xmlSource
except Exception, e:
# oops, notify user what error occurred
LOG( str( e ), xbmc.LOGERROR )
# error so return empty string
return []
class Trailers(object):
"""Trailers Class: List trailers and categories
"""
def __init__(self, *args, **kwargs):
# set our passed addon object
self.m_addon = kwargs["addon"]
# set database object
self.m_database = Database(addon=self.m_addon)
# setup
self._setup()
# get default category
category, categories = self._set_category(
self.m_addon.params.get("category", None)
)
# media window helper functions
self.media_window = MediaWindow(
hId=self.m_addon.params["handle"],
addon=self.m_addon,
content=["movies", "addoncategories"][categories],
links=self._get_quick_links(category)
)
# fetch list and end directory
self.media_window.end(
succeeded=self._set_list(category),
cacheToDisc=categories
)
# close database
self.m_database.close()
def _setup(self):
# categories
self.root_category_list = [
u"recent: ",
u"studio",
u"director",
u"writer",
u"actor",
u"genre",
u"showtimes: ",
u"hd: ",
u"intheaters: ",
u"comingsoon: ",
u"downloaded: ",
u"downloadedrecently: ",
u"rootlist"
]
def _set_category(self, category):
search = u""
if (self.m_addon.params.has_key("search")):
search = u" - ({search})".format(
search=self.m_addon.params["search"]
)
# if no category, get default
if (category is None):
# set default category
category = self.root_category_list[
self.m_addon.getSetting("startup.category")
]
# set default subcategory
if (self.m_addon.getSetting("startup.category") in [1, 2, 3, 4, 5] and
self.m_addon.getSetting("startup.category.text")):
category = u"{category}: {subcategory}".format(
category=category,
subcategory=self.m_addon.getSetting("startup.category.text")
)
# localize search category
self.m_addon.setSetting(
id="plugin.category",
value=category.replace(
u"search", self.m_addon.getLocalizedString(30730)
) + search
)
# iterate thru and localize category
for idx, cat in enumerate(self.root_category_list):
self.m_addon.setSetting(
id="plugin.category",
value=self.m_addon.getSetting("plugin.category").replace(
cat, self.m_addon.getLocalizedString(30111 + idx)
)
)
return (
category,
category in
[u"studio", u"director", u"writer", u"actor", u"genre", u"rootlist"]
)
def _get_quick_links(self, category):
# set search quick link
if (self.m_addon.getSetting("search.current.list")):
search = u"XBMC.RunScript({addon},search={search}&category={category})".format(
addon=self.m_addon.getAddonInfo("Id"),
search=quote_plus(repr(self.m_addon.params.get("search", u""))),
category=quote_plus(repr(category))
)
else:
search = u"XBMC.RunScript({addon},search={search}&category=u'')".format(
addon=self.m_addon.getAddonInfo("Id"),
search=quote_plus(repr(self.m_addon.params.get("search", u"")))
)
# set universal links
links = [
self.m_addon.getLocalizedString(30502),
[],
search,
u"XBMC.RunScript({addon},task='configure')".format(
addon=self.m_addon.getAddonInfo("Id")
)
]
# loop thru and add preferred button
for id_ in range(1, 6):
# get quick link category
category = int(self.m_addon.getSetting(u"quick.link{id}".format(id=id_)))
# if not disabled add quick link
if (category > 0):
links[1] += [[
self.m_addon.getLocalizedString(30110 + category),
"Container.Update({url}?category={category},replace)".format(
url=self.m_addon.params["path"],
category=quote_plus(repr(self.root_category_list[category - 1]))
),
None,
None
]]
return links
def _set_list(self, category):
# update source if necessary FIXME: is this where we want this
self._update_source()
# root list
if (category == u"rootlist"):
ok = self._get_root_list()
# scraper dependent lists
else:
# categories
if (category in
[u"studio", u"director", u"writer", u"actor", u"genre"]):
ok = self._get_categories(category)
# trailer listing
else:
ok = self._get_movies(category)
return ok
def _update_source(self):
# check if scraper exists and source date
record = self.m_database.scraper(self.m_addon.getSetting("trailer.scraper"))
# update source if no scraper info or if user preference to update on first run
if ((record is not None and
self.m_addon.getSetting("source.schedule.when") == 0 and
self.m_addon.getSetting("source.last.checked") < today(format_="%Y-%m-%d") and
get_refresh(date=record[1], expires=record[2]))
or record is None
):
print "UPDATING SOURCE................................................................"
# set new refresh date
self.m_addon.setSetting(
"source.last.checked",
today(format_="%Y-%m-%d")
)
# import preferred scraper and fetch new trailers
exec "from resources.scrapers.trailers import {scraper} as scraper".format(
scraper=self.m_addon.getSetting("trailer.scraper").replace(" - ", "_").replace(" ", "_").lower()
)
# update source
scraper.Scraper(self.m_addon, self.m_database).update()
def _get_root_list(self):
# set thumbs
thumbs = [
"DefaultRecentlyAddedMovies.png",
"DefaultFolder.png",
"DefaultFolder.png",
"DefaultFolder.png",
"DefaultFolder.png",
"DefaultMusicArtists.png",
"DefaultFolder.png",
"DefaultMovies.png",
"DefaultMovies.png",
"DefaultMovies.png",
"DefaultMovies.png",
"DefaultRecentlyAddedMovies.png"
]
# initialize out list
categories = []
# iterate thru and create our category list, skipping rootlist
for idx, cat in enumerate(self.root_category_list[:-1]):
# only include category if enabled and trailers exist for category
if (self.m_addon.getSetting("category{idx}".format(idx=idx + 1,)) == True and self.m_database.check_category(cat) is not None):
categories += [[self.m_addon.getLocalizedString(30111 + idx), thumbs[idx], None, quote_plus(repr(self.root_category_list[idx]))]]
# add categories to our media list
return self.add_categories(categories)
def _get_categories(self, category):
# fetch records
records = self.m_database.get_categories(category)
# initialize out list
categories = []
# iterate thru and create our category list
for record in records:
categories += [[record[1], u"Default{category}.png".format(category=category.title()), None, quote_plus(repr(u"{category}: {subcategory}".format(category=category, subcategory=record[1])))]]
# add categories to our media list
return self.add_categories(categories)
def add_categories(self, records):
# get our media item
dirItem = DirectoryItem()
# set as folder since these our virtual folders to filtered lists
dirItem.isFolder = True
# FIXME: queue and now playing menu items
# universal context menu items for categories
# #dirItem.addContextMenuItem( xbmc.getLocalizedString( 13347 ), "XBMC.Action(Queue)" )
# #dirItem.addContextMenuItem( xbmc.getLocalizedString( 13350 ), "XBMC.ActivateWindow(10028)" )
dirItem.addContextMenuItem(xbmc.getLocalizedString(24020), "XBMC.RunScript({addon},task='configure')".format(addon=self.m_addon.getAddonInfo("Id")))
dirItem.addContextMenuItem(xbmc.getLocalizedString(137), u"XBMC.RunScript({addon},search={search}&category=u'')".format(addon=self.m_addon.getAddonInfo("Id"), search=quote_plus(repr(self.m_addon.params.get("search", u"")))))
# initialize our categories list
categories = []
# enumerate thru and set category
for title, icon, thumb, category in records:
# check for cached thumb FIXME: only actors (not enabled)
if (thumb is None or not os.path.isfile(thumb)):
thumb = icon
# set the URL
dirItem.url = u"{url}?category={category}".format(url=self.m_addon.params["path"], category=category)
# create our listitem
dirItem.listitem = xbmcgui.ListItem(title, iconImage=icon, thumbnailImage=thumb)
# add context menu items to listitem with replaceItems = True so only ours show
dirItem.listitem.addContextMenuItems(dirItem.context, replaceItems=True)
# add category to our category list
categories += [(dirItem.url, dirItem.listitem, dirItem.isFolder,)]
# add categories to our media list
return self.media_window.addItems(categories)
def _get_movies(self, category):
# showtimes list
if (category.startswith("showtimes:")):
print "FETCH showtimes and set list"
####################
from resources.scrapers.showtimes.googleapi import Scraper
movies = Scraper.fetch_movies()
return True
else:
# add movies to our media list
return self.add_movies(self.m_database.get_movies(category, self.m_addon.params.get("search", None)), category)
def add_movies(self, records, category):
# get our media item
dirItem = DirectoryItem()
# FIXME: queue and now playing menu items
# universal context menu items for trailer lists
# #dirItem.addContextMenuItem( xbmc.getLocalizedString( 13347 ), "XBMC.Action(Queue)" )
dirItem.addContextMenuItem(self.m_addon.getLocalizedString(30903), u"XBMC.Action(Info)")
# #dirItem.addContextMenuItem( xbmc.getLocalizedString( 13350 ), "XBMC.ActivateWindow(10028)" )
dirItem.addContextMenuItem(xbmc.getLocalizedString(24020), u"XBMC.RunScript({addon},task='configure')".format(addon=self.m_addon.getAddonInfo("Id")))
#print ["PSPSPSPSPSPSPSPS", self.m_addon.params]
dirItem.addContextMenuItem(xbmc.getLocalizedString(137), u"XBMC.RunScript({addon},search={search}&category={category})".format(addon=self.m_addon.getAddonInfo("Id"), search=quote_plus(repr(self.m_addon.params.get("search", u""))), category=quote_plus(repr([u"", category][self.m_addon.getSetting("search.current.list")]))))
# initialize our movies list
movies = []
# video and audio stream details used by some skins to display flagging
stream_details = {
"video": {
"Standard": {"codec": "h264", "aspect": 1.78, "width": 720, "height": 480},
"480p": {"codec": "h264", "aspect": 1.78, "width": 720, "height": 480},
"720p": {"codec": "h264", "aspect": 1.78, "width": 1280, "height": 720},
"1080p": {"codec": "h264", "aspect": 1.78, "width": 1920, "height": 1080}
},
"audio": {
"Standard": {"codec": "aac", "language": "en", "channels": 2},
"480p": {"codec": "aac", "language": "en", "channels": 2},
"720p": {"codec": "aac", "language": "en", "channels": 2},
"1080p": {"codec": "aac", "language": "en", "channels": 2}
}
}
# iterate thru and set trailer
for movie in records:
# set downloaded based on all trailers available
downloaded = (
sum([
tlr in movie[27] for tlr in movie[25].split(",")
if (movie[27] is not None)
]) == len(movie[25].split(","))
)
# set playcount based on all trailers available
playcount = int(
sum([
tlr in movie[26] for tlr in movie[25].split(",")
if (movie[26] is not None)
]) == len(movie[25].split(","))
)
# set URL and play parameter
dirItem.url = u"{url}?play={id}".format(
url=self.m_addon.params["path"],
id=movie[0]
)
# Play Trailer
context = [(
self.m_addon.getLocalizedString(30902),
u"XBMC.RunPlugin({url})".format(url=dirItem.url),
)]
# Download & Play
if (self.m_addon.getSetting("trailer.play.mode") == 0 and
sum([tlr in movie[27] for tlr in movie[25].split(",")
if (movie[27] is not None)]) < len(movie[24].split(","))):
context += [(
self.m_addon.getLocalizedString(30901),
u"XBMC.RunPlugin({url}&download=True)".format(
url=dirItem.url
),
)]
# Check Showtimes
context += [(
self.m_addon.getLocalizedString(30900),
u"XBMC.RunScript({id},showtimes={title})".format(
id=self.m_addon.getAddonInfo("Id"),
title=quote_plus(repr(movie[1].split(" | ")[0])),
)
)]
# overlay
overlay = [
xbmcgui.ICON_OVERLAY_UNWATCHED,
xbmcgui.ICON_OVERLAY_WATCHED
][playcount]
# tagline
tagline = [
"",
"In Theaters {date}".format(
date=format_date(movie[4])
)
][movie[4] != ""]
# year
year = int(movie[4][: 4] or 0)
# format duration, sum of all available trailers
# #duration = "{0:1.0f}:{1:02.0f}".format(*divmod(movie[23], 60))#movie[15]
# set proper date for sorting, we use downloaded date for downloaded lists
# and release date for in theaters and coming soon lists
if (category.startswith("downloaded")):
date = movie[21].split(" ")[0]
elif (category.startswith("intheaters:") or category.startswith("comingsoon:")):
date = movie[4]
else:
date = movie[16]
# set our listitem
dirItem.listitem = xbmcgui.ListItem(
movie[1].split(" | ")[-1],
iconImage="DefaultVideo.png",
thumbnailImage="{url}|User-Agent={ua}".format(
url=movie[11],
ua=quote_plus(movie[30])
)
)
# set info
dirItem.listitem.setInfo("video", {
"Count": movie[0],
"PlayCount": playcount,
"SortTitle": movie[1].split(" | ")[0],
"Title": u"{downloaded}{title}{trailers}".format(
downloaded=[u"", u"* "][downloaded],
title=movie[1].split(" | ")[-1],
trailers=["", " - ({trailers})".format(
trailers=len(movie[24].split(","))
)
][len(movie[24].split(",")) > 1]
),
"MPAA": movie[2],
"Studio": movie[3],
"Date": "{day}-{month}-{year}".format(
day=date[8 :],
month=date[5 : 7],
year=date[: 4]
),
"Year": year,
"Director": movie[6],
"Writer": movie[7],
"Plot": movie[8] or "No plot available",
"Cast": movie[9].split(" / "),
"Genre": movie[10],
"TagLine": tagline,
"Size": movie[17],
"lastplayed": movie[20] or "",
"Overlay": overlay
})
# set stream details
stream_details["video"][movie[14]]["duration"] = movie[23]
dirItem.listitem.addStreamInfo("video", stream_details["video"][movie[14]])
dirItem.listitem.addStreamInfo("audio", stream_details["audio"][movie[14]])
# set additional properties
dirItem.listitem.setProperty("ReleaseDate", format_date(movie[4]))
dirItem.listitem.setProperty("Copyright", movie[5])
dirItem.listitem.setProperty("AvailableTrailers", movie[24].replace(",", " / "))
###############################################
# dirItem.listitem.setProperty("fanart_image", self.m_addon.getSetting("fanart")[0])
###############################################
# dirItem.listitem.setProperty("Poster", movie[11])
# used for video info dialog to search on trailers not database
# dirItem.listitem.setProperty("Addon.Actor", movie[9].split(" / ")[0])
# dirItem.listitem.setProperty("Addon.OnClick", "XBMC.RunScript(%s,search=%s)" % (self.m_addon.getAddonInfo("Id"), quote_plus(movie[9].split(" / ")[0].encode("UTF-8")),))
# add context menu items to listitem with replaceItems = True so only ours show
dirItem.listitem.addContextMenuItems(dirItem.context + context, replaceItems=True)
# add the movie to our movie list
movies += [(dirItem.url, dirItem.listitem, dirItem.isFolder,)]
# add movies to our media list
return self.media_window.addItems(movies)
