code.vuplus.com Git - vuplus_dvbapp/blob - 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 class Satfinder(ScanSetup):
  18         def openFrontend(self):
  19                 res_mgr = eDVBResourceManager.getInstance()
  20                 if res_mgr:
  21                         self.raw_channel = res_mgr.allocateRawChannel(self.feid)
  22                         if self.raw_channel:
  23                                 self.frontend = self.raw_channel.getFrontend()
  24                                 if self.frontend:
  25                                         return True
  26                                 else:
  27                                         print "getFrontend failed"
  28                         else:
  29                                 print "getRawChannel failed"
  30                 else:
  31                         print "getResourceManager instance failed"
  32                 return False
  33
  34         def __init__(self, session, feid):
  35                 self.initcomplete = False
  36                 self.feid = feid
  37                 self.oldref = None
  38
  39                 if not self.openFrontend():
  40                         self.oldref = session.nav.getCurrentlyPlayingServiceReference()
  41                         session.nav.stopService() # try to disable foreground service
  42                         if not self.openFrontend():
  43                                 if session.pipshown: # try to disable pip
  44                                         session.pipshown = False
  45                                         del session.pip
  46                                         if not self.openFrontend():
  47                                                 self.frontend = None # in normal case this should not happen
  48
  49                 ScanSetup.__init__(self, session)
  50                 self.tuner = Tuner(self.frontend)
  51                 self["introduction"].setText("")
  52                 self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
  53                 self.initcomplete = True
  54                 self.onClose.append(self.__onClose)
  55
  56         def __onClose(self):
  57                 self.session.nav.playService(self.oldref)
  58
  59         def createSetup(self):
  60                 self.modulationEntry = None
  61                 self.typeOfTuningEntry = None
  62                 self.satEntry = None
  63                 self.systemEntry = None
  64                 self.is_id_boolEntry = None
  65                 self.plsModeEntry = None
  66                 self.list = []
  67                 self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
  68                 self.list.append(self.typeOfTuningEntry)
  69                 self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
  70                 self.list.append(self.satEntry)
  71
  72                 nim = nimmanager.nim_slots[self.feid]
  73                 if self.tuning_type.value == "manual_transponder":
  74                         scan_sat_system_value = self.scan_sat.system.value
  75                         if nim.isCompatible("DVB-S2X"):
  76                                         scan_sat_system_value = self.scan_sat.system_dvbs2x.value
  77                                         self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x)
  78                                         self.list.append(self.systemEntry)
  79                         elif nim.isCompatible("DVB-S2"):
  80                                 self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
  81                                 self.list.append(self.systemEntry)
  82                         else:
  83                                 # downgrade to dvb-s, in case a -s2 config was active
  84                                 self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
  85                         self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
  86                         self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
  87                         self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
  88                         self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
  89                         if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S:
  90                                 self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
  91                         elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:
  92                                 self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
  93                                 self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
  94                                 self.list.append(self.modulationEntry)
  95                                 self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
  96                                 self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
  97                         elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
  98                                 if self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_QPSK:
  99                                         self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_qpsk))
 100                                 elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8PSK:
 101                                         self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8psk))
 102                                 elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8APSK:
 103                                         self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8apsk))
 104                                 elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_16APSK:
 105                                         self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_16apsk))
 106                                 elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_32APSK:
 107                                         self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_32apsk))
 108                                 self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation_dvbs2x)
 109                                 self.list.append(self.modulationEntry)
 110                                 self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
 111                                 self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
 112                         if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
 113                                 if nim.isMultistream():
 114                                         self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
 115                                         self.list.append(self.is_id_boolEntry)
 116                                         if self.scan_sat.is_id_bool.value:
 117                                                 self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
 118                                                 self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
 119                                                 self.list.append(self.plsModeEntry)
 120                                                 if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
 121                                                         self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
 122                 elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder":
 123                         self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder))
 124                 self["config"].list = self.list
 125                 self["config"].l.setList(self.list)
 126
 127         def newConfig(self):
 128                 cur = self["config"].getCurrent()
 129                 if cur in (self.typeOfTuningEntry, self.systemEntry, self.is_id_boolEntry, self.plsModeEntry):
 130                         self.createSetup()
 131                 elif cur == self.satEntry:
 132                         self.updateSats()
 133                         self.createSetup()
 134                 elif self.modulationEntry and (cur == self.modulationEntry) and \
 135                         self.systemEntry and (self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2X):
 136                         self.createSetup()
 137
 138         def sat_changed(self, config_element):
 139                 self.newConfig()
 140                 self.retune(config_element)
 141
 142         def retune(self, configElement):
 143                 returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 3, 0)
 144                 satpos = int(self.tuning_sat.value)
 145                 nim = nimmanager.nim_slots[self.feid]
 146                 if self.tuning_type.value == "manual_transponder":
 147                         system = self.scan_sat.system.value
 148                         modulation = self.scan_sat.modulation.value
 149                         if nim.isCompatible("DVB-S2X"):
 150                                 system = self.scan_sat.system_dvbs2x.value
 151                                 modulation = self.scan_sat.modulation_dvbs2x.value
 152
 153                         if system == eDVBFrontendParametersSatellite.System_DVB_S:
 154                                 fec = self.scan_sat.fec.value
 155                         elif system == eDVBFrontendParametersSatellite.System_DVB_S2:
 156                                 fec = self.scan_sat.fec_s2.value
 157                         elif system == eDVBFrontendParametersSatellite.System_DVB_S2X:
 158                                 if modulation == eDVBFrontendParametersSatellite.Modulation_QPSK:
 159                                         fec = self.scan_sat.fec_s2x_qpsk.value
 160                                 elif modulation == eDVBFrontendParametersSatellite.Modulation_8PSK:
 161                                         fec = self.scan_sat.fec_s2x_8psk.value
 162                                 elif modulation == eDVBFrontendParametersSatellite.Modulation_8APSK:
 163                                         fec = self.scan_sat.fec_s2x_8apsk.value
 164                                 elif modulation == eDVBFrontendParametersSatellite.Modulation_16APSK:
 165                                         fec = self.scan_sat.fec_s2x_16apsk.value
 166                                 elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
 167                                         fec = self.scan_sat.fec_s2x_32apsk.value
 168
 169                         is_id = -1
 170                         pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
 171                         pls_code = 0
 172                         if self.scan_sat.is_id_bool.value:
 173                                 is_id = self.scan_sat.is_id.value
 174                                 pls_mode = self.scan_sat.pls_mode.value
 175                                 if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
 176                                         pls_code = 0
 177                                 else:
 178                                         pls_code = self.scan_sat.pls_code.value
 179
 180                         returnvalue = (
 181                                 self.scan_sat.frequency.value,
 182                                 self.scan_sat.symbolrate.value,
 183                                 self.scan_sat.polarization.value,
 184                                 fec,
 185                                 self.scan_sat.inversion.value,
 186                                 satpos,
 187                                 system,
 188                                 modulation,
 189                                 self.scan_sat.rolloff.value,
 190                                 self.scan_sat.pilot.value,
 191                                 is_id,
 192                                 pls_mode,
 193                                 pls_code)
 194                         self.tune(returnvalue)
 195                 elif self.tuning_type.value == "predefined_transponder":
 196                         tps = nimmanager.getTransponders(satpos)
 197                         l = len(tps)
 198                         if l > self.tuning_transponder.index:
 199                                 transponder = tps[self.tuning_transponder.index]
 200                                 returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
 201                                         transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12])
 202                                 self.tune(returnvalue)
 203
 204         def createConfig(self, foo):
 205                 self.tuning_transponder = None
 206                 self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("Manual transponder")), ("predefined_transponder", _("Predefined transponder"))])
 207                 self.tuning_sat = getConfigSatlist(192, nimmanager.getSatListForNim(self.feid))
 208                 ScanSetup.createConfig(self, None)
 209
 210                 self.updateSats()
 211
 212                 setup_list = [self.tuning_type, self.tuning_sat, self.scan_sat.frequency,
 213                         self.scan_sat.inversion, self.scan_sat.symbolrate,
 214                         self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
 215                         self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,
 216                         self.scan_sat.rolloff, self.scan_sat.system,
 217                         self.scan_sat.is_id_bool, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code]
 218
 219                 nim = nimmanager.nim_slots[self.feid]
 220                 if nim.isCompatible("DVB-S2X"):
 221                         dvbs2x_setup_list = [self.scan_sat.system_dvbs2x, self.scan_sat.modulation_dvbs2x, self.scan_sat.fec_s2x_qpsk,
 222                                 self.scan_sat.fec_s2x_8psk, self.scan_sat.fec_s2x_8apsk, self.scan_sat.fec_s2x_16apsk, self.scan_sat.fec_s2x_32apsk]
 223                         setup_list.extend(dvbs2x_setup_list)
 224
 225                 for x in setup_list:
 226                         x.addNotifier(self.retune, initial_call = False)
 227
 228         def updateSats(self):
 229                 orb_pos = self.tuning_sat.orbital_position
 230                 if orb_pos is not None:
 231                         transponderlist = nimmanager.getTransponders(orb_pos)
 232                         list = []
 233                         default = None
 234                         index = 0
 235                         for x in transponderlist:
 236                                 if x[3] == 0:
 237                                         pol = "H"
 238                                 elif x[3] == 1:
 239                                         pol = "V"
 240                                 elif x[3] == 2:
 241                                         pol = "CL"
 242                                 elif x[3] == 3:
 243                                         pol = "CR"
 244                                 else:
 245                                         pol = "??"
 246                                 if x[4] == 0:
 247                                         fec = "FEC Auto"
 248                                 elif x[4] == 1:
 249                                         fec = "FEC 1/2"
 250                                 elif x[4] == 2:
 251                                         fec = "FEC 2/3"
 252                                 elif x[4] == 3:
 253                                         fec = "FEC 3/4"
 254                                 elif x[4] == 4:
 255                                         fec = "FEC 5/6"
 256                                 elif x[4] == 5:
 257                                         fec = "FEC 7/8"
 258                                 elif x[4] == 6:
 259                                         fec = "FEC 8/9"
 260                                 elif x[4] == 7:
 261                                         fec = "FEC 3/5"
 262                                 elif x[4] == 8:
 263                                         fec = "FEC 4/5"
 264                                 elif x[4] == 9:
 265                                         fec = "FEC 9/10"
 266                                 elif x[4] == 15:
 267                                         fec = "FEC None"
 268                                 else:
 269                                         fec = "FEC Unknown"
 270                                 e = str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec
 271                                 if default is None:
 272                                         default = str(index)
 273                                 list.append((str(index), e))
 274                                 index += 1
 275                         self.tuning_transponder = ConfigSelection(choices = list, default = default)
 276                         self.tuning_transponder.addNotifier(self.retune, initial_call = False)
 277
 278         def keyGo(self):
 279                 self.retune(self.tuning_type)
 280
 281         def restartPrevService(self, yesno):
 282                 if yesno:
 283                         if self.frontend:
 284                                 self.frontend = None
 285                                 del self.raw_channel
 286                 else:
 287                         self.oldref = None
 288                 self.close(None)
 289
 290         def keyCancel(self):
 291                 if self.oldref:
 292                         self.session.openWithCallback(self.restartPrevService, MessageBox, _("Zap back to service before satfinder?"), MessageBox.TYPE_YESNO)
 293                 else:
 294                         self.restartPrevService(False)
 295
 296         def tune(self, transponder):
 297                 if self.initcomplete:
 298                         if transponder is not None:
 299                                 self.tuner.tune(transponder)
 300
 301 class SatNimSelection(Screen):
 302         skin = """
 303                 <screen position="140,165" size="400,130" title="select Slot">
 304                         <widget name="nimlist" position="20,10" size="360,100" />
 305                 </screen>"""
 306
 307         def __init__(self, session):
 308                 Screen.__init__(self, session)
 309
 310                 nimlist = nimmanager.getNimListOfType("DVB-S")
 311                 nimMenuList = []
 312                 for x in nimlist:
 313                         nimMenuList.append((nimmanager.nim_slots[x].friendly_full_description, x))
 314
 315                 self["nimlist"] = MenuList(nimMenuList)
 316
 317                 self["actions"] = ActionMap(["OkCancelActions"],
 318                 {
 319                         "ok": self.okbuttonClick ,
 320                         "cancel": self.close
 321                 }, -1)
 322
 323         def okbuttonClick(self):
 324                 selection = self["nimlist"].getCurrent()[1]
 325                 self.session.open(Satfinder, selection)
 326
 327 def SatfinderMain(session, **kwargs):
 328         nims = nimmanager.getNimListOfType("DVB-S")
 329
 330         nimList = []
 331         for x in nims:
 332                 if not nimmanager.getNimConfig(x).configMode.value in ("loopthrough", "satposdepends", "nothing"):
 333                         nimList.append(x)
 334
 335         if len(nimList) == 0:
 336                 session.open(MessageBox, _("No satellite frontend found!!"), MessageBox.TYPE_ERROR)
 337         else:
 338                 if session.nav.RecordTimer.isRecording():
 339                         session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR)
 340                 else:
 341                         if len(nimList) == 1:
 342                                 session.open(Satfinder, nimList[0])
 343                         else:
 344                                 session.open(SatNimSelection)
 345
 346 def SatfinderStart(menuid, **kwargs):
 347         if menuid == "scan":
 348                 return [(_("Satfinder"), SatfinderMain, "satfinder", None)]
 349         else:
 350                 return []
 351
 352 def Plugins(**kwargs):
 353         if (nimmanager.hasNimType("DVB-S")):
 354                 return PluginDescriptor(name=_("Satfinder"), description="Helps setting up your dish", where = PluginDescriptor.WHERE_MENU, needsRestart = False, fnc=SatfinderStart)
 355         else:
 356                 return []