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