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 class Session:
  91         def __init__(self, desktop = None, summary_desktop = None, navigation = None):
  92                 self.desktop = desktop
  93                 self.summary_desktop = summary_desktop
  94                 self.nav = navigation
  95                 self.delay_timer = eTimer()
  96                 self.delay_timer.timeout.get().append(self.processDelay)
  97
  98                 self.current_dialog = None
  99
 100                 self.dialog_stack = [ ]
 101                 self.summary_stack = [ ]
 102                 self.summary = None
 103
 104                 self.in_exec = False
 105
 106                 for p in plugins.getPlugins(PluginDescriptor.WHERE_SESSIONSTART):
 107                         p(reason=0, session=self)
 108
 109         def processDelay(self):
 110                 callback = self.current_dialog.callback
 111
 112                 retval = self.current_dialog.returnValue
 113
 114                 if self.current_dialog.isTmp:
 115                         self.current_dialog.doClose()
 116 #                       dump(self.current_dialog)
 117                         del self.current_dialog
 118                 else:
 119                         del self.current_dialog.callback
 120
 121                 self.popCurrent()
 122                 if callback is not None:
 123                         callback(*retval)
 124
 125         def execBegin(self):
 126                 assert not self.in_exec
 127                 self.in_exec = True
 128                 c = self.current_dialog
 129
 130                 self.pushSummary()
 131
 132                 summary = c.createSummary() or SimpleSummary
 133                 self.summary = self.instantiateSummaryDialog(summary, c)
 134                 self.summary.show()
 135
 136                 c.addSummary(self.summary)
 137                 c.execBegin()
 138
 139                 # when execBegin opened a new dialog, don't bother showing the old one.
 140                 if c == self.current_dialog:
 141                         c.show()
 142
 143         def execEnd(self):
 144                 assert self.in_exec
 145                 self.in_exec = False
 146
 147                 self.current_dialog.execEnd()
 148                 self.current_dialog.hide()
 149                 self.current_dialog.removeSummary(self.summary)
 150                 self.popSummary()
 151
 152         def create(self, screen, arguments, **kwargs):
 153                 # creates an instance of 'screen' (which is a class)
 154                 try:
 155                         return screen(self, *arguments, **kwargs)
 156                 except:
 157                         errstr = "Screen %s(%s, %s): %s" % (str(screen), str(arguments), str(kwargs), sys.exc_info()[0])
 158                         print errstr
 159                         traceback.print_exc(file=sys.stdout)
 160                         quitMainloop(5)
 161
 162         def instantiateDialog(self, screen, *arguments, **kwargs):
 163                 return self.doInstantiateDialog(screen, arguments, kwargs, self.desktop)
 164
 165         def instantiateSummaryDialog(self, screen, *arguments, **kwargs):
 166                 return self.doInstantiateDialog(screen, arguments, kwargs, self.summary_desktop)
 167
 168         def doInstantiateDialog(self, screen, arguments, kwargs, desktop):
 169                 # create dialog
 170
 171                 try:
 172                         dlg = self.create(screen, arguments, **kwargs)
 173                 except:
 174                         print 'EXCEPTION IN DIALOG INIT CODE, ABORTING:'
 175                         print '-'*60
 176                         traceback.print_exc(file=sys.stdout)
 177                         quitMainloop(5)
 178                         print '-'*60
 179
 180                 if dlg is None:
 181                         return
 182
 183                 # read skin data
 184                 readSkin(dlg, None, dlg.skinName, desktop)
 185
 186                 # create GUI view of this dialog
 187                 assert desktop is not None
 188
 189                 z = 0
 190                 title = ""
 191                 for (key, value) in dlg.skinAttributes:
 192                         if key == "zPosition":
 193                                 z = int(value)
 194                         elif key == "title":
 195                                 title = value
 196
 197                 dlg.instance = eWindow(desktop, z)
 198                 dlg.title = title
 199                 applyAllAttributes(dlg.instance, desktop, dlg.skinAttributes)
 200                 gui = GUIOutputDevice()
 201                 gui.parent = dlg.instance
 202                 gui.create(dlg, desktop)
 203
 204                 return dlg
 205
 206         def pushCurrent(self):
 207                 if self.current_dialog:
 208                         self.dialog_stack.append(self.current_dialog)
 209                         self.execEnd()
 210
 211         def popCurrent(self):
 212                 if len(self.dialog_stack):
 213                         self.current_dialog = self.dialog_stack.pop()
 214                         self.execBegin()
 215                 else:
 216                         self.current_dialog = None
 217
 218         def execDialog(self, dialog):
 219                 self.pushCurrent()
 220                 self.current_dialog = dialog
 221                 self.current_dialog.isTmp = False
 222                 self.current_dialog.callback = None # would cause re-entrancy problems.
 223                 self.execBegin()
 224
 225         def openWithCallback(self, callback, screen, *arguments, **kwargs):
 226                 dlg = self.open(screen, *arguments, **kwargs)
 227                 dlg.callback = callback
 228
 229         def open(self, screen, *arguments, **kwargs):
 230                 self.pushCurrent()
 231                 dlg = self.current_dialog = self.instantiateDialog(screen, *arguments, **kwargs)
 232                 dlg.isTmp = True
 233                 dlg.callback = None
 234                 self.execBegin()
 235                 return dlg
 236
 237         def keyEvent(self, code):
 238                 print "code " + str(code)
 239
 240         def close(self, *retval):
 241                 if not self.in_exec:
 242                         print "close after exec!"
 243                         return
 244
 245                 self.current_dialog.returnValue = retval
 246                 self.delay_timer.start(0, 1)
 247                 self.execEnd()
 248
 249         def pushSummary(self):
 250                 if self.summary is not None:
 251                         self.summary.hide()
 252                 self.summary_stack.append(self.summary)
 253                 self.summary = None
 254
 255         def popSummary(self):
 256                 if self.summary is not None:
 257                         self.summary.doClose()
 258                 self.summary = self.summary_stack.pop()
 259                 if self.summary is not None:
 260                         self.summary.show()
 261
 262 from Screens.Volume import Volume
 263 from Screens.Mute import Mute
 264 from GlobalActions import globalActionMap
 265 from Components.config import ConfigSubsection, configSequence, configElement, configsequencearg
 266
 267 #TODO .. move this to a own .py file
 268 class VolumeControl:
 269         """Volume control, handles volUp, volDown, volMute actions and display
 270         a corresponding dialog"""
 271         def __init__(self, session):
 272                 global globalActionMap
 273                 globalActionMap.actions["volumeUp"]=self.volUp
 274                 globalActionMap.actions["volumeDown"]=self.volDown
 275                 globalActionMap.actions["volumeMute"]=self.volMute
 276
 277                 config.audio = ConfigSubsection()
 278                 config.audio.volume = configElement("config.audio.volume", configSequence, [100], configsequencearg.get("INTEGER", (0, 100)))
 279
 280                 self.volumeDialog = session.instantiateDialog(Volume)
 281                 self.muteDialog = session.instantiateDialog(Mute)
 282
 283                 self.hideVolTimer = eTimer()
 284                 self.hideVolTimer.timeout.get().append(self.volHide)
 285
 286                 vol = config.audio.volume.value[0]
 287                 self.volumeDialog.setValue(vol)
 288                 eDVBVolumecontrol.getInstance().setVolume(vol, vol)
 289
 290         def volSave(self):
 291                 config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
 292                 config.audio.volume.save()
 293
 294         def     volUp(self):
 295                 if (eDVBVolumecontrol.getInstance().isMuted()):
 296                         self.volMute()
 297                 eDVBVolumecontrol.getInstance().volumeUp()
 298                 self.volumeDialog.show()
 299                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
 300                 self.volSave()
 301                 self.hideVolTimer.start(3000, True)
 302
 303         def     volDown(self):
 304                 if (eDVBVolumecontrol.getInstance().isMuted()):
 305                         self.volMute()
 306                 eDVBVolumecontrol.getInstance().volumeDown()
 307                 self.volumeDialog.show()
 308                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
 309                 self.volSave()
 310                 self.hideVolTimer.start(3000, True)
 311
 312         def volHide(self):
 313                 self.volumeDialog.hide()
 314
 315         def     volMute(self):
 316                 eDVBVolumecontrol.getInstance().volumeToggleMute()
 317                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
 318
 319                 if (eDVBVolumecontrol.getInstance().isMuted()):
 320                         self.muteDialog.show()
 321                 else:
 322                         self.muteDialog.hide()
 323
 324 from Screens.Standby import Standby
 325
 326 class PowerKey:
 327         """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
 328
 329         def __init__(self, session):
 330                 self.session = session
 331                 self.powerKeyTimer = eTimer()
 332                 self.powerKeyTimer.timeout.get().append(self.powertimer)
 333                 globalActionMap.actions["powerdown"]=self.powerdown
 334                 globalActionMap.actions["powerup"]=self.powerup
 335                 self.standbyblocked = 0
 336 #               self["PowerKeyActions"] = HelpableActionMap(self, "PowerKeyActions",
 337                         #{
 338                                 #"powerdown": self.powerdown,
 339                                 #"powerup": self.powerup,
 340                                 #"discreteStandby": (self.standby, "Go standby"),
 341                                 #"discretePowerOff": (self.quit, "Go to deep standby"),
 342                         #})
 343
 344         def powertimer(self):
 345                 print "PowerOff - Now!"
 346                 self.quit()
 347
 348         def powerdown(self):
 349                 self.standbyblocked = 0
 350                 self.powerKeyTimer.start(3000, True)
 351
 352         def powerup(self):
 353                 self.powerKeyTimer.stop()
 354                 if self.standbyblocked == 0:
 355                         self.standbyblocked = 1
 356                         self.standby()
 357
 358         def standby(self):
 359                 self.session.open(Standby, self)
 360
 361         def quit(self):
 362                 # halt
 363                 quitMainloop(1)
 364
 365 def runScreenTest():
 366         plugins.readPluginList(resolveFilename(SCOPE_PLUGINS))
 367
 368         session = Session(desktop = getDesktop(0), summary_desktop = getDesktop(1), navigation = Navigation())
 369
 370         screensToRun = [ ]
 371
 372         for p in plugins.getPlugins(PluginDescriptor.WHERE_WIZARD):
 373                 screensToRun.append(p.__call__)
 374
 375         screensToRun += wizardManager.getWizards()
 376
 377         screensToRun.append(Screens.InfoBar.InfoBar)
 378
 379         def runNextScreen(session, screensToRun, *result):
 380                 if result:
 381                         quitMainloop(*result)
 382                         return
 383
 384                 screen = screensToRun[0]
 385
 386                 if len(screensToRun):
 387                         session.openWithCallback(boundFunction(runNextScreen, session, screensToRun[1:]), screen)
 388                 else:
 389                         session.open(screen)
 390
 391         runNextScreen(session, screensToRun)
 392
 393         CONNECT(keyPressedSignal(), session.keyEvent)
 394
 395         vol = VolumeControl(session)
 396         power = PowerKey(session)
 397
 398         runReactor()
 399
 400         configfile.save()
 401
 402         from Tools.DreamboxHardware import setFPWakeuptime
 403         from time import time
 404         nextRecordingTime = session.nav.RecordTimer.getNextRecordingTime()
 405         if nextRecordingTime != -1:
 406                 if (nextRecordingTime - time() < 330): # no time to switch box back on
 407                         setFPWakeuptime(time() + 30) # so switch back on in 30 seconds
 408                 else:
 409                         setFPWakeuptime(nextRecordingTime - (300))
 410
 411         session.nav.shutdown()
 412
 413         return 0
 414
 415 import keymapparser
 416 keymapparser.readKeymap()
 417 import skin
 418 skin.loadSkinData(getDesktop(0))
 419
 420 import Components.InputDevice
 421 Components.InputDevice.InitInputDevices()
 422
 423 import Components.AVSwitch
 424 Components.AVSwitch.InitAVSwitch()
 425
 426 import Components.RecordingConfig
 427 Components.RecordingConfig.InitRecordingConfig()
 428
 429 import Components.UsageConfig
 430 Components.UsageConfig.InitUsageConfig()
 431
 432 import Components.Network
 433 Components.Network.InitNetwork()
 434
 435 import Components.Lcd
 436 Components.Lcd.InitLcd()
 437
 438 import Components.SetupDevices
 439 Components.SetupDevices.InitSetupDevices()
 440
 441 import Components.RFmod
 442 Components.RFmod.InitRFmod()
 443
 444 import Components.NimManager
 445
 446 # first, setup a screen
 447 try:
 448         runScreenTest()
 449
 450         plugins.shutdown()
 451 except:
 452         print 'EXCEPTION IN PYTHON STARTUP CODE:'
 453         print '-'*60
 454         traceback.print_exc(file=sys.stdout)
 455         quitMainloop(5)
 456         print '-'*60