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