def _get_episode_url(self, show_url, video):
params = urlparse.parse_qs(show_url)
cmd = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"tvshowid": %s, "season": %s, "filter": {"field": "%s", "operator": "is", "value": "%s"}, \
"limits": { "start" : 0, "end": 25 }, "properties" : ["title", "season", "episode", "file", "streamdetails"], "sort": { "order": "ascending", "method": "label", "ignorearticle": true }}, "id": "libTvShows"}'
base_url = 'video_type=%s&id=%s'
episodes = []
force_title = self._force_title(video)
if not force_title:
run = cmd % (params['id'][0], video.season, 'episode', video.episode)
meta = xbmc.executeJSONRPC(run)
meta = json.loads(meta)
log_utils.log('Episode Meta: %s' % (meta), log_utils.LOGDEBUG)
if 'result' in meta and 'episodes' in meta['result']:
episodes = meta['result']['episodes']
else:
log_utils.log('Skipping S&E matching as title search is forced on: %s' % (video.trakt_id), log_utils.LOGDEBUG)
if (force_title or kodi.get_setting('title-fallback') == 'true') and video.ep_title and not episodes:
run = cmd % (params['id'][0], video.season, 'title', video.ep_title)
meta = xbmc.executeJSONRPC(run)
meta = json.loads(meta)
log_utils.log('Episode Title Meta: %s' % (meta), log_utils.LOGDEBUG)
if 'result' in meta and 'episodes' in meta['result']:
episodes = meta['result']['episodes']
for episode in episodes:
if episode['file'].endswith('.strm'):
continue
return base_url % (video.video_type, episode['episodeid'])
def FullScreenXBMC():
#Logutil.log("Toggle to Full Screen mode", util.LOG_LEVEL_INFO)
#this brings xbmc back
try:
xbmc.executehttpapi("Action(199)")
except:
xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Input.ExecuteAction","params":{"action":"togglefullscreen"},"id":"1"}')
def _finalize_download( self, tmp_path ):
try:
if ( tmp_path != self.filepath ):
# copy the trailer
msg1 = self.Addon.getLocalizedString( 30503 ) % ( os.path.split( self.filepath )[ 1 ], )
msg2 = self.Addon.getLocalizedString( 30502 ) % ( os.path.split( self.filepath )[ 0 ], )
pDialog.update( -1, msg1, msg2 )
# necessary for dialog to update
xbmc.sleep( 50 )
# use JSON RPC for file copying
xbmc.executeJSONRPC( "FileCopy(%s,%s)" % ( tmp_path, self.filepath.encode( "utf-8" ), ) )
# remove temporary cache file
os.remove( tmp_path )
# create conf file for better MPlayer playback only when trailer saved on xbox and not progressive
if ( not self.filepath.startswith( "smb://" ) and not self.args.trailer_url.endswith( "p.mov" ) and not os.path.isfile( self.filepath + ".conf" ) and os.environ.get( "OS", "xbox" ) == "xbox" ):
f = open( self.filepath + ".conf" , "w" )
f.write( "nocache=1" )
f.close()
# copy the thumbnail
thumbpath = os.path.splitext( self.filepath )[ 0 ] + ".tbn"
msg1 = self.Addon.getLocalizedString( 30503 ) % ( os.path.split( thumbpath )[ 1 ], )
pDialog.update( -1, msg1, msg2 )
# necessary for dialog to update
xbmc.sleep( 50 )
xbmc.executeJSONRPC( "FileCopy(%s,%s)" % ( g_thumbnail, thumbpath.encode( "utf-8" ), ) )
# we succeeded
return True
except:
print "ERROR: %s::%s (%d) - %s" % ( self.__class__.__name__, sys.exc_info()[ 2 ].tb_frame.f_code.co_name, sys.exc_info()[ 2 ].tb_lineno, sys.exc_info()[ 1 ], )
return False
def JumpToLetter(letter):
if not xbmc.getInfoLabel("ListItem.Sortletter")[0] == letter:
xbmc.executebuiltin("SetFocus(50)")
if letter in ["A", "B", "C", "2"]:
jumpsms_id = "2"
elif letter in ["D", "E", "F", "3"]:
jumpsms_id = "3"
elif letter in ["G", "H", "I", "4"]:
jumpsms_id = "4"
elif letter in ["J", "K", "L", "5"]:
jumpsms_id = "5"
elif letter in ["M", "N", "O", "6"]:
jumpsms_id = "6"
elif letter in ["P", "Q", "R", "S", "7"]:
jumpsms_id = "7"
elif letter in ["T", "U", "V", "8"]:
jumpsms_id = "8"
elif letter in ["W", "X", "Y", "Z", "9"]:
jumpsms_id = "9"
else:
jumpsms_id = None
if jumpsms_id:
for i in range(1, 5):
# xbmc.executebuiltin("jumpsms" + jumpsms_id)
xbmc.executeJSONRPC('{ "jsonrpc": "2.0", "method": "Input.ExecuteAction", "params": { "action": "jumpsms%s" }, "id": 1 }' % (jumpsms_id))
# prettyprint(response)
xbmc.sleep(15)
if xbmc.getInfoLabel("ListItem.Sortletter")[0] == letter:
break
xbmc.executebuiltin("SetFocus(24000)")
def updateVideoRefreshRate(self, themePlayList):
# Check if the setting is enabled to switch the refresh rate
if not Settings.blockRefreshRateChange():
self.original_refreshrate = 0
return
log("ThemePlayer: Checking for update of refresh rate")
try:
# Check if we have any videos in the PlayList
hasVideoFiles = True
i = 0
while i < themePlayList.size():
if Settings.isVideoFile(themePlayList[i].getfilename()):
hasVideoFiles = True
break
i = i + 1
if hasVideoFiles:
# Save off the existing refresh setting
jsonresponse = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "Settings.GetSettingValue", "params": { "setting": "videoplayer.adjustrefreshrate" }, "id": 1}')
data = simplejson.loads(jsonresponse)
if 'result' in data:
if 'value' in data['result']:
self.original_refreshrate = data['result']['value']
# Check if the refresh rate is currently set
log("ThemePlayer: Video refresh rate currently set to %d" % self.original_refreshrate)
# Check if the refresh rate is currently set, if it is, then we need
if self.original_refreshrate != 0:
# Disable the refresh rate setting
log("ThemePlayer: Disabling refresh rate")
xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "Settings.SetSettingValue", "params": { "setting": "videoplayer.adjustrefreshrate", "value": 0 }, "id": 1}')
except:
log("ThemePlayer: Failed to process video refresh")
def AddArtToLibrary(type, media, folder, limit, silent=False):
json_query = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.Get%ss", "params": {"properties": ["art", "file"], "sort": { "method": "label" } }, "id": 1}' % media.lower())
json_query = unicode(json_query, 'utf-8', errors='ignore')
json_response = simplejson.loads(json_query)
if (json_response['result'] is not None) and ('%ss' % (media.lower()) in json_response['result']):
# iterate through the results
if not silent:
progressDialog = xbmcgui.DialogProgress(ADDON_LANGUAGE(32016))
progressDialog.create(ADDON_LANGUAGE(32016))
for count, item in enumerate(json_response['result']['%ss' % media.lower()]):
if not silent:
if progressDialog.iscanceled():
return
path = os.path.join(media_path(item['file']).encode("utf-8"), folder)
file_list = xbmcvfs.listdir(path)[1]
for i, file in enumerate(file_list):
if i + 1 > limit:
break
if not silent:
progressDialog.update((count * 100) / json_response['result']['limits']['total'], ADDON_LANGUAGE(32011) + ' %s: %s %i' % (item["label"], type, i + 1))
if progressDialog.iscanceled():
return
# just in case someone uses backslahes in the path
# fixes problems mentioned on some german forum
file_path = os.path.join(path, file).encode('string-escape')
if xbmcvfs.exists(file_path) and item['art'].get('%s%i' % (type, i), '') == "":
xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.Set%sDetails", "params": { "%sid": %i, "art": { "%s%i": "%s" }}, "id": 1 }' %
(media, media.lower(), item.get('%sid' % media.lower()), type, i + 1, file_path))
def getSeasonCast():
import json
dbid = xbmc.getInfoLabel('%sListItem.DBID' % getPrefix())
if dbid < 0:
return []
query = xbmc.executeJSONRPC('{ "jsonrpc": "2.0", "method": "VideoLibrary.GetSeasonDetails", "params": {"seasonid": %s, "properties": ["tvshowid"]}, "id": 1 }' % dbid)
query = unicode(query, 'utf-8', errors='ignore')
j = json.loads(query)
if 'result' not in j: #usually caused by the 'All Seasons' item
dbid = str(int(dbid) + 2) #this seems to give Season 1 which will suffice
query = xbmc.executeJSONRPC('{ "jsonrpc": "2.0", "method": "VideoLibrary.GetSeasonDetails", "params": {"seasonid": %s, "properties": ["tvshowid"]}, "id": 1 }' % dbid)
query = unicode(query, 'utf-8', errors='ignore')
j = json.loads(query)
if 'result' not in j:
return []
seasonID = j['result']['seasondetails']['seasonid']
tvshowID = j['result']['seasondetails']['tvshowid']
return getTVShowCast(tvshowID)
def get_tv_files(called_from_tv_menu, progress, done):
result = eval(xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "id": 1}'))
if 'tvshows' not in result['result']:
return []
tv_shows = result['result']['tvshows']
files = []
for tv_show in tv_shows:
show_id = tv_show['tvshowid']
show_name = clean_path(tv_show['label'])
log("%s" % show_name, xbmc.LOGINFO)
displaystring = __language__(30209) + show_name
log("%s" % displaystring, xbmc.LOGINFO)
progress.update(done, displaystring.encode('utf-8'))
episode_result = eval(xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"tvshowid": %d, "properties": ["file"]}, "id": 1}' % show_id))
try:
episodes = episode_result['result']['episodes']
files.extend([ clean_path(e['file']) for e in episodes ])
except KeyError:
if called_from_tv_menu and __scriptdebug__:
displaystring = __language__(30209) + show_name
xbmcgui.Dialog().ok(__language__(30203), displaystring.encode('utf-8'), __language__(30204))
return files
def getPlaylistLengthFromXBMCPlayer(playerid):
if playerid == -1:
return 1 #Default player (-1) can't be checked properly
if playerid < 0 or playerid > 2:
Debug("[Util] getPlaylistLengthFromXBMCPlayer, invalid playerid: "+str(playerid))
return 0
rpccmd = json.dumps({'jsonrpc': '2.0', 'method': 'Player.GetProperties','params':{'playerid': playerid, 'properties':['playlistid']}, 'id': 1})
result = xbmc.executeJSONRPC(rpccmd)
result = json.loads(result)
# check for error
try:
error = result['error']
Debug("[Util] getPlaylistLengthFromXBMCPlayer, Player.GetProperties: " + str(error))
return 0
except KeyError:
pass # no error
playlistid = result['result']['playlistid']
rpccmd = json.dumps({'jsonrpc': '2.0', 'method': 'Playlist.GetProperties','params':{'playlistid': playlistid, 'properties': ['size']}, 'id': 1})
result = xbmc.executeJSONRPC(rpccmd)
result = json.loads(result)
# check for error
try:
error = result['error']
Debug("[Util] getPlaylistLengthFromXBMCPlayer, Playlist.GetProperties: " + str(error))
return 0
except KeyError:
pass # no error
return result['result']['size']
def getNowPlaying(self):
# Get the active player
result = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "id": 1, "method": "Player.GetActivePlayers"}')
result = unicode(result, 'utf-8', errors='ignore')
self.logMsg("Got active player " + result, 2)
result = json.loads(result)
# Seems to work too fast loop whilst waiting for it to become active
while not result["result"]:
result = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "id": 1, "method": "Player.GetActivePlayers"}')
result = unicode(result, 'utf-8', errors='ignore')
self.logMsg("Got active player " + result, 2)
result = json.loads(result)
if 'result' in result and result["result"][0] is not None:
playerid = result["result"][0]["playerid"]
# Get details of the playing media
self.logMsg("Getting details of now playing media", 1)
result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "id": 1, "method": "Player.GetItem", "params": {"playerid": ' + str(
playerid) + ', "properties": ["showtitle", "tvshowid", "episode", "season", "playcount","genre"] } }')
result = unicode(result, 'utf-8', errors='ignore')
self.logMsg("Got details of now playing media" + result, 2)
result = json.loads(result)
return result
def __init__(self):
self._parse_argv()
# check how we were executed
if self.MOVIEID:
xbmc.executeJSONRPC('{ "jsonrpc": "2.0", "method": "Player.Open", "params": { "item": { "movieid": %d }, "options":{ "resume": %s } }, "id": 1 }' % (int(self.MOVIEID), self.RESUME))
elif self.EPISODEID:
xbmc.executeJSONRPC('{ "jsonrpc": "2.0", "method": "Player.Open", "params": { "item": { "episodeid": %d }, "options":{ "resume": %s } }, "id": 1 }' % (int(self.EPISODEID), self.RESUME))
elif self.MUSICVIDEOID:
xbmc.executeJSONRPC('{ "jsonrpc": "2.0", "method": "Player.Open", "params": { "item": { "musicvideoid": %d } }, "id": 1 }' % int(self.MUSICVIDEOID))
elif self.ALBUMID:
xbmc.executeJSONRPC('{ "jsonrpc": "2.0", "method": "Player.Open", "params": { "item": { "albumid": %d } }, "id": 1 }' % int(self.ALBUMID))
elif self.SONGID:
xbmc.executeJSONRPC('{ "jsonrpc": "2.0", "method": "Player.Open", "params": { "item": { "songid": %d } }, "id": 1 }' % int(self.SONGID))
else:
self._init_vars()
self._init_property()
# clear our property, if another instance is already running it should stop now
self.WINDOW.clearProperty('SkinWidgets_Running')
a_total = datetime.datetime.now()
self._fetch_info_randomitems()
self._fetch_info_recommended()
self._fetch_info_recentitems()
b_total = datetime.datetime.now()
c_total = b_total - a_total
log('Total time needed for all queries: %s' % c_total)
# give a possible other instance some time to notice the empty property
self.WINDOW.setProperty('SkinWidgets_Running', 'true')
self._daemon()
def _fetch_song(self, request):
if not xbmc.abortRequested:
json_string = '{"jsonrpc": "2.0", "id": 1, "method": "AudioLibrary.GetSongs", "params": {"properties": ["title", "playcount", "artist", "album", "year", "file", "thumbnail", "fanart", "rating"], "filter": {"field": "playcount", "operator": "lessthan", "value": "1"}, "limits": {"end": %d},' %self.LIMIT
if request == 'RandomSong' and self.RANDOMITEMS_UNPLAYED == "True":
json_query = xbmc.executeJSONRPC('%s "sort": {"method": "random"}}}' %json_string)
else:
json_query = xbmc.executeJSONRPC('%s "sort": {"method": "random"}}}' %json_string)
json_query = unicode(json_query, 'utf-8', errors='ignore')
json_query = simplejson.loads(json_query)
if json_query.has_key('result') and json_query['result'].has_key('songs'):
self._clear_properties(request)
count = 0
for item in json_query['result']['songs']:
count += 1
play = 'XBMC.RunScript(' + __addonid__ + ',songid=' + str(item.get('songid')) + ')'
path = media_path(item['file'])
self.WINDOW.setProperty("%s.%d.Title" % (request, count), item['title'])
self.WINDOW.setProperty("%s.%d.Artist" % (request, count), " / ".join(item['artist']))
self.WINDOW.setProperty("%s.%d.Year" % (request, count), str(item['year']))
self.WINDOW.setProperty("%s.%d.Rating" % (request, count), str(int(item['rating'])-48))
self.WINDOW.setProperty("%s.%d.Album" % (request, count), item['album'])
self.WINDOW.setProperty("%s.%d.Thumb" % (request, count), item['thumbnail']) #remove
self.WINDOW.setProperty("%s.%d.Fanart" % (request, count), item['fanart']) #remove
self.WINDOW.setProperty("%s.%d.Art(thumb)" % (request, count), item['thumbnail'])
self.WINDOW.setProperty("%s.%d.Art(fanart)" % (request, count), item['fanart'])
self.WINDOW.setProperty("%s.%d.File" % (request, count), item['file'])
self.WINDOW.setProperty("%s.%d.Path" % (request, count), path)
self.WINDOW.setProperty("%s.%d.Play" % (request, count), play)
del json_query
def getNextUpEpisodes(tagname,limit):
count=0
addonSettings = xbmcaddon.Addon(id='plugin.video.emby')
#if the addon is called with nextup parameter, we return the nextepisodes list of the given tagname
xbmcplugin.setContent(int(sys.argv[1]), 'episodes')
# First we get a list of all the in-progress TV shows - filtered by tag
json_query_string = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": { "sort": { "order": "descending", "method": "lastplayed" }, "filter": {"and": [{"operator":"true", "field":"inprogress", "value":""}, {"operator": "contains", "field": "tag", "value": "%s"}]}, "properties": [ "title", "studio", "mpaa", "file", "art" ] }, "id": "libTvShows"}' %tagname)
json_result = json.loads(json_query_string)
# If we found any, find the oldest unwatched show for each one.
if json_result.has_key('result') and json_result['result'].has_key('tvshows'):
for item in json_result['result']['tvshows']:
# If Ignore Specials is true only choose episodes from seasons greater than 0.
if addonSettings.getSetting("ignoreSpecialsNextEpisodes")=="true":
json_query2 = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": { "tvshowid": %d, "sort": {"method":"episode"}, "filter": {"and": [ {"field": "playcount", "operator": "lessthan", "value":"1"}, {"field": "season", "operator": "greaterthan", "value": "0"} ]}, "properties": [ "title", "playcount", "season", "episode", "showtitle", "plot", "file", "rating", "resume", "tvshowid", "art", "streamdetails", "firstaired", "runtime", "writer", "dateadded", "lastplayed" ], "limits":{"end":1}}, "id": "1"}' %item['tvshowid'])
else:
json_query2 = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": { "tvshowid": %d, "sort": {"method":"episode"}, "filter": {"field": "playcount", "operator": "lessthan", "value":"1"}, "properties": [ "title", "playcount", "season", "episode", "showtitle", "plot", "file", "rating", "resume", "tvshowid", "art", "streamdetails", "firstaired", "runtime", "writer", "dateadded", "lastplayed" ], "limits":{"end":1}}, "id": "1"}' %item['tvshowid'])
if json_query2:
json_query2 = json.loads(json_query2)
if json_query2.has_key('result') and json_query2['result'].has_key('episodes'):
for item in json_query2['result']['episodes']:
liz = createListItem(item)
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=item['file'], listitem=liz)
count +=1
if count == limit:
break
xbmcplugin.endOfDirectory(handle=int(sys.argv[1]))
def getRecentEpisodes(tagname,limit):
#if the addon is called with recentepisodes parameter, we return the recentepisodes list of the given tagname
xbmcplugin.setContent(int(sys.argv[1]), 'episodes')
# First we get a list of all the TV shows - filtered by tag
json_query_string = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": { "sort": { "order": "descending", "method": "dateadded" }, "properties": [ "title","sorttitle" ], "filter": {"operator": "contains", "field": "tag", "value": "%s"} }, "id": "libTvShows"}' %tagname)
json_result = json.loads(json_query_string)
# If we found any, put all tv show id's in a list
if json_result.has_key('result') and json_result['result'].has_key('tvshows'):
alltvshowIds = list()
for tvshow in json_result['result']['tvshows']:
alltvshowIds.append(tvshow["tvshowid"])
alltvshowIds = set(alltvshowIds)
#get all recently added episodes
json_query2 = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": { "sort": {"order": "descending", "method": "dateadded"}, "filter": {"field": "playcount", "operator": "lessthan", "value":"1"}, "properties": [ "title", "playcount", "season", "episode", "showtitle", "plot", "file", "rating", "resume", "tvshowid", "art", "streamdetails", "firstaired", "runtime", "cast", "writer", "dateadded", "lastplayed" ]}, "limits":{"end":%d}, "id": "1"}' %limit)
count = 0
if json_query2:
json_query2 = json.loads(json_query2)
if json_query2.has_key('result') and json_query2['result'].has_key('episodes'):
for item in json_query2['result']['episodes']:
if item["tvshowid"] in alltvshowIds:
liz = createListItem(item)
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=item['file'], listitem=liz)
count += 1
if count == limit:
break
xbmcplugin.endOfDirectory(handle=int(sys.argv[1]))
def build_music_playlist():
log( "Building Music Playlist", xbmc.LOGNOTICE )
xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "AudioPlaylist.Clear", "id": 1}')
music_playlist = xbmc.PlayList( xbmc.PLAYLIST_MUSIC )
track_location = []
# check to see if playlist or music file is selected
if trivia_settings[ "trivia_music" ] == 1:
if trivia_settings[ "trivia_music_file" ].endswith(".m3u"):
log( "Music Playlist: %s" % trivia_settings[ "trivia_music_file" ] )
playlist_file = xbmcvfs.File( trivia_settings[ "trivia_music_file" ], 'rb')
saved_playlist = playlist_file.read().splitlines()
playlist_file.close()
log( "Finished Reading Music Playlist" )
track_info, track_location = parse_playlist( saved_playlist, xbmc.getSupportedMedia('music') )
elif os.path.splitext( trivia_settings[ "trivia_music_file" ] )[1] in xbmc.getSupportedMedia('music'):
for track in range(100):
track_location.append( trivia_settings[ "trivia_music_file" ] )
# otherwise
else:
if trivia_settings[ "trivia_music_folder" ]:
# search given folder and subfolders for files
track_location = dirEntries( trivia_settings[ "trivia_music_folder" ], "music", "TRUE" )
# shuffle playlist
shuffle( track_location )
for track in track_location:
music_playlist.add( track, )
def getLibraryMeta(self):
try:
if self.content == 'movie':
meta = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": {"filter":{"or": [{"field": "year", "operator": "is", "value": "%s"}, {"field": "year", "operator": "is", "value": "%s"}, {"field": "year", "operator": "is", "value": "%s"}]}, "properties" : ["title", "originaltitle", "year", "genre", "studio", "country", "runtime", "rating", "votes", "mpaa", "director", "writer", "plot", "plotoutline", "tagline", "thumbnail", "file"]}, "id": 1}' % (self.year, str(int(self.year)+1), str(int(self.year)-1)))
meta = unicode(meta, 'utf-8', errors='ignore')
meta = json.loads(meta)['result']['movies']
meta = [i for i in meta if i['file'].endswith(self.file)][0]
self.DBID = meta['movieid'] ; poster = thumb = meta['thumbnail']
meta = {'title': meta['title'], 'originaltitle': meta['originaltitle'], 'year': meta['year'], 'genre': str(' / '.join(meta['genre'])), 'studio' : str(' / '.join(meta['studio'])), 'country' : str(' / '.join(meta['country'])), 'duration' : meta['runtime'], 'rating': meta['rating'], 'votes': meta['votes'], 'mpaa': meta['mpaa'], 'director': str(' / '.join(meta['director'])), 'writer': str(' / '.join(meta['writer'])), 'plot': meta['plot'], 'plotoutline': meta['plotoutline'], 'tagline': meta['tagline']}
elif self.content == 'episode':
meta = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"filter":{"and": [{"field": "season", "operator": "is", "value": "%s"}, {"field": "episode", "operator": "is", "value": "%s"}]}, "properties": ["title", "season", "episode", "showtitle", "firstaired", "runtime", "rating", "director", "writer", "plot", "thumbnail", "file"]}, "id": 1}' % (self.season, self.episode))
meta = unicode(meta, 'utf-8', errors='ignore')
meta = json.loads(meta)['result']['episodes']
meta = [i for i in meta if i['file'].endswith(self.file)][0]
self.DBID = meta['episodeid'] ; thumb = meta['thumbnail'] ; showtitle = meta['showtitle']
meta = {'title': meta['title'], 'season' : meta['season'], 'episode': meta['episode'], 'tvshowtitle': meta['showtitle'], 'premiered' : meta['firstaired'], 'duration' : meta['runtime'], 'rating': meta['rating'], 'director': str(' / '.join(meta['director'])), 'writer': str(' / '.join(meta['writer'])), 'plot': meta['plot']}
poster = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": {"filter": {"field": "title", "operator": "is", "value": "%s"}, "properties": ["thumbnail"]}, "id": 1}' % showtitle)
poster = unicode(poster, 'utf-8', errors='ignore')
poster = json.loads(poster)['result']['tvshows'][0]['thumbnail']
return (poster, thumb, meta)
except:
poster, thumb, meta = '', '', {'title': self.name}
return (poster, thumb, meta)
def clear_slideshow():
get_players = json.loads(xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "Player.GetActivePlayers", "id": 1}')) # @UndefinedVariable
for _player in get_players['result']:
if _player['type'] == 'picture':
stop_slideshow = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "Player.Stop", "params": {"playerid":%i}, "id": 1}' % _player['playerid']) # @UndefinedVariable
else: continue
clear_playlist = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "Playlist.Clear", "params": {"playlistid":2}, "id": 1}') # @UndefinedVariable
def build_music_playlist():
utils.log( "Building Music Playlist", xbmc.LOGNOTICE )
xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "AudioPlaylist.Clear", "id": 1}')
music_playlist = xbmc.PlayList( xbmc.PLAYLIST_MUSIC )
track_location = []
# check to see if playlist or music file is selected
if trivia_settings[ "trivia_music" ] == 1:
if ( os.path.splitext( trivia_settings[ "trivia_music_file" ] )[ 1 ] ).lower() in ( "m3u", "pls", "asf", "ram" ):
utils.log( "Music Playlist: %s" % trivia_settings[ "trivia_music_file" ] )
if trivia_settings[ "trivia_music_file" ].endswith(".m3u"):
track_location = parser.parse_m3u( trivia_settings[ "trivia_music_file" ], xbmc.getSupportedMedia('music') )
elif trivia_settings[ "trivia_music_file" ].endswith(".pls"):
track_location = parser.parse_pls( trivia_settings[ "trivia_music_file" ], xbmc.getSupportedMedia('music') )
elif trivia_settings[ "trivia_music_file" ].endswith(".asf"):
track_location = parser.parse_asf( trivia_settings[ "trivia_music_file" ], xbmc.getSupportedMedia('music') )
elif trivia_settings[ "trivia_music_file" ].endswith(".ram"):
track_location = parser.parse_ram( trivia_settings[ "trivia_music_file" ], xbmc.getSupportedMedia('music') )
elif os.path.splitext( trivia_settings[ "trivia_music_file" ] )[1] in xbmc.getSupportedMedia('music'):
for track in range(100):
track_location.append( trivia_settings[ "trivia_music_file" ] )
# otherwise
else:
if trivia_settings[ "trivia_music_folder" ]:
# search given folder and subfolders for files
track_location = absolute_listdir( trivia_settings[ "trivia_music_folder" ], media_type = "music", recursive = True )
# shuffle playlist
shuffle( track_location )
for track in track_location:
music_playlist.add( track, )
def getTvshowList():
rpccmd = {'jsonrpc': '2.0', 'method': 'VideoLibrary.GetTVShows', 'params': { 'properties': ['title', 'imdbnumber'] }, 'id': 'libTvShows'}
rpccmd = json.dumps(rpccmd)
result = xbmc.executeJSONRPC(rpccmd)
tvshows = json.loads(result)
log('tvshows=%s' % tvshows)
tvshowList = []
if tvshows.has_key('result') and tvshows['result'] != None and tvshows['result'].has_key('tvshows'):
tvshows = tvshows['result']['tvshows']
for tvshow in tvshows:
rpccmd = {'jsonrpc': '2.0', 'method': 'VideoLibrary.GetEpisodes', 'params': {'tvshowid': tvshow['tvshowid'], 'properties': ['season', 'episode', 'playcount']}, 'id': 1}
rpccmd = json.dumps(rpccmd)
result = xbmc.executeJSONRPC(rpccmd)
episodes = json.loads(result)
log('tvshow=%s [%s]' % (tvshow['title'], tvshow['imdbnumber']))
log('episodes[%s]=%s' % (tvshow['imdbnumber'], episodes))
if episodes.has_key('result') and episodes['result'] != None and episodes['result'].has_key('episodes'):
episodes = episodes['result']['episodes']
lastEpisode = None
lastSeasonNr = 0
lastEpisodeNr = 0
firstEpisode = None
firstSeasonNr = 2
firstEpisodeNr = 2
for episode in episodes:
if episode['playcount'] >= 1:
if (episode['season'] > lastSeasonNr):
lastSeasonNr = episode['season']
lastEpisodeNr = episode['episode']
lastEpisode = episode
elif (episode['season'] == lastSeasonNr and episode['episode'] > lastEpisodeNr):
lastEpisodeNr = episode['episode']
lastEpisode = episode
if (episode['season'] < firstSeasonNr):
firstSeasonNr = episode['season']
firstEpisodeNr = episode['episode']
firstEpisode = episode
elif (episode['season'] == firstSeasonNr and episode['episode'] < firstEpisodeNr):
firstEpisodeNr = episode['episode']
firstEpisode = episode
if lastEpisode != None:
tvshowList.append({
'seen': 1,
'title': tvshow['title'],
'show_id': tvshow['imdbnumber'],
'season': lastEpisode['season'],
'episode': lastEpisode['episode']
})
log('dernier_vu=s%.2de%.2d' % (int(lastEpisode['season']), int(lastEpisode['episode'])))
elif firstEpisode != None:
tvshowList.append({
'seen': 0,
'title': tvshow['title'],
'show_id': tvshow['imdbnumber'],
'season': firstEpisode['season'],
'episode': firstEpisode['episode']
})
log('premier_non_vu=s%.2de%.2d' % (int(firstEpisode['season']), int(firstEpisode['episode'])))
log('list=%s' % tvshowList)
return tvshowList
def setTvshowProgress(show_id, last_season_seen, last_episode_seen):
rpccmd = {'jsonrpc': '2.0', 'method': 'VideoLibrary.GetTVShows', 'params': { 'properties': ['title', 'imdbnumber'] }, 'id': 'libTvShows'}
rpccmd = json.dumps(rpccmd)
result = xbmc.executeJSONRPC(rpccmd)
tvshows = json.loads(result)
log('tvshows=%s' % tvshows)
if tvshows['result']['limits']['total'] == 0:
return
tvshows = tvshows['result']['tvshows']
for tvshow in tvshows:
if int(tvshow['imdbnumber']) == int(show_id):
log('tvshow=%s' % tvshow)
rpccmd = {'jsonrpc': '2.0', 'method': 'VideoLibrary.GetEpisodes', 'params': {'tvshowid': tvshow['tvshowid'], 'properties': ['title', 'season', 'episode']}, 'id': 1}
rpccmd = json.dumps(rpccmd)
result = xbmc.executeJSONRPC(rpccmd)
episodes = json.loads(result)
log('episodes=%s' % episodes)
if episodes['result']['limits']['total'] > 0:
episodes = episodes['result']['episodes']
for episode in episodes:
log('episode=%s' % episode)
if (episode['season'] <= last_season_seen and episode['episode'] <= last_episode_seen):
command2 = '{"jsonrpc": "2.0", "id": 1, "method": "VideoLibrary.SetEpisodeDetails", "params": {"episodeid" : %s, "playcount": %s}}' % (episode['episodeid'], 1)
result2 = json.loads(xbmc.executeJSONRPC(command2))
log('watched=%s' % 1)
else:
command2 = '{"jsonrpc": "2.0", "id": 1, "method": "VideoLibrary.SetEpisodeDetails", "params": {"episodeid" : %s, "playcount": %s}}' % (episode['episodeid'], 0)
result2 = json.loads(xbmc.executeJSONRPC(command2))
log('watched=%s' % 0)
def alphabetletter(self):
"""used with the alphabet scrollbar to jump to a letter"""
if KODI_VERSION > 16:
xbmcplugin.setResolvedUrl(handle=int(sys.argv[1]), succeeded=False, listitem=xbmcgui.ListItem())
letter = self.params.get("letter", "").upper()
jumpcmd = ""
if letter in ["A", "B", "C", "2"]:
jumpcmd = "2"
elif letter in ["D", "E", "F", "3"]:
jumpcmd = "3"
elif letter in ["G", "H", "I", "4"]:
jumpcmd = "4"
elif letter in ["J", "K", "L", "5"]:
jumpcmd = "5"
elif letter in ["M", "N", "O", "6"]:
jumpcmd = "6"
elif letter in ["P", "Q", "R", "S", "7"]:
jumpcmd = "7"
elif letter in ["T", "U", "V", "8"]:
jumpcmd = "8"
elif letter in ["W", "X", "Y", "Z", "9"]:
jumpcmd = "9"
if jumpcmd:
xbmc.executebuiltin("SetFocus(50)")
for i in range(40):
xbmc.executeJSONRPC(
'{ "jsonrpc": "2.0", "method": "Input.ExecuteAction",\
"params": { "action": "jumpsms%s" }, "id": 1 }'
% (jumpcmd)
)
xbmc.sleep(50)
if xbmc.getInfoLabel("ListItem.Sortletter").upper() == letter:
break
def mirror_sub(id, filename, sub_file):
try:
playerid_query = '{"jsonrpc": "2.0", "method": "Player.GetActivePlayers", "id": 1}'
playerid = json.loads(xbmc.executeJSONRPC(playerid_query))['result'][0]['playerid']
imdb_id_query = '{"jsonrpc": "2.0", "method": "Player.GetItem", "params": {"playerid": ' + str(playerid) + ', "properties": ["imdbnumber"]}, "id": 1}'
imdb_id = json.loads(xbmc.executeJSONRPC (imdb_id_query))['result']['item']['imdbnumber']
except:
imdb_id = 0
values = {}
values['id'] = id
values['versioname'] = filename
values['source'] = 'ktuvit'
values['year'] = xbmc.getInfoLabel("VideoPlayer.Year")
values['season'] = str(xbmc.getInfoLabel("VideoPlayer.Season"))
values['episode'] = str(xbmc.getInfoLabel("VideoPlayer.Episode"))
values['imdb'] = str(imdb_id)
values['tvshow'] = normalizeString(xbmc.getInfoLabel("VideoPlayer.TVshowtitle"))
values['title'] = normalizeString(xbmc.getInfoLabel("VideoPlayer.OriginalTitle"))
values['file_original_path'] = urllib.unquote(unicode(xbmc.Player().getPlayingFile(), 'utf-8'))
url = 'http://api.wizdom.xyz/upload.php'
try:
post(url, files={'sub': open(sub_file, 'rb')}, data=values)
except:
pass
def getKodiMusicVideos(self,fullInfo = False):
#returns all musicvideos in Kodi db inserted by MB
xbmc.sleep(sleepVal)
if fullInfo:
json_response = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetMusicVideos", "params": { "properties" : ["art", "thumbnail", "fanart", "resume", "runtime", "year", "genre", "studio", "artist", "album", "track", "lastplayed", "plot", "director", "playcount", "tag", "file"] }, "id": "libMusicVideos"}')
else:
json_response = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetMusicVideos", "params": { "properties" : ["resume", "playcount", "lastplayed", "file", "track"] }, "id": "libMusicVideos"}')
jsonobject = json.loads(json_response.decode('utf-8','replace'))
musicvideos = None
if(jsonobject.has_key('result')):
result = jsonobject['result']
if(result.has_key('musicvideos')):
musicvideos = result['musicvideos']
kodiMusicVideoMap = None
if(musicvideos != None and len(musicvideos) > 0):
kodiMusicVideoMap = {}
connection = utils.KodiSQL()
cursor = connection.cursor()
for kodivideo in musicvideos:
cursor.execute("SELECT c23 as MBid FROM musicvideo WHERE idMVideo = ?",(kodivideo["musicvideoid"],))
result = cursor.fetchone()
if result != None:
key = result[0]
kodiMusicVideoMap[key] = kodivideo
cursor.close()
return kodiMusicVideoMap
def _fetch_albums(self, request):
if not xbmc.abortRequested:
json_string = '{"jsonrpc": "2.0", "id": 1, "method": "AudioLibrary.GetAlbums", "params": {"properties": ["title", "description", "albumlabel", "artist", "genre", "year", "thumbnail", "fanart", "rating", "playcount"], "limits": {"end": %d},' %self.LIMIT
if request == 'RecommendedAlbum':
json_query = xbmc.executeJSONRPC('%s "sort": {"order": "descending", "method": "playcount" }}}' %json_string)
elif request == 'RecentAlbum':
json_query = xbmc.executeJSONRPC('%s "sort": {"order": "descending", "method": "dateadded" }}}' %json_string)
else:
json_query = xbmc.executeJSONRPC('%s "sort": {"method": "random"}}}' %json_string)
json_query = unicode(json_query, 'utf-8', errors='ignore')
json_query = simplejson.loads(json_query)
if json_query['result'].has_key('albums'):
self._clear_properties(request)
count = 0
for item in json_query['result']['albums']:
count += 1
rating = str(item['rating'])
if rating == '48':
rating = ''
play = 'XBMC.RunScript(' + __addonid__ + ',albumid=' + str(item.get('albumid')) + ')'
self.WINDOW.setProperty("%s.%d.Title" % (request, count), item['title'])
self.WINDOW.setProperty("%s.%d.Label" % (request, count), item['title']) #needs to be removed
self.WINDOW.setProperty("%s.%d.Artist" % (request, count), " / ".join(item['artist']))
self.WINDOW.setProperty("%s.%d.Genre" % (request, count), " / ".join(item['genre']))
self.WINDOW.setProperty("%s.%d.Year" % (request, count), str(item['year']))
self.WINDOW.setProperty("%s.%d.RecordLabel" % (request, count), item['albumlabel'])
self.WINDOW.setProperty("%s.%d.Description" % (request, count), item['description'])
self.WINDOW.setProperty("%s.%d.Rating" % (request, count), rating)
self.WINDOW.setProperty("%s.%d.Thumb" % (request, count), item['thumbnail']) #remove
self.WINDOW.setProperty("%s.%d.Fanart" % (request, count), item['fanart']) #remove
self.WINDOW.setProperty("%s.%d.Art(thumb)" % (request, count), item['thumbnail'])
self.WINDOW.setProperty("%s.%d.Art(fanart)" % (request, count), item['fanart'])
self.WINDOW.setProperty("%s.%d.Play" % (request, count), play)
del json_query
def first_step():
which_way = xbmcgui.Dialog().select(__language__(33901), ["TVShow Time > Kodi", "Kodi > TVShow Time"])
if which_way < 0: return
tvshows = []
tvshowsid = []
command = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": {"sort": { "order": "ascending", "method": "label" }}, "id": 1}'
result = json.loads(xbmc.executeJSONRPC(command))
for i in range(0, result['result']['limits']['total']):
tvshows.append(result['result']['tvshows'][i]['label'])
tvshowsid.append(result['result']['tvshows'][i]['tvshowid'])
tvshows.insert(0, __language__(33902))
tvshowsid.insert(0, "0")
whattvshow = xbmcgui.Dialog().select(__language__(33903), tvshows)
if whattvshow < 0: return
elif whattvshow == 0:
scan(which_way)
else:
seasons = []
command = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params":{"tvshowid": %s, "properties": ["season"], "sort": { "order": "ascending", "method": "season" }}, "id": 1}' % tvshowsid[whattvshow]
result = json.loads(xbmc.executeJSONRPC(command))
for i in range(0, result['result']['limits']['total']):
seasons.append(str(result['result']['episodes'][i]['season']))
seasons = remove_duplicates(seasons)
seasons.insert(0, __language__(33904))
whatseason = xbmcgui.Dialog().select(__language__(33905), seasons)
if whatseason < 0: return
elif whatseason == 0:
scan(which_way, tvshowsid[whattvshow])
else:
scan(which_way, tvshowsid[whattvshow], whatseason)
def setXBMCMoviePlaycount(movieid, playcount, imdb_id):
if getXBMCMajorVersion() >= 12:
time.sleep(0.2)
xbmc.executeJSONRPC(
json.dumps(
{
"jsonrpc": "2.0",
"method": "VideoLibrary.SetMovieDetails",
"params": {"movieid": movieid, "playcount": playcount},
"id": 1,
}
)
)
time.sleep(0.2)
else:
match = raw_xbmc_database.RawXbmcDb.query(
"SELECT movie.idFile FROM movie" + " WHERE movie.c09='%(imdb_id)s'" % {"imdb_id": xcp(imdb_id)}
)
if not match:
# add error message here
return
try:
match[0][0]
except KeyError:
return
raw_xbmc_database.RawXbmcDb.execute(
"UPDATE files"
+ " SET playcount=%(playcount)d" % {"playcount": int(playcount)}
+ " WHERE idFile=%(idFile)s" % {"idFile": xcp(match[0][0])}
)
def getEpisodeDetailsFromXbmc(libraryId, fields):
rpccmd = json.dumps({'jsonrpc': '2.0', 'method': 'VideoLibrary.GetEpisodeDetails', 'params':{'episodeid': libraryId, 'properties': fields}, 'id': 1})
result = xbmc.executeJSONRPC(rpccmd)
Debug('[VideoLibrary.GetEpisodeDetails] ' + result)
result = json.loads(result)
# check for error
try:
error = result['error']
Debug("getEpisodeDetailsFromXbmc: " + str(error))
return None
except KeyError:
pass # no error
try:
# get tvdb id
rpccmd_show = json.dumps({'jsonrpc': '2.0', 'method': 'VideoLibrary.GetTVShowDetails', 'params':{'tvshowid': result['result']['episodedetails']['tvshowid'], 'properties': ['year', 'imdbnumber']}, 'id': 1})
result_show = xbmc.executeJSONRPC(rpccmd_show)
Debug('[VideoLibrary.GetTVShowDetails] ' + result_show)
result_show = json.loads(result_show)
# add to episode data
result['result']['episodedetails']['tvdb_id'] = result_show['result']['tvshowdetails']['imdbnumber']
result['result']['episodedetails']['year'] = result_show['result']['tvshowdetails']['year']
return result['result']['episodedetails']
except KeyError:
Debug("getEpisodeDetailsFromXbmc: KeyError: result['result']['episodedetails']")
return None
def getDetails(self):
details_query_string = '{"jsonrpc": "2.0", "method": "Player.GetProperties", "params":' \
'{ "properties": ["currentaudiostream", "audiostreams", "subtitleenabled", "currentsubtitle", "subtitles" ], "playerid": 1 },' \
'"id": 1}'
json_query = xbmc.executeJSONRPC(details_query_string)
json_query = unicode(json_query, 'utf-8', errors='ignore')
json_response = simplejson.loads(json_query)
if json_response.has_key('result') and json_response['result'] != None:
self.selected_audio_stream = json_response['result']['currentaudiostream']
self.selected_sub = json_response['result']['currentsubtitle']
self.selected_sub_enabled = json_response['result']['subtitleenabled']
self.audiostreams = json_response['result']['audiostreams']
self.subtitles = json_response['result']['subtitles']
log(LOG_DEBUG, json_response )
genre_tags_query_string = '{"jsonrpc": "2.0", "method": "Player.GetItem", "params": { "properties": ["genre", "tag"], "playerid": 1 }, "id": 1}'
json_query = xbmc.executeJSONRPC(genre_tags_query_string)
json_query = unicode(json_query, 'utf-8', errors='ignore')
json_response = simplejson.loads(json_query)
if json_response.has_key('result') and json_response['result'] != None:
gt = []
if json_response['result']['item'].has_key('genre'):
gt = json_response['result']['item']['genre']
if json_response['result']['item'].has_key('tag'):
gt.extend(json_response['result']['item']['tag'])
self.genres_and_tags = set(map(lambda x:x.lower(), gt))
log(LOG_DEBUG, 'Video tags/genres: {0}'.format(self.genres_and_tags))
log(LOG_DEBUG, json_response )
def _get_info( self, episodeid, playcount, playstatus ):
try:
tvshow_query = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodeDetails", "params": {"episodeid": ' + str(episodeid) + ', "properties": ["tvshowid", "showtitle", "season", "episode"]}, "id": 1}'
tvshow = json.loads(xbmc.executeJSONRPC (tvshow_query))['result']['episodedetails']
tvdbid_query = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShowDetails", "params": {"tvshowid": ' + str(tvshow['tvshowid']) + ', "properties": ["imdbnumber"]}, "id": 1}'
tvdbid = json.loads(xbmc.executeJSONRPC (tvdbid_query))['result']['tvshowdetails']['imdbnumber']
showtitle = tvshow['showtitle'].encode("utf-8")
epname = str(tvshow['season']) + 'x' + str(tvshow['episode'])
except:
log("could not get tvshow/episode details", xbmc.LOGNOTICE)
if not tvdbid:
url = self.service[1] + '/shows/search'
urldata = '?v=2.2&key=' + self.service[2] + '&title=' + showtitle
try:
tvdbid_query = get_urldata(url + urldata, '', "GET")
tvdbid_query = json.loads(tvdbid_query)
tvdbid = tvdbid_query['shows'][0]['thetvdb_id']
except:
log("could not fetch tvshow's thetvdb_id", xbmc.LOGNOTICE)
return False
url = self.service[1] + '/shows/episodes'
urldata = '?v=2.2&key=' + self.service[2] + '&thetvdb_id=' + str(tvdbid) + '&season=' + str(tvshow['season']) + '&episode=' + str(tvshow['episode'])
try:
tvdbepid_query = get_urldata(url + urldata, '', "GET")
tvdbepid_query = json.loads(tvdbepid_query)
tvdbepid = tvdbepid_query['episodes'][0]['thetvdb_id']
except:
log("could not fetch episode's thetvdb_id", xbmc.LOGNOTICE)
return False
epinfo = [int(tvdbid), int(tvdbepid), int(playcount), bool(playstatus), showtitle, epname]
return epinfo
def RefreshPVR(m3uPath, epgPath, logoPath, forceUpdate=False, forceUpdateIPTV=False):
if forceUpdateIPTV or common.getAutoIPTV():
UpdateIPTVSimpleSettings(m3uPath, epgPath, logoPath)
kodi16 = True if common.GetKodiVer() < 17 else False
if Addon.getSetting("autoPVR") == "true":
if (not json.loads(xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Addons.GetAddonDetails","params":{"addonid":"pvr.iptvsimple", "properties": ["enabled"]},"id":1}'))['result']['addon']['enabled'] or (kodi16 and not json.loads(xbmc.executeJSONRPC('{"jsonrpc":"2.0", "method":"Settings.GetSettingValue", "params":{"setting":"pvrmanager.enabled"},"id":1}'))['result']['value'])):
tvOption = common.GetMenuSelected(localizedString(30317).encode('utf-8'), [localizedString(30318).encode('utf-8'), localizedString(30319).encode('utf-8')])
if tvOption != 0:
if tvOption == 1:
Addon.setSetting("useIPTV", "False")
return False
isIPTVnotRestarted = not EnableIptvClient() and not kodi16
isPVRnotRestarted = kodi16 and not EnablePVR()
if isIPTVnotRestarted and forceUpdate:
xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Addons.SetAddonEnabled","params":{"addonid":"pvr.iptvsimple","enabled":false},"id":1}')
xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Addons.SetAddonEnabled","params":{"addonid":"pvr.iptvsimple","enabled":true},"id":1}')
#iptvAddon = GetIptvAddon()
#if iptvAddon is None:
# return False
#iptvAddon.setSetting("m3uPathType", iptvAddon.getSetting("m3uPathType"))
if isPVRnotRestarted:
xbmc.executebuiltin('StopPVRManager')
xbmc.executebuiltin('StartPVRManager')
return True
else:
return False
def migrate_profile(new_profile, add_on_id, kodi_add_on_dir, add_on_name):
""" Migrates the old user profile.
:param str|unicode new_profile: The new profile folder.
:param str|unicode add_on_id: The new add-on id.
:param str|unicode kodi_add_on_dir: The Kodi add-on dir.
:param str|unicode add_on_name: The name of the current add-on.
"""
old_add_on_id = "net.rieter.xot"
# This was a xbmc.LOGWARNING, but that is not allowed according to the Kodi add-on rules.
log_level = xbmc.LOGDEBUG
xbmc.log(
"{}: Checking if migration of profile is required.".format(
add_on_name), xbmc.LOGDEBUG)
# If the profile already existed, just stop here.
if os.path.isdir(new_profile):
xbmc.log("{}: Profile already migrated.".format(add_on_name),
log_level)
return
import shutil
d = xbmcgui.Dialog()
# If an old add-on with the old ID was found, disable and rename it.
old_add_on_path = os.path.abspath(
os.path.join(kodi_add_on_dir, "..", old_add_on_id))
if os.path.isdir(old_add_on_path):
xbmc.log(
"{}: Disabling add-on from {}".format(add_on_name,
old_add_on_path), log_level)
# Disable it.
data = {
"jsonrpc": "2.0",
"method": "Addons.SetAddonEnabled",
"params": {
"addonid": old_add_on_id,
"enabled": False
},
"id": 1
}
result = xbmc.executeJSONRPC(json.dumps(data))
xbmc.log(result, log_level)
result = json.loads(result)
if not result or "error" in result:
# This was a xbmc.LOGWARNING, but that is not allowed according to the Kodi add-on rules.
xbmc.log(
"{}: Error disabling {}".format(add_on_name, old_add_on_id),
xbmc.LOGDEBUG)
# Rename it.
old_add_on_xml = os.path.join(old_add_on_path, "addon.xml")
if os.path.exists(old_add_on_xml):
with io.open(old_add_on_xml, mode="r", encoding='utf-8') as fp:
content = fp.read()
if "<broken>" not in content:
xbmc.log(
"{}: Marking add-on {} as broken.".format(
add_on_name, old_add_on_path), log_level)
content = content.replace(
'</language>', '</language>\n '
'<broken>New Add-on is used. Please install version 4.8 or higher.</broken>'
)
with io.open(old_add_on_xml, mode='w+',
encoding='utf-8') as fp:
fp.write(content)
text = xbmcaddon.Addon().getLocalizedString(30603)
d.ok(add_on_name, text)
xbmc.log(
"{}: Reloading all Kodi Add-ons information.".format(add_on_name),
log_level)
xbmc.executebuiltin("UpdateLocalAddons")
# If there was an old profile, migrate it.
old_profile = os.path.abspath(
os.path.join(new_profile, "..", old_add_on_id))
if not os.path.exists(old_profile):
xbmc.log(
"{}: No old profile data found at {}.".format(
add_on_name, old_profile), log_level)
return
xbmc.log("{}: Old Profile located at {}".format(add_on_name, old_profile),
log_level)
d.notification(add_on_name,
"Migrating add-on data to new format.",
icon="info",
time=5)
xbmc.log(
"{}: Migrating addon_data {} to {}.".format(add_on_name, old_profile,
new_profile), log_level)
shutil.copytree(old_profile,
new_profile,
ignore=shutil.ignore_patterns("textures"))
# If there were local setttings, we need to migrate those too so the channel ID's are updated.
local_settings_file = os.path.join(new_profile, "settings.json")
if os.path.exists(local_settings_file):
xbmc.log("{}: Migrating {}.".format(add_on_name, local_settings_file),
log_level)
with io.open(local_settings_file, mode="rb") as fp:
content = fp.read()
settings = json.loads(content, encoding='utf-8')
channel_ids = settings.get("channels", {})
channel_settings = {}
for channel_id in channel_ids:
new_channel_id = channel_id.replace(old_add_on_id, add_on_id)
xbmc.log(
"{}: - Renaming {} -> {}.".format(add_on_name, channel_id,
new_channel_id), log_level)
channel_settings[new_channel_id] = settings["channels"][channel_id]
settings["channels"] = channel_settings
with io.open(local_settings_file, mode='w+b') as fp:
content = json.dumps(settings, indent=4, encoding='utf-8')
fp.write(content)
# fix the favourites
favourites_path = os.path.join(new_profile, "favourites")
if os.path.isdir(favourites_path):
xbmc.log(
"{}: Updating favourites at {}".format(add_on_name,
favourites_path), log_level)
for fav in os.listdir(favourites_path):
# plugin://net.rieter.xot/
fav_path = os.path.join(favourites_path, fav)
xbmc.log("{}: - Updating favourite: {}.".format(add_on_name, fav),
log_level)
with io.open(fav_path, mode='r', encoding='utf-8') as fp:
content = fp.read()
content = content.replace("plugin://{}/".format(old_add_on_id),
"plugin://{}/".format(add_on_id))
with io.open(fav_path, mode='w+', encoding='utf-8') as fp:
fp.write(content)
xbmc.log("{}: Migration completed.".format(add_on_name), log_level)
return
def loop(self):
twpath = os.path.join(xbmc.translatePath('special://home'), 'userdata',
'addon_data', 'service.maxxam.teamwatch',
'tw.ini')
while not self.monitor.abortRequested():
# after DISPLAY_TIME_SECS elapsed hide the message bar
if self.monitor.waitForAbort(REFRESH_TIME_SECS):
self.hide_message()
self._log("stop")
break
if self.feed_is_shown and time.time(
) - self.feed_show_time > DISPLAY_TIME_SECS:
self.hide_message()
if self.show_disable_after:
self.hide_message()
self.show_enable = False
self.show_disable_after = False
if (time.time() -
self.start_time) < REFRESH_TIME_SECS or self.feed_is_shown:
continue
self.start_time = time.time()
try:
file = open(twpath, "r")
self.id_chat = int(file.read())
file.close()
except:
self.id_chat = -1
params = {
'idt': self.id_twitter,
'idc': self.id_chat,
'twid': self.id_teamwatch,
'pcid': self.id_playerctl,
'nickname': self.nickname
}
if self.feed_name:
params['q'] = ":".join(self.feed_name)
else:
params['q'] = "#teamwatch"
if self.twitter_enabled:
params['tqp'] = "&lang=%s&result_type=%s" % (
self.twitter_language, self.twitter_result_type)
params['tl'] = self.twitter_language
else:
params[' notweet'] = 1
url = 'http://www.teamwatch.it/get.php?%s' % urllib.urlencode(
params)
if DEBUG > 1:
self._log("id_chat: " + str(self.id_chat))
self._log(url)
try:
jresult = {}
jresult = json.loads(urllib.urlopen(url).read())
except:
self._log("error opening %s" % url)
finally:
if 'id' in jresult:
if 'is_twitter' in jresult and jresult['is_twitter'] == 1:
self.id_twitter = jresult['id']
else:
self.id_chat = jresult['id']
file = open(twpath, "w+")
file.write(str(self.id_chat))
file.close()
if jresult['status'] == 'ok' and self.show_enable:
file = open(twpath, "w")
file.write(str(self.id_chat))
file.close()
user = jresult['user'].encode('utf-8')
text = jresult['text'].encode('utf-8')
if self.show_allways or xbmcgui.getCurrentWindowId(
) == WINDOW_FULLSCREEN_VIDEO:
if DEBUG > 1:
self.show_message(user, text, [
ICON_CHAT, ICON_TWITTER
][jresult['is_twitter']]) #, jresult['id'])
else:
self.show_message(user, text,
[ICON_CHAT, ICON_TWITTER
][jresult['is_twitter']])
elif jresult['status'] == 'settings':
param = jresult['param'].encode('utf-8')
if param.startswith("#tw:addfeed:"):
if not param[12:] in self.feed_name:
self.feed_name.append(param[12:])
self.__addon__.setSetting('feed',
":".join(self.feed_name))
self.show_message('TeamWatch',
localize(32000, param[12:]),
ICON_SETTING)
elif param.startswith("#tw:removefeed:"):
if param[15:] in self.feed_name:
self.feed_name.remove(param[15:])
self.__addon__.setSetting('feed',
":".join(self.feed_name))
self.show_message('TeamWatch',
localize(32001, param[15:]),
ICON_SETTING)
elif param == "#tw:off":
self.show_message('TeamWatch', localize(32002),
ICON_SETTING)
self.show_disable_after = True
elif param == "#tw:on":
self.show_enable = True
self.show_message('TeamWatch', localize(32003),
ICON_SETTING)
elif param == "#tw:bar:top":
self.bartop = 0
self.show_message('TeamWatch', "Bar position set to top",
ICON_SETTING)
elif param == "#tw:bar:bottom":
self.bartop = self.screen_height - 75
self.show_message('TeamWatch',
"Bar position set to bottom",
ICON_SETTING)
elif param == "#tw:id":
self.id_chat = jresult['idc']
self.id_twitter = jresult['idt']
file = open(twpath, "w")
file.write(str(self.id_chat))
file.close()
elif param == "#tw:playerctl:playpause":
self._log('esecuzione #tw:playerctl:playpause')
xbmc.executebuiltin("Action(PlayPause)")
self._log('playpause terminated id_chat: ' +
str(self.id_chat))
elif param == "#tw:playerctl:sshot":
xbmc.executebuiltin("TakeScreenshot")
elif param.startswith("#tw:playerctl:seek:"):
t = [
int("0" + filter(str.isdigit, x))
for x in param[19:].split(":")
]
if len(t) == 4:
xbmc.executeJSONRPC(
'{ "jsonrpc": "2.0", "method": "Player.Seek", "params": {"playerid":1, "value": {"hours":%d, "minutes":%d, "seconds":%d, "milliseconds":%d}}, "id": 1 }'
% tuple(t))
elif DEBUG:
self._log('#tw:playerctl:seek invalid time')
elif param.startswith("#tw:playstream:"):
self._log('*** playstream received ***')
self._log(param[15:])
player = xbmc.Player()
player.play(param[15:])
elif param.startswith("#tw:invite:"):
# web_pdb.set_trace()
if DEBUG: self._log("#tw:invite")
invite = param[11:].split(":")
if invite[0] == "m":
self._log("#tw:invite:m: %s" % invite[1])
movie = xbmc_helpers.search_movie(invite[1])
self._log("after movie search")
if movie:
# dialog = xbmcgui.Dialog()
# res = dialog.yesno(localize(32004), localize(32005, (invite[1], movie["title"])))
if DEBUG:
self._log("invite received for movie: %s" %
movie["title"])
player = xbmc.Player()
player.play(movie["file"])
if player.isPlaying():
self._log('playing...')
else:
self._log('not playing...')
else:
if DEBUG:
self._log(
"invite received for non existent movie %s"
% invite[1])
elif invite[0] == "e":
episode = xbmc_helpers.search_episode(
invite[1], invite[2], invite[3])
if episode:
dialog = xbmcgui.Dialog()
s_ep = "S[COLOR green][B]%02d[/B][/COLOR]E[COLOR green][B]%02d[/B][/COLOR]" % (
int(episode["season"]), int(
episode["episode"]))
res = dialog.yesno(
localize(32004),
localize(
32006,
(invite[1], episode["showtitle"], s_ep)))
if DEBUG:
self._log(
"invite received for episode id: %d" %
episode["episodeid"])
else:
if DEBUG:
self._log(
"invite received for non existent episode %s %s %s"
% (invite[1], invite[2], invite[3]))
else:
pass
else:
pass
else:
if DEBUG and jresult['status'] == "fail" and jresult[
'reason'] != "no feeds" and not jresult[
'reason'].startswith('waiting'):
self._log(jresult)
if DEBUG and jresult['reason'].startswith('json parse error'):
self.id_twitter = -1
self.id_chat = -1
def _execute(self, request):
request_string = json.dumps(request)
response = xbmc.executeJSONRPC(request_string)
if (response):
response = json.loads(response)
return response
def ShowNotification(title,
lines,
notificationType=Info,
displayTime=1500,
fallback=True,
logger=None):
""" Shows an XBMC Notification
Arguments:
titel : String - The title to show
content : String - The content to show
Keyword Arguments:
notificationType : String - The type of notification: info, error, warning
displayTime : int - Time to display the notification. Defaults to 1500 ms.
fallback : bool - Should we fallback on XbmcWrapper.ShowDialog on error?
"""
# check for a title
if title:
notificationTitle = "%s - %s" % (Config.appName, title)
else:
notificationTitle = Config.appName
# check for content and merge multiple lines. This is to stay compatible
# with the LanguageHelper.GetLocalizedString that returns strings as arrays
# if they are multiple lines (this is because XbmcWrapper.ShowDialog needs
# this for multi-line dialog boxes.
if not lines:
notificationContent = ""
else:
if isinstance(lines, (tuple, list)):
notificationContent = " ".join(lines)
else:
notificationContent = lines
# determine the duration
notificationType = notificationType.lower()
if notificationType == XbmcWrapper.Warning and displayTime < 2500:
displayTime = 2500
elif notificationType == XbmcWrapper.Info and displayTime < 5000:
displayTime = 5000
elif displayTime < 1500:
# cannot be smaller then 1500 (API limit)
displayTime = 1500
# Get an icon
notificationIcon = os.path.join(Config.rootDir, "icon.png")
if os.path.exists(notificationIcon):
# change the separators
notificationIcon = notificationIcon.replace("\\", "/")
else:
notificationIcon = notificationType
if logger:
logger.Debug("Showing notification: %s - %s", notificationTitle,
notificationContent)
command = '{"id": 1,"jsonrpc":"2.0","method":"GUI.ShowNotification","params":{"title":"%s","message":"%s", "image":"%s", "displaytime": %s}}' % (
notificationTitle, notificationContent, notificationIcon,
displayTime)
try:
if logger:
logger.Trace("Sending command: %s", command)
response = xbmc.executeJSONRPC(command)
if logger:
logger.Trace("Response: %s", response)
return response
except:
if fallback:
XbmcWrapper.ShowDialog(title or "", lines or "")
# no reason to worry if this does not work on older XBMC's
return False
def getTvshowList():
rpccmd = {
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetTVShows',
'params': {
'properties': ['title', 'imdbnumber']
},
'id': 'libTvShows'
}
rpccmd = json.dumps(rpccmd)
result = xbmc.executeJSONRPC(rpccmd)
tvshows = json.loads(result)
log('tvshows=%s' % tvshows)
tvshowList = []
if tvshows.has_key('result') and tvshows['result'] != None and tvshows[
'result'].has_key('tvshows'):
tvshows = tvshows['result']['tvshows']
for tvshow in tvshows:
rpccmd = {
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetEpisodes',
'params': {
'tvshowid': tvshow['tvshowid'],
'properties': ['season', 'episode', 'playcount']
},
'id': 1
}
rpccmd = json.dumps(rpccmd)
result = xbmc.executeJSONRPC(rpccmd)
episodes = json.loads(result)
log('tvshow=%s [%s]' % (tvshow['title'], tvshow['imdbnumber']))
log('episodes[%s]=%s' % (tvshow['imdbnumber'], episodes))
if episodes.has_key(
'result') and episodes['result'] != None and episodes[
'result'].has_key('episodes'):
episodes = episodes['result']['episodes']
lastEpisode = None
lastSeasonNr = 0
lastEpisodeNr = 0
firstEpisode = None
firstSeasonNr = 2
firstEpisodeNr = 2
for episode in episodes:
if episode['playcount'] >= 1:
if (episode['season'] > lastSeasonNr):
lastSeasonNr = episode['season']
lastEpisodeNr = episode['episode']
lastEpisode = episode
elif (episode['season'] == lastSeasonNr
and episode['episode'] > lastEpisodeNr):
lastEpisodeNr = episode['episode']
lastEpisode = episode
if (episode['season'] < firstSeasonNr):
firstSeasonNr = episode['season']
firstEpisodeNr = episode['episode']
firstEpisode = episode
elif (episode['season'] == firstSeasonNr
and episode['episode'] < firstEpisodeNr):
firstEpisodeNr = episode['episode']
firstEpisode = episode
if lastEpisode != None:
tvshowList.append({
'seen': 1,
'title': tvshow['title'],
'show_id': tvshow['imdbnumber'],
'season': lastEpisode['season'],
'episode': lastEpisode['episode']
})
log('dernier_vu=s%.2de%.2d' % (int(
lastEpisode['season']), int(lastEpisode['episode'])))
elif firstEpisode != None:
tvshowList.append({
'seen': 0,
'title': tvshow['title'],
'show_id': tvshow['imdbnumber'],
'season': firstEpisode['season'],
'episode': firstEpisode['episode']
})
log('premier_non_vu=s%.2de%.2d' % (int(
firstEpisode['season']), int(firstEpisode['episode'])))
log('list=%s' % tvshowList)
return tvshowList
#
# Copyright (C) 2016 KenV99
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
import xbmc
import sys
addonid = sys.argv[1]
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Addons.SetAddonEnabled", "params":{"addonid":"%s","enabled":"toggle"},"id":1}'
% addonid)
xbmc.log(msg='***** Toggling addon enabled 1: %s' % addonid)
xbmc.sleep(1000)
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Addons.SetAddonEnabled", "params":{"addonid":"%s","enabled":"toggle"},"id":1}'
% addonid)
xbmc.log(msg='***** Toggling addon enabled 2: %s' % addonid)
def search_subtitles(search):
subtitles = []
log("entering search_subtitles()")
if search['mode'] == "movie":
log("movies not supported!")
return False
# get video file name
dirsync = __addon__.getSetting('dirsync') == 'true'
if dirsync:
# get directory name as filename
filename = os.path.basename(os.path.dirname(search['path'])).lower()
else:
# or use filename
filename = os.path.basename(search['path']).lower()
# and remove file extension
filename = re.sub(r"\.[^.]+$", "", filename)
filename = normalize_string(filename)
log("after filename = %s" % (filename))
# if file, check if valid tvshow
if search['mode'] == "file" and not re.search(r"(?i)(s[0-9]+e[0-9]+|[0-9]+x?[0-9]{2,})", filename):
log("not a tvshow or badly named!")
return False
# get subtitle team
subteams = []
subteams.append(filename.replace(".","-"))
if len(subteams[0]) > 0:
# get team name (everything after "-")
subteams[0] = self_team_pattern.match("-" + subteams[0]).groups()[0].lower()
# find equivalent teams, if any
tmp = other_team(subteams[0],0,1)
if len(tmp) > 0 and tmp != subteams[0]:
subteams.append(tmp)
# find other equivalent teams, if any
tmp = other_team(subteams[0],1,0)
if len(tmp) > 0 and tmp != subteams[0]:
subteams.append(tmp)
log("after subteams = %s" % (subteams))
# configure socket
socket.setdefaulttimeout(10)
# define default url to get betaseries episode id from filename
episodeurl = "%s/episodes/scraper?file=%s&key=%s&v=%s" % (self_host, urllib.quote(filename), self_apikey, self_apiver)
# check video type
if search['mode'] == "tvshow":
# get playerid
json_query = '{"jsonrpc": "2.0", "method": "Player.GetActivePlayers", "id": 1}'
playerid = json.loads(xbmc.executeJSONRPC(json_query))['result'][0]['playerid']
# get tvshowid
json_query = '{"jsonrpc": "2.0", "method": "Player.GetItem", "params": {"playerid": ' + str(playerid) + ', "properties": ["tvshowid"]}, "id": 1}'
tvshowid = json.loads(xbmc.executeJSONRPC (json_query))['result']['item']['tvshowid']
# check result
if tvshowid > 0:
# get tvdbid
json_query = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShowDetails", "params": {"tvshowid": ' + str(tvshowid) + ', "properties": ["imdbnumber"]}, "id": 1}'
tvdbid_result = json.loads(xbmc.executeJSONRPC(json_query))
# if we have tvdbid, work with ids
if 'result' in tvdbid_result:
# get betaseries show id from tvdbid
tvdbid = tvdbid_result['result']['tvshowdetails']['imdbnumber']
showurl = "%s/shows/display?thetvdb_id=%s&key=%s&v=%s" % (self_host, tvdbid, self_apikey, self_apiver)
showid = json.loads(get_url(showurl))["show"]["id"]
log("after showid = %s" % (showid))
# then get betaseries episode id
episodeurl = "%s/episodes/search?show_id=%s&number=S%#02dE%#02d&key=%s&v=%s" % (self_host, showid, int(search['season']), int(search['episode']), self_apikey, self_apiver)
try:
episodeid = json.loads(get_url(episodeurl))["episode"]["id"]
log("after episodeid = %s" % (episodeid))
except:
log("error or episode not found!")
return False
# then get subtitles list
listurl = "%s/subtitles/episode?id=%s&key=%s&v=%s" % (self_host, episodeid, self_apikey, self_apiver)
try:
data = json.loads(get_url(listurl))["subtitles"]
except:
log("could not parse data or fetch url, cannot continue")
return False
# for each release version
log("parsing data after urlopen")
log("--------------------------")
for subtitle in data:
# get filename
subfile = normalize_string(subtitle["file"])
log("after subfile = %s" % (subfile))
# get file extension
ext = string.split(subfile,'.')[-1]
# get season number from data
season = int(subtitle["episode"]["season"])
log("after season = %s" % (season))
# get episode number from data
episode = int(subtitle["episode"]["episode"])
log("after episode = %s" % (episode))
# get names of files contained in zip file, if any
if len(subtitle["content"]) > 0:
content = subtitle["content"]
# or put filename in content
else:
content = [subtitle["file"]]
log("after content = %s" % (content))
# for each file in content
for subversion in content:
log("-------------")
# subtitle file name
subversion = normalize_string(subversion)
log("after subversion = %s" % (subversion))
# subtitle download url
link = subtitle["url"]
log("after link = %s" % (link))
try:
# normalize lang
lang2 = {
"VO": "en",
"VF": "fr",
"VOVF": "xx",
}[subtitle["language"]]
except:
log("unsupported language")
continue
# get note
if 0 <= int(subtitle["quality"]) <= 5:
note = int(subtitle["quality"])
else:
note = 0
log("after note = %s" % (note))
# check if file is a subtitle
if not len(re.findall(r"(?i)\.(srt|ssa|ass|sub)$", subversion)):
log("not a subtitle : %s" % (subversion))
continue
# if from a zip file
if len(content) > 1:
# check if file is for correct season and episode
search_string = r"(?i)(s%#02de%#02d|%d%#02d|%dx%#02d)" % (season, episode, season, episode, season, episode)
if not re.search(search_string, subversion):
log("file not matching episode : %s" % (subversion))
continue
# get subtitle file lang
langs = re.search(r"(?i)[ _.-](english|french|eng|fre|en|fr|vo|vf)[ _.-]", subversion)
# or get zip file lang
if langs == None:
langs = lang2
else:
langs = langs.group(1).lower()
log("after zip langs = %s" % (lang2))
try:
lang2 = {
"french": 'fr',
"english": 'en',
"fre": 'fr',
"eng": 'en',
"fr": 'fr',
"en": 'en',
"vf": 'fr',
"vo": 'en'
}[langs]
except:
log("unsupported language")
continue
log("after zip lang2 = %s" % (lang2))
try:
# get full language name
lang = xbmc.convertLanguage(lang2, xbmc.ENGLISH_NAME)
except:
log("unsupported language")
continue
# if lang = user gui language
if lang == search['uilang']:
# put this file on top
uilang = True
else:
uilang = False
log("after lang = %s, lang2 = %s" % (lang, lang2))
# check sync
sync = False
team = False
for (key, subteam) in enumerate(subteams):
# if team corresponds
if len(subteam) > 0 and len(re.findall(r"(?i)[ _.-](" + subteam + ")[ _.-]", subversion)) > 0:
# set sync tag
sync = True
# if videofile team matches subfile team
if key == 0:
team = True
log("after sync = %s" % (sync))
# check if this is for hearing impaired
if len(re.findall(r"(?i)[ _.-](CC|HI)[ _.-]", subversion)) > 0:
cc = True
else:
cc = False
log("after cc = %s" % (cc))
# if language allowed by user
if lang2 in search['langs']:
# add subtitle to list
subtitles.append({'uilang':uilang,'ext':ext,'filename':subversion,'link':link,'lang':lang,'lang2':lang2,"cc":cc,"sync":sync,"note":note,"team":team})
log("subtitle added : %s" % (subversion))
log("--------------------------")
if subtitles:
# get settings for sorting
uifirst = __addon__.getSetting('uifirst') == 'true'
ccfirst = __addon__.getSetting('ccfirst') == 'true'
# sort accordingly
log("sorting by filename asc")
subtitles.sort(key=lambda x: [x['filename']])
if not ccfirst:
log("sorting by cc last")
subtitles.sort(key=lambda x: [x['cc']])
log("sorting by note best")
subtitles.sort(key=lambda x: [x['note']], reverse=True)
log("sorting by lang asc")
subtitles.sort(key=lambda x: [x['lang']])
if ccfirst:
log("sorting by cc first")
subtitles.sort(key=lambda x: [not x['cc']])
if uifirst:
log("sorting by uilang first")
subtitles.sort(key=lambda x: [not x['uilang']])
log("sorting by sync first")
subtitles.sort(key=lambda x: [not x['sync']])
log("sorting by team first")
subtitles.sort(key=lambda x: [not x['team']])
log("sorted subtitles = %s" % (subtitles))
# for each subtitle
for item in subtitles:
# xbmc list item format
listitem = xbmcgui.ListItem(label=item["lang"],
label2=item["filename"],
iconImage=str(item["note"]),
thumbnailImage=item["lang2"])
# setting sync / CC tag
listitem.setProperty("sync", 'true' if item["sync"] else 'false')
listitem.setProperty("hearing_imp", 'true' if item["cc"] else 'false')
# adding item to GUI list
url = "plugin://%s/?action=download&link=%s&ext=%s&filename=%s" % (__addonid__, item["link"], item["ext"], urllib.quote(item["filename"]))
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=url,listitem=listitem,isFolder=False)
else:
if self_notify:
xbmc.executebuiltin((u'Notification(%s,%s,%s,%s)' % (__addonname__, __language__(30010), 750, __icon__)).encode('utf-8', 'ignore'))
log("nothing found")
log("end of search_subtitles()")
if not control.addon().getAddonInfo('id')=='program.apollo':
with open(M3UFile, "rt") as fin:
with open(M3UFile+"_tmp", "wt") as fout:
for line in fin:
fout.write(line.replace('program.apollo', control.addon().getAddonInfo('id')))
fin.close
fout.close
os.remove(M3UFile)
os.rename(M3UFile+"_tmp",M3UFile)
xbmc.sleep(5)
xbmc.executebuiltin('StopPVRManager')
xbmc.executebuiltin('StartPVRManager')
try:
if not json.loads(xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Addons.GetAddonDetails","params":{"addonid":"pvr.iptvsimple", "properties": ["enabled"]},"id":1}'))['result']['addon']['enabled']:
xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Addons.SetAddonEnabled","params":{"addonid":"pvr.iptvsimple","enabled":true},"id":1}')
xbmc.sleep(5)
print "**** IPTV Simple: Enable"
except: pass
try:
if not json.loads(xbmc.executeJSONRPC('{"jsonrpc":"2.0", "method":"Settings.GetSettingValue", "params":{"setting":"pvrmanager.enabled"},"id":1}'))['result']['value']:
xbmc.executeJSONRPC('{"jsonrpc":"2.0", "method":"Settings.SetSettingValue", "params":{"setting":"pvrmanager.enabled", "value":true},"id":1}')
xbmc.sleep(2)
xbmc.executebuiltin('StopPVRManager')
xbmc.executebuiltin('StartPVRManager')
print "**** PVR Manager: Enable"
xbmc.Dialog().ok(control.addon().getAddonInfo('name'),"Please restart kodi for TV Guide to start")
except: pass
if isItMovie:
item['title'] = xbmc.getInfoLabel("ListItem.OriginalTitle")
elif isItEpisode:
item['title'] = xbmc.getInfoLabel("ListItem.TVShowTitle")
else:
item[
'title'] = "SearchFor..." # In order to show "No Subtitles Found" result.
MyLog("item:%s" % item)
imdb_id = 0
try:
if Player().isPlaying(
): # Enable using subtitles search dialog when kodi is not playing
playerid_query = '{"jsonrpc": "2.0", "method": "Player.GetActivePlayers", "id": 1}'
playerid = loads(
executeJSONRPC(playerid_query))['result'][0]['playerid']
imdb_id_query = '{"jsonrpc": "2.0", "method": "Player.GetItem", "params": {"playerid": ' + str(
playerid) + ', "properties": ["imdbnumber"]}, "id": 1}'
imdb_id = loads(
executeJSONRPC(imdb_id_query))['result']['item']['imdbnumber']
MyLog("imdb JSONPC:%s" % imdb_id)
else:
if labelIMDB:
imdb_id = labelIMDB
else:
if isItMovie:
imdb_id = "ThisIsMovie" #Search the movie by item['title'] for imdb_id
elif isItEpisode:
imdb_id = "ThisIsEpisode" #Search by item['title'] for tvdb_id
else:
imdb_id = "tt0" # In order to show "No Subtitles Found" result => Doesn't recognize movie/episode
def execute_jsonrpc(command):
if not isinstance(command, basestring):
command = json.dumps(command)
response = xbmc.executeJSONRPC(command)
return json.loads(response)
def Main():
first_q = dialog.yesno('LazyTV', lang(32142), lang(32143), lang(32144))
if first_q != 1:
sys.exit()
else:
keyboard = xbmc.Keyboard(lang(32139))
keyboard.doModal()
if (keyboard.isConfirmed()):
clone_name = keyboard.getText()
else:
sys.exit()
# if the clone_name is blank then use default name of 'Clone'
if not clone_name:
clone_name = 'Clone'
san_name = 'script.lazytv.' + sanitize_strings(clone_name)
new_path = os.path.join(addon_path, san_name)
log('clone_name = ' + str(clone_name))
log('san_name = ' + str(san_name))
log('new_path = ' + str(new_path))
log('script path = ' + str(scriptPath))
#check if folder exists, if it does then abort
if os.path.isdir(new_path):
log('That name is in use. Please try another')
dialog.ok('LazyTV', lang(32145))
__addon__.openSettings()
sys.exit()
try:
# copy current addon to new location
IGNORE_PATTERNS = ('.pyc', 'CVS', '.git', 'tmp', '.svn')
shutil.copytree(scriptPath,
new_path,
ignore=shutil.ignore_patterns(*IGNORE_PATTERNS))
# remove the unneeded files
addon_file = os.path.join(new_path, 'addon.xml')
os.remove(os.path.join(new_path, 'service.py'))
os.remove(addon_file)
#os.remove(os.path.join(new_path,'resources','selector.py'))
os.remove(os.path.join(new_path, 'resources', 'settings.xml'))
os.remove(os.path.join(new_path, 'resources', 'clone.py'))
# replace the settings file and addon file with the truncated one
shutil.move(os.path.join(new_path, 'resources', 'addon_clone.xml'),
addon_file)
shutil.move(os.path.join(new_path, 'resources', 'settings_clone.xml'),
os.path.join(new_path, 'resources', 'settings.xml'))
except Exception as e:
ex_type, ex, tb = sys.exc_info()
errorHandle(e, tb, new_path)
# edit the addon.xml to point to the right folder
tree = et.parse(addon_file)
root = tree.getroot()
root.set('id', san_name)
root.set('name', clone_name)
tree.find('.//summary').text = clone_name
tree.write(addon_file)
# replace the id on these files, avoids Access Violation
py_files = [
os.path.join(new_path, 'resources', 'selector.py'),
os.path.join(new_path, 'resources', 'playlists.py'),
os.path.join(new_path, 'resources', 'update_clone.py'),
os.path.join(new_path, 'resources', 'episode_exporter.py')
]
for py in py_files:
for line in fileinput.input(
py, inplace=1
): # Does a list of files, and writes redirects STDOUT to the file in question
print line.replace('script.lazytv', san_name),
# stop and start the addon to have it show in the Video Addons window
try:
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Addons.SetAddonEnabled","id":1,"params":{"addonid":"%s","enabled":false}}'
% san_name)
xbmc.sleep(1000)
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Addons.SetAddonEnabled","id":1,"params":{"addonid":"%s", "enabled":true}}'
% san_name)
except:
pass
dialog.ok('LazyTV', lang(32146), lang(32147))
def on_player_get():
r_dict = json.loads(xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Player.GetActivePlayers","id":0}'))
try: return r_dict["result"]
except Exception: return None
import lib.private.ydlfix
import lib.utils as utils
import xbmc
import xbmcaddon
from lib.utils import logger
from lib.youtube_dl import YoutubeDL
lib.private.ydlfix.patch_youtube_dl()
if utils.is_python_3():
from urllib.parse import unquote
else:
from urllib import unquote
have_adaptive_plugin = '"enabled":true' in xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Addons.GetAddonDetails","id":1,"params":{"addonid":"inputstream.adaptive", "properties": ["enabled"]}}'
)
def run(argument):
if argument['type'] == 'magnet':
handle_magnet(argument['data'])
elif argument['type'] == 'unresolvedurl':
if ('queue' not in argument) or (argument['queue'] == 'false'):
action = 'play'
else:
action = 'queue'
handle_unresolved_url(argument['data'], action)
def handle_magnet(data):
def getBandwidthLimit():
json_result = xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Settings.GetSettingValue","params":{"setting":"network.bandwidth"},"id":1}')
data_object = json.loads(json_result)
return data_object['result']['value']
def listCat(cat):
xbmcplugin.setContent(pluginhandle, "addons")
xbmcplugin.addSortMethod(pluginhandle, xbmcplugin.SORT_METHOD_LABEL)
addons = os.listdir(addonsFolder)
json_result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "Addons.GetAddons", "params": {"content": "'
+ contentType + '"}, "id": 1}')
if '"Method not found."' in json_result:
if cat == "all":
for a in addons:
types = getTypes(a)
if a != "script.categories" and contentType in types:
try:
currentAddon = xbmcaddon.Addon(id=a)
addonUrl = getAddonUrl(a, types)
title = currentAddon.getAddonInfo('name')
addAddonDir(title, addonUrl,
currentAddon.getAddonInfo('icon'),
currentAddon.getAddonInfo('description'),
contentType, a,
currentAddon.getAddonInfo('author'),
currentAddon.getAddonInfo('version'))
except:
pass
else:
if os.path.exists(catsFile):
fh = open(catsFile, 'r')
content = fh.read()
fh.close()
for a in addons:
types = getTypes(a)
if a != "script.categories" and contentType in types and a + "#" + cat in content:
try:
currentAddon = xbmcaddon.Addon(id=a)
addonUrl = getAddonUrl(a, types)
title = currentAddon.getAddonInfo('name')
addAddonRDir(
title, addonUrl,
currentAddon.getAddonInfo('icon'), cat,
currentAddon.getAddonInfo('description'), a,
currentAddon.getAddonInfo('author'),
currentAddon.getAddonInfo('version'))
except:
pass
else:
match = re.compile('"addonid":"(.+?)","type":"(.+?)"',
re.DOTALL).findall(json_result)
if cat == "all":
for addonid, temp in match:
try:
if addonid != "script.categories":
types = getTypes(addonid)
addonUrl = getAddonUrl(addonid, types)
currentAddon = xbmcaddon.Addon(id=addonid)
title = currentAddon.getAddonInfo('name')
addAddonDir(title, addonUrl,
currentAddon.getAddonInfo('icon'),
currentAddon.getAddonInfo('description'),
contentType, addonid,
currentAddon.getAddonInfo('author'),
currentAddon.getAddonInfo('version'))
except:
pass
else:
if os.path.exists(catsFile):
fh = open(catsFile, 'r')
content = fh.read()
fh.close()
for addonid, temp in match:
if addonid + "#" + cat in content:
try:
if addonid != "script.categories":
types = getTypes(addonid)
addonUrl = getAddonUrl(addonid, types)
currentAddon = xbmcaddon.Addon(id=addonid)
title = currentAddon.getAddonInfo('name')
addAddonRDir(
title, addonUrl,
currentAddon.getAddonInfo('icon'), cat,
currentAddon.getAddonInfo('description'),
addonid,
currentAddon.getAddonInfo('author'),
currentAddon.getAddonInfo('version'))
except:
pass
xbmcplugin.endOfDirectory(pluginhandle)
if forceViewMode:
xbmc.executebuiltin('Container.SetViewMode(' + viewMode2 + ')')
def getAllCount():
json_result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "Addons.GetAddons", "params": {"content": "'
+ contentType + '"}, "id": 1}')
match = re.compile('"addonid"', re.DOTALL).findall(json_result)
return len(match) - 1
def _maybePlayNextProgramme(self):
nextProgramme = _db_.getNextEpg()
_db_.closeDB()
if not nextProgramme:
return
timestampNow = int(time.time())
if int(nextProgramme['end']) <= timestampNow:
question = 'Do you want to play the next programme: '+nextProgramme["title"] + '?'
response = xbmcgui.Dialog().yesno(_scriptname_, question, yeslabel='Yes', nolabel='No')
if response:
command = 'RunPlugin(plugin://plugin.video.o2tvgo.iptv.simple?playfromepg=1&starttimestamp='
command += str(nextProgramme["start"])
command += '&channelname='
command += str(nextProgramme["channelName"])
command += ')'
self.logDbg('command: '+command)
xbmc.executebuiltin(command)
else:
position = timestampNow - int(nextProgramme['start'])
length = int(nextProgramme['end']) - int(nextProgramme['start'])
lengthMin = length / 60
positionMinutes = position / 60
positionPercent = 10000 * position / length * 0.01
question = 'Do you want to switch to the currently playing programme on '+nextProgramme["channelName"]+': '+nextProgramme["title"] + ' (' + str(positionMinutes) + ' / ' + str(lengthMin) + ' min [' + str(positionPercent) + '%])?'
response = xbmcgui.Dialog().yesno(_scriptname_, question, yeslabel='Yes', nolabel='No')
if response:
payload = {
"jsonrpc": "2.0",
"id":"1",
"method": "PVR.GetChannels",
"params": {
"channelgroupid": "alltv"
}
}
payloadJson = json.dumps(payload)
jsonResponse = xbmc.executeJSONRPC(payloadJson)
if jsonResponse:
response = json.loads(jsonResponse)
channelID = None
if "result" in response and "channels" in response["result"]:
channels = response["result"]["channels"]
for channel in channels:
if channel["label"] == nextProgramme["channelName"]:
channelID = channel["channelid"]
break
if not channelID and channelID != 0:
self.logErr("Could not find the channel's ID")
self.logDbg('channelName: '+nextProgramme["channelName"])
self.logDbg('channels: '+jsonResponse)
else:
payload = {
"jsonrpc": "2.0",
"id":"1",
"method": "Player.Open",
"params": {
"item":{
"channelid": channelID
}
}
}
payloadJson = json.dumps(payload)
jsonResponse = xbmc.executeJSONRPC(payloadJson)
if jsonResponse:
responseDecoded = json.loads(jsonResponse)
if "error" in responseDecoded:
if "message" in responseDecoded["error"]:
self.logErr("Could not play "+nextProgramme["channelKey"]+": "+responseDecoded["error"]["message"])
else:
self.logErr("Could not play "+nextProgramme["channelKey"])
self.logDbg('payloadJson: '+payloadJson)
self.logDbg('jsonResponse: '+jsonResponse)
else:
self.logErr("Could not play "+nextProgramme["channelKey"]+": No response from JSONRPC")
self.logDbg('payloadJson: '+payloadJson)
self.logDbg('jsonResponse: '+jsonResponse)
_db_.setIsNextProgrammeUsed()
_db_.closeDB()
def get_kodi_json(method, params):
json_query = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "%s", "params": %s, "id": 1}' % (method, params))
json_query = unicode(json_query, 'utf-8', errors='ignore')
return simplejson.loads(json_query)
def getMovieLibrary():
try:
if common.getXBMCVersion() >= 12.0:
properties = [
'year', 'imdbnumber', 'thumbnail', 'plot', 'dateadded',
'rating'
]
else:
properties = ['year', 'imdbnumber', 'thumbnail', 'plot', 'rating']
except:
properties = ['year', 'imdbnumber', 'thumbnail', 'plot', 'rating']
rpccmd = json.dumps({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetMovies',
'params': {
'properties': properties,
"sort": {
"order": "ascending",
"method": "label",
"ignorearticle": True
}
},
"id": "libMovies"
})
result = xbmc.executeJSONRPC(rpccmd)
result = json.loads(result)
if 'error' in result:
dialog = xbmcgui.Dialog()
ok = dialog.ok(plugin, settings.getLocalizedString(30018))
build_main_directory()
return
if (result['result']['limits']['total'] == 0):
dialog = xbmcgui.Dialog()
ok = dialog.ok(plugin, settings.getLocalizedString(30016))
build_main_directory()
return
totalItems = len(result['result']['movies'])
for movie in result['result']['movies']:
label = movie['label'].encode('ascii', 'ignore')
plot = movie['plot'].encode('ascii', 'ignore')
if 'dateadded' in movie:
day = movie['dateadded'].split(' ')[0].split('-')
date = day[2] + '.' + day[1] + '.' + day[0]
else:
date = '0000.00.00'
thumbnail = movie['thumbnail']
year = movie['thumbnail']
url = movie['imdbnumber'].rsplit('tt')
if len(url) == 2:
url = url[1]
else:
url = '1'
listitem = xbmcgui.ListItem(label=label,
iconImage=thumbnail,
thumbnailImage=thumbnail)
u = {'mode': '8', 'name': label, 'url': url}
cm = []
run = sys.argv[0] + '?' + urllib.urlencode({
'mode': '8',
'name': label,
'url': url,
'download': 'True'
})
cm.append(
(settings.getLocalizedString(30059), "XBMC.RunPlugin(%s)" % run))
infoLabels = {
"Title": label,
"Plot": plot,
"date": date,
"Year": movie['year'],
"Rating": movie['rating']
}
addListItem(label=label,
image=thumbnail,
url=u,
isFolder=False,
totalItems=totalItems,
infoLabels=infoLabels,
cm=cm)
xbmcplugin.addSortMethod(handle=int(sys.argv[1]),
sortMethod=xbmcplugin.SORT_METHOD_TITLE)
xbmcplugin.addSortMethod(handle=int(sys.argv[1]),
sortMethod=xbmcplugin.SORT_METHOD_DATE)
xbmcplugin.addSortMethod(handle=int(sys.argv[1]),
sortMethod=xbmcplugin.SORT_METHOD_VIDEO_YEAR)
xbmcplugin.addSortMethod(handle=int(sys.argv[1]),
sortMethod=xbmcplugin.SORT_METHOD_VIDEO_RATING)
setViewMode("500", "movies")
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def playVid(id,
filename=None,
season=None,
episode=None,
show=None,
folder=None,
type=''):
import time
import json
#Check if its PseudoTV that's playing this file, if so, we shouldn't do anything else than play the video
if xbmcgui.Window(10000).getProperty('PseudoTVRunning') == 'True':
dev.log('PseudoTV is running, so just play the video')
return playYoutubeVid(id)
#Prepare the information
loadingTime = time.time()
totalTime = 0
currentTime = 0
folderPath = xbmc.getInfoLabel('Container.FolderPath')
name = filename
filename = filename + '.strm'
filename = filename.translate(None, '\/:*?"<>|').strip('.')
#Grab the metadata of this episode
if type == 'movies':
#meta = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": {"filter":{"field": "studio", "operator": "is", "value": "Youtube"}, "properties": ["title", "runtime", "rating", "director", "writer", "plot", "thumbnail", "file"]}, "id": 1}' % (filename))
query = '{"jsonrpc": "2.0", "params": {"sort": {"order": "ascending", "method": "title"}, "filter": {"operator": "contains", "field": "path", "value": "%s"}, "properties": ["title", "art", "file", "thumbnail", "runtime", "rating", "plot"]}, "method": "VideoLibrary.GetMovies", "id": "libMovies"}' % (
folder)
dev.log('trying meta query now: ' + query)
meta = xbmc.executeJSONRPC(query)
else:
meta = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"filter":{"and": [{"field": "season", "operator": "is", "value": "%s"}, {"field": "episode", "operator": "is", "value": "%s"}]}, "properties": ["title", "season", "episode", "showtitle", "firstaired", "runtime", "rating", "director", "writer", "plot", "thumbnail", "file"]}, "id": 1}'
% (season, episode))
meta = unicode(meta, 'utf-8', errors='ignore')
dev.log('Meta: ' + meta)
if 'episodes' in json.loads(meta)['result'] or 'movies' in json.loads(
meta)['result']:
if type == 'movies':
meta = json.loads(meta)['result']['movies']
else:
meta = json.loads(meta)['result']['episodes']
for i in meta:
dev.log('Meta: ' + i['file'].encode('utf8'))
dev.log('Looking for :' + filename)
dev.log('File :' + i['file'])
i['file'] = i['file'].encode('utf-8')
if i['file'].endswith(filename):
dev.log('Found the episode we are looking for')
meta = i
break
if type == 'movies':
DBID = meta['movieid']
thumb = meta['thumbnail']
meta = {
'title': meta['title'].encode('utf-8'),
'duration': meta['runtime'],
'rating': meta['rating'],
'plot': meta['plot'].encode('utf-8')
}
poster = 'Default.png'
#poster = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": {"filter": {"field": "title", "operator": "is", "value": "%s"}, "properties": ["thumbnail"]}, "id": 1}' % showtitle.encode('utf-8'))
#poster = unicode(poster, 'utf-8', errors='ignore')
#poster = json.loads(poster)['result']['tvshows'][0]['thumbnail']
else:
DBID = meta['episodeid']
thumb = meta['thumbnail']
showtitle = meta['showtitle']
meta = {
'title': meta['title'].encode('utf-8'),
'season': meta['season'],
'episode': meta['episode'],
'tvshowtitle': meta['showtitle'].encode('utf-8'),
'premiered': meta['firstaired'].encode('utf-8'),
'duration': meta['runtime'],
'rating': meta['rating'],
'director': str(' / '.join(meta['director']).encode('utf-8')),
'writer': str(' / '.join(meta['writer']).encode('utf-8')),
'plot': meta['plot'].encode('utf-8')
}
poster = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": {"filter": {"field": "title", "operator": "is", "value": "%s"}, "properties": ["thumbnail"]}, "id": 1}'
% showtitle.encode('utf-8'))
poster = unicode(poster, 'utf-8', errors='ignore')
poster = json.loads(poster)['result']['tvshows'][0]['thumbnail']
#If resume playback is set in the settings, display a resume menu
try:
if xbmcaddon.Addon().getSetting('resume_playback') == 'true':
dev.log('Resume Playback is turned on. Grab resume point..')
offset = bookmarks.getBookmark(name)
dev.log('Offset is %s' % offset)
if offset == '0': raise Exception()
dev.log('Grabbing minutes and seconds')
minutes, seconds = divmod(float(offset), 60)
hours, minutes = divmod(minutes, 60)
dev.log('Showing yesno. Minutes: %s, seconds: %s' %
(minutes, seconds))
#yes = yesnoDialog('%s %02d:%02d:%02d' % ('Resume from ', hours, minutes, seconds), '', '', self.name, 'Resume', 'Start From Beginning')
yes = xbmcgui.Dialog().yesno(
'Resume',
'%s %02d:%02d:%02d' %
('Resume from ', hours, minutes, seconds),
nolabel='Resume',
yeslabel='Start From Beginning')
dev.log('Chose option: %s' % yes)
if yes: offset = '0'
except:
pass
#Play the youtube video with the meta data just acquired
playYoutubeVid(id, meta, poster)
else:
dev.log(
'Error: Could not retrieve meta information from the database!',
True)
return playYoutubeVid(
id
) #Just play the video, since we could not retrieve meta information
#Check if the video is still playing and store the time it is currently playing
for i in range(0, 300):
if xbmc.Player().isPlayingVideo():
#Set the offset of the video
try:
if offset == '0': raise Exception()
xbmc.Player().seekTime(float(offset))
except:
pass
break
xbmc.sleep(100)
while xbmc.Player().isPlayingVideo():
try:
totalTime = xbmc.Player().getTotalTime()
except:
pass
try:
currentTime = xbmc.Player().getTime()
except:
pass
xbmc.sleep(1000)
diff = currentTime / totalTime #Calculate how much of the video has been watched
#The video has stopped playing
dev.log('Ended Video Playback (%s) @ %s (percentage: %s)' %
(totalTime, currentTime, diff))
#Delete the previous bookmark where we were and store the new one
try:
bookmarks.deleteBookmark(name) #Delete the previous saved bookmark
dev.log('Deleted the previous bookmark')
ok = int(currentTime) > 120 and (
currentTime / totalTime
) <= .9 #Has the video been playing long enough and is it viewed less then 90%?
if ok:
bookmarks.addBookmark(currentTime, name) #Add the new bookmark
dev.log('Added new bookmark @ %s' % currentTime)
except:
pass
#Mark the episode as watched if enough was watched
ok = diff >= .9 #Did the episode get watched for 90% or more?
if int(currentTime) < 120:
ok = diff >= .75 #Since the runtime is very short, we'll accept a view through as 75%
if ok:
dev.log('Episode has been watched for %s, mark as watched' % diff)
bookmarks.mark_as_watched(DBID,
folderPath) #Mark the episode as watched
else:
dev.log('Episode has been watched for %s, dont mark as watched' % diff)
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2011-present Alex@ELEC (http://alexelec.in.ua)
import os, json
import xbmc, xbmcgui
kodi_json = {}
params = {}
params["setting"] = "input.libinputkeyboardlayout"
kodi_json["jsonrpc"] = "2.0"
kodi_json["method"] = "Settings.GetSettingValue"
kodi_json["params"] = params
kodi_json["id"] = 1
request = xbmc.executeJSONRPC(json.dumps(kodi_json).encode("utf-8"))
response = json.loads(request.decode('utf-8', 'replace'))
if 'result' in response:
kodi_json["method"] = "Settings.SetSettingValue"
params["setting"] = "input.libinputkeyboardlayout"
if response['result']['value'] == 'us':
params["value"] = "ru"
request = xbmc.executeJSONRPC(json.dumps(kodi_json).encode("utf-8"))
response = json.loads(request.decode('utf-8', 'replace'))
if response['result']:
xbmc.executebuiltin(
'Notification("Keybord", "set keyboard layout: Russian (RU)", 5000)'
)
else:
xbmc.executebuiltin(
# -*- coding: utf-8 -*-
import xbmc, xbmcaddon, xbmcplugin, xbmcgui
import sys, os, time, datetime, re, json
import urllib, urlparse
xbmcVer = xbmcaddon.Addon('xbmc.addon').getAddonInfo('version').split('.')
if int(xbmcVer[0]) > 16:
res = json.loads(xbmc.executeJSONRPC('{"jsonrpc":"2.0","method":"Addons.GetAddons","params":{"type":"kodi.inputstream","content":"unknown","enabled":false,"installed":true},"id":1}')).get('result', []).get('addons', [])
for item in res:
xbmc.executeJSONRPC('{{"jsonrpc": "2.0", "method":"Addons.SetAddonEnabled","params":{{"addonid":"{0}","enabled":true}}, "id": 1}}'.format(item['addonid']))
resolverID = 'script.module.israeliveresolver'
AddonID = "plugin.video.israelive"
Addon = xbmcaddon.Addon(AddonID)
if Addon.getSetting("unverifySSL") == "true":
try:
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
except:
pass
addonPath = xbmc.translatePath(Addon.getAddonInfo("path")).decode("utf-8")
libDir = os.path.join(addonPath, 'resources', 'lib')
sys.path.insert(0, libDir)
import common, myIPTV, checkUpdates, updateM3U
localizedString = Addon.getLocalizedString
AddonName = Addon.getAddonInfo("name")
icon = Addon.getAddonInfo('icon')
artDir = os.path.join(addonPath, 'resources', 'art')
__icon__ = os.path.join(artDir, "check2.png")
#!/usr/bin/env python
import xbmc
import json
jsonSWAT_Sel_Vol = '{"jsonrpc": "2.0", "method": "Application.GetProperties", "params": {"properties": ["volume"]}, "id": 1}'
jsonSWAT_Notify = '{"jsonrpc":"2.0","method":"GUI.ShowNotification","params":{"title":"Volume Level","message":"%s","image":"info"},"id":1}'
result = json.loads(xbmc.executeJSONRPC(jsonSWAT_Sel_Vol))['result']['volume']
print result
xbmc.executeJSONRPC(jsonSWAT_Notify % result)
def walk_Path(path, walked_files, progress):
log("walk_Path(" + path + ")")
if progress.iscanceled():
return
global dirCount
global fileCount
global filesFound
count_text = language(30105).format(str(dirCount), str(fileCount))
found_text = language(30107).format(str(filesFound))
hacked_path = language(30108).format(
unicode(path, 'utf-8', errors='replace'))
progress.update(0, count_text, found_text, hacked_path)
#time.sleep(5)
# double slash the \ in the path
path = path.replace("\\", "\\\\")
rpcCall = "{\"jsonrpc\": \"2.0\", \"method\": \"Files.GetDirectory\", \"params\": {\"directory\": \"" + path + "\"}, \"id\": 1}"
#log("rpcCall: " + rpcCall)
jsonResult = xbmc.executeJSONRPC(rpcCall)
#log("Files.GetDirectory results: " + jsonResult)
# json.loads expects utf-8 but the conversion using unicode breaks stuff
#jsonResult = unicode(jsonResult, 'utf-8', errors='ignore')
#set_files = json.loads(jsonResult)
set_files = []
try:
set_files = eval(jsonResult)
except:
log("Error Parsing GetDirectory() results : " + str(sys.exc_info()[0]))
return
if (len(set_files) == 0):
return
if (set_files.get('error') != None):
xbmcgui.Dialog().ok(language(30109), language(30110),
str(set_files.get('error')))
log("Error walking the source path: " + str(set_files.get('error')))
return
files = set_files['result']
#['files']
files = files.get('files')
if (files == None):
return
dirCount += 1
for file in files:
if progress.iscanceled():
return
if file['filetype'] == "directory":
walk_Path(file["file"], walked_files, progress)
elif file['filetype'] == "file":
fileCount += 1
if file_has_extensions(file["file"],
FILE_EXTENSIONS) and file_contains_forbiden(
file["file"]) == False:
filesFound += 1
log("WALKER ADDING FILE : " + file["file"])
file_name = file["file"]
#XBMC urlencodes the filename if it's in a .rar
if file_name.startswith('rar://'):
file_name = urllib.unquote(file_name)
walked_files.append(file_name)
def getJSON(method, params):
json_response = xbmc.executeJSONRPC(
'{ "jsonrpc": "2.0", "method" : "%s", "params": %s, "id":1 }' %
(method, try_encode(params)))
jsonobject = json.loads(json_response.decode('utf-8', 'replace'))
if (jsonobject.has_key('result')):
jsonobject = jsonobject['result']
if jsonobject.has_key('files'):
return jsonobject['files']
elif jsonobject.has_key('movies'):
return jsonobject['movies']
elif jsonobject.has_key('tvshows'):
return jsonobject['tvshows']
elif jsonobject.has_key('episodes'):
return jsonobject['episodes']
elif jsonobject.has_key('musicvideos'):
return jsonobject['musicvideos']
elif jsonobject.has_key('channels'):
return jsonobject['channels']
elif jsonobject.has_key('recordings'):
return jsonobject['recordings']
elif jsonobject.has_key('songs'):
return jsonobject['songs']
elif jsonobject.has_key('albums'):
return jsonobject['albums']
elif jsonobject.has_key('songdetails'):
return jsonobject['songdetails']
elif jsonobject.has_key('albumdetails'):
return jsonobject['albumdetails']
elif jsonobject.has_key('artistdetails'):
return jsonobject['artistdetails']
elif jsonobject.has_key('favourites'):
if jsonobject['favourites']:
return jsonobject['favourites']
else:
return {}
elif jsonobject.has_key('tvshowdetails'):
return jsonobject['tvshowdetails']
elif jsonobject.has_key('episodedetails'):
return jsonobject['episodedetails']
elif jsonobject.has_key('moviedetails'):
return jsonobject['moviedetails']
elif jsonobject.has_key('setdetails'):
return jsonobject['setdetails']
elif jsonobject.has_key('sets'):
return jsonobject['sets']
elif jsonobject.has_key('video'):
return jsonobject['video']
elif jsonobject.has_key('artists'):
return jsonobject['artists']
elif jsonobject.has_key('sources'):
if jsonobject['sources']:
return jsonobject['sources']
else:
return {}
elif jsonobject.has_key('addons'):
return jsonobject['addons']
else:
logMsg(
"getJson - invalid result for Method %s - params: %s - response: %s"
% (method, params, str(jsonobject)))
return {}
else:
logMsg(
"getJson - empty result for Method %s - params: %s - response: %s"
% (method, params, str(jsonobject)))
return {}
def get_library_files(type_of_scan):
library_files = []
media_files = []
#Movies
if type_of_scan == 1 or type_of_scan == 0:
jsonResult = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": {"properties": ["file", "trailer"]}, "id": 1}'
)
log("VideoLibrary.GetMovies results: " + jsonResult)
result = eval(jsonResult) #json.loads(jsonResult)
movies = result['result']
movies = movies.get('movies')
if (movies == None):
if type_of_scan == 1:
xbmcgui.Dialog().ok(language(30114), language(30115))
movies = []
for m in movies:
media_files.append(m['file'])
#try:
# trailer = m['trailer']
# if not trailer.startswith('http://'):
# media_files.append(clean_name(trailer))
#except KeyError:
# pass
#TV Shows
if type_of_scan == 2 or type_of_scan == 0:
jsonResult = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"properties": ["file"]}, "id": 1}'
)
log("VideoLibrary.GetEpisodes results: " + jsonResult)
result = eval(jsonResult) #json.loads(jsonResult)
tvshows = result['result']
tvshows = tvshows.get('episodes')
if (tvshows == None):
if type_of_scan == 2:
xbmcgui.Dialog().ok(language(30116), language(30117))
tvshows = []
for t in tvshows:
media_files.append(t['file'])
# add files from trailers and sets
for f in media_files:
if f.startswith("videodb://"):
rpcCall = "{\"jsonrpc\": \"2.0\", \"method\": \"Files.GetDirectory\", \"params\": {\"directory\": \"" + f + "\"}, \"id\": 1}"
rpc_result = xbmc.executeJSONRPC(rpcCall)
set_files = eval(rpc_result) #json.loads(rpc_result)
sub_files = []
sub_trailers = []
for item in set_files['result']['files']:
sub_files.append(clean_name(item['file']))
try:
trailer = item['trailer']
if not trailer.startswith('http://'):
library_files.append(clean_name(trailer))
except KeyError:
pass
library_files.extend(sub_files)
library_files.extend(sub_trailers)
elif f.startswith('stack://'):
f = f.replace('stack://', '')
f = f.replace(',,', '<ACTUALCOMMER>')
parts = f.split(' , ')
#parts = [ clean_name(f) for f in parts ]
for b in parts:
b = b.replace('<ACTUALCOMMER>', ',')
b = clean_name(b)
library_files.append(b)
else:
library_files.append(clean_name(f))
# all paths to lower case
#library_files = [ file_name.lower() for file_name in library_files ]
# make a set from the paths
library_files = set(library_files)
return library_files
def doScan(self, movieDir):
json_cmd = '{"jsonrpc":"2.0","method":"VideoLibrary.Scan", "params": {"directory":"%s/"},"id":1}' % movieDir.replace(
'\\', '/')
jsonRespond = xbmc.executeJSONRPC(json_cmd)
xbmc_port) + "/jsonrpc"
req = urllib2.Request(xbmc_json_rpc_url, data=jsontools.dump_json(payload), headers=headers)
f = urllib2.urlopen(req)
response = f.read()
f.close()
logger.info("get_data: response %s" % response)
data = jsontools.load_json(response)
except Exception, ex:
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.error("get_data: error en xbmc_json_rpc_url: %s" % message)
data = ["error"]
else:
try:
data = jsontools.load_json(xbmc.executeJSONRPC(jsontools.dump_json(payload)))
except Exception, ex:
template = "An exception of type {0} occured. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
logger.error("get_data:: error en xbmc.executeJSONRPC: {0}".
format(message))
data = ["error"]
logger.info("data: %s" % data)
return data
def update(folder_content=config.get_setting("folder_tvshows"), folder=""):
"""
Actualiza la libreria dependiendo del tipo de contenido y la ruta que se le pase.
def addToMenu(self, path, label, icon, content, window, DATA):
log(repr(window))
log(repr(label))
log(repr(path))
log(repr(content))
# Show a waiting dialog
dialog = xbmcgui.DialogProgress()
dialog.create(path, LANGUAGE(32063))
# Work out if it's a single item, or a node
isNode = False
jsonPath = path.replace("\\", "\\\\")
json_query = xbmc.executeJSONRPC(
'{ "jsonrpc": "2.0", "id": 0, "method": "Files.GetDirectory", "params": { "properties": ["title", "file", "thumbnail"], "directory": "'
+ jsonPath + '", "media": "files" } }')
json_query = unicode(json_query, 'utf-8', errors='ignore')
json_response = simplejson.loads(json_query)
labels = []
paths = []
nodePaths = []
# Add all directories returned by the json query
if 'result' in json_response and 'files' in json_response[
'result'] and json_response['result']['files'] is not None:
labels = [LANGUAGE(32058)]
paths = ["ActivateWindow(%s,%s,return)" % (window, path)]
for item in json_response['result']['files']:
if item["filetype"] == "directory":
isNode = True
labels.append(item["label"])
nodePaths.append("ActivateWindow(%s,%s,return)" %
(window, item["file"]))
else:
# Unable to add to get directory listings
log("Invalid JSON response returned")
log(repr(simplejson))
# And tell the user it failed
xbmcgui.Dialog().ok(ADDON.getAddonInfo("name"),
ADDON.getLocalizedString(32115))
return
# Add actions based on content
if content == "albums":
labels.append("Play")
paths.append(
"RunScript(script.skinshortcuts,type=launchalbum&album=%s)" %
(self.extractID(path)))
if window == 10002:
labels.append("Slideshow")
paths.append("SlideShow(%s,notrandom)" % (path))
labels.append("Slideshow (random)")
paths.append("SlideShow(%s,random)" % (path))
labels.append("Slideshow (recursive)")
paths.append("SlideShow(%s,recursive,notrandom)" % (path))
labels.append("Slideshow (recursive, random)")
paths.append("SlideShow(%s,recursive,random)" % (path))
if path.endswith(".xsp"):
labels.append("Play")
paths.append("PlayMedia(%s)" % (path))
allMenuItems = [xbmcgui.ListItem(label=LANGUAGE(32112))] # Main menu
allLabelIDs = ["mainmenu"]
if isNode:
allMenuItems.append(xbmcgui.ListItem(
label=LANGUAGE(32113))) # Main menu + autofill submenu
allLabelIDs.append("mainmenu")
# Get main menu items
menuitems = DATA._get_shortcuts("mainmenu", processShortcuts=False)
DATA._clear_labelID()
for menuitem in menuitems.findall("shortcut"):
# Get existing items labelID's
allMenuItems.append(
xbmcgui.ListItem(
label=DATA.local(menuitem.find("label").text)[2]))
listitem.setArt({'icon': menuitem.find("icon").text})
allLabelIDs.append(
DATA._get_labelID(
DATA.local(menuitem.find("label").text)[3],
menuitem.find("action").text))
# Close progress dialog
dialog.close()
# Show a select dialog so the user can pick where in the menu to add the item
w = ShowDialog("DialogSelect.xml",
CWD,
listing=allMenuItems,
windowtitle=LANGUAGE(32114))
w.doModal()
selectedMenu = w.result
del w
if selectedMenu == -1 or selectedMenu is None:
# User cancelled
return
action = paths[0]
if isNode and selectedMenu == 1:
# We're auto-filling submenu, so add all sub-nodes as possible default actions
paths = paths + nodePaths
if len(paths) > 1:
# There are multiple actions to choose from
selectedAction = xbmcgui.Dialog().select(LANGUAGE(32095), labels)
if selectedAction == -1 or selectedAction is None:
# User cancelled
return True
action = paths[selectedAction]
# Add the shortcut to the menu the user has selected
# Load existing main menu items
menuitems = DATA._get_shortcuts(allLabelIDs[selectedMenu],
processShortcuts=False)
DATA._clear_labelID()
# Generate a new labelID
newLabelID = DATA._get_labelID(label, action)
# Write the updated mainmenu.DATA.xml
newelement = xmltree.SubElement(menuitems.getroot(), "shortcut")
xmltree.SubElement(newelement, "label").text = label
xmltree.SubElement(newelement,
"label2").text = "32024" # Custom shortcut
xmltree.SubElement(newelement, "icon").text = icon
xmltree.SubElement(newelement, "thumb")
xmltree.SubElement(newelement, "action").text = action
DATA.indent(menuitems.getroot())
path = xbmc.translatePath(
os.path.join(
"special://profile", "addon_data", ADDONID, "%s.DATA.xml" %
(DATA.slugify(allLabelIDs[selectedMenu], True))))
menuitems.write(path, encoding="UTF-8")
if isNode and selectedMenu == 1:
# We're also going to write a submenu
menuitems = xmltree.ElementTree(xmltree.Element("shortcuts"))
for item in json_response['result']['files']:
if item["filetype"] == "directory":
newelement = xmltree.SubElement(menuitems.getroot(),
"shortcut")
xmltree.SubElement(newelement,
"label").text = item["label"]
xmltree.SubElement(
newelement, "label2").text = "32024" # Custom shortcut
xmltree.SubElement(newelement,
"icon").text = item["thumbnail"]
xmltree.SubElement(newelement, "thumb")
xmltree.SubElement(
newelement,
"action").text = "ActivateWindow(%s,%s,return)" % (
window, item["file"])
DATA.indent(menuitems.getroot())
path = xbmc.translatePath(
os.path.join("special://profile", "addon_data", ADDONID,
DATA.slugify(newLabelID, True) + ".DATA.xml"))
menuitems.write(path, encoding="UTF-8")
# Mark that the menu needs to be rebuilt
xbmcgui.Window(10000).setProperty("skinshortcuts-reloadmainmenu",
"True")
# And tell the user it all worked
xbmcgui.Dialog().ok(ADDON.getAddonInfo("name"), LANGUAGE(32090))
def GetSimilarFromOwnLibrary(dbid):
movies = []
# # if xbmcvfs.exists(filename) and time.time() - os.path.getmtime(filename) < 1:
# return read_from_file(filename)
if True:
json_query = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovieDetails", "params": {"properties": ["genre","director","country","year","mpaa"], "movieid":%s }, "id": 1}'
% dbid)
json_query = unicode(json_query, 'utf-8', errors='ignore')
json_response = simplejson.loads(json_query)
if "moviedetails" in json_response['result']:
id = json_response['result']['moviedetails']['movieid']
genres = json_response['result']['moviedetails']['genre']
year = int(json_response['result']['moviedetails']['year'])
countries = json_response['result']['moviedetails']['country']
directors = json_response['result']['moviedetails']['director']
mpaa = json_response['result']['moviedetails']['mpaa']
json_query = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": {"properties": ["genre","director","mpaa","country","year"], "sort": { "method": "random" } }, "id": 1}'
)
json_query = unicode(json_query, 'utf-8', errors='ignore')
json_query = simplejson.loads(json_query)
if "movies" in json_query['result']:
quotalist = []
for item in json_query['result']['movies']:
difference = int(item['year']) - year
hit = 0.0
miss = 0.0
quota = 0.0
for genre in genres:
if genre in item['genre']:
hit += 1.0
else:
miss += 1.0
miss += 0.00001
if hit > 0.0:
quota = float(hit) / float(hit + miss)
if genres[0] == item['genre'][0]:
quota += 0.3
if difference < 6 and difference > -6:
quota += 0.15
if difference < 3 and difference > -3:
quota += 0.15
if countries[0] == item['country'][0]:
quota += 0.4
if mpaa == item['mpaa']:
quota += 0.4
if directors[0] == item['director'][0]:
quota += 0.6
quotalist.append((quota, item["movieid"]))
if True:
quotalist = sorted(quotalist,
key=lambda quota: quota[0],
reverse=True)
count = 1
for list_movie in quotalist:
if id <> list_movie[1]:
json_query = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovieDetails", "params": {"properties": ["imdbnumber","genre","year", "art", "rating"], "movieid":%s }, "id": 1}'
% str(list_movie[1]))
json_query = unicode(json_query,
'utf-8',
errors='ignore')
json_response = simplejson.loads(json_query)
movie = json_response["result"]["moviedetails"]
newmovie = {
'Art(fanart)': movie["art"].get('fanart', ""),
'Art(poster)': movie["art"].get('poster', ""),
'Title': movie.get('label', ""),
'OriginalTitle':
movie.get('originaltitle', ""),
'ID': movie.get('imdbnumber', ""),
'Path': "",
'Play': "",
'DBID': "",
'Rating': str(round(float(movie['rating']),
1)),
'Premiered': movie.get('year', "")
}
movies.append(newmovie)
count += 1
if count > 20:
break
return movies