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