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