def handleProgress(self):
printl("", self, "S")
currentTime = self.getPlayPosition()[1] / 90000
totalTime = self.getPlayLength()[1] / 90000
progress = currentTime / (totalTime/100)
printl( "played time is %s secs of %s @ %s%%" % ( currentTime, totalTime, progress),self, "I" )
instance = Singleton()
plexInstance = instance.getPlexInstance()
if self.multiUser:
plexInstance.getTimelineURL(self.server, "/library/sections/onDeck", self.id, "stopped", str(currentTime*1000), str(totalTime*1000))
#Legacy PMS Server server support before MultiUser version v0.9.8.0 and if we are not connected via myPlex
else:
if currentTime < 30:
printl("Less that 30 seconds, will not set resume", self, "I")
#If we are less than 95% complete, store resume time
elif progress < 95:
printl("Less than 95% progress, will store resume time", self, "I" )
plexInstance.doRequest("http://"+self.server+"/:/progress?key="+self.id+"&identifier=com.plexapp.plugins.library&time="+str(currentTime*1000))
#Otherwise, mark as watched
else:
printl( "Movie marked as watched. Over 95% complete", self, "I")
plexInstance.doRequest("http://"+self.server+"/:/scrobble?key="+self.id+"&identifier=com.plexapp.plugins.library")
printl("", self, "C")
def keyBlue(self):
printl("", self, "S")
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(
PlexLibrary(self.session, self.current))
token = self.plexInstance.getNewMyPlexToken()
if token:
self.session.openWithCallback(
self.saveNow, MessageBox,
(_("myPlex Token:") + "\n%s \n" + _("for the user:"******"\n%s \n" + _("with the id:") + "\n%s") %
(token, self.current.myplexTokenUsername.value,
self.current.myplexId.value), MessageBox.TYPE_INFO)
else:
response = self.plexInstance.getLastResponse()
self.session.openWithCallback(
self.saveNow, MessageBox,
(_("Error:") + "\n%s \n" + _("for the user:"******"\n%s") %
(response, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO)
printl("", self, "C")
def registerPlexFonts():
"""
registers fonts for skins
@param: none
@return none
"""
printl2("", "__common__::registerPlexFonts", "S")
printl2("adding fonts", "__common__::registerPlexFonts", "I")
tree = Singleton().getSkinParamsInstance()
#tree = getXmlContent("/usr/lib/enigma2/python/Plugins/Extensions/DreamPlex/skins/" + config.plugins.dreamplex.skins.value +"/params")
for font in tree.findall('font'):
path = str(font.get('path'))
printl2("path: " + str(font.get('path')), "__common__::registerPlexFonts", "D")
size = int(font.get('size'))
printl2("size: " + str(font.get('size')), "__common__::registerPlexFonts", "D")
name = str(font.get('name'))
printl2("name: " + str(font.get('name')), "__common__::registerPlexFonts", "D")
addFont(path, name, size, False)
printl2("added => " + name, "__common__::registerPlexFonts", "I")
printl2("", "__common__::registerPlexFonts", "C")
def registerPlexFonts():
"""
registers fonts for skins
@param: none
@return none
"""
printl2("", "__common__::registerPlexFonts", "S")
printl2("adding fonts", "__common__::registerPlexFonts", "I")
tree = Singleton().getSkinParamsInstance()
#tree = getXmlContent("/usr/lib/enigma2/python/Plugins/Extensions/DreamPlex/skins/" + config.plugins.dreamplex.skins.value +"/params")
for font in tree.findall('font'):
path = str(font.get('path'))
printl2("path: " + str(font.get('path')), "__common__::registerPlexFonts", "D")
size = int(font.get('size'))
printl2("size: " + str(font.get('size')), "__common__::registerPlexFonts", "D")
name = str(font.get('name'))
printl2("name: " + str(font.get('name')), "__common__::registerPlexFonts", "D")
addFont(path, name, size, False)
printl2("added => " + name, "__common__::registerPlexFonts", "I")
printl2("", "__common__::registerPlexFonts", "C")
def updateTimeline(self):
printl("" ,self,"S")
try:
currentTime = self.getPlayPosition()[1] / 90000
totalTime = self.getPlayLength()[1] / 90000
progress = int(( float(currentTime) / float(totalTime) ) * 100)
if totalTime > 100000:
return True
printl("currentTime: " + str(currentTime), self, "C")
printl("totalTime: " + str(totalTime), self, "C")
instance = Singleton()
plexInstance = instance.getPlexInstance()
seekState = self.seekstate
if seekState == self.SEEK_STATE_PAUSE:
printl( "Movies PAUSED time: %s secs of %s @ %s%%" % ( currentTime, totalTime, progress), self,"D" )
plexInstance.getTimelineURL(self.server, "/library/sections/onDeck", self.id, "paused", str(currentTime*1000), str(totalTime*1000))
if seekState == self.SEEK_STATE_PLAY :
printl( "Movies PLAYING time: %s secs of %s @ %s%%" % ( currentTime, totalTime, progress),self,"D" )
plexInstance.getTimelineURL(self.server, "/library/sections/onDeck", self.id, "playing", str(currentTime*1000), str(totalTime*1000))
except Exception, e:
printl("exception: " + str(e), self, "E")
return False
def registerPlexFonts():
"""
registers fonts for skins
@param: none
@return none
"""
printl2("", "__common__::registerPlexFonts", "S")
printl2("adding fonts", "__common__::registerPlexFonts", "D")
tree = Singleton().getSkinParamsInstance()
for font in tree.findall('font'):
path = str(font.get('path'))
printl2("path: " + str(font.get('path')), "__common__::registerPlexFonts", "D")
size = int(font.get('size'))
printl2("size: " + str(font.get('size')), "__common__::registerPlexFonts", "D")
name = str(font.get('name'))
printl2("name: " + str(font.get('name')), "__common__::registerPlexFonts", "D")
addFont(path, name, size, False)
printl2("added => " + name, "__common__::registerPlexFonts", "D")
printl2("", "__common__::registerPlexFonts", "C")
def writeToLog(dmode, out):
"""
singleton handler for the log file
@param dmode: E, W, S, H, A, C, I
@param out: message string
@return: none
"""
if config.plugins.dreamplex.writeDebugFile.value:
try:
instance = Singleton()
if instance.getLogFileInstance() is "":
openLogFile()
gLogFile = instance.getLogFileInstance()
gLogFile.truncate()
else:
gLogFile = instance.getLogFileInstance()
now = datetime.datetime.now()
gLogFile.write("%02d:%02d:%02d.%07d " % (now.hour, now.minute, now.second, now.microsecond) + " >>> " + str(
dmode) + " <<< " + str(out) + "\n")
gLogFile.flush()
except Exception, ex:
config.plugins.dreamplex.writeDebugFile.value = False
config.plugins.dreamplex.debugMode.save()
printl2("Exception(" + str(type(ex)) + "): " + str(ex), "__common__::writeToLog", "E")
def writeToLog(dmode, out):
"""
singleton handler for the log file
@param dmode: E, W, S, H, A, C, I
@param out: message string
@return: none
"""
try:
# =======================================================================
# if gLogFile is None:
# openLogFile()
# =======================================================================
instance = Singleton()
if instance.getLogFileInstance() is "":
openLogFile()
gLogFile = instance.getLogFileInstance()
gLogFile.truncate()
else:
gLogFile = instance.getLogFileInstance()
now = datetime.datetime.now()
gLogFile.write(
"%02d:%02d:%02d.%07d " % (now.hour, now.minute, now.second, now.microsecond)
+ " >>> "
+ str(dmode)
+ " <<< "
+ str(out)
+ "\n"
)
gLogFile.flush()
except Exception, ex:
printl2("Exception(" + str(type(ex)) + "): " + str(ex), "__common__::writeToLog", "E")
def writeToLog(dmode, out):
'''
singleton handler for the log file
@param dmode: E, W, S, H, A, C, I
@param out: message string
@return: none
'''
try:
#=======================================================================
# if gLogFile is None:
# openLogFile()
#=======================================================================
instance = Singleton()
if instance.getLogFileInstance() is "":
openLogFile()
gLogFile = instance.getLogFileInstance()
gLogFile.truncate()
else:
gLogFile = instance.getLogFileInstance()
now = datetime.datetime.now()
gLogFile.write("%02d:%02d:%02d.%07d " %
(now.hour, now.minute, now.second, now.microsecond) +
" >>> " + str(dmode) + " <<< " + str(out) + "\n")
gLogFile.flush()
except Exception, ex:
printl2("Exception(" + str(type(ex)) + "): " + str(ex),
"__common__::writeToLog", "E")
def writeToLog(dmode, out):
"""
singleton handler for the log file
@param dmode: E, W, S, H, A, C, I
@param out: message string
@return: none
"""
if config.plugins.dreamplex.writeDebugFile.value:
try:
instance = Singleton()
if instance.getLogFileInstance() is "":
openLogFile()
gLogFile = instance.getLogFileInstance()
gLogFile.truncate()
else:
gLogFile = instance.getLogFileInstance()
now = datetime.datetime.now()
gLogFile.write("%02d:%02d:%02d.%07d " % (now.hour, now.minute, now.second, now.microsecond) + " >>> " + str(
dmode) + " <<< " + str(out) + "\n")
gLogFile.flush()
except Exception, ex:
config.plugins.dreamplex.writeDebugFile.value = False
config.plugins.dreamplex.debugMode.save()
printl2("Exception(" + str(type(ex)) + "): " + str(ex), "__common__::writeToLog", "E")
def registerPlexFonts():
"""
registers fonts for skins
@param: none
@return none
"""
printl2("", "__common__::registerPlexFonts", "S")
printl2("adding fonts", "__common__::registerPlexFonts", "D")
tree = Singleton().getSkinParamsInstance()
for font in tree.findall('font'):
path = str(font.get('path'))
printl2("path: " + str(font.get('path')), "__common__::registerPlexFonts", "D")
size = int(font.get('size'))
printl2("size: " + str(font.get('size')), "__common__::registerPlexFonts", "D")
name = str(font.get('name'))
printl2("name: " + str(font.get('name')), "__common__::registerPlexFonts", "D")
addFont(path, name, size, False)
printl2("added => " + name, "__common__::registerPlexFonts", "D")
printl2("", "__common__::registerPlexFonts", "C")
def keyYellow(self):
printl("", self, "S")
if self.useMappings:
serverID = self.currentId
self.session.open(DPS_Mappings, serverID)
elif self.current.localAuth.value:
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(
PlexLibrary(self.session, self.current))
ipInConfig = "%d.%d.%d.%d" % tuple(self.current.ip.value)
token = self.plexInstance.getPlexUserTokenForLocalServerAuthentication(
ipInConfig)
if token:
self.current.myplexLocalToken.value = token
self.current.myplexLocalToken.save()
self.session.open(
MessageBox,
(_("Local Token:") + "\n%s \n" + _("for the user:"******"\n%s") % (token, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO)
else:
response = self.plexInstance.getLastResponse()
self.session.open(
MessageBox,
(_("Error:") + "\n%s \n" + _("for the user:"******"\n%s") %
(response, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO)
printl("", self, "C")
def openLogFile():
'''
singleton instance for logfile
@param: none
@return: none
'''
#printl2("", "openLogFile", "S")
logDir = config.plugins.dreamplex.logfolderpath.value
now = datetime.datetime.now()
try:
if os.path.exists(logDir + "dreamplex_former.log"):
os.remove(logDir + "dreamplex_former.log")
if os.path.exists(logDir + "dreamplex.log"):
shutil.copy2(logDir + "dreamplex.log",
logDir + "dreamplex_former.log")
instance = Singleton()
instance.getLogFileInstance(open(logDir + "dreamplex.log", "w"))
except Exception, ex:
printl2("Exception(" + str(type(ex)) + "): " + str(ex), "openLogFile",
"E")
def __init__(self, session, g_serverConfig ):
printl("", self, "S")
DPH_Screen.__init__(self, session)
DPH_ScreenHelper.__init__(self)
DPH_Filter.__init__(self)
DPH_PlexScreen.__init__(self)
self.selectionOverride = None
printl("selectionOverride:" +str(self.selectionOverride), self, "D")
self.session = session
self.g_serverConfig = g_serverConfig
self.plexInstance = Singleton().getPlexInstance()
self.guiElements = getGuiElements()
self.initScreen("server_menu")
self.initMenu()
if self.g_horizontal_menu:
self.setHorMenuElements(depth=2)
self.translateNames()
self["title"] = StaticText()
self["menu"]= List(enableWrapAround=True)
self["actions"] = HelpableActionMap(self, "DP_MainMenuActions",
{
"ok": (self.okbuttonClick, ""),
"left": (self.left, ""),
"right": (self.right, ""),
"up": (self.up, ""),
"down": (self.down, ""),
"cancel": (self.cancel, ""),
"red": (self.onKeyRed, ""),
"green": (self.onKeyGreen, ""),
}, -2)
self["btn_green"] = Pixmap()
self["btn_green"].hide()
self["btn_greenText"] = Label()
self["text_HomeUserLabel"] = Label()
self["text_HomeUser"] = Label()
self.onLayoutFinish.append(self.finishLayout)
self.onLayoutFinish.append(self.getInitialData)
self.onLayoutFinish.append(self.checkSelectionOverride)
printl("", self, "C")
def handleProgress(self, EOF=False):
printl("", self, "S")
currentTime = self.getPlayPosition()[1] / 90000
totalTime = self.getPlayLength()[1] / 90000
if not EOF and currentTime is not None and currentTime > 0 and totalTime is not None and totalTime > 0:
progress = currentTime / float(totalTime / 100.0)
printl(
"played time is %s secs of %s @ %s%%" %
(currentTime, totalTime, progress), self, "I")
else:
progress = 100
printl("End of file reached", self, "I")
instance = Singleton()
plexInstance = instance.getPlexInstance()
if self.multiUser:
plexInstance.getTimelineURL(self.server,
"/library/sections/onDeck", self.id,
"stopped", str(currentTime * 1000),
str(totalTime * 1000))
#Legacy PMS Server server support before MultiUser version v0.9.8.0 and if we are not connected via myPlex
else:
if currentTime < 30:
printl("Less that 30 seconds, will not set resume", self, "I")
#If we are less than 95% complete, store resume time
elif progress < 95:
printl("Less than 95% progress, will store resume time", self,
"I")
plexInstance.doRequest(
"http://" + self.server + "/:/progress?key=" + self.id +
"&identifier=com.plexapp.plugins.library&time=" +
str(currentTime * 1000))
#Otherwise, mark as watched
else:
printl("Movie marked as watched. Over 95% complete", self, "I")
plexInstance.doRequest(
"http://" + self.server + "/:/scrobble?key=" + self.id +
"&identifier=com.plexapp.plugins.library")
if self.multiUser and self.timelinewatcherThread.isAlive():
self.timelinewatcherthread_wait.set()
self.timelinewatcherthread_stop.set()
printl("", self, "C")
def playEntry(self, selection):
printl("-> in DP_ListMain", self, "S")
media_id = selection[1]['Id']
server = selection[1]['ArtPoster']
instance = Singleton()
plexInstance = instance.getPlexInstance()
print "server =>" + server
url = plexInstance.playStream(media_id, server, False)
sref = eServiceReference(0x1001, 0, str(url))
sref.setName("DreamPlex")
self.sref = sref
self.session.open(DP_Player, sref, self)
def getGuiElements():
printl("", "DP_ViewFactory::getGuiElements", "S")
tree = Singleton().getSkinParamsInstance()
guiElements = {}
for guiElement in tree.findall('guiElement'):
name = str(guiElement.get('name'))
path = str(guiElement.get('path'))
guiElements[name] = path
printl("guiElements: " + str(guiElements), "DP_ViewFactory::getGuiElements", "D")
printl("", "DP_ViewFactory::getGuiElements", "C")
return guiElements
def loadSkinParams():
printl2("", "__common__::loadSkinParams", "S")
global skinAuthors
global skinCompatibility
global skinResolution
tree = Singleton().getSkinParamsInstance()
for skinParams in tree.findall('skinParams'):
skinCompatibility = str(skinParams.get('compatibility'))
skinAuthors = str(skinParams.get('skinner'))
skinResolution = str(skinParams.get('resolution'))
printl2("", "__common__::loadSkinParams", "C")
def getGuiElements():
printl("", "DP_ViewFactory::getGuiElements", "S")
tree = Singleton().getSkinParamsInstance()
guiElements = {}
for guiElement in tree.findall('guiElement'):
name = str(guiElement.get('name'))
path = str(guiElement.get('path'))
guiElements[name] = path
printl("guiElements: " + str(guiElements),
"DP_ViewFactory::getGuiElements", "D")
printl("", "DP_ViewFactory::getGuiElements", "C")
return guiElements
def playMedia(self):
printl("", self, "S")
selection = self.listViewList[self.currentIndex]
printl("selection: " + str(selection), self, "D")
if "parentRatingKey" in selection[1]: # this is the case with shows
self.show_id = selection[1]['parentRatingKey']
self.isShow = True
else:
self.isShow = False
self.media_id = selection[1]['ratingKey']
self.selection = selection
server = selection[1]['server']
self.setPoster()
self.count, self.options, self.server = Singleton().getPlexInstance(
).getMediaOptionsToPlay(self.media_id,
server,
False,
myType=selection[1]['tagType'])
self.selectMedia(self.count, self.options, self.server)
printl("", self, "C")
def initMenu(self):
printl("", self, "S")
tree = Singleton().getSkinParamsInstance()
for menuScreen in tree.findall('menuScreen'):
name = str(menuScreen.get('name'))
if name == self.screenName:
myType = str(menuScreen.get('type'))
if myType == "horizontal":
self.g_horizontal_menu = True
self.highlightedColor = str(menuScreen.get('highlighted'))
self.normalColor = str(menuScreen.get('normal'))
printl("", self, "C")
def initMenu(self):
printl("", self, "S")
tree = Singleton().getSkinParamsInstance()
for menuScreen in tree.findall('menuScreen'):
name = str(menuScreen.get('name'))
if name == self.screenName:
myType = str(menuScreen.get('type'))
if myType == "horizontal":
self.g_horizontal_menu = True
self.highlightedColor = str(menuScreen.get('highlighted'))
self.normalColor = str(menuScreen.get('normal'))
printl("", self, "C")
def registerSkinParamsInstance():
printl("", "__init__::registerSkinParamsInstance", "S")
boxResolution = str(getBoxResolution())
skinName = str(config.plugins.dreamplex.skin.value)
printl("current skin: " + skinName,
"__common__::registerSkinParamsInstance", "S")
# if we are our default we switch automatically between the resolutions
if skinName == "default":
if boxResolution == "FHD":
skinfolder = "/usr/lib/enigma2/python/Plugins/Extensions/DreamPlex/skins/" + config.plugins.dreamplex.skin.value + "_FHD"
else:
skinfolder = "/usr/lib/enigma2/python/Plugins/Extensions/DreamPlex/skins/" + config.plugins.dreamplex.skin.value
else:
skinfolder = "/usr/lib/enigma2/python/Plugins/Extensions/DreamPlex/skins/" + config.plugins.dreamplex.skin.value
setSkinFolder(currentSkinFolder=skinfolder)
printl("current skinfolder: " + skinfolder,
"__common__::checkSkinResolution", "S")
configXml = getXmlContent(skinfolder + "/params")
Singleton().getSkinParamsInstance(configXml)
printl("", "__init__::registerSkinParamsInstance", "C")
def keyYellow(self):
printl("", self, "S")
if self.useMappings:
serverID = self.currentId
self.session.open(DPS_Mappings, serverID)
elif self.current.localAuth.value:
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.current))
ipInConfig = "%d.%d.%d.%d" % tuple(self.current.ip.value)
token = self.plexInstance.getPlexUserTokenForLocalServerAuthentication(ipInConfig)
if token:
self.current.myplexLocalToken.value = token
self.current.myplexLocalToken.save()
self.session.open(
MessageBox,
(_("Local Token:") + "\n%s \n" + _("for the user:"******"\n%s")
% (token, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO,
)
else:
response = self.plexInstance.getLastResponse()
self.session.open(
MessageBox,
(_("Error:") + "\n%s \n" + _("for the user:"******"\n%s")
% (response, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO,
)
printl("", self, "C")
def checkSkinResolution():
printl("", "__init__::checkSkinResolution", "S")
boxResolution = str(getBoxResolution())
printl("boxResolution: " + boxResolution,
"__common__::checkSkinResolution", "S")
skinResolution = str(getSkinResolution())
printl("skinResolution: " + skinResolution,
"__common__::checkSkinResolution", "S")
if boxResolution == "HD" and skinResolution == "FHD":
# if there is setup another FHD skin but the box skin is HD we switch automatically to default HD skin to avoid wrong screen size
# which leads to unconfigurable dreamplex
skinfolder = "/usr/lib/enigma2/python/Plugins/Extensions/DreamPlex/skins/default"
printl(
"switching to default due to mismatch of box and skin resolution!")
setSkinFolder(currentSkinFolder=skinfolder)
printl("current skinfolder: " + skinfolder,
"__common__::checkSkinResolution", "S")
configXml = getXmlContent(skinfolder + "/params")
Singleton().getSkinParamsInstance(configXml)
printl("", "__init__::checkSkinResolution", "C")
def stopTranscoding(self):
printl("", self, "S")
if self.multiUser:
self.timelinewatcherthread_wait.set()
self.timelinewatcherthread_stop.set()
instance = Singleton()
plexInstance = instance.getPlexInstance()
if self.universalTranscoder:
plexInstance.doRequest("http://"+self.server+"/video/:/transcode/universal/stop?session=" + self.transcodingSession)
else:
plexInstance.doRequest("http://"+self.server+"/video/:/transcode/segmented/stop?session=" + self.transcodingSession)
printl("", self, "C")
def loadLibrary(self, params):
'''
'''
printl ("", self, "S")
printl("params =" + str(params), self, "D")
url = self.g_url
printl("url: " + str(url), self, "D")
library, tmpAbc, tmpGenres = Singleton().getPlexInstance().getMoviesFromSection(url)
# sort
sort = [("by title", None, False), ("by year", "year", True), ("by rating", "rating", True), ]
filter = [("All", (None, False), ("", )), ]
# filter seen unseen
#filter.append(("Seen", ("viewState", "seen", ), ("", )))
# filter genres
#if len(tmpGenres) > 0:
#tmpGenres.sort()
#filter.append(("Genre", ("genre", True), tmpGenres))
printl ("", self, "C")
return (library, ("viewMode", "ratingKey", ), None, None, sort, filter)
def keyBlue(self):
printl("", self, "S")
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.current))
token = self.plexInstance.getNewMyPlexToken()
if token:
self.session.open(
MessageBox,
(_("myPlex Token:") + "\n%s \n" + _("for the user:"******"\n%s")
% (token, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO,
)
else:
response = self.plexInstance.getLastResponse()
self.session.open(
MessageBox,
(_("Error:") + "\n%s \n" + _("for the user:"******"\n%s")
% (response, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO,
)
printl("", self, "C")
def getLibraryDataFromPlex(self, url, nextViewMode, currentViewMode):
printl("", self, "S")
printl("nextViewMode: " + str(nextViewMode), self, "D")
printl("currentViewMode: " + str(currentViewMode), self, "D")
library = None
mediaContainer = None
# MUSIC
if nextViewMode == "artist":
library, mediaContainer = Singleton().getPlexInstance(
).getMusicByArtist(url)
elif nextViewMode == "ShowAlbums" or (currentViewMode == "ShowAlbums"
and nextViewMode
== "ShowDirectory"):
library, mediaContainer = Singleton().getPlexInstance(
).getMusicByAlbum(url)
elif nextViewMode == "ShowTracks":
library, mediaContainer = Singleton().getPlexInstance(
).getMusicTracks(url)
# MOVIES
elif nextViewMode == "movie" or (currentViewMode == "ShowMovies"
and nextViewMode == "ShowDirectory"):
library, mediaContainer = Singleton().getPlexInstance(
).getMoviesFromSection(url)
elif nextViewMode == "mixed":
library, mediaContainer = Singleton().getPlexInstance(
).getMixedContentFromSection(url)
# SHOWS
elif nextViewMode == "show":
library, mediaContainer = Singleton().getPlexInstance(
).getShowsFromSection(url)
elif nextViewMode == "ShowEpisodesDirect":
library, mediaContainer = Singleton().getPlexInstance(
).getEpisodesOfSeason(url, directMode=True)
elif nextViewMode == "ShowSeasons":
library, mediaContainer = Singleton().getPlexInstance(
).getSeasonsOfShow(url)
elif nextViewMode == "ShowEpisodes":
library, mediaContainer = Singleton().getPlexInstance(
).getEpisodesOfSeason(url)
printl("", self, "C")
return library, mediaContainer
def keySave(self, stayOpen=False):
printl("", self, "S")
if self.newmode == 1:
config.plugins.dreamplex.entriescount.value += 1
config.plugins.dreamplex.entriescount.save()
#if self.current.machineIdentifier.value == "":
from DP_PlexLibrary import PlexLibrary
self.plexInstance = Singleton().getPlexInstance(
PlexLibrary(self.session, self.current))
machineIdentifiers = ""
if self.current.connectionType.value == "2":
xmlResponse = self.plexInstance.getSharedServerForPlexUser()
machineIdentifier = xmlResponse.get("machineIdentifier")
if machineIdentifier is not None:
machineIdentifiers += machineIdentifier
servers = xmlResponse.findall("Server")
for server in servers:
machineIdentifier = server.get("machineIdentifier")
if machineIdentifier is not None:
machineIdentifiers += ", " + machineIdentifier
else:
xmlResponse = self.plexInstance.getXmlTreeFromUrl(
"http://" + self.plexInstance.g_currentServer)
machineIdentifier = xmlResponse.get("machineIdentifier")
if machineIdentifier is not None:
machineIdentifiers += xmlResponse.get("machineIdentifier")
self.current.machineIdentifier.value = machineIdentifiers
printl(
"machineIdentifier: " + str(self.current.machineIdentifier.value),
self, "D")
config.plugins.dreamplex.entriescount.save()
config.plugins.dreamplex.Entries.save()
config.plugins.dreamplex.save()
configfile.save()
if not stayOpen:
self.close()
printl("", self, "C")
def buildPlayerData(self, mediaFileUrl):
printl("", self, "S")
Singleton().getPlexInstance().setPlaybackType(str(self.playbackMode))
if self.isExtraData:
Singleton().getPlexInstance().setPlaybackType(str(1))
self.playerData[self.currentIndex] = Singleton().getPlexInstance(
).playLibraryMedia(self.media_id, mediaFileUrl)
# populate addional data
self.setPlayerData()
self.playSelectedMedia()
printl("", self, "C")
def getMiniTvParams(self):
printl("", self, "S")
tree = Singleton().getSkinParamsInstance()
width = 400
height = 225
printl("menuType: " + str(self.menuType), self, "D")
for miniTv in tree.findall('miniTv'):
name = str(miniTv.get('name'))
if name == self.menuType:
width = miniTv.get('width')
height = miniTv.get('height')
printl("width: " + str(width) + " - height: " + str(height), self, "D")
printl("", self, "C")
return int(width), int(height)
def __init__(self, session, mode, serverConfig=None):
Screen.__init__(self, session)
DPH_ScreenHelper.__init__(self)
DPH_PlexScreen.__init__(self)
self.guiElements = getGuiElements()
self.initScreen("syncer")
self.serverConfig = serverConfig
self.resolution = getSkinResolution()
if serverConfig is not None:
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.serverConfig))
# we are "sync" or "render"
self._mode = mode
# we use the global g_mediaSyncerInfo.instance to take care only having one instance
self.mediaSyncerInfo = g_mediaSyncerInfo.instance
self["output"] = ScrollLabel()
self["progress"] = Label()
# we use this counter to reset scorll label every x entries to stay responsive
self.counter = 0
self["btn_greenText"] = Label()
if self._mode == "sync":
self["btn_greenText"].setText(_("Start Sync"))
else:
self["btn_greenText"].setText(_("Start Rendering"))
self["btn_green"] = Pixmap()
self["btn_blueText"] = Label()
self["btn_blueText"].setText(_("Background"))
self["btn_blue"] = Pixmap()
self["btn_redText"] = Label()
self["btn_redText"].setText(_("Abort"))
self["btn_red"] = Pixmap()
self["setupActions"] = ActionMap(["DPS_Syncer"],
{
"red": self.keyRed,
"blue": self.keyBlue,
"yellow": self.keyYellow,
"green": self.keyGreen,
"bouquet_up": self.keyBouquetUp,
"bouquet_down": self.keyBouquetDown,
"cancel": self.exit,
}, -2)
self.onFirstExecBegin.append(self.startup)
self.onShown.append(self.finishLayout)
self.onClose.append(self.__onClose)
def registerSkinParamsInstance():
printl("", "__init__::registerSkinParamsInstance", "S")
configXml = getXmlContent(
"/usr/lib/enigma2/python/Plugins/Extensions/DreamPlex/skins/" +
config.plugins.dreamplex.skins.value + "/params")
Singleton().getSkinParamsInstance(configXml)
printl("", "__init__::registerSkinParamsInstance", "C")
def openLogFile():
"""
singleton instance for logfile
@param: none
@return: none
"""
# printl2("", "openLogFile", "S")
logDir = config.plugins.dreamplex.logfolderpath.value
now = datetime.datetime.now()
try:
instance = Singleton()
instance.getLogFileInstance(open(logDir + "dreamplex.log", "w"))
except Exception, ex:
printl2("Exception(" + str(type(ex)) + "): " + str(ex), "openLogFile", "E")
def openLogFile():
"""
singleton instance for logfile
"""
#printl2("", "openLogFile", "S")
logDir = config.plugins.dreamplex.logfolderpath.value
try:
if os.path.exists(logDir + "dreamplex_former.log"):
os.remove(logDir + "dreamplex_former.log")
if os.path.exists(logDir + "dreamplex.log"):
shutil.copy2(logDir + "dreamplex.log", logDir + "dreamplex_former.log")
instance = Singleton()
instance.getLogFileInstance(open(logDir + "dreamplex.log", "w"))
except Exception, ex:
printl2("Exception(" + str(type(ex)) + "): " + str(ex), "openLogFile", "E")
def __init__(self, session, g_serverConfig):
printl("", self, "S")
DPH_Screen.__init__(self, session)
DPH_ScreenHelper.__init__(self)
DPH_Filter.__init__(self)
DPH_PlexScreen.__init__(self)
self.selectionOverride = None
printl("selectionOverride:" + str(self.selectionOverride), self, "D")
self.session = session
self.g_serverConfig = g_serverConfig
self.plexInstance = Singleton().getPlexInstance()
self.guiElements = getGuiElements()
self.initScreen("server_menu")
self.initMenu()
if self.g_horizontal_menu:
self.setHorMenuElements(depth=2)
self.translateNames()
self["title"] = StaticText()
self["menu"] = List(enableWrapAround=True)
self["actions"] = HelpableActionMap(
self,
"DP_MainMenuActions",
{
"ok": (self.okbuttonClick, ""),
"left": (self.left, ""),
"right": (self.right, ""),
"up": (self.up, ""),
"down": (self.down, ""),
"cancel": (self.cancel, ""),
"red": (self.onKeyRed, ""),
"green": (self.onKeyGreen, ""),
},
-2,
)
self["btn_green"] = Pixmap()
self["btn_green"].hide()
self["btn_greenText"] = Label()
self["text_HomeUserLabel"] = Label()
self["text_HomeUser"] = Label()
self.onLayoutFinish.append(self.finishLayout)
self.onLayoutFinish.append(self.getInitialData)
self.onLayoutFinish.append(self.checkSelectionOverride)
printl("", self, "C")
def keyRed(self):
printl("", self, "S")
if self.useHomeUsers:
serverID = self.currentId
plexInstance = Singleton().getPlexInstance(
PlexLibrary(self.session, self.current))
self.session.open(DPS_Users, serverID, plexInstance)
#self.session.open(MessageBox,(_("myPlex Token:") + "\n%s \n" + _("myPlex Localtoken:") + "\n%s \n"+ _("for the user:"******"\n%s") % (self.current.myplexToken.value, self.current.myplexLocalToken.value, self.current.myplexTokenUsername.value), MessageBox.TYPE_INFO)
printl("", self, "C")
def loadSkinParams():
printl2("", "__common__::loadSkinParams", "S")
global skinAuthors
global skinCompatibility
global skinResolution
global skinDebugMode
global skinHighlightedColor
global skinNormalColor
tree = Singleton().getSkinParamsInstance()
for skinParams in tree.findall('skinParams'):
skinCompatibility = str(skinParams.get('compatibility'))
skinAuthors = str(skinParams.get('skinner'))
skinResolution = str(skinParams.get('resolution'))
skinDebugMode = str(skinParams.get('debugMode'))
skinHighlightedColor = str(skinParams.get('highlighted'))
skinNormalColor = str(skinParams.get('normal'))
printl2("", "__common__::loadSkinParams", "C")
def loadSkinParams():
printl2("", "__common__::loadSkinParams", "S")
global skinAuthors
global skinCompatibility
global skinResolution
global skinDebugMode
global skinHighlightedColor
global skinNormalColor
tree = Singleton().getSkinParamsInstance()
for skinParams in tree.findall('skinParams'):
skinCompatibility = str(skinParams.get('compatibility'))
skinAuthors = str(skinParams.get('skinner'))
skinResolution = str(skinParams.get('resolution'))
skinDebugMode = str(skinParams.get('debugMode'))
skinHighlightedColor = str(skinParams.get('highlighted'))
skinNormalColor = str(skinParams.get('normal'))
printl2("", "__common__::loadSkinParams", "C")
def updateTimeline(self):
printl("", self, "S")
try:
currentTime = self.getPlayPosition()[1] / 90000
totalTime = self.getPlayLength()[1] / 90000
progress = int((float(currentTime) / float(totalTime)) * 100)
if totalTime > 100000:
return True
printl("currentTime: " + str(currentTime), self, "C")
printl("totalTime: " + str(totalTime), self, "C")
instance = Singleton()
plexInstance = instance.getPlexInstance()
seekState = self.seekstate
if seekState == self.SEEK_STATE_PAUSE:
printl(
"Movies PAUSED time: %s secs of %s @ %s%%" %
(currentTime, totalTime, progress), self, "D")
plexInstance.getTimelineURL(self.server,
"/library/sections/onDeck",
self.id, "paused",
str(currentTime * 1000),
str(totalTime * 1000))
if seekState == self.SEEK_STATE_PLAY:
printl(
"Movies PLAYING time: %s secs of %s @ %s%%" %
(currentTime, totalTime, progress), self, "D")
plexInstance.getTimelineURL(self.server,
"/library/sections/onDeck",
self.id, "playing",
str(currentTime * 1000),
str(totalTime * 1000))
except Exception, e:
printl("exception: " + str(e), self, "E")
return False
def initScreen(self, screenName):
printl("", self, "S")
tree = Singleton().getSkinParamsInstance()
self.screenName = screenName
for screen in tree.findall('screen'):
name = str(screen.get('name'))
if name == self.screenName:
self.miniTv = translateValues(str(screen.get('miniTv')))
if self.miniTv:
self.width = screen.get('width')
self.height = screen.get('height')
else:
self.Poster= translateValues(str(screen.get('usePoster')))
if self.Poster:
self.width = screen.get('width')
self.height = screen.get('height')
printl("", self, "C")
def initScreen(self, screenName):
printl("", self, "S")
tree = Singleton().getSkinParamsInstance()
self.screenName = screenName
for screen in tree.findall('screen'):
name = str(screen.get('name'))
if name == self.screenName:
self.miniTv = translateValues(str(screen.get('miniTv')))
if self.miniTv:
self.width = screen.get('width')
self.height = screen.get('height')
else:
self.Poster = translateValues(str(screen.get('usePoster')))
if self.Poster:
self.width = screen.get('width')
self.height = screen.get('height')
printl("", self, "C")
def stopTranscoding(self):
printl("", self, "S")
if self.multiUser:
self.timelinewatcherthread_wait.set()
self.timelinewatcherthread_stop.set()
instance = Singleton()
plexInstance = instance.getPlexInstance()
if self.universalTranscoder:
plexInstance.doRequest(
"http://" + self.server +
"/video/:/transcode/universal/stop?session=" +
self.transcodingSession)
else:
plexInstance.doRequest(
"http://" + self.server +
"/video/:/transcode/segmented/stop?session=" +
self.transcodingSession)
printl("", self, "C")
def selectMedia(self, count, options, server):
printl("", self, "S")
#if we have two or more files for the same movie, then present a screen
self.options = options
self.server = server
self.dvdplayback = False
if not self.options:
response = Singleton().getPlexInstance().getLastResponse()
self.session.open(MessageBox, (_("Error:") + "\n%s") % response,
MessageBox.TYPE_INFO)
else:
if count > 1:
printl("we have more than one playable part ...", self, "I")
indexCount = 0
functionList = []
for items in self.options:
printl("item: " + str(items), self, "D")
if items[1] is not None:
name = items[1].split('/')[-1]
else:
size = convertSize(int(items[3]))
duration = time.strftime('%H:%M:%S',
time.gmtime(int(items[4])))
# this is the case when there is no information of the real file name
name = items[0] + " (" + items[
2] + " / " + size + " / " + duration + ")"
printl("name " + str(name), self, "D")
functionList.append((
name,
indexCount,
))
indexCount += 1
self.session.openWithCallback(self.setSelectedMedia,
ChoiceBox,
title=_("Select media to play"),
list=functionList)
else:
self.setSelectedMedia()
printl("", self, "C")
def keySave(self, stayOpen = False):
printl("", self, "S")
if self.newmode == 1:
config.plugins.dreamplex.entriescount.value += 1
config.plugins.dreamplex.entriescount.save()
#if self.current.machineIdentifier.value == "":
from DP_PlexLibrary import PlexLibrary
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.current))
machineIdentifiers = ""
if self.current.connectionType.value == "2":
xmlResponse = self.plexInstance.getSharedServerForPlexUser()
machineIdentifier = xmlResponse.get("machineIdentifier")
if machineIdentifier is not None:
machineIdentifiers += machineIdentifier
servers = xmlResponse.findall("Server")
for server in servers:
machineIdentifier = server.get("machineIdentifier")
if machineIdentifier is not None:
machineIdentifiers += ", " + machineIdentifier
else:
xmlResponse = self.plexInstance.getXmlTreeFromUrl("http://" + self.plexInstance.g_currentServer)
machineIdentifier = xmlResponse.get("machineIdentifier")
if machineIdentifier is not None:
machineIdentifiers += xmlResponse.get("machineIdentifier")
self.current.machineIdentifier.value = machineIdentifiers
printl("machineIdentifier: " + str(self.current.machineIdentifier.value), self, "D")
config.plugins.dreamplex.entriescount.save()
config.plugins.dreamplex.Entries.save()
config.plugins.dreamplex.save()
configfile.save()
if not stayOpen:
self.close()
printl("", self, "C")
def setSelectedMedia(self, choice=None):
printl("", self, "S")
result = 0
printl("choice: " + str(choice), self, "D")
if choice is not None:
result = int(choice[1])
printl("result: " + str(result), self, "D")
mediaFileUrl = Singleton().getPlexInstance().mediaType(
{
'key': self.options[result][0],
'file': self.options[result][1]
}, self.server)
printl("We have selected media at " + mediaFileUrl, self, "I")
self.buildPlayerData(mediaFileUrl)
printl("", self, "C")
def buildPosterData(self):
printl("", self, "S")
mediaPath = config.plugins.dreamplex.mediafolderpath.value
image_prefix = Singleton().getPlexInstance().getServerName().lower()
self.poster_postfix = "_poster_" + self.width + "x" + self.height + "_v2.jpg"
if self.isShow:
self.whatPoster = mediaPath + image_prefix + "_" + self.show_id + self.poster_postfix
else:
self.whatPoster = mediaPath + image_prefix + "_" + self.media_id + self.poster_postfix
printl("what poster: " + self.whatPoster, self, "D")
printl("builded poster data: " + str(self.whatPoster), self, "D")
if not fileExists(self.whatPoster):
self.downloadPoster()
if config.plugins.dreamplex.lcd4linux.value:
self.preparePosterForExternalUsage()
printl("", self, "C")
def okbuttonClick(self, selectionOverride = None):
printl("", self, "S")
# this is used to step in directly into a server when there is only one entry in the serverlist
if selectionOverride is not None:
selection = selectionOverride
else:
selection = self["menu"].getCurrent()
printl("selection = " + str(selection), self, "D")
self.nextExitIsQuit = False
if selection is not None:
self.selectedEntry = selection[1]
printl("selected entry " + str(self.selectedEntry), self, "D")
if type(self.selectedEntry) is int:
printl("selected entry is int", self, "D")
if self.selectedEntry == Plugin.MENU_MAIN:
printl("found Plugin.MENU_MAIN", self, "D")
self["menu"].setList(self.menu_main_list)
elif self.selectedEntry == Plugin.MENU_SERVER:
printl("found Plugin.MENU_SERVER", self, "D")
self.g_serverConfig = selection[3]
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.g_serverConfig))
self.checkServerState()
elif self.selectedEntry == Plugin.MENU_MOVIES:
printl("found Plugin.MENU_MOVIES", self, "D")
self.getServerData("movies")
elif self.selectedEntry == Plugin.MENU_TVSHOWS:
printl("found Plugin.MENU_TVSHOWS", self, "D")
self.getServerData("tvshow")
elif self.selectedEntry == Plugin.MENU_MUSIC:
printl("found Plugin.MENU_MUSIC", self, "D")
self.getServerData("music")
elif self.selectedEntry == Plugin.MENU_FILTER:
printl("found Plugin.MENU_FILTER", self, "D")
params = selection[3]
printl("params: " + str(params), self, "D")
self.s_url = params.get('t_url', "notSet")
self.s_mode = params.get('t_mode', "notSet")
self.s_final = params.get('t_final', "notSet")
self.s_source = params.get('t_source', "notSet")
self.s_uuid = params.get('t_uuid', "notSet")
self.getFilterData()
elif self.selectedEntry == Plugin.MENU_SYSTEM:
printl("found Plugin.MENU_SYSTEM", self, "D")
self["menu"].setList(self.getSettingsMenu())
self.refreshMenu(0)
elif type(self.selectedEntry) is str:
printl("selected entry is string", self, "D")
if selection[1] == "DPS_Settings":
self.session.open(DPS_Settings)
elif selection[1] == "DPS_ServerEntriesListConfigScreen":
self.session.open(DPS_ServerEntriesListConfigScreen)
elif selection[1] == "DPS_SystemCheck":
self.session.open(DPS_SystemCheck)
elif selection[1] == "DPS_About":
self.session.open(DPS_About)
elif selection[1] == "DPS_Help":
self.session.open(DPS_Help)
elif selection[1] == "DPS_Exit":
self.exit()
elif selection[1] == "getMusicSections":
self.getMusicSections(selection)
else:
printl("selected entry is executable", self, "D")
params = selection[3]
printl("params: " + str(params), self, "D")
self.s_url = params.get('t_url', "notSet")
self.showEpisodesDirectly = params.get('t_showEpisodesDirectly', "notSet")
self.uuid = params.get('t_uuid', "notSet")
self.source = params.get('t_source', "notSet")
self.viewGroup = params.get('t_viewGroup', "notSet")
isSearchFilter = params.get('isSearchFilter', "notSet")
printl("isSearchFilter: " + str(isSearchFilter), self, "D")
if isSearchFilter == "True" or isSearchFilter and isSearchFilter != "notSet":
printl("i am here: " + str(isSearchFilter), self, "D")
self.session.openWithCallback(self.addSearchString, InputBox, title=_("Please enter your search string!"), text="", maxSize=55, type=Input.TEXT)
else:
self.executeSelectedEntry()
printl("", self, "C")
class RemoteHandler(BaseHTTPRequestHandler):
"""
Serves a HEAD request
"""
session = None
playerCallback = None
#===========================================================================
#
#===========================================================================
def do_HEAD(self):
printl("", self, "S")
printl("Serving HEAD request...", self, "D")
self.answer_request()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def do_GET(self):
printl("", self, "S")
printl("Serving GET request...", self, "D")
self.answer_request()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def do_OPTIONS(self):
printl("", self, "S")
printl("Serving OPTIONS request...", self, "D")
self.send_response(200)
self.setAccessControlHeaders()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def answer_request(self):
printl("", self, "S")
try:
self.send_response(200)
self.setAccessControlHeaders()
request_path=self.path[1:]
request_path=re.sub(r"\?.*","",request_path)
printl("request path is: [%s]" % request_path, self, "D")
if request_path == "player/timeline/poll":
sleep(10)
xml = "<MediaContainer location='navigation' commandID='10'><Timeline state='stopped' time='0' type='music' /><Timeline state='stopped' time='0' type='video' /><Timeline state='stopped' time='0' type='photo' /></MediaContainer>"
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
elif request_path == "resources":
xml = self.getResourceXml()
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
elif request_path == "player/timeline/subscribe":
xml = "<MediaContainer location='navigation' commandID='10'><Timeline state='stopped' time='0' type='music' /><Timeline state='stopped' time='0' type='video' /><Timeline state='stopped' time='0' type='photo' /></MediaContainer>"
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
elif request_path == "player/playback/seekTo":
params = self.getParams()
offset = params["offset"][0]
elif request_path == "player/playback/setParameters":
params = self.getParams()
volume = params["volume"][0]
url = "http://localhost/web/vol?set=set" + str(volume)
urllib.urlopen(url)
self.send_response(200)
elif request_path == "/player/playback/pause":
url = "http://localhost/web/remotecontrol?command=400"
urllib.urlopen(url)
xml = "<MediaContainer location='navigation' commandID='10'><Timeline state='paused' time='0' type='music' /><Timeline state='paused' time='0' type='video' /><Timeline state='paused' time='0' type='photo' /></MediaContainer>"
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
elif request_path == "player/playback/stop":
url = "http://localhost/web/remotecontrol?command=377"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/skipNext":
url = "http://localhost/web/remotecontrol?command=407"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/stepForward":
url = "http://localhost/web/remotecontrol?command=10"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/stepBack":
url = "http://localhost/web/remotecontrol?command=8"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/skipPrevious":
url = "http://localhost/web/remotecontrol?command=412"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/playMedia":
url = "http://localhost/web/powerstate?newstate=4"
urllib.urlopen(url)
params = self.getParams()
address = params["address"][0]
port = params["port"][0]
completeAddress = address+":"+port
protocol = params["protocol"][0]
key = params["key"][0]
if "offset" in params:
offset = int(params["offset"][0])
else:
offset = 0
machineIdentifier = params["machineIdentifier"][0]
printl("target machineIdentifier: " + str(machineIdentifier), self, "D")
for serverConfig in config.plugins.dreamplex.Entries:
printl("current machineIdentifier: " + str(serverConfig.machineIdentifier.value), self, "D")
if machineIdentifier in serverConfig.machineIdentifier.value:
printl("we have a match ...", self, "D")
self.g_serverConfig = serverConfig
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.g_serverConfig, completeAddress, machineIdentifier))
listViewList, mediaContainer = self.plexInstance.getMoviesFromSection(protocol + "://" + address + ":" + port + key)
autoPlayMode = False
if offset > 0:
forceResume = True
else:
forceResume = False
resumeMode = False # this is always false because the ios and android app ask itself if we want to resume :-) no need to ask second time
playbackMode = self.g_serverConfig.playbackType.value
currentIndex = 0
libraryName = "Mixed"
data = {"listViewList": listViewList, "mediaContainer": mediaContainer, "autoPlayMode": autoPlayMode, "forceResume": forceResume, "resumeMode": resumeMode, "playbackMode": playbackMode, "currentIndex": currentIndex, "libraryName": libraryName}
self.playerCallback(data)
xml = "<MediaContainer location='navigation' commandID='10'><Timeline state='stopped' time='0' type='music' /><Timeline state='stopped' time='0' type='video' /><Timeline state='stopped' time='0' type='photo' /></MediaContainer>"
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
else:
printl("no match ...", self, "D")
else:
self.send_response(200)
except:
traceback.print_exc()
self.wfile.close()
printl("", self, "C")
return
try:
self.wfile.close()
except:
pass
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def address_string(self):
printl("", self, "S")
host, port = self.client_address[:2]
#return socket.getfqdn(host)
printl("", self, "C")
return host
#===========================================================================
#
#===========================================================================
def getResourceXml(self):
printl("", self, "S")
xml = "<MediaContainer><Player protocolCapabilities='playback, navigation' product='"+ getMyIp() +"' platformVersion='"+ getVersion() +"' platform='Enigma2' machineIdentifier='"+ getUUID() +"' title='"+ config.plugins.dreamplex.boxName.value +"' protocolVersion='1' deviceClass='stb'/></MediaContainer>"
printl("", self, "C")
return xml
#===========================================================================
#
#===========================================================================
def setXmlHeader(self, xml):
printl("", self, "S")
self.send_header('Content-type', 'text/xml; charset="utf-8"')
self.send_header('Content-Length', str(len(xml)))
printl("", self, "S")
#===========================================================================
#
#===========================================================================
def setAccessControlHeaders(self):
printl("", self, "S")
self.send_header('Access-Control-Allow-Credentials', 'true')
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
self.send_header("Access-Control-Allow-Headers", "x-plex-client-identifier,x-plex-device,x-plex-device-name,x-plex-platform,x-plex-platform-version,x-plex-product,x-plex-target-client-identifier,x-plex-username,x-plex-version")
printl("", self, "S")
#===========================================================================
#
#===========================================================================
def getParams(self):
printl("", self, "S")
printl("", self, "C")
return parse_qs(urlparse(self.path).query)
def loadLibrary(self, params):
printl("", self, "S")
printl("params: " + str(params), self, "D")
if self.showEpisodesDirectly:
printl("show episodes directly ...", self, "I")
url = self.g_url
library = Singleton().getPlexInstance().getEpisodesOfSeason(
url, directMode=True)
sort = [
("by title", None, False),
]
myFilter = [
("All", (None, False), ("", )),
]
#filter.append(("Seen", ("Seen", False, 1), ("Seen", "Unseen", )))
printl("", self, "C")
return library, (
"viewMode",
"ratingKey",
), None, "None", sort, myFilter
else:
# Diplay all TVShows
if params["viewMode"] is None:
printl("show TV shows ...", self, "I")
url = self.g_url
printl("url: " + str(url), self, "D")
if config.plugins.dreamplex.useCache.value:
#noinspection PyAttributeOutsideInit
self.tvShowPickle = "%s%s_%s_%s.cache" % (
config.plugins.dreamplex.cachefolderpath.value,
"tvShowSection", self.g_uuid, self.g_viewGroup)
# params['cache'] is default None. if it is present and it is False we know that we triggered refresh
# for this reason we have to set self.g_source = 'plex' because the if is with "or" and not with "and" which si not possible
if "cache" in params:
if not params['cache']:
self.g_source = "plex"
if self.g_source == "cache" or params['cache'] == True:
try:
fd = open(self.tvShowPickle, "rb")
pickleData = pickle.load(fd)
library = pickleData[0]
# todo we have to check if we will need this in future or not
#tmpAbc = pickleData[1]
#tmpGenres = pickleData [2]
fd.close()
printl("from pickle", self, "D")
except:
printl("movie cache not found ... saving", self,
"D")
library, tmpAbc, tmpGenres = Singleton(
).getPlexInstance().getShowsFromSection(url)
reason = "cache file does not exists, recreating ..."
self.generatingCacheForTvShowSection(
reason, library, tmpAbc, tmpGenres)
printl("fallback to: from server", self, "D")
else:
library, tmpAbc, tmpGenres = Singleton(
).getPlexInstance().getShowsFromSection(url)
reason = "generating cache first time, creating ..."
self.generatingCacheForTvShowSection(
reason, library, tmpAbc, tmpGenres)
else:
library, tmpAbc, tmpGenres = Singleton().getPlexInstance(
).getShowsFromSection(url)
# sort
sort = [
("by title", None, False),
("by year", "year", True),
("by rating", "rating", True),
]
myFilter = [
("All", (None, False), ("", )),
]
#if len(tmpGenres) > 0:
#tmpGenres.sort()
#filter.append(("Genre", ("Genres", True), tmpGenres))
printl("", self, "C")
return library, (
"viewMode",
"ratingKey",
), None, None, sort, myFilter
# (libraryArray, onEnterPrimaryKeys, onLeavePrimaryKeys, onLeaveSelectEntry
# Display the Seasons Menu
elif params["viewMode"] == "ShowSeasons":
printl("show seasons of TV show ...", self, "I")
url = params["url"]
library = Singleton().getPlexInstance().getSeasonsOfShow(url)
sort = (("by season", True, False), )
myFilter = [
("All", (None, False), ("", )),
]
printl("", self, "C")
return library, (
"viewMode",
"ratingKey",
), None, "backToShows", sort, myFilter
# (libraryArray, onEnterPrimaryKeys, onLeavePrimaryKeys, onLeaveSelectEntry
# Display the Episodes Menu
elif params["viewMode"] == "ShowEpisodes":
printl("show episodes of season ...", self, "I")
url = params["url"]
library = Singleton().getPlexInstance().getEpisodesOfSeason(
url)
sort = [
("by title", None, False),
]
myFilter = [
("All", (None, False), ("", )),
]
#filter.append(("Seen", ("Seen", False, 1), ("Seen", "Unseen", )))
printl("", self, "C")
return library, (
"viewMode",
"ratingKey",
), None, "backToSeasons", sort, myFilter
# (libraryArray, onEnterPrimaryKeys, onLeavePrimaryKeys, onLeaveSelectEntry
printl("", self, "C")
def getViewsFromSkinParams(myType):
printl("", __name__, "S")
tree = Singleton().getSkinParamsInstance()
availableViewList = []
if myType == "movieView":
myFile = "DP_ViewMovies"
myClass = "DPS_ViewMovies"
defaultParams = getMovieViewDefaults()
elif myType == "showView":
myFile = "DP_ViewShows"
myClass = "DPS_ViewShows"
defaultParams = getShowViewDefaults()
elif myType == "episodeView":
myFile = "DP_ViewShows"
myClass = "DPS_ViewEpisodes"
defaultParams = getEpisodesViewDefaults()
elif myType == "musicView":
myFile = "DP_ViewMusic"
myClass = "DPS_ViewMusic"
defaultParams = getMusicViewDefaults()
else:
raise Exception()
for view in tree.findall(myType):
# lets copy params to new alterable variable
currentParams = copy.deepcopy(defaultParams)
printl("currentParams: " + str(currentParams), __name__, "D")
useMe, subViewDict = getSubViewParams(view)
if useMe:
currentParams["subViews"] = subViewDict
name = str(view.get("name"))
printl("viewMe:" + str(view), __name__, "D")
# settings
settings = defaultParams["settings"]
for setting in settings:
printl("setting:" + str(setting), __name__, "D")
#check if there are params that we have to override
value = view.get(setting, None)
printl("value: " + str(value), __name__, "D")
# check if this value is mandatory
# if we are mandatory we stop here
if defaultParams["settings"][setting] == "mandatory" and value is None:
raise Exception
else:
currentParams["settings"][setting] = translateValues(value)
# override params in the main first = main screen
for main in view.findall("main"):
name = main.get("name")
printl("name: " + str(name), __name__, "D")
params = main.attrib
printl("params: " + str(params), __name__, "D")
for key, value in params.items():
translatedValue = translateValues(value)
if key != "name":
currentParams["elements"][name][key] = translatedValue
view = (_(name), myFile, myClass, currentParams)
availableViewList.append(view)
printl("availableViewList: " + str(availableViewList), __name__, "D")
printl("", __name__, "C")
return availableViewList
def answer_request(self):
printl("", self, "S")
try:
self.send_response(200)
self.setAccessControlHeaders()
request_path=self.path[1:]
request_path=re.sub(r"\?.*","",request_path)
printl("request path is: [%s]" % request_path, self, "D")
if request_path == "player/timeline/poll":
sleep(10)
xml = "<MediaContainer location='navigation' commandID='10'><Timeline state='stopped' time='0' type='music' /><Timeline state='stopped' time='0' type='video' /><Timeline state='stopped' time='0' type='photo' /></MediaContainer>"
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
elif request_path == "resources":
xml = self.getResourceXml()
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
elif request_path == "player/timeline/subscribe":
xml = "<MediaContainer location='navigation' commandID='10'><Timeline state='stopped' time='0' type='music' /><Timeline state='stopped' time='0' type='video' /><Timeline state='stopped' time='0' type='photo' /></MediaContainer>"
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
elif request_path == "player/playback/seekTo":
params = self.getParams()
offset = params["offset"][0]
elif request_path == "player/playback/setParameters":
params = self.getParams()
volume = params["volume"][0]
url = "http://localhost/web/vol?set=set" + str(volume)
urllib.urlopen(url)
self.send_response(200)
elif request_path == "/player/playback/pause":
url = "http://localhost/web/remotecontrol?command=400"
urllib.urlopen(url)
xml = "<MediaContainer location='navigation' commandID='10'><Timeline state='paused' time='0' type='music' /><Timeline state='paused' time='0' type='video' /><Timeline state='paused' time='0' type='photo' /></MediaContainer>"
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
elif request_path == "player/playback/stop":
url = "http://localhost/web/remotecontrol?command=377"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/skipNext":
url = "http://localhost/web/remotecontrol?command=407"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/stepForward":
url = "http://localhost/web/remotecontrol?command=10"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/stepBack":
url = "http://localhost/web/remotecontrol?command=8"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/skipPrevious":
url = "http://localhost/web/remotecontrol?command=412"
urllib.urlopen(url)
self.send_response(200)
elif request_path == "player/playback/playMedia":
url = "http://localhost/web/powerstate?newstate=4"
urllib.urlopen(url)
params = self.getParams()
address = params["address"][0]
port = params["port"][0]
completeAddress = address+":"+port
protocol = params["protocol"][0]
key = params["key"][0]
if "offset" in params:
offset = int(params["offset"][0])
else:
offset = 0
machineIdentifier = params["machineIdentifier"][0]
printl("target machineIdentifier: " + str(machineIdentifier), self, "D")
for serverConfig in config.plugins.dreamplex.Entries:
printl("current machineIdentifier: " + str(serverConfig.machineIdentifier.value), self, "D")
if machineIdentifier in serverConfig.machineIdentifier.value:
printl("we have a match ...", self, "D")
self.g_serverConfig = serverConfig
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.g_serverConfig, completeAddress, machineIdentifier))
listViewList, mediaContainer = self.plexInstance.getMoviesFromSection(protocol + "://" + address + ":" + port + key)
autoPlayMode = False
if offset > 0:
forceResume = True
else:
forceResume = False
resumeMode = False # this is always false because the ios and android app ask itself if we want to resume :-) no need to ask second time
playbackMode = self.g_serverConfig.playbackType.value
currentIndex = 0
libraryName = "Mixed"
data = {"listViewList": listViewList, "mediaContainer": mediaContainer, "autoPlayMode": autoPlayMode, "forceResume": forceResume, "resumeMode": resumeMode, "playbackMode": playbackMode, "currentIndex": currentIndex, "libraryName": libraryName}
self.playerCallback(data)
xml = "<MediaContainer location='navigation' commandID='10'><Timeline state='stopped' time='0' type='music' /><Timeline state='stopped' time='0' type='video' /><Timeline state='stopped' time='0' type='photo' /></MediaContainer>"
self.setXmlHeader(xml)
self.end_headers()
self.wfile.write(xml)
else:
printl("no match ...", self, "D")
else:
self.send_response(200)
except:
traceback.print_exc()
self.wfile.close()
printl("", self, "C")
return
try:
self.wfile.close()
except:
pass
printl("", self, "C")
class DPS_ServerConfig(ConfigListScreen, Screen, DPH_PlexScreen):
useMappings = False
def __init__(self, session, entry, data=None):
printl("", self, "S")
self.session = session
Screen.__init__(self, session)
self.guiElements = getGuiElements()
self["actions"] = ActionMap(
["DPS_ServerConfig", "ColorActions"],
{
"green": self.keySave,
"cancel": self.keyCancel,
"exit": self.keyCancel,
"yellow": self.keyYellow,
"blue": self.keyBlue,
"red": self.keyRed,
"left": self.keyLeft,
"right": self.keyRight,
},
-2,
)
self["help"] = StaticText()
self["btn_redText"] = Label()
self["btn_red"] = Pixmap()
self["btn_greenText"] = Label()
self["btn_green"] = Pixmap()
self["btn_yellowText"] = Label()
self["btn_yellow"] = Pixmap()
self["btn_blueText"] = Label()
self["btn_blue"] = Pixmap()
if entry is None:
self.newmode = 1
self.current = initServerEntryConfig()
if data is not None:
ipBlocks = data.get("server").split(".")
self.current.name.value = data.get("serverName")
self.current.ip.value = [int(ipBlocks[0]), int(ipBlocks[1]), int(ipBlocks[2]), int(ipBlocks[3])]
self.current.port.value = int(data.get("port"))
self.keySave(True)
else:
self.newmode = 0
self.current = entry
self.currentId = self.current.id.value
printl("currentId: " + str(self.currentId), self, "D")
self.cfglist = []
ConfigListScreen.__init__(self, self.cfglist, session)
self.createSetup()
self["config"].onSelectionChanged.append(self.updateHelp)
self.onLayoutFinish.append(self.finishLayout)
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def finishLayout(self):
printl("", self, "S")
# first we set the pics for buttons
self.setColorFunctionIcons()
self.setKeyNames()
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def createSetup(self):
printl("", self, "S")
separator = "".ljust(90, "_")
self.cfglist = []
##
self.cfglist.append(
getConfigListEntry(_("General Settings") + separator, config.plugins.dreamplex.about, _("-"))
)
##
self.cfglist.append(
getConfigListEntry(
_(" > State"), self.current.state, _("Toggle state to on/off to show this server in lost or not.")
)
)
self.cfglist.append(
getConfigListEntry(
_(" > Autostart"), self.current.autostart, _("Enter this server automatically on startup.")
)
)
self.cfglist.append(getConfigListEntry(_(" > Name"), self.current.name, _(" ")))
##
self.cfglist.append(
getConfigListEntry(_("Connection Settings") + separator, config.plugins.dreamplex.about, _(" "))
)
##
self.cfglist.append(getConfigListEntry(_(" > Connection Type"), self.current.connectionType, _(" ")))
if self.current.connectionType.value == "0" or self.current.connectionType.value == "1": # IP or DNS
self.cfglist.append(
getConfigListEntry(
_(" > Local Authentication"),
self.current.localAuth,
_(
"For currentlyRunning feature just activate.\nFor section management you have to connect your server successfully to myPlex once.\nAfter that just disable your Portforwarding policy."
),
)
)
self.addIpSettings()
if self.current.localAuth.value:
self.addMyPlexSettings()
elif self.current.connectionType.value == "1": # DNS
self.cfglist.append(getConfigListEntry(_(" >> DNS"), self.current.dns, _(" ")))
self.cfglist.append(getConfigListEntry(_(" >> Port"), self.current.port, _(" ")))
elif self.current.connectionType.value == "2": # MYPLEX
self.addMyPlexSettings()
##
self.cfglist.append(
getConfigListEntry(_("Playback Settings") + separator, config.plugins.dreamplex.about, _(" "))
)
##
self.cfglist.append(getConfigListEntry(_(" > Playback Type"), self.current.playbackType, _(" ")))
if self.current.playbackType.value == "0":
self.useMappings = False
elif self.current.playbackType.value == "1":
self.useMappings = False
self.cfglist.append(
getConfigListEntry(
_(" >> Use universal Transcoder"),
self.current.universalTranscoder,
_("You need gstreamer_fragmented installed for this feature! Please check in System ... "),
)
)
if not self.current.universalTranscoder.value:
self.cfglist.append(
getConfigListEntry(
_(" >> Transcoding quality"),
self.current.quality,
_("You need gstreamer_fragmented installed for this feature! Please check in System ... "),
)
)
self.cfglist.append(
getConfigListEntry(
_(" >> Segmentsize in seconds"),
self.current.segments,
_("You need gstreamer_fragmented installed for this feature! Please check in System ... "),
)
)
else:
self.cfglist.append(
getConfigListEntry(
_(" >> Transcoding quality"),
self.current.uniQuality,
_("You need gstreamer_fragmented installed for this feature! Please check in System ... "),
)
)
elif self.current.playbackType.value == "2":
printl("i am here", self, "D")
self.useMappings = True
elif self.current.playbackType.value == "3":
self.useMappings = False
# self.cfglist.append(getConfigListEntry(_(">> Username"), self.current.smbUser))
# self.cfglist.append(getConfigListEntry(_(">> Password"), self.current.smbPassword))
# self.cfglist.append(getConfigListEntry(_(">> Server override IP"), self.current.nasOverrideIp))
# self.cfglist.append(getConfigListEntry(_(">> Servers root"), self.current.nasRoot))
##
self.cfglist.append(
getConfigListEntry(_("Wake On Lan Settings") + separator, config.plugins.dreamplex.about, _(" "))
)
##
self.cfglist.append(getConfigListEntry(_(" > Use Wake on Lan (WoL)"), self.current.wol, _(" ")))
if self.current.wol.value:
self.cfglist.append(
getConfigListEntry(
_(" >> Mac address (Size: 12 alphanumeric no seperator) only for WoL"), self.current.wol_mac, _(" ")
)
)
self.cfglist.append(
getConfigListEntry(
_(" >> Wait for server delay (max 180 seconds) only for WoL"), self.current.wol_delay, _(" ")
)
)
##
self.cfglist.append(getConfigListEntry(_("Sync Settings") + separator, config.plugins.dreamplex.about, _(" ")))
##
self.cfglist.append(getConfigListEntry(_(" > Sync Movies Medias"), self.current.syncMovies, _(" ")))
self.cfglist.append(getConfigListEntry(_(" > Sync Shows Medias"), self.current.syncShows, _(" ")))
self.cfglist.append(getConfigListEntry(_(" > Sync Music Medias"), self.current.syncMusic, _(" ")))
# ===================================================================
#
# getConfigListEntry(_("Transcode Type (no function yet but soon ;-)"), self.current.transcodeType),
# getConfigListEntry(_("Quality (no function yet but soon ;-)"), self.current.quality),
# getConfigListEntry(_("Audio Output (no function yet but soon ;-)"), self.current.audioOutput),
# getConfigListEntry(_("Stream Mode (no function yet but soon ;-)"), self.current.streamMode),
# ===================================================================
self["config"].list = self.cfglist
self["config"].l.setList(self.cfglist)
self.setKeyNames()
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def addIpSettings(self):
printl("", self, "S")
self.cfglist.append(getConfigListEntry(_(" >> IP"), self.current.ip, _(" ")))
self.cfglist.append(getConfigListEntry(_(" >> Port"), self.current.port, _(" ")))
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def addMyPlexSettings(self):
printl("", self, "S")
self.cfglist.append(
getConfigListEntry(
_(" >> myPLEX URL"),
self.current.myplexUrl,
_("You need openSSL installed for this feature! Please check in System ..."),
)
)
self.cfglist.append(
getConfigListEntry(
_(" >> myPLEX Username"),
self.current.myplexUsername,
_("You need openSSL installed for this feature! Please check in System ..."),
)
)
self.cfglist.append(
getConfigListEntry(
_(" >> myPLEX Password"),
self.current.myplexPassword,
_("You need openSSL installed for this feature! Please check in System ..."),
)
)
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def updateHelp(self):
printl("", self, "S")
cur = self["config"].getCurrent()
printl("cur: " + str(cur), self, "D")
self["help"].setText(cur[2]) # = cur and cur[2] or ""
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def setKeyNames(self):
printl("", self, "S")
self["btn_greenText"].setText(_("Save"))
if self.useMappings and self.newmode == 0:
self["btn_yellowText"].setText(_("Mappings"))
self["btn_yellowText"].show()
self["btn_yellow"].show()
elif self.current.localAuth.value:
self["btn_yellowText"].setText(_("get local auth Token"))
self["btn_yellowText"].show()
self["btn_yellow"].show()
else:
self["btn_yellowText"].hide()
self["btn_yellow"].hide()
if (self.current.localAuth.value or self.current.connectionType.value == "2") and self.newmode == 0:
self["btn_redText"].setText(_("check myPlex Token"))
self["btn_blueText"].setText(_("(re)create myPlex Token"))
self["btn_redText"].show()
self["btn_red"].show()
self["btn_blueText"].show()
self["btn_blue"].show()
else:
self["btn_redText"].hide()
self["btn_red"].hide()
self["btn_blueText"].hide()
self["btn_blue"].hide()
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def keyLeft(self):
printl("", self, "S")
ConfigListScreen.keyLeft(self)
self.createSetup()
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def keyRight(self):
printl("", self, "S")
ConfigListScreen.keyRight(self)
self.createSetup()
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def keySave(self, stayOpen=False):
printl("", self, "S")
if self.newmode == 1:
config.plugins.dreamplex.entriescount.value += 1
config.plugins.dreamplex.entriescount.save()
config.plugins.dreamplex.entriescount.save()
config.plugins.dreamplex.Entries.save()
config.plugins.dreamplex.save()
configfile.save()
if not stayOpen:
self.close()
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def keyCancel(self):
printl("", self, "S")
if self.newmode == 1:
config.plugins.dreamplex.Entries.remove(self.current)
ConfigListScreen.cancelConfirm(self, True)
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def keyYellow(self):
printl("", self, "S")
if self.useMappings:
serverID = self.currentId
self.session.open(DPS_Mappings, serverID)
elif self.current.localAuth.value:
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.current))
ipInConfig = "%d.%d.%d.%d" % tuple(self.current.ip.value)
token = self.plexInstance.getPlexUserTokenForLocalServerAuthentication(ipInConfig)
if token:
self.current.myplexLocalToken.value = token
self.current.myplexLocalToken.save()
self.session.open(
MessageBox,
(_("Local Token:") + "\n%s \n" + _("for the user:"******"\n%s")
% (token, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO,
)
else:
response = self.plexInstance.getLastResponse()
self.session.open(
MessageBox,
(_("Error:") + "\n%s \n" + _("for the user:"******"\n%s")
% (response, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO,
)
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def keyBlue(self):
printl("", self, "S")
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.current))
token = self.plexInstance.getNewMyPlexToken()
if token:
self.session.open(
MessageBox,
(_("myPlex Token:") + "\n%s \n" + _("for the user:"******"\n%s")
% (token, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO,
)
else:
response = self.plexInstance.getLastResponse()
self.session.open(
MessageBox,
(_("Error:") + "\n%s \n" + _("for the user:"******"\n%s")
% (response, self.current.myplexTokenUsername.value),
MessageBox.TYPE_INFO,
)
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def keyRed(self):
printl("", self, "S")
self.session.open(
MessageBox,
(_("myPlex Token:") + "\n%s \n" + _("myPlex Localtoken:") + "\n%s \n" + _("for the user:"******"\n%s")
% (
self.current.myplexToken.value,
self.current.myplexLocalToken.value,
self.current.myplexTokenUsername.value,
),
MessageBox.TYPE_INFO,
)
printl("", self, "C")
class DPS_ServerMenu(DPH_Screen, DPH_HorizontalMenu, DPH_ScreenHelper, DPH_Filter, DPH_PlexScreen):
g_horizontal_menu = False
selectedEntry = None
g_serverConfig = None
g_serverDataMenu = None
currentService = None
plexInstance = None
selectionOverride = None
secondRun = False
menuStep = 0 # vaule how many steps we made to restore navigation data
currentMenuDataDict = {}
currentIndexDict = {}
isHomeUser = False
# ===========================================================================
#
# ===========================================================================
def __init__(self, session, g_serverConfig):
printl("", self, "S")
DPH_Screen.__init__(self, session)
DPH_ScreenHelper.__init__(self)
DPH_Filter.__init__(self)
DPH_PlexScreen.__init__(self)
self.selectionOverride = None
printl("selectionOverride:" + str(self.selectionOverride), self, "D")
self.session = session
self.g_serverConfig = g_serverConfig
self.plexInstance = Singleton().getPlexInstance()
self.guiElements = getGuiElements()
self.initScreen("server_menu")
self.initMenu()
if self.g_horizontal_menu:
self.setHorMenuElements(depth=2)
self.translateNames()
self["title"] = StaticText()
self["menu"] = List(enableWrapAround=True)
self["actions"] = HelpableActionMap(
self,
"DP_MainMenuActions",
{
"ok": (self.okbuttonClick, ""),
"left": (self.left, ""),
"right": (self.right, ""),
"up": (self.up, ""),
"down": (self.down, ""),
"cancel": (self.cancel, ""),
"red": (self.onKeyRed, ""),
"green": (self.onKeyGreen, ""),
},
-2,
)
self["btn_green"] = Pixmap()
self["btn_green"].hide()
self["btn_greenText"] = Label()
self["text_HomeUserLabel"] = Label()
self["text_HomeUser"] = Label()
self.onLayoutFinish.append(self.finishLayout)
self.onLayoutFinish.append(self.getInitialData)
self.onLayoutFinish.append(self.checkSelectionOverride)
printl("", self, "C")
# ===============================================================================
#
# ===============================================================================
def finishLayout(self):
printl("", self, "S")
self.setTitle(_("Server Menu"))
# first we set the pics for buttons
self.setColorFunctionIcons()
if self.miniTv:
self.initMiniTv()
if self.g_serverConfig.myplexHomeUsers.value:
self["btn_green"].show()
self["btn_greenText"].setText(_("Switch User"))
self["text_HomeUserLabel"].setText(_("Current User:"******"":
self["text_HomeUser"].setText(self.g_serverConfig.myplexCurrentHomeUser.value)
self.plexInstance.setAccessTokenHeader(
self.plexInstance.g_currentServer, self.g_serverConfig.myplexCurrentHomeUserAccessToken.value
)
else:
self["text_HomeUser"].setText(self.g_serverConfig.myplexTokenUsername.value)
printl("", self, "C")
# ===============================================================================
#
# ===============================================================================
def getInitialData(self):
printl("", self, "S")
self.getServerData()
# save the mainMenuList for later usage
self.menu_main_list = self["menu"].list
if self.g_horizontal_menu:
# init horizontal menu
self.refreshOrientationHorMenu(0)
printl("", self, "C")
# ===============================================================================
#
# ===============================================================================
def checkSelectionOverride(self):
printl("", self, "S")
printl("self.selectionOverride: " + str(self.selectionOverride), self, "D")
if self.selectionOverride is not None:
self.okbuttonClick()
printl("", self, "C")
# ===============================================================================
# KEYSTROKES
# ===============================================================================
# ===============================================================
#
# ===============================================================
def onKeyRed(self):
printl("", self, "S")
self.session.open(DPS_Syncer, "sync", self.g_serverConfig)
printl("", self, "C")
# ===============================================================
#
# ===============================================================
def onKeyGreen(self):
printl("", self, "S")
self.displayOptionsMenu()
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def displayOptionsMenu(self):
printl("", self, "S")
functionList = []
# add myPlex User as first one
functionList.append(
(
self.g_serverConfig.myplexTokenUsername.value,
self.g_serverConfig.myplexPin.value,
self.g_serverConfig.myplexToken.value,
False,
self.g_serverConfig.myplexId.value,
)
)
# now add all home users
self.homeUsersObject = DPS_Users(self.session, self.g_serverConfig.id.value, self.plexInstance)
homeUsersFromServer = self.homeUsersObject["content"].getHomeUsersFromServer()
if homeUsersFromServer is not None:
for user in homeUsersFromServer.findall("user"):
self.lastUserId = user.attrib.get("id")
self.currentHomeUsername = user.attrib.get("username")
self.currentPin = user.attrib.get("pin")
self.currentHomeUserToken = user.attrib.get("token")
functionList.append(
(self.currentHomeUsername, self.currentPin, self.currentHomeUserToken, True, self.lastUserId)
)
self.session.openWithCallback(
self.displayOptionsMenuCallback, ChoiceBox, title=_("Home Users"), list=functionList
)
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def displayOptionsMenuCallback(self, choice):
printl("", self, "S")
if choice is None or choice[1] is None:
printl("choice: None - we pressed exit", self, "D")
return
printl("choice: " + str(choice), self, "D")
self.isHomeUser = choice[3]
self.currentHomeUserId = choice[4]
self.currentHomeUserPin = choice[1]
if self.isHomeUser:
if choice[1] != "":
printl(choice[1], self, "D")
self.session.openWithCallback(
self.askForPin, InputBox, title=_("Please enter the pincode!"), type=Input.PIN
)
else:
self.switchUser()
else:
if self.g_serverConfig.myplexPinProtect.value:
self.session.openWithCallback(
self.askForPin, InputBox, title=_("Please enter the pincode!"), type=Input.PIN
)
self.currentPin = self.g_serverConfig.myplexPin.value
else:
self.switchUser()
printl("", self, "C")
# ===============================================================
#
# ===============================================================
def switchUser(self):
printl("", self, "S")
# TODO add use saved values if we have no internet connection
xmlResponse = self.plexInstance.switchHomeUser(self.currentHomeUserId, self.currentHomeUserPin)
entryData = dict(xmlResponse.items())
myId = entryData["id"]
token = entryData["authenticationToken"]
title = entryData["title"]
self.plexInstance.serverConfig_myplexToken = token
accessToken = self.plexInstance.getPlexUserTokenForLocalServerAuthentication(self.plexInstance.g_host)
if not accessToken:
# we get all the restriction data from plex and not from the local server this means that if we ar not connected no data is coming to check, means no restction
self.session.open(
MessageBox, "No accessToken! Check plex.tv connection and plexPass status.", MessageBox.TYPE_INFO
)
else:
self.g_serverConfig.myplexCurrentHomeUser.value = title
self.g_serverConfig.myplexCurrentHomeUserAccessToken.value = accessToken
self.g_serverConfig.myplexCurrentHomeUserId.value = myId
self.g_serverConfig.save()
self.plexInstance.setAccessTokenHeader(self.plexInstance.g_currentServer, accessToken)
self["text_HomeUser"].setText(title)
printl("", self, "C")
# ===============================================================
#
# ===============================================================
def askForPin(self, enteredPin):
printl("", self, "S")
if enteredPin is None:
pass
else:
if int(enteredPin) == int(self.currentPin):
self.session.open(MessageBox, "The pin was correct! Switching user.", MessageBox.TYPE_INFO)
if self.isHomeUser:
self.switchUser()
else:
self.switchUser()
else:
self.session.open(MessageBox, "The pin was wrong! Abort user switiching.", MessageBox.TYPE_INFO)
printl("", self, "C")
# ===============================================================
#
# ===============================================================
def okbuttonClick(self):
printl("", self, "S")
self.currentMenuDataDict[self.menuStep] = self.g_serverDataMenu
printl("currentMenuDataDict: " + str(self.currentMenuDataDict), self, "D")
# first of all we save the data from the current step
self.currentIndexDict[self.menuStep] = self["menu"].getIndex()
# now we increase the step value because we go to the next step
self.menuStep += 1
printl("menuStep: " + str(self.menuStep), self, "D")
# this is used to step in directly into a server when there is only one entry in the serverlist
if self.selectionOverride is not None:
selection = self.selectionOverride
# because we change the screen we have to unset the information to be able to return to main menu
self.selectionOverride = None
else:
selection = self["menu"].getCurrent()
printl("selection = " + str(selection), self, "D")
if selection is not None and selection:
self.selectedEntry = selection[1]
printl("selected entry " + str(self.selectedEntry), self, "D")
if type(self.selectedEntry) is int:
printl("selected entry is int", self, "D")
if self.selectedEntry == Plugin.MENU_MOVIES:
printl("found Plugin.MENU_MOVIES", self, "D")
self.getServerData("movies")
elif self.selectedEntry == Plugin.MENU_TVSHOWS:
printl("found Plugin.MENU_TVSHOWS", self, "D")
self.getServerData("tvshow")
elif self.selectedEntry == Plugin.MENU_MUSIC:
printl("found Plugin.MENU_MUSIC", self, "D")
self.getServerData("music")
elif self.selectedEntry == Plugin.MENU_FILTER:
printl("found Plugin.MENU_FILTER", self, "D")
self.getFilterData(selection[3])
elif self.selectedEntry == Plugin.MENU_SERVERFILTER:
self.getServerData(
filterBy=selection[3]["myCurrentFilterData"], serverFilterActive=selection[3]["serverName"]
)
else:
printl("selected entry is executable", self, "D")
self.mediaType = selection[2]
printl("mediaType: " + str(self.mediaType), self, "D")
entryData = selection[3]
printl("entryData: " + str(entryData), self, "D")
hasPromptTag = entryData.get("hasPromptTag", False)
printl("hasPromptTag: " + str(hasPromptTag), self, "D")
if hasPromptTag:
self.session.openWithCallback(
self.addSearchString,
DPS_InputBox,
entryData,
title=_("Please enter your search string: "),
text=" " * 55,
maxSize=55,
type=Input.TEXT,
)
else:
self.menuStep -= 1
self.executeSelectedEntry(entryData)
self.refreshMenu()
else:
printl("no data, leaving ...", self, "D")
self.cancel()
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def addSearchString(self, entryData, searchString=None):
printl("", self, "S")
printl("entryData: " + str(entryData), self, "D")
if searchString is not None:
if "origContentUrl" in entryData[0]:
searchUrl = entryData[0]["origContentUrl"] + "&query=" + searchString
else:
searchUrl = entryData[0]["contentUrl"] + "&query=" + searchString
entryData[0]["origContentUrl"] = entryData[0]["contentUrl"]
printl("searchUrl: " + str(searchUrl), self, "D")
entryData[0]["contentUrl"] = searchUrl
self.executeSelectedEntry(entryData[0])
printl("", self, "C")
# ===========================================================================
# this function starts DP_Lib...
# ===========================================================================
def executeSelectedEntry(self, entryData):
printl("", self, "S")
if self.selectedEntry.start is not None:
printl("we are startable ...", self, "D")
self.session.openWithCallback(self.myCallback, self.selectedEntry.start, entryData)
elif self.selectedEntry.fnc is not None:
printl("we are a function ...", self, "D")
self.selectedEntry.fnc(self.session)
if config.plugins.dreamplex.showFilter.value:
self.selectedEntry = (
Plugin.MENU_FILTER
) # we overwrite this now to handle correct menu jumps with exit/cancel button
printl("", self, "C")
# ==========================================================================
#
# ==========================================================================
def myCallback(self):
printl("", self, "S")
if not config.plugins.dreamplex.stopLiveTvOnStartup.value:
self.session.nav.playService(getLiveTv(), forceRestart=True)
printl("", self, "C")
# ==========================================================================
#
# ==========================================================================
def up(self):
printl("", self, "S")
if self.g_horizontal_menu:
self.left()
else:
self["menu"].selectPrevious()
printl("", self, "C")
# ===========================================================================
#
# ===========================================================================
def down(self):
printl("", self, "S")
if self.g_horizontal_menu:
self.right()
else:
self["menu"].selectNext()
printl("", self, "C")
# ===============================================================================
#
# ===============================================================================
def right(self):
printl("", self, "S")
try:
if self.g_horizontal_menu:
self.refreshOrientationHorMenu(+1)
else:
self["menu"].pageDown()
except Exception, ex:
printl("Exception(" + str(type(ex)) + "): " + str(ex), self, "W")
self["menu"].selectNext()
printl("", self, "C")
class DPS_MainMenu(Screen):
g_wolon = False
g_wakeserver = "00-11-32-12-C5-F9"
g_woldelay = 10
selectedEntry = None
s_url = None
s_mode = None
s_final = False
g_serverDataMenu = None
g_filterDataMenu = None
nextExitIsQuit = True
currentService = None
plexInstance = None
selectionOverride = None
secondRun = False
#===========================================================================
#
#===========================================================================
def __init__(self, session, allowOverride=True):
printl("", self, "S")
Screen.__init__(self, session)
self.selectionOverride = None
printl("selectionOverride:" +str(self.selectionOverride), self, "D")
self.session = session
self["title"] = StaticText()
self["welcomemessage"] = StaticText()
# get all our servers as list
self.getServerList(allowOverride)
self["menu"]= List(self.mainMenuList, True)
self.menu_main_list = self["menu"].list
self["actions"] = HelpableActionMap(self, "DP_MainMenuActions",
{
"ok": (self.okbuttonClick, ""),
"left": (self.left, ""),
"right": (self.right, ""),
"up": (self.up, ""),
"down": (self.down, ""),
"cancel": (self.cancel, ""),
}, -2)
self.onFirstExecBegin.append(self.onExec)
self.onFirstExecBegin.append(self.onExecRunDev)
if config.plugins.dreamplex.stopLiveTvOnStartup.value:
self.currentService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
self.onLayoutFinish.append(self.setCustomTitle)
self.onShown.append(self.checkSelectionOverride)
printl("", self, "C")
#===============================================================================
# SCREEN FUNCTIONS
#===============================================================================
#===============================================================================
#
#===============================================================================
def setCustomTitle(self):
printl("", self, "S")
self.setTitle(_("DreamPlex"))
printl("", self, "C")
#===============================================================================
#
#===============================================================================
def checkSelectionOverride(self):
printl("", self, "S")
printl("self.selectionOverride: " + str(self.selectionOverride), self, "D")
if self.selectionOverride is not None:
self.okbuttonClick(self.selectionOverride)
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def showWakeMessage(self):
printl("", self, "S")
self.session.openWithCallback(self.executeWakeOnLan, MessageBox, _("Plexserver seems to be offline. Start with Wake on Lan settings? \n\nPlease note: \nIf you press yes the spinner will run for " + str(self.g_woldelay) + " seconds. \nAccording to your settings."), MessageBox.TYPE_YESNO)
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def showOfflineMessage(self):
printl("", self, "S")
self.session.openWithCallback(self.setMainMenu,MessageBox,_("Plexserver seems to be offline. Please check your your settings or connection!\n Retry?"), MessageBox.TYPE_YESNO)
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def setMainMenu(self, answer):
printl("", self, "S")
printl("answer: " + str(answer), self, "D")
if answer:
self.checkServerState()
else:
self.session.open(DPS_MainMenu,allowOverride=False)
printl("", self, "C")
#===============================================================================
# KEYSTROKES
#===============================================================================
#===============================================================
#
#===============================================================
def okbuttonClick(self, selectionOverride = None):
printl("", self, "S")
# this is used to step in directly into a server when there is only one entry in the serverlist
if selectionOverride is not None:
selection = selectionOverride
else:
selection = self["menu"].getCurrent()
printl("selection = " + str(selection), self, "D")
self.nextExitIsQuit = False
if selection is not None:
self.selectedEntry = selection[1]
printl("selected entry " + str(self.selectedEntry), self, "D")
if type(self.selectedEntry) is int:
printl("selected entry is int", self, "D")
if self.selectedEntry == Plugin.MENU_MAIN:
printl("found Plugin.MENU_MAIN", self, "D")
self["menu"].setList(self.menu_main_list)
elif self.selectedEntry == Plugin.MENU_SERVER:
printl("found Plugin.MENU_SERVER", self, "D")
self.g_serverConfig = selection[3]
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.g_serverConfig))
self.checkServerState()
elif self.selectedEntry == Plugin.MENU_MOVIES:
printl("found Plugin.MENU_MOVIES", self, "D")
self.getServerData("movies")
elif self.selectedEntry == Plugin.MENU_TVSHOWS:
printl("found Plugin.MENU_TVSHOWS", self, "D")
self.getServerData("tvshow")
elif self.selectedEntry == Plugin.MENU_MUSIC:
printl("found Plugin.MENU_MUSIC", self, "D")
self.getServerData("music")
elif self.selectedEntry == Plugin.MENU_FILTER:
printl("found Plugin.MENU_FILTER", self, "D")
params = selection[3]
printl("params: " + str(params), self, "D")
self.s_url = params.get('t_url', "notSet")
self.s_mode = params.get('t_mode', "notSet")
self.s_final = params.get('t_final', "notSet")
self.s_source = params.get('t_source', "notSet")
self.s_uuid = params.get('t_uuid', "notSet")
self.getFilterData()
elif self.selectedEntry == Plugin.MENU_SYSTEM:
printl("found Plugin.MENU_SYSTEM", self, "D")
self["menu"].setList(self.getSettingsMenu())
self.refreshMenu(0)
elif type(self.selectedEntry) is str:
printl("selected entry is string", self, "D")
if selection[1] == "DPS_Settings":
self.session.open(DPS_Settings)
elif selection[1] == "DPS_ServerEntriesListConfigScreen":
self.session.open(DPS_ServerEntriesListConfigScreen)
elif selection[1] == "DPS_SystemCheck":
self.session.open(DPS_SystemCheck)
elif selection[1] == "DPS_About":
self.session.open(DPS_About)
elif selection[1] == "DPS_Help":
self.session.open(DPS_Help)
elif selection[1] == "DPS_Exit":
self.exit()
elif selection[1] == "getMusicSections":
self.getMusicSections(selection)
else:
printl("selected entry is executable", self, "D")
params = selection[3]
printl("params: " + str(params), self, "D")
self.s_url = params.get('t_url', "notSet")
self.showEpisodesDirectly = params.get('t_showEpisodesDirectly', "notSet")
self.uuid = params.get('t_uuid', "notSet")
self.source = params.get('t_source', "notSet")
self.viewGroup = params.get('t_viewGroup', "notSet")
isSearchFilter = params.get('isSearchFilter', "notSet")
printl("isSearchFilter: " + str(isSearchFilter), self, "D")
if isSearchFilter == "True" or isSearchFilter and isSearchFilter != "notSet":
printl("i am here: " + str(isSearchFilter), self, "D")
self.session.openWithCallback(self.addSearchString, InputBox, title=_("Please enter your search string!"), text="", maxSize=55, type=Input.TEXT)
else:
self.executeSelectedEntry()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def getMusicSections(self, selection):
printl("", self, "S")
mainMenuList = []
plugin = selection[2] #e.g. Plugin.MENU_MOVIES
# ARTISTS
params = copy.deepcopy(selection[3])
url = params['t_url']
params['t_url'] = url + "?type=8"
mainMenuList.append((_("by Artists"), plugin, "artistsEntry", params))
printl("mainMenuList 1: " + str(mainMenuList), self, "D")
#ALBUMS
params = copy.deepcopy(selection[3])
params['t_url'] = url + "?type=9"
mainMenuList.append((_("by Albums"), plugin, "albumsEntry", params))
printl("mainMenuList 2: " + str(mainMenuList), self, "D")
self["menu"].setList(mainMenuList)
self.refreshMenu(0)
printl("mainMenuList: " + str(mainMenuList), self, "D")
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def getSettingsMenuList(self):
printl("", self, "S")
self.nextExitIsQuit = False
self["menu"].setList(self.getSettingsMenu())
self.refreshMenu(0)
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def addSearchString(self, searchString):
printl("", self, "S")
# sample: http://192.168.45.190:32400/search?type=1&query=fringe
serverUrl = self.plexInstance.getServerFromURL(self.s_url)
if searchString is not "" and searchString is not None:
self.s_url = serverUrl + "/search?type=1&query=" + searchString
self.executeSelectedEntry()
printl("", self, "C")
#===========================================================================
# this function starts DP_Lib...
#===========================================================================
def executeSelectedEntry(self):
printl("", self, "S")
printl("self.s_url: " + str(self.s_url), self, "D")
if self.selectedEntry.start is not None:
kwargs = {"url": self.s_url, "uuid": self.uuid, "source": self.source , "viewGroup": self.viewGroup}
if self.showEpisodesDirectly != "notSet":
kwargs["showEpisodesDirectly"] = self.showEpisodesDirectly
self.session.open(self.selectedEntry.start, **kwargs)
elif self.selectedEntry.fnc is not None:
self.selectedEntry.fnc(self.session)
if config.plugins.dreamplex.showFilter.value:
self.selectedEntry = Plugin.MENU_FILTER # we overwrite this now to handle correct menu jumps with exit/cancel button
printl("", self, "C")
#==========================================================================
#
#==========================================================================
def up(self):
printl("", self, "S")
self["menu"].selectPrevious()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def down(self):
printl("", self, "S")
self["menu"].selectNext()
printl("", self, "C")
#===============================================================================
#
#===============================================================================
def right(self):
printl("", self, "S")
try:
self["menu"].pageDown()
except Exception, ex:
printl("Exception(" + str(type(ex)) + "): " + str(ex), self, "W")
self["menu"].selectNext()
printl("", self, "C")
class RemoteHandler(BaseHTTPRequestHandler):
"""
Serves a HEAD request
"""
session = None
playerCallback = None
progress = None
currentCommandId = 0
protocol_version = 'HTTP/1.1'
#===========================================================================
#
#===========================================================================
def do_HEAD(self):
printl("", self, "S")
printl("Serving HEAD request...", self, "D")
self.answer_request()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def do_GET(self):
printl("", self, "S")
printl("Serving GET request...", self, "D")
self.answer_request()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def do_OPTIONS(self):
printl("", self, "S")
printl("Serving OPTIONS request...", self, "D")
self.send_response(200)
self.send_header('Content-Length', '0')
self.send_header('Content-Type', 'text/plain')
self.send_header('Connection', 'close')
self.setAccessControlHeaders()
self.end_headers()
self.wfile.close()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def response(self, body, headers = {}, code = 200):
printl("", self, "S")
try:
self.send_response(code)
for key in headers:
self.send_header(key, headers[key])
self.send_header('Content-Length', len(body))
self.send_header('Connection', "close")
self.setAccessControlHeaders()
self.end_headers()
self.wfile.write(body)
self.wfile.close()
except:
pass
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def answer_request(self):
printl("", self, "S")
try:
request_path=self.path[1:]
request_path=re.sub(r"\?.*","",request_path)
printl("request path is: [%s]" % request_path, self, "D")
# first we get all params form url
params = self.getParams()
data = {"command": "updateCommandId", "uuid": self.headers.get('X-Plex-Client-Identifier', self.client_address[0]), "commandID": params.get('commandID', False)}
self.playerCallback(data)
self.resetCallback()
if request_path == "player/timeline/subscribe":
self.response(getOKMsg(), getPlexHeaders())
protocol = params.get('protocol', False)
host = self.client_address[0]
port = params.get('port', False)
uuid = self.headers.get('X-Plex-Client-Identifier', "")
commandID = params.get('commandID', 0)
printl("host: " + str(host), self, "D")
printl("protocol: " + str(protocol), self, "D")
printl("port: " + str(port), self, "D")
printl("uuid: " + str(uuid), self, "D")
printl("commandID: " + str(commandID), self, "D")
data = {"command": "addSubscriber", "protocol": protocol, "host": host, "port": port, "uuid": uuid, "commandID": commandID}
#subMgr.addSubscriber(protocol, host, port, uuid, commandID)
self.playerCallback(data)
self.resetCallback()
elif "player/timeline/unsubscribe" in request_path:
self.response(getOKMsg(), getPlexHeaders())
uuid = self.headers.get('X-Plex-Client-Identifier', False) or self.client_address[0]
data = {"command": "removeSubscriber", "uuid": uuid}
#subMgr.removeSubscriber(uuid)
self.playerCallback(data)
self.resetCallback()
elif request_path == "resources":
responseContent = getXMLHeader()
responseContent += str(self.getResourceXml())
self.response(responseContent, getPlexHeaders())
elif request_path == "player/timeline/poll":
commandID = params.get('commandID', 0)
self.subMgr = SubscriptionManager()
try:
e2params = self.session.current_dialog.getPlayerState()
if e2params:
self.subMgr.progressFromEnigma2 = e2params['progress']
self.subMgr.playerStateFromEnigma2 = e2params["state"]
self.subMgr.durationFromEnigma2 = e2params["duration"]
self.subMgr.lastkey = e2params["lastKey"]
self.answerPoll(commandID)
sleep(1)
except:
print "no params"
self.answerPoll(commandID)
sleep(1)
elif request_path == "player/playback/setParameters":
volume = params["volume"]
data = {"command": "setVolume", "volume": volume}
self.playerCallback(data)
self.resetCallback()
elif request_path == "player/playback/pause":
self.response(getOKMsg(), getPlexHeaders())
data = {"command": "pause"}
self.playerCallback(data)
self.resetCallback()
elif request_path == "player/playback/play":
self.response(getOKMsg(), getPlexHeaders())
data = {"command": "play"}
self.playerCallback(data)
self.resetCallback()
elif request_path == "player/playback/stop":
self.response(getOKMsg(), getPlexHeaders())
data = {"command": "stop"}
self.playerCallback(data)
self.resetCallback()
elif request_path == "player/playback/skipNext":
self.response(getOKMsg(), getPlexHeaders())
data = {"command": "skipNext"}
self.playerCallback(data)
self.resetCallback()
elif request_path == "player/playback/skipPrevious":
self.response(getOKMsg(), getPlexHeaders())
data = {"command": "skipPrevious"}
self.playerCallback(data)
self.resetCallback()
elif request_path == "player/playback/stepForward":
self.response(getOKMsg(), getPlexHeaders())
data = {"command": "stepForward"}
self.playerCallback(data)
self.resetCallback()
elif request_path == "player/playback/stepBack":
self.response(getOKMsg(), getPlexHeaders())
data = {"command": "stepBack"}
self.playerCallback(data)
self.resetCallback()
elif request_path == "player/playback/seekTo":
self.response(getOKMsg(), getPlexHeaders())
offset = params["offset"]
data = {"command": "seekTo", "offset": offset}
self.playerCallback(data)
self.resetCallback()
elif request_path == "player/playback/playMedia":
self.response(getOKMsg(), getPlexHeaders())
self.currentAddress = params.get('address', self.client_address[0])
self.currentKey = params['key']
self.currentPort = params['port']
self.currentProtocol = params.get('protocol', "http")
self.currentCompleteAddress = self.currentAddress + ":" + self.currentPort
if "offset" in params:
offset = int(params["offset"])
else:
offset = 0
machineIdentifier = params["machineIdentifier"]
printl("target machineIdentifier: " + str(machineIdentifier), self, "D")
for serverConfig in config.plugins.dreamplex.Entries:
printl("current machineIdentifier: " + str(serverConfig.machineIdentifier.value), self, "D")
if machineIdentifier in serverConfig.machineIdentifier.value:
printl("we have a match ...", self, "D")
self.g_serverConfig = serverConfig
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.g_serverConfig, self.currentCompleteAddress, machineIdentifier))
listViewList, mediaContainer = self.plexInstance.getMixedContentFromSection(self.currentProtocol + "://" + self.currentAddress + ":" + self.currentPort + self.currentKey, fromRemotePlayer=True)
autoPlayMode = False
if offset > 0:
forceResume = True
else:
forceResume = False
resumeMode = False # this is always false because the ios and android app ask itself if we want to resume :-) no need to ask second time
playbackMode = self.g_serverConfig.playbackType.value
currentIndex = 0
libraryName = "Mixed"
splittedData = self.currentKey.split("/")
subtitleData = self.plexInstance.getSelectedSubtitleDataById(self.currentCompleteAddress, splittedData[-1])
data = {"command": "playMedia", "currentKey": self.currentKey, "listViewList": listViewList, "mediaContainer": mediaContainer, "autoPlayMode": autoPlayMode, "forceResume": forceResume, "resumeMode": resumeMode, "playbackMode": playbackMode, "currentIndex": currentIndex, "libraryName": libraryName, "subtitleData": subtitleData }
self.playerCallback(data)
self.resetCallback()
else:
printl("no match ...", self, "D")
else:
self.response(getOKMsg(), getPlexHeaders())
except:
traceback.print_exc()
self.wfile.close()
printl("", self, "C")
return
try:
self.wfile.close()
except:
pass
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def resetCallback(self):
# we do this due to the fact that the messagepump is triggered mor often than we want to via playercallback for this reason we set to idle so that for example playMedia command is not called more than once
data = {"command": "idle"}
self.playerCallback(data)
#===========================================================================
#
#===========================================================================
def answerPoll(self, commandID):
self.response(re.sub(r"INSERTCOMMANDID", str(commandID), self.subMgr.msg(self.getPlayers())), {
'Access-Control-Expose-Headers': 'X-Plex-Client-Identifier',
'Content-Type': 'text/xml'
})
#===========================================================================
#
#===========================================================================
def address_string(self):
printl("", self, "S")
host, port = self.client_address[:2]
#return socket.getfqdn(host)
printl("", self, "C")
return host
#===========================================================================
#
#===========================================================================
def getResourceXml(self):
printl("", self, "S")
xml = "<MediaContainer><Player protocolCapabilities='playback, navigation' product='"+ getMyIp() +"' platformVersion='"+ getVersion() +"' platform='Enigma2' machineIdentifier='"+ getUUID() +"' title='"+ config.plugins.dreamplex.boxName.value +"' protocolVersion='1' deviceClass='stb'/></MediaContainer>"
printl("", self, "C")
return xml
#===========================================================================
#
#===========================================================================
def setXmlHeader(self, xml):
printl("", self, "S")
self.send_header('Content-type', 'text/xml; charset="utf-8"')
self.send_header('Content-Length', str(len(xml)))
printl("", self, "S")
#===========================================================================
#
#===========================================================================
def setAccessControlHeaders(self):
printl("", self, "S")
self.send_header('X-Plex-Client-Identifier', getUUID())
self.send_header('Access-Control-Max-Age', '1209600')
self.send_header('Access-Control-Allow-Credentials', 'true')
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
self.send_header("Access-Control-Allow-Headers", "x-plex-client-identifier,x-plex-device,x-plex-device-name,x-plex-platform,x-plex-platform-version,x-plex-product,x-plex-target-client-identifier,x-plex-username,x-plex-version")
printl("", self, "S")
#===========================================================================
#
#===========================================================================
def getParams(self):
printl("", self, "S")
params = {}
paramarrays = parse_qs(urlparse(self.path).query)
for key in paramarrays:
params[key] = paramarrays[key][0]
printl("", self, "C")
return params
#===========================================================================
#
#===========================================================================
def getPlayers(self):
ret = {}
try:
ret = self.session.current_dialog.getPlayer()
except:
pass
return ret
class DPS_ServerConfig(ConfigListScreen, Screen, DPH_PlexScreen):
useMappings = False
useHomeUsers = False
authenticated = False
def __init__(self, session, entry, data = None):
printl("", self, "S")
Screen.__init__(self, session)
self.guiElements = getGuiElements()
self["actions"] = ActionMap(["DPS_ServerConfig", "ColorActions"],
{
"green": self.keySave,
"cancel": self.keyCancel,
"exit": self.keyCancel,
"yellow": self.keyYellow,
"blue": self.keyBlue,
"red": self.keyRed,
"left": self.keyLeft,
"right": self.keyRight,
}, -2)
self["help"] = StaticText()
self["btn_redText"] = Label()
self["btn_red"] = Pixmap()
self["btn_greenText"] = Label()
self["btn_green"] = Pixmap()
self["btn_yellowText"] = Label()
self["btn_yellow"] = Pixmap()
self["btn_blueText"] = Label()
self["btn_blue"] = Pixmap()
if entry is None:
self.newmode = 1
self.current = initServerEntryConfig()
if data is not None:
ipBlocks = data.get("server").split(".")
self.current.name.value = data.get("serverName")
self.current.ip.value = [int(ipBlocks[0]),int(ipBlocks[1]),int(ipBlocks[2]),int(ipBlocks[3])]
self.current.port.value = int(data.get("port"))
else:
self.newmode = 0
self.current = entry
self.currentId = self.current.id.value
printl("currentId: " + str(self.currentId), self, "D")
self.cfglist = []
ConfigListScreen.__init__(self, self.cfglist, session)
self["config"].onSelectionChanged.append(self.updateHelp)
self.onLayoutFinish.append(self.finishLayout)
self.onShown.append(self.checkForPinUsage)
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def finishLayout(self):
printl("", self, "S")
print "here"
# first we set the pics for buttons
self.setColorFunctionIcons()
self.setKeyNames()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def checkForPinUsage(self):
printl("", self, "S")
self.onShown = []
if not self.authenticated:
if self.current.protectSettings.value:
self.session.openWithCallback(self.askForPin, InputBox, title=_("Please enter the pincode!") , type=Input.PIN)
else:
self.authenticated = True
self.createSetup()
else:
self.createSetup()
printl("", self, "C")
#===============================================================
#
#===============================================================
def askForPin(self, enteredPin):
printl("", self, "S")
if enteredPin is None:
pass
else:
if int(enteredPin) == int(self.current.settingsPin.value):
#self.session.open(MessageBox,"The pin was correct!", MessageBox.TYPE_INFO)
self.authenticated = True
self.createSetup()
else:
self.session.open(MessageBox,"The pin was wrong! Returning ...", MessageBox.TYPE_INFO)
self.close()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def createSetup(self):
printl("", self, "S")
separator = "".ljust(250,"_")
self.cfglist = []
##
self.cfglist.append(getConfigListEntry(_("General Settings ") + separator, config.plugins.dreamplex.about, _("-")))
##
self.cfglist.append(getConfigListEntry(_(" > State"), self.current.state, _("Toggle state to on/off to show this server in lost or not.")))
self.cfglist.append(getConfigListEntry(_(" > Autostart"), self.current.autostart, _("Enter this server automatically on startup.")))
self.cfglist.append(getConfigListEntry(_(" > Name"), self.current.name, _("Simply a name for better overview")))
self.cfglist.append(getConfigListEntry(_(" > Trailer"), self.current.loadExtraData, _("Enable trailer function. Only works with PlexPass or YYTrailer plugin.")))
##
self.cfglist.append(getConfigListEntry(_("Connection Settings ") + separator, config.plugins.dreamplex.about, _(" ")))
##
self.cfglist.append(getConfigListEntry(_(" > Connection Type"), self.current.connectionType, _("Select your type how the box is reachable.")))
if self.current.connectionType.value == "0" or self.current.connectionType.value == "1": # IP or DNS
self.cfglist.append(getConfigListEntry(_(" > Local Authentication"), self.current.localAuth, _("Use this if you secured your plex server in the settings.")))
if self.current.connectionType.value == "0":
self.addIpSettings()
else:
self.cfglist.append(getConfigListEntry(_(" >> DNS"), self.current.dns, _(" ")))
self.cfglist.append(getConfigListEntry(_(" >> Port"), self.current.port, _(" ")))
if self.current.localAuth.value:
self.addMyPlexSettings()
elif self.current.connectionType.value == "2": # MYPLEX
self.addMyPlexSettings()
##
self.cfglist.append(getConfigListEntry(_("Playback Settings ") + separator, config.plugins.dreamplex.about, _(" ")))
##
self.cfglist.append(getConfigListEntry(_(" > Playback Type"), self.current.playbackType, _(" ")))
if self.current.playbackType.value == "0":
self.useMappings = False
elif self.current.playbackType.value == "1":
self.useMappings = False
self.cfglist.append(getConfigListEntry(_(" >> Use universal Transcoder"), self.current.universalTranscoder, _("You need gstreamer_fragmented installed for this feature! Please check in System ... ")))
if not self.current.universalTranscoder.value:
self.cfglist.append(getConfigListEntry(_(" >> Transcoding quality"), self.current.quality, _("You need gstreamer_fragmented installed for this feature! Please check in System ... ")))
self.cfglist.append(getConfigListEntry(_(" >> Segmentsize in seconds"), self.current.segments, _("You need gstreamer_fragmented installed for this feature! Please check in System ... ")))
else:
self.cfglist.append(getConfigListEntry(_(" >> Transcoding quality"), self.current.uniQuality, _("You need gstreamer_fragmented installed for this feature! Please check in System ... ")))
elif self.current.playbackType.value == "2":
self.useMappings = True
self.cfglist.append(getConfigListEntry(_("> Search and use forced subtitles"), self.current.useForcedSubtitles, _("Monitor playback to activate subtitles automatically if needed. You have to enable subtitles with 'Text'-Buttion first.")))
elif self.current.playbackType.value == "3":
self.useMappings = False
#self.cfglist.append(getConfigListEntry(_(">> Username"), self.current.smbUser))
#self.cfglist.append(getConfigListEntry(_(">> Password"), self.current.smbPassword))
#self.cfglist.append(getConfigListEntry(_(">> Server override IP"), self.current.nasOverrideIp))
#self.cfglist.append(getConfigListEntry(_(">> Servers root"), self.current.nasRoot))
if self.current.playbackType.value == "2":
##
self.cfglist.append(getConfigListEntry(_("Subtitle Settings ") + separator, config.plugins.dreamplex.about, _(" ")))
##
self.cfglist.append(getConfigListEntry(_(" >> Enable Subtitle renaming in direct local mode"), self.current.srtRenamingForDirectLocal, _("Renames filename.eng.srt automatically to filename.srt so e2 is able to read them.")))
if self.current.srtRenamingForDirectLocal.value:
self.cfglist.append(getConfigListEntry(_(" >> Target subtitle language"), self.current.subtitlesLanguage, _("Search string that should be removed from srt file.")))
##
self.cfglist.append(getConfigListEntry(_("Wake On Lan Settings ") + separator, config.plugins.dreamplex.about, _(" ")))
##
self.cfglist.append(getConfigListEntry(_(" > Use Wake on Lan (WoL)"), self.current.wol, _(" ")))
if self.current.wol.value:
self.cfglist.append(getConfigListEntry(_(" >> Mac address (Size: 12 alphanumeric no seperator) only for WoL"), self.current.wol_mac, _(" ")))
self.cfglist.append(getConfigListEntry(_(" >> Wait for server delay (max 180 seconds) only for WoL"), self.current.wol_delay, _(" ")))
##
self.cfglist.append(getConfigListEntry(_("Sync Settings ") + separator, config.plugins.dreamplex.about, _(" ")))
##
self.cfglist.append(getConfigListEntry(_(" > Sync Movies Medias"), self.current.syncMovies, _("Sync this content.")))
self.cfglist.append(getConfigListEntry(_(" > Sync Shows Medias"), self.current.syncShows, _("Sync this content.")))
self.cfglist.append(getConfigListEntry(_(" > Sync Music Medias"), self.current.syncMusic, _("Sync this content.")))
self["config"].list = self.cfglist
self["config"].l.setList(self.cfglist)
if self.current.myplexHomeUsers.value:
self.useHomeUsers = True
else:
self.useHomeUsers = False
self.setKeyNames()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def addIpSettings(self):
printl("", self, "S")
self.cfglist.append(getConfigListEntry(_(" >> IP"), self.current.ip, _(" ")))
self.cfglist.append(getConfigListEntry(_(" >> Port"), self.current.port, _(" ")))
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def addMyPlexSettings(self):
printl("", self, "S")
self.cfglist.append(getConfigListEntry(_(" >> myPLEX URL"), self.current.myplexUrl, _("You need openSSL installed for this feature! Please check in System ...")))
self.cfglist.append(getConfigListEntry(_(" >> myPLEX Username"), self.current.myplexUsername, _("You need openSSL installed for this feature! Please check in System ...")))
self.cfglist.append(getConfigListEntry(_(" >> myPLEX Password"), self.current.myplexPassword, _("You need openSSL installed for this feature! Please check in System ...")))
self.cfglist.append(getConfigListEntry(_(" >> myPLEX Home Users"), self.current.myplexHomeUsers, _("Use Home Users?")))
if self.current.myplexHomeUsers.value:
self.cfglist.append(getConfigListEntry(_(" >> Use Settings Protection"), self.current.protectSettings, _("Ask for pin?")))
if self.current.protectSettings.value:
self.cfglist.append(getConfigListEntry(_(" >> Settings Pincode"), self.current.settingsPin, _("Pincode for changing settings")))
self.cfglist.append(getConfigListEntry(_(" >> myPLEX Pin Protection"), self.current.myplexPinProtect, _("Use Pinprotection for switch back to myPlex user?")))
if self.current.myplexPinProtect.value:
self.cfglist.append(getConfigListEntry(_(" >> myPLEX Pincode"), self.current.myplexPin, _("Pincode for switching back from any home user.")))
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def updateHelp(self):
printl("", self, "S")
cur = self["config"].getCurrent()
printl("cur: " + str(cur), self, "D")
self["help"].setText(cur[2])# = cur and cur[2] or ""
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def setKeyNames(self):
printl("", self, "S")
self["btn_greenText"].setText(_("Save"))
if self.useMappings and self.newmode == 0:
self["btn_yellowText"].setText(_("Mappings"))
self["btn_yellowText"].show()
self["btn_yellow"].show()
elif self.current.localAuth.value:
self["btn_yellowText"].setText(_("get local auth Token"))
self["btn_yellowText"].show()
self["btn_yellow"].show()
else:
self["btn_yellowText"].hide()
self["btn_yellow"].hide()
if (self.current.localAuth.value or self.current.connectionType.value == "2") and self.newmode == 0:
if self.useHomeUsers:
self["btn_redText"].setText(_("Home Users"))
self["btn_redText"].show()
self["btn_red"].show()
else:
self["btn_redText"].hide()
self["btn_red"].hide()
self["btn_blueText"].setText(_("(re)create myPlex Token"))
self["btn_blueText"].show()
self["btn_blue"].show()
else:
self["btn_redText"].hide()
self["btn_red"].hide()
self["btn_blueText"].hide()
self["btn_blue"].hide()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def keyLeft(self):
printl("", self, "S")
ConfigListScreen.keyLeft(self)
self.createSetup()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def keyRight(self):
printl("", self, "S")
ConfigListScreen.keyRight(self)
self.createSetup()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def keySave(self):
printl("", self, "S")
if self.newmode == 1:
config.plugins.dreamplex.entriescount.value += 1
config.plugins.dreamplex.entriescount.save()
#if self.current.machineIdentifier.value == "":
from DP_PlexLibrary import PlexLibrary
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.current))
machineIdentifiers = ""
if self.current.connectionType.value == "2":
xmlResponse = self.plexInstance.getSharedServerForPlexUser()
machineIdentifier = xmlResponse.get("machineIdentifier")
if machineIdentifier is not None:
machineIdentifiers += machineIdentifier
servers = xmlResponse.findall("Server")
for server in servers:
machineIdentifier = server.get("machineIdentifier")
if machineIdentifier is not None:
machineIdentifiers += ", " + machineIdentifier
else:
xmlResponse = self.plexInstance.getXmlTreeFromUrl("http://" + str(self.plexInstance.g_host) + ":" + str(self.plexInstance.serverConfig_port))
machineIdentifier = xmlResponse.get("machineIdentifier")
if machineIdentifier is not None:
machineIdentifiers += xmlResponse.get("machineIdentifier")
self.current.machineIdentifier.value = machineIdentifiers
printl("machineIdentifier: " + str(self.current.machineIdentifier.value), self, "D")
if self.current.connectionType.value == "2" or self.current.localAuth.value:
self.keyBlue()
else:
self.saveNow()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def saveNow(self, retval=None):
printl("", self, "S")
config.plugins.dreamplex.entriescount.save()
config.plugins.dreamplex.Entries.save()
config.plugins.dreamplex.save()
configfile.save()
self.close()
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def keyCancel(self):
printl("", self, "S")
if self.newmode == 1:
config.plugins.dreamplex.Entries.remove(self.current)
ConfigListScreen.cancelConfirm(self, True)
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def keyYellow(self):
printl("", self, "S")
if self.useMappings:
serverID = self.currentId
self.session.open(DPS_Mappings, serverID)
elif self.current.localAuth.value:
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.current))
ipInConfig = "%d.%d.%d.%d" % tuple(self.current.ip.value)
token = self.plexInstance.getPlexUserTokenForLocalServerAuthentication(ipInConfig)
if token:
self.current.myplexLocalToken.value = token
self.current.myplexLocalToken.save()
self.session.open(MessageBox,(_("Local Token:") + "\n%s \n" + _("for the user:"******"\n%s") % (token, self.current.myplexTokenUsername.value), MessageBox.TYPE_INFO)
else:
response = self.plexInstance.getLastResponse()
self.session.open(MessageBox,(_("Error:") + "\n%s \n" + _("for the user:"******"\n%s") % (response, self.current.myplexTokenUsername.value), MessageBox.TYPE_INFO)
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def keyBlue(self):
printl("", self, "S")
# now that we know the server we establish global plexInstance
self.plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.current))
token = self.plexInstance.getNewMyPlexToken()
if token:
self.session.openWithCallback(self.saveNow, MessageBox,(_("myPlex Token:") + "\n%s \n" + _("for the user:"******"\n%s \n" + _("with the id:") + "\n%s") % (token, self.current.myplexTokenUsername.value, self.current.myplexId.value), MessageBox.TYPE_INFO)
else:
response = self.plexInstance.getLastResponse()
self.session.openWithCallback(self.saveNow, MessageBox,(_("Error:") + "\n%s \n" + _("for the user:"******"\n%s") % (response, self.current.myplexTokenUsername.value), MessageBox.TYPE_INFO)
printl("", self, "C")
#===========================================================================
#
#===========================================================================
def keyRed(self):
printl("", self, "S")
if self.useHomeUsers:
serverID = self.currentId
plexInstance = Singleton().getPlexInstance(PlexLibrary(self.session, self.current))
self.session.open(DPS_Users, serverID, plexInstance)
#self.session.open(MessageBox,(_("myPlex Token:") + "\n%s \n" + _("myPlex Localtoken:") + "\n%s \n"+ _("for the user:"******"\n%s") % (self.current.myplexToken.value, self.current.myplexLocalToken.value, self.current.myplexTokenUsername.value), MessageBox.TYPE_INFO)
printl("", self, "C")
def loadLibrary(self, params):
printl ("", self, "S")
printl("params =" + str(params), self, "D")
url = self.g_url
instance = Singleton()
plexInstance = instance.getPlexInstance()
library = plexInstance.getMoviesFromSection(url)
parsedLibrary = []
tmpAbc = []
tmpGenres = []
for movie in library:
#===============================================================
# printl ("-> url = " + str(movie[0]), self, "D")
# printl ("-> properties = " + str(movie[1]), self, "D")
# printl ("-> arguments = " + str(movie[2]), self, "D")
# printl ("-> context = " + str(movie[3]), self, "D")
#===============================================================
url = movie[0]
properties = movie[1]
arguments = movie[2]
context = movie[3]
d = {}
d["Title"] = properties.get('title', "")#
d["Year"] = properties.get('year', "")#
d["Plot"] = properties.get('plot', "") #
d["Runtime"] = properties.get('duration', "")#
d["Genres"] = properties.get('genre', "")
d["Seen"] = properties.get('playcount', "")#
d["Popularity"] = properties.get('rating', 0)#
d["Studio"] = properties.get('studio', 0)#
d["MPAA"] = properties.get('mpaa', 0)#
d["Tag"] = properties.get('tagline', "")#
d["server"] = properties.get('server', "")
d["Id"] = arguments.get('ratingKey') #we use this because there is the id as value without any need of manipulating
d["Path"] = arguments.get('key', "")
d["Resolution"] = arguments.get('VideoResolution', "")
d["Video"] = arguments.get('VideoCodec', "")
d["Sound"] = arguments.get('AudioCodec', "")
d["ArtBackdrop"] = arguments.get('fanart_image', "")
d["ArtPoster"] = arguments.get('thumb', "")
d["Creation"] = arguments.get('addedAt', 0)
d["Key"] = arguments.get('key', "")
d["ViewMode"] = "play"
d["ScreenTitle"] = d["Title"]
if d["Title"].upper() not in tmpAbc:
tmpAbc.append(d["Title"].upper())
for genre in d["Genres"]:
if genre not in tmpGenres:
tmpGenres.append(genre)
if (d["Seen"] == 0):
image = None
else:
image = None
parsedLibrary.append((d["Title"], d, d["Title"].lower(), "50", image))
sort = [("Title", None, False), ("Popularity", "Popularity", True), ]
if self.checkFileCreationDate:
sort.append(("File Creation", "Creation", True))
sort.append(("Filename", "Filename", False))
filter = [("All", (None, False), ("", )), ]
filter.append(("Seen", ("Seen", False, 1), ("Seen", "Unseen", )))
if len(tmpGenres) > 0:
tmpGenres.sort()
filter.append(("Genre", ("Genres", True), tmpGenres))
if len(tmpAbc) > 0:
tmpAbc.sort()
filter.append(("Abc", ("Title", False, 1), tmpAbc))
printl ("", self, "C")
return (parsedLibrary, ("ViewMode", "Id", ), None, None, sort, filter)
