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