fix zapping alternatives bluescreen

[enigma2.git] / lib / python / Plugins / Extensions / ZappingAlternatives / plugin.py

diff --git a/lib/python/Plugins/Extensions/ZappingAlternatives/plugin.py b/lib/python/Plugins/Extensions/ZappingAlternatives/plugin.py
index 424641c97e2ba808c8f3207b98d6b603813ced9c..814f174ae30aa34b3013355a17d535fe9714bc20 100644 (file)
--- a/lib/python/Plugins/Extensions/ZappingAlternatives/plugin.py
+++ b/lib/python/Plugins/Extensions/ZappingAlternatives/plugin.py
@@ -57,8 +57,8 @@ class AlternativeZapping(Screen):
                        <widget name="green" position="140,0" size="140,40" backgroundColor="green" halign="center" valign="center" font="Regular;21" />
                        <widget name="yellow" position="280,0" size="140,40" backgroundColor="yellow" halign="center" valign="center" font="Regular;21" />
                        <widget name="blue" position="420,0" size="140,40" backgroundColor="blue" halign="center" valign="center" font="Regular;21" />
-                       <widget name="serviceslist" position="0,40" size="280,360" />
-                       <widget name="alternativeslist" position="280,40" size="280,360" selectionDisabled="1" />
+                       <widget name="serviceslist" position="0,40" size="280,360" scrollbarMode="showOnDemand" />
+                       <widget name="alternativeslist" position="280,40" size="280,360" selectionDisabled="1" scrollbarMode="showOnDemand" />
                </screen>"""
        def __init__(self, session):
                self.skin = AlternativeZapping.skin
@@ -216,14 +216,15 @@ class AlternativeZapping(Screen):
        def greenKey(self):
                self.session.openWithCallback(self.finishedChannelSelection, SimpleChannelSelection, _("Select reference service"))
 
-       def finishedChannelSelection(self, args):
-               serviceString = str(ServiceReference(args))
-               if not self.alternatives.has_key(serviceString):
-                       self.alternatives[serviceString] = []
-               self.updateServices()
-               self.updateAlternatives()
-               self.selectService(serviceString)
-
+       def finishedChannelSelection(self, *args):
+               if len(args):
+                       serviceString = str(ServiceReference(args[0]))
+                       if not self.alternatives.has_key(serviceString):
+                               self.alternatives[serviceString] = []
+                       self.updateServices()
+                       self.selectService(serviceString)
+                       self.updateAlternatives()
+               
        def yellowKey(self):
                if len(self.serviceslist) > 0:
                        self.session.openWithCallback(self.finishedAlternativeSelection, SimpleChannelSelection, _("Select alternative service"))
@@ -232,28 +233,74 @@ class AlternativeZapping(Screen):
                pass
 
 
-oldPlayService = NavigationInstance.instance.playService
+oldPlayService = None
+
+from Components.PerServiceDisplay import PerServiceDisplay
+
+class ServiceChanged(PerServiceDisplay):
+       def __init__(self, navcore):
+               PerServiceDisplay.__init__(self, navcore,
+                       {
+                               iPlayableService.evTuneFailed: self.tuneFailed,
+                               iPlayableService.evStart: self.start
+                       })
+               
+               self.lastPlayAction = None
+               self.nextPlayTry = 0
 
-def playService(self, ref):
-       if not oldPlayService(ref):
-               if alternatives.has_key(str(ServiceReference(ref))):
-                       for x in alternatives[str(ServiceReference(ref))]:
-                               if oldPlayService(ServiceReference(x).ref):
-                                       return 1
-               return 0
-       return 1
+       def start(self):
+#              print "+++++++++++++++++++++++++++++++++++++++++++++++++Start", self.lastPlayAction
+               if self.lastPlayAction is not None:
+                       self.lastPlayAction = None
 
-def autostart(reason):
+       def tuneFailed(self):
+#              print "+++++++++++++++++++++++++++++++++++++++++++++++++Tuning failed!", self.lastPlayAction
+               ref = self.lastPlayAction
+#              print "Ref:", ref
+#              print "Alternatives: failed to play service"
+               if ref is not None:
+                       if alternatives.has_key(ref):
+#                                      print "Alternatives: trying alternatives"
+                                       if len(alternatives[ref]) > self.nextPlayTry:
+#                                              print "Alternatives: trying alternative", alternatives[ref][self.nextPlayTry]
+                                               if oldPlayService(ServiceReference(alternatives[ref][self.nextPlayTry]).ref) == 0:
+                                                               self.nextPlayTry += 1
+#                                                              print "Alternatives: Alternative found!"
+                                               else:
+                                                               self.nextPlayTry += 1
+#                                                              print "Alternatives: Alternative doesn't play either"
+                                                               self.tuneFailed()
+                                       else:
+                                               self.lastPlayAction = None
+
+                                       #print "Alternatives: No playable alternative found!"
+
+servicechanged = None
+
+def playService(self, ref, **kwargs):
+       #print "--------------------Alternatives: trying to play service", str(ServiceReference(ref))
+       if ref is not None:
+               servicechanged.lastPlayAction = str(ServiceReference(ref))
+       servicechanged.nextPlayTry = 0
+       result = oldPlayService(ref, **kwargs)
+       return result
+
+def sessionstart(reason, session, **kwargs):
        if reason == 0:
                try:
                        loadAlternatives()
-               except:
+               except: # FIXME, THIS IS ILLEGAL CODE AND WILL BE PROSECUTED!
                        pass
-               NavigationInstance.instance.playService = type(NavigationInstance.instance.playService)(playService, NavigationInstance, Navigation)
+               
+               # attach to this sessions navigation instance.
+               global oldPlayService, servicechanged
+               oldPlayService = session.nav.playService
+               session.nav.playService = type(session.nav.playService)(playService, NavigationInstance, Navigation)
+               servicechanged = ServiceChanged(session.nav)
 
-def AlternativeZappingSetup(session):
+def AlternativeZappingSetup(session, **kwargs):
        session.open(AlternativeZapping)
 
-def Plugins():
-       return [PluginDescriptor(where = PluginDescriptor.WHERE_AUTOSTART, fnc = autostart),
+def Plugins(**kwargs):
+       return [PluginDescriptor(where = PluginDescriptor.WHERE_SESSIONSTART, fnc = sessionstart),
                        PluginDescriptor(name="Alternative services setup" , description="Defines alternatives for services.", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=AlternativeZappingSetup)]