def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar self.infoBarInstance = InfoBar.instance self.StandbyCounterIncrease = StandbyCounterIncrease self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None #mute adc self.setMute() self.paused_service = None self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() service = self.prev_running_service and self.prev_running_service.toString() if service: if service.rsplit(":", 1)[1].startswith("/"): self.paused_service = True self.infoBarInstance.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session): Screen.__init__(self, session) self.skinName = 'Standby' self.avswitch = AVSwitch() print 'enter standby' if getMachineProcModel() in 'ini-7012': if path.exists('/proc/stb/lcd/symbol_scrambled'): open('/proc/stb/lcd/symbol_scrambled', 'w').write('0') if path.exists('/proc/stb/lcd/symbol_1080p'): open('/proc/stb/lcd/symbol_1080p', 'w').write('0') if path.exists('/proc/stb/lcd/symbol_1080i'): open('/proc/stb/lcd/symbol_1080i', 'w').write('0') if path.exists('/proc/stb/lcd/symbol_720p'): open('/proc/stb/lcd/symbol_720p', 'w').write('0') if path.exists('/proc/stb/lcd/symbol_576i'): open('/proc/stb/lcd/symbol_576i', 'w').write('0') if path.exists('/proc/stb/lcd/symbol_576p'): open('/proc/stb/lcd/symbol_576p', 'w').write('0') if path.exists('/proc/stb/lcd/symbol_hd'): open('/proc/stb/lcd/symbol_hd', 'w').write('0') if path.exists('/proc/stb/lcd/symbol_dolby_audio'): open('/proc/stb/lcd/symbol_dolby_audio', 'w').write('0') if path.exists('/proc/stb/lcd/symbol_mp3'): open('/proc/stb/lcd/symbol_mp3', 'w').write('0') self['actions'] = ActionMap(['StandbyActions'], {'power': self.Power, 'discrete_on': self.Power}, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar self.infoBarInstance = InfoBar.instance self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None self.setMute() if SystemInfo['Display'] and SystemInfo['LCDMiniTV']: setLCDModeMinitTV('0') self.paused_service = None self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() service = self.prev_running_service and self.prev_running_service.toString() if service: if service.rsplit(':', 1)[1].startswith('/'): self.paused_service = True self.infoBarInstance.pauseService() else: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr(self.infoBarInstance, 'showPiP') and self.infoBarInstance.showPiP() if SystemInfo['ScartSwitch']: self.avswitch.setInput('SCART') else: self.avswitch.setInput('AUX') self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __onClose(self): global inStandby inStandby = None self.standbyTimeoutTimer.stop() self.standbyStopServiceTimer.stop() self.standbyWakeupTimer.stop() self.timeHandler and self.timeHandler.m_timeUpdated.get().remove(self.stopService) if self.paused_service: self.paused_action and self.paused_service.unPauseService() elif self.prev_running_service: service = self.prev_running_service.toString() if config.servicelist.startupservice_onstandby.value: self.session.nav.playService(eServiceReference(config.servicelist.startupservice.value)) from Screens.InfoBar import InfoBar InfoBar.instance and InfoBar.instance.servicelist.correctChannelNumber() else: self.session.nav.playService(self.prev_running_service) self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) if RecordTimer.RecordTimerEntry.receiveRecordEvents: RecordTimer.RecordTimerEntry.stopTryQuitMainloop() self.avswitch.setInput("ENCODER") self.leaveMute() if os.path.exists("/usr/script/standby_leave.sh"): Console().ePopen("/usr/script/standby_leave.sh") if config.usage.remote_fallback_import_standby.value: ImportChannels()
def __init__(self, session): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power }, -1) globalActionMap.setEnabled(False) #mute adc self.setMute() self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceReference() #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __onClose(self): global inStandby inStandby = None self.standbyTimeoutTimer.stop() self.standbyStopServiceTimer.stop() self.timeHandler and self.timeHandler.m_timeUpdated.get().remove(self.stopService) if self.paused_service: self.infoBarInstance.unPauseService() elif self.prev_running_service: service = self.prev_running_service.toString() if config.servicelist.startupservice_onstandby.value: self.session.nav.playService(eServiceReference(config.servicelist.startupservice.value)) from Screens.InfoBar import InfoBar InfoBar.instance and InfoBar.instance.servicelist.correctChannelNumber() else: self.session.nav.playService(self.prev_running_service) self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("on") for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime(int(config.usage.hdd_standby.value)) # HDD standby timer value (box active) if RecordTimer.RecordTimerEntry.receiveRecordEvents: RecordTimer.RecordTimerEntry.stopTryQuitMainloop()
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None #mute adc self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") self.paused_service = None self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() service = self.prev_running_service and self.prev_running_service.toString() if service: if service.startswith("1:") and service.rsplit(":", 1)[1].startswith("/"): self.paused_service = self.session.current_dialog self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if int(config.usage.hdd_standby_in_standby.value) != -1: # HDD standby timer value (box in standby) / -1 = same as when box is active for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime(int(config.usage.hdd_standby_in_standby.value)) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "[Standby] enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.standbyTimeUnknownTimer = eTimer() #mute adc self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: if localtime(time()).tm_year > 1970 and self.session.nav.getCurrentlyPlayingServiceOrGroup(): if config.servicelist.startupservice_standby.value: self.prev_running_service = eServiceReference(config.servicelist.startupservice_standby.value) else: self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService() else: self.standbyTimeUnknownTimer.callback.append(self.stopService) self.standbyTimeUnknownTimer.startLongTimer(60) elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("off") if int(config.usage.hdd_standby_in_standby.value) != -1: # HDD standby timer value (box in standby) / -1 = same as when box is active for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime(int(config.usage.hdd_standby_in_standby.value)) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.StandbyCounterIncrease = StandbyCounterIncrease self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None #mute adc self.setMute() self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") open("/proc/stb/hdmi/output", "w").write("off") gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __onClose(self): global inStandby inStandby = None if self.prev_running_service: self.session.nav.playService(self.prev_running_service) elif self.paused_service: self.paused_service.unPauseService() self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar self.infoBarInstance = InfoBar.instance self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None #mute adc self.setMute() self.paused_service = None self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() service = self.prev_running_service and self.prev_running_service.toString() if service: if service.rsplit(":", 1)[1].startswith("/"): self.paused_service = True self.infoBarInstance.pauseService() else: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("off") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __onClose(self): global inStandby inStandby = None if self.prev_running_service: self.session.nav.playService(self.prev_running_service) elif self.paused_service: self.paused_service.unPauseService() self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) if RecordTimer.RecordTimerEntry.receiveRecordEvents: RecordTimer.RecordTimerEntry.stopTryQuitMainloop()
def __onClose(self): global inStandby inStandby = None self.standbyTimeUnknownTimer.stop() if self.prev_running_service: self.session.nav.playService(self.prev_running_service) elif self.paused_service: self.paused_service.unPauseService() self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime(int(config.usage.hdd_standby.value)) # HDD standby timer value (box active)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.standbyTimeUnknownTimer = eTimer() #mute adc self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: if localtime(time()).tm_year > 1970 and self.session.nav.getCurrentlyPlayingServiceOrGroup(): if config.servicelist.startupservice_standby.value: self.prev_running_service = eServiceReference(config.servicelist.startupservice_standby.value) else: self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService() else: self.standbyTimeUnknownTimer.callback.append(self.stopService) self.standbyTimeUnknownTimer.startLongTimer(60) elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session): Screen.__init__(self, session) self.avswitch = AVSwitch() if boxtype == 'gb800se' or boxtype == 'gb800solo' or boxtype == 'gb800ue': self.forled = readled() if self.forled[0] == 'True': self.ledenable = 1 else: self.ledenable = 0 print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) #mute adc self.setMute() self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceReference() #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") #+++> open("/proc/stb/hdmi/output", "w").write("off") #+++< self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose) if boxtype == 'gb800se' or boxtype == 'gb800solo' or boxtype == 'gb800ue': self.sign = 0 self.zaPrik = eTimer() self.zaPrik.timeout.get().append(self.vrime) self.zaPrik.start(1, 1)
def __onClose(self): global inStandby inStandby = None self.standbyTimeUnknownTimer.stop() if self.prev_running_service: self.session.nav.playService(self.prev_running_service) elif self.paused_service: self.paused_service.unPauseService() self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime(int(config.usage.hdd_standby.value) ) # HDD standby timer value (box active)
def __onClose(self): global inStandby inStandby = None self.standbyTimeUnknownTimer.stop() self.standbyTimeoutTimer.stop() if self.prev_running_service: self.session.nav.playService(self.prev_running_service) elif self.paused_service: self.paused_service.unPauseService() self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) if RecordTimer.RecordTimerEntry.receiveRecordEvents: RecordTimer.RecordTimerEntry.stopTryQuitMainloop()
def __onClose(self): global inStandby inStandby = None self.timeReady() if not self.session.shutdown: if self.prev_running_service: self.session.nav.playService(self.prev_running_service) elif self.paused_service: self.paused_service.unPauseService() self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True)
def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap(["StandbyActions"], {"power": self.Power, "discrete_on": self.Power}, -1) globalActionMap.setEnabled(False) self.StandbyCounterIncrease = StandbyCounterIncrease self.standbyTimeUnknownTimer = eTimer() self.standbyTimeoutTimer = eTimer() # mute adc self.setMute() # set LCDminiTV off if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV("0") self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: if localtime(time()).tm_year > 1970 and self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService() else: self.standbyTimeUnknownTimer.callback.append(self.stopService) self.standbyTimeUnknownTimer.startLongTimer(60) elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() # set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __onClose(self): global inStandby inStandby = None self.standbyStopServiceTimer.stop() self.timeHandler and self.timeHandler.m_timeUpdated.get().remove(self.stopService) if self.paused_service: self.paused_service.unPauseService() elif self.prev_running_service: service = self.prev_running_service.toString() self.session.nav.playService(self.prev_running_service) self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime(int(config.usage.hdd_standby.value)) # HDD standby timer value (box active)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.standbyTimeUnknownTimer = eTimer() #mute adc self.setMute() self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: if localtime( time() ).tm_year > 1970 and self.session.nav.getCurrentlyPlayingServiceOrGroup( ): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) self.session.nav.stopService() else: self.standbyTimeUnknownTimer.callback.append( self.stopService) self.standbyTimeUnknownTimer.startLongTimer(60) elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr( InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __onClose(self): global inStandby inStandby = None self.standbyTimeoutTimer.stop() self.standbyStopServiceTimer.stop() self.timeHandler and self.timeHandler.m_timeUpdated.get().remove(self.stopService) if self.prev_running_service: self.session.nav.playService(self.prev_running_service) elif self.paused_service: self.paused_service.unPauseService() self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) if RecordTimer.RecordTimerEntry.receiveRecordEvents: RecordTimer.RecordTimerEntry.stopTryQuitMainloop()
def __init__(self, session): Screen.__init__(self, session) self.avswitch = AVSwitch() if boxtype == 'gb800se' or boxtype == 'gb800solo' or boxtype == 'gb800ue': self.forled = readled() if self.forled[0] == 'True': self.ledenable = 1 else: self.ledenable = 0 print "enter standby" self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) #mute adc self.setMute() self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceReference( ) #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose) if boxtype == 'gb800se' or boxtype == 'gb800solo' or boxtype == 'gb800ue': self.sign = 0 self.zaPrik = eTimer() self.zaPrik.timeout.get().append(self.vrime) self.zaPrik.start(1, 1)
def __init__(self, session): Screen.__init__(self, session) self.skinName = 'Standby' self.avswitch = AVSwitch() print '[Standby] enter standby' self['actions'] = ActionMap(['StandbyActions'], {'power': self.Power, 'discrete_on': self.Power}, -1) globalActionMap.setEnabled(False) self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None self.setMute() if SystemInfo['Display'] and SystemInfo['LCDMiniTV']: setLCDModeMinitTV('0') self.paused_service = None self.prev_running_service = None self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() service = self.prev_running_service and self.prev_running_service.toString() if service: if service.startswith('1:') and service.rsplit(':', 1)[1].startswith('/'): self.paused_service = self.session.current_dialog self.paused_service.pauseService() else: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr(InfoBar.instance, 'showPiP') and InfoBar.instance.showPiP() if SystemInfo['ScartSwitch']: self.avswitch.setInput('SCART') else: self.avswitch.setInput('AUX') if getBrandOEM() in 'fulan': open('/proc/stb/hdmi/output', 'w').write('off') if int(config.usage.hdd_standby_in_standby.value) != -1: for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime(int(config.usage.hdd_standby_in_standby.value)) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose) return
def __init__(self, session): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power }, -1) globalActionMap.setEnabled(False) #mute adc self.setMute() self.paused_service = None self.prev_running_service = None self.connected_time_handler = False if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceReference() #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose) if config.misc.standbyCounter.value == 0 and config.misc.useTransponderTime.value: th = eDVBLocalTimeHandler.getInstance() if not th.ready(): refstr = config.servicelist.lastmode.value == 'tv' and config.tv.lastservice.value or config.radio.lastservice.value ref = eServiceReference(refstr) if ref.valid(): th.m_timeUpdated.get().append(self.timeReady) self.connected_time_handler = True self.session.nav.playService(ref)
def __onClose(self): global inStandby inStandby = None self.standbyStopServiceTimer.stop() self.timeHandler and self.timeHandler.m_timeUpdated.get().remove(self.stopService) if self.paused_service: self.infoBarInstance.unPauseService() elif self.prev_running_service: service = self.prev_running_service.toString() if config.servicelist.startupservice_onstandby.value: self.session.nav.playService(eServiceReference(config.servicelist.startupservice.value)) from Screens.InfoBar import InfoBar InfoBar.instance and InfoBar.instance.servicelist.correctChannelNumber() else: self.session.nav.playService(self.prev_running_service) self.session.screen['Standby'].boolean = False globalActionMap.setEnabled(True)
def __onClose(self): global inStandby inStandby = None self.standbyStopServiceTimer.stop() self.timeHandler and self.timeHandler.m_timeUpdated.get().remove(self.stopService) if self.paused_service: self.infoBarInstance.unPauseService() elif self.prev_running_service: service = self.prev_running_service.toString() if config.servicelist.startupservice_onstandby.value: self.session.nav.playService(eServiceReference(config.servicelist.startupservice.value)) from Screens.InfoBar import InfoBar InfoBar.instance and InfoBar.instance.servicelist.correctChannelNumber() else: self.session.nav.playService(self.prev_running_service) self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True)
def __init__(self, session): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap(["StandbyActions"], {"power": self.Power}, -1) globalActionMap.setEnabled(False) #mute adc self.setMute() self.paused_service = None self.prev_running_service = None self.time_handler_conn = False if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceReference( ) #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose) if config.misc.standbyCounter.value == 0 and config.misc.useTransponderTime.value: th = eDVBLocalTimeHandler.getInstance() if not th.ready(): refstr = config.servicelist.lastmode.value == 'tv' and config.tv.lastservice.value or config.radio.lastservice.value ref = eServiceReference(refstr) if ref.valid(): self.time_handler_conn = th.m_timeUpdated.connect( self.timeReady) self.session.nav.playService(ref, False, False)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.standbyTimeUnknownTimer = eTimer() #mute adc self.setMute() self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: if localtime( time() ).tm_year > 1970 and self.session.nav.getCurrentlyPlayingServiceOrGroup( ): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) self.session.nav.stopService() else: self.standbyTimeUnknownTimer.callback.append( self.stopService) self.standbyTimeUnknownTimer.startLongTimer(60) elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.StandbyCounterIncrease = StandbyCounterIncrease #mute adc self.setMute() self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power }, -1) globalActionMap.setEnabled(False) self.StandbyCounterIncrease = StandbyCounterIncrease #mute adc self.setMute() self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __onClose(self): global inStandby inStandby = None if self.prev_running_service: self.session.nav.playService(self.prev_running_service) elif self.paused_service: self.paused_service.unPauseService() elif self.prev_running_service: service = self.prev_running_service.toString() if config.servicelist.startupservice_onstandby.value: self.session.nav.playService(eServiceReference(config.servicelist.startupservice.value)) from Screens.InfoBar import InfoBar InfoBar.instance and InfoBar.instance.servicelist.correctChannelNumber() else: self.session.nav.playService(self.prev_running_service) self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) print ("goto deep1") Notifications.RemovePopup(id = "RecordTimerQuitMainloop")
def __onClose(self): global inStandby inStandby = None self.standbyStopServiceTimer.stop() self.timeHandler and self.timeHandler.m_timeUpdated.get().remove(self.stopService) if self.paused_service: self.paused_service.unPauseService() elif self.prev_running_service: service = self.prev_running_service.toString() if config.servicelist.startupservice_onstandby.value: self.session.nav.playService(eServiceReference(config.servicelist.startupservice.value)) from Screens.InfoBar import InfoBar InfoBar.instance and InfoBar.instance.servicelist.correctChannelNumber() else: self.session.nav.playService(self.prev_running_service) self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime(int(config.usage.hdd_standby.value)) # HDD standby timer value (box active)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) #mute adc self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) #mute adc self.setMute() self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceReference( ) #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") #+++> open("/proc/stb/hdmi/output", "w").write("off") #+++< self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __onClose(self): global inStandby inStandby = None if self.prev_running_service: self.session.nav.playService(self.prev_running_service) elif self.paused_service: self.paused_service.unPauseService() self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) if boxtype == 'gb800se' or boxtype == 'gb800solo' or boxtype == 'gb800ue': try: open("/proc/stb/fp/rtc", "w").write(str(0)) except IOError: print "setRTCtime failed!" self.zaPrik.stop() if self.forled[0] == 'True': self.ledenable = 1 else: self.ledenable = 0 if self.ledenable == 1: evfd.getInstance().vfd_led(str(self.forled[1]))
def __onClose(self): global inStandby inStandby = None self.standbyStopServiceTimer.stop() self.timeHandler and self.timeHandler.m_timeUpdated.get().remove(self.stopService) if self.paused_service: self.paused_action and self.paused_service.unPauseService() elif self.prev_running_service: service = self.prev_running_service.toString() if config.servicelist.startupservice_onstandby.value: self.session.nav.playService(eServiceReference(config.servicelist.startupservice.value)) from Screens.InfoBar import InfoBar InfoBar.instance and InfoBar.instance.servicelist.correctChannelNumber() else: self.session.nav.playService(self.prev_running_service) self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) self.avswitch.setInput("ENCODER") self.leaveMute() if os.path.exists("/usr/scripts/standby_leave.sh"): Console().ePopen("/usr/scripts/standby_leave.sh")
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "[Standby] enter standby" if path.exists("/usr/scripts/standby_enter.sh"): Console().ePopen("/usr/scripts/standby_enter.sh") self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar self.infoBarInstance = InfoBar.instance self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDMiniTVMode("0") self.paused_service = self.paused_action = False self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) if Components.ParentalControl.parentalControl.isProtected( self.prev_running_service): self.prev_running_service = eServiceReference( config.tv.lastservice.value) service = self.prev_running_service and self.prev_running_service.toString( ) if service: if service.rsplit(":", 1)[1].startswith("/"): self.paused_service = hasattr( self.session.current_dialog, "pauseService") and hasattr( self.session.current_dialog, "unPauseService" ) and self.session.current_dialog or self.infoBarInstance self.paused_action = hasattr( self.paused_service, "seekstate" ) and hasattr( self.paused_service, "SEEK_STATE_PLAY" ) and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY self.paused_action and self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr( self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if getBrandOEM() in ('dinobot') or SystemInfo["HasHiSi"]: try: open("/proc/stb/hdmi/output", "w").write("off") except: pass self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def enableKeyMap(self): globalActionMap.setEnabled(True) eActionMap.getInstance().bindKey('keymap.xml', 'generic', 103, 5, 'ListboxActions', 'moveUp') eActionMap.getInstance().bindKey('keymap.xml', 'generic', 108, 5, 'ListboxActions', 'moveDown') eActionMap.getInstance().bindKey('keymap.xml', 'generic', 105, 5, 'ListboxActions', 'pageUp') eActionMap.getInstance().bindKey('keymap.xml', 'generic', 106, 5, 'ListboxActions', 'pageDown')
def enableKeyMap(self): globalActionMap.setEnabled(True)
def __init__(self, session): Screen.__init__(self, session) self.skinName = 'Standby' self.avswitch = AVSwitch() print '[Standby] enter standby' if os.path.exists('/usr/scripts/StandbyEnter.sh'): Console().ePopen('/usr/scripts/StandbyEnter.sh &') self['actions'] = ActionMap( ['StandbyActions'], { 'power': self.Power, 'power_make': self.Power_make, 'power_break': self.Power_break, 'power_long': self.Power_long, 'power_repeat': self.Power_repeat, 'discrete_on': self.Power }, -1) globalActionMap.setEnabled(False) self.ignoreKeyBreakTimer = eTimer() self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None self.setMute() if SystemInfo['Display'] and SystemInfo['LCDMiniTV']: setLCDModeMinitTV('0') self.paused_service = None self.prev_running_service = None self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) service = self.prev_running_service and self.prev_running_service.toString( ) if service: if service.startswith('1:') and service.rsplit( ':', 1)[1].startswith('/'): self.paused_service = self.session.current_dialog self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr( InfoBar.instance, 'showPiP') and InfoBar.instance.showPiP() if SystemInfo['ScartSwitch']: self.avswitch.setInput('SCART') else: self.avswitch.setInput('AUX') if getBrandOEM() in 'fulan': open('/proc/stb/hdmi/output', 'w').write('off') if int(config.usage.hdd_standby_in_standby.value) != -1: for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime( int(config.usage.hdd_standby_in_standby.value)) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose) return
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "[Standby] enter standby" self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.standbyTimeUnknownTimer = eTimer() #mute adc self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: if localtime( time() ).tm_year > 1970 and self.session.nav.getCurrentlyPlayingServiceOrGroup( ): if config.servicelist.startupservice_standby.value: self.prev_running_service = eServiceReference( config.servicelist.startupservice_standby.value) else: self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) self.session.nav.stopService() else: self.standbyTimeUnknownTimer.callback.append( self.stopService) self.standbyTimeUnknownTimer.startLongTimer(60) elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr( InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("off") if int( config.usage.hdd_standby_in_standby.value ) != -1: # HDD standby timer value (box in standby) / -1 = same as when box is active for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime( int(config.usage.hdd_standby_in_standby.value)) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "[Standby] enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None #mute adc self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") self.paused_service = None self.prev_running_service = None self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() service = self.prev_running_service and self.prev_running_service.toString() if service: if service.startswith("1:") and service.rsplit(":", 1)[1].startswith("/"): self.paused_service = self.session.current_dialog self.paused_service.pauseService() else: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("off") if int(config.usage.hdd_standby_in_standby.value) != -1: # HDD standby timer value (box in standby) / -1 = same as when box is active for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime(int(config.usage.hdd_standby_in_standby.value)) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar self.infoBarInstance = InfoBar.instance self.StandbyCounterIncrease = StandbyCounterIncrease self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None #mute adc self.setMute() self.paused_service = None self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() service = self.prev_running_service and self.prev_running_service.toString() if service: if service.rsplit(":", 1)[1][:1] == "/": self.paused_service = True self.infoBarInstance.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") #+++> call("/bin/vdstandby -a &", shell="true") #+++< gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() self.oldService = self.session.nav.getCurrentlyPlayingServiceOrGroup() print "[Standby] enter standby" SystemInfo["StandbyState"] = True if os.path.exists("/usr/script/StandbyEnter.sh"): Console().ePopen("/usr/script/StandbyEnter.sh &") self["actions"] = ActionMap( ["StandbyActions"], { "power": self.Power, "power_make": self.Power_make, "power_break": self.Power_break, "power_long": self.Power_long, "power_repeat": self.Power_repeat, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.ignoreKeyBreakTimer = eTimer() self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None #mute adc self.setMute() self.stopService() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") elif SystemInfo["Display"] and SystemInfo["LCDMiniTV4k"]: # set LCDminiTV off setLCDModeMinitTV4k("disable") self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr( InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) print "goto deep2" if gotoShutdownTime: print "goto deep3" self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) if (getBrandOEM() in ('fulan', 'clap', 'dinobot') or getMachineBuild() in ('gbmv200', 'sf8008', 'sf8008m', 'ustym4kpro')): try: open("/proc/stb/hdmi/output", "w").write("off") except: pass self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "enter standby" if getMachineProcModel() in ('ini-7012'): if path.exists("/proc/stb/lcd/symbol_scrambled"): open("/proc/stb/lcd/symbol_scrambled", "w").write("0") if path.exists("/proc/stb/lcd/symbol_1080p"): open("/proc/stb/lcd/symbol_1080p", "w").write("0") if path.exists("/proc/stb/lcd/symbol_1080i"): open("/proc/stb/lcd/symbol_1080i", "w").write("0") if path.exists("/proc/stb/lcd/symbol_720p"): open("/proc/stb/lcd/symbol_720p", "w").write("0") if path.exists("/proc/stb/lcd/symbol_576i"): open("/proc/stb/lcd/symbol_576i", "w").write("0") if path.exists("/proc/stb/lcd/symbol_576p"): open("/proc/stb/lcd/symbol_576p", "w").write("0") if path.exists("/proc/stb/lcd/symbol_hd"): open("/proc/stb/lcd/symbol_hd", "w").write("0") if path.exists("/proc/stb/lcd/symbol_dolby_audio"): open("/proc/stb/lcd/symbol_dolby_audio", "w").write("0") if path.exists("/proc/stb/lcd/symbol_mp3"): open("/proc/stb/lcd/symbol_mp3", "w").write("0") self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.standbyTimeUnknownTimer = eTimer() #mute adc self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: if localtime(time()).tm_year > 1970 and self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService() else: self.standbyTimeUnknownTimer.callback.append(self.stopService) self.standbyTimeUnknownTimer.startLongTimer(60) elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() if self.session.pipshown: del self.session.pip self.session.pipshown = False #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "enter standby" if getMachineProcModel() in ('ini-7012'): if path.exists("/proc/stb/lcd/symbol_scrambled"): open("/proc/stb/lcd/symbol_scrambled", "w").write("0") if path.exists("/proc/stb/lcd/symbol_1080p"): open("/proc/stb/lcd/symbol_1080p", "w").write("0") if path.exists("/proc/stb/lcd/symbol_1080i"): open("/proc/stb/lcd/symbol_1080i", "w").write("0") if path.exists("/proc/stb/lcd/symbol_720p"): open("/proc/stb/lcd/symbol_720p", "w").write("0") if path.exists("/proc/stb/lcd/symbol_576i"): open("/proc/stb/lcd/symbol_576i", "w").write("0") if path.exists("/proc/stb/lcd/symbol_576p"): open("/proc/stb/lcd/symbol_576p", "w").write("0") if path.exists("/proc/stb/lcd/symbol_hd"): open("/proc/stb/lcd/symbol_hd", "w").write("0") if path.exists("/proc/stb/lcd/symbol_dolby_audio"): open("/proc/stb/lcd/symbol_dolby_audio", "w").write("0") if path.exists("/proc/stb/lcd/symbol_mp3"): open("/proc/stb/lcd/symbol_mp3", "w").write("0") self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) #mute adc self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") self.paused_service = None self.prev_running_service = None if self.session.current_dialog: if self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_STOPS: #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() #stop actual played dvb-service self.session.nav.stopService() elif self.session.current_dialog.ALLOW_SUSPEND == Screen.SUSPEND_PAUSES: self.paused_service = self.session.current_dialog self.paused_service.pauseService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("off") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def disableKeyMap(self): globalActionMap.setEnabled(False) eActionMap.getInstance().unbindNativeKey("ListboxActions", 0) eActionMap.getInstance().unbindNativeKey("ListboxActions", 1) eActionMap.getInstance().unbindNativeKey("ListboxActions", 4) eActionMap.getInstance().unbindNativeKey("ListboxActions", 5)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "[Standby] enter standby" if getBoxType() in ('ini-7012', 'ini-7012au'): if path.exists("/proc/stb/lcd/symbol_scrambled"): open("/proc/stb/lcd/symbol_scrambled", "w").write("0") if path.exists("/proc/stb/lcd/symbol_1080p"): open("/proc/stb/lcd/symbol_1080p", "w").write("0") if path.exists("/proc/stb/lcd/symbol_1080i"): open("/proc/stb/lcd/symbol_1080i", "w").write("0") if path.exists("/proc/stb/lcd/symbol_720p"): open("/proc/stb/lcd/symbol_720p", "w").write("0") if path.exists("/proc/stb/lcd/symbol_576i"): open("/proc/stb/lcd/symbol_576i", "w").write("0") if path.exists("/proc/stb/lcd/symbol_576p"): open("/proc/stb/lcd/symbol_576p", "w").write("0") if path.exists("/proc/stb/lcd/symbol_hd"): open("/proc/stb/lcd/symbol_hd", "w").write("0") if path.exists("/proc/stb/lcd/symbol_dolby_audio"): open("/proc/stb/lcd/symbol_dolby_audio", "w").write("0") if path.exists("/proc/stb/lcd/symbol_mp3"): open("/proc/stb/lcd/symbol_mp3", "w").write("0") self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power, "deepstandby": self.deepStandby, }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar self.infoBarInstance = InfoBar.instance self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None # mute adc self.setMute() self.paused_service = None self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() service = self.prev_running_service and self.prev_running_service.toString() if service: if service.rsplit(":", 1)[1].startswith("/"): self.paused_service = True self.infoBarInstance.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() self.videoOff() self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def enableKeyMap(self): globalActionMap.setEnabled(True) eActionMap.getInstance().bindKey("keymap.xml", "generic", 103, 5, "ListboxActions", "moveUp") eActionMap.getInstance().bindKey("keymap.xml", "generic", 108, 5, "ListboxActions", "moveDown") eActionMap.getInstance().bindKey("keymap.xml", "generic", 105, 5, "ListboxActions", "pageUp") eActionMap.getInstance().bindKey("keymap.xml", "generic", 106, 5, "ListboxActions", "pageDown")
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "[Standby] enter standby" if os.path.exists("/usr/scripts/standby_enter.sh"): Console().ePopen("/usr/scripts/standby_enter.sh") self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar self.infoBarInstance = InfoBar.instance self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDMiniTVMode("0") self.paused_service = self.paused_action = False self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() if Components.ParentalControl.parentalControl.isProtected(self.prev_running_service): self.prev_running_service = eServiceReference(config.tv.lastservice.value) service = self.prev_running_service and self.prev_running_service.toString() if service: if service.rsplit(":", 1)[1].startswith("/"): self.paused_service = hasattr(self.session.current_dialog, "pauseService") and hasattr(self.session.current_dialog, "unPauseService") and self.session.current_dialog or self.infoBarInstance self.paused_action = hasattr(self.paused_service, "seekstate") and hasattr(self.paused_service, "SEEK_STATE_PLAY") and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY self.paused_action and self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print "[Standby] enter standby" if os.path.exists("/usr/script/standby_enter.sh"): Console().ePopen("/usr/script/standby_enter.sh") self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar from Screens.SleepTimerEdit import isNextWakeupTime self.infoBarInstance = InfoBar.instance self.StandbyCounterIncrease = StandbyCounterIncrease self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.standbyWakeupTimer = eTimer() self.standbyWakeupTimer.callback.append(self.standbyWakeup) self.timeHandler = None self.setMute() self.paused_service = self.paused_action = False self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() if Components.ParentalControl.parentalControl.isProtected(self.prev_running_service): self.prev_running_service = eServiceReference(config.tv.lastservice.value) service = self.prev_running_service and self.prev_running_service.toString() if service: if service.rsplit(":", 1)[1].startswith("/"): self.paused_service = hasattr(self.session.current_dialog, "pauseService") and hasattr(self.session.current_dialog, "unPauseService") and self.session.current_dialog or self.infoBarInstance self.paused_action = hasattr(self.paused_service, "seekstate") and hasattr(self.paused_service, "SEEK_STATE_PLAY") and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY self.paused_action and self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) gotoWakeupTime = isNextWakeupTime(True) if gotoWakeupTime != -1: curtime = localtime(time()) if curtime.tm_year > 1970: wakeup_time = int(gotoWakeupTime - time()) if wakeup_time > 0: self.standbyWakeupTimer.startLongTimer(wakeup_time) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "[Standby] enter standby" if os.path.exists("/usr/script/StandbyEnter.sh"): Console().ePopen("/usr/script/StandbyEnter.sh &") self["actions"] = ActionMap( ["StandbyActions"], { "power": self.Power, "power_make": self.Power_make, "power_break": self.Power_break, "power_long": self.Power_long, "power_repeat": self.Power_repeat, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) self.ignoreKeyBreakTimer = eTimer() self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None #mute adc self.setMute() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDModeMinitTV("0") self.paused_service = self.paused_action = False self.prev_running_service = None if config.servicelist.startupservice_standby.value: self.prev_running_service = eServiceReference( config.servicelist.startupservice_standby.value) else: self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) service = self.prev_running_service and self.prev_running_service.toString( ) if service: if service.startswith("1:") and service.rsplit( ":", 1)[1].startswith("/"): self.paused_service = hasattr( self.session.current_dialog, "pauseService" ) and hasattr( self.session.current_dialog, "unPauseService" ) and self.session.current_dialog or self.infoBarInstance self.paused_action = hasattr( self.paused_service, "seekstate" ) and hasattr( self.paused_service, "SEEK_STATE_PLAY" ) and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY self.paused_action and self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: if config.misc.SyncTimeUsing.value == 0: self.timeHandler.m_timeUpdated.get().append( self.stopService) else: self.standbyStopServiceTimer.startLongTimer(5) if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr( InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("off") if int( config.usage.hdd_standby_in_standby.value ) != -1: # HDD standby timer value (box in standby) / -1 = same as when box is active for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime( int(config.usage.hdd_standby_in_standby.value)) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def disableKeyMap(self): globalActionMap.setEnabled(False)
def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print("[Standby] enter standby") SystemInfo["StandbyState"] = True if os.path.exists("/usr/script/standby_enter.sh"): Console().ePopen("/usr/script/standby_enter.sh") self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar from Screens.SleepTimerEdit import isNextWakeupTime self.infoBarInstance = InfoBar.instance self.StandbyCounterIncrease = StandbyCounterIncrease self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.standbyWakeupTimer = eTimer() self.standbyWakeupTimer.callback.append(self.standbyWakeup) self.timeHandler = None self.setMute() self.paused_service = self.paused_action = False self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) if Components.ParentalControl.parentalControl.isProtected( self.prev_running_service): self.prev_running_service = eServiceReference( config.tv.lastservice.value) service = self.prev_running_service and self.prev_running_service.toString( ) if service: if service.rsplit(":", 1)[1].startswith("/"): self.paused_service = hasattr( self.session.current_dialog, "pauseService") and hasattr( self.session.current_dialog, "unPauseService" ) and self.session.current_dialog or self.infoBarInstance self.paused_action = hasattr( self.paused_service, "seekstate" ) and hasattr( self.paused_service, "SEEK_STATE_PLAY" ) and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY self.paused_action and self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr( self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if SystemInfo["HiSilicon"]: try: open("/proc/stb/hdmi/output", "w").write("off") except: pass if SystemInfo["AmlogicFamily"]: try: open("/sys/class/leds/led-sys/brightness", "w").write("0") except: pass try: open("/sys/class/cec/cmd", "w").write("0f 36") except: pass gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) gotoWakeupTime = isNextWakeupTime(True) if gotoWakeupTime != -1: curtime = localtime(time()) if curtime.tm_year > 1970: wakeup_time = int(gotoWakeupTime - time()) if wakeup_time > 0: self.standbyWakeupTimer.startLongTimer(wakeup_time) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print "[Standby] enter standby" if os.path.exists("/usr/script/standby_enter.sh"): Console().ePopen("/usr/script/standby_enter.sh") self["actions"] = ActionMap(["StandbyActions"], { "power": self.Power, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar self.infoBarInstance = InfoBar.instance self.StandbyCounterIncrease = StandbyCounterIncrease self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.timeHandler = None self.setMute() self.paused_service = self.paused_action = False self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) if Components.ParentalControl.parentalControl.isProtected( self.prev_running_service): self.prev_running_service = eServiceReference( config.tv.lastservice.value) service = self.prev_running_service and self.prev_running_service.toString( ) if service: if service.rsplit(":", 1)[1].startswith("/"): self.paused_service = hasattr( self.session.current_dialog, "pauseService") and hasattr( self.session.current_dialog, "unPauseService" ) and self.session.current_dialog or self.infoBarInstance self.paused_action = hasattr( self.paused_service, "seekstate" ) and hasattr( self.paused_service, "SEEK_STATE_PLAY" ) and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY self.paused_action and self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: self.timeHandler.m_timeUpdated.get().append(self.stopService) if self.session.pipshown: self.infoBarInstance and hasattr( self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)
def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print "[Standby] enter standby" self["actions"] = ActionMap( ["StandbyActions"], { "power": self.Power, "power_make": self.Power_make, "power_break": self.Power_break, "power_long": self.Power_long, "power_repeat": self.Power_repeat, "discrete_on": self.Power }, -1) globalActionMap.setEnabled(False) from Screens.InfoBar import InfoBar from Screens.SleepTimerEdit import isNextWakeupTime self.infoBarInstance = InfoBar.instance self.StandbyCounterIncrease = StandbyCounterIncrease self.standbyTimeoutTimer = eTimer() self.standbyTimeoutTimer.callback.append(self.standbyTimeout) self.ignoreKeyBreakTimer = eTimer() self.standbyStopServiceTimer = eTimer() self.standbyStopServiceTimer.callback.append(self.stopService) self.standbyWakeupTimer = eTimer() self.standbyWakeupTimer.callback.append(self.standbyWakeup) self.timeHandler = None self.setMute() self.paused_service = self.paused_action = False self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) if Components.ParentalControl.parentalControl.isProtected( self.prev_running_service): self.prev_running_service = eServiceReference( config.tv.lastservice.value) service = self.prev_running_service and self.prev_running_service.toString( ) if service: if service.rsplit(":", 1)[1].startswith("/"): self.paused_service = hasattr( self.session.current_dialog, "pauseService") and hasattr( self.session.current_dialog, "unPauseService" ) and self.session.current_dialog or self.infoBarInstance self.paused_action = hasattr( self.paused_service, "seekstate" ) and hasattr( self.paused_service, "SEEK_STATE_PLAY" ) and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY self.paused_action and self.paused_service.pauseService() if not self.paused_service: self.timeHandler = eDVBLocalTimeHandler.getInstance() if self.timeHandler.ready(): if self.session.nav.getCurrentlyPlayingServiceOrGroup(): self.stopService() else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None else: if config.misc.SyncTimeUsing.value == 0: self.timeHandler.m_timeUpdated.get().append( self.stopService) else: self.standbyStopServiceTimer.startLongTimer(5) self.timeHandler = None if self.session.pipshown: self.infoBarInstance and hasattr( self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP() if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("off") if int( config.usage.hdd_standby_in_standby.value ) != -1: # HDD standby timer value (box in standby) / -1 = same as when box is active for hdd in harddiskmanager.HDDList(): hdd[1].setIdleTime( int(config.usage.hdd_standby_in_standby.value)) gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value) if gotoShutdownTime: self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime) gotoWakeupTime = isNextWakeupTime(True) if gotoWakeupTime != -1: curtime = localtime(time()) if curtime.tm_year > 1970: wakeup_time = int(gotoWakeupTime - time()) if wakeup_time > 0: self.standbyWakeupTimer.startLongTimer(wakeup_time) self.onFirstExecBegin.append(self.__onFirstExecBegin) self.onClose.append(self.__onClose)