code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Screens/ScanSetup.py

   1 from Screen import Screen
   2 from Screens.DefaultWizard import DefaultWizard
   3 from ServiceScan import ServiceScan
   4 from Components.config import config, ConfigSubsection, ConfigSelection, \
   5         ConfigYesNo, ConfigInteger, getConfigListEntry, ConfigSlider, ConfigEnableDisable
   6 from Components.ActionMap import NumberActionMap, ActionMap
   7 from Components.ConfigList import ConfigListScreen
   8 from Components.NimManager import nimmanager, getConfigSatlist
   9 from Components.Label import Label
  10 from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION
  11 from Tools.HardwareInfo import HardwareInfo
  12 from Screens.MessageBox import MessageBox
  13 from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, \
  14         eDVBSatelliteEquipmentControl, eDVBFrontendParametersTerrestrial, \
  15         eDVBFrontendParametersCable, eConsoleAppContainer, eDVBResourceManager
  16
  17 def buildTerTransponder(frequency,
  18                 inversion=2, bandwidth = 3, fechigh = 6, feclow = 6,
  19                 modulation = 2, transmission = 2, guard = 4,
  20                 hierarchy = 4, system = 0, plpid = 0):
  21 #       print "freq", frequency, "inv", inversion, "bw", bandwidth, "fech", fechigh, "fecl", feclow, "mod", modulation, "tm", transmission, "guard", guard, "hierarchy", hierarchy
  22         parm = eDVBFrontendParametersTerrestrial()
  23         parm.frequency = frequency
  24         parm.inversion = inversion
  25         parm.bandwidth = bandwidth
  26         parm.code_rate_HP = fechigh
  27         parm.code_rate_LP = feclow
  28         parm.modulation = modulation
  29         parm.transmission_mode = transmission
  30         parm.guard_interval = guard
  31         parm.hierarchy = hierarchy
  32         parm.system = system
  33         parm.plpid = plpid
  34         return parm
  35
  36 def getInitialTransponderList(tlist, pos):
  37         list = nimmanager.getTransponders(pos)
  38         for x in list:
  39                 if x[0] == 0:           #SAT
  40                         parm = eDVBFrontendParametersSatellite()
  41                         parm.frequency = x[1]
  42                         parm.symbol_rate = x[2]
  43                         parm.polarisation = x[3]
  44                         parm.fec = x[4]
  45                         parm.inversion = x[7]
  46                         parm.orbital_position = pos
  47                         parm.system = x[5]
  48                         parm.modulation = x[6]
  49                         parm.rolloff = x[8]
  50                         parm.pilot = x[9]
  51                         tlist.append(parm)
  52
  53 def getInitialCableTransponderList(tlist, nim):
  54         list = nimmanager.getTranspondersCable(nim)
  55         for x in list:
  56                 if x[0] == 1: #CABLE
  57                         parm = eDVBFrontendParametersCable()
  58                         parm.frequency = x[1]
  59                         parm.symbol_rate = x[2]
  60                         parm.modulation = x[3]
  61                         parm.fec_inner = x[4]
  62                         parm.inversion = parm.Inversion_Unknown
  63                         #print "frequency:", x[1]
  64                         #print "symbol_rate:", x[2]
  65                         #print "modulation:", x[3]
  66                         #print "fec_inner:", x[4]
  67                         #print "inversion:", 2
  68                         tlist.append(parm)
  69
  70 def getInitialTerrestrialTransponderList(tlist, region):
  71         list = nimmanager.getTranspondersTerrestrial(region)
  72
  73         #self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv,system,plpid))
  74
  75         #def buildTerTransponder(frequency, inversion = 2, bandwidth = 3, fechigh = 6, feclow = 6,
  76                                 #modulation = 2, transmission = 2, guard = 4, hierarchy = 4, system = 0, plpid = 0):):
  77
  78         for x in list:
  79                 if x[0] == 2: #TERRESTRIAL
  80                         parm = buildTerTransponder(x[1], x[9], x[2], x[4], x[5], x[3], x[7], x[6], x[8], x[10], x[11])
  81                         tlist.append(parm)
  82
  83 cable_bands = {
  84         "DVBC_BAND_EU_VHF_I" : 1 << 0,
  85         "DVBC_BAND_EU_MID" : 1 << 1,
  86         "DVBC_BAND_EU_VHF_III" : 1 << 2,
  87         "DVBC_BAND_EU_SUPER" : 1 << 3,
  88         "DVBC_BAND_EU_HYPER" : 1 << 4,
  89         "DVBC_BAND_EU_UHF_IV" : 1 << 5,
  90         "DVBC_BAND_EU_UHF_V" : 1 << 6,
  91         "DVBC_BAND_US_LO" : 1 << 7,
  92         "DVBC_BAND_US_MID" : 1 << 8,
  93         "DVBC_BAND_US_HI" : 1 << 9,
  94         "DVBC_BAND_US_SUPER" : 1 << 10,
  95         "DVBC_BAND_US_HYPER" : 1 << 11,
  96 }
  97
  98 class CableTransponderSearchSupport:
  99 #       def setCableTransponderSearchResult(self, tlist):
 100 #               pass
 101
 102 #       def cableTransponderSearchFinished(self):
 103 #               pass
 104
 105         def tryGetRawFrontend(self, feid):
 106                 res_mgr = eDVBResourceManager.getInstance()
 107                 if res_mgr:
 108                         raw_channel = res_mgr.allocateRawChannel(self.feid)
 109                         if raw_channel:
 110                                 frontend = raw_channel.getFrontend()
 111                                 if frontend:
 112                                         frontend.closeFrontend() # immediate close...
 113                                         del frontend
 114                                         del raw_channel
 115                                         return True
 116                 return False
 117
 118         def cableTransponderSearchSessionClosed(self, *val):
 119                 print "cableTransponderSearchSessionClosed, val", val
 120                 self.cable_search_container.appClosed.remove(self.cableTransponderSearchClosed)
 121                 self.cable_search_container.dataAvail.remove(self.getCableTransponderData)
 122                 if val and len(val):
 123                         if val[0]:
 124                                 self.setCableTransponderSearchResult(self.__tlist)
 125                         else:
 126                                 self.cable_search_container.sendCtrlC()
 127                                 self.setCableTransponderSearchResult(None)
 128                 self.cable_search_container = None
 129                 self.cable_search_session = None
 130                 self.__tlist = None
 131                 self.cableTransponderSearchFinished()
 132
 133         def cableTransponderSearchClosed(self, retval):
 134                 print "cableTransponderSearch finished", retval
 135                 self.cable_search_session.close(True)
 136
 137         def getCableTransponderData(self, str):
 138                 data = str.split()
 139                 if len(data):
 140                         if data[0] == 'OK':
 141                                 print str
 142                                 parm = eDVBFrontendParametersCable()
 143                                 qam = { "QAM16" : parm.Modulation_QAM16,
 144                                         "QAM32" : parm.Modulation_QAM32,
 145                                         "QAM64" : parm.Modulation_QAM64,
 146                                         "QAM128" : parm.Modulation_QAM128,
 147                                         "QAM256" : parm.Modulation_QAM256 }
 148                                 inv = { "INVERSION_OFF" : parm.Inversion_Off,
 149                                         "INVERSION_ON" : parm.Inversion_On,
 150                                         "INVERSION_AUTO" : parm.Inversion_Unknown }
 151                                 fec = { "FEC_AUTO" : parm.FEC_Auto,
 152                                         "FEC_1_2" : parm.FEC_1_2,
 153                                         "FEC_2_3" : parm.FEC_2_3,
 154                                         "FEC_3_4" : parm.FEC_3_4,
 155                                         "FEC_5_6": parm.FEC_5_6,
 156                                         "FEC_7_8" : parm.FEC_7_8,
 157                                         "FEC_8_9" : parm.FEC_8_9,
 158                                         "FEC_NONE" : parm.FEC_None }
 159                                 parm.frequency = int(data[1])
 160                                 parm.symbol_rate = int(data[2])
 161                                 parm.fec_inner = fec[data[3]]
 162                                 parm.modulation = qam[data[4]]
 163                                 parm.inversion = inv[data[5]]
 164                                 self.__tlist.append(parm)
 165                         tmpstr = _("Try to find used Transponders in cable network.. please wait...")
 166                         tmpstr += "\n\n"
 167                         tmpstr += data[1]
 168                         tmpstr += " kHz "
 169                         tmpstr += data[0]
 170                         self.cable_search_session["text"].setText(tmpstr)
 171
 172         def startCableTransponderSearch(self, nim_idx):
 173                 def GetCommand(nimIdx):
 174                         _supportNimType   = { 'SSH108':'ssh108' }
 175                         _nimSocket = {}
 176                         fp = file('/proc/bus/nim_sockets')
 177
 178                         sNo, sName = -1, ""
 179                         for line in fp:
 180                                 line = line.strip()
 181                                 if line.startswith('NIM Socket'):
 182                                         try:    sNo = line.split()[2][:-1]
 183                                         except: sNo = -1
 184                                 elif line.startswith('Name:'):
 185                                         try:    sName = line.split()[3][4:-1]
 186                                         except: sName = ""
 187                                 if sNo >= 0 and sName != "":
 188                                         _nimSocket[sNo] = sName
 189                                         sNo, sName = -1, ''
 190                         fp.close()
 191                         print 'parsed nim_sockets :', _nimSocket
 192
 193                         try:
 194                                 sName = _nimSocket[str(nimIdx)]
 195                                 sType = _supportNimType[sName]
 196                                 return sType
 197                         except: pass
 198                         return 'tda1002x'
 199
 200                 if not self.tryGetRawFrontend(nim_idx):
 201                         self.session.nav.stopService()
 202                         if not self.tryGetRawFrontend(nim_idx):
 203                                 if self.session.pipshown: # try to disable pip
 204                                         self.session.pipshown = False
 205                                         del self.session.pip
 206                                 if not self.tryGetRawFrontend(nim_idx):
 207                                         self.cableTransponderSearchFinished()
 208                                         return
 209                 self.__tlist = [ ]
 210                 self.cable_search_container = eConsoleAppContainer()
 211                 self.cable_search_container.appClosed.append(self.cableTransponderSearchClosed)
 212                 self.cable_search_container.dataAvail.append(self.getCableTransponderData)
 213                 cableConfig = config.Nims[nim_idx].cable
 214                 tunername = nimmanager.getNimName(nim_idx)
 215                 bus = nimmanager.getI2CDevice(nim_idx)
 216                 if bus is None:
 217                         print "ERROR: could not get I2C device for nim", nim_idx, "for cable transponder search"
 218                         bus = 2
 219
 220                 if tunername == "CXD1981":
 221                         cmd = "cxd1978 --init --scan --verbose --wakeup --inv 2 --bus %d" % bus
 222                 else:
 223                         bin_name = GetCommand(nim_idx)
 224                         cmd = "%(BIN_NAME)s --init --scan --verbose --wakeup --inv 2 --bus %(BUS)d" % {'BIN_NAME':bin_name , 'BUS':bus}
 225
 226                 if cableConfig.scan_type.value == "bands":
 227                         cmd += " --scan-bands "
 228                         bands = 0
 229                         if cableConfig.scan_band_EU_VHF_I.value:
 230                                 bands |= cable_bands["DVBC_BAND_EU_VHF_I"]
 231                         if cableConfig.scan_band_EU_MID.value:
 232                                 bands |= cable_bands["DVBC_BAND_EU_MID"]
 233                         if cableConfig.scan_band_EU_VHF_III.value:
 234                                 bands |= cable_bands["DVBC_BAND_EU_VHF_III"]
 235                         if cableConfig.scan_band_EU_UHF_IV.value:
 236                                 bands |= cable_bands["DVBC_BAND_EU_UHF_IV"]
 237                         if cableConfig.scan_band_EU_UHF_V.value:
 238                                 bands |= cable_bands["DVBC_BAND_EU_UHF_V"]
 239                         if cableConfig.scan_band_EU_SUPER.value:
 240                                 bands |= cable_bands["DVBC_BAND_EU_SUPER"]
 241                         if cableConfig.scan_band_EU_HYPER.value:
 242                                 bands |= cable_bands["DVBC_BAND_EU_HYPER"]
 243                         if cableConfig.scan_band_US_LOW.value:
 244                                 bands |= cable_bands["DVBC_BAND_US_LO"]
 245                         if cableConfig.scan_band_US_MID.value:
 246                                 bands |= cable_bands["DVBC_BAND_US_MID"]
 247                         if cableConfig.scan_band_US_HIGH.value:
 248                                 bands |= cable_bands["DVBC_BAND_US_HI"]
 249                         if cableConfig.scan_band_US_SUPER.value:
 250                                 bands |= cable_bands["DVBC_BAND_US_SUPER"]
 251                         if cableConfig.scan_band_US_HYPER.value:
 252                                 bands |= cable_bands["DVBC_BAND_US_HYPER"]
 253                         cmd += str(bands)
 254                 else:
 255                         cmd += " --scan-stepsize "
 256                         cmd += str(cableConfig.scan_frequency_steps.value)
 257                 if cableConfig.scan_mod_qam16.value:
 258                         cmd += " --mod 16"
 259                 if cableConfig.scan_mod_qam32.value:
 260                         cmd += " --mod 32"
 261                 if cableConfig.scan_mod_qam64.value:
 262                         cmd += " --mod 64"
 263                 if cableConfig.scan_mod_qam128.value:
 264                         cmd += " --mod 128"
 265                 if cableConfig.scan_mod_qam256.value:
 266                         cmd += " --mod 256"
 267                 if cableConfig.scan_sr_6900.value:
 268                         cmd += " --sr 6900000"
 269                 if cableConfig.scan_sr_6875.value:
 270                         cmd += " --sr 6875000"
 271                 if cableConfig.scan_sr_ext1.value > 450:
 272                         cmd += " --sr "
 273                         cmd += str(cableConfig.scan_sr_ext1.value)
 274                         cmd += "000"
 275                 if cableConfig.scan_sr_ext2.value > 450:
 276                         cmd += " --sr "
 277                         cmd += str(cableConfig.scan_sr_ext2.value)
 278                         cmd += "000"
 279                 print bin_name, " CMD is", cmd
 280
 281                 self.cable_search_container.execute(cmd)
 282                 tmpstr = _("Try to find used transponders in cable network.. please wait...")
 283                 tmpstr += "\n\n..."
 284                 self.cable_search_session = self.session.openWithCallback(self.cableTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO)
 285
 286 class TerrestrialTransponderSearchSupport:
 287 #       def setTerrestrialTransponderSearchResult(self, tlist):
 288 #               pass
 289
 290 #       def terrestrialTransponderSearchFinished(self):
 291 #               pass
 292
 293         def terrestrialTransponderSearchSessionClosed(self, *val):
 294                 print "TerrestrialTransponderSearchSessionClosed, val", val
 295                 self.terrestrial_search_container.appClosed.remove(self.terrestrialTransponderSearchClosed)
 296                 self.terrestrial_search_container.dataAvail.remove(self.getTerrestrialTransponderData)
 297                 if val and len(val):
 298                         if val[0]:
 299                                 self.setTerrestrialTransponderSearchResult(self.__tlist)
 300                         else:
 301                                 self.terrestrial_search_container.sendCtrlC()
 302                                 self.setTerrestrialTransponderSearchResult(None)
 303                 self.terrestrial_search_container = None
 304                 self.terrestrial_search_session = None
 305                 self.__tlist = None
 306                 self.terrestrialTransponderSearchFinished()
 307
 308         def terrestrialTransponderSearchClosed(self, retval):
 309                 self.setTerrestrialTransponderData()
 310                 opt = self.terrestrialTransponderGetOpt()
 311                 if opt is None:
 312                         print "terrestrialTransponderSearch finished", retval
 313                         self.terrestrial_search_session.close(True)
 314                 else:
 315                         (freq, bandWidth) = opt
 316                         self.terrestrialTransponderSearch(freq, bandWidth)
 317
 318         def getTerrestrialTransponderData(self, str):
 319                 self.terrestrial_search_data += str
 320
 321         def setTerrestrialTransponderData(self):
 322                 print self.terrestrial_search_data
 323                 data = self.terrestrial_search_data.split()
 324                 if len(data):
 325                         if data[0] == 'OK':
 326                                 # DVB-T : OK frequency bandwidth delivery system -1
 327                                 # DVB-T2 : OK frequency bandwidth delivery system number_of_plp plp_id0:plp_type0
 328                                 if data[3] == 1: # DVB-T
 329                                         parm = eDVBFrontendParametersTerrestrial()
 330                                         parm.frequency = int(data[1])
 331                                         parm.bandwidth = int(data[2])
 332                                         parm.inversion = parm.Inversion_Unknown
 333                                         parm.code_rate_HP = parm.FEC_Auto
 334                                         parm.code_rate_LP = parm.FEC_Auto
 335                                         parm.modulation = parm.Modulation_Auto
 336                                         parm.transmission_mode = parm.TransmissionMode_Auto
 337                                         parm.guard_interval = parm.GuardInterval_Auto
 338                                         parm.hierarchy = parm.Hierarchy_Auto
 339                                         parm.system = parm.System_DVB_T
 340                                         parm.plpid = 0
 341                                         self.__tlist.append(parm)
 342                                 else:
 343                                         plp_list = data[5:]
 344                                         plp_num = data[4]
 345                                         if len(plp_list) > plp_num:
 346                                                 plp_list = plp_list[:plp_num]
 347                                         for plp in plp_list:
 348                                                 (plp_id, plp_type) = plp.split(':')
 349                                                 if plp_type == '0': # common PLP:
 350                                                         continue
 351                                                 parm = eDVBFrontendParametersTerrestrial()
 352                                                 parm.frequency = int(data[1])
 353                                                 parm.bandwidth = self.terrestrialTransponderconvBandwidth_P(int(data[2]))
 354                                                 parm.inversion = parm.Inversion_Unknown
 355                                                 parm.code_rate_HP = parm.FEC_Auto
 356                                                 parm.code_rate_LP = parm.FEC_Auto
 357                                                 parm.modulation = parm.Modulation_Auto
 358                                                 parm.transmission_mode = parm.TransmissionMode_Auto
 359                                                 parm.guard_interval = parm.GuardInterval_Auto
 360                                                 parm.hierarchy = parm.Hierarchy_Auto
 361                                                 parm.system = parm.System_DVB_T2
 362                                                 parm.plpid = int(plp_id)
 363                                                 self.__tlist.append(parm)
 364
 365                         tmpstr = _("Try to find used Transponders in cable network.. please wait...")
 366                         tmpstr += "\n\n"
 367                         tmpstr += data[1][:-3]
 368                         tmpstr += " kHz "
 369                         tmpstr += data[0]
 370                         self.terrestrial_search_session["text"].setText(tmpstr)
 371
 372         def terrestrialTransponderInitSearchList(self, searchList, region):
 373                 tpList = nimmanager.getTranspondersTerrestrial(region)
 374                 for x in tpList:
 375                         if x[0] == 2: #TERRESTRIAL
 376                                 freq = x[1] # frequency
 377                                 bandWidth = self.terrestrialTransponderConvBandwidth_I(x[2]) # bandWidth
 378                                 parm = (freq, bandWidth)
 379                                 searchList.append(parm)
 380
 381         def terrestrialTransponderConvBandwidth_I(self, _bandWidth):
 382                 bandWidth = {
 383                         eDVBFrontendParametersTerrestrial.Bandwidth_8MHz : 8000000,
 384                         eDVBFrontendParametersTerrestrial.Bandwidth_7MHz : 7000000,
 385                         eDVBFrontendParametersTerrestrial.Bandwidth_6MHz : 6000000,
 386                         eDVBFrontendParametersTerrestrial.Bandwidth_5MHz : 5000000,
 387                         eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz : 1712000,
 388                         eDVBFrontendParametersTerrestrial.Bandwidth_10MHz : 10000000,
 389                 }.get(_bandWidth, 8000000)
 390                 return bandWidth
 391
 392         def terrestrialTransponderconvBandwidth_P(self, _bandWidth):
 393                 bandWidth = {
 394                         8000000 : eDVBFrontendParametersTerrestrial.Bandwidth_8MHz,
 395                         7000000 : eDVBFrontendParametersTerrestrial.Bandwidth_7MHz,
 396                         6000000 : eDVBFrontendParametersTerrestrial.Bandwidth_6MHz,
 397                         5000000 : eDVBFrontendParametersTerrestrial.Bandwidth_5MHz,
 398                         1712000 : eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz,
 399                         10000000 : eDVBFrontendParametersTerrestrial.Bandwidth_10MHz,
 400                 }.get(_bandWidth, eDVBFrontendParametersTerrestrial.Bandwidth_8MHz)
 401                 return bandWidth
 402
 403         def terrestrialTransponderGetOpt(self):
 404                 if len(self.terrestrial_search_list) > 0:
 405                         return self.terrestrial_search_list.pop(0)
 406                 else:
 407                         return None
 408
 409         def startTerrestrialTransponderSearch(self, nim_idx, region):
 410                 def GetCommand(nimIdx):
 411                         _supportNimType   = { 'SSH108':'ssh108_t2_scan' }
 412                         description = nimmanager.getNimName(nimIdx)
 413                         try:
 414                                 tunername = description.split()[2][4:-1]
 415                         except:
 416                                 tunername = description
 417                         return  _supportNimType.get(tunername, 'ssh108_t2_scan')
 418
 419                 if not self.tryGetRawFrontend(nim_idx):
 420                         self.session.nav.stopService()
 421                         if not self.tryGetRawFrontend(nim_idx):
 422                                 if self.session.pipshown: # try to disable pip
 423                                         self.session.pipshown = False
 424                                         del self.session.pip
 425                                 if not self.tryGetRawFrontend(nim_idx):
 426                                         self.terrestrialTransponderSearchFinished()
 427                                         return
 428                 self.__tlist = [ ]
 429                 self.terrestrial_search_container = eConsoleAppContainer()
 430                 self.terrestrial_search_container.appClosed.append(self.terrestrialTransponderSearchClosed)
 431                 self.terrestrial_search_container.dataAvail.append(self.getTerrestrialTransponderData)
 432
 433                 self.terrestrial_search_binName = GetCommand(nim_idx)
 434
 435                 self.terrestrial_search_bus = nimmanager.getI2CDevice(nim_idx)
 436                 if self.terrestrial_search_bus is None:
 437                         print "ERROR: could not get I2C device for nim", nim_idx, "for terrestrial transponder search"
 438                         self.terrestrial_search_bus = 2
 439
 440                 self.terrestrial_search_list = []
 441                 self.terrestrialTransponderInitSearchList(self.terrestrial_search_list ,region)
 442                 (freq, bandWidth) = self.terrestrialTransponderGetOpt()
 443                 self.terrestrialTransponderSearch(freq, bandWidth)
 444
 445                 tmpstr = _("Try to find used transponders in terrestrial network.. please wait...")
 446                 tmpstr += "\n\n..."
 447                 self.terrestrial_search_session = self.session.openWithCallback(self.terrestrialTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO)
 448
 449         def terrestrialTransponderSearch(self, freq, bandWidth):
 450                 self.terrestrial_search_data = ""
 451                 cmd = "%s --freq %d --bw %d --bus %d --ds 2" % (self.terrestrial_search_binName, freq, bandWidth, self.terrestrial_search_bus)
 452                 print "SCAN CMD : ",cmd
 453                 self.terrestrial_search_container.execute(cmd)
 454
 455 class DefaultSatLists(DefaultWizard):
 456         def __init__(self, session, silent = True, showSteps = False):
 457                 self.xmlfile = "defaultsatlists.xml"
 458                 DefaultWizard.__init__(self, session, silent, showSteps, neededTag = "services")
 459                 print "configuredSats:", nimmanager.getConfiguredSats()
 460
 461         def setDirectory(self):
 462                 self.directory = []
 463                 self.directory.append(resolveFilename(SCOPE_DEFAULTDIR))
 464                 import os
 465                 os.system("mount %s %s" % (resolveFilename(SCOPE_DEFAULTPARTITION), resolveFilename(SCOPE_DEFAULTPARTITIONMOUNTDIR)))
 466                 self.directory.append(resolveFilename(SCOPE_DEFAULTPARTITIONMOUNTDIR))
 467
 468         def statusCallback(self, status, progress):
 469                 print "statusCallback:", status, progress
 470                 from Components.DreamInfoHandler import DreamInfoHandler
 471                 if status == DreamInfoHandler.STATUS_DONE:
 472                         self["text"].setText(_("The installation of the default services lists is finished.") + "\n\n" + _("Please press OK to continue."))
 473                         self.markDone()
 474                         self.disableKeys = False
 475
 476 class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, TerrestrialTransponderSearchSupport):
 477         def __init__(self, session):
 478                 Screen.__init__(self, session)
 479
 480                 self.finished_cb = None
 481                 self.updateSatList()
 482                 self.service = session.nav.getCurrentService()
 483                 self.feinfo = None
 484                 frontendData = None
 485                 if self.service is not None:
 486                         self.feinfo = self.service.frontendInfo()
 487                         frontendData = self.feinfo and self.feinfo.getAll(True)
 488
 489                 self.createConfig(frontendData)
 490
 491                 del self.feinfo
 492                 del self.service
 493
 494                 self["actions"] = NumberActionMap(["SetupActions"],
 495                 {
 496                         "ok": self.keyGo,
 497                         "cancel": self.keyCancel,
 498                 }, -2)
 499
 500                 self.statusTimer = eTimer()
 501                 self.statusTimer.callback.append(self.updateStatus)
 502                 #self.statusTimer.start(5000, True)
 503
 504                 self.list = []
 505                 ConfigListScreen.__init__(self, self.list)
 506                 if not self.scan_nims.value == "":
 507                         self.createSetup()
 508                         self["introduction"] = Label(_("Press OK to start the scan"))
 509                 else:
 510                         self["introduction"] = Label(_("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."))
 511
 512         def runAsync(self, finished_cb):
 513                 self.finished_cb = finished_cb
 514                 self.keyGo()
 515
 516         def updateSatList(self):
 517                 self.satList = []
 518                 for slot in nimmanager.nim_slots:
 519                         if slot.isCompatible("DVB-S"):
 520                                 self.satList.append(nimmanager.getSatListForNim(slot.slot))
 521                         else:
 522                                 self.satList.append(None)
 523
 524         def createSetup(self):
 525                 self.list = []
 526                 self.multiscanlist = []
 527                 index_to_scan = int(self.scan_nims.value)
 528                 print "ID: ", index_to_scan
 529
 530                 self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims)
 531                 self.list.append(self.tunerEntry)
 532
 533                 if self.scan_nims == [ ]:
 534                         return
 535
 536                 self.typeOfScanEntry = None
 537                 self.systemEntry = None
 538                 self.modulationEntry = None
 539                 nim = nimmanager.nim_slots[index_to_scan]
 540                 if nim.isCompatible("DVB-S"):
 541                         self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)
 542                         self.list.append(self.typeOfScanEntry)
 543                 elif nim.isCompatible("DVB-C"):
 544                         self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typecable)
 545                         self.list.append(self.typeOfScanEntry)
 546                 elif nim.isCompatible("DVB-T"):
 547                         self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typeterrestrial)
 548                         self.list.append(self.typeOfScanEntry)
 549
 550                 self.scan_networkScan.value = False
 551                 if nim.isCompatible("DVB-S"):
 552                         if self.scan_type.value == "single_transponder":
 553                                 self.updateSatList()
 554                                 if nim.isCompatible("DVB-S2"):
 555                                         self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
 556                                         self.list.append(self.systemEntry)
 557                                 else:
 558                                         # downgrade to dvb-s, in case a -s2 config was active
 559                                         self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S
 560                                 self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan]))
 561                                 self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
 562                                 self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
 563                                 self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
 564                                 self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
 565                                 if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
 566                                         self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
 567                                 elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
 568                                         self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
 569                                         self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
 570                                         self.list.append(self.modulationEntry)
 571                                         self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
 572                                         self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
 573                         elif self.scan_type.value == "single_satellite":
 574                                 self.updateSatList()
 575                                 print self.scan_satselection[index_to_scan]
 576                                 self.list.append(getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan]))
 577                                 self.scan_networkScan.value = True
 578                         elif self.scan_type.value.find("multisat") != -1:
 579                                 tlist = []
 580                                 SatList = nimmanager.getSatListForNim(index_to_scan)
 581                                 for x in SatList:
 582                                         if self.Satexists(tlist, x[0]) == 0:
 583                                                 tlist.append(x[0])
 584                                                 sat = ConfigEnableDisable(default = self.scan_type.value.find("_yes") != -1 and True or False)
 585                                                 configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat)
 586                                                 self.list.append(configEntry)
 587                                                 self.multiscanlist.append((x[0], sat))
 588                                 self.scan_networkScan.value = True
 589                 elif nim.isCompatible("DVB-C"):
 590                         if self.scan_typecable.value == "single_transponder":
 591                                 self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency))
 592                                 self.list.append(getConfigListEntry(_("Inversion"), self.scan_cab.inversion))
 593                                 self.list.append(getConfigListEntry(_("Symbol rate"), self.scan_cab.symbolrate))
 594                                 self.list.append(getConfigListEntry(_("Modulation"), self.scan_cab.modulation))
 595                                 self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec))
 596                 elif nim.isCompatible("DVB-T"):
 597                         if self.scan_typeterrestrial.value == "single_transponder":
 598                                 if nim.isCompatible("DVB-T2"):
 599                                         self.systemEntry = getConfigListEntry(_('System'), self.scan_ter.system)
 600                                         self.list.append(self.systemEntry)
 601                                 else:
 602                                         self.scan_ter.system.value = eDVBFrontendParametersTerrestrial.System_DVB_T
 603                                 if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T:
 604                                         self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
 605                                         self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
 606                                         self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth))
 607                                         self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh))
 608                                         self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow))
 609                                         self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation))
 610                                         self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission))
 611                                         self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard))
 612                                         self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy))
 613                                 else: # DVB-T2
 614                                         self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
 615                                         self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
 616                                         self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth_t2))
 617                                         self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh_t2))
 618                                         self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow_t2))
 619                                         self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation_t2))
 620                                         self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission_t2))
 621                                         self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard_t2))
 622                                         self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy))
 623                                         self.list.append(getConfigListEntry(_('PLP ID'), self.scan_ter.plp_id))
 624                 self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan))
 625                 self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
 626                 self.list.append(getConfigListEntry(_("Only Free scan"), self.scan_onlyfree))
 627                 self["config"].list = self.list
 628                 self["config"].l.setList(self.list)
 629
 630         def Satexists(self, tlist, pos):
 631                 for x in tlist:
 632                         if x == pos:
 633                                 return 1
 634                 return 0
 635
 636         def newConfig(self):
 637                 cur = self["config"].getCurrent()
 638                 print "cur is", cur
 639                 if cur == self.typeOfScanEntry or \
 640                         cur == self.tunerEntry or \
 641                         cur == self.systemEntry or \
 642                         (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
 643                         self.createSetup()
 644
 645         def createConfig(self, frontendData):
 646                                                            #("Type", frontendData["system"], TYPE_TEXT),
 647                                            #("Modulation", frontendData["modulation"], TYPE_TEXT),
 648                                            #("Orbital position", frontendData["orbital_position"], TYPE_VALUE_DEC),
 649                                            #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
 650                                            #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
 651                                            #("Polarization", frontendData["polarization"], TYPE_TEXT),
 652                                            #("Inversion", frontendData["inversion"], TYPE_TEXT),
 653                                            #("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
 654                                                 #)
 655                 #elif frontendData["tuner_type"] == "DVB-C":
 656                         #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
 657                                            #("Type", frontendData["tuner_type"], TYPE_TEXT),
 658                                            #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
 659                                            #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
 660                                            #("Modulation", frontendData["modulation"], TYPE_TEXT),
 661                                            #("Inversion", frontendData["inversion"], TYPE_TEXT),
 662                         #                  ("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
 663                                                 #)
 664                 #elif frontendData["tuner_type"] == "DVB-T":
 665                         #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
 666                                            #("Type", frontendData["tuner_type"], TYPE_TEXT),
 667                                            #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
 668                                            #("Inversion", frontendData["inversion"], TYPE_TEXT),
 669                                            #("Bandwidth", frontendData["bandwidth"], TYPE_VALUE_DEC),
 670                                            #("CodeRateLP", frontendData["code_rate_lp"], TYPE_TEXT),
 671                                            #("CodeRateHP", frontendData["code_rate_hp"], TYPE_TEXT),
 672                                            #("Constellation", frontendData["constellation"], TYPE_TEXT),
 673                                            #("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT),
 674                                            #("Guard Interval", frontendData["guard_interval"], TYPE_TEXT),
 675                                            #("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT),
 676                         defaultSat = {
 677                                 "orbpos": 192,
 678                                 "system": eDVBFrontendParametersSatellite.System_DVB_S,
 679                                 "frequency": 11836,
 680                                 "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
 681                                 "symbolrate": 27500,
 682                                 "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
 683                                 "fec": eDVBFrontendParametersSatellite.FEC_Auto,
 684                                 "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
 685                                 "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK }
 686                         defaultCab = {
 687                                 "frequency": 466,
 688                                 "inversion": eDVBFrontendParametersCable.Inversion_Unknown,
 689                                 "modulation": eDVBFrontendParametersCable.Modulation_QAM64,
 690                                 "fec": eDVBFrontendParametersCable.FEC_Auto,
 691                                 "symbolrate": 6900 }
 692                         defaultTer = {
 693                                 "frequency" : 466000,
 694                                 "inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown,
 695                                 "bandwidth" : eDVBFrontendParametersTerrestrial.Bandwidth_7MHz,
 696                                 "fechigh" : eDVBFrontendParametersTerrestrial.FEC_Auto,
 697                                 "feclow" : eDVBFrontendParametersTerrestrial.FEC_Auto,
 698                                 "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto,
 699                                 "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto,
 700                                 "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto,
 701                                 "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto,
 702                                 "system": eDVBFrontendParametersTerrestrial.System_DVB_T,
 703                                 "plp_id": 0 }
 704
 705                         if frontendData is not None:
 706                                 ttype = frontendData.get("tuner_type", "UNKNOWN")
 707                                 if ttype == "DVB-S":
 708                                         defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
 709                                         defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
 710                                         defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
 711                                         defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
 712                                         defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
 713                                         if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
 714                                                 defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
 715                                                 defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
 716                                                 defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
 717                                         else:
 718                                                 defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
 719                                         defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
 720                                         defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
 721                                 elif ttype == "DVB-C":
 722                                         defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
 723                                         defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
 724                                         defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown)
 725                                         defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto)
 726                                         defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16)
 727                                 elif ttype == "DVB-T":
 728                                         defaultTer["frequency"] = frontendData.get("frequency", 0) / 1000
 729                                         defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown)
 730                                         defaultTer["bandwidth"] = frontendData.get("bandwidth", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz)
 731                                         defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto)
 732                                         defaultTer["feclow"] = frontendData.get("code_rate_lp", eDVBFrontendParametersTerrestrial.FEC_Auto)
 733                                         defaultTer["modulation"] = frontendData.get("constellation", eDVBFrontendParametersTerrestrial.Modulation_Auto)
 734                                         defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto)
 735                                         defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto)
 736                                         defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto)
 737                                         defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersTerrestrial.System_DVB_T)
 738                                         defaultTer["plp_id"] = frontendData.get("plp_id", 0)
 739
 740                         self.scan_sat = ConfigSubsection()
 741                         self.scan_cab = ConfigSubsection()
 742                         self.scan_ter = ConfigSubsection()
 743
 744                         self.scan_type = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat")), ("multisat_yes", _("Multisat"))])
 745                         self.scan_typecable = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
 746                         self.scan_typeterrestrial = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
 747                         self.scan_clearallservices = ConfigSelection(default = "no", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))])
 748                         self.scan_onlyfree = ConfigYesNo(default = False)
 749                         self.scan_networkScan = ConfigYesNo(default = False)
 750
 751                         nim_list = []
 752                         # collect all nims which are *not* set to "nothing"
 753                         for n in nimmanager.nim_slots:
 754                                 if n.config_mode == "nothing":
 755                                         continue
 756                                 if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1:
 757                                         continue
 758                                 if n.config_mode in ("loopthrough", "satposdepends"):
 759                                         root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.value))
 760                                         if n.type == nimmanager.nim_slots[root_id].type: # check if connected from a DVB-S to DVB-S2 Nim or vice versa
 761                                                 continue
 762                                 nim_list.append((str(n.slot), n.friendly_full_description))
 763
 764                         self.scan_nims = ConfigSelection(choices = nim_list)
 765
 766                         # status
 767                         self.scan_snr = ConfigSlider()
 768                         self.scan_snr.enabled = False
 769                         self.scan_agc = ConfigSlider()
 770                         self.scan_agc.enabled = False
 771                         self.scan_ber = ConfigSlider()
 772                         self.scan_ber.enabled = False
 773
 774                         # sat
 775                         self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [
 776                                 (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
 777                                 (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))])
 778                         self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
 779                         self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
 780                                 (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
 781                                 (eDVBFrontendParametersSatellite.Inversion_On, _("On")),
 782                                 (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))])
 783                         self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999))
 784                         self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
 785                                 (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")),
 786                                 (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")),
 787                                 (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")),
 788                                 (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))])
 789                         self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [
 790                                 (eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")),
 791                                 (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
 792                                 (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
 793                                 (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
 794                                 (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
 795                                 (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
 796                                 (eDVBFrontendParametersSatellite.FEC_None, _("None"))])
 797                         self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [
 798                                 (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
 799                                 (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
 800                                 (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
 801                                 (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
 802                                 (eDVBFrontendParametersSatellite.FEC_4_5, "4/5"),
 803                                 (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
 804                                 (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
 805                                 (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
 806                                 (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
 807                         self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
 808                                 (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
 809                                 (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
 810                         self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
 811                                 (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
 812                                 (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
 813                                 (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20")])
 814                         self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [
 815                                 (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
 816                                 (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
 817                                 (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
 818
 819                         # cable
 820                         self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
 821                         self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [
 822                                 (eDVBFrontendParametersCable.Inversion_Off, _("Off")),
 823                                 (eDVBFrontendParametersCable.Inversion_On, _("On")),
 824                                 (eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))])
 825                         self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [
 826                                 (eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"),
 827                                 (eDVBFrontendParametersCable.Modulation_QAM32, "32-QAM"),
 828                                 (eDVBFrontendParametersCable.Modulation_QAM64, "64-QAM"),
 829                                 (eDVBFrontendParametersCable.Modulation_QAM128, "128-QAM"),
 830                                 (eDVBFrontendParametersCable.Modulation_QAM256, "256-QAM")])
 831                         self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [
 832                                 (eDVBFrontendParametersCable.FEC_Auto, _("Auto")),
 833                                 (eDVBFrontendParametersCable.FEC_1_2, "1/2"),
 834                                 (eDVBFrontendParametersCable.FEC_2_3, "2/3"),
 835                                 (eDVBFrontendParametersCable.FEC_3_4, "3/4"),
 836                                 (eDVBFrontendParametersCable.FEC_5_6, "5/6"),
 837                                 (eDVBFrontendParametersCable.FEC_7_8, "7/8"),
 838                                 (eDVBFrontendParametersCable.FEC_8_9, "8/9"),
 839                                 (eDVBFrontendParametersCable.FEC_None, _("None"))])
 840                         self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999))
 841
 842                         # terrestial
 843                         self.scan_ter.frequency = ConfigInteger(default = defaultTer["frequency"], limits = (50000, 999000))
 844                         self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [
 845                                 (eDVBFrontendParametersTerrestrial.Inversion_Off, _("Off")),
 846                                 (eDVBFrontendParametersTerrestrial.Inversion_On, _("On")),
 847                                 (eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))])
 848                         # WORKAROUND: we can't use BW-auto
 849                         self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [
 850                                 (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"),
 851                                 (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"),
 852                                 (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")])
 853                         self.scan_ter.bandwidth_t2 = ConfigSelection(default = defaultTer["bandwidth"], choices = [
 854                                 (eDVBFrontendParametersTerrestrial.Bandwidth_10MHz, "10MHz"),
 855                                 (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"),
 856                                 (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"),
 857                                 (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz"),
 858                                 (eDVBFrontendParametersTerrestrial.Bandwidth_5MHz, "5MHz"),
 859                                 (eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz, "1.712MHz")])
 860                         #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto"))))
 861                         self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [
 862                                 (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
 863                                 (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
 864                                 (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
 865                                 (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
 866                                 (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
 867                                 (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
 868                         self.scan_ter.fechigh_t2 = ConfigSelection(default = defaultTer["fechigh"], choices = [
 869                                 (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
 870                                 (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
 871                                 (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
 872                                 (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
 873                                 (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"),
 874                                 (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
 875                                 (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"),
 876                                 (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
 877                         self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [
 878                                 (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
 879                                 (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
 880                                 (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
 881                                 (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
 882                                 (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
 883                                 (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
 884                         self.scan_ter.feclow_t2 = ConfigSelection(default = defaultTer["feclow"], choices = [
 885                                 (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
 886                                 (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
 887                                 (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
 888                                 (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
 889                                 (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"),
 890                                 (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
 891                                 (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"),
 892                                 (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
 893                         self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [
 894                                 (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"),
 895                                 (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"),
 896                                 (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"),
 897                                 (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))])
 898                         self.scan_ter.modulation_t2 = ConfigSelection(default = defaultTer["modulation"], choices = [
 899                                 (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"),
 900                                 (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"),
 901                                 (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"),
 902                                 (eDVBFrontendParametersTerrestrial.Modulation_QAM256, "QAM256"),
 903                                 (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))])
 904                         self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [
 905                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"),
 906                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"),
 907                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))])
 908                         self.scan_ter.transmission_t2 = ConfigSelection(default = defaultTer["transmission_mode"], choices = [
 909                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_1k, "1K"),
 910                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"),
 911                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_4k, "4K"),
 912                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"),
 913                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_16k, "16K"),
 914                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_32k, "32K"),
 915                                 (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))])
 916                         self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [
 917                                 (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"),
 918                                 (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"),
 919                                 (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"),
 920                                 (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"),
 921                                 (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))])
 922                         self.scan_ter.guard_t2 = ConfigSelection(default = defaultTer["guard_interval"], choices = [
 923                                 (eDVBFrontendParametersTerrestrial.GuardInterval_19_256, "19/256"),
 924                                 (eDVBFrontendParametersTerrestrial.GuardInterval_19_128, "19/128"),
 925                                 (eDVBFrontendParametersTerrestrial.GuardInterval_1_128, "1/128"),
 926                                 (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"),
 927                                 (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"),
 928                                 (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"),
 929                                 (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"),
 930                                 (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))])
 931                         self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [
 932                                 (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")),
 933                                 (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"),
 934                                 (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"),
 935                                 (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"),
 936                                 (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))])
 937                         self.scan_ter.system = ConfigSelection(default = defaultTer["system"], choices = [
 938                                 (eDVBFrontendParametersTerrestrial.System_DVB_T, _("DVB-T")),
 939                                 (eDVBFrontendParametersTerrestrial.System_DVB_T2, _("DVB-T2"))])
 940                         self.scan_ter.plp_id = ConfigInteger(default = defaultTer["plp_id"], limits = (0, 255))
 941
 942                         self.scan_scansat = {}
 943                         for sat in nimmanager.satList:
 944                                 #print sat[1]
 945                                 self.scan_scansat[sat[0]] = ConfigYesNo(default = False)
 946
 947                         self.scan_satselection = []
 948                         for slot in nimmanager.nim_slots:
 949                                 if slot.isCompatible("DVB-S"):
 950                                         self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot]))
 951                                 else:
 952                                         self.scan_satselection.append(None)
 953
 954                         return True
 955
 956         def keyLeft(self):
 957                 ConfigListScreen.keyLeft(self)
 958                 self.newConfig()
 959
 960         def keyRight(self):
 961                 ConfigListScreen.keyRight(self)
 962                 self.newConfig()
 963
 964         def updateStatus(self):
 965                 print "updatestatus"
 966
 967         def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot):
 968                 print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot)
 969                 print "orbpos: " + str(orbital_position)
 970                 parm = eDVBFrontendParametersSatellite()
 971                 parm.modulation = modulation
 972                 parm.system = system
 973                 parm.frequency = frequency * 1000
 974                 parm.symbol_rate = symbol_rate * 1000
 975                 parm.polarisation = polarisation
 976                 parm.fec = fec
 977                 parm.inversion = inversion
 978                 parm.orbital_position = orbital_position
 979                 parm.rolloff = rolloff
 980                 parm.pilot = pilot
 981                 tlist.append(parm)
 982
 983         def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):
 984                 print "Add Cab: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(modulation) + " fec: " + str(fec) + " inversion: " + str(inversion)
 985                 parm = eDVBFrontendParametersCable()
 986                 parm.frequency = frequency * 1000
 987                 parm.symbol_rate = symbol_rate * 1000
 988                 parm.modulation = modulation
 989                 parm.fec = fec
 990                 parm.inversion = inversion
 991                 tlist.append(parm)
 992
 993         def addTerTransponder(self, tlist, *args, **kwargs):
 994                 tlist.append(buildTerTransponder(*args, **kwargs))
 995
 996         def keyGo(self):
 997                 START_SCAN =0
 998                 SEARCH_CABLE_TRANSPONDERS = 1
 999                 SEARCH_TERRESTRIAL2_TRANSPONDERS = 2
1000
1001                 if self.scan_nims.value == "":
1002                         return
1003                 tlist = []
1004                 flags = None
1005                 action = START_SCAN
1006                 removeAll = True
1007                 index_to_scan = int(self.scan_nims.value)
1008
1009                 if self.scan_nims == [ ]:
1010                         self.session.open(MessageBox, _("No tuner is enabled!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
1011                         return
1012
1013                 nim = nimmanager.nim_slots[index_to_scan]
1014                 print "nim", nim.slot
1015                 if nim.isCompatible("DVB-S"):
1016                         print "is compatible with DVB-S"
1017                         if self.scan_type.value == "single_transponder":
1018                                 # these lists are generated for each tuner, so this has work.
1019                                 assert len(self.satList) > index_to_scan
1020                                 assert len(self.scan_satselection) > index_to_scan
1021
1022                                 nimsats = self.satList[index_to_scan]
1023                                 selsatidx = self.scan_satselection[index_to_scan].index
1024
1025                                 # however, the satList itself could be empty. in that case, "index" is 0 (for "None").
1026                                 if len(nimsats):
1027                                         orbpos = nimsats[selsatidx][0]
1028                                         if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
1029                                                 fec = self.scan_sat.fec.value
1030                                         else:
1031                                                 fec = self.scan_sat.fec_s2.value
1032                                         print "add sat transponder"
1033                                         self.addSatTransponder(tlist, self.scan_sat.frequency.value,
1034                                                                 self.scan_sat.symbolrate.value,
1035                                                                 self.scan_sat.polarization.value,
1036                                                                 fec,
1037                                                                 self.scan_sat.inversion.value,
1038                                                                 orbpos,
1039                                                                 self.scan_sat.system.value,
1040                                                                 self.scan_sat.modulation.value,
1041                                                                 self.scan_sat.rolloff.value,
1042                                                                 self.scan_sat.pilot.value)
1043                                 removeAll = False
1044                         elif self.scan_type.value == "single_satellite":
1045                                 sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
1046                                 getInitialTransponderList(tlist, sat[0])
1047                         elif self.scan_type.value.find("multisat") != -1:
1048                                 SatList = nimmanager.getSatListForNim(index_to_scan)
1049                                 for x in self.multiscanlist:
1050                                         if x[1].value:
1051                                                 print "   " + str(x[0])
1052                                                 getInitialTransponderList(tlist, x[0])
1053
1054                 elif nim.isCompatible("DVB-C"):
1055                         if self.scan_typecable.value == "single_transponder":
1056                                 self.addCabTransponder(tlist, self.scan_cab.frequency.value,
1057                                                                                           self.scan_cab.symbolrate.value,
1058                                                                                           self.scan_cab.modulation.value,
1059                                                                                           self.scan_cab.fec.value,
1060                                                                                           self.scan_cab.inversion.value)
1061                                 removeAll = False
1062                         elif self.scan_typecable.value == "complete":
1063                                 if config.Nims[index_to_scan].cable.scan_type.value == "provider":
1064                                         getInitialCableTransponderList(tlist, index_to_scan)
1065                                 else:
1066                                         action = SEARCH_CABLE_TRANSPONDERS
1067
1068                 elif nim.isCompatible("DVB-T"):
1069                         if self.scan_typeterrestrial.value == "single_transponder":
1070                                 if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T:
1071                                         self.addTerTransponder(tlist,
1072                                                         self.scan_ter.frequency.value * 1000,
1073                                                         inversion = self.scan_ter.inversion.value,
1074                                                         bandwidth = self.scan_ter.bandwidth.value,
1075                                                         fechigh = self.scan_ter.fechigh.value,
1076                                                         feclow = self.scan_ter.feclow.value,
1077                                                         modulation = self.scan_ter.modulation.value,
1078                                                         transmission = self.scan_ter.transmission.value,
1079                                                         guard = self.scan_ter.guard.value,
1080                                                         hierarchy = self.scan_ter.hierarchy.value,
1081                                                         system = self.scan_ter.system.value,
1082                                                         plpid = self.scan_ter.plp_id.value)
1083                                 else:
1084                                         self.addTerTransponder(tlist,
1085                                                         self.scan_ter.frequency.value * 1000,
1086                                                         inversion = self.scan_ter.inversion.value,
1087                                                         bandwidth = self.scan_ter.bandwidth_t2.value,
1088                                                         fechigh = self.scan_ter.fechigh_t2.value,
1089                                                         feclow = self.scan_ter.feclow_t2.value,
1090                                                         modulation = self.scan_ter.modulation_t2.value,
1091                                                         transmission = self.scan_ter.transmission_t2.value,
1092                                                         guard = self.scan_ter.guard_t2.value,
1093                                                         hierarchy = self.scan_ter.hierarchy.value,
1094                                                         system = self.scan_ter.system.value,
1095                                                         plpid = self.scan_ter.plp_id.value)
1096                                 removeAll = False
1097                         elif self.scan_typeterrestrial.value == "complete":
1098                                 getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan))
1099                                 if nim.isCompatible("DVB-T2"):
1100                                         action = SEARCH_TERRESTRIAL2_TRANSPONDERS
1101
1102                 flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0
1103
1104                 tmp = self.scan_clearallservices.value
1105                 if tmp == "yes":
1106                         flags |= eComponentScan.scanRemoveServices
1107                 elif tmp == "yes_hold_feeds":
1108                         flags |= eComponentScan.scanRemoveServices
1109                         flags |= eComponentScan.scanDontRemoveFeeds
1110
1111                 if tmp != "no" and not removeAll:
1112                         flags |= eComponentScan.scanDontRemoveUnscanned
1113
1114                 if self.scan_onlyfree.value:
1115                         flags |= eComponentScan.scanOnlyFree
1116
1117                 for x in self["config"].list:
1118                         x[1].save()
1119
1120                 if action == START_SCAN:
1121                         self.startScan(tlist, flags, index_to_scan)
1122                 elif action == SEARCH_CABLE_TRANSPONDERS:
1123                         self.flags = flags
1124                         self.feid = index_to_scan
1125                         self.tlist = []
1126                         self.startCableTransponderSearch(self.feid)
1127                 elif action == SEARCH_TERRESTRIAL2_TRANSPONDERS:
1128                         self.flags = flags
1129                         self.feid = index_to_scan
1130                         self.tlist = tlist
1131                         self.startTerrestrialTransponderSearch(self.feid, nimmanager.getTerrestrialDescription(self.feid))
1132
1133         def setCableTransponderSearchResult(self, tlist):
1134                 self.tlist = tlist
1135
1136         def cableTransponderSearchFinished(self):
1137                 if self.tlist is None:
1138                         self.tlist = []
1139                 else:
1140                         self.startScan(self.tlist, self.flags, self.feid)
1141
1142         def setTerrestrialTransponderSearchResult(self, tlist):
1143                 if tlist is not None:
1144                         self.tlist.extend(tlist)
1145
1146         def terrestrialTransponderSearchFinished(self):
1147                 if self.tlist is None:
1148                         self.tlist = []
1149                 else:
1150                         self.startScan(self.tlist, self.flags, self.feid)
1151
1152         def startScan(self, tlist, flags, feid):
1153                 if len(tlist):
1154                         # flags |= eComponentScan.scanSearchBAT
1155                         if self.finished_cb:
1156                                 self.session.openWithCallback(self.finished_cb, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags}])
1157                         else:
1158                                 self.session.open(ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags}])
1159                 else:
1160                         if self.finished_cb:
1161                                 self.session.openWithCallback(self.finished_cb, MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
1162                         else:
1163                                 self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
1164
1165         def keyCancel(self):
1166                 for x in self["config"].list:
1167                         x[1].cancel()
1168                 self.close()
1169
1170 class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport, TerrestrialTransponderSearchSupport):
1171         def getNetworksForNim(self, nim):
1172                 if nim.isCompatible("DVB-S"):
1173                         networks = nimmanager.getSatListForNim(nim.slot)
1174                 elif not nim.empty:
1175                         networks = [ nim.type ] # "DVB-C" or "DVB-T". TODO: seperate networks for different C/T tuners, if we want to support that.
1176                 else:
1177                         # empty tuners provide no networks.
1178                         networks = [ ]
1179                 return networks
1180
1181         def __init__(self, session):
1182                 Screen.__init__(self, session)
1183
1184                 self["actions"] = ActionMap(["SetupActions"],
1185                 {
1186                         "ok": self.keyGo,
1187                         "cancel": self.keyCancel,
1188                 }, -2)
1189
1190                 self.list = []
1191                 tlist = []
1192
1193                 known_networks = [ ]
1194                 nims_to_scan = [ ]
1195                 self.finished_cb = None
1196
1197                 for nim in nimmanager.nim_slots:
1198                         # collect networks provided by this tuner
1199
1200                         need_scan = False
1201                         networks = self.getNetworksForNim(nim)
1202
1203                         print "nim %d provides" % nim.slot, networks
1204                         print "known:", known_networks
1205
1206                         # we only need to scan on the first tuner which provides a network.
1207                         # this gives the first tuner for each network priority for scanning.
1208                         for x in networks:
1209                                 if x not in known_networks:
1210                                         need_scan = True
1211                                         print x, "not in ", known_networks
1212                                         known_networks.append(x)
1213
1214                         # don't offer to scan nims if nothing is connected
1215                         if not nimmanager.somethingConnected(nim.slot):
1216                                 need_scan = False
1217
1218                         if need_scan:
1219                                 nims_to_scan.append(nim)
1220
1221
1222                 if "DVB-T2" in known_networks: # we need to remove "DVB-T" when networks have "DVB-T2"
1223                         nims_dvb_t = []
1224                         for nim in nims_to_scan:
1225                                 if nim.type == "DVB-T":
1226                                         nims_dvb_t.append(nim)
1227
1228                         for nim in nims_dvb_t:
1229                                 nims_to_scan.remove(nim)
1230
1231                 # we save the config elements to use them on keyGo
1232                 self.nim_enable = [ ]
1233
1234                 if len(nims_to_scan):
1235                         self.scan_clearallservices = ConfigSelection(default = "yes", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))])
1236                         self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
1237
1238                         for nim in nims_to_scan:
1239                                 nimconfig = ConfigYesNo(default = True)
1240                                 nimconfig.nim_index = nim.slot
1241                                 self.nim_enable.append(nimconfig)
1242                                 self.list.append(getConfigListEntry(_("Scan ") + nim.slot_name + " (" + nim.friendly_type + ")", nimconfig))
1243
1244                 ConfigListScreen.__init__(self, self.list)
1245                 self["header"] = Label(_("Automatic Scan"))
1246                 self["footer"] = Label(_("Press OK to scan"))
1247
1248         def runAsync(self, finished_cb):
1249                 self.finished_cb = finished_cb
1250                 self.keyGo()
1251
1252         def keyGo(self):
1253                 self.scanList = []
1254                 self.known_networks = set()
1255                 self.nim_iter=0
1256                 self.buildTransponderList()
1257
1258         def buildTransponderList(self): # this method is called multiple times because of asynchronous stuff
1259                 APPEND_NOW = 0
1260                 SEARCH_CABLE_TRANSPONDERS = 1
1261                 SEARCH_TERRESTRIAL2_TRANSPONDERS = 2
1262                 action = APPEND_NOW
1263
1264                 n = self.nim_iter < len(self.nim_enable) and self.nim_enable[self.nim_iter] or None
1265                 self.nim_iter += 1
1266                 if n:
1267                         if n.value: # check if nim is enabled
1268                                 flags = 0
1269                                 nim = nimmanager.nim_slots[n.nim_index]
1270                                 networks = set(self.getNetworksForNim(nim))
1271
1272                                 # don't scan anything twice
1273                                 networks.discard(self.known_networks)
1274
1275                                 tlist = [ ]
1276                                 if nim.isCompatible("DVB-S"):
1277                                         # get initial transponders for each satellite to be scanned
1278                                         for sat in networks:
1279                                                 getInitialTransponderList(tlist, sat[0])
1280                                 elif nim.isCompatible("DVB-C"):
1281                                         if config.Nims[nim.slot].cable.scan_type.value == "provider":
1282                                                 getInitialCableTransponderList(tlist, nim.slot)
1283                                         else:
1284                                                 action = SEARCH_CABLE_TRANSPONDERS
1285                                 elif nim.isCompatible("DVB-T"):
1286                                         getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(nim.slot))
1287                                         if nim.isCompatible("DVB-T2"):
1288                                                 action = SEARCH_TERRESTRIAL2_TRANSPONDERS
1289                                 else:
1290                                         assert False
1291
1292                                 flags |= eComponentScan.scanNetworkSearch #FIXMEEE.. use flags from cables / satellites / terrestrial.xml
1293                                 tmp = self.scan_clearallservices.value
1294                                 if tmp == "yes":
1295                                         flags |= eComponentScan.scanRemoveServices
1296                                 elif tmp == "yes_hold_feeds":
1297                                         flags |= eComponentScan.scanRemoveServices
1298                                         flags |= eComponentScan.scanDontRemoveFeeds
1299
1300                                 if action == APPEND_NOW:
1301                                         self.scanList.append({"transponders": tlist, "feid": nim.slot, "flags": flags})
1302                                 elif action == SEARCH_CABLE_TRANSPONDERS:
1303                                         self.flags = flags
1304                                         self.feid = nim.slot
1305                                         self.startCableTransponderSearch(nim.slot)
1306                                         return
1307                                 elif action == SEARCH_TERRESTRIAL2_TRANSPONDERS:
1308                                         self.tlist = tlist
1309                                         self.flags = flags
1310                                         self.feid = nim.slot
1311                                         self.startTerrestrialTransponderSearch(nim.slot, nimmanager.getTerrestrialDescription(nim.slot))
1312                                         return
1313                                 else:
1314                                         assert False
1315
1316                         self.buildTransponderList() # recursive call of this function !!!
1317                         return
1318                 # when we are here, then the recursion is finished and all enabled nims are checked
1319                 # so we now start the real transponder scan
1320                 self.startScan(self.scanList)
1321
1322         def startScan(self, scanList):
1323                 if len(scanList):
1324                         if self.finished_cb:
1325                                 self.session.openWithCallback(self.finished_cb, ServiceScan, scanList = scanList)
1326                         else:
1327                                 self.session.open(ServiceScan, scanList = scanList)
1328                 else:
1329                         if self.finished_cb:
1330                                 self.session.openWithCallback(self.finished_cb, MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
1331                         else:
1332                                 self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
1333
1334         def setCableTransponderSearchResult(self, tlist):
1335                 if tlist is not None:
1336                         self.scanList.append({"transponders": tlist, "feid": self.feid, "flags": self.flags})
1337
1338         def cableTransponderSearchFinished(self):
1339                 self.buildTransponderList()
1340
1341         def setTerrestrialTransponderSearchResult(self, tlist):
1342                 if tlist is not None:
1343                         self.tlist.extend(tlist)
1344                 if self.tlist is not None:
1345                         self.scanList.append({"transponders": self.tlist, "feid": self.feid, "flags": self.flags})
1346
1347         def terrestrialTransponderSearchFinished(self):
1348                 self.buildTransponderList()
1349
1350         def keyCancel(self):
1351                 self.close()
1352
1353         def Satexists(self, tlist, pos):
1354                 for x in tlist:
1355                         if x == pos:
1356                                 return 1
1357                 return 0
1358