lib/python/Plugins/SystemPlugins/Satfinder/plugin.py

   1 from enigma import eDVBResourceManager,\
   2         eDVBFrontendParametersSatellite, eDVBFrontendParameters
   3
   4 from Screens.Screen import Screen
   5 from Screens.ScanSetup import ScanSetup
   6 from Screens.MessageBox import MessageBox
   7 from Plugins.Plugin import PluginDescriptor
   8
   9 from Components.Label import Label
  10 from Components.Sources.FrontendStatus import FrontendStatus
  11 from Components.ActionMap import ActionMap
  12 from Components.NimManager import nimmanager, getConfigSatlist
  13 from Components.MenuList import MenuList
  14 from Components.config import ConfigSelection, getConfigListEntry
  15 from Components.TuneTest import Tuner
  16
  17
  18 class Satfinder(ScanSetup):
  19         def openFrontend(self):
  20                 res_mgr = eDVBResourceManager.getInstance()
  21                 if res_mgr:
  22                         self.raw_channel = res_mgr.allocateRawChannel(self.feid)
  23                         if self.raw_channel:
  24                                 self.frontend = self.raw_channel.getFrontend()
  25                                 if self.frontend:
  26                                         return True
  27                                 else:
  28                                         print "getFrontend failed"
  29                         else:
  30                                 print "getRawChannel failed"
  31                 else:
  32                         print "getResourceManager instance failed"
  33                 return False
  34
  35         def __init__(self, session, feid):
  36                 self.initcomplete = False
  37                 self.feid = feid
  38                 self.oldref = None
  39
  40                 if not self.openFrontend():
  41                         self.oldref = session.nav.getCurrentlyPlayingServiceReference()
  42                         session.nav.stopService() # try to disable foreground service
  43                         if not self.openFrontend():
  44                                 if session.pipshown: # try to disable pip
  45                                         session.pipshown = False
  46                                         del session.pip
  47                                         if not self.openFrontend():
  48                                                 self.frontend = None # in normal case this should not happen
  49
  50                 ScanSetup.__init__(self, session)
  51                 self.tuner = Tuner(self.frontend)
  52                 self["introduction"].setText("")
  53                 self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
  54                 self.initcomplete = True
  55                 self.onClose.append(self.__onClose)
  56
  57         def __onClose(self):
  58                 self.session.nav.playService(self.oldref)
  59
  60         def createSetup(self):
  61                 self.typeOfTuningEntry = None
  62                 self.satEntry = None
  63
  64                 self.list = []
  65
  66                 self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
  67                 self.list.append(self.typeOfTuningEntry)
  68                 self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
  69                 self.list.append(self.satEntry)
  70
  71                 nim = nimmanager.nim_slots[self.feid]
  72
  73                 self.systemEntry = None
  74                 if self.tuning_type.value == "manual_transponder":
  75                         if nim.isCompatible("DVB-S2"):
  76                                 self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
  77                                 self.list.append(self.systemEntry)
  78                         else:
  79                                 # downgrade to dvb-s, in case a -s2 config was active
  80                                 self.scan_sat.system.value = "dvb-s"
  81                         self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
  82                         self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
  83                         self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
  84                         self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
  85                         if self.scan_sat.system.value == "dvb-s":
  86                                 self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
  87                         elif self.scan_sat.system.value == "dvb-s2":
  88                                 self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
  89                                 self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
  90                                 self.list.append(self.modulationEntry)
  91                                 self.list.append(getConfigListEntry(_('Rolloff'), self.scan_sat.rolloff))
  92                                 self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
  93                 elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder":
  94                         self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder))
  95                 self["config"].list = self.list
  96                 self["config"].l.setList(self.list)
  97
  98         def newConfig(self):
  99                 cur = self["config"].getCurrent()
 100                 if cur in (self.typeOfTuningEntry, self.systemEntry):
 101                         self.createSetup()
 102                 elif cur == self.satEntry:
 103                         self.updateSats()
 104                         self.createSetup()
 105
 106         def sat_changed(self, config_element):
 107                 self.newConfig()
 108                 self.retune(config_element)
 109
 110         def retune(self, configElement):
 111                 returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 112                 satpos = int(self.tuning_sat.value)
 113                 if self.tuning_type.value == "manual_transponder":
 114                         if self.scan_sat.system.value == "dvb-s2":
 115                                 fec = self.scan_sat.fec_s2.value
 116                         else:
 117                                 fec = self.scan_sat.fec.value
 118                         returnvalue = (
 119                                 self.scan_sat.frequency.value,
 120                                 self.scan_sat.symbolrate.value,
 121                                 self.scan_sat.polarization.index,
 122                                 { "auto": 0,
 123                                    "1_2": 1,
 124                                    "2_3": 2,
 125                                    "3_4": 3,
 126                                    "5_6": 4,
 127                                    "7_8": 5,
 128                                    "8_9": 6,
 129                                    "3_5": 7,
 130                                    "4_5": 8,
 131                                    "9_10": 9,
 132                                    "none": 15 }[fec],
 133                                 self.scan_sat.inversion.index,
 134                                 satpos,
 135                                 self.scan_sat.system.index,
 136                                 self.scan_sat.modulation.index == 1 and 2 or 1,
 137                                 self.scan_sat.rolloff.index,
 138                                 self.scan_sat.pilot.index)
 139                         self.tune(returnvalue)
 140                 elif self.tuning_type.value == "predefined_transponder":
 141                         tps = nimmanager.getTransponders(satpos)
 142                         l = len(tps)
 143                         if l > self.tuning_transponder.index:
 144                                 transponder = tps[self.tuning_transponder.index]
 145                                 returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
 146                                         transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9])
 147                                 self.tune(returnvalue)
 148
 149         def createConfig(self, foo):
 150                 self.tuning_transponder = None
 151                 self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("Manual transponder")), ("predefined_transponder", _("Predefined transponder"))])
 152                 self.tuning_sat = getConfigSatlist(192, nimmanager.getSatListForNim(self.feid))
 153                 ScanSetup.createConfig(self, None)
 154
 155                 self.updateSats()
 156
 157                 for x in (self.tuning_type, self.tuning_sat, self.scan_sat.frequency,
 158                         self.scan_sat.inversion, self.scan_sat.symbolrate,
 159                         self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
 160                         self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,
 161                         self.scan_sat.rolloff, self.scan_sat.system):
 162                         x.addNotifier(self.retune, initial_call = False)
 163
 164         def updateSats(self):
 165                 orb_pos = self.tuning_sat.orbital_position
 166                 if orb_pos is not None:
 167                         transponderlist = nimmanager.getTransponders(orb_pos)
 168                         list = []
 169                         default = None
 170                         for x in transponderlist:
 171                                 if x[3] == 0:
 172                                         pol = "H"
 173                                 elif x[3] == 1:
 174                                         pol = "V"
 175                                 elif x[3] == 2:
 176                                         pol = "CL"
 177                                 elif x[3] == 3:
 178                                         pol = "CR"
 179                                 else:
 180                                         pol = "??"
 181                                 if x[4] == 0:
 182                                         fec = "FEC_AUTO"
 183                                 elif x[4] == 1:
 184                                         fec = "FEC_1_2"
 185                                 elif x[4] == 2:
 186                                         fec = "FEC_2_3"
 187                                 elif x[4] == 3:
 188                                         fec = "FEC_3_4"
 189                                 elif x[4] == 4:
 190                                         fec = "FEC_5_6"
 191                                 elif x[4] == 5:
 192                                         fec = "FEC_7_8"
 193                                 elif x[4] == 6:
 194                                         fec = "FEC_8_9"
 195                                 elif x[4] == 7:
 196                                         fec = "FEC_3_5"
 197                                 elif x[4] == 8:
 198                                         fec = "FEC_4_5"
 199                                 elif x[4] == 9:
 200                                         fec = "FEC_9_10"
 201                                 elif x[4] == 15:
 202                                         fec = "FEC_None"
 203                                 else:
 204                                         fec = "FEC_Unknown"
 205                                 e = str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec
 206                                 if default is None:
 207                                         default = e
 208                                 list.append(e)
 209                         self.tuning_transponder = ConfigSelection(choices = list, default = default)
 210                         self.tuning_transponder.addNotifier(self.retune, initial_call = False)
 211
 212         def keyGo(self):
 213                 self.retune(self.tuning_type)
 214
 215         def restartPrevService(self, yesno):
 216                 if yesno:
 217                         if self.frontend:
 218                                 self.frontend = None
 219                                 del self.raw_channel
 220                 else:
 221                         self.oldref = None
 222                 self.close(None)
 223
 224         def keyCancel(self):
 225                 if self.oldref:
 226                         self.session.openWithCallback(self.restartPrevService, MessageBox, _("Zap back to service before satfinder?"), MessageBox.TYPE_YESNO)
 227                 else:
 228                         self.restartPrevService(False)
 229
 230         def tune(self, transponder):
 231                 if self.initcomplete:
 232                         if transponder is not None:
 233                                 self.tuner.tune(transponder)
 234
 235 class SatNimSelection(Screen):
 236         skin = """
 237                 <screen position="140,165" size="400,130" title="select Slot">
 238                         <widget name="nimlist" position="20,10" size="360,100" />
 239                 </screen>"""
 240
 241         def __init__(self, session):
 242                 Screen.__init__(self, session)
 243
 244                 nimlist = nimmanager.getNimListOfType("DVB-S")
 245                 nimMenuList = []
 246                 for x in nimlist:
 247                         nimMenuList.append((nimmanager.nim_slots[x].friendly_full_description, x))
 248
 249                 self["nimlist"] = MenuList(nimMenuList)
 250
 251                 self["actions"] = ActionMap(["OkCancelActions"],
 252                 {
 253                         "ok": self.okbuttonClick ,
 254                         "cancel": self.close
 255                 }, -1)
 256
 257         def okbuttonClick(self):
 258                 selection = self["nimlist"].getCurrent()[1]
 259                 self.session.open(Satfinder, selection)
 260
 261 def SatfinderMain(session, **kwargs):
 262         nims = nimmanager.getNimListOfType("DVB-S")
 263
 264         nimList = []
 265         for x in nims:
 266                 if not nimmanager.getNimConfig(x).configMode.value in ("loopthrough", "satposdepends", "nothing"):
 267                         nimList.append(x)
 268
 269         if len(nimList) == 0:
 270                 session.open(MessageBox, _("No satellite frontend found!!"), MessageBox.TYPE_ERROR)
 271         else:
 272                 if session.nav.RecordTimer.isRecording():
 273                         session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR)
 274                 else:
 275                         if len(nimList) == 1:
 276                                 session.open(Satfinder, nimList[0])
 277                         else:
 278                                 session.open(SatNimSelection)
 279
 280 def SatfinderStart(menuid, **kwargs):
 281         if menuid == "scan":
 282                 return [(_("Satfinder"), SatfinderMain, "satfinder", None)]
 283         else:
 284                 return []
 285
 286 def Plugins(**kwargs):
 287         if (nimmanager.hasNimType("DVB-S")):
 288                 return PluginDescriptor(name=_("Satfinder"), description="Helps setting up your dish", where = PluginDescriptor.WHERE_MENU, fnc=SatfinderStart)
 289         else:
 290                 return []