mytest.py

   1 from Tools import RedirectOutput
   2 from enigma import *
   3 from tools import *
   4
   5 from Components.Language import language
   6
   7 def setEPGLanguage():
   8         print "language set to", language.getLanguage()
   9         eServiceEvent.setEPGLanguage(language.getLanguage())
  10
  11 language.addCallback(setEPGLanguage)
  12
  13 import traceback
  14 import Screens.InfoBar
  15 from Screens.SimpleSummary import SimpleSummary
  16
  17 import sys
  18 import time
  19
  20 import ServiceReference
  21
  22 from Navigation import Navigation
  23
  24 from skin import readSkin, applyAllAttributes
  25
  26 from Components.config import configfile
  27 from Tools.Directories import InitFallbackFiles, resolveFilename, SCOPE_PLUGINS
  28 InitFallbackFiles()
  29 eDVBDB.getInstance().reloadBouquets()
  30
  31 try:
  32         import e2reactor
  33         e2reactor.install()
  34
  35         from twisted.internet import reactor
  36
  37         def runReactor():
  38                 reactor.run()
  39 except ImportError:
  40         print "twisted not available"
  41         def runReactor():
  42                 runMainloop()
  43
  44 # initialize autorun plugins and plugin menu entries
  45 from Components.PluginComponent import plugins
  46
  47 from Screens.Wizard import wizardManager
  48 from Screens.ImageWizard import *
  49 from Screens.StartWizard import *
  50 from Screens.TutorialWizard import *
  51 from Tools.BoundFunction import boundFunction
  52 from Plugins.Plugin import PluginDescriptor
  53
  54 had = dict()
  55
  56 def dump(dir, p = ""):
  57         if isinstance(dir, dict):
  58                 for (entry, val) in dir.items():
  59                         dump(val, p + "(dict)/" + entry)
  60         if hasattr(dir, "__dict__"):
  61                 for name, value in dir.__dict__.items():
  62                         if not had.has_key(str(value)):
  63                                 had[str(value)] = 1
  64                                 dump(value, p + "/" + str(name))
  65                         else:
  66                                 print p + "/" + str(name) + ":" + str(dir.__class__) + "(cycle)"
  67         else:
  68                 print p + ":" + str(dir)
  69
  70 # + ":" + str(dir.__class__)
  71
  72 # display
  73
  74 class OutputDevice:
  75         def create(self, screen): pass
  76
  77 # display: HTML
  78
  79 class HTMLOutputDevice(OutputDevice):
  80         def create(self, comp):
  81                 print comp.produceHTML()
  82
  83 html = HTMLOutputDevice()
  84
  85 class GUIOutputDevice(OutputDevice):
  86         parent = None
  87         def create(self, comp, desktop):
  88                 comp.createGUIScreen(self.parent, desktop)
  89
  90 # Session.open:
  91 # * push current active dialog ('current_dialog') onto stack
  92 # * call execEnd for this dialog
  93 #   * clear in_exec flag
  94 #   * hide screen
  95 # * instantiate new dialog into 'current_dialog'
  96 #   * create screens, components
  97 #   * read, apply skin
  98 #   * create GUI for screen
  99 # * call execBegin for new dialog
 100 #   * set in_exec
 101 #   * show gui screen
 102 #   * call components' / screen's onExecBegin
 103 # ... screen is active, until it calls 'close'...
 104 # Session.close:
 105 # * assert in_exec
 106 # * save return value
 107 # * start deferred close handler ('onClose')
 108 # * execEnd
 109 #   * clear in_exec
 110 #   * hide screen
 111 # .. a moment later:
 112 # Session.doClose:
 113 # * destroy screen
 114
 115 class Session:
 116         def __init__(self, desktop = None, summary_desktop = None, navigation = None):
 117                 self.desktop = desktop
 118                 self.summary_desktop = summary_desktop
 119                 self.nav = navigation
 120                 self.delay_timer = eTimer()
 121                 self.delay_timer.timeout.get().append(self.processDelay)
 122
 123                 self.current_dialog = None
 124
 125                 self.dialog_stack = [ ]
 126                 self.summary_stack = [ ]
 127                 self.summary = None
 128
 129                 self.in_exec = False
 130
 131                 for p in plugins.getPlugins(PluginDescriptor.WHERE_SESSIONSTART):
 132                         p(reason=0, session=self)
 133
 134         def processDelay(self):
 135                 callback = self.current_dialog.callback
 136
 137                 retval = self.current_dialog.returnValue
 138
 139                 if self.current_dialog.isTmp:
 140                         self.current_dialog.doClose()
 141 #                       dump(self.current_dialog)
 142                         del self.current_dialog
 143                 else:
 144                         del self.current_dialog.callback
 145
 146                 self.popCurrent()
 147                 if callback is not None:
 148                         callback(*retval)
 149
 150         def execBegin(self):
 151                 assert not self.in_exec
 152                 self.in_exec = True
 153                 c = self.current_dialog
 154
 155                 self.pushSummary()
 156
 157                 summary = c.createSummary() or SimpleSummary
 158                 self.summary = self.instantiateSummaryDialog(summary, c)
 159                 self.summary.show()
 160
 161                 c.addSummary(self.summary)
 162                 c.execBegin()
 163
 164                 # when execBegin opened a new dialog, don't bother showing the old one.
 165                 if c == self.current_dialog:
 166                         c.show()
 167
 168         def execEnd(self):
 169                 assert self.in_exec
 170                 self.in_exec = False
 171
 172                 self.current_dialog.execEnd()
 173                 self.current_dialog.hide()
 174                 self.current_dialog.removeSummary(self.summary)
 175                 self.popSummary()
 176
 177         def create(self, screen, arguments, **kwargs):
 178                 # creates an instance of 'screen' (which is a class)
 179                 try:
 180                         return screen(self, *arguments, **kwargs)
 181                 except:
 182                         errstr = "Screen %s(%s, %s): %s" % (str(screen), str(arguments), str(kwargs), sys.exc_info()[0])
 183                         print errstr
 184                         traceback.print_exc(file=sys.stdout)
 185                         quitMainloop(5)
 186
 187         def instantiateDialog(self, screen, *arguments, **kwargs):
 188                 return self.doInstantiateDialog(screen, arguments, kwargs, self.desktop)
 189
 190         def instantiateSummaryDialog(self, screen, *arguments, **kwargs):
 191                 return self.doInstantiateDialog(screen, arguments, kwargs, self.summary_desktop)
 192
 193         def doInstantiateDialog(self, screen, arguments, kwargs, desktop):
 194                 # create dialog
 195
 196                 try:
 197                         dlg = self.create(screen, arguments, **kwargs)
 198                 except:
 199                         print 'EXCEPTION IN DIALOG INIT CODE, ABORTING:'
 200                         print '-'*60
 201                         traceback.print_exc(file=sys.stdout)
 202                         quitMainloop(5)
 203                         print '-'*60
 204
 205                 if dlg is None:
 206                         return
 207
 208                 # read skin data
 209                 readSkin(dlg, None, dlg.skinName, desktop)
 210
 211                 # create GUI view of this dialog
 212                 assert desktop is not None
 213
 214                 z = 0
 215                 title = ""
 216                 for (key, value) in dlg.skinAttributes:
 217                         if key == "zPosition":
 218                                 z = int(value)
 219                         elif key == "title":
 220                                 title = value
 221
 222                 dlg.instance = eWindow(desktop, z)
 223                 dlg.title = title
 224                 applyAllAttributes(dlg.instance, desktop, dlg.skinAttributes)
 225                 gui = GUIOutputDevice()
 226                 gui.parent = dlg.instance
 227                 gui.create(dlg, desktop)
 228
 229                 return dlg
 230
 231         def pushCurrent(self):
 232                 if self.current_dialog is not None:
 233                         self.dialog_stack.append(self.current_dialog)
 234                         self.execEnd()
 235
 236         def popCurrent(self):
 237                 if len(self.dialog_stack):
 238                         self.current_dialog = self.dialog_stack.pop()
 239                         self.execBegin()
 240                 else:
 241                         self.current_dialog = None
 242
 243         def execDialog(self, dialog):
 244                 self.pushCurrent()
 245                 self.current_dialog = dialog
 246                 self.current_dialog.isTmp = False
 247                 self.current_dialog.callback = None # would cause re-entrancy problems.
 248                 self.execBegin()
 249
 250         def openWithCallback(self, callback, screen, *arguments, **kwargs):
 251                 dlg = self.open(screen, *arguments, **kwargs)
 252                 dlg.callback = callback
 253
 254         def open(self, screen, *arguments, **kwargs):
 255                 if len(self.dialog_stack) and not self.in_exec:
 256                         raise "modal open are allowed only from a screen which is modal!"
 257                         # ...unless it's the very first screen.
 258
 259                 self.pushCurrent()
 260                 dlg = self.current_dialog = self.instantiateDialog(screen, *arguments, **kwargs)
 261                 dlg.isTmp = True
 262                 dlg.callback = None
 263                 self.execBegin()
 264                 return dlg
 265
 266         def keyEvent(self, code):
 267                 print "code " + str(code)
 268
 269         def close(self, screen, *retval):
 270                 if not self.in_exec:
 271                         print "close after exec!"
 272                         return
 273
 274                 # be sure that the close is for the right dialog!
 275                 # if it's not, you probably closed after another dialog
 276                 # was opened. this can happen if you open a dialog
 277                 # onExecBegin, and forget to do this only once.
 278                 # after close of the top dialog, the underlying will
 279                 # gain focus again (for a short time), thus triggering
 280                 # the onExec, which opens the dialog again, closing the loop.
 281                 assert screen == self.current_dialog
 282
 283                 self.current_dialog.returnValue = retval
 284                 self.delay_timer.start(0, 1)
 285                 self.execEnd()
 286
 287         def pushSummary(self):
 288                 if self.summary is not None:
 289                         self.summary.hide()
 290                 self.summary_stack.append(self.summary)
 291                 self.summary = None
 292
 293         def popSummary(self):
 294                 if self.summary is not None:
 295                         self.summary.doClose()
 296                 self.summary = self.summary_stack.pop()
 297                 if self.summary is not None:
 298                         self.summary.show()
 299
 300 from Screens.Volume import Volume
 301 from Screens.Mute import Mute
 302 from GlobalActions import globalActionMap
 303 from Components.config import ConfigSubsection, configSequence, configElement, configsequencearg
 304
 305 #TODO .. move this to a own .py file
 306 class VolumeControl:
 307         """Volume control, handles volUp, volDown, volMute actions and display
 308         a corresponding dialog"""
 309         def __init__(self, session):
 310                 global globalActionMap
 311                 globalActionMap.actions["volumeUp"]=self.volUp
 312                 globalActionMap.actions["volumeDown"]=self.volDown
 313                 globalActionMap.actions["volumeMute"]=self.volMute
 314
 315                 config.audio = ConfigSubsection()
 316                 config.audio.volume = configElement("config.audio.volume", configSequence, [100], configsequencearg.get("INTEGER", (0, 100)))
 317
 318                 self.volumeDialog = session.instantiateDialog(Volume)
 319                 self.muteDialog = session.instantiateDialog(Mute)
 320
 321                 self.hideVolTimer = eTimer()
 322                 self.hideVolTimer.timeout.get().append(self.volHide)
 323
 324                 vol = config.audio.volume.value[0]
 325                 self.volumeDialog.setValue(vol)
 326                 eDVBVolumecontrol.getInstance().setVolume(vol, vol)
 327
 328         def volSave(self):
 329                 config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
 330                 config.audio.volume.save()
 331
 332         def     volUp(self):
 333                 if (eDVBVolumecontrol.getInstance().isMuted()):
 334                         self.volMute()
 335                 eDVBVolumecontrol.getInstance().volumeUp()
 336                 self.volumeDialog.show()
 337                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
 338                 self.volSave()
 339                 self.hideVolTimer.start(3000, True)
 340
 341         def     volDown(self):
 342                 if (eDVBVolumecontrol.getInstance().isMuted()):
 343                         self.volMute()
 344                 eDVBVolumecontrol.getInstance().volumeDown()
 345                 self.volumeDialog.show()
 346                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
 347                 self.volSave()
 348                 self.hideVolTimer.start(3000, True)
 349
 350         def volHide(self):
 351                 self.volumeDialog.hide()
 352
 353         def     volMute(self):
 354                 eDVBVolumecontrol.getInstance().volumeToggleMute()
 355                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
 356
 357                 if (eDVBVolumecontrol.getInstance().isMuted()):
 358                         self.muteDialog.show()
 359                 else:
 360                         self.muteDialog.hide()
 361
 362 from Screens.Standby import Standby
 363
 364 class PowerKey:
 365         """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
 366
 367         def __init__(self, session):
 368                 self.session = session
 369                 self.powerKeyTimer = eTimer()
 370                 self.powerKeyTimer.timeout.get().append(self.powertimer)
 371                 globalActionMap.actions["powerdown"]=self.powerdown
 372                 globalActionMap.actions["powerup"]=self.powerup
 373                 self.standbyblocked = 0
 374 #               self["PowerKeyActions"] = HelpableActionMap(self, "PowerKeyActions",
 375                         #{
 376                                 #"powerdown": self.powerdown,
 377                                 #"powerup": self.powerup,
 378                                 #"discreteStandby": (self.standby, "Go standby"),
 379                                 #"discretePowerOff": (self.quit, "Go to deep standby"),
 380                         #})
 381
 382         def powertimer(self):
 383                 print "PowerOff - Now!"
 384                 self.quit()
 385
 386         def powerdown(self):
 387                 self.standbyblocked = 0
 388                 self.powerKeyTimer.start(3000, True)
 389
 390         def powerup(self):
 391                 self.powerKeyTimer.stop()
 392                 if self.standbyblocked == 0:
 393                         self.standbyblocked = 1
 394                         self.standby()
 395
 396         def standby(self):
 397                 self.session.open(Standby, self)
 398
 399         def quit(self):
 400                 # halt
 401                 quitMainloop(1)
 402
 403 def runScreenTest():
 404         plugins.readPluginList(resolveFilename(SCOPE_PLUGINS))
 405
 406         session = Session(desktop = getDesktop(0), summary_desktop = getDesktop(1), navigation = Navigation())
 407
 408         screensToRun = [ ]
 409
 410         for p in plugins.getPlugins(PluginDescriptor.WHERE_WIZARD):
 411                 screensToRun.append(p.__call__)
 412
 413         screensToRun += wizardManager.getWizards()
 414
 415         screensToRun.append(Screens.InfoBar.InfoBar)
 416
 417         def runNextScreen(session, screensToRun, *result):
 418                 if result:
 419                         quitMainloop(*result)
 420                         return
 421
 422                 screen = screensToRun[0]
 423
 424                 if len(screensToRun):
 425                         session.openWithCallback(boundFunction(runNextScreen, session, screensToRun[1:]), screen)
 426                 else:
 427                         session.open(screen)
 428
 429         runNextScreen(session, screensToRun)
 430
 431         CONNECT(keyPressedSignal(), session.keyEvent)
 432
 433         vol = VolumeControl(session)
 434         power = PowerKey(session)
 435
 436         runReactor()
 437
 438         configfile.save()
 439
 440         from Tools.DreamboxHardware import setFPWakeuptime
 441         from time import time
 442         nextRecordingTime = session.nav.RecordTimer.getNextRecordingTime()
 443         if nextRecordingTime != -1:
 444                 if (nextRecordingTime - time() < 330): # no time to switch box back on
 445                         setFPWakeuptime(time() + 30) # so switch back on in 30 seconds
 446                 else:
 447                         setFPWakeuptime(nextRecordingTime - (300))
 448
 449         session.nav.shutdown()
 450
 451         return 0
 452
 453 import keymapparser
 454 keymapparser.readKeymap()
 455 import skin
 456 skin.loadSkinData(getDesktop(0))
 457
 458 import Components.InputDevice
 459 Components.InputDevice.InitInputDevices()
 460
 461 import Components.AVSwitch
 462 Components.AVSwitch.InitAVSwitch()
 463
 464 import Components.RecordingConfig
 465 Components.RecordingConfig.InitRecordingConfig()
 466
 467 import Components.UsageConfig
 468 Components.UsageConfig.InitUsageConfig()
 469
 470 import Components.Network
 471 Components.Network.InitNetwork()
 472
 473 import Components.Lcd
 474 Components.Lcd.InitLcd()
 475
 476 import Components.SetupDevices
 477 Components.SetupDevices.InitSetupDevices()
 478
 479 import Components.RFmod
 480 Components.RFmod.InitRFmod()
 481
 482 import Components.NimManager
 483
 484 # first, setup a screen
 485 try:
 486         runScreenTest()
 487
 488         plugins.shutdown()
 489 except:
 490         print 'EXCEPTION IN PYTHON STARTUP CODE:'
 491         print '-'*60
 492         traceback.print_exc(file=sys.stdout)
 493         quitMainloop(5)
 494         print '-'*60