Exemple #1
0
        if config.av.vcrswitch.value or value > 2:
            if value:
                self.scartDialog.showMessageBox()
            else:
                self.scartDialog.switchToTV()


profile("Load:CI")
from Screens.Ci import CiHandler

profile("Load:VolumeControl")
from Components.VolumeControl import VolumeControl

profile("Load:StackTracePrinter")
from Components.StackTrace import StackTracePrinter
StackTracePrinterInst = StackTracePrinter()

from time import time, localtime, strftime
from Tools.StbHardware import setFPWakeuptime, setRTCtime


def autorestoreLoop():
    # Check if auto restore settings fails, just start the wizard (avoid a endless loop)
    count = 0
    if os.path.exists("/media/hdd/images/config/autorestore"):
        f = open("/media/hdd/images/config/autorestore", "r")
        try:
            count = int(f.read())
        except:
            count = 0
        f.close()
Exemple #2
0
def runScreenTest():
    config.misc.startCounter.value += 1

    profile("readPluginList")
    plugins.readPluginList(resolveFilename(SCOPE_PLUGINS))

    profile("Init:Session")
    nav = Navigation(config.misc.nextWakeup.value)
    session = Session(desktop=enigma.getDesktop(0),
                      summary_desktop=enigma.getDesktop(1),
                      navigation=nav)

    CiHandler.setSession(session)

    screensToRun = [
        p.__call__ for p in plugins.getPlugins(PluginDescriptor.WHERE_WIZARD)
    ]

    profile("wizards")
    screensToRun += wizardManager.getWizards()
    screensToRun.append((100, InfoBar.InfoBar))
    screensToRun.sort()

    enigma.ePythonConfigQuery.setQueryFunc(configfile.getResolvedKey)

    def runNextScreen(session, screensToRun, *result):
        if result:
            print "[mytest.py] quitMainloop #3"
            enigma.quitMainloop(*result)
            return

        screen = screensToRun[0][1]
        args = screensToRun[0][2:]
        if screensToRun:
            session.openWithCallback(
                boundFunction(runNextScreen, session, screensToRun[1:]),
                screen, *args)
        else:
            session.open(screen, *args)

    runNextScreen(session, screensToRun)

    profile("Init:VolumeControl")
    vol = VolumeControl(session)
    profile("Init:PowerKey")
    power = PowerKey(session)

    if boxtype in ('sf8008', 'clap4k', 'alien5', 'osninopro', 'osnino',
                   'osninoplus', 'alphatriple', 'spycat4kmini', 'tmtwin4k',
                   'mbmicrov2', 'revo4k', 'force3uhd', 'wetekplay',
                   'wetekplay2', 'wetekhub', 'dm7020hd', 'dm7020hdv2',
                   'osminiplus', 'osmega', 'sf3038', 'spycat', 'e4hd',
                   'e4hdhybrid', 'mbmicro', 'et7500', 'mixosf5', 'mixosf7',
                   'mixoslumi', 'gi9196m', 'maram9', 'ixussone', 'ixusszero',
                   'uniboxhd1', 'uniboxhd2', 'uniboxhd3', 'sezam5000hd',
                   'mbtwin', 'sezam1000hd', 'mbmini', 'atemio5x00',
                   'beyonwizt3', '9910lx', '9911lx') or getBrandOEM() in (
                       'fulan') or getMachineBuild() in ('dags7362',
                                                         'dags73625', 'dags5'):
        profile("VFDSYMBOLS")
        import Components.VfdSymbols
        Components.VfdSymbols.SymbolsCheck(session)

    # we need session.scart to access it from within menu.xml
    session.scart = AutoScartControl(session)

    profile("Init:Trashcan")
    import Tools.Trashcan
    Tools.Trashcan.init(session)

    profile("Init:AutoVideoMode")
    import Screens.VideoMode
    Screens.VideoMode.autostart(session)

    profile("Init:StackTracePrinter")
    from threading import current_thread
    StackTracePrinter.activate(current_thread().ident)

    profile("RunReactor")
    profile_final()

    if boxtype in ('sf8', 'classm', 'axodin', 'axodinc', 'starsatlx', 'genius',
                   'evo'):
        f = open("/dev/dbox/oled0", "w")
        f.write('-E2-')
        f.close()

    print "lastshutdown=%s		(True = last shutdown was OK)" % config.usage.shutdownOK.value
    print "NOK shutdown action=%s" % config.usage.shutdownNOK_action.value
    print "bootup action=%s" % config.usage.boot_action.value
    if not config.usage.shutdownOK.value and not config.usage.shutdownNOK_action.value == 'normal' or not config.usage.boot_action.value == 'normal':
        print "last shutdown = %s" % config.usage.shutdownOK.value
        import Screens.PowerLost
        Screens.PowerLost.PowerLost(session)

    config.usage.shutdownOK.setValue(False)
    config.usage.shutdownOK.save()
    configfile.save()

    # kill showiframe if it is running (sh4 hack...)
    if getMachineBuild() in ('spark', 'spark7162'):
        os.system("killall -9 showiframe")

    runReactor()

    print "[mytest.py] normal shutdown"
    config.misc.startCounter.save()
    config.usage.shutdownOK.setValue(True)
    config.usage.shutdownOK.save()

    profile("wakeup")

    #get currentTime
    nowTime = time()
    #	if not config.misc.SyncTimeUsing.value == "0" or getBrandOEM() == 'gigablue':
    if not config.misc.SyncTimeUsing.value == "0" or boxtype.startswith(
            'gb') or getBrandOEM().startswith('ini'):
        print "dvb time sync disabled... so set RTC now to current linux time!", strftime(
            "%Y/%m/%d %H:%M", localtime(nowTime))
        setRTCtime(nowTime)

    #recordtimer
    if session.nav.isRecordTimerImageStandard:  #check RecordTimer instance
        tmp = session.nav.RecordTimer.getNextRecordingTime(
            getNextStbPowerOn=True)
        nextRecordTime = tmp[0]
        nextRecordTimeInStandby = tmp[1]
    else:
        nextRecordTime = session.nav.RecordTimer.getNextRecordingTime()
        nextRecordTimeInStandby = session.nav.RecordTimer.isNextRecordAfterEventActionAuto(
        )
    #zaptimer
    nextZapTime = session.nav.RecordTimer.getNextZapTime()
    nextZapTimeInStandby = 0
    #powertimer
    tmp = session.nav.PowerTimer.getNextPowerManagerTime(
        getNextStbPowerOn=True)
    nextPowerTime = tmp[0]
    nextPowerTimeInStandby = tmp[1]
    #plugintimer
    tmp = plugins.getNextWakeupTime(getPluginIdent=True)
    nextPluginTime = tmp[0]
    nextPluginIdent = tmp[1]  #"pluginname | pluginfolder"
    tmp = tmp[1].lower()
    #start in standby, depending on plugin type
    if "epgrefresh" in tmp:
        nextPluginName = "EPGRefresh"
        nextPluginTimeInStandby = 1
    elif "vps" in tmp:
        nextPluginName = "VPS"
        nextPluginTimeInStandby = 1
    elif "serienrecorder" in tmp:
        nextPluginName = "SerienRecorder"
        nextPluginTimeInStandby = 1
    elif "elektro" in tmp:
        nextPluginName = "Elektro"
        nextPluginTimeInStandby = 1
    elif "minipowersave" in tmp:
        nextPluginName = "MiniPowersave"
        nextPluginTimeInStandby = 1
    elif "enhancedpowersave" in tmp:
        nextPluginName = "EnhancedPowersave"
        nextPluginTimeInStandby = 1
    else:
        #default for plugins
        nextPluginName = nextPluginIdent
        nextPluginTimeInStandby = 0

    wakeupList = [
        x for x in ((nextRecordTime, 0, nextRecordTimeInStandby),
                    (nextZapTime, 1, nextZapTimeInStandby),
                    (nextPowerTime, 2, nextPowerTimeInStandby),
                    (nextPluginTime, 3, nextPluginTimeInStandby)) if x[0] != -1
    ]
    wakeupList.sort()

    print "=" * 100
    if wakeupList and wakeupList[0][0] > 0:
        startTime = wakeupList[0]
        # wakeup time before timer begins
        wptime = startTime[0] - (config.workaround.wakeuptime.value * 60)
        if (wptime - nowTime) < 120:  # no time to switch box back on
            wptime = int(nowTime) + 120  # so switch back on in 120 seconds

        #check for plugin-, zap- or power-timer to enable the 'forced' record-timer wakeup
        forceNextRecord = 0
        setStandby = startTime[2]
        if startTime[1] != 0 and nextRecordTime > 0:
            #when next record starts in 15 mins
            if abs(nextRecordTime - startTime[0]) <= 900:
                setStandby = forceNextRecord = 1
            #by vps-plugin
            elif startTime[1] == 3 and nextPluginName == "VPS":
                setStandby = forceNextRecord = 1

        if startTime[1] == 3:
            nextPluginName = " (%s)" % nextPluginName
        else:
            nextPluginName = ""
        print "[mytest.py] set next wakeup type to '%s'%s %s" % (
            {
                0: "record-timer",
                1: "zap-timer",
                2: "power-timer",
                3: "plugin-timer"
            }[startTime[1]], nextPluginName, {
                0: "and starts normal",
                1: "and starts in standby"
            }[setStandby])
        if forceNextRecord:
            print "[mytest.py] set from 'vps-plugin' or just before a 'record-timer' starts, set 'record-timer' wakeup flag"
        print "[mytest.py] set next wakeup time to", strftime(
            "%a, %Y/%m/%d %H:%M:%S", localtime(wptime))
        #set next wakeup
        setFPWakeuptime(wptime)
        #set next standby only after shutdown in deep standby
        if Screens.Standby.quitMainloopCode != 1 and Screens.Standby.quitMainloopCode != 45:
            setStandby = 2  # 0=no standby, but get in standby if wakeup to timer start > 60 sec (not for plugin-timer, here is no standby), 1=standby, 2=no standby, when before was not in deep-standby
        config.misc.nextWakeup.value = "%d,%d,%d,%d,%d,%d,%d" % (
            int(nowTime), wptime, startTime[0], startTime[1], setStandby,
            nextRecordTime, forceNextRecord)
    else:
        config.misc.nextWakeup.value = "-1,-1,-1,0,0,-1,0"
        setFPWakeuptime(int(nowTime) -
                        3600)  #minus one hour -> overwrite old wakeup time
        print "[mytest.py] no set next wakeup time"
    config.misc.nextWakeup.save()
    print "=" * 100

    profile("stopService")
    session.nav.stopService()
    profile("nav shutdown")
    session.nav.shutdown()

    profile("configfile.save")
    configfile.save()
    from Screens import InfoBarGenerics
    InfoBarGenerics.saveResumePoints()

    return 0