mytest.py

   1 import eConsoleImpl
   2 import eBaseImpl
   3 import enigma
   4 enigma.eTimer = eBaseImpl.eTimer
   5 enigma.eSocketNotifier = eBaseImpl.eSocketNotifier
   6 enigma.eConsoleAppContainer = eConsoleImpl.eConsoleAppContainer
   7
   8 from Tools.Profile import profile, profile_final
   9
  10 profile("PYTHON_START")
  11
  12 from enigma import runMainloop, eDVBDB, eTimer, quitMainloop, \
  13         getDesktop, ePythonConfigQuery, eAVSwitch, eServiceEvent, \
  14         eEPGCache
  15 from tools import *
  16
  17 profile("LANGUAGE")
  18
  19 from Components.Language import language
  20
  21 def setEPGLanguage():
  22         print "language set to", language.getLanguage()
  23         eServiceEvent.setEPGLanguage(language.getLanguage())
  24
  25 language.addCallback(setEPGLanguage)
  26
  27 from traceback import print_exc
  28 profile("LOAD:InfoBar")
  29 import Screens.InfoBar
  30 from Screens.SimpleSummary import SimpleSummary
  31
  32 from sys import stdout, exc_info
  33
  34 profile("Bouquets")
  35 eDVBDB.getInstance().reloadBouquets()
  36
  37 profile("ParentalControl")
  38 from Components.ParentalControl import InitParentalControl
  39 InitParentalControl()
  40
  41 profile("LOAD:Navigation")
  42 from Navigation import Navigation
  43
  44 profile("LOAD:skin")
  45 from skin import readSkin
  46
  47 profile("LOAD:Tools")
  48 from Tools.Directories import InitFallbackFiles, resolveFilename, SCOPE_PLUGINS, SCOPE_CURRENT_SKIN
  49 from Components.config import config, configfile, ConfigText, ConfigYesNo, ConfigInteger, NoSave
  50 InitFallbackFiles()
  51
  52 profile("config.misc")
  53
  54 config.misc.radiopic = ConfigText(default = resolveFilename(SCOPE_CURRENT_SKIN, "radio.mvi"))
  55 config.misc.isNextRecordTimerAfterEventActionAuto = ConfigYesNo(default=False)
  56 config.misc.useTransponderTime = ConfigYesNo(default=True)
  57 config.misc.startCounter = ConfigInteger(default=0) # number of e2 starts...
  58 config.misc.standbyCounter = NoSave(ConfigInteger(default=0)) # number of standby
  59 config.misc.epgcache_filename = ConfigText(default = "/hdd/epg.dat")
  60
  61 def setEPGCachePath(configElement):
  62         eEPGCache.getInstance().setCacheFile(configElement.value)
  63
  64
  65 #demo code for use of standby enter leave callbacks
  66 #def leaveStandby():
  67 #       print "!!!!!!!!!!!!!!!!!leave standby"
  68
  69 #def standbyCountChanged(configElement):
  70 #       print "!!!!!!!!!!!!!!!!!enter standby num", configElement.value
  71 #       from Screens.Standby import inStandby
  72 #       inStandby.onClose.append(leaveStandby)
  73
  74 #config.misc.standbyCounter.addNotifier(standbyCountChanged, initial_call = False)
  75 ####################################################
  76
  77 def useTransponderTimeChanged(configElement):
  78         enigma.eDVBLocalTimeHandler.getInstance().setUseDVBTime(configElement.value)
  79 config.misc.useTransponderTime.addNotifier(useTransponderTimeChanged)
  80
  81 profile("Twisted")
  82 try:
  83         import twisted.python.runtime
  84         twisted.python.runtime.platform.supportsThreads = lambda: False
  85
  86         import e2reactor
  87         e2reactor.install()
  88
  89         from twisted.internet import reactor
  90
  91         def runReactor():
  92                 reactor.run(installSignalHandlers=False)
  93 except ImportError:
  94         print "twisted not available"
  95         def runReactor():
  96                 runMainloop()
  97
  98 profile("LOAD:Plugin")
  99
 100 # initialize autorun plugins and plugin menu entries
 101 from Components.PluginComponent import plugins
 102
 103 profile("LOAD:Wizard")
 104 from Screens.Wizard import wizardManager
 105 from Screens.DefaultWizard import *
 106 from Screens.StartWizard import *
 107 from Screens.TutorialWizard import *
 108 import Screens.Rc
 109 from Tools.BoundFunction import boundFunction
 110 from Plugins.Plugin import PluginDescriptor
 111
 112 profile("misc")
 113 had = dict()
 114
 115 def dump(dir, p = ""):
 116         if isinstance(dir, dict):
 117                 for (entry, val) in dir.items():
 118                         dump(val, p + "(dict)/" + entry)
 119         if hasattr(dir, "__dict__"):
 120                 for name, value in dir.__dict__.items():
 121                         if not had.has_key(str(value)):
 122                                 had[str(value)] = 1
 123                                 dump(value, p + "/" + str(name))
 124                         else:
 125                                 print p + "/" + str(name) + ":" + str(dir.__class__) + "(cycle)"
 126         else:
 127                 print p + ":" + str(dir)
 128
 129 # + ":" + str(dir.__class__)
 130
 131 # display
 132
 133 profile("LOAD:ScreenGlobals")
 134 from Screens.Globals import Globals
 135 from Screens.SessionGlobals import SessionGlobals
 136 from Screens.Screen import Screen
 137
 138 profile("Screen")
 139 Screen.global_screen = Globals()
 140
 141 # Session.open:
 142 # * push current active dialog ('current_dialog') onto stack
 143 # * call execEnd for this dialog
 144 #   * clear in_exec flag
 145 #   * hide screen
 146 # * instantiate new dialog into 'current_dialog'
 147 #   * create screens, components
 148 #   * read, apply skin
 149 #   * create GUI for screen
 150 # * call execBegin for new dialog
 151 #   * set in_exec
 152 #   * show gui screen
 153 #   * call components' / screen's onExecBegin
 154 # ... screen is active, until it calls 'close'...
 155 # Session.close:
 156 # * assert in_exec
 157 # * save return value
 158 # * start deferred close handler ('onClose')
 159 # * execEnd
 160 #   * clear in_exec
 161 #   * hide screen
 162 # .. a moment later:
 163 # Session.doClose:
 164 # * destroy screen
 165
 166 class Session:
 167         def __init__(self, desktop = None, summary_desktop = None, navigation = None):
 168                 self.desktop = desktop
 169                 self.summary_desktop = summary_desktop
 170                 self.nav = navigation
 171                 self.delay_timer = eTimer()
 172                 self.delay_timer.callback.append(self.processDelay)
 173
 174                 self.current_dialog = None
 175
 176                 self.dialog_stack = [ ]
 177                 self.summary_stack = [ ]
 178                 self.summary = None
 179
 180                 self.in_exec = False
 181
 182                 self.screen = SessionGlobals(self)
 183
 184                 for p in plugins.getPlugins(PluginDescriptor.WHERE_SESSIONSTART):
 185                         p(reason=0, session=self)
 186
 187         def processDelay(self):
 188                 callback = self.current_dialog.callback
 189
 190                 retval = self.current_dialog.returnValue
 191
 192                 if self.current_dialog.isTmp:
 193                         self.current_dialog.doClose()
 194 #                       dump(self.current_dialog)
 195                         del self.current_dialog
 196                 else:
 197                         del self.current_dialog.callback
 198
 199                 self.popCurrent()
 200                 if callback is not None:
 201                         callback(*retval)
 202
 203         def execBegin(self, first=True, do_show = True):
 204                 assert not self.in_exec
 205                 self.in_exec = True
 206                 c = self.current_dialog
 207
 208                 # when this is an execbegin after a execend of a "higher" dialog,
 209                 # popSummary already did the right thing.
 210                 if first:
 211                         self.pushSummary()
 212                         summary = c.createSummary() or SimpleSummary
 213                         self.summary = self.instantiateSummaryDialog(summary, c)
 214                         self.summary.show()
 215                         c.addSummary(self.summary)
 216
 217                 c.saveKeyboardMode()
 218                 c.execBegin()
 219
 220                 # when execBegin opened a new dialog, don't bother showing the old one.
 221                 if c == self.current_dialog and do_show:
 222                         c.show()
 223
 224         def execEnd(self, last=True):
 225                 assert self.in_exec
 226                 self.in_exec = False
 227
 228                 self.current_dialog.execEnd()
 229                 self.current_dialog.restoreKeyboardMode()
 230                 self.current_dialog.hide()
 231
 232                 if last:
 233                         self.current_dialog.removeSummary(self.summary)
 234                         self.popSummary()
 235
 236         def create(self, screen, arguments, **kwargs):
 237                 # creates an instance of 'screen' (which is a class)
 238                 try:
 239                         return screen(self, *arguments, **kwargs)
 240                 except:
 241                         errstr = "Screen %s(%s, %s): %s" % (str(screen), str(arguments), str(kwargs), exc_info()[0])
 242                         print errstr
 243                         print_exc(file=stdout)
 244                         quitMainloop(5)
 245
 246         def instantiateDialog(self, screen, *arguments, **kwargs):
 247                 return self.doInstantiateDialog(screen, arguments, kwargs, self.desktop)
 248
 249         def deleteDialog(self, screen):
 250                 screen.hide()
 251                 screen.doClose()
 252
 253         def instantiateSummaryDialog(self, screen, *arguments, **kwargs):
 254                 return self.doInstantiateDialog(screen, arguments, kwargs, self.summary_desktop)
 255
 256         def doInstantiateDialog(self, screen, arguments, kwargs, desktop):
 257                 # create dialog
 258
 259                 try:
 260                         dlg = self.create(screen, arguments, **kwargs)
 261                 except:
 262                         print 'EXCEPTION IN DIALOG INIT CODE, ABORTING:'
 263                         print '-'*60
 264                         print_exc(file=stdout)
 265                         quitMainloop(5)
 266                         print '-'*60
 267
 268                 if dlg is None:
 269                         return
 270
 271                 # read skin data
 272                 readSkin(dlg, None, dlg.skinName, desktop)
 273
 274                 # create GUI view of this dialog
 275                 assert desktop is not None
 276
 277                 dlg.setDesktop(desktop)
 278                 dlg.applySkin()
 279
 280                 return dlg
 281
 282         def pushCurrent(self):
 283                 if self.current_dialog is not None:
 284                         self.dialog_stack.append((self.current_dialog, self.current_dialog.shown))
 285                         self.execEnd(last=False)
 286
 287         def popCurrent(self):
 288                 if self.dialog_stack:
 289                         (self.current_dialog, do_show) = self.dialog_stack.pop()
 290                         self.execBegin(first=False, do_show=do_show)
 291                 else:
 292                         self.current_dialog = None
 293
 294         def execDialog(self, dialog):
 295                 self.pushCurrent()
 296                 self.current_dialog = dialog
 297                 self.current_dialog.isTmp = False
 298                 self.current_dialog.callback = None # would cause re-entrancy problems.
 299                 self.execBegin()
 300
 301         def openWithCallback(self, callback, screen, *arguments, **kwargs):
 302                 dlg = self.open(screen, *arguments, **kwargs)
 303                 dlg.callback = callback
 304                 return dlg
 305
 306         def open(self, screen, *arguments, **kwargs):
 307                 if self.dialog_stack and not self.in_exec:
 308                         raise RuntimeError("modal open are allowed only from a screen which is modal!")
 309                         # ...unless it's the very first screen.
 310
 311                 self.pushCurrent()
 312                 dlg = self.current_dialog = self.instantiateDialog(screen, *arguments, **kwargs)
 313                 dlg.isTmp = True
 314                 dlg.callback = None
 315                 self.execBegin()
 316                 return dlg
 317
 318         def close(self, screen, *retval):
 319                 if not self.in_exec:
 320                         print "close after exec!"
 321                         return
 322
 323                 # be sure that the close is for the right dialog!
 324                 # if it's not, you probably closed after another dialog
 325                 # was opened. this can happen if you open a dialog
 326                 # onExecBegin, and forget to do this only once.
 327                 # after close of the top dialog, the underlying will
 328                 # gain focus again (for a short time), thus triggering
 329                 # the onExec, which opens the dialog again, closing the loop.
 330                 assert screen == self.current_dialog
 331
 332                 self.current_dialog.returnValue = retval
 333                 self.delay_timer.start(0, 1)
 334                 self.execEnd()
 335
 336         def pushSummary(self):
 337                 if self.summary is not None:
 338                         self.summary.hide()
 339                 self.summary_stack.append(self.summary)
 340                 self.summary = None
 341
 342         def popSummary(self):
 343                 if self.summary is not None:
 344                         self.summary.doClose()
 345                 self.summary = self.summary_stack.pop()
 346                 if self.summary is not None:
 347                         self.summary.show()
 348
 349 profile("Standby,PowerKey")
 350 import Screens.Standby
 351 from Screens.Menu import MainMenu, mdom
 352 from GlobalActions import globalActionMap
 353
 354 class PowerKey:
 355         """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
 356
 357         def __init__(self, session):
 358                 self.session = session
 359                 globalActionMap.actions["power_down"]=self.powerdown
 360                 globalActionMap.actions["power_up"]=self.powerup
 361                 globalActionMap.actions["power_long"]=self.powerlong
 362                 globalActionMap.actions["deepstandby"]=self.shutdown # frontpanel long power button press
 363                 self.standbyblocked = 1
 364
 365         def MenuClosed(self, *val):
 366                 self.session.infobar = None
 367
 368         def shutdown(self):
 369                 print "PowerOff - Now!"
 370                 if not Screens.Standby.inTryQuitMainloop and self.session.current_dialog and self.session.current_dialog.ALLOW_SUSPEND:
 371                         self.session.open(Screens.Standby.TryQuitMainloop, 1)
 372
 373         def powerlong(self):
 374                 if Screens.Standby.inTryQuitMainloop or (self.session.current_dialog and not self.session.current_dialog.ALLOW_SUSPEND):
 375                         return
 376                 self.doAction(action = config.usage.on_long_powerpress.value)
 377
 378         def doAction(self, action):
 379                 self.standbyblocked = 1
 380                 if action == "shutdown":
 381                         self.shutdown()
 382                 elif action == "show_menu":
 383                         print "Show shutdown Menu"
 384                         root = mdom.getroot()
 385                         for x in root.findall("menu"):
 386                                 y = x.find("id")
 387                                 if y is not None:
 388                                         id = y.get("val")
 389                                         if id and id == "shutdown":
 390                                                 self.session.infobar = self
 391                                                 menu_screen = self.session.openWithCallback(self.MenuClosed, MainMenu, x)
 392                                                 menu_screen.setTitle(_("Standby / Restart"))
 393                                                 return
 394                 elif action == "standby":
 395                         self.standby()
 396
 397         def powerdown(self):
 398                 self.standbyblocked = 0
 399
 400         def powerup(self):
 401                 if self.standbyblocked == 0:
 402                         self.doAction(action = config.usage.on_short_powerpress.value)
 403
 404         def standby(self):
 405                 if not Screens.Standby.inStandby and self.session.current_dialog and self.session.current_dialog.ALLOW_SUSPEND and self.session.in_exec:
 406                         self.session.open(Screens.Standby.Standby)
 407
 408 profile("Scart")
 409 from Screens.Scart import Scart
 410
 411 class AutoScartControl:
 412         def __init__(self, session):
 413                 self.force = False
 414                 self.current_vcr_sb = eAVSwitch.getInstance().getVCRSlowBlanking()
 415                 if self.current_vcr_sb and config.av.vcrswitch.value:
 416                         self.scartDialog = session.instantiateDialog(Scart, True)
 417                 else:
 418                         self.scartDialog = session.instantiateDialog(Scart, False)
 419                 config.av.vcrswitch.addNotifier(self.recheckVCRSb)
 420                 eAVSwitch.getInstance().vcr_sb_notifier.get().append(self.VCRSbChanged)
 421
 422         def recheckVCRSb(self, configElement):
 423                 self.VCRSbChanged(self.current_vcr_sb)
 424
 425         def VCRSbChanged(self, value):
 426                 #print "vcr sb changed to", value
 427                 self.current_vcr_sb = value
 428                 if config.av.vcrswitch.value or value > 2:
 429                         if value:
 430                                 self.scartDialog.showMessageBox()
 431                         else:
 432                                 self.scartDialog.switchToTV()
 433
 434 profile("Load:CI")
 435 from enigma import eDVBCIInterfaces
 436 from Screens.Ci import CiHandler
 437
 438 profile("Load:VolumeControl")
 439 from Components.VolumeControl import VolumeControl
 440
 441 def runScreenTest():
 442         config.misc.startCounter.value += 1
 443
 444         profile("readPluginList")
 445         plugins.readPluginList(resolveFilename(SCOPE_PLUGINS))
 446
 447         profile("Init:Session")
 448         nav = Navigation(config.misc.isNextRecordTimerAfterEventActionAuto.value)
 449         session = Session(desktop = getDesktop(0), summary_desktop = getDesktop(1), navigation = nav)
 450
 451         CiHandler.setSession(session)
 452
 453         screensToRun = [ p.__call__ for p in plugins.getPlugins(PluginDescriptor.WHERE_WIZARD) ]
 454
 455         profile("wizards")
 456         screensToRun += wizardManager.getWizards()
 457
 458         screensToRun.append((100, Screens.InfoBar.InfoBar))
 459
 460         screensToRun.sort()
 461
 462         ePythonConfigQuery.setQueryFunc(configfile.getResolvedKey)
 463
 464 #       eDVBCIInterfaces.getInstance().setDescrambleRules(0 # Slot Number
 465 #               ,(      ["1:0:1:24:4:85:C00000:0:0:0:"], #service_list
 466 #                       ["PREMIERE"], #provider_list,
 467 #                       [] #caid_list
 468 #               ));
 469
 470         def runNextScreen(session, screensToRun, *result):
 471                 if result:
 472                         quitMainloop(*result)
 473                         return
 474
 475                 screen = screensToRun[0][1]
 476                 args = screensToRun[0][2:]
 477
 478                 if screensToRun:
 479                         session.openWithCallback(boundFunction(runNextScreen, session, screensToRun[1:]), screen, *args)
 480                 else:
 481                         session.open(screen, *args)
 482
 483         config.misc.epgcache_filename.addNotifier(setEPGCachePath)
 484
 485         runNextScreen(session, screensToRun)
 486
 487         profile("Init:VolumeControl")
 488         vol = VolumeControl(session)
 489         profile("Init:PowerKey")
 490         power = PowerKey(session)
 491
 492         # we need session.scart to access it from within menu.xml
 493         session.scart = AutoScartControl(session)
 494
 495         profile("RunReactor")
 496         profile_final()
 497         runReactor()
 498
 499         config.misc.startCounter.save()
 500
 501         profile("wakeup")
 502         from time import time, strftime, localtime
 503         from Tools.DreamboxHardware import setFPWakeuptime, getFPWakeuptime, setRTCtime
 504         #get currentTime
 505         nowTime = time()
 506         wakeupList = [
 507                 x for x in ((session.nav.RecordTimer.getNextRecordingTime(), 0, session.nav.RecordTimer.isNextRecordAfterEventActionAuto()),
 508                                         (session.nav.RecordTimer.getNextZapTime(), 1),
 509                                         (plugins.getNextWakeupTime(), 2))
 510                 if x[0] != -1
 511         ]
 512         wakeupList.sort()
 513         recordTimerWakeupAuto = False
 514         if wakeupList:
 515                 from time import strftime
 516                 startTime = wakeupList[0]
 517                 if (startTime[0] - nowTime) < 270: # no time to switch box back on
 518                         wptime = nowTime + 30  # so switch back on in 30 seconds
 519                 else:
 520                         wptime = startTime[0] - 240
 521                 if not config.misc.useTransponderTime.value:
 522                         print "dvb time sync disabled... so set RTC now to current linux time!", strftime("%Y/%m/%d %H:%M", localtime(nowTime))
 523                         setRTCtime(nowTime)
 524                 print "set wakeup time to", strftime("%Y/%m/%d %H:%M", localtime(wptime))
 525                 setFPWakeuptime(wptime)
 526                 recordTimerWakeupAuto = startTime[1] == 0 and startTime[2]
 527         config.misc.isNextRecordTimerAfterEventActionAuto.value = recordTimerWakeupAuto
 528         config.misc.isNextRecordTimerAfterEventActionAuto.save()
 529
 530         profile("stopService")
 531         session.nav.stopService()
 532         profile("nav shutdown")
 533         session.nav.shutdown()
 534
 535         profile("configfile.save")
 536         configfile.save()
 537
 538         return 0
 539
 540 profile("Init:skin")
 541 import skin
 542 skin.loadSkinData(getDesktop(0))
 543
 544 profile("InputDevice")
 545 import Components.InputDevice
 546 Components.InputDevice.InitInputDevices()
 547
 548 profile("AVSwitch")
 549 import Components.AVSwitch
 550 Components.AVSwitch.InitAVSwitch()
 551
 552 profile("RecordingConfig")
 553 import Components.RecordingConfig
 554 Components.RecordingConfig.InitRecordingConfig()
 555
 556 profile("UsageConfig")
 557 import Components.UsageConfig
 558 Components.UsageConfig.InitUsageConfig()
 559
 560 profile("keymapparser")
 561 import keymapparser
 562 keymapparser.readKeymap(config.usage.keymap.value)
 563
 564 profile("Network")
 565 import Components.Network
 566 Components.Network.InitNetwork()
 567
 568 profile("LCD")
 569 import Components.Lcd
 570 Components.Lcd.InitLcd()
 571
 572 profile("SetupDevices")
 573 import Components.SetupDevices
 574 Components.SetupDevices.InitSetupDevices()
 575
 576 profile("RFMod")
 577 import Components.RFmod
 578 Components.RFmod.InitRFmod()
 579
 580 profile("Init:CI")
 581 import Screens.Ci
 582 Screens.Ci.InitCiConfig()
 583
 584 #from enigma import dump_malloc_stats
 585 #t = eTimer()
 586 #t.callback.append(dump_malloc_stats)
 587 #t.start(1000)
 588
 589 # first, setup a screen
 590 try:
 591         runScreenTest()
 592
 593         plugins.shutdown()
 594
 595         from Components.ParentalControl import parentalControl
 596         parentalControl.save()
 597 except:
 598         print 'EXCEPTION IN PYTHON STARTUP CODE:'
 599         print '-'*60
 600         print_exc(file=stdout)
 601         quitMainloop(5)
 602         print '-'*60