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 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 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 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 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 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)