class Scart(Screen): def __init__(self, session, start_visible=True): Screen.__init__(self, session) self.avswitch = AVSwitch() if start_visible: self.onExecBegin.append(self.showMessageBox) self.msgVisible = None else: self.msgVisible = False def showMessageBox(self): if self.msgVisible is None: self.onExecBegin.remove(self.showMessageBox) self.msgVisible = False if not self.msgVisible: self.msgVisible = True self.avswitch.setInput("SCART") self.msgBox = self.session.openWithCallback(self.MsgBoxClosed, MessageBox, _("If you see this, something is wrong with\nyour scart connection. Press OK to return."), MessageBox.TYPE_ERROR) def MsgBoxClosed(self, *val): self.msgBox = None self.switchToTV() def switchToTV(self, *val): if self.msgVisible: if self.msgBox: self.msgBox.close() # ... MsgBoxClosed -> switchToTV again.. return self.avswitch.setInput("ENCODER") self.msgVisible = False
class Scart(Screen): def __init__(self, session, start_visible=True): Screen.__init__(self, session) self.msgBox = None self.notificationVisible = None self.avswitch = AVSwitch() if start_visible: self.onExecBegin.append(self.showMessageBox) self.msgVisible = None else: self.msgVisible = False def showMessageBox(self): if self.msgVisible is None: self.onExecBegin.remove(self.showMessageBox) self.msgVisible = False if not self.msgVisible: self.msgVisible = True self.avswitch.setInput("SCART") if not self.session.in_exec: self.notificationVisible = True Notifications.AddNotificationWithCallback( self.MsgBoxClosed, MessageBox, _("If you see this, something is wrong with\nyour scart connection. Press OK to return." ), MessageBox.TYPE_ERROR, msgBoxID="scart_msgbox") else: self.msgBox = self.session.openWithCallback( self.MsgBoxClosed, MessageBox, _("If you see this, something is wrong with\nyour scart connection. Press OK to return." ), MessageBox.TYPE_ERROR) def MsgBoxClosed(self, *val): self.msgBox = None self.switchToTV() def switchToTV(self, *val): if self.msgVisible: if self.msgBox: self.msgBox.close() # ... MsgBoxClosed -> switchToTV again.. return self.avswitch.setInput("ENCODER") self.msgVisible = False if self.notificationVisible: self.avswitch.setInput("ENCODER") self.notificationVisible = False for notification in Notifications.current_notifications: try: if notification[1].msgBoxID == "scart_msgbox": notification[1].close() except: print( "[Scart] other notification is open. try another one.")
class Scart(Screen): def __init__(self, session, start_visible=True): Screen.__init__(self, session) self.avswitch = AVSwitch() if start_visible: self.onExecBegin.append(self.showMessageBox) self.msgVisible = None else: self.msgVisible = False def showMessageBox(self): if self.msgVisible is None: self.onExecBegin.remove(self.showMessageBox) self.msgVisible = False if not self.msgVisible: self.msgVisible = True self.avswitch.setInput("SCART") self.msgBox = self.session.openWithCallback( self.MsgBoxClosed, MessageBox, _("If you see this, something is wrong with\nyour scart connection. Press OK to return." ), MessageBox.TYPE_ERROR) def MsgBoxClosed(self, *val): self.msgBox = None self.switchToTV() def switchToTV(self, *val): if self.msgVisible: if self.msgBox: self.msgBox.close() # ... MsgBoxClosed -> switchToTV again.. return self.avswitch.setInput("ENCODER") self.msgVisible = False
class Scart(Screen): def __init__(self, session, start_visible = True): Screen.__init__(self, session) self.msgBox = None self.notificationVisible = None self.avswitch = AVSwitch() if start_visible: self.onExecBegin.append(self.showMessageBox) self.msgVisible = None else: self.msgVisible = False return def showMessageBox(self): if self.msgVisible is None: self.onExecBegin.remove(self.showMessageBox) self.msgVisible = False if not self.msgVisible: self.msgVisible = True self.avswitch.setInput('SCART') if not self.session.in_exec: self.notificationVisible = True Notifications.AddNotificationWithCallback(self.MsgBoxClosed, MessageBox, _('If you see this, something is wrong with\nyour scart connection. Press OK to return.'), MessageBox.TYPE_ERROR, msgBoxID='scart_msgbox') else: self.msgBox = self.session.openWithCallback(self.MsgBoxClosed, MessageBox, _('If you see this, something is wrong with\nyour scart connection. Press OK to return.'), MessageBox.TYPE_ERROR) return def MsgBoxClosed(self, *val): self.msgBox = None self.switchToTV() return def switchToTV(self, *val): if self.msgVisible: if self.msgBox: self.msgBox.close() return self.avswitch.setInput('ENCODER') self.msgVisible = False if self.notificationVisible: self.avswitch.setInput('ENCODER') self.notificationVisible = False for notification in Notifications.current_notifications: try: if notification[1].msgBoxID == 'scart_msgbox': notification[1].close() except: print 'other notification is open. try another one.'
class Standby(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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.standbyTimeUnknownTimer = eTimer() self.standbyTimeoutTimer = 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") 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.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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True if self.StandbyCounterIncrease: config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def standbyTimeout(self): if config.usage.standby_to_shutdown_timer_blocktime.value: curtime = localtime(time()) if curtime.tm_year > 1970: #check if the current time is valid curtime = (curtime.tm_hour, curtime.tm_min, curtime.tm_sec) begintime = tuple( config.usage.standby_to_shutdown_timer_blocktime_begin. value) endtime = tuple( config.usage.standby_to_shutdown_timer_blocktime_end.value) if begintime <= endtime and ( curtime >= begintime and curtime < endtime) or begintime > endtime and ( curtime >= begintime or curtime < endtime): duration = (endtime[0] * 3600 + endtime[1] * 60) - ( curtime[0] * 3600 + curtime[1] * 60 + curtime[2]) if duration: if duration < 0: duration += 24 * 3600 self.standbyTimeoutTimer.startLongTimer(duration) return if self.session.screen["TunerInfo"].tuner_use_mask: self.standbyTimeoutTimer.startLongTimer(600) else: from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop() def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) self.session.nav.stopService()
class Standby(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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() self.session.screen["Standby"].boolean = False globalActionMap.setEnabled(True) if RecordTimer.RecordTimerEntry.receiveRecordEvents: RecordTimer.RecordTimerEntry.stopTryQuitMainloop() def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True if self.StandbyCounterIncrease: config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def standbyTimeout(self): from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop()
class Standby2(Screen): def Power(self): print 'leave standby' self.avswitch.setInput('ENCODER') self.leaveMute() if SystemInfo['Display'] and SystemInfo['LCDMiniTV']: setLCDModeMinitTV(config.lcd.modeminitv.getValue()) PowerTimer.resetTimerWakeup() RecordTimer.resetTimerWakeup() self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print 'mute already active' else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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.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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen['Standby'].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): 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()
class Standby(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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.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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary
class Standby(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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.standbyTimeUnknownTimer = eTimer() self.standbyTimeoutTimer = 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") 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.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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True if self.StandbyCounterIncrease: config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def standbyTimeout(self): if config.usage.standby_to_shutdown_timer_blocktime.value: curtime = localtime(time()) if curtime.tm_year > 1970: #check if the current time is valid curtime = (curtime.tm_hour, curtime.tm_min, curtime.tm_sec) begintime = tuple(config.usage.standby_to_shutdown_timer_blocktime_begin.value) endtime = tuple(config.usage.standby_to_shutdown_timer_blocktime_end.value) if begintime <= endtime and (curtime >= begintime and curtime < endtime) or begintime > endtime and (curtime >= begintime or curtime < endtime): duration = (endtime[0]*3600 + endtime[1]*60) - (curtime[0]*3600 + curtime[1]*60 + curtime[2]) if duration: if duration < 0: duration += 24*3600 self.standbyTimeoutTimer.startLongTimer(duration) return if self.session.screen["TunerInfo"].tuner_use_mask: self.standbyTimeoutTimer.startLongTimer(600) else: from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop() def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "[Standby] leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "[Standby] mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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) 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") 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.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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "leave standby" if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("on") #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) #remove wakup files and reset wakup state PowerTimer.resetTimerWakeup() RecordTimer.resetTimerWakeup() #kill me if os.path.exists("/usr/scripts/standby.sh") is True: os.system("chmod 755 /usr/scripts/standby.sh") os.system("/usr/scripts/standby.sh") else: print "/usr/scripts/standby.sh not found" self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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") 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 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) def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): 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()
class Standby2(Screen): def Power(self): print '[Standby] leave standby' if getBrandOEM() in 'fulan': open('/proc/stb/hdmi/output', 'w').write('on') self.avswitch.setInput('ENCODER') self.leaveMute() if SystemInfo['Display'] and SystemInfo['LCDMiniTV']: setLCDModeMinitTV(config.lcd.modeminitv.value) self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print '[Standby] mute already active' else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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)) return def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen['Standby'].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "[Standby] leave standby" if os.path.exists("/usr/script/StandbyLeave.sh"): Console().ePopen("/usr/script/StandbyLeave.sh &") if (getBrandOEM() in ('fulan','clap','dinobot') or getBoxType() in ('sf8008','ustym4kpro')): open("/proc/stb/hdmi/output", "w").write("on") #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) #kill me self.close(True) # normally handle only key's 'make' event def Power_make(self): if (config.usage.on_short_powerpress.value != "standby_noTVshutdown"): self.Power() # with the option "standby_noTVshutdown", use 'break' event / allow turning off the TV by a 'long' key press in standby # avoid waking from standby by ignoring the key's 'break' event after the 'long' and subsequent 'repeat' events. def Power_long(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown"): self.TVoff() self.ignoreKeyBreakTimer.start(250,1) def Power_repeat(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown") and self.ignoreKeyBreakTimer.isActive(): self.ignoreKeyBreakTimer.start(250,1) def Power_break(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown") and not self.ignoreKeyBreakTimer.isActive(): self.Power() def TVoff(self): print "[Standby] TVoff" TVinStandby.skipHdmiCecNow(False) TVinStandby.setTVstate('standby') def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "[Standby] mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 = 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: 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: 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','clap','dinobot') or getBoxType() in ('sf8008','ustym4kpro')): 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) #remove wakup files and reset wakup state PowerTimer.resetTimerWakeup() RecordTimer.resetTimerWakeup() #kill me if os.path.exists("/usr/scripts/standby.sh") is True: os.system("chmod 755 /usr/scripts/standby.sh") os.system("/usr/scripts/standby.sh") else: print "/usr/scripts/standby.sh not found" self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 = 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: 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): 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()
class Standby(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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 prikaz(self): if self.forled[4] == 'True': clock = str(localtime()[3]) clock1 = str(localtime()[4]) if self.forled[5] != '24h': if clock > 12: clock = str(int(clock) - 12) if len(clock) != 2: clock = " "+clock if len(clock1) != 2: clock1 = "0"+clock1 if self.sign == 0: clock = clock+":" self.sign = 1 else: self.sign = 0 clock = clock+clock1 evfd.getInstance().vfd_write_string(str(clock)) else: evfd.getInstance().vfd_write_string(" ") if self.forled[0] == 'True': self.ledenable = 1 evfd.getInstance().vfd_led(str(self.forled[2])) else: self.ledenable = 0 evfd.getInstance().vfd_led(str(0)) def vrime(self): self.zaPrik.start(1000, 1) self.prikaz() def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary
class Standby2(Screen): def Power(self): print "leave standby" if (getBrandOEM() in ('fulan', 'clap') or getBoxType() in ('sf8008')): open("/proc/stb/hdmi/output", "w").write("on") #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() self.session.nav.playService(self.oldService) # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) elif SystemInfo["Display"] and SystemInfo["LCDMiniTV4k"]: setLCDModeMinitTV4k(config.lcd.modeminitv4k.value) #kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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() 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() #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') or getBoxType() in ('sf8008')): 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) print "goto deep1" Notifications.RemovePopup(id="RecordTimerQuitMainloop") def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def standbyTimeout(self): print "goto deep3" from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop() def stopService(self): if config.servicelist.startupservice_standby.value: self.oldService = eServiceReference( config.servicelist.startupservice_standby.value) else: self.oldService = self.session.nav.getCurrentlyPlayingServiceReference( ) self.session.nav.stopService()
class Standby(Screen): def Power(self): print "leave standby" #+++> import os #os.system("/bin/vdstandby -d") try: os.popen("/bin/vdstandby -d") except OSError: print "no memory" #+++< #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #set brightness of lcd config.lcd.bright.apply() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() def __init__(self, session): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" #+++> import os #os.system("/bin/vdstandby -a") try: os.popen("/bin/vdstandby -a") except OSError: print "no memory" #+++< self["actions"] = ActionMap(["StandbyActions"], {"power": self.Power}, -1) #mute adc self.setMute() #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceReference( ) #stop actual played dvb-service self.session.nav.stopService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") #set lcd brightness to standby value config.lcd.standby.apply() self.onShow.append(self.__onShow) self.onHide.append(self.__onHide) self.onClose.append(self.__onClose) def __onClose(self): if self.prev_running_service: self.session.nav.playService(self.prev_running_service) def createSummary(self): return StandbySummary def __onShow(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True def __onHide(self): global inStandby inStandby = None self.session.screen["Standby"].boolean = False
class Standby(Screen): def Power(self): print("[Standby] leave standby") SystemInfo["StandbyState"] = False self.close(True) if os.path.exists("/usr/script/StandbyLeave.sh"): Console().ePopen("/usr/script/StandbyLeave.sh") if SystemInfo["HiSilicon"]: try: open("/proc/stb/hdmi/output", "w").write("on") except: pass if SystemInfo["AmlogicFamily"]: try: open("/sys/class/leds/led-sys/brightness", "w").write("1") except: pass try: open("/sys/class/cec/cmd", "w").write("10 04") except: pass def setMute(self): self.wasMuted = eDVBVolumecontrol.getInstance().isMuted() if not self.wasMuted: eDVBVolumecontrol.getInstance().volumeMute() def leaveMute(self): if not self.wasMuted: eDVBVolumecontrol.getInstance().volumeUnMute() 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True if self.StandbyCounterIncrease: config.misc.standbyCounter.value += 1 def stopService(self): 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) self.session.nav.stopService() def createSummary(self): return StandbySummary def standbyTimeout(self): if config.usage.standby_to_shutdown_timer_blocktime.value: curtime = localtime(time()) if curtime.tm_year > 1970: #check if the current time is valid curtime = (curtime.tm_hour, curtime.tm_min, curtime.tm_sec) begintime = tuple( config.usage.standby_to_shutdown_timer_blocktime_begin. value) endtime = tuple( config.usage.standby_to_shutdown_timer_blocktime_end.value) if begintime <= endtime and ( curtime >= begintime and curtime < endtime) or begintime > endtime and ( curtime >= begintime or curtime < endtime): duration = (endtime[0] * 3600 + endtime[1] * 60) - ( curtime[0] * 3600 + curtime[1] * 60 + curtime[2]) if duration: if duration < 0: duration += 24 * 3600 self.standbyTimeoutTimer.startLongTimer(duration) return if self.session.screen["TunerInfo"].tuner_use_mask or mediafilesInUse( self.session): self.standbyTimeoutTimer.startLongTimer(600) else: from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop() def standbyWakeup(self): self.Power()
class Standby2(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() def __init__(self, session): Screen.__init__(self, session) self.skinName = "Standby" self.avswitch = AVSwitch() print "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 }, -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.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) def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService()
class Standby(Screen): def Power(self): print "leave standby" #+++> call("/bin/vdstandby -d &", shell="true") #+++< #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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 RecordTimer.RecordTimerEntry.receiveRecordEvents: RecordTimer.RecordTimerEntry.stopTryQuitMainloop() def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True if self.StandbyCounterIncrease: config.misc.standbyCounter.value += 1 def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService() def createSummary(self): return StandbySummary def standbyTimeout(self): if config.usage.standby_to_shutdown_timer_blocktime.value: curtime = localtime(time()) if curtime.tm_year > 1970: #check if the current time is valid curtime = (curtime.tm_hour, curtime.tm_min, curtime.tm_sec) begintime = tuple(config.usage.standby_to_shutdown_timer_blocktime_begin.value) endtime = tuple(config.usage.standby_to_shutdown_timer_blocktime_end.value) if begintime <= endtime and (curtime >= begintime and curtime < endtime) or begintime > endtime and (curtime >= begintime or curtime < endtime): duration = (endtime[0]*3600 + endtime[1]*60) - (curtime[0]*3600 + curtime[1]*60 + curtime[2]) if duration: if duration < 0: duration += 24*3600 self.standbyTimeoutTimer.startLongTimer(duration) return if self.session.screen["TunerInfo"].tuner_use_mask or internalHDDNotSleeping(): self.standbyTimeoutTimer.startLongTimer(600) else: from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop()
class Standby(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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 prikaz(self): if self.forled[4] == 'True': clock = str(localtime()[3]) clock1 = str(localtime()[4]) if self.forled[5] != '24h': if clock > 12: clock = str(int(clock) - 12) if len(clock) != 2: clock = " " + clock if len(clock1) != 2: clock1 = "0" + clock1 if self.sign == 0: clock = clock + ":" self.sign = 1 else: self.sign = 0 clock = clock + clock1 evfd.getInstance().vfd_write_string(str(clock)) else: evfd.getInstance().vfd_write_string(" ") if self.forled[0] == 'True': self.ledenable = 1 evfd.getInstance().vfd_led(str(self.forled[2])) else: self.ledenable = 0 evfd.getInstance().vfd_led(str(0)) def vrime(self): self.zaPrik.start(1000, 1) self.prikaz() def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary
class Standby(Screen): def Power(self): print "[Standby] leave standby" self.leaveMute() self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "[Standby] mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() def __init__(self, session, StandbyCounterIncrease=True): Screen.__init__(self, session) self.avswitch = AVSwitch() print "[Standby] 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 self.setMute() self.paused_service = self.paused_action = False 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 = 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 ('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) 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.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 (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() self.avswitch.setInput("ENCODER") def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True if self.StandbyCounterIncrease: config.misc.standbyCounter.value += 1 def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) self.session.nav.stopService() def createSummary(self): return StandbySummary def standbyTimeout(self): if config.usage.standby_to_shutdown_timer_blocktime.value: curtime = localtime(time()) if curtime.tm_year > 1970: #check if the current time is valid curtime = (curtime.tm_hour, curtime.tm_min, curtime.tm_sec) begintime = tuple( config.usage.standby_to_shutdown_timer_blocktime_begin. value) endtime = tuple( config.usage.standby_to_shutdown_timer_blocktime_end.value) if begintime <= endtime and ( curtime >= begintime and curtime < endtime) or begintime > endtime and ( curtime >= begintime or curtime < endtime): duration = (endtime[0] * 3600 + endtime[1] * 60) - ( curtime[0] * 3600 + curtime[1] * 60 + curtime[2]) if duration: if duration < 0: duration += 24 * 3600 self.standbyTimeoutTimer.startLongTimer(duration) return if self.session.screen[ "TunerInfo"].tuner_use_mask or internalHDDNotSleeping(): self.standbyTimeoutTimer.startLongTimer(600) else: from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop()
class Standby2(Screen): def Power(self): print '[Standby] leave standby' if os.path.exists('/usr/scripts/StandbyLeave.sh'): Console().ePopen('/usr/scripts/StandbyLeave.sh &') if getBrandOEM() in 'fulan': open('/proc/stb/hdmi/output', 'w').write('on') self.avswitch.setInput('ENCODER') self.leaveMute() if SystemInfo['Display'] and SystemInfo['LCDMiniTV']: setLCDModeMinitTV(config.lcd.minitvmode.value) self.close(True) def Power_make(self): if config.usage.on_short_powerpress.value != 'standby_noTVshutdown': self.Power() def Power_long(self): if config.usage.on_short_powerpress.value == 'standby_noTVshutdown': self.TVoff() self.ignoreKeyBreakTimer.start(250, 1) def Power_repeat(self): if config.usage.on_short_powerpress.value == 'standby_noTVshutdown' and self.ignoreKeyBreakTimer.isActive( ): self.ignoreKeyBreakTimer.start(250, 1) def Power_break(self): if config.usage.on_short_powerpress.value == 'standby_noTVshutdown' and not self.ignoreKeyBreakTimer.isActive( ): self.Power() def TVoff(self): print '[Standby] TVoff' try: config.hdmicec.control_tv_standby_skipnow.setValue(False) config.hdmicec.TVoffCounter.value += 1 except: pass def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print '[Standby] mute already active' else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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)) return def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen['Standby'].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) self.session.nav.stopService()
class Standby(Screen): def Power(self): print "[Standby] leave standby" self.close(True) # normally handle only key's 'make' event def Power_make(self): if (config.usage.on_short_powerpress.value != "standby_noTVshutdown"): self.Power() # with the option "standby_noTVshutdown", use 'break' event / allow turning off the TV by a 'long' key press in standby # avoid waking from standby by ignoring the key's 'break' event after the 'long' and subsequent 'repeat' events. def Power_long(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown"): self.TVoff() self.ignoreKeyBreakTimer.start(250, 1) def Power_repeat(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown" ) and self.ignoreKeyBreakTimer.isActive(): self.ignoreKeyBreakTimer.start(250, 1) def Power_break(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown" ) and not self.ignoreKeyBreakTimer.isActive(): self.Power() def TVoff(self): print "[Standby] TVoff" try: config.hdmicec.control_tv_standby_skipnow.setValue(False) except: pass # no HdmiCec config.hdmicec.TVoffCounter.value += 1 def setMute(self): self.wasMuted = eDVBVolumecontrol.getInstance().isMuted() if not self.wasMuted: eDVBVolumecontrol.getInstance().volumeMute() def leaveMute(self): if not self.wasMuted: eDVBVolumecontrol.getInstance().volumeUnMute() 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) 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 (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() self.avswitch.setInput("ENCODER") self.leaveMute() def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True if self.StandbyCounterIncrease: config.misc.standbyCounter.value += 1 def stopService(self): 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) self.session.nav.stopService() def createSummary(self): return StandbySummary def standbyTimeout(self): if config.usage.standby_to_shutdown_timer_blocktime.value: curtime = localtime(time()) if curtime.tm_year > 1970: #check if the current time is valid curtime = (curtime.tm_hour, curtime.tm_min, curtime.tm_sec) begintime = tuple( config.usage.standby_to_shutdown_timer_blocktime_begin. value) endtime = tuple( config.usage.standby_to_shutdown_timer_blocktime_end.value) if begintime <= endtime and ( curtime >= begintime and curtime < endtime) or begintime > endtime and ( curtime >= begintime or curtime < endtime): duration = (endtime[0] * 3600 + endtime[1] * 60) - ( curtime[0] * 3600 + curtime[1] * 60 + curtime[2]) if duration: if duration < 0: duration += 24 * 3600 self.standbyTimeoutTimer.startLongTimer(duration) return if self.session.screen[ "TunerInfo"].tuner_use_mask or internalHDDNotSleeping(): self.standbyTimeoutTimer.startLongTimer(600) else: from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop() def standbyWakeup(self): self.Power()
class Standby(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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) def timeReady(self): if self.time_handler_conn: self.time_handler_conn = None self.session.nav.stopService() 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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary
class Standby2(Screen): def Power(self): print "[Standby] leave standby" if os.path.exists("/usr/script/StandbyLeave.sh"): Console().ePopen("/usr/script/StandbyLeave.sh &") if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("on") #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) #kill me self.close(True) # normally handle only key's 'make' event def Power_make(self): if (config.usage.on_short_powerpress.value != "standby_noTVshutdown"): self.Power() # with the option "standby_noTVshutdown", use 'break' event / allow turning off the TV by a 'long' key press in standby # avoid waking from standby by ignoring the key's 'break' event after the 'long' and subsequent 'repeat' events. def Power_long(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown"): self.TVoff() self.ignoreKeyBreakTimer.start(250,1) def Power_repeat(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown") and self.ignoreKeyBreakTimer.isActive(): self.ignoreKeyBreakTimer.start(250,1) def Power_break(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown") and not self.ignoreKeyBreakTimer.isActive(): self.Power() def TVoff(self): print "[Standby] TVoff" try: config.hdmicec.control_tv_standby_skipnow.setValue(False) config.hdmicec.TVoffCounter.value += 1 except: pass # no HdmiCec def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "[Standby] mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 = 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() #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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService()
class Standby(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 timeReady(self): if self.time_handler_conn: self.time_handler_conn = None self.session.nav.stopService() 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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary
class Standby2(Screen): def Power(self): print "leave standby" if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("on") #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) #remove wakup files and reset wakup state PowerTimer.resetTimerWakeup() RecordTimer.resetTimerWakeup() #kill me if os.path.exists("/usr/scripts/standby.sh") is True: os.system("chmod 755 /usr/scripts/standby.sh") os.system("/usr/scripts/standby.sh") else: print "/usr/scripts/standby.sh not found" self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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") 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 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) def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): 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()
class Standby2(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) #remove wakup files and reset wakup state PowerTimer.resetTimerWakeup() RecordTimer.resetTimerWakeup() #kill me if os.path.exists("/usr/scripts/standby.sh") is True: os.system("chmod 755 /usr/scripts/standby.sh") os.system("/usr/scripts/standby.sh") else: print "/usr/scripts/standby.sh not found" self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 = 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: 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): 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()
class Standby(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #set brightness of lcd config.lcd.bright.apply() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() def __init__(self, session): Screen.__init__(self, session) self.avswitch = AVSwitch() print "enter standby" self["actions"] = ActionMap( [ "StandbyActions" ], { "power": self.Power }, -1) #mute adc self.setMute() #get currently playing service reference self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceReference() #stop actual played dvb-service self.session.nav.stopService() #set input to vcr scart if SystemInfo["ScartSwitch"]: self.avswitch.setInput("SCART") else: self.avswitch.setInput("AUX") #set lcd brightness to standby value config.lcd.standby.apply() self.onShow.append(self.__onShow) self.onHide.append(self.__onHide) self.onClose.append(self.__onClose) def __onClose(self): if self.prev_running_service: self.session.nav.playService(self.prev_running_service) def createSummary(self): return StandbySummary def __onShow(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True def __onHide(self): global inStandby inStandby = None self.session.screen["Standby"].boolean = False
class Standby2(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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.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) def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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() 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary
class Standby2(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) #remove wakup files and reset wakup state PowerTimer.resetTimerWakeup() RecordTimer.resetTimerWakeup() #kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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(): 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 __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) def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.getValue()) #kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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) def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup() self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "leave standby" if (getBrandOEM() in ('fulan', 'clap', 'dinobot') or getMachineBuild() in ('gbmv200', 'sf8008', 'sf8008m', 'ustym4kpro')): try: open("/proc/stb/hdmi/output", "w").write("on") except: pass #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() self.session.nav.playService(self.oldService) # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) elif SystemInfo["Display"] and SystemInfo["LCDMiniTV4k"]: setLCDModeMinitTV4k(config.lcd.modeminitv4k.value) #kill me self.close(True) # normally handle only key's 'make' event def Power_make(self): if (config.usage.on_short_powerpress.value != "standby_noTVshutdown"): self.Power() # with the option "standby_noTVshutdown", use 'break' event / allow turning off the TV by a 'long' key press in standby # avoid waking from standby by ignoring the key's 'break' event after the 'long' and subsequent 'repeat' events. def Power_long(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown"): self.TVoff() self.ignoreKeyBreakTimer.start(250, 1) def Power_repeat(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown" ) and self.ignoreKeyBreakTimer.isActive(): self.ignoreKeyBreakTimer.start(250, 1) def Power_break(self): if (config.usage.on_short_powerpress.value == "standby_noTVshutdown" ) and not self.ignoreKeyBreakTimer.isActive(): self.Power() def TVoff(self): print "[Standby] TVoff" TVinStandby.skipHdmiCecNow(False) TVinStandby.setTVstate('standby') def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def standbyTimeout(self): print "goto deep3" from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop() def stopService(self): if config.servicelist.startupservice_standby.value: self.oldService = eServiceReference( config.servicelist.startupservice_standby.value) else: self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "[Standby] leave standby" self.close(True) def setMute(self): self.wasMuted = eDVBVolumecontrol.getInstance().isMuted() if not self.wasMuted: eDVBVolumecontrol.getInstance().volumeMute() def leaveMute(self): if not self.wasMuted: eDVBVolumecontrol.getInstance().volumeUnMute() 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): 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) self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "leave standby" if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("on") #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) #kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary
class Standby2(Screen): def Power(self): if getBrandOEM() in ('dinobot') or SystemInfo["HasHiSi"]: try: open("/proc/stb/hdmi/output", "w").write("on") except: pass print "[Standby] leave standby" self.close(True) def setMute(self): self.wasMuted = eDVBVolumecontrol.getInstance().isMuted() if not self.wasMuted: eDVBVolumecontrol.getInstance().volumeMute() def leaveMute(self): if not self.wasMuted: eDVBVolumecontrol.getInstance().volumeUnMute() 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 __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 path.exists("/usr/scripts/standby_leave.sh"): Console().ePopen("/usr/scripts/standby_leave.sh") def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): 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) self.session.nav.stopService()
class Standby(Screen): def Power(self): print "leave standby" # set input to encoder self.avswitch.setInput("ENCODER") # restart last played service # unmute adc self.leaveMute() # kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True if self.StandbyCounterIncrease: config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def standbyTimeout(self): from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop()
class Standby(Screen): def Power(self): print "[Standby] leave standby" self.leaveMute() self.close(True) def setMute(self): if (eDVBVolumecontrol.getInstance().isMuted()): self.wasMuted = 1 print "[Standby] mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().openMixerOnMute() # fix for vuplus eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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") if os.path.exists("/usr/script/standby_leave.sh"): Console().ePopen("/usr/script/standby_leave.sh") def __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True if self.StandbyCounterIncrease: config.misc.standbyCounter.value += 1 def stopService(self): 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) self.session.nav.stopService() def createSummary(self): return StandbySummary def standbyTimeout(self): if config.usage.standby_to_shutdown_timer_blocktime.value: curtime = localtime(time()) if curtime.tm_year > 1970: #check if the current time is valid curtime = (curtime.tm_hour, curtime.tm_min, curtime.tm_sec) begintime = tuple(config.usage.standby_to_shutdown_timer_blocktime_begin.value) endtime = tuple(config.usage.standby_to_shutdown_timer_blocktime_end.value) if begintime <= endtime and (curtime >= begintime and curtime < endtime) or begintime > endtime and (curtime >= begintime or curtime < endtime): duration = (endtime[0]*3600 + endtime[1]*60) - (curtime[0]*3600 + curtime[1]*60 + curtime[2]) if duration: if duration < 0: duration += 24*3600 self.standbyTimeoutTimer.startLongTimer(duration) return if self.session.screen["TunerInfo"].tuner_use_mask or internalHDDNotSleeping(): self.standbyTimeoutTimer.startLongTimer(600) else: from RecordTimer import RecordTimerEntry RecordTimerEntry.TryQuitMainloop() def standbyWakeup(self): self.Power()
class Standby2(Screen): def Power(self): print "[Standby] leave standby" #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() #kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "[Standby] mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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) 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() if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: # set LCDminiTV off setLCDMiniTVMode("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() 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") 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.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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.session.nav.stopService()
class Standby2(Screen): def Power(self): print "[Standby] leave standby" if (getBrandOEM() in ('fulan')): open("/proc/stb/hdmi/output", "w").write("on") #set input to encoder self.avswitch.setInput("ENCODER") #restart last played service #unmute adc self.leaveMute() # set LCDminiTV if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]: setLCDModeMinitTV(config.lcd.modeminitv.value) #kill me self.close(True) def setMute(self): if eDVBVolumecontrol.getInstance().isMuted(): self.wasMuted = 1 print "[Standby] mute already active" else: self.wasMuted = 0 eDVBVolumecontrol.getInstance().volumeToggleMute() def leaveMute(self): if self.wasMuted == 0: eDVBVolumecontrol.getInstance().volumeToggleMute() 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 __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 __onFirstExecBegin(self): global inStandby inStandby = self self.session.screen["Standby"].boolean = True config.misc.standbyCounter.value += 1 def createSummary(self): return StandbySummary def stopService(self): self.session.nav.stopService()
class FactoryTest(Screen): skin = """ <screen position="120,125" size="440,400" title="Test Menu" > <widget name="testlist" position="10,0" size="340,350" /> <widget name="resultlist" position="370,0" size="60,350" /> <widget name="testdate" position="20,350" size="150,25" font="Regular;22" /> <widget name="testversion" position="20,375" size="150,25" font="Regular;22" /> <widget name="mactext" position="180,350" size="230,25" font="Regular;22" /> </screen>""" def __init__(self, session): self["actions"] = ActionMap(["OkCancelActions","WizardActions"], { "ok": self.TestAction, "cancel": self.keyCancel, "agingstart": self.Agingmode, }, -2) Screen.__init__(self, session) TESTPROGRAM_DATE = "2009-12-09" TESTPROGRAM_VERSION = "Version 00.01" self["testdate"]=Label((TESTPROGRAM_DATE)) self["testversion"]=Label(("Loading version...")) self["mactext"]=Label(("Loading mac address...")) nimConfig = nimmanager.getNimConfig(0) nimConfig.configMode.slot_id=0 nimConfig.configMode.value= "simple" nimConfig.diseqcMode.value="diseqc_a_b" nimConfig.diseqcA.value="160" nimConfig.diseqcB.value="100" nimConfig = nimmanager.getNimConfig(1) nimConfig.configMode.slot_id=1 nimConfig.configMode.value= "simple" nimConfig.diseqcMode.value="diseqc_a_b" nimConfig.diseqcA.value="130" nimConfig.diseqcB.value="192" nimmanager.sec.update() system("cp /usr/lib/enigma2/python/Plugins/SystemPlugins/FactoryTest/testdb /etc/enigma2/lamedb") db = eDVBDB.getInstance() db.reloadServicelist() tlist = [] tlist.append((" 0. sata & extend hdd test",0)) tlist.append((" 1. Front test",1)) tlist.append((" 2. Smartcard test",2)) tlist.append((" 3. T1 H 22K x 4:3 CVBS",3)) tlist.append((" 4. T1 V 22k o 16:9 RGB",4)) tlist.append((" 5. T2 H 22k x 4:3 YC",5)) tlist.append((" 6. T2 V 22k o 16:9 CVBS",6)) tlist.append((" 7. VCR Scart loop",7)) tlist.append((" 8. rs232 test",8)) tlist.append((" 9. usb test",9)) tlist.append(("10. ethernet & mac test",10)) # tlist.append(("11. DRAM test",11)) # tlist.append(("12. Flash test",12)) # tlist.append(("13. DRAM+Flash test",13)) tlist.append(("11. factory default",11)) tlist.append(("12. shutdown",12)) self["testlist"] = MenuList(tlist) self.rlist = [] # for x in range(15): for x in range(12): self.rlist.append(("..")) self["resultlist"] = TestResultList(self.rlist) self.NetworkState = 0 self.first = 0 self.avswitch = AVSwitch() self.memTest = eMemtest() self.scTest= eSctest() self.feid=0 self.servicelist = ServiceList() self.oldref = session.nav.getCurrentlyPlayingServiceReference() print "oldref",self.oldref session.nav.stopService() # try to disable foreground service self.tunemsgtimer = eTimer() self.tunemsgtimer.callback.append(self.tunemsg) self.camstep = 1 self.camtimer = eTimer() self.camtimer.callback.append(self.cam_state) self.getmacaddr() self.getversion() self.tunerlock = 0 self.tuningtimer = eTimer() self.tuningtimer.callback.append(self.updateStatus) def updateStatus(self): index = self["testlist"].getCurrent()[1] if index ==2 or index==3: tunno = 1 result = eSctest.getInstance().getFrontendstatus(0) else: tunno = 2 result = eSctest.getInstance().getFrontendstatus(1) if index == 2 or index==4: hv = "Hor" else: hv = "Ver" print "eSctest.getInstance().getFrontendstatus - %d"%result if result == 0: self.tunerlock = 0 self.tunemsgtimer.stop() self.session.nav.stopService() self.session.open( MessageBox, _("Tune%d %s Locking Fail..."%(tunno,hv)), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" else : self.tunerlock = 1 def getversion(self): try: fd = open("/proc/stb/info/version","r") version = fd.read() self["testversion"].setText(("Version %s"%version)) except: self["testversion"].setText(("Version no load")) def readmac(self, result, retval,extra_args=None): (statecallback) = extra_args if self.macConsole is not None: if retval == 0: self.macConsole = None content =result.split() self["mactext"].setText(("MAC : "+content[10])) def getmacaddr(self): try: cmd = "ip -o addr" self.macConsole = Console() self.macConsole.ePopen(cmd, self.readmac) # self["stattext"].setText((macaddr)) except: return def TestAction(self): print "line - ",self["testlist"].getCurrent()[1] index = self["testlist"].getCurrent()[1] result = 0 if index==0: self.Test0() elif index==1: self.Test1() elif index>2 and index<7: self.TestTune(index) elif index==7: self.Test6() elif index==8: self.Test7() elif index==9: self.Test8() elif index==10: self.Test9() elif index == 2: self.Test10() # elif index == 11: # self.Test11() # elif index ==12: # self.Test12() # elif index==13: # self.Test13() elif index==10: self.Test14() elif index==11: self.Test15() def Test0(self): result = 0 checktab=0 try: mtab = open('/etc/mtab','r') while(1): disk = mtab.readline().split(' ') if len(disk) < 2: break if disk[1].startswith('/media/hdd'): checktab+=1 elif disk[1].startswith('/media/sdb1'): checktab+=10 if checktab==11: break except: checktab = 0 if checktab==0: self.session.open( MessageBox, _("Sata & extend hdd test error"), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" return elif checktab < 11: self.session.open( MessageBox, _("one hdd test error"), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" return try: if fileExists("/media/sdb1"): dummy=open("/media/sdb1/dummy03","w") dummy.write("complete") dummy.close() dummy=open("/media/sdb1/dummy03","r") if dummy.readline()=="complete": print "complete" else: result = 1 dummy.close() system("rm /media/sdb1/dummy03") else: result = 1 except: result = 1 try: if fileExists("/media/hdd"): dummy=open("/media/hdd/dummy03","w") dummy.write("complete") dummy.close() dummy=open("/media/hdd/dummy03","r") if dummy.readline()=="complete": print "complete" else: result += 1 dummy.close() system("rm /media/hdd/dummy03") else: result += 1 except: result += 1 if result ==0: self.session.open( MessageBox, _("Sata & extend hdd test pass"), MessageBox.TYPE_INFO) self.rlist[self["testlist"].getCurrent()[1]]="pass" elif result == 1: self.session.open( MessageBox, _("one hdd test error"), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" else: self.session.open( MessageBox, _("Sata & extend hdd test error"), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" def Test1(self): self.session.openWithCallback(self.displayresult ,FrontTest) def displayresult(self): global fronttest if fronttest == 1: self.rlist[self["testlist"].getCurrent()[1]]="pass" else: self.rlist[self["testlist"].getCurrent()[1]]="fail" INTERNAL_PID_STATUS_NOOP = 0 INTERNAL_PID_STATUS_WAITING = 1 INTERNAL_PID_STATUS_SUCCESSFUL = 2 INTERNAL_PID_STATUS_FAILED = 3 def TestTune(self,index): if self.oldref is None: eref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0") serviceHandler = eServiceCenter.getInstance() servicelist = serviceHandler.list(eref) if not servicelist is None: ref = servicelist.getNext() else: ref = self.getCurrentSelection() print "servicelist none" else: ref = self.oldref self.session.nav.stopService() # try to disable foreground service if index==3: ref.setData(0,1) ref.setData(1,0x6D3) ref.setData(2,0x3) ref.setData(3,0xA4) ref.setData(4,0xA00000) self.session.nav.playService(ref) self.avswitch.setColorFormat(0) self.avswitch.setAspectRatio(0) elif index==4: ref.setData(0,0x19) ref.setData(1,0x83) ref.setData(2,0x6) ref.setData(3,0x85) ref.setData(4,0x640000) self.session.nav.playService(ref) self.avswitch.setColorFormat(1) self.avswitch.setAspectRatio(6) elif index==5: # self.camstep = 1 # self.camtimer.start(100,True) ref.setData(0,1) ref.setData(1,0x6D3) ref.setData(2,0x3) ref.setData(3,0xA4) ref.setData(4,0x820000) self.session.nav.playService(ref) self.avswitch.setColorFormat(2) self.avswitch.setAspectRatio(0) elif index==6: self.camstep = 1 self.camtimer.start(100,True) ref.setData(0,0x19) ref.setData(1,0x83) ref.setData(2,0x6) ref.setData(3,0x85) ref.setData(4,0xC00000) self.session.nav.playService(ref) self.avswitch.setColorFormat(0) self.avswitch.setAspectRatio(6) self.tuningtimer.start(2000,True) self.tunemsgtimer.start(3000, True) def cam_state(self): if self.camstep == 1: slot = 0 state = eDVBCI_UI.getInstance().getState(slot) print '-1-stat',state if state > 0: self.camstep=2 self.camtimer.start(100,True) else: self.session.nav.stopService() self.session.open( MessageBox, _("NO_CAM1_NOT_INSERTED"), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" self.tunemsgtimer.stop() # self.rlist[index]="fail" # self["resultlist"].updateList(self.rlist) elif self.camstep == 2: slot = 0 appname = eDVBCI_UI.getInstance().getAppName(slot) print 'appname',appname if appname is None: self.session.nav.stopService() self.session.open( MessageBox, _("NO_GET_APPNAME"), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" self.tunemsgtimer.stop() else: self.camstep=3 self.camtimer.start(100,True) elif self.camstep==3: slot = 1 state = eDVBCI_UI.getInstance().getState(slot) print '-2-stat',state if state > 0: self.camstep=4 self.camtimer.start(100,True) else: self.session.nav.stopService() self.session.open( MessageBox, _("NO_CAM2_NOT_INSERTED"), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" self.tunemsgtimer.stop() # self.rlist[index]="fail" # self["resultlist"].updateList(self.rlist) elif self.camstep == 4: slot = 1 appname = eDVBCI_UI.getInstance().getAppName(slot) print 'appname',appname if appname is None: self.session.nav.stopService() self.session.open( MessageBox, _("NO_GET_APPNAME"), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" self.tunemsgtimer.stop() else: self.setSource() self.camstep = 5 self.session.open( MessageBox, _("CAM OK!"), MessageBox.TYPE_INFO,2) def setSource(self): filename = ("/proc/stb/tsmux/ci0_input") fd = open(filename,'w') fd.write('B') fd.close() # filename = ("/proc/stb/tsmux/ci1_input") # fd = open(filename,'w') # fd.write('CI0') # fd.close() fd=open("/proc/stb/tsmux/input1","w") fd.write("CI0") fd.close() print "CI loop test!!!!!!!!!!!!!!" def resetSource(self): fd=open("/proc/stb/tsmux/input1","w") fd.write("B") fd.close() print "CI loop test end!!!!!!!!!!!!!!" def tunemsg(self): self.tuningtimer.stop() self.session.openWithCallback(self.tuneback, MessageBox, _("%s ok?" %(self["testlist"].getCurrent()[0])), MessageBox.TYPE_YESNO) def tuneback(self,yesno): self.session.nav.stopService() # try to disable foreground service if yesno: self.rlist[self["testlist"].getCurrent()[1]]="pass" if self.tunerlock == 0: self.rlist[self["testlist"].getCurrent()[1]]="fail" elif self["testlist"].getCurrent()[1] == 5 and self.camstep < 5: self.rlist[self["testlist"].getCurrent()[1]]="fail" else: self.rlist[self["testlist"].getCurrent()[1]]="fail" self.resetSource() self["resultlist"].updateList(self.rlist) def Test6(self): self.avswitch.setInput("SCART") sleep(2) self.session.openWithCallback(self.check6, MessageBox, _("Scart loop ok?"), MessageBox.TYPE_YESNO) def check6(self,yesno): if yesno: self.rlist[self["testlist"].getCurrent()[1]]="pass" else: self.rlist[self["testlist"].getCurrent()[1]]="fail" self.avswitch.setInput("ENCODER") def check7(self): global rstest if rstest == 1: self.rlist[self["testlist"].getCurrent()[1]]="pass" else: self.rlist[self["testlist"].getCurrent()[1]]="fail" def Test7(self): self.session.openWithCallback(self.check7,RS232Test) def Agingmode(self): self.session.openWithCallback(self.checkaging,AgingTest) def checkaging(self): global Agingresult if(Agingresult ==1): self["testlist"].moveToIndex(11) self.Test14() self["testlist"].moveToIndex(12) # self["testlist"].instance.moveSelection(self["testlist"].instance.moveDown) def Test8(self): try: result = 0 mtab = open('/etc/mtab','r') while(1): disk = mtab.readline().split(' ') if len(disk) < 2: break if disk[1].startswith('/media/hdd'): continue elif disk[1].startswith('/media/sdb1'): continue elif disk[1].startswith('/media/sd'): result=result +1 if result < 0 : result = 0 if result == 3: self.session.open( MessageBox, _("USB test pass %d devices"%result), MessageBox.TYPE_INFO) self.rlist[self["testlist"].getCurrent()[1]]="pass" else: self.session.open( MessageBox, _("USB test error : Success-%d"%result+" Fail-%d"%(3-result)), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" except: if result < 0 : result = 0 if result == 3: self.session.open( MessageBox, _("USB test pass %d devices"%result), MessageBox.TYPE_INFO) self.rlist[self["testlist"].getCurrent()[1]]="pass" else: self.session.open( MessageBox, _("USB test error : Success-%d"%result+" Fail-%d"%(3-result)), MessageBox.TYPE_ERROR) self.rlist[self["testlist"].getCurrent()[1]]="fail" def Test9(self): self.session.openWithCallback(self.macresult ,MacConfig) def macresult(self): global ethtest if ethtest == 1: self.rlist[self["testlist"].getCurrent()[1]]="pass" else: self.rlist[self["testlist"].getCurrent()[1]]="fail" self.getmacaddr() def MemTest(self, which): index = which result = 0 if index==0: result = eMemtest.getInstance().dramtest() elif index==1: result = eMemtest.getInstance().flashtest() result = 0 # temp else: result = eMemtest.getInstance().dramtest() result = eMemtest.getInstance().flashtest() result = 0 # temp index = index+10 if result == 0: print index,self.rlist[index] self.rlist[index]="pass" else: print index,self.rlist[index] self.rlist[index]="fail" self["resultlist"].updateList(self.rlist) def scciresult(self): global smartcardtest if smartcardtest == 1: self.rlist[self["testlist"].getCurrent()[1]]="pass" else: self.rlist[self["testlist"].getCurrent()[1]]="fail" def Test10(self): self.session.openWithCallback(self.scciresult ,SmartCartTest) def Test11(self): self.MemTest(1) def Test12(self): self.MemTest(2) def Test13(self): self.MemTest(3) def Test14(self): try: system("rm -R /etc/enigma2") system("cp -R /usr/share/enigma2/defaults /etc/enigma2") self.rlist[self["testlist"].getCurrent()[1]]="pass" self["resultlist"].updateList(self.rlist) except: self.rlist[self["testlist"].getCurrent()[1]]="fail" self["resultlist"].updateList(self.rlist) self.session.open( MessageBox, _("Factory reset fail"), MessageBox.TYPE_ERROR) def Test15(self): self.session.openWithCallback(self.shutdown ,MessageBox, _("Do you want to shut down?"), MessageBox.TYPE_YESNO) def shutdown(self, yesno): if yesno : from os import _exit system("/usr/bin/showiframe /boot/backdrop.mvi") _exit(1) else: return def keyCancel(self): print "exit" self.close()