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