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