only sample each 40MB at max, use fallback bitrate if no other bitrate available
[enigma2.git] / mytest.py
1 from Tools import RedirectOutput
2 from enigma import *
3 from tools import *
4
5 from Components.Language import language
6
7 import traceback
8 import Screens.InfoBar
9 from Screens.SimpleSummary import SimpleSummary
10
11 import sys
12 import time
13
14 import ServiceReference
15
16 from Navigation import Navigation
17
18 from skin import readSkin, applyAllAttributes
19
20 from Components.config import configfile
21 from Tools.Directories import InitFallbackFiles, resolveFilename, SCOPE_PLUGINS
22 InitFallbackFiles()
23 eDVBDB.getInstance().reloadBouquets()
24
25 try:
26         import e2reactor
27         e2reactor.install()
28         
29         from twisted.internet import reactor
30         
31         def runReactor():
32                 reactor.run()
33 except ImportError:
34         print "twisted not available"
35         def runReactor():
36                 runMainloop()
37
38 # initialize autorun plugins and plugin menu entries
39 from Components.PluginComponent import plugins
40
41 from Screens.Wizard import wizardManager
42 from Screens.ImageWizard import *
43 from Screens.StartWizard import *
44 from Screens.TutorialWizard import *
45 from Tools.BoundFunction import boundFunction
46 from Plugins.Plugin import PluginDescriptor
47
48 had = dict()
49
50 def dump(dir, p = ""):
51         if isinstance(dir, dict):
52                 for (entry, val) in dir.items():
53                         dump(val, p + "(dict)/" + entry)
54         if hasattr(dir, "__dict__"):
55                 for name, value in dir.__dict__.items():
56                         if not had.has_key(str(value)):
57                                 had[str(value)] = 1
58                                 dump(value, p + "/" + str(name))
59                         else:
60                                 print p + "/" + str(name) + ":" + str(dir.__class__) + "(cycle)"
61         else:
62                 print p + ":" + str(dir)
63
64 # + ":" + str(dir.__class__)
65
66 # display
67
68 class OutputDevice:
69         def create(self, screen): pass
70
71 # display: HTML
72
73 class HTMLOutputDevice(OutputDevice):
74         def create(self, comp):
75                 print comp.produceHTML()
76
77 html = HTMLOutputDevice()
78
79 class GUIOutputDevice(OutputDevice):
80         parent = None
81         def create(self, comp, desktop):
82                 comp.createGUIScreen(self.parent, desktop)
83
84 class Session:
85         def __init__(self, desktop = None, summary_desktop = None, navigation = None):
86                 self.desktop = desktop
87                 self.summary_desktop = summary_desktop
88                 self.nav = navigation
89                 self.delay_timer = eTimer()
90                 self.delay_timer.timeout.get().append(self.processDelay)
91                 
92                 self.current_dialog = None
93                 
94                 self.dialog_stack = [ ]
95                 self.summary_stack = [ ]
96                 self.summary = None
97         
98         def processDelay(self):
99                 self.execEnd()
100                 
101                 callback = self.current_dialog.callback
102
103                 retval = self.current_dialog.returnValue
104
105                 if self.current_dialog.isTmp:
106                         self.current_dialog.doClose()
107 #                       dump(self.current_dialog)
108                         del self.current_dialog
109                 else:
110                         del self.current_dialog.callback
111                 
112                 self.popCurrent()
113                 if callback is not None:
114                         callback(*retval)
115
116         def execBegin(self):
117                 c = self.current_dialog
118                 
119                 self.pushSummary()
120
121                 summary = c.createSummary() or SimpleSummary
122                 self.summary = self.instantiateSummaryDialog(summary, c)
123                 self.summary.show()
124
125                 c.addSummary(self.summary)
126                 c.execBegin()
127
128                 # when execBegin opened a new dialog, don't bother showing the old one.
129                 if c == self.current_dialog:
130                         c.show()
131                 
132         def execEnd(self):
133                 self.current_dialog.execEnd()
134                 self.current_dialog.hide()
135                 self.current_dialog.removeSummary(self.summary)
136                 self.popSummary()
137         
138         def create(self, screen, arguments, **kwargs):
139                 # creates an instance of 'screen' (which is a class)
140                 try:
141                         return screen(self, *arguments, **kwargs)
142                 except:
143                         errstr = "Screen %s(%s, %s): %s" % (str(screen), str(arguments), str(kwargs), sys.exc_info()[0])
144                         print errstr
145                         traceback.print_exc(file=sys.stdout)
146                         quitMainloop(5)
147         
148         def instantiateDialog(self, screen, *arguments, **kwargs):
149                 return self.doInstantiateDialog(screen, arguments, kwargs, self.desktop)
150         
151         def instantiateSummaryDialog(self, screen, *arguments, **kwargs):
152                 return self.doInstantiateDialog(screen, arguments, kwargs, self.summary_desktop)
153         
154         def doInstantiateDialog(self, screen, arguments, kwargs, desktop):
155                 # create dialog
156                 
157                 try:
158                         dlg = self.create(screen, arguments, **kwargs)
159                 except:
160                         print 'EXCEPTION IN DIALOG INIT CODE, ABORTING:'
161                         print '-'*60
162                         traceback.print_exc(file=sys.stdout)
163                         quitMainloop(5)
164                         print '-'*60
165                 
166                 if dlg is None:
167                         return
168
169                 # read skin data
170                 readSkin(dlg, None, dlg.skinName, desktop)
171
172                 # create GUI view of this dialog
173                 assert desktop is not None
174                 
175                 z = 0
176                 title = ""
177                 for (key, value) in dlg.skinAttributes:
178                         if key == "zPosition":
179                                 z = int(value)
180                         elif key == "title":
181                                 title = value
182                 
183                 dlg.instance = eWindow(desktop, z)
184                 dlg.title = title
185                 applyAllAttributes(dlg.instance, desktop, dlg.skinAttributes)
186                 gui = GUIOutputDevice()
187                 gui.parent = dlg.instance
188                 gui.create(dlg, desktop)
189                 
190                 return dlg
191          
192         def pushCurrent(self):
193                 if self.current_dialog:
194                         self.dialog_stack.append(self.current_dialog)
195                         self.execEnd()
196         
197         def popCurrent(self):
198                 if len(self.dialog_stack):
199                         self.current_dialog = self.dialog_stack.pop()
200                         self.execBegin()
201                 else:
202                         self.current_dialog = None
203
204         def execDialog(self, dialog):
205                 self.pushCurrent()
206                 self.current_dialog = dialog
207                 self.current_dialog.isTmp = False
208                 self.current_dialog.callback = None # would cause re-entrancy problems.
209                 self.execBegin()
210
211         def openWithCallback(self, callback, screen, *arguments, **kwargs):
212                 dlg = self.open(screen, *arguments, **kwargs)
213                 dlg.callback = callback
214
215         def open(self, screen, *arguments, **kwargs):
216                 self.pushCurrent()
217                 dlg = self.current_dialog = self.instantiateDialog(screen, *arguments, **kwargs)
218                 dlg.isTmp = True
219                 dlg.callback = None
220                 self.execBegin()
221                 return dlg
222
223         def keyEvent(self, code):
224                 print "code " + str(code)
225
226         def close(self, *retval):
227                 self.current_dialog.returnValue = retval
228                 self.delay_timer.start(0, 1)
229
230         def pushSummary(self):
231                 if self.summary is not None:
232                         self.summary.hide()
233                 self.summary_stack.append(self.summary)
234                 self.summary = None
235
236         def popSummary(self):
237                 if self.summary is not None:
238                         self.summary.doClose()
239                 self.summary = self.summary_stack.pop()
240                 if self.summary is not None:
241                         self.summary.show()
242
243 from Screens.Volume import Volume
244 from Screens.Mute import Mute
245 from GlobalActions import globalActionMap
246 from Components.config import ConfigSubsection, configSequence, configElement, configsequencearg
247
248 #TODO .. move this to a own .py file
249 class VolumeControl:
250         """Volume control, handles volUp, volDown, volMute actions and display
251         a corresponding dialog"""
252         def __init__(self, session):
253                 global globalActionMap
254                 globalActionMap.actions["volumeUp"]=self.volUp
255                 globalActionMap.actions["volumeDown"]=self.volDown
256                 globalActionMap.actions["volumeMute"]=self.volMute
257
258                 config.audio = ConfigSubsection()
259                 config.audio.volume = configElement("config.audio.volume", configSequence, [100], configsequencearg.get("INTEGER", (0, 100)))
260
261                 self.volumeDialog = session.instantiateDialog(Volume)
262                 self.muteDialog = session.instantiateDialog(Mute)
263
264                 self.hideVolTimer = eTimer()
265                 self.hideVolTimer.timeout.get().append(self.volHide)
266
267                 vol = config.audio.volume.value[0]
268                 self.volumeDialog.setValue(vol)
269                 eDVBVolumecontrol.getInstance().setVolume(vol, vol)
270
271         def volSave(self):
272                 config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
273                 config.audio.volume.save()
274
275         def     volUp(self):
276                 if (eDVBVolumecontrol.getInstance().isMuted()):
277                         self.volMute()
278                 eDVBVolumecontrol.getInstance().volumeUp()
279                 self.volumeDialog.show()
280                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
281                 self.volSave()
282                 self.hideVolTimer.start(3000, True)
283
284         def     volDown(self):
285                 if (eDVBVolumecontrol.getInstance().isMuted()):
286                         self.volMute()
287                 eDVBVolumecontrol.getInstance().volumeDown()
288                 self.volumeDialog.show()
289                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
290                 self.volSave()
291                 self.hideVolTimer.start(3000, True)
292
293         def volHide(self):
294                 self.volumeDialog.hide()
295
296         def     volMute(self):
297                 eDVBVolumecontrol.getInstance().volumeToggleMute()
298                 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
299
300                 if (eDVBVolumecontrol.getInstance().isMuted()):
301                         self.muteDialog.show()
302                 else:
303                         self.muteDialog.hide()
304
305 def runScreenTest():
306         session = Session(desktop = getDesktop(0), summary_desktop = getDesktop(1), navigation = Navigation())
307
308         plugins.readPluginList(resolveFilename(SCOPE_PLUGINS))
309         
310         screensToRun = [ ]
311         
312         for p in plugins.getPlugins(PluginDescriptor.WHERE_WIZARD):
313                 screensToRun.append(p.__call__)
314         
315         screensToRun += wizardManager.getWizards()
316         
317         screensToRun.append(Screens.InfoBar.InfoBar)
318
319         def runNextScreen(session, screensToRun, *result):
320                 if result:
321                         quitMainloop(*result)
322                         return
323         
324                 screen = screensToRun[0]
325                 
326                 if len(screensToRun):
327                         session.openWithCallback(boundFunction(runNextScreen, session, screensToRun[1:]), screen)
328                 else:
329                         session.open(screen)
330         
331         runNextScreen(session, screensToRun)
332         
333         CONNECT(keyPressedSignal(), session.keyEvent)
334         
335         vol = VolumeControl(session)
336         
337         runReactor()
338         
339         configfile.save()
340         
341         from Tools.DreamboxHardware import setFPWakeuptime
342         from time import time
343         nextRecordingTime = session.nav.RecordTimer.getNextRecordingTime()
344         if nextRecordingTime != -1:
345                 if (nextRecordingTime - time() < 330): # no time to switch box back on
346                         setFPWakeuptime(time() + 30) # so switch back on in 30 seconds
347                 else:
348                         setFPWakeuptime(nextRecordingTime - (300))
349         
350         session.nav.shutdown()
351         
352         return 0
353
354 import keymapparser
355 keymapparser.readKeymap()
356 import skin
357 skin.loadSkin(getDesktop(0))
358
359 import Components.InputDevice
360 Components.InputDevice.InitInputDevices()
361
362 import Components.AVSwitch
363 Components.AVSwitch.InitAVSwitch()
364
365 import Components.RecordingConfig
366 Components.RecordingConfig.InitRecordingConfig()
367
368 import Components.UsageConfig
369 Components.UsageConfig.InitUsageConfig()
370
371 import Components.Network
372 Components.Network.InitNetwork()
373
374 import Components.Lcd
375 Components.Lcd.InitLcd()
376
377 import Components.SetupDevices
378 Components.SetupDevices.InitSetupDevices()
379
380 import Components.RFmod
381 Components.RFmod.InitRFmod()
382
383 import Components.NimManager
384
385 # first, setup a screen
386 try:
387         runScreenTest()
388
389         plugins.shutdown()
390 except:
391         print 'EXCEPTION IN PYTHON STARTUP CODE:'
392         print '-'*60
393         traceback.print_exc(file=sys.stdout)
394         quitMainloop(5)
395         print '-'*60