def startDebugging(self):
active = False
#Eric4
try:
from dbg_client.DebugClient import DebugClient
DBG = DebugClient()
DBG.startDebugger(host='localhost',
filename='',
port=42424,
exceptions=True,
enableTrace=True,
redirect=True)
active = True
self._statusBar().showMessage(u"Eric4 debugging active")
except:
pass
#PyDev (Eclipse)
try:
from pysrc import pydevd
pydevd.settrace(port=5678, suspend=False)
active = True
self._statusBar().showMessage(u"PyDev debugging active")
except:
pass
if not active:
self._statusBar().showMessage(u"Debugging connection failed")
def init():
# append pydev remote debugger
if globalvar.REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', stdoutToServer=True, stderrToServer=True)
except ImportError:
sys.stderr.write("Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
globalvar.channels = [
[0, 'favourites', 'Favourites', favourites],
[1, 'cplus', 'Canal +', cplus],
[2, 'france1', 'France 1ere', pluzz],
[3, 'france2', 'France 2', pluzz],
[4, 'france3', 'France 3', pluzz],
[5, 'france4', 'France 4', pluzz],
[6, 'france5', 'France 5', pluzz],
[7, 'franceO', 'France O', pluzz],
[8, 'arte', 'Arte', arte],
[9, 'gulli', 'Gulli', gulli]
]
def start():
pydevd.settrace('localhost',
stdoutToServer=True,
stderrToServer=True,
suspend=False)
#pydevd.settrace('192.168.1.10', stdoutToServer=True, stderrToServer=True, suspend=False)
#pydevd.settrace('192.168.1.10')
logging.basicConfig(level=logging.DEBUG)
def startPyDevClient(self):
started = False
try:
from pysrc import pydevd
pydevd.settrace(port=5678, suspend=False)
started = True
self._statusBar().showMessage(u"PyDev debugging active")
except:
pass
return started
def startPyDevClient(self):
started = False
try:
from pysrc import pydevd
pydevd.settrace(port=5678, suspend=False)
started = True
self._statusBar().showMessage(u"PyDev debugging active")
except:
pass
return started
def debug():
#http://wiki.xbmc.org/index.php?title=HOW-TO_debug_Python_Scripts_with_Eclipse
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
print sys.path
try:
from pysrc import pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', stdoutToServer = True, stderrToServer = True)
except ImportError:
sys.stderr.write("Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
def debug(self):
if REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', port=5678, stdoutToServer=True, stderrToServer=True)
except ImportError:
sys.stderr.write("Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
return
def debugger():
try:
remote_debugger = settings.getSetting('remote_debugger')
remote_debugger_host = settings.getSetting('remote_debugger_host')
# append pydev remote debugger
if remote_debugger == 'true':
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace(remote_debugger_host, stdoutToServer=True, stderrToServer=True)
except ImportError:
xbmc.log(addon.getLocalizedString(30016), xbmc.LOGERROR)
sys.exit(1)
except :
pass
def debugger():
try:
remote_debugger = settings.getSetting('remote_debugger')
remote_debugger_host = settings.getSetting('remote_debugger_host')
# append pydev remote debugger
if remote_debugger == 'true':
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace(remote_debugger_host, stdoutToServer=True, stderrToServer=True)
except ImportError:
xbmc.log(addon.getLocalizedString(30016), xbmc.LOGERROR)
sys.exit(1)
except :
pass
def __init__(self, debug = True):
'''
Constructor
'''
if debug:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
from pysrc import pydevd;
except:
sys.stderr.write("Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.");
return;
try:
pydevd.settrace("localhost", stdoutToServer=True, stderrToServer=True, suspend=True);
except:
sys.stderr.write("Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.");
return;
def startDebugging(self):
active = False
#Eric4
try:
from dbg_client.DebugClient import DebugClient
DBG=DebugClient()
DBG.startDebugger(host='localhost', filename='', port=42424, exceptions=True, enableTrace=True, redirect=True)
active = True
self._statusBar().showMessage(u"Eric4 debugging active")
except:
pass
#PyDev (Eclipse)
try:
from pysrc import pydevd
pydevd.settrace(port=5678, suspend=False)
active = True
self._statusBar().showMessage(u"PyDev debugging active")
except:
pass
if not active:
self._statusBar().showMessage(u"Debugging connection failed")
#from resources.lib import tvWindow
#debugging
try:
remote_debugger = addon.getSetting('remote_debugger')
remote_debugger_host = addon.getSetting('remote_debugger_host')
# append pydev remote debugger
if remote_debugger == 'true':
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace(remote_debugger_host, stdoutToServer=True, stderrToServer=True)
except ImportError:
log(addon.getLocalizedString(30016), True)
sys.exit(1)
except :
pass
# retrieve settings
user_agent = addon.getSetting('user_agent')
mode = plugin_queries['mode']
# make mode case-insensitive
mode = mode.lower()
import logging
import xbmc, xbmcaddon, xbmcgui, xbmcplugin
from bs4 import BeautifulSoup as bs
REMOTE_DBG = False
# append pydev remote debugger
if REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd # with the addon script.module.pydevd, only use `import pydevd`
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', stdoutToServer=True, stderrToServer=True)
except ImportError:
sys.stderr.write(
"Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
__settings__ = xbmcaddon.Addon(id='plugin.video.zoomby.ru')
h = int(sys.argv[1])
xbmcplugin.setContent(h, 'movies')
plugin_path = __settings__.getAddonInfo('path').replace(';', '')
plugin_icon = xbmc.translatePath(os.path.join(plugin_path, 'icon.png'))
context_path = xbmc.translatePath(os.path.join(plugin_path, 'default.py'))
class gPlayer(xbmc.Player):
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', stdoutToServer=True, stderrToServer=True)
except:
pass
def __init__(self, *args, **kwargs):
xbmc.Player.__init__(self)
self.isExit = 0
self.seek = 0
def setScheduler(self, scheduler):
self.tvScheduler = scheduler
def setWorksheet(self, worksheet):
self.worksheet = worksheet
def setContent(self, episodes):
self.content = episodes
self.current = 0
def next(self):
# log('video ' + str(episodes[self.current][CONSTANTS.D_SOURCE]) + ',' + str(episodes[self.current][CONSTANTS.D_SHOW]))
# addVideo('plugin://plugin.video.gdrive?mode=playvideo&title='+episodes[video][0],
# { 'title' : str(episodes[video][CONSTANTS.D_SHOW]) + ' - S' + str(episodes[video][CONSTANTS.D_SEASON]) + 'xE' + str(episodes[video][CONSTANTS.D_EPISODE]) + ' ' + str(episodes[video][CONSTANTS.D_PART]) , 'plot' : episodes[video][CONSTANTS.D_SHOW] },
# img='None')
# play video
# if self.isExit == 0:
self.play(
'plugin://plugin.video.gdrive-testing/?mode=video&instance=' +
str(self.tvScheduler.service.instanceName) + '&title=' +
self.content[self.current][0])
# self.play(self.content[self.current][0])
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
if self.current < len(self.content):
self.current += 1
else:
self.current = 0
def PlayStream(self, url, item, seek):
self.play(url, item)
while not self.isPlaying(
): #<== The should be while self.isPlaying():
print "LOOP"
xbmc.sleep(2000)
xbmc.sleep(2000)
print "SEEK " + str(seek)
self.seekTime(seek)
def onPlayBackStarted(self):
print "PLAYBACK STARTED"
if self.seek > 0:
self.seekTime(self.seek)
def onPlayBackEnded(self):
print "PLAYBACK ENDED"
self.next()
def onPlayBackStopped(self):
print "PLAYBACK STOPPED"
self.isExit = 1
if self.isExit == 0:
print "don't exit"
def onPlayBackPaused(self):
print "PLAYBACK Paused"
self.seekTime(10)
import sys, traceback
# REMOTE DEBUGGING
REMOTE_DBG = False
# append pydev remote debugger
if REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost',
stdoutToServer=True,
stderrToServer=True,
suspend=False)
except ImportError:
sys.stderr.write(
"Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
except:
sys.stderr.write('Remote Debugger is not started')
# ACTUAL ADDON
from lib import main
try:
myAddon = main.Main()
myAddon.run(sys.argv)
except:
class gPlayer(xbmc.Player):
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', stdoutToServer=True, stderrToServer=True)
except:
pass
def __init__(self, *args, **kwargs):
xbmc.Player.__init__(self)
self.isExit = False
self.seek = 0
self.package = None
self.time = 0
self.service = None
self.current = 1
self.playStatus = False
self.currentURL = ''
def setService(self, service):
self.service = service
def setWorksheet(self, worksheet):
self.worksheet = worksheet
def setContent(self, episodes):
self.content = episodes
self.current = 0
def setMedia(self, mediaItems):
self.mediaItems = mediaItems
self.current = 0
def next(self):
# log('video ' + str(episodes[self.current][CONSTANTS.D_SOURCE]) + ',' + str(episodes[self.current][CONSTANTS.D_SHOW]))
# addVideo('plugin://plugin.video.gdrive?mode=playvideo&title='+episodes[video][0],
# { 'title' : str(episodes[video][CONSTANTS.D_SHOW]) + ' - S' + str(episodes[video][CONSTANTS.D_SEASON]) + 'xE' + str(episodes[video][CONSTANTS.D_EPISODE]) + ' ' + str(episodes[video][CONSTANTS.D_PART]) , 'plot' : episodes[video][CONSTANTS.D_SHOW] },
# img='None')
# play video
# if self.isExit == 0:
self.play(
'plugin://plugin.video.gdrive-testing/?mode=video&instance=' +
str(self.service.instanceName) + '&title=' +
self.content[self.current][0])
#self.play('plugin://plugin.video.gdrive/?mode=video&instance='+str(self.service.instanceName)+'&title='+self.content[self.current][0])
# self.play(self.content[self.current][0])
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
# self.tvScheduler.createRow(self.worksheet, '','','','')
if self.current < len(self.content):
self.current += 1
else:
self.current = 0
def saveTime(self):
try:
newTime = self.getTime()
if newTime > self.seek:
self.time = newTime
except:
pass
def PlayStream(self, url, item, seek, startPlayback=True, package=None):
self.currentURL = url
if startPlayback:
self.play(url, item)
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': Playback url ' + str(url), xbmc.LOGNOTICE)
if package is not None:
self.package = package
if seek != '':
self.seek = float(seek)
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') + ': Seek ' +
str(seek), xbmc.LOGNOTICE)
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
# if seek > 0 and seek !='':
# while not self.isPlaying(): #<== The should be while self.isPlaying():
# print "LOOP"
# xbmc.sleep(500)
# xbmc.sleep(2000)
# print "SEEK "+str(seek)
# self.time = float(seek)
# self.seekTime(float(seek))
def playNext(self, service, package):
(mediaURLs, package) = service.getPlaybackCall(package)
options = []
mediaURLs = sorted(mediaURLs)
for mediaURL in mediaURLs:
options.append(mediaURL.qualityDesc)
if mediaURL.qualityDesc == 'original':
originalURL = mediaURL.url
playbackURL = ''
playbackQuality = ''
playbackPath = ''
if service.settings.promptQuality:
if len(options) > 1:
ret = xbmcgui.Dialog().select(
service.addon.getLocalizedString(30033), options)
else:
ret = 0
else:
ret = 0
playbackURL = mediaURLs[ret].url
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') + ': Play next ' +
str(playbackURL), xbmc.LOGNOTICE)
playbackQuality = mediaURLs[ret].quality
item = xbmcgui.ListItem(package.file.displayTitle(),
iconImage=package.file.thumbnail,
thumbnailImage=package.file.thumbnail,
path=playbackURL + '|' +
service.getHeadersEncoded())
item.setInfo(type="Video", infoLabels={"Title": package.file.title})
self.PlayStream(playbackURL + '|' + service.getHeadersEncoded(), item,
0, package)
def playList(self, service):
while self.current < len(self.mediaItems) and not self.isExit:
self.playNext(service, self.mediaItems[self.current])
current = self.current
while current == self.current and not self.isExit:
xbmc.sleep(3000)
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') + ': Exit play list',
xbmc.LOGNOTICE)
def onPlayBackSeek(self, offset):
print "PLAYBACK SEEKED"
def onPlayBackStarted(self):
print "PLAYBACK STARTED"
self.playStatus = True
#self.tag = xbmc.Player().getVideoInfoTag()
# if self.seek > 0:
# self.seekTime(self.seek)
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') + ': Play started',
xbmc.LOGNOTICE)
if self.seek > 0 and self.seek != '':
# while not self.isPlaying(): #<== The should be while self.isPlaying():
# print "LOOP"
# xbmc.sleep(500)
# xbmc.sleep(2000)
print "SEEK " + str(self.seek)
self.time = float(self.seek)
self.seekTime(float(self.seek))
self.seek = 0
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') + ': Seek time ' +
str(self.seek), xbmc.LOGNOTICE)
try:
if (self.service.settings.tv_watch
or self.service.settings.movie_watch):
result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": { "sort": {"method":"lastplayed"}, "filter": {"field": "title", "operator": "isnot", "value":"1"}, "properties": [ "file"]}, "id": "1"}'
)
#fixedTitle = re.escape(re.sub('.strm', '',self.package.file.title))
fixedTitle = re.escape(
urllib.quote_plus(self.package.file.title))
#fixedTitle = re.escape(re.sub('[','',fixedTitle))
foundMatch = 0
#exp = re.search('"episodeid":(\d+), "file":"[^\"]+"', result)
#for match in re.finditer('"episodeid":(\d+)\,"file"\:".*'+str(fixedTitle)+'\.strm"', result):#, re.S):
for match in re.finditer(
'"episodeid":(\d+)\,"file"\:"[^\"]+' +
str(fixedTitle) + '.strm"', result): #, re.S):
#for match in re.finditer('"episodeid":(\d+)\,"file"\:"[^\"]+","label"\:"'+str(fixedTitle)+'"', result):#, re.S):
xbmc.log(
self.service.addon.getAddonInfo('name') +
': found show ID ' + match.group(1), xbmc.LOGNOTICE)
self.package.file.TVID = match.group(1)
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(match.group(1))+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
# xbmc.executeJSONRPC('{"params": {"episodeid": '+str(match.group(1))+', "playcount": '+str(self.package.file.playcount+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
foundMatch = 1
break
if foundMatch == 0:
for match in re.finditer(
'"episodeid":(\d+)\,"file"\:"[^\"]+' +
str(re.escape(self.package.file.title)) + '.strm"',
result): #, re.S):
xbmc.log(
self.service.addon.getAddonInfo('name') +
': found show ID ' + match.group(1),
xbmc.LOGNOTICE)
self.package.file.TVID = match.group(1)
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(match.group(1))+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
# xbmc.executeJSONRPC('{"params": {"episodeid": '+str(match.group(1))+', "playcount": '+str(self.package.file.playcount+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
foundMatch = 1
break
if self.service.settings and foundMatch == 1:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': Found local tv db id=' +
str(self.package.file.TVID), xbmc.LOGNOTICE)
if foundMatch == 0:
result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": { "sort": {"method":"lastplayed"}, "filter": {"field": "title", "operator": "isnot", "value":"1"}, "properties": [ "file"]}, "id": "1"}'
)
for match in re.finditer(
'"file":"[^\"]+' + str(fixedTitle) +
'.strm","label":"[^\"]+","movieid":(\d+)',
result): #, re.S):
xbmc.log(
self.service.addon.getAddonInfo('name') +
': found movie ID ' + match.group(1),
xbmc.LOGNOTICE)
self.package.file.MOVIEID = match.group(1)
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(match.group(1))+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
#xbmc.executeJSONRPC('{"params": {"movieid": '+str(match.group(1))+', "playcount": '+str(self.package.file.playcount+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetMovieDetails"}')
break
if foundMatch == 0:
for match in re.finditer(
'"file":"[^\"]+' +
str(re.escape(self.package.file.title)) +
'.strm","label":"[^\"]+","movieid":(\d+)',
result): #, re.S):
xbmc.log(
self.service.addon.getAddonInfo('name') +
': found movie ID ' + match.group(1),
xbmc.LOGNOTICE)
self.package.file.MOVIEID = match.group(1)
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(match.group(1))+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
#xbmc.executeJSONRPC('{"params": {"movieid": '+str(match.group(1))+', "playcount": '+str(self.package.file.playcount+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetMovieDetails"}')
break
if self.service.settings and foundMatch == 1:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': Found local movie db id=' +
str(self.package.file.MOVIEID), xbmc.LOGNOTICE)
except:
pass
def onPlayBackEnded(self):
xbmc.log(
self.service.addon.getAddonInfo('name') + ': PLAYBACK ENDED',
xbmc.LOGNOTICE)
# self.next()
if self.package is not None:
try:
if addon_parameters.spreadsheet and self.service.cloudResume == '1' and self.service.protocol == 2 and self.time > self.package.file.resume:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': PLAYBACK ENDED 1 ' +
str(self.package.file.playcount), xbmc.LOGNOTICE)
self.service.setProperty(self.package.file.id, 'resume',
self.time)
self.service.setProperty(
self.package.file.id, 'playcount',
int(self.package.file.playcount) + 1)
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': Updated remote db ', xbmc.LOGNOTICE)
elif addon_parameters.spreadsheet and self.service.cloudResume == '2' and self.service.protocol == 2 and (
self.time / self.package.file.duration) >= int(
self.service.settings.skipResume
) * 0.01: #and self.time > self.package.file.resume:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': PLAYBACK ENDED 2 ' +
str(self.package.file.playcount), xbmc.LOGNOTICE)
self.service.gSpreadsheet.setMediaStatus(
self.service.worksheetID,
self.package,
watched=int(self.package.file.playcount) + 1,
resume=0)
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': Updated local db ', xbmc.LOGNOTICE)
# if self.service.settings.tv_watch:
# exp = re.search('0?(\d+)', self.package.file.season)
# season = exp.group(1)
# exp = re.search('0?(\d+)', self.package.file.episode)
# episode = exp.group(1)
# result = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"filter":{"and": [{"field": "season", "operator": "is", "value": "'+str(season)+'"}, {"field": "episode", "operator": "is", "value": "'+str(episode)+'"}]}}, "id": 1}')
# exp = re.search('"episodeid":(\d+)', result)
# episodeID = exp.group(1)
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(episodeID)+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
# xbmc.executeJSONRPC('{"params": {"episodeid": '+str(episodeID)+', "playcount": '+str(self.package.file.playcount+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
except:
pass
try:
if (self.service.settings.tv_watch
and self.package.file.TVID != None):
xbmc.executeJSONRPC(
'{"params": {"episodeid": ' +
str(self.package.file.TVID) + ', "playcount": ' +
str(int(self.package.file.playcount) + 1) +
'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}'
)
xbmc.log(
self.service.addon.getAddonInfo('name') +
': 1 Updated watch status local tv db id=' +
str(self.package.file.TVID) + ' playcount=' +
str(int(self.package.file.playcount) + 1),
xbmc.LOGNOTICE)
elif (self.service.settings.movie_watch
and self.package.file.MOVIEID != None):
xbmc.executeJSONRPC(
'{"params": {"movieid": ' +
str(self.package.file.MOVIEID) + ', "playcount": ' +
str(int(self.package.file.playcount) + 1) +
'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetMovieDetails"}'
)
xbmc.log(
self.service.addon.getAddonInfo('name') +
': 1 Updated watch status local movie db id=' +
str(self.package.file.MOVIEID) + ' playcount=' +
str(int(self.package.file.playcount) + 1),
xbmc.LOGNOTICE)
else:
if (self.service.settings.tv_watch
or self.service.settings.movie_watch):
result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": { "sort": {"method":"lastplayed"}, "filter": {"field": "title", "operator": "isnot", "value":"1"}, "properties": [ "file"]}, "id": "1"}'
)
fixedTitle = re.escape(
re.sub(' ', '+', self.package.file.title))
foundMatch = 0
if (self.service.settings.tv_watch):
#exp = re.search('"episodeid":(\d+), "file":"[^\"]+"', result)
#for match in re.finditer('"episodeid":(\d+)\,"file"\:".*'+str(fixedTitle)+'\.strm"', result):#, re.S):
for match in re.finditer(
'"episodeid":(\d+)\,"file"\:"[^\"]*' +
str(fixedTitle) + '[^\"]*"',
result): #, re.S):
xbmc.log(
self.service.addon.getAddonInfo('name') +
': found show ID ' + match.group(1),
xbmc.LOGNOTICE)
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(match.group(1))+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
xbmc.executeJSONRPC(
'{"params": {"episodeid": ' +
str(match.group(1)) + ', "playcount": ' +
str(int(self.package.file.playcount) + 1) +
'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}'
)
foundMatch = 1
break
if self.service.settings and foundMatch == 1:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': 2 Updated local tv db id=' +
str(self.package.file.TVID) +
' playcount=' +
str(int(self.package.file.playcount) + 1),
xbmc.LOGNOTICE)
elif self.service.settings.movie_watch and foundMatch == 0:
result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": { "sort": {"method":"lastplayed"}, "filter": {"field": "title", "operator": "isnot", "value":"1"}, "properties": [ "file"]}, "id": "1"}'
)
for match in re.finditer(
'"file"\:"[^\"]*' + str(fixedTitle) +
'[^\"]*","label":"[^\"]+","movieid":(\d+)',
result): #, re.S):
xbmc.log(
self.service.addon.getAddonInfo('name') +
': found movie ID ' + match.group(1),
xbmc.LOGNOTICE)
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(match.group(1))+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
xbmc.executeJSONRPC(
'{"params": {"movieid": ' +
str(match.group(1)) + ', "playcount": ' +
str(int(self.package.file.playcount) + 1) +
'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetMovieDetails"}'
)
break
if self.service.settings and foundMatch == 1:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': 2 Updated local movie db id=' +
str(self.package.file.MOVIEID) +
' playcount=' +
str(int(self.package.file.playcount) + 1),
xbmc.LOGNOTICE)
except:
pass
#try:
# self.service.gSpreadsheet.setMediaStatus(self.worksheet,self.package, watched=1)
#except: pass
self.current = self.current + 1
self.isExit = True
self.playStatus = False
def onPlayBackStopped(self):
xbmc.log(
self.service.addon.getAddonInfo('name') + ': PLAYBACK STOPPED',
xbmc.LOGNOTICE)
if self.package is not None:
try:
if addon_parameters.spreadsheet and self.service.cloudResume == '1' and self.service.protocol == 2 and float(
self.time) > float(self.package.file.resume):
xbmc.log(
self.service.addon.getAddonInfo('name') +
': PLAYBACK STOPPED 1 ' + str(self.time),
xbmc.LOGNOTICE)
self.service.setProperty(self.package.file.id, 'resume',
self.time)
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': Updated remote db ', xbmc.LOGNOTICE)
elif addon_parameters.spreadsheet and self.service.cloudResume == '2' and self.service.protocol == 2: # and float(self.time) > float(self.package.file.resume):
xbmc.log(
self.service.addon.getAddonInfo('name') +
': PLAYBACK STOPPED 2 ' + str(self.time),
xbmc.LOGNOTICE)
self.service.gSpreadsheet.setMediaStatus(
self.service.worksheetID,
self.package,
resume=self.time)
# exp = re.search('0?(\d+)', self.package.file.season)
# season = exp.group(1)
# exp = re.search('0?(\d+)', self.package.file.episode)
# episode = exp.group(1)
# result = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"filter":{"and": [{"field": "season", "operator": "is", "value": "'+str(season)+'"}, {"field": "episode", "operator": "is", "value": "'+str(episode)+'"}]}}, "id": 1}')
# exp = re.search('"episodeid":(\d+)', result)
# episodeID = exp.group(1)
#result = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": { "sort": {"method":"lastplayed"}, "filter": {"field": "title", "operator": "isnot", "value":"1"}, "properties": [ "file"], "limits":{"end":3}}, "id": "1"}')
except:
pass
try:
if (self.service.settings.tv_watch
or self.service.settings.movie_watch):
if (float(self.service.settings.skipResume) / 100 < float(
self.time / self.package.file.duration)):
if (self.service.settings.tv_watch
and self.package.file.TVID != None):
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(self.package.file.TVID)+', "playcount": '+str(int(self.package.file.playcount)+1)+',"resume": {"position": '+str(1)+', "total": '+str(1)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(self.package.file.TVID)+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}, "playcount": '+str(int(self.package.file.playcount)+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(self.package.file.TVID)+', "playcount": '+str(1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
xbmc.executeJSONRPC(
'{"params": {"episodeid": ' +
str(self.package.file.TVID) + ', "playcount": ' +
str(int(self.package.file.playcount) + 1) +
', "resume": {"position": ' + str(self.time) +
', "total": ' + str(self.package.file.duration) +
'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}'
)
xbmc.log(
self.service.addon.getAddonInfo('name') +
': 1 Updated watch + resume status local tv db id='
+ str(self.package.file.TVID) + ' playcount=' +
str(int(self.package.file.playcount)) + ' time=' +
self.time + ' duration=' +
self.package.file.duration, xbmc.LOGNOTICE)
elif (self.service.settings.movie_watch
and self.package.file.MOVIEID != None):
# xbmc.executeJSONRPC('{"params": {"movieid": '+str(self.package.file.MOVIEID)+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetMovieDetails"}')
xbmc.executeJSONRPC(
'{"params": {"movieid": ' +
str(self.package.file.MOVIEID) +
', "playcount": ' +
str(int(self.package.file.playcount) + 1) +
', "resume": {"position": ' + str(self.time) +
', "total": ' + str(self.package.file.duration) +
'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetMovieDetails"}'
)
xbmc.log(
self.service.addon.getAddonInfo('name') +
': 1 Updated watch + resume status local movie db id='
+ str(self.package.file.MOVIEID) + ' playcount=' +
str(int(self.package.file.playcount)) + ' time=' +
self.time + ' duration=' +
self.package.file.duration, xbmc.LOGNOTICE)
else:
if (self.service.settings.tv_watch
and self.package.file.TVID != None):
xbmc.executeJSONRPC(
'{"params": {"episodeid": ' +
str(self.package.file.TVID) +
', "resume": {"position": ' + str(self.time) +
', "total": ' + str(self.package.file.duration) +
'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}'
)
xbmc.log(
self.service.addon.getAddonInfo('name') +
': 2 Updated resume status local tv db id=' +
str(self.package.file.TVID) + ' playcount=' +
str(int(self.package.file.playcount)) + ' time=' +
self.time + ' duration=' +
self.package.file.duration, xbmc.LOGNOTICE)
elif (self.service.settings.movie_watch
and self.package.file.MOVIEID != None):
xbmc.executeJSONRPC(
'{"params": {"movieid": ' +
str(self.package.file.MOVIEID) +
', "resume": {"position": ' + str(self.time) +
', "total": ' + str(self.package.file.duration) +
'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetMovieDetails"}'
)
xbmc.log(
self.service.addon.getAddonInfo('name') +
': 2 Updated resume status local movie db id=' +
str(self.package.file.MOVIEID) + ' playcount=' +
str(int(self.package.file.playcount)) + ' time=' +
self.time + ' duration=' +
self.package.file.duration, xbmc.LOGNOTICE)
elif (self.service.settings.tv_watch
or self.service.settings.movie_watch):
result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": { "sort": {"method":"lastplayed"}, "filter": {"field": "title", "operator": "isnot", "value":"1"}, "properties": [ "file"]}, "id": "1"}'
)
fixedTitle = re.escape(
re.sub(' ', '+', self.package.file.title))
foundMatch = 0
if (self.service.settings.tv_watch):
#exp = re.search('"episodeid":(\d+), "file":"[^\"]+"', result)
#for match in re.finditer('"episodeid":(\d+)\,"file"\:".*'+str(fixedTitle)+'\.strm"', result):#, re.S):
for match in re.finditer(
'"episodeid":(\d+)\,"file"\:"[^\"]*' +
str(fixedTitle) + '[^\"]*"',
result): #, re.S):
xbmc.log(
self.service.addon.getAddonInfo('name') +
': found show ID ' + match.group(1),
xbmc.LOGNOTICE)
xbmc.executeJSONRPC(
'{"params": {"episodeid": ' +
str(match.group(1)) +
', "resume": {"position": ' +
str(self.time) + ', "total": ' +
str(self.package.file.duration) +
'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}'
)
foundMatch = 1
break
#sxbmc.executeJSONRPC('{"params": {"episodeid": '+str(episodeID)+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(episodeID)+', "playcount": '+str(self.package.file.playcount+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
if self.service.settings and foundMatch == 1:
xbmc.log(
self.service.addon.getAddonInfo('name') +
': 3 Updated local tv db playcount=' +
str(int(self.package.file.playcount)) +
' time=' + self.time + ' duration=' +
self.package.file.duration, xbmc.LOGNOTICE)
elif self.service.settings.movie_watch and foundMatch == 0:
result = xbmc.executeJSONRPC(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": { "sort": {"method":"lastplayed"}, "filter": {"field": "title", "operator": "isnot", "value":"1"}, "properties": [ "file"]}, "id": "1"}'
)
for match in re.finditer(
'"file"\:"[^\"]*' + str(fixedTitle) +
'[^\"]*","label":"[^\"]+","movieid":(\d+)',
result): #, re.S):
xbmc.log(
self.service.addon.getAddonInfo('name')
+ ': found movie ID ' + match.group(1),
xbmc.LOGNOTICE)
xbmc.executeJSONRPC(
'{"params": {"movieid": ' +
str(match.group(1)) +
', "resume": {"position": ' +
str(self.time) + ', "total": ' +
str(self.package.file.duration) +
'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetMovieDetails"}'
)
#xbmc.executeJSONRPC('{"params": {"movieid": '+str(match.group(1))+', "playcount": '+str(self.package.file.playcount+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetMovieDetails"}')
break
if self.service.settings and foundMatch == 1:
xbmc.log(
self.service.addon.getAddonInfo('name')
+
': 3 Updated local movie db playcount='
+
str(int(self.package.file.playcount)) +
' time=' + self.time + ' duration=' +
self.package.file.duration,
xbmc.LOGNOTICE)
except:
pass
#self.current = self.current +1
self.isExit = True
# if not self.isExit:
# print "don't exit"
self.playStatus = False
def onPlayBackPaused(self):
print "PLAYBACK Paused"
if self.seek > 0:
self.seekTime(self.seek)
self.seek = 0
def seekTo(self, seek):
if seek != '':
self.seek = float(seek)
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
if seek > 0 and seek != '':
while not self.isPlaying(
): #<== The should be while self.isPlaying():
print "LOOP"
xbmc.sleep(500)
xbmc.sleep(2000)
print "SEEK " + str(seek)
self.time = float(seek)
self.seekTime(float(seek))
if self.service.settings:
xbmc.log(
self.service.addon.getAddonInfo('name') + ': Seek ' +
str(self.time), xbmc.LOGNOTICE)
# REMOTE DEBUGGING
REMOTE_DBG = False
# append pydev remote debugger
if REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', stdoutToServer=True, stderrToServer=True, suspend=False)
except ImportError:
sys.stderr.write("Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
except:
sys.stderr.write('Remote Debugger is not started')
##if (__name__ == "__main__" ):
## from lib.main import Main
## main = Main()
## main.run()
class Main:
def __init__(self):
self.pDialog = None
self.run()
try:
import pydevd
except ImportError:
sys.stderr.write(
"Error: Debugging could not be enabled." +
"Unable to determine directory where org.python.pydev.debug.pysrc is stored. "
+
"Please add this path either to your PYTHONPATH, or in the \"pysrc_path\" setting in addon.xml. "
+
"If you are not sure where this is, try searching your computer for a \"pysrc\" directory."
)
sys.exit(1)
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace(host=remote_debugger_host,
stdoutToServer=True,
stderrToServer=True,
port=remote_debugger_port)
# -*- coding: cp1252 -*-
from bs4 import BeautifulSoup
import urllib, urllib2, re, xbmcplugin, xbmcgui, xbmc
# Set default encoding to 'UTF-8' instead of 'ascii'
reload(sys)
sys.setdefaultencoding("UTF8")
__language__ = addon.getLocalizedString
__icon__ = addon.getAddonInfo('icon')
__fanart__ = addon.getAddonInfo('fanart')
#headers = ['User-Agent', 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3']
def start():
pydevd.settrace('localhost', stdoutToServer=True, stderrToServer=True, suspend=False)
#pydevd.settrace('192.168.1.10', stdoutToServer=True, stderrToServer=True, suspend=False)
#pydevd.settrace('192.168.1.10')
logging.basicConfig(level=logging.DEBUG)
REMOTE_DBG = True
# append pydev remote debugger
if REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('10.155.30.24',port=5678, stdoutToServer=True, stderrToServer=True)
except ImportError:
sys.stderr.write("Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
from selenium.webdriver.remote.webdriver import WebDriver
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from selenium.webdriver.firefox.firefox_profile import FirefoxProfile
from selenium.webdriver.common.by import By
class WebUIDriver(WebDriver):
def __init__(self, command_executor='http://127.0.0.1:4444/wd/hub', desired_capabilities=None, browser_profile=None, session_id=None):
self.preserved_session_id = session_id
WebDriver.__init__(self, command_executor, desired_capabilities, browser_profile)
def start_session(self, desired_capabilities, browser_profile=None):
if self.preserved_session_id:
self.command_executor._commands['getSession'] = ('GET', '/session/$sessionId')
self.session_id = self.preserved_session_id
response = self.execute('getSession', {'sessionId ': self.session_id})
self.session_id = response['sessionId']
'''
Created on Jan 9, 2011
@author: Administrator
'''
from pysrc import pydevd
pydevd.settrace('172.16.0.1', stdoutToServer=True, stderrToServer=True)
import rpyc
print 'marek'
except:
import simplejson as json
import SimpleDownloader as downloader
import time
g_ignoreSetResolved=['plugin.video.f4mTester','plugin.video.shahidmbcnet']
REMOTE_DBG=False;
if REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', stdoutToServer=True, stderrToServer=True)
except ImportError:
sys.stderr.write("Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
addon = xbmcaddon.Addon('plugin.video.live.streams')
addon_version = addon.getAddonInfo('version')
profile = xbmc.translatePath(addon.getAddonInfo('profile').decode('utf-8'))
home = xbmc.translatePath(addon.getAddonInfo('path').decode('utf-8'))
favorites = os.path.join(profile, 'favorites')
REV = os.path.join(profile, 'list_revision')
icon = os.path.join(home, 'icon.png')
FANART = os.path.join(home, 'fanart.jpg')
source_file = os.path.join(profile, 'source_file')
def f**k(_sys, _xbmc):
####Variables
# Inicializadas
global sys
global xbmc
global logger
global addon
sys = _sys
xbmc = _xbmc
modo = MODO_INICIAL
params = get_params()
url_plugin = sys.argv[0]
handle_xbmc = int(sys.argv[1])
addon = xbmcaddon.Addon(id=__plugin__)
# Sin inicializar
velocidad_internet = 0
total_a_descargar = 0
urls_archivos_descargables = []
hilos_archivos_descargables = []
logger = None
opener = None
pagina = None
parser_html = None
carpeta_li = None
archivo_persistencia = None
url_descarga = ""
carpetas = {}
# append pydev remote debuggerm
if REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace("localhost", stdoutToServer=True, stderrToServer=True, port=5678)
except ImportError:
sys.stderr.write("Error: " + "You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
# Inicializando logger
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger("mierda")
# logger.debug("kussou rumba %s" % params)
# Configurando el timeout de los socketes
socket.setdefaulttimeout(60)
if len(params) > 0 and params["modo"]:
modo = int(params["modo"], 0)
if modo == MODO_INICIAL:
logger.debug("Modo inicial")
carpeta_li = xbmcgui.ListItem("Series", iconImage="DefaultFolder.png", thumbnailImage="")
carpeta_li.setInfo(type="Video", infoLabels={"Title": "Series"})
xbmcplugin.addDirectoryItem(
handle=handle_xbmc, url="%s?modo=%d" % (url_plugin, MODO_CARPETA), listitem=carpeta_li, isFolder=True
)
carpeta_li = xbmcgui.ListItem("Canales", iconImage="DefaultFolder.png", thumbnailImage="")
carpeta_li.setInfo(type="Video", infoLabels={"Title": "Canales"})
xbmcplugin.addDirectoryItem(
handle=handle_xbmc, url="%s?modo=%d" % (url_plugin, MODO_LISTA_FLUJO), listitem=carpeta_li, isFolder=True
)
carpeta_li = xbmcgui.ListItem("Peliculas", iconImage="DefaultFolder.png", thumbnailImage="")
carpeta_li.setInfo(type="Video", infoLabels={"Title": "Peliculas"})
xbmcplugin.addDirectoryItem(
handle=handle_xbmc, url="%s?modo=%d" % (url_plugin, MODO_LISTA_PELOS), listitem=carpeta_li, isFolder=True
)
carpeta_li = xbmcgui.ListItem("Pagos por evento", iconImage="DefaultFolder.png", thumbnailImage="")
carpeta_li.setInfo(type="Video", infoLabels={"Title": "PPV"})
xbmcplugin.addDirectoryItem(
handle=handle_xbmc, url="%s?modo=%d" % (url_plugin, MODO_INICIAL), listitem=carpeta_li, isFolder=True
)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
elif modo == MODO_CARPETA:
logger.debug("Modo carpeta")
opener = urllib2.build_opener(urllib2.HTTPHandler(debuglevel=1))
opener.addheaders = [("User-agent", "Mozilla/5.0")]
pagina = opener.open(URL_CACA)
parser_html = ParserArchivos(pagina)
archivo_persistencia = shelve.open("mierda")
archivo_persistencia["carpetas"] = parser_html.carpetas
archivo_persistencia.close()
for carpeta in parser_html.carpetas:
carpeta_li = xbmcgui.ListItem(carpeta.replace(".", " "), iconImage="DefaultFolder.png", thumbnailImage="")
carpeta_li.setInfo(type="Video", infoLabels={"Title": carpeta.replace(".", " ")})
xbmcplugin.addDirectoryItem(
handle=handle_xbmc,
url="%s?carpeta=%s&modo=%d" % (url_plugin, carpeta, MODO_ARCHIVO),
listitem=carpeta_li,
isFolder=True,
)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
elif modo == MODO_ARCHIVO:
logger.debug("Modo archivo")
archivo_persistencia = shelve.open("mierda")
carpetas = archivo_persistencia["carpetas"]
for archivo in carpetas[params["carpeta"]]:
carpeta_li = xbmcgui.ListItem(archivo, iconImage="DefaultFolder.png", thumbnailImage="")
carpeta_li.setInfo(type="Video", infoLabels={"Title": archivo})
logger.debug("La url a la que e hara la peticion es " + URL_CACA + params["carpeta"])
xbmcplugin.addDirectoryItem(
handle=handle_xbmc,
url="%s?carpeta=%s&archivo=%s&modo=%d" % (url_plugin, params["carpeta"], archivo, MODO_ACCESO_ARCHIVO),
listitem=carpeta_li,
isFolder=False,
)
archivo_persistencia.close()
xbmcplugin.endOfDirectory(int(sys.argv[1]))
elif modo == MODO_ACCESO_ARCHIVO:
logger.debug("Modo acceso archivo")
archivo_persistencia = shelve.open("mierda")
carpetas = archivo_persistencia["carpetas"]
logger.debug("La carpeta es %s, el archivo es %s" % (params["carpeta"], params["archivo"]))
url_descarga = URL_CACA + carpetas[params["carpeta"]][params["archivo"]]
archivo_persistencia.close()
logger.debug("Modo de reproduccion la url %s" % url_descarga)
urls_archivos_descargables = get_urls_archivos(url_descarga)
logger.debug("Empieza la descarga de poder")
for url_archivo_descargable in urls_archivos_descargables:
logger.debug("die die die my darling %s" % url_archivo_descargable)
# https://www.assembla.com/wiki/show/oniontv-plugin/Script_to_play_a_video_file_in_XBMC
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
playlist.add(url_descarga + url_archivo_descargable)
xbmc.Player().play(playlist)
elif modo == MODO_LISTA_FLUJO:
logger.debug("Modo lista flujo")
# logger.debug("Modo lista de flujos %s" % addon.getAddonInfo('path'))
parser_html = ParserFlujos(open(addon.getAddonInfo("path") + "/plantillas_html/series.html", "r"))
logger.debug("Los flujos encontrados son %s" % parser_html.flujos)
for flujo in parser_html.flujos:
carpeta_li = xbmcgui.ListItem(flujo[0], iconImage="DefaultFolder.png", thumbnailImage="")
carpeta_li.setInfo(type="Video", infoLabels={"Title": flujo[0]})
logger.debug("La url a la que e hara la peticion es " + flujo[1])
xbmcplugin.addDirectoryItem(
handle=handle_xbmc,
url="%s?flujo=%s&modo=%d" % (url_plugin, flujo[1], MODO_FLUJO),
listitem=carpeta_li,
isFolder=False,
)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
elif modo == MODO_FLUJO:
logger.debug("Modo flujo")
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
playlist.add(params["flujo"])
xbmc.Player().play(playlist)
elif modo == MODO_LISTA_PELOS:
logger.debug("Modo lista pelos")
opener = urllib2.build_opener(urllib2.HTTPHandler(debuglevel=1))
opener.addheaders = [("User-agent", "Mozilla/5.0")]
pagina = opener.open(URL_PELOS)
parser_html = ParserPelos(pagina)
for pelo in parser_html.pelos:
carpeta_li = xbmcgui.ListItem(pelo.replace(".", " "), iconImage="DefaultFolder.png", thumbnailImage="")
carpeta_li.setInfo(type="Video", infoLabels={"Title": pelo.replace(".", " ")})
xbmcplugin.addDirectoryItem(
handle=handle_xbmc,
url="%s?carpeta=%s&modo=%d&url_pelo=%s" % (url_plugin, pelo, MODO_PELO, parser_html.pelos[pelo]),
listitem=carpeta_li,
isFolder=True,
)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
elif modo == MODO_PELO:
logger.debug("Modo pelo %s" % params["url_pelo"])
url_archivo_descargable = get_url_pelo(URL_PELOS + params["url_pelo"])
url_archivo_descargable = URL_PELOS + params["url_pelo"] + "/" + url_archivo_descargable
logger.debug("die die die my darling %s" % url_archivo_descargable)
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
playlist.add(url_archivo_descargable)
xbmc.Player().play(playlist)
else:
logger.error("Modo desconocido, abortando")
sys.exit(1)
def searchBacklog(self, which_shows=None):
REMOTE_DBG = False
if REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', port=5678, stdoutToServer=True, stderrToServer=True)
except ImportError:
sys.stderr.write("Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
if which_shows:
show_list = which_shows
else:
show_list = sickbeard.showList
if self.amActive == True:
logger.log(u"Backlog is still running, not starting it again", logger.DEBUG)
return
self._get_lastBacklog()
curDate = datetime.date.today().toordinal()
fromDate = datetime.date.fromordinal(1)
if not which_shows and not curDate - self._lastBacklog >= self.cycleTime:
logger.log(u"Running limited backlog on recently missed episodes only")
fromDate = datetime.date.today() - datetime.timedelta(days=7)
self.amActive = True
self.amPaused = False
#myDB = db.DBConnection()
#numSeasonResults = myDB.select("SELECT DISTINCT(season), showid FROM tv_episodes ep, tv_shows show WHERE season != 0 AND ep.showid = show.tvdb_id AND show.paused = 0 AND ep.airdate > ?", [fromDate.toordinal()])
# get separate lists of the season/date shows
#season_shows = [x for x in show_list if not x.air_by_date]
air_by_date_shows = [x for x in show_list if x.air_by_date]
# figure out how many segments of air by date shows we're going to do
air_by_date_segments = []
for cur_id in [x.tvdbid for x in air_by_date_shows]:
air_by_date_segments += self._get_air_by_date_segments(cur_id, fromDate)
logger.log(u"Air-by-date segments: "+str(air_by_date_segments), logger.DEBUG)
#totalSeasons = float(len(numSeasonResults) + len(air_by_date_segments))
#numSeasonsDone = 0.0
# go through non air-by-date shows and see if they need any episodes
for curShow in show_list:
if curShow.paused:
continue
if curShow.air_by_date:
segments = [x[1] for x in self._get_air_by_date_segments(curShow.tvdbid, fromDate)]
else:
segments = self._get_season_segments(curShow.tvdbid, fromDate)
for cur_segment in segments:
self.currentSearchInfo = {'title': curShow.name + " Season "+str(cur_segment)}
backlog_queue_item = search_queue.BacklogQueueItem(curShow, cur_segment)
if not backlog_queue_item.wantSeason:
logger.log(u"Nothing in season "+str(cur_segment)+" needs to be downloaded, skipping this season", logger.DEBUG)
else:
sickbeard.searchQueueScheduler.action.add_item(backlog_queue_item) #@UndefinedVariable
# don't consider this an actual backlog search if we only did recent eps
# or if we only did certain shows
if fromDate == datetime.date.fromordinal(1) and not which_shows:
self._set_lastBacklog(curDate)
self.amActive = False
self._resetPI()
import xbmcgui
import xbmcaddon
import json
import xbmc
REMOTE_DBG = False
# append pydev remote debugger
if REMOTE_DBG:
# Make pydev debugger works for auto reload.
# Note pydevd module need to be copied in XBMC\system\python\Lib\pysrc
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('192.168.0.12',
stdoutToServer=True,
stderrToServer=True)
except ImportError:
sys.stderr.write(
"Error: " +
"You must add org.python.pydev.debug.pysrc to your PYTHONPATH.")
sys.exit(1)
socket.setdefaulttimeout(30)
pluginhandle = int(sys.argv[1])
addon = xbmcaddon.Addon()
addonID = addon.getAddonInfo('id')
thumbsDir = xbmc.translatePath('special://home/addons/' + addonID +
'/resources/thumbs')
forceViewMode = addon.getSetting("forceViewMode") == "true"
useThumbAsFanart = addon.getSetting("useThumbAsFanart") == "true"
class gPlayer(xbmc.Player):
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', stdoutToServer=True, stderrToServer=True)
except:
pass
def __init__(self, *args, **kwargs):
xbmc.Player.__init__(self)
self.isExit = False
self.seek = 0
self.package = None
self.time = 0
self.service = None
self.current = 1
def setService(self, service):
self.service = service
def setWorksheet(self, worksheet):
self.worksheet = worksheet
def setContent(self, episodes):
self.content = episodes
self.current = 0
def setMedia(self, mediaItems):
self.mediaItems = mediaItems
self.current = 0
def next(self):
# log('video ' + str(episodes[self.current][CONSTANTS.D_SOURCE]) + ',' + str(episodes[self.current][CONSTANTS.D_SHOW]))
# addVideo('plugin://plugin.video.gdrive?mode=playvideo&title='+episodes[video][0],
# { 'title' : str(episodes[video][CONSTANTS.D_SHOW]) + ' - S' + str(episodes[video][CONSTANTS.D_SEASON]) + 'xE' + str(episodes[video][CONSTANTS.D_EPISODE]) + ' ' + str(episodes[video][CONSTANTS.D_PART]) , 'plot' : episodes[video][CONSTANTS.D_SHOW] },
# img='None')
# play video
# if self.isExit == 0:
self.play(
'plugin://plugin.video.gdrive-testing/?mode=video&instance=' +
str(self.service.instanceName) + '&title=' +
self.content[self.current][0])
# self.play(self.content[self.current][0])
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
# self.tvScheduler.createRow(self.worksheet, '','','','')
if self.current < len(self.content):
self.current += 1
else:
self.current = 0
def saveTime(self):
try:
newTime = self.getTime()
if newTime > self.seek:
self.time = newTime
except:
pass
def PlayStream(self, url, item, seek, startPlayback=True, package=None):
if startPlayback:
self.play(url, item)
if package is not None:
self.package = package
if seek != '':
self.seek = float(seek)
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
# if seek > 0 and seek !='':
# while not self.isPlaying(): #<== The should be while self.isPlaying():
# print "LOOP"
# xbmc.sleep(500)
# xbmc.sleep(2000)
# print "SEEK "+str(seek)
# self.time = float(seek)
# self.seekTime(float(seek))
def playNext(self, service, package):
(mediaURLs, package) = service.getPlaybackCall(package)
options = []
mediaURLs = sorted(mediaURLs)
for mediaURL in mediaURLs:
options.append(mediaURL.qualityDesc)
if mediaURL.qualityDesc == 'original':
originalURL = mediaURL.url
playbackURL = ''
playbackQuality = ''
playbackPath = ''
ret = xbmcgui.Dialog().select(service.addon.getLocalizedString(30033),
options)
playbackURL = mediaURLs[ret].url
playbackQuality = mediaURLs[ret].quality
item = xbmcgui.ListItem(package.file.displayTitle(),
iconImage=package.file.thumbnail,
thumbnailImage=package.file.thumbnail,
path=playbackURL + '|' +
service.getHeadersEncoded(service.useWRITELY))
item.setInfo(type="Video", infoLabels={"Title": package.file.title})
self.PlayStream(
playbackURL + '|' + service.getHeadersEncoded(service.useWRITELY),
item, 0, package)
def playList(self, service):
while self.current < len(self.mediaItems) and not self.isExit:
self.playNext(service, self.mediaItems[self.current])
current = self.current
while current == self.current and not self.isExit:
xbmc.sleep(3000)
def onPlayBackStarted(self):
print "PLAYBACK STARTED"
# if self.seek > 0:
# self.seekTime(self.seek)
if self.seek > 0 and self.seek != '':
# while not self.isPlaying(): #<== The should be while self.isPlaying():
# print "LOOP"
# xbmc.sleep(500)
# xbmc.sleep(2000)
print "SEEK " + str(self.seek)
self.time = float(self.seek)
self.seekTime(float(self.seek))
def onPlayBackEnded(self):
print "PLAYBACK ENDED"
# self.next()
if self.package is not None:
self.service.setProperty(self.package.file.id, 'playcount',
int(self.package.file.playcount) + 1)
#try:
# self.service.gSpreadsheet.setMediaStatus(self.worksheet,self.package, watched=1)
#except: pass
self.current = self.current + 1
self.isExit = True
def onPlayBackStopped(self):
print "PLAYBACK STOPPED"
if self.package is not None:
try:
self.service.gSpreadsheet.setMediaStatus(self.worksheet,
self.package,
resume=self.time)
except:
pass
#self.current = self.current +1
self.isExit = True
# if not self.isExit:
# print "don't exit"
def onPlayBackPaused(self):
print "PLAYBACK Paused"
#self.seekTime(10)
def seekTo(self, seek):
if seek != '':
self.seek = float(seek)
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
if seek > 0 and seek != '':
while not self.isPlaying(
): #<== The should be while self.isPlaying():
print "LOOP"
xbmc.sleep(500)
xbmc.sleep(2000)
print "SEEK " + str(seek)
self.time = float(seek)
self.seekTime(float(seek))
class gPlayer(xbmc.Player):
try:
import pysrc.pydevd as pydevd
# stdoutToServer and stderrToServer redirect stdout and stderr to eclipse console
pydevd.settrace('localhost', stdoutToServer=True, stderrToServer=True)
except :
pass
def __init__( self, *args, **kwargs ):
xbmc.Player.__init__( self )
self.isExit = False
self.seek = 0
self.package = None
self.time = 0
self.service = None
self.current = 1
self.playStatus = False
self.currentURL = ''
def setService(self,service):
self.service = service
def setWorksheet(self,worksheet):
self.worksheet = worksheet
def setContent(self, episodes):
self.content = episodes
self.current = 0
def setMedia(self, mediaItems):
self.mediaItems = mediaItems
self.current = 0
def next(self):
# log('video ' + str(episodes[self.current][CONSTANTS.D_SOURCE]) + ',' + str(episodes[self.current][CONSTANTS.D_SHOW]))
# addVideo('plugin://plugin.video.gdrive?mode=playvideo&title='+episodes[video][0],
# { 'title' : str(episodes[video][CONSTANTS.D_SHOW]) + ' - S' + str(episodes[video][CONSTANTS.D_SEASON]) + 'xE' + str(episodes[video][CONSTANTS.D_EPISODE]) + ' ' + str(episodes[video][CONSTANTS.D_PART]) , 'plot' : episodes[video][CONSTANTS.D_SHOW] },
# img='None')
# play video
# if self.isExit == 0:
self.play('plugin://plugin.video.OTV_MEDIA/?mode=12&url='+str(self.service)+'&title='+self.content[self.current][0])
#self.play('plugin://plugin.video.gdrive/?mode=video&instance='+str(self.service.instanceName)+'&title='+self.content[self.current][0])
# self.play(self.content[self.current][0])
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
# self.tvScheduler.createRow(self.worksheet, '','','','')
if self.current < len(self.content):
self.current += 1
else:
self.current = 0
def saveTime(self):
try:
newTime = self.getTime()
if newTime > self.seek:
self.time = newTime
except:
pass
def playStream(self, urlm, **kwargs):
for url,title in urlm:
self._initStream(title, url, **kwargs)
def _initStream(self, title, url):
self.url = url
self.title = title
if isinstance(url, unicode):
url = url.encode('utf-8', 'ignore')
if isinstance(title, unicode):
title= title.encode('utf-8', 'ignore')
self.addLink('[COLOR lightblue][B]OTV MEDIA >> [/B][/COLOR]'+title,url,'')
def PlayStream(self, url, item, seek, startPlayback=True, package=None):
self.currentURL = url
if startPlayback:
self.play(url, item)
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Playback url ' + str(url), xbmc.LOGNOTICE)
if package is not None:
self.package = package
if seek != '':
self.seek = float(seek)
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Seek ' + str(seek), xbmc.LOGNOTICE)
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
# if seek > 0 and seek !='':
# while not self.isPlaying(): #<== The should be while self.isPlaying():
# print "LOOP"
# xbmc.sleep(500)
# xbmc.sleep(2000)
# print "SEEK "+str(seek)
# self.time = float(seek)
# self.seekTime(float(seek))
def __getPlayerType(self):
oConfig = cConfig()
sPlayerType = oConfig.getSetting('playerType')
try:
if (sPlayerType == '0'):
cConfig().log("playertype from config: auto")
return xbmc.PLAYER_CORE_AUTO
if (sPlayerType == '1'):
cConfig().log("playertype from config: mplayer")
return xbmc.PLAYER_CORE_MPLAYER
if (sPlayerType == '2'):
cConfig().log("playertype from config: dvdplayer")
return xbmc.PLAYER_CORE_DVDPLAYER
except: return False
def playNext(self, service, package):
(mediaURLs, package) = service.getPlaybackCall(package)
options = []
mediaURLs = sorted(mediaURLs)
for mediaURL in mediaURLs:
options.append(mediaURL.qualityDesc)
if mediaURL.qualityDesc == 'original':
originalURL = mediaURL.url
playbackURL = ''
playbackQuality = ''
playbackPath = ''
if service.settings.promptQuality:
if len(options) > 1:
ret = xbmcgui.Dialog().select(service.addon.getLocalizedString(30033), options)
else:
ret = 0
else:
ret = 0
playbackURL = mediaURLs[ret].url
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Play next ' + str(playbackURL), xbmc.LOGNOTICE)
playbackQuality = mediaURLs[ret].quality
item = xbmcgui.ListItem(package.file.displayTitle(), iconImage=package.file.thumbnail,
thumbnailImage=package.file.thumbnail, path=playbackURL+'|' + service.getHeadersEncoded())
item.setInfo( type="Video", infoLabels={ "Title": package.file.title } )
self.PlayStream(playbackURL+'|' + service.getHeadersEncoded(),item,0,package)
def playList(self, service):
while self.current < len(self.mediaItems) and not self.isExit:
self.playNext(service, self.mediaItems[self.current])
current = self.current
while current == self.current and not self.isExit:
xbmc.sleep(3000)
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Exit play list', xbmc.LOGNOTICE)
def onPlayBackStarted(self):
print "PLAYBACK STARTED"
self.playStatus = True
#self.tag = xbmc.Player().getVideoInfoTag()
# if self.seek > 0:
# self.seekTime(self.seek)
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Play started', xbmc.LOGNOTICE)
if self.seek > 0 and self.seek !='':
# while not self.isPlaying(): #<== The should be while self.isPlaying():
# print "LOOP"
# xbmc.sleep(500)
# xbmc.sleep(2000)
print "SEEK "+str(self.seek)
self.time = float(self.seek)
self.seekTime(float(self.seek))
self.seek = 0
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Seek time ' + str(self.seek), xbmc.LOGNOTICE)
def onPlayBackEnded(self):
print "PLAYBACK ENDED"
# self.next()
if self.package is not None:
try:
if self.service.settings.cloudResume == '1' and self.service.protocol == 2 and self.time > self.package.file.resume:
xbmc.log(self.service.addon.getAddonInfo('name') + ': PLAYBACK ENDED 1 ' + str(self.package.file.playcount), xbmc.LOGNOTICE)
self.service.setProperty(self.package.file.id,'resume', self.time)
self.service.setProperty(self.package.file.id,'playcount', int(self.package.file.playcount)+1)
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Updated remote db ', xbmc.LOGNOTICE)
elif self.service.settings.cloudResume == '2' and self.service.protocol == 2 and (self.time/self.package.file.duration) >= int(self.service.settings.skipResume)*0.01:#and self.time > self.package.file.resume:
xbmc.log(self.service.addon.getAddonInfo('name') + ': PLAYBACK ENDED 2 ' + str(self.package.file.playcount), xbmc.LOGNOTICE)
self.service.gSpreadsheet.setMediaStatus(self.service.worksheetID,self.package, watched= int(self.package.file.playcount)+1, resume=0)
exp = re.search('0?(\d+)', self.package.file.season)
season = exp.group(1)
exp = re.search('0?(\d+)', self.package.file.episode)
episode = exp.group(1)
result = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"filter":{"and": [{"field": "season", "operator": "is", "value": "'+str(season)+'"}, {"field": "episode", "operator": "is", "value": "'+str(episode)+'"}]}}, "id": 1}')
exp = re.search('"episodeid":(\d+)', result)
episodeID = exp.group(1)
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(episodeID)+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
xbmc.executeJSONRPC('{"params": {"episodeid": '+str(episodeID)+', "playcount": '+str(self.package.file.playcount+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Updated local db ', xbmc.LOGNOTICE)
except: pass
#try:
# self.service.gSpreadsheet.setMediaStatus(self.worksheet,self.package, watched=1)
#except: pass
self.current = self.current +1
self.isExit = True
self.playStatus = False
def onPlayBackStopped(self):
print "PLAYBACK STOPPED"
if self.package is not None:
try:
if self.service.settings.cloudResume == '1' and self.service.protocol == 2 and float(self.time) > float(self.package.file.resume):
xbmc.log(self.service.addon.getAddonInfo('name') + ': PLAYBACK STOPPED 1 ' + str(self.time), xbmc.LOGNOTICE)
self.service.setProperty(self.package.file.id,'resume', self.time)
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Updated remote db ', xbmc.LOGNOTICE)
elif self.service.settings.cloudResume == '2' and self.service.protocol == 2:# and float(self.time) > float(self.package.file.resume):
xbmc.log(self.service.addon.getAddonInfo('name') + ': PLAYBACK STOPPED 2 ' + str(self.time), xbmc.LOGNOTICE)
self.service.gSpreadsheet.setMediaStatus(self.service.worksheetID,self.package, resume=self.time)
exp = re.search('0?(\d+)', self.package.file.season)
season = exp.group(1)
exp = re.search('0?(\d+)', self.package.file.episode)
episode = exp.group(1)
result = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"filter":{"and": [{"field": "season", "operator": "is", "value": "'+str(season)+'"}, {"field": "episode", "operator": "is", "value": "'+str(episode)+'"}]}}, "id": 1}')
exp = re.search('"episodeid":(\d+)', result)
episodeID = exp.group(1)
xbmc.executeJSONRPC('{"params": {"episodeid": '+str(episodeID)+', "resume": {"position": '+str(self.time)+', "total": '+str(self.package.file.duration)+'}}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
#xbmc.executeJSONRPC('{"params": {"episodeid": '+str(episodeID)+', "playcount": '+str(self.package.file.playcount+1)+'}, "jsonrpc": "2.0", "id": "setResumePoint", "method": "VideoLibrary.SetEpisodeDetails"}')
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Updated local db ', xbmc.LOGNOTICE)
except: pass
#self.current = self.current +1
self.isExit = True
# if not self.isExit:
# print "don't exit"
self.playStatus = False
def onPlayBackPaused(self):
print "PLAYBACK Paused"
if self.seek > 0:
self.seekTime(self.seek)
self.seek = 0
def seekTo(self, seek):
if seek != '':
self.seek = float(seek)
# self.tvScheduler.setVideoWatched(self.worksheet, self.content[self.current][0])
if seek > 0 and seek !='':
while not self.isPlaying(): #<== The should be while self.isPlaying():
print "LOOP"
xbmc.sleep(500)
xbmc.sleep(2000)
print "SEEK "+str(seek)
self.time = float(seek)
self.seekTime(float(seek))
if self.service.settings:
xbmc.log(self.service.addon.getAddonInfo('name') + ': Seek ' + str(self.time), xbmc.LOGNOTICE)
def addLink(self,name,url,iconimage):
ok=True
liz=xbmcgui.ListItem(name, iconImage="DefaultVideo.png", thumbnailImage=iconimage)
liz.setInfo( type="Video", infoLabels={ "Title": name } )
liz.setProperty("IsPlayable", "true")
ok=xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=str(url),listitem=liz)
xbmc.Player().play(url,liz)
sys.exit()
return ok
