def run(self):
startup_delay = utilities.getSettingAsInt('startup_delay')
if startup_delay:
utilities.Debug("Delaying startup by %d seconds." % startup_delay)
xbmc.sleep(startup_delay * 1000)
utilities.Debug("Service thread starting.")
# setup event driven classes
self.Player = traktPlayer(action=self._dispatchQueue)
self.Monitor = traktMonitor(action=self._dispatchQueue)
# init traktapi class
globals.traktapi = traktAPI()
# init sync thread
self.syncThread = syncThread()
# init scrobbler class
self.scrobbler = Scrobbler(globals.traktapi)
# init tagging class
self.tagger = Tagger(globals.traktapi)
# purge queue
self.dispatchQueue.purge()
# start loop for events
while (not xbmc.abortRequested):
while len(self.dispatchQueue) and (not xbmc.abortRequested):
data = self.dispatchQueue.get()
utilities.Debug("Queued dispatch: %s" % data)
self._dispatch(data)
if xbmc.Player().isPlayingVideo():
self.scrobbler.update()
xbmc.sleep(500)
# we are shutting down
utilities.Debug("Beginning shut down.")
# check if watcher is set and active, if so, cancel it.
if self.watcher:
if self.watcher.isAlive():
self.watcher.cancel()
# delete player/monitor
del self.Player
del self.Monitor
# check update tags thread.
if self.updateTagsThread and self.updateTagsThread.isAlive():
self.updateTagsThread.join()
# check if sync thread is running, if so, join it.
if self.syncThread.isAlive():
self.syncThread.join()
def __rateOnTrakt(rating, media_type, media, unrate=False):
utils.Debug("[Rating] Sending rating (%s) to trakt.tv" % rating)
params = {}
if utils.isMovie(media_type):
params = media
params['rating'] = rating
root = {}
listing = [params]
root['movies'] = listing
elif utils.isShow(media_type):
params['rating'] = rating
params['title'] = media['title']
params['year'] = media['year']
params['ids'] = {}
params['ids']['tmdb'] = media['ids']['tmdb']
params['ids']['imdb'] = media['ids']['imdb']
params['ids']['tvdb'] = media['ids']['tvdb']
root = {}
listing = [params]
root['shows'] = listing
elif utils.isEpisode(media_type):
params = media
params['rating'] = rating
root = {}
listing = [params]
root['episodes'] = listing
else:
return
if not unrate:
data = globals.traktapi.addRating(root)
else:
data = globals.traktapi.removeRating(root)
if data:
utils.Debug("data rate: %s" % data)
s = utils.getFormattedItemName(media_type, media)
if 'not_found' in data and not data['not_found']['movies'] and not data[
'not_found']['episodes'] and not data['not_found']['shows']:
if not unrate:
utils.notification(utils.getString(1350), s)
else:
utils.notification(utils.getString(1352), s)
else:
utils.notification(utils.getString(1354), s)
def onPlayBackSeek(self, time, offset):
if self._playing:
utilities.Debug(
"[traktPlayer] onPlayBackSeek(time: %s, offset: %s) - %s" %
(str(time), str(offset), self.isPlayingVideo()))
data = {'action': 'seek', 'time': time, 'offset': offset}
self.action(data)
def onPlayBackSeekChapter(self, chapter):
if self._playing:
utilities.Debug(
"[traktPlayer] onPlayBackSeekChapter(chapter: %s) - %s" %
(str(chapter), self.isPlayingVideo()))
data = {'action': 'seekchapter', 'chapter': chapter}
self.action(data)
def onPlayBackStopped(self):
if self._playing:
utilities.Debug("[traktPlayer] onPlayBackStopped() - %s" % self.isPlayingVideo())
self._playing = False
self.plIndex = None
data = {'action': 'stopped'}
self.action(data)
def watchlistTagCheck(self):
if not utilities.isMovie(self.curVideo['type']):
return
if not 'id' in self.curVideo:
return
if not (tagging.isTaggingEnabled() and tagging.isWatchlistsEnabled()):
return
id = self.curVideo['id']
result = utilities.getMovieDetailsFromXbmc(id, ['tag'])
if result:
tags = result['tag']
if tagging.hasTraktWatchlistTag(tags):
tags.remove(tagging.listToTag("Watchlist"))
s = utilities.getFormattedItemName(self.curVideo['type'],
self.curVideoInfo)
tagging.xbmcSetTags(id, self.curVideo['type'], s, tags)
else:
utilities.Debug(
"No data was returned from XBMC, aborting tag udpate.")
def onDatabaseScanStarted(self, database):
if database == "video":
utilities.Debug(
"[traktMonitor] onDatabaseScanStarted(database: %s)" %
database)
data = {'action': 'scanStarted'}
self.action(data)
def ratingCheck(media_type, summary_info, watched_time, total_time, playlist_length):
"""Check if a video should be rated and if so launches the rating dialog"""
utils.Debug("[Rating] Rating Check called for '%s'" % media_type);
if not utils.getSettingAsBool("rate_%s" % media_type):
utils.Debug("[Rating] '%s' is configured to not be rated." % media_type)
return
if summary_info is None:
utils.Debug("[Rating] Summary information is empty, aborting.")
return
watched = (watched_time / total_time) * 100
if watched >= utils.getSettingAsFloat("rate_min_view_time"):
if (playlist_length <= 1) or utils.getSettingAsBool("rate_each_playlist_item"):
rateMedia(media_type, summary_info)
else:
utils.Debug("[Rating] Rate each playlist item is disabled.")
else:
utils.Debug("[Rating] '%s' does not meet minimum view time for rating (watched: %0.2f%%, minimum: %0.2f%%)" % (media_type, watched, utils.getSettingAsFloat("rate_min_view_time")))
def __init__(self):
self.path = xbmc.translatePath(
__addon__.getAddonInfo("profile")).decode("utf-8")
if not xbmcvfs.exists(self.path):
utils.Debug("Making path structure: " + repr(self.path))
xbmcvfs.mkdir(self.path)
self.path = os.path.join(self.path, 'queue.db')
self._connection_cache = {}
with self._get_conn() as conn:
conn.execute(self._create)
def _dispatch(self, data):
try:
utilities.Debug("Dispatch: %s" % data)
action = data['action']
if action == 'started':
del data['action']
self.scrobbler.playbackStarted(data)
elif action == 'ended' or action == 'stopped':
self.scrobbler.playbackEnded()
elif action == 'paused':
self.scrobbler.playbackPaused()
elif action == 'resumed':
self.scrobbler.playbackResumed()
elif action == 'seek' or action == 'seekchapter':
self.scrobbler.playbackSeek()
elif action == 'databaseUpdated':
if utilities.getSettingAsBool('sync_on_update'):
utilities.Debug("Performing sync after library update.")
self.doSync()
elif action == 'databaseCleaned':
if utilities.getSettingAsBool('sync_on_update') and (utilities.getSettingAsBool('clean_trakt_movies') or utilities.getSettingAsBool('clean_trakt_episodes')):
utilities.Debug("Performing sync after library clean.")
self.doSync()
elif action == 'settingsChanged':
utilities.Debug("Settings changed, reloading.")
globals.traktapi.updateSettings()
elif action == 'markWatched':
del data['action']
self.doMarkWatched(data)
elif action == 'manualRating':
ratingData = data['ratingData']
self.doManualRating(ratingData)
elif action == 'manualSync':
if not self.syncThread.isAlive():
utilities.Debug("Performing a manual sync.")
self.doSync(manual=True, silent=data['silent'], library=data['library'])
else:
utilities.Debug("There already is a sync in progress.")
elif action == 'settings':
utilities.showSettings()
elif action == 'scanStarted':
pass
else:
utilities.Debug("Unknown dispatch action, '%s'." % action)
except Exception as ex:
template = (
"[TRAKT] EXCEPTION Thrown (PythonToCppException) : -->Python callback/script returned the following error<--\n"
" - NOTE: IGNORING THIS CAN LEAD TO MEMORY LEAKS!\n"
"Error Type: <type '{0}'>\n"
"Error Contents: {1!r}\n"
"{2}"
"-->End of Python script error report<--"
)
message = template.format(type(ex).__name__, ex.args, traceback.format_exc())
xbmc.log(message, level=xbmc.LOGDEBUG)
def doManualRating(self, data):
action = data['action']
media_type = data['media_type']
summaryInfo = None
if not utilities.isValidMediaType(media_type):
utilities.Debug(
"doManualRating(): Invalid media type '%s' passed for manual %s."
% (media_type, action))
return
if not data['action'] in ['rate', 'unrate']:
utilities.Debug("doManualRating(): Unknown action passed.")
return
if 'dbid' in data:
utilities.Debug(
"Getting data for manual %s of library '%s' with ID of '%s'" %
(action, media_type, data['dbid']))
elif 'remoteitd' in data:
if 'season' in data:
utilities.Debug(
"Getting data for manual %s of non-library '%s' S%02dE%02d, with ID of '%s'."
% (action, media_type, data['season'], data['episode'],
data['remoteid']))
else:
utilities.Debug(
"Getting data for manual %s of non-library '%s' with ID of '%s'"
% (action, media_type, data['remoteid']))
if utilities.isEpisode(media_type):
summaryInfo = globals.traktapi.getEpisodeSummary(
data['tvdb_id'], data['season'], data['episode'])
elif utilities.isShow(media_type):
summaryInfo = globals.traktapi.getShowSummary(data['imdbnumber'])
elif utilities.isMovie(media_type):
summaryInfo = globals.traktapi.getMovieSummary(data['imdbnumber'])
if not summaryInfo is None:
if utilities.isMovie(media_type) or utilities.isShow(media_type):
summaryInfo['xbmc_id'] = data['dbid']
if action == 'rate':
if not 'rating' in data:
rateMedia(media_type, summaryInfo)
else:
rateMedia(media_type, summaryInfo, rating=data['rating'])
elif action == 'unrate':
rateMedia(media_type, summaryInfo, unrate=True)
else:
utilities.Debug(
"doManualRating(): Summary info was empty, possible problem retrieving data from trakt.tv"
)
def _dispatch(self, data):
utilities.Debug("Dispatch: %s" % data)
action = data['action']
if action == 'started':
del data['action']
self.scrobbler.playbackStarted(data)
elif action == 'ended' or action == 'stopped':
self.scrobbler.playbackEnded()
elif action == 'paused':
self.scrobbler.playbackPaused()
elif action == 'resumed':
self.scrobbler.playbackResumed()
elif action == 'seek' or action == 'seekchapter':
self.scrobbler.playbackSeek()
elif action == 'databaseUpdated':
if utilities.getSettingAsBool('sync_on_update'):
utilities.Debug("Performing sync after library update.")
self.doSync()
elif action == 'settingsChanged':
utilities.Debug("Settings changed, reloading.")
globals.traktapi.updateSettings()
elif action == 'markWatched':
del data['action']
self.doMarkWatched(data)
elif action == 'manualRating':
ratingData = data['ratingData']
self.doManualRating(ratingData)
elif action == 'manualSync':
if not self.syncThread.isAlive():
utilities.Debug("Performing a manual sync.")
self.doSync(manual=True,
silent=data['silent'],
library=data['library'])
else:
utilities.Debug("There already is a sync in progress.")
elif action == 'settings':
utilities.showSettings()
elif action == 'scanStarted':
pass
else:
utilities.Debug("Unknown dispatch action, '%s'." % action)
# -*- coding: utf-8 -*-
#
import xbmcaddon
import utilities
from service import traktService
__addon__ = xbmcaddon.Addon('script.trakt')
__addonversion__ = __addon__.getAddonInfo('version')
__addonid__ = __addon__.getAddonInfo('id')
utilities.Debug("Loading '%s' version '%s'" % (__addonid__, __addonversion__))
traktService().run()
utilities.Debug("'%s' shutting down." % __addonid__)
def Main():
args = __getArguments()
data = {}
if args['action'] == 'sync':
data = {'action': 'manualSync', 'silent': False}
if 'silent' in args:
data['silent'] = (args['silent'].lower() == 'true')
data['library'] = "all"
if 'library' in args and args['library'] in ['episodes', 'movies']:
data['library'] = args['library']
elif args['action'] in ['rate', 'unrate']:
data = {'action': args['action']}
media_type = None
if 'media_type' in args and 'dbid' in args:
media_type = args['media_type']
try:
data['dbid'] = int(args['dbid'])
except ValueError:
utils.Debug(
"Manual %s triggered for library item, but DBID is invalid."
% args['action'])
return
elif 'media_type' in args and 'remoteid' in args:
media_type = args['media_type']
data['remoteid'] = args['remoteid']
if 'season' in args:
if not 'episode' in args:
utils.Debug(
"Manual %s triggered for non-library episode, but missing episode number."
% args['action'])
return
try:
data['season'] = int(args['season'])
data['episode'] = int(args['episode'])
except ValueError:
utils.Debug(
"Error parsing season or episode for manual %s" %
args['action'])
return
else:
media_type = __getMediaType()
if not utils.isValidMediaType(media_type):
utils.Debug("Error, not in video library.")
return
data['dbid'] = int(xbmc.getInfoLabel('ListItem.DBID'))
if media_type is None:
utils.Debug(
"Manual %s triggered on an unsupported content container." %
args['action'])
elif utils.isValidMediaType(media_type):
data['media_type'] = media_type
if 'dbid' in data:
utils.Debug("Manual %s of library '%s' with an ID of '%s'." %
(args['action'], media_type, data['dbid']))
if utils.isMovie(media_type):
result = utils.getMovieDetailsFromKodi(
data['dbid'], ['imdbnumber', 'title', 'year'])
if not result:
utils.Debug(
"No data was returned from Kodi, aborting manual %s."
% args['action'])
return
data['imdbnumber'] = result['imdbnumber']
elif utils.isShow(media_type):
result = utils.getShowDetailsFromKodi(
data['dbid'], ['imdbnumber', 'tag'])
if not result:
utils.Debug(
"No data was returned from Kodi, aborting manual %s."
% args['action'])
return
data['imdbnumber'] = result['imdbnumber']
data['tag'] = result['tag']
elif utils.isEpisode(media_type):
result = utils.getEpisodeDetailsFromKodi(
data['dbid'],
['showtitle', 'season', 'episode', 'imdbnumber'])
if not result:
utils.Debug(
"No data was returned from Kodi, aborting manual %s."
% args['action'])
return
data['imdbnumber'] = result['imdbnumber']
data['season'] = result['season']
data['episode'] = result['episode']
else:
if 'season' in data:
utils.Debug(
"Manual %s of non-library '%s' S%02dE%02d, with an ID of '%s'."
% (args['action'], media_type, data['season'],
data['episode'], data['remoteid']))
data['imdbnumber'] = data['remoteid']
else:
utils.Debug(
"Manual %s of non-library '%s' with an ID of '%s'." %
(args['action'], media_type, data['remoteid']))
data['imdbnumber'] = data['remoteid']
if args['action'] == 'rate' and 'rating' in args:
if args['rating'] in [
'1', '2', '3', '4', '5', '6', '7', '8', '9', '10'
]:
data['rating'] = int(args['rating'])
data = {'action': 'manualRating', 'ratingData': data}
else:
utils.Debug("Manual %s of '%s' is unsupported." %
(args['action'], media_type))
elif args['action'] == 'togglewatched':
media_type = __getMediaType()
if media_type in ['movie', 'show', 'season', 'episode']:
data = {'media_type': media_type}
if utils.isMovie(media_type):
dbid = int(xbmc.getInfoLabel('ListItem.DBID'))
result = utils.getMovieDetailsFromKodi(
dbid, ['imdbnumber', 'title', 'year', 'playcount'])
if result:
if result['playcount'] == 0:
data['id'] = result['imdbnumber']
else:
utils.Debug("Movie alread marked as watched in Kodi.")
else:
utils.Debug("Error getting movie details from Kodi.")
return
elif utils.isEpisode(media_type):
dbid = int(xbmc.getInfoLabel('ListItem.DBID'))
result = utils.getEpisodeDetailsFromKodi(
dbid, [
'showtitle', 'season', 'episode', 'tvshowid',
'playcount'
])
if result:
if result['playcount'] == 0:
data['id'] = result['tvdb_id']
data['season'] = result['season']
data['episode'] = result['episode']
else:
utils.Debug(
"Episode already marked as watched in Kodi.")
else:
utils.Debug("Error getting episode details from Kodi.")
return
elif utils.isSeason(media_type):
showID = None
showTitle = xbmc.getInfoLabel('ListItem.TVShowTitle')
result = utils.kodiJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetTVShows',
'params': {
'properties': ['title', 'imdbnumber', 'year']
},
'id': 0
})
if result and 'tvshows' in result:
for show in result['tvshows']:
if show['title'] == showTitle:
showID = show['tvshowid']
data['id'] = show['imdbnumber']
break
else:
utils.Debug("Error getting TV shows from Kodi.")
return
season = xbmc.getInfoLabel('ListItem.Season')
if season == "":
season = 0
else:
season = int(season)
result = utils.kodiJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetEpisodes',
'params': {
'tvshowid': showID,
'season': season,
'properties': ['season', 'episode', 'playcount']
},
'id': 0
})
if result and 'episodes' in result:
episodes = []
for episode in result['episodes']:
if episode['playcount'] == 0:
episodes.append(episode['episode'])
if len(episodes) == 0:
utils.Debug(
"'%s - Season %d' is already marked as watched." %
(showTitle, season))
return
data['season'] = season
data['episodes'] = episodes
else:
utils.Debug(
"Error getting episodes from '%s' for Season %d" %
(showTitle, season))
return
elif utils.isShow(media_type):
dbid = int(xbmc.getInfoLabel('ListItem.DBID'))
result = utils.getShowDetailsFromKodi(dbid,
['year', 'imdbnumber'])
if not result:
utils.Debug("Error getting show details from Kodi.")
return
showTitle = result['label']
data['id'] = result['imdbnumber']
result = utils.kodiJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetEpisodes',
'params': {
'tvshowid': dbid,
'properties': ['season', 'episode', 'playcount']
},
'id': 0
})
if result and 'episodes' in result:
i = 0
s = {}
for e in result['episodes']:
season = str(e['season'])
if not season in s:
s[season] = []
if e['playcount'] == 0:
s[season].append(e['episode'])
i += 1
if i == 0:
utils.Debug("'%s' is already marked as watched." %
showTitle)
return
data['seasons'] = dict(
(k, v) for k, v in s.iteritems() if v)
else:
utils.Debug(
"Error getting episode details for '%s' from Kodi." %
showTitle)
return
if len(data) > 1:
utils.Debug(
"Marking '%s' with the following data '%s' as watched on trakt.tv"
% (media_type, str(data)))
data['action'] = 'markWatched'
# execute toggle watched action
xbmc.executebuiltin("Action(ToggleWatched)")
q = sqliteQueue.SqliteQueue()
if 'action' in data:
utils.Debug("Queuing for dispatch: %s" % data)
q.append(data)
def Main():
args = getArguments()
data = {}
if args['action'] == 'sync':
data = {'action': 'manualSync'}
elif args['action'] in ['rate', 'unrate']:
data = {}
data['action'] = args['action']
media_type = None
if 'media_type' in args and 'dbid' in args:
media_type = args['media_type']
try:
data['dbid'] = int(args['dbid'])
except ValueError:
utils.Debug(
"Manual %s triggered for library item, but DBID is invalid."
% args['action'])
return
elif 'media_type' in args and 'remoteid' in args:
media_type = args['media_type']
data['remoteid'] = args['remoteid']
if 'season' in args:
if not 'episode' in args:
utils.Debug(
"Manual %s triggered for non-library episode, but missing episode number."
% args['action'])
return
try:
data['season'] = int(args['season'])
data['episode'] = int(args['episode'])
except ValueError:
utilities.Debug(
"Error parsing season or episode for manual %s" %
args['action'])
return
else:
media_type = getMediaType()
if not utils.isValidMediaType(media_type):
utils.Debug("Error, not in video library.")
return
data['dbid'] = int(xbmc.getInfoLabel('ListItem.DBID'))
if media_type is None:
utils.Debug(
"Manual %s triggered on an unsupported content container." %
args['action'])
elif utils.isValidMediaType(media_type):
data['media_type'] = media_type
if 'dbid' in data:
utils.Debug("Manual %s of library '%s' with an ID of '%s'." %
(args['action'], media_type, data['dbid']))
if utils.isMovie(media_type):
result = utils.getMovieDetailsFromXbmc(
data['dbid'], ['imdbnumber', 'title', 'year'])
if not result:
utils.Debug(
"No data was returned from XBMC, aborting manual %s."
% args['action'])
return
data['imdbnumber'] = result['imdbnumber']
elif utils.isShow(media_type):
result = utils.getShowDetailsFromXBMC(
data['dbid'], ['imdbnumber', 'tag'])
if not result:
utils.Debug(
"No data was returned from XBMC, aborting manual %s."
% args['action'])
return
data['imdbnumber'] = result['imdbnumber']
data['tag'] = result['tag']
elif utils.isEpisode(media_type):
result = utils.getEpisodeDetailsFromXbmc(
data['dbid'],
['showtitle', 'season', 'episode', 'tvshowid'])
if not result:
utils.Debug(
"No data was returned from XBMC, aborting manual %s."
% args['action'])
return
data['tvdb_id'] = result['tvdb_id']
data['season'] = result['season']
data['episode'] = result['episode']
else:
if 'season' in data:
utils.Debug(
"Manual %s of non-library '%s' S%02dE%02d, with an ID of '%s'."
% (args['action'], media_type, data['season'],
data['episode'], data['remoteid']))
data['tvdb_id'] = data['remoteid']
else:
utils.Debug(
"Manual %s of non-library '%s' with an ID of '%s'." %
(args['action'], media_type, data['remoteid']))
data['imdbnumber'] = data['remoteid']
if args['action'] == 'rate' and 'rating' in args:
if args['rating'] in [
'1', '2', '3', '4', '5', '6', '7', '8', '9', '10'
]:
data['rating'] = int(args['rating'])
data = {'action': 'manualRating', 'ratingData': data}
else:
utils.Debug("Manual %s of '%s' is unsupported." %
(args['action'], media_type))
elif args['action'] == 'togglewatched':
media_type = getMediaType()
if media_type in ['movie', 'show', 'season', 'episode']:
data = {}
data['media_type'] = media_type
if utils.isMovie(media_type):
dbid = int(xbmc.getInfoLabel('ListItem.DBID'))
result = utils.getMovieDetailsFromXbmc(
dbid, ['imdbnumber', 'title', 'year', 'playcount'])
if result:
if result['playcount'] == 0:
data['id'] = result['imdbnumber']
else:
utils.Debug("Movie alread marked as watched in XBMC.")
else:
utils.Debug("Error getting movie details from XBMC.")
return
elif utils.isEpisode(media_type):
dbid = int(xbmc.getInfoLabel('ListItem.DBID'))
result = utils.getEpisodeDetailsFromXbmc(
dbid, [
'showtitle', 'season', 'episode', 'tvshowid',
'playcount'
])
if result:
if result['playcount'] == 0:
data['id'] = result['tvdb_id']
data['season'] = result['season']
data['episode'] = result['episode']
else:
utils.Debug(
"Episode already marked as watched in XBMC.")
else:
utils.Debug("Error getting episode details from XBMC.")
return
elif utils.isSeason(media_type):
showID = None
showTitle = xbmc.getInfoLabel('ListItem.TVShowTitle')
result = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetTVShows',
'params': {
'properties': ['title', 'imdbnumber', 'year']
},
'id': 0
})
if result and 'tvshows' in result:
for show in result['tvshows']:
if show['title'] == showTitle:
showID = show['tvshowid']
data['id'] = show['imdbnumber']
break
else:
utils.Debug("Error getting TV shows from XBMC.")
return
season = xbmc.getInfoLabel('ListItem.Season')
if season == "":
season = 0
else:
season = int(season)
result = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetEpisodes',
'params': {
'tvshowid': showID,
'season': season,
'properties': ['season', 'episode', 'playcount']
},
'id': 0
})
if result and 'episodes' in result:
episodes = []
for episode in result['episodes']:
if episode['playcount'] == 0:
episodes.append(episode['episode'])
if len(episodes) == 0:
utils.Debug(
"'%s - Season %d' is already marked as watched." %
(showTitle, season))
return
data['season'] = season
data['episodes'] = episodes
else:
utils.Debug(
"Error getting episodes from '%s' for Season %d" %
(showTitle, season))
return
elif utils.isShow(media_type):
dbid = int(xbmc.getInfoLabel('ListItem.DBID'))
result = utils.getShowDetailsFromXBMC(dbid,
['year', 'imdbnumber'])
if not result:
utils.Debug("Error getting show details from XBMC.")
return
showTitle = result['label']
data['id'] = result['imdbnumber']
result = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetEpisodes',
'params': {
'tvshowid': dbid,
'properties': ['season', 'episode', 'playcount']
},
'id': 0
})
if result and 'episodes' in result:
i = 0
s = {}
for e in result['episodes']:
season = str(e['season'])
if not season in s:
s[season] = []
if e['playcount'] == 0:
s[season].append(e['episode'])
i = i + 1
if i == 0:
utils.Debug("'%s' is already marked as watched." %
showTitle)
return
data['seasons'] = dict(
(k, v) for k, v in s.iteritems() if v)
else:
utils.Debug(
"Error getting episode details for '%s' from XBMC." %
showTitle)
return
if len(data) > 1:
utils.Debug(
"Marking '%s' with the following data '%s' as watched on trakt.tv"
% (media_type, str(data)))
data['action'] = 'markWatched'
# execute toggle watched action
xbmc.executebuiltin("Action(ToggleWatched)")
elif args['action'] == 'updatetags':
data = {'action': 'updatetags'}
elif args['action'] == 'managelists':
data = {'action': 'managelists'}
elif args['action'] == 'timertest':
utils.Debug("Timing JSON requests.")
import time
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetTVShowDetails',
'params': {
'tvshowid': 254,
'properties': ['tag']
},
'id': 1
})
#data = utils.getShowDetailsFromXBMC(254, ['tag', 'imdbnumber'])
e = time.time() - t
utils.Debug("VideoLibrary.GetTVShowDetails with tags: %0.3f seconds." %
e)
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetMovieDetails',
'params': {
'movieid': 634,
'properties': ['tag']
},
'id': 1
})
#data = utils.getMovieDetailsFromXbmc(634, ['tag', 'imdbnumber', 'title', 'year'])
e = time.time() - t
utils.Debug("VideoLibrary.GetMovieDetails with tags: %0.3f seconds." %
e)
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetTVShows',
'params': {
'properties': ['tag', 'title', 'imdbnumber', 'year']
},
'id': 0
})
e = time.time() - t
utils.Debug(
"VideoLibrary.GetTVShows with tags: %0.3f seconds, %d items at %0.5f seconds per item"
% (e, len(data['tvshows']), e / len(data['tvshows'])))
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'id': 0,
'method': 'VideoLibrary.GetMovies',
'params': {
'properties': ['tag', 'title', 'imdbnumber', 'year']
}
})
e = time.time() - t
utils.Debug(
"VideoLibrary.GetMovies with tags: %0.3f seconds, %d items at %0.5f seconds per item"
% (e, len(data['movies']), e / len(data['movies'])))
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetTVShows',
'params': {
'properties': ['title', 'imdbnumber', 'year']
},
'id': 0
})
e = time.time() - t
utils.Debug(
"VideoLibrary.GetTVShows without tags: %0.3f seconds, %d items at %0.5f seconds per item"
% (e, len(data['tvshows']), e / len(data['tvshows'])))
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'id': 0,
'method': 'VideoLibrary.GetMovies',
'params': {
'properties': ['title', 'imdbnumber', 'year']
}
})
e = time.time() - t
utils.Debug(
"VideoLibrary.GetMovies without tags: %0.3f seconds, %d items at %0.5f seconds per item"
% (e, len(data['movies']), e / len(data['movies'])))
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetTVShowDetails',
'params': {
'tvshowid': 254,
'properties': ['imdbnumber']
},
'id': 1
})
#data = utils.getShowDetailsFromXBMC(254, ['imdbnumber'])
e = time.time() - t
utils.Debug(
"VideoLibrary.GetTVShowDetails without tags: %0.3f seconds." % e)
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetMovieDetails',
'params': {
'movieid': 634,
'properties': ['imdbnumber', 'title', 'year']
},
'id': 1
})
#data = utils.getMovieDetailsFromXbmc(634, ['imdbnumber', 'title', 'year'])
e = time.time() - t
utils.Debug(
"VideoLibrary.GetMovieDetails without tags: %0.3f seconds." % e)
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetTVShows',
'params': {
'properties': ['title', 'imdbnumber', 'year']
},
'id': 0
})
data = data['tvshows']
for item in data:
item_data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetTVShowDetails',
'params': {
'tvshowid': item['tvshowid'],
'properties': ['tag']
},
'id': 1
})
item['tag'] = item_data['tvshowdetails']['tag']
e = time.time() - t
utils.Debug(
"VideoLibrary.GetTVShows with tags from loop: %0.3f seconds, %d items at %0.5f seconds per item"
% (e, len(data), e / len(data)))
t = time.time()
data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetMovies',
'params': {
'properties': ['title', 'imdbnumber', 'year']
},
'id': 0
})
data = data['movies']
for item in data:
item_data = utils.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetMovieDetails',
'params': {
'movieid': item['movieid'],
'properties': ['tag']
},
'id': 1
})
item['tag'] = item_data['moviedetails']['tag']
e = time.time() - t
utils.Debug(
"VideoLibrary.GetMovies with tags from: %0.3f seconds, %d items at %0.5f seconds per item."
% (e, len(data), e / len(data)))
elif args['action'] in ['itemlists', 'addtolist', 'removefromlist']:
data = {}
data['action'] = args['action']
media_type = None
dbid = None
if 'media_type' in args and 'dbid' in args:
media_type = args['media_type']
try:
dbid = int(args['dbid'])
except ValueError:
utils.Debug(
"'%s' triggered for library item, but DBID is invalid." %
args['action'])
return
else:
media_type = getMediaType()
if not media_type in ['movie', 'show']:
utils.Debug("Error, not in video library.")
return
try:
dbid = int(xbmc.getInfoLabel('ListItem.DBID'))
except ValueError:
utils.Debug(
"'%s' triggered for library item, but there is a problem with ListItem.DBID."
% args['action'])
return
if not media_type in ['movie', 'show']:
utils.Debug("'%s' is not a valid media type for '%s'." %
(media_type, args['action']))
return
if args['action'] in ['addtolist', 'removefromlist']:
if 'list' in args:
data['list'] = args['list']
else:
utils.Debug("'%s' requires a list parameter." % data['action'])
data['type'] = media_type
if utils.isMovie(media_type):
result = utils.getMovieDetailsFromXbmc(
dbid, ['imdbnumber', 'title', 'year', 'tag'])
if not result:
utils.Debug("Error getting movie details from XBMC.")
return
data['tag'] = result['tag']
data['movieid'] = result['movieid']
data['title'] = result['title']
data['year'] = result['year']
if result['imdbnumber'].startswith("tt"):
data['imdb_id'] = result['imdbnumber']
elif result['imdbnumber'].isdigit():
data['tmdb_id'] = result['imdbnumber']
elif utils.isShow(media_type):
result = utils.getShowDetailsFromXBMC(
dbid, ['imdbnumber', 'title', 'tag'])
if not result:
utils.Debug("Error getting show details from XBMC.")
return
data['tag'] = result['tag']
data['tvshowid'] = result['tvshowid']
data['title'] = result['title']
if result['imdbnumber'].startswith("tt"):
data['imdb_id'] = result['imdbnumber']
elif result['imdbnumber'].isdigit():
data['tvdb_id'] = result['imdbnumber']
q = queue.SqliteQueue()
if 'action' in data:
utils.Debug("Queuing for dispatch: %s" % data)
q.append(data)
def _dispatch(self, data):
utilities.Debug("Dispatch: %s" % data)
action = data['action']
if action == 'started':
del data['action']
self.scrobbler.playbackStarted(data)
elif action == 'ended' or action == 'stopped':
self.scrobbler.playbackEnded()
elif action == 'paused':
self.scrobbler.playbackPaused()
elif action == 'resumed':
self.scrobbler.playbackResumed()
elif action == 'seek' or action == 'seekchapter':
self.scrobbler.playbackSeek()
elif action == 'databaseUpdated':
if utilities.getSettingAsBool('sync_on_update'):
utilities.Debug("Performing sync after library update.")
self.doSync()
elif action == 'scanStarted':
pass
elif action == 'settingsChanged':
utilities.Debug("Settings changed, reloading.")
globals.traktapi.updateSettings()
self.tagger.updateSettings()
elif action == 'markWatched':
del data['action']
self.doMarkWatched(data)
elif action == 'manualRating':
ratingData = data['ratingData']
self.doManualRating(ratingData)
elif action == 'manualSync':
if not self.syncThread.isAlive():
utilities.Debug("Performing a manual sync.")
self.doSync(manual=True,
silent=data['silent'],
library=data['library'])
else:
utilities.Debug("There already is a sync in progress.")
elif action == 'updatetags':
if self.updateTagsThread and self.updateTagsThread.isAlive():
utilities.Debug("Currently updating tags already.")
else:
self.updateTagsThread = threading.Thread(
target=self.tagger.updateTagsFromTrakt,
name="trakt-updatetags")
self.updateTagsThread.start()
elif action == 'managelists':
self.tagger.manageLists()
elif action == 'itemlists':
del data['action']
self.tagger.itemLists(data)
elif action == 'addtolist':
del data['action']
list = data['list']
del data['list']
self.tagger.manualAddToList(list, data)
elif action == 'removefromlist':
del data['action']
list = data['list']
del data['list']
self.tagger.manualRemoveFromList(list, data)
elif action == 'loadsettings':
force = False
if 'force' in data:
force = data['force']
globals.traktapi.getAccountSettings(force)
elif action == 'settings':
utilisites.showSettings()
else:
utilities.Debug("Unknown dispatch action, '%s'." % action)
def onPlayBackSpeedChanged(self, speed):
if self._playing:
utilities.Debug(
"[traktPlayer] onPlayBackSpeedChanged(speed: %s) - %s" %
(str(speed), self.isPlayingVideo()))
def onQueueNextItem(self):
if self._playing:
utilities.Debug("[traktPlayer] onQueueNextItem() - %s" %
self.isPlayingVideo())
def onPlayBackResumed(self):
if self._playing:
utilities.Debug("[traktPlayer] onPlayBackResumed() - %s" %
self.isPlayingVideo())
data = {'action': 'resumed'}
self.action(data)
def rateOnTrakt(rating, media_type, media, unrate=False):
utils.Debug("[Rating] Sending rating (%s) to trakt.tv" % rating)
params = {}
params['rating'] = rating
if utils.isMovie(media_type):
params['title'] = media['title']
params['year'] = media['year']
params['tmdb_id'] = media['tmdb_id']
params['imdb_id'] = media['imdb_id']
data = globals.traktapi.rateMovie(params)
elif utils.isShow(media_type):
params['title'] = media['title']
params['year'] = media['year']
params['tvdb_id'] = media['tvdb_id']
params['imdb_id'] = media['imdb_id']
data = globals.traktapi.rateShow(params)
elif utils.isEpisode(media_type):
params['title'] = media['show']['title']
params['year'] = media['show']['year']
params['season'] = media['episode']['season']
params['episode'] = media['episode']['number']
params['tvdb_id'] = media['show']['tvdb_id']
params['imdb_id'] = media['show']['imdb_id']
data = globals.traktapi.rateEpisode(params)
else:
return
if data:
s = utils.getFormattedItemName(media_type, media)
if 'status' in data and data['status'] == "success":
if tagging.isTaggingEnabled() and tagging.isRatingsEnabled():
if utils.isMovie(media_type) or utils.isShow(media_type):
id = media['xbmc_id']
f = utils.getMovieDetailsFromXbmc if utils.isMovie(media_type) else utils.getShowDetailsFromXBMC
result = f(id, ['tag'])
if result:
tags = result['tag']
new_rating = rating
if new_rating == "love":
new_rating = 10
elif new_rating == "hate":
new_rating = 1
new_rating_tag = tagging.ratingToTag(new_rating)
if unrate:
new_rating_tag = ""
update = False
if tagging.hasTraktRatingTag(tags):
old_rating_tag = tagging.getTraktRatingTag(tags)
if not old_rating_tag == new_rating_tag:
tags.remove(old_rating_tag)
update = True
if not unrate and new_rating >= tagging.getMinRating():
tags.append(new_rating_tag)
update = True
if update:
tagging.xbmcSetTags(id, media_type, s, tags)
else:
utils.Debug("No data was returned from XBMC, aborting tag udpate.")
if not unrate:
utils.notification(utils.getString(1350), s)
else:
utils.notification(utils.getString(1352), s)
elif 'status' in data and data['status'] == "failure":
utils.notification(utils.getString(1354), s)
else:
# status not in data, different problem, do nothing for now
pass
def onDatabaseUpdated(self, database):
if database == 'video':
utilities.Debug("[traktMonitor] onDatabaseUpdated(database: %s)" %
database)
data = {'action': 'databaseUpdated'}
self.action(data)
def _dispatch(self, data):
utilities.Debug("Dispatch: %s" % data)
action = data['action']
if action == 'started':
del data['action']
self.scrobbler.playbackStarted(data)
self.watcher = threading.Timer(self._interval, self.doWatching)
self.watcher.name = "trakt-watching"
self.watcher.start()
elif action == 'ended' or action == 'stopped':
self.scrobbler.playbackEnded()
if self.watcher:
if self.watcher.isAlive():
self.watcher.cancel()
self.watcher = None
elif action == 'paused':
self.scrobbler.playbackPaused()
elif action == 'resumed':
self.scrobbler.playbackResumed()
elif action == 'seek' or action == 'seekchapter':
self.scrobbler.playbackSeek()
elif action == 'databaseUpdated':
self.doSync()
elif action == 'scanStarted':
pass
elif action == 'settingsChanged':
utilities.Debug("Settings changed, reloading.")
globals.traktapi.updateSettings()
self.tagger.updateSettings()
elif action == 'markWatched':
del data['action']
self.doMarkWatched(data)
elif action == 'manualRating':
ratingData = data['ratingData']
self.doManualRating(ratingData)
elif action == 'manualSync':
if not self.syncThread.isAlive():
utilities.Debug("Performing a manual sync.")
self.doSync(manual=True)
else:
utilities.Debug("There already is a sync in progress.")
elif action == 'updatetags':
if self.updateTagsThread and self.updateTagsThread.isAlive():
utilities.Debug("Currently updating tags already.")
else:
self.updateTagsThread = threading.Thread(
target=self.tagger.updateTagsFromTrakt,
name="trakt-updatetags")
self.updateTagsThread.start()
elif action == 'managelists':
self.tagger.manageLists()
elif action == 'itemlists':
del data['action']
self.tagger.itemLists(data)
elif action == 'addtolist':
del data['action']
list = data['list']
del data['list']
self.tagger.manualAddToList(list, data)
elif action == 'removefromlist':
del data['action']
list = data['list']
del data['list']
self.tagger.manualRemoveFromList(list, data)
else:
utilities.Debug("Unknown dispatch action, '%s'." % action)
def _dispatchQueue(self, data):
utilities.Debug("Queuing for dispatch: %s" % data)
self.dispatchQueue.append(data)
def doMarkWatched(self, data):
media_type = data['media_type']
simulate = utilities.getSettingAsBool('simulate_sync')
markedNotification = utilities.getSettingAsBool(
'show_marked_notification')
if utilities.isMovie(media_type):
summaryInfo = globals.traktapi.getMovieSummary(data['id'])
if summaryInfo:
if not summaryInfo['watched']:
s = utilities.getFormattedItemName(media_type, summaryInfo)
utilities.Debug(
"doMarkWatched(): '%s' is not watched on trakt, marking it as watched."
% s)
movie = {}
movie['imdb_id'] = data['id']
movie['title'] = summaryInfo['title']
movie['year'] = summaryInfo['year']
movie['plays'] = 1
movie['last_played'] = int(time())
params = {'movies': [movie]}
utilities.Debug("doMarkWatched(): %s" % str(params))
if not simulate:
result = globals.traktapi.updateSeenMovie(params)
if result:
if markedNotification:
utilities.notification(
utilities.getString(1550), s)
else:
utilities.notification(utilities.getString(1551),
s)
else:
if markedNotification:
utilities.notification(utilities.getString(1550),
s)
elif utilities.isEpisode(media_type):
summaryInfo = globals.traktapi.getEpisodeSummary(
data['id'], data['season'], data['episode'])
if summaryInfo:
if not summaryInfo['episode']['watched']:
s = utilities.getFormattedItemName(media_type, summaryInfo)
utilities.Debug(
"doMarkWathced(): '%s' is not watched on trakt, marking it as watched."
% s)
params = {}
params['imdb_id'] = summaryInfo['show']['imdb_id']
params['tvdb_id'] = summaryInfo['show']['tvdb_id']
params['title'] = summaryInfo['show']['title']
params['year'] = summaryInfo['show']['year']
params['episodes'] = [{
'season': data['season'],
'episode': data['episode']
}]
utilities.Debug("doMarkWatched(): %s" % str(params))
if not simulate:
result = globals.traktapi.updateSeenEpisode(params)
if result:
if markedNotification:
utilities.notification(
utilities.getString(1550), s)
else:
utilities.notification(utilities.getString(1551),
s)
else:
if markedNotification:
utilities.notification(utilities.getString(1550),
s)
elif utilities.isSeason(media_type):
showInfo = globals.traktapi.getShowSummary(data['id'])
if not showInfo:
return
summaryInfo = globals.traktapi.getSeasonInfo(
data['id'], data['season'])
if summaryInfo:
showInfo['season'] = data['season']
s = utilities.getFormattedItemName(media_type, showInfo)
params = {}
params['imdb_id'] = showInfo['imdb_id']
params['tvdb_id'] = showInfo['tvdb_id']
params['title'] = showInfo['title']
params['year'] = showInfo['year']
params['episodes'] = []
for ep in summaryInfo:
if ep['episode'] in data['episodes']:
if not ep['watched']:
params['episodes'].append({
'season': ep['season'],
'episode': ep['episode']
})
utilities.Debug(
"doMarkWatched(): '%s - Season %d' has %d episode(s) that are going to be marked as watched."
% (showInfo['title'], data['season'],
len(params['episodes'])))
if len(params['episodes']) > 0:
utilities.Debug("doMarkWatched(): %s" % str(params))
if not simulate:
result = globals.traktapi.updateSeenEpisode(params)
if result:
if markedNotification:
utilities.notification(
utilities.getString(1550),
utilities.getString(1552) %
(len(params['episodes']), s))
else:
utilities.notification(
utilities.getString(1551),
utilities.getString(1552) %
(len(params['episodes']), s))
else:
if markedNotification:
utilities.notification(
utilities.getString(1550),
utilities.getString(1552) %
(len(params['episodes']), s))
elif utilities.isShow(media_type):
summaryInfo = globals.traktapi.getShowSummary(data['id'],
extended=True)
if summaryInfo:
s = utilities.getFormattedItemName(media_type, summaryInfo)
params = {}
params['imdb_id'] = summaryInfo['imdb_id']
params['tvdb_id'] = summaryInfo['tvdb_id']
params['title'] = summaryInfo['title']
params['year'] = summaryInfo['year']
params['episodes'] = []
for season in summaryInfo['seasons']:
for ep in season['episodes']:
if str(season['season']) in data['seasons']:
if ep['episode'] in data['seasons'][str(
season['season'])]:
if not ep['watched']:
params['episodes'].append({
'season':
ep['season'],
'episode':
ep['episode']
})
utilities.Debug(
"doMarkWatched(): '%s' has %d episode(s) that are going to be marked as watched."
% (summaryInfo['title'], len(params['episodes'])))
if len(params['episodes']) > 0:
utilities.Debug("doMarkWatched(): %s" % str(params))
if not simulate:
result = globals.traktapi.updateSeenEpisode(params)
if result:
if markedNotification:
utilities.notification(
utilities.getString(1550),
utilities.getString(1552) %
(len(params['episodes']), s))
else:
utilities.notification(
utilities.getString(1551),
utilities.getString(1552) %
(len(params['episodes']), s))
else:
if markedNotification:
utilities.notification(
utilities.getString(1550),
utilities.getString(1552) %
(len(params['episodes']), s))
def __init__(self, *args, **kwargs):
xbmc.Player.__init__(self)
self.action = kwargs['action']
utilities.Debug("[traktPlayer] Initalized.")
def onPlayBackStarted(self):
xbmc.sleep(1000)
self.type = None
self.id = None
# only do anything if we're playing a video
if self.isPlayingVideo():
# get item data from json rpc
result = utilities.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'Player.GetItem',
'params': {
'playerid': 1
},
'id': 1
})
utilities.Debug("[traktPlayer] onPlayBackStarted() - %s" % result)
# check for exclusion
_filename = None
try:
_filename = self.getPlayingFile()
except:
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - Exception trying to get playing filename, player stopped suddently."
)
return
if utilities.checkScrobblingExclusion(_filename):
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - '%s' is in exclusion settings, ignoring."
% _filename)
return
self.type = result['item']['type']
data = {'action': 'started'}
# check type of item
if self.type == 'unknown':
# do a deeper check to see if we have enough data to perform scrobbles
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - Started playing a non-library file, checking available data."
)
season = xbmc.getInfoLabel('VideoPlayer.Season')
episode = xbmc.getInfoLabel('VideoPlayer.Episode')
showtitle = xbmc.getInfoLabel('VideoPlayer.TVShowTitle')
year = xbmc.getInfoLabel('VideoPlayer.Year')
if season and episode and showtitle:
# we have season, episode and show title, can scrobble this as an episode
self.type = 'episode'
data['type'] = 'episode'
data['season'] = int(season)
data['episode'] = int(episode)
data['showtitle'] = showtitle
data['title'] = xbmc.getInfoLabel('VideoPlayer.Title')
if year.isdigit():
data['year'] = year
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - Playing a non-library 'episode' - %s - S%02dE%02d - %s."
% (data['showtitle'], data['season'], data['episode'],
data['title']))
elif year and not season and not showtitle:
# we have a year and no season/showtitle info, enough for a movie
self.type = 'movie'
data['type'] = 'movie'
data['year'] = int(year)
data['title'] = xbmc.getInfoLabel('VideoPlayer.Title')
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - Playing a non-library 'movie' - %s (%d)."
% (data['title'], data['year']))
else:
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - Non-library file, not enough data for scrobbling, skipping."
)
return
elif self.type == 'episode' or self.type == 'movie':
# get library id
self.id = result['item']['id']
data['id'] = self.id
data['type'] = self.type
if self.type == 'episode':
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - Doing multi-part episode check."
)
result = utilities.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetEpisodeDetails',
'params': {
'episodeid': self.id,
'properties': ['tvshowid', 'season', 'episode']
},
'id': 1
})
if result:
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - %s" % result)
tvshowid = int(result['episodedetails']['tvshowid'])
season = int(result['episodedetails']['season'])
episode = int(result['episodedetails']['episode'])
episode_index = episode - 1
result = utilities.xbmcJsonRequest({
'jsonrpc': '2.0',
'method': 'VideoLibrary.GetEpisodes',
'params': {
'tvshowid': tvshowid,
'season': season,
'properties': ['episode', 'file'],
'sort': {
'method': 'episode'
}
},
'id': 1
})
if result:
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - %s" %
result)
# make sure episodes array exists in results
if 'episodes' in result:
multi = []
for i in range(episode_index,
result['limits']['total']):
if result['episodes'][i]['file'] == result[
'episodes'][episode_index]['file']:
multi.append(
result['episodes'][i]['episodeid'])
else:
break
if len(multi) > 1:
data['multi_episode_data'] = multi
data['multi_episode_count'] = len(multi)
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - This episode is part of a multi-part episode."
)
else:
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - This is a single episode."
)
else:
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - Video type '%s' unrecognized, skipping."
% self.type)
return
pl = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
plSize = len(pl)
if plSize > 1:
pos = pl.getposition()
if not self.plIndex is None:
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - User manually skipped to next (or previous) video, forcing playback ended event."
)
self.onPlayBackEnded()
self.plIndex = pos
utilities.Debug(
"[traktPlayer] onPlayBackStarted() - Playlist contains %d item(s), and is currently on item %d"
% (plSize, (pos + 1)))
self._playing = True
# send dispatch
self.action(data)
def rateMedia(media_type, summary_info, unrate=False, rating=None):
"""Launches the rating dialog"""
if not utils.isValidMediaType(media_type):
return
if utils.isEpisode(media_type):
if 'rating' in summary_info['episode']:
summary_info['rating'] = summary_info['episode']['rating']
if 'rating_advanced' in summary_info['episode']:
summary_info['rating_advanced'] = summary_info['episode']['rating_advanced']
s = utils.getFormattedItemName(media_type, summary_info)
if not globals.traktapi.settings:
globals.traktapi.getAccountSettings()
rating_type = globals.traktapi.settings['viewing']['ratings']['mode']
if unrate:
rating = None
if rating_type == "simple":
if not summary_info['rating'] == "false":
rating = "unrate"
else:
if summary_info['rating_advanced'] > 0:
rating = 0
if not rating is None:
utils.Debug("[Rating] '%s' is being unrated." % s)
rateOnTrakt(rating, media_type, summary_info, unrate=True)
else:
utils.Debug("[Rating] '%s' has not been rated, so not unrating." % s)
return
rerate = utils.getSettingAsBool('rate_rerate')
if not rating is None:
if summary_info['rating_advanced'] == 0:
utils.Debug("[Rating] Rating for '%s' is being set to '%d' manually." % (s, rating))
rateOnTrakt(rating, media_type, summary_info)
else:
if rerate:
if not summary_info['rating_advanced'] == rating:
utils.Debug("[Rating] Rating for '%s' is being set to '%d' manually." % (s, rating))
rateOnTrakt(rating, media_type, summary_info)
else:
utils.notification(utils.getString(1353), s)
utils.Debug("[Rating] '%s' already has a rating of '%d'." % (s, rating))
else:
utils.notification(utils.getString(1351), s)
utils.Debug("[Rating] '%s' is already rated." % s)
return
if summary_info['rating'] or summary_info['rating_advanced']:
if not rerate:
utils.Debug("[Rating] '%s' has already been rated." % s)
utils.notification(utils.getString(1351), s)
return
else:
utils.Debug("[Rating] '%s' is being re-rated." % s)
xbmc.executebuiltin('Dialog.Close(all, true)')
gui = RatingDialog(
"RatingDialog.xml",
__addon__.getAddonInfo('path'),
media_type=media_type,
media=summary_info,
rating_type=rating_type,
rerate=rerate
)
gui.doModal()
if gui.rating:
rating = gui.rating
if rerate:
rating = gui.rating
if rating_type == "simple":
if not summary_info['rating'] == "false" and rating == summary_info['rating']:
rating = "unrate"
else:
if summary_info['rating_advanced'] > 0 and rating == summary_info['rating_advanced']:
rating = 0
if rating == 0 or rating == "unrate":
rateOnTrakt(rating, gui.media_type, gui.media, unrate=True)
else:
rateOnTrakt(rating, gui.media_type, gui.media)
else:
utils.Debug("[Rating] Rating dialog was closed with no rating.")
del gui
def __init__(self, *args, **kwargs):
xbmc.Monitor.__init__(self)
self.action = kwargs['action']
# xbmc.getCondVisibility('Library.IsScanningVideo') returns false when cleaning during update...
self.scanning_video = False
utilities.Debug("[traktMonitor] Initalized.")
