code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Plugins/SystemPlugins/FactoryTest/plugin.py

   1 from Screens.Screen import Screen
   2 from Screens.MessageBox import MessageBox
   3 from Plugins.Plugin import PluginDescriptor
   4 from Components.MenuList import MenuList
   5 from Tools.Directories import fileExists
   6 from Components.ServiceList import ServiceList
   7 from Components.ActionMap import ActionMap,NumberActionMap
   8 from Components.config import config
   9 from os import system,access,F_OK,R_OK,W_OK
  10 from Components.Label import Label
  11 from Components.AVSwitch import AVSwitch
  12 from time import sleep
  13 from Components.Console import Console
  14 from enigma import eTimer
  15 from Components.HTMLComponent import HTMLComponent
  16 from Components.GUIComponent import GUIComponent
  17 from enigma import eListboxPythonStringContent, eListbox, gFont, eServiceCenter, eDVBResourceManager
  18 from enigma import eServiceReference
  19 from sctest import eSctest
  20 from enigma import eDVBDB
  21 from Components.NimManager import nimmanager
  22 from enigma import eDVBCI_UI,eDVBCIInterfaces
  23 from Tools.Directories import resolveFilename, SCOPE_SYSETC
  24 from Components.Sources.StaticText import StaticText
  25
  26 class TestResultList(MenuList):
  27         def postWidgetCreate(self, instance):
  28                 self.instance.setSelectionEnable(0)
  29                 instance.setContent(self.l)
  30                 instance.selectionChanged.get().append(self.selectionChanged)
  31                 if self.enableWrapAround:
  32                         self.instance.setWrapAround(True)
  33
  34         def updateList(self, list):
  35                 self.list = list
  36                 self.l.setList(self.list)
  37
  38 class TuneMessageBox(MessageBox):
  39         skin = """
  40                 <screen position="center,center" size="600,10" title="Message">
  41                         <widget name="text" position="65,8" size="420,0" font="Regular;22" />
  42                         <widget name="ErrorPixmap" pixmap="Vu_HD/icons/input_error.png" position="5,5" size="53,53" alphatest="blend" />
  43                         <widget name="QuestionPixmap" pixmap="Vu_HD/icons/input_question.png" position="5,5" size="53,53" alphatest="blend" />
  44                         <widget name="InfoPixmap" pixmap="Vu_HD/icons/input_info.png" position="5,5" size="53,53" alphatest="blend" />
  45                         <widget name="list" position="100,100" size="380,375" transparent="1" backgroundColor="darkgrey" />
  46                         <!-- Signal Quality -->
  47                         <eLabel text="SNR : " position="60,130" size="60,25" font="Regular;25" transparent="1" />
  48                         <widget source="session.FrontendStatus" render="Label" position="120,130" size="60,25" font="Regular;25"  transparent="1">
  49                                 <convert type="FrontendInfo">SNRdB</convert>
  50                         </widget>
  51                         <!-- AGC -->
  52                         <eLabel text="AGC : " position="200,130" size="60,25" font="Regular;25"  transparent="1" noWrap="1" />
  53                         <widget source="session.FrontendStatus" render="Label" position="260,130" size="60,25" font="Regular;25"  transparent="1" noWrap="1">
  54                                 <convert type="FrontendInfo">AGC</convert>
  55                         </widget>
  56                         <applet type="onLayoutFinish">
  57 # this should be factored out into some helper code, but currently demonstrates applets.
  58 from enigma import eSize, ePoint
  59
  60 orgwidth = self.instance.size().width()
  61 orgpos = self.instance.position()
  62 textsize = self[&quot;text&quot;].getSize()
  63
  64 # y size still must be fixed in font stuff...
  65 textsize = (textsize[0] + 50, textsize[1] + 50)
  66 offset = 0
  67 if self.type == self.TYPE_YESNO:
  68         offset = 60
  69 wsizex = textsize[0] + 60
  70 wsizey = textsize[1] + offset
  71 if (280 &gt; wsizex):
  72         wsizex = 280
  73 wsizex = wsizex + 30
  74 wsizey = wsizey + 30
  75 wsize = (wsizex, wsizey)
  76
  77 # resize
  78 self.instance.resize(eSize(*wsize))
  79
  80 # resize label
  81 self[&quot;text&quot;].instance.resize(eSize(*textsize))
  82
  83 # move list
  84 listsize = (wsizex, 50)
  85 self[&quot;list&quot;].instance.move(ePoint(0, textsize[1]))
  86 self[&quot;list&quot;].instance.resize(eSize(*listsize))
  87
  88 # center window
  89 newwidth = wsize[0]
  90 self.instance.move(ePoint(orgpos.x() + (orgwidth - newwidth)/2, orgpos.y()))
  91                         </applet>
  92                 </screen>"""
  93         def __init__(self, session, text, type = MessageBox.TYPE_YESNO):
  94                 MessageBox.__init__(self, session, text, type)
  95
  96 class FactoryTestSummary(Screen):
  97         skin = """
  98         <screen name="FactoryTestSummary" position="0,0" size="132,64" id="1">
  99                 <widget source="parent.Title" render="Label" position="6,0" size="132,64" font="Regular;18" halign="center" valign="center"/>
 100         </screen>"""
 101
 102 class FactoryTestSummary_VFD(Screen):
 103         skin = """
 104         <screen name="FactoryTestSummary" position="0,0" size="256,64" id="1">
 105                 <widget source="parent.Title" render="Label" position="0,0" size="256,64" font="VFD;24" halign="center" valign="center"/>
 106         </screen>"""
 107
 108 class FactoryTest(Screen):
 109         skin = """
 110                 <screen name="FactoryTest" position="300,100" size="660,550" title="Test Menu" >
 111                         <widget name="testlist" position="10,0" size="440,455" itemHeight="35" />
 112                         <widget name="resultlist" position="470,0" size="60,455" itemHeight="35" />
 113                         <widget name="testdate" position="20,470" size="250,35" font="Regular;30" />
 114                         <widget name="testversion" position="20,505" size="250,35" font="Regular;30" />
 115                         <widget name="mactext" position="320,470" size="340,35" font="Regular;30" />
 116                 </screen>"""
 117
 118         def createSummary(self):
 119                 if self.model == 4:
 120                         return FactoryTestSummary_VFD
 121                 else:
 122                         return FactoryTestSummary
 123
 124         def __init__(self, session):
 125
 126                 self["actions"] = NumberActionMap(["OkCancelActions","WizardActions","NumberActions","ColorActions",],
 127                 {
 128                         "left": self.nothing,
 129                         "right":self.nothing,
 130                         "ok": self.TestAction,
 131                         "testexit": self.keyCancel,
 132                         "agingstart": self.Agingmode,
 133                         "up": self.keyup,
 134                         "down": self.keydown,
 135                         "0": self.numberaction,
 136                         "1": self.numberaction,
 137                         "2": self.numberaction,
 138                         "3": self.numberaction,
 139                         "4": self.numberaction,
 140                         "5": self.numberaction,
 141                         "6": self.numberaction,
 142                         "7": self.numberaction,
 143                         "8": self.numberaction,
 144                         "9": self.numberaction,
 145                         "red": self.shutdownaction,
 146                         "blue": self.Agingmode2,
 147                 }, -2)
 148
 149                 Screen.__init__(self, session)
 150                 TESTPROGRAM_DATE = self.getImageVersion() +" (v1.20)"
 151                 TESTPROGRAM_VERSION = "Version 01.20"
 152
 153                 self.model = 0
 154                 self.getModelInfo()
 155
 156                 self["testdate"]=Label((TESTPROGRAM_DATE))
 157                 self["testversion"]=Label(("Loading version..."))
 158                 self["mactext"]=Label(("Loading mac address..."))
 159                 if self.model == 0 or self.model == 1:
 160                         nimConfig = nimmanager.getNimConfig(0)
 161                         nimConfig.configMode.slot_id=0
 162                         nimConfig.configMode.value= "simple"
 163                         nimConfig.diseqcMode.value="diseqc_a_b"
 164                         nimConfig.diseqcA.value="160"
 165                         nimConfig.diseqcB.value="100"
 166                 if self.model == 0:
 167                         nimConfig = nimmanager.getNimConfig(1)
 168                         nimConfig.configMode.slot_id=1
 169                         nimConfig.configMode.value= "simple"
 170                         nimConfig.diseqcMode.value="diseqc_a_b"
 171                         nimConfig.diseqcA.value="130"
 172                         nimConfig.diseqcB.value="192"
 173                 if self.model == 2:
 174                         pass
 175                 if self.model == 3 or self.model == 4:
 176                         self.NimType = {}
 177                         sat_list = ["160","100","130","192","620","642","685","720"]
 178 #                                       ' sat ' : namespace , # satname
 179 #                                       '160' : '0xA00000', # Eutelsat W2
 180 #                                       '100' : '0x64af79', # Eutelsat
 181 #                                       '130' : '0x820000', # Hotbird
 182 #                                       '192' : '0xC00000', # Astra
 183 #                                       '620' : '0x26c0000', # Intelsat 902
 184 #                                       '642' : '0x282AF79' # Intelsat 906
 185 #                                       '685' : '02ad0000' # Panamsat 7,10 (68.5E)
 186 #                                       '720' : '02d0af79' # Panamsat 4 (72.0E)
 187                         try:
 188                                 nimfile = open("/proc/bus/nim_sockets")
 189                         except IOError:
 190                                 nimfile = None
 191                         if nimfile is None:
 192                                 self.session.openWithCallback(self.close, MessageBox, _("File not Found!\n/proc/bus/nim_sockets"), MessageBox.TYPE_ERROR)
 193                         for line in nimfile.readlines():
 194                                 print line
 195                                 if line == "":
 196                                         break
 197                                 if line.strip().startswith("NIM Socket"):
 198                                         parts = line.strip().split(" ")
 199                                         current_slot = int(parts[2][:-1])
 200                                         self.NimType[current_slot]={}
 201                                         self.NimType[current_slot]["slot"] = current_slot
 202                                 elif line.strip().startswith("Type:"):
 203                                         print str(line.strip())
 204                                         self.NimType[current_slot]["type"] = str(line.strip()[6:])
 205                                         if self.NimType[current_slot]["type"].startswith("DVB-S"):
 206                                                 self.NimType[current_slot]["sat1"] = sat_list.pop(0)
 207                                                 self.NimType[current_slot]["sat2"] = sat_list.pop(0)
 208                                         else:
 209                                                 self.NimType[current_slot]["sat1"] = None
 210                                                 self.NimType[current_slot]["sat2"] = None
 211                                 elif line.strip().startswith("empty"):
 212                                         self.NimType.pop(current_slot)
 213                         nimfile.close()
 214                         if True:
 215                                 for (key, val) in self.NimType.items():
 216                                         print key
 217                                         print val
 218                                         if val["type"].startswith("DVB-S"):
 219                                                 print "nimConfig (dvb-s): ",key
 220                                                 nimConfig = nimmanager.getNimConfig(key)
 221                                                 nimConfig.configMode.slot_id=key
 222                                                 nimConfig.configMode.value= "simple"
 223                                                 nimConfig.diseqcMode.value="diseqc_a_b"
 224                                                 nimConfig.diseqcA.value = val["sat1"]
 225                                                 nimConfig.diseqcB.value = val["sat2"]
 226                                         else :
 227                                                 nimConfig = nimmanager.getNimConfig(key)
 228                                                 print "configMode check : ",nimConfig.configMode.value
 229
 230                 nimmanager.sec.update()
 231
 232                 system("cp /usr/lib/enigma2/python/Plugins/SystemPlugins/FactoryTest/testdb /etc/enigma2/lamedb")
 233                 db = eDVBDB.getInstance()
 234                 db.reloadServicelist()
 235                 self.createConfig()
 236
 237                 self.rlist = []
 238                 for x in range(self.menulength-1):
 239                         self.rlist.append((".."))
 240                 self.rlist.append((" "))
 241                 self["resultlist"] = TestResultList(self.rlist)
 242
 243                 self.avswitch = AVSwitch()
 244                 self.scTest= eSctest()
 245
 246                 self.testing = 0
 247
 248                 self.servicelist = ServiceList()
 249                 self.oldref = session.nav.getCurrentlyPlayingServiceReference()
 250                 print "oldref",self.oldref
 251                 session.nav.stopService() # try to disable foreground service
 252
 253                 self.tunemsgtimer = eTimer()
 254                 self.tunemsgtimer.callback.append(self.tunemsg)
 255
 256                 self.camstep = 1
 257                 self.camtimer = eTimer()
 258                 self.camtimer.callback.append(self.cam_state)
 259                 self.mactry = 1
 260                 self.getmacaddr()
 261                 self.getversion()
 262
 263                 self.tunerlock = 0
 264                 self.tuningtimer = eTimer()
 265                 self.tuningtimer.callback.append(self.updateStatus)
 266
 267                 self.satatry = 8
 268                 self.satatimer = eTimer()
 269                 self.satatimer.callback.append(self.sataCheck)
 270
 271                 self.usbtimer = eTimer()
 272                 self.usbtimer.callback.append(self.usbCheck)
 273
 274                 self.setSourceVar()
 275                 self.FanSpeedUp(255)
 276
 277         def FanSpeedUp(self,value):
 278                 if self.model in (3,4): # uno or ultimo
 279                         if value <0:
 280                                 value = 0
 281                         elif value >255:
 282                                 value = 255
 283                         print "[FactoryTest, FanSpeedUp] setPWM to : %d"%value
 284                         f = open("/proc/stb/fp/fan_pwm", "w")
 285                         f.write("%x" % value)
 286                         f.close()
 287
 288         def createConfig(self):
 289                 tlist = []
 290                 self.satetestIndex = -1
 291                 self.scarttestIndex = -1
 292                 if self.model == 0:
 293                         self.satetestIndex=0
 294                         tlist.append((" 0. Sata & extend hdd test",self.satetestIndex))
 295                         self.usbtestIndex=1
 296                         tlist.append((" 1. USB test",self.usbtestIndex))
 297                         self.fronttestIndex=2
 298                         tlist.append((" 2. Front test",self.fronttestIndex))
 299                         self.smarttestIndex=3
 300                         tlist.append((" 3. Smartcard test",self.smarttestIndex))
 301                         self.tuner1_1testIndex=4
 302                         tlist.append((" 4. T1/H/22K x /4:3/CVBS",self.tuner1_1testIndex))
 303                         self.tuner1_2testIndex=5
 304                         tlist.append((" 5. T1/V/22k o/16:9/RGB",self.tuner1_2testIndex))
 305                         self.tuner2_1testIndex=6
 306                         tlist.append((" 6. T2/H/22k x/4:3/YC",self.tuner2_1testIndex))
 307                         self.tuner2_2testIndex=7
 308                         tlist.append((" 7. T2/V/22k o/16:9/CVBS/CAM",self.tuner2_2testIndex))
 309                         self.scarttestIndex=8
 310                         tlist.append((" 8. VCR Scart loop",self.scarttestIndex))
 311                         self.rs232testIndex=9
 312                         tlist.append((" 9. RS232 test",self.rs232testIndex))
 313                         self.ethernettestIndex=10
 314                         tlist.append(("10. Ethernet & mac test",self.ethernettestIndex))
 315                         self.fdefaultIndex=11
 316                         tlist.append(("11. Factory default",self.fdefaultIndex))
 317                         self.shutdownIndex=12
 318                         tlist.append(("12. Shutdown(Deep Standby)",self.shutdownIndex))
 319                         self.tuner_test_first_index = 4
 320                         self.tuner_test_last_index = 7
 321
 322                 elif self.model == 1:
 323                         self.usbtestIndex=0
 324                         tlist.append((" 0. USB test",self.usbtestIndex))
 325                         self.fronttestIndex=1
 326                         tlist.append((" 1. Front test",self.fronttestIndex))
 327                         self.smarttestIndex=2
 328                         tlist.append((" 2. Smartcard test",self.smarttestIndex))
 329                         self.tuner1_1testIndex=3
 330                         tlist.append((" 3. T1/H/22K x/4:3/CVBS",self.tuner1_1testIndex))
 331                         self.tuner2_2testIndex = self.tuner1_2testIndex=4
 332                         tlist.append((" 4. T1/V/22k o/16:9/RGB/CAM",self.tuner1_2testIndex))
 333                         self.rs232testIndex=5
 334                         tlist.append((" 5. RS232 test",self.rs232testIndex))
 335                         self.ethernettestIndex=6
 336                         tlist.append((" 6. Ethernet & mac test",self.ethernettestIndex))
 337                         self.fdefaultIndex=7
 338                         tlist.append((" 7. Factory default",self.fdefaultIndex))
 339                         self.shutdownIndex=8
 340                         tlist.append((" 8. Shutdown(Deep Standby)",self.shutdownIndex))
 341                         self.tuner_test_first_index = 3
 342                         self.tuner_test_last_index = 4
 343
 344                 elif self.model == 2:
 345                         self.satetestIndex=0
 346                         tlist.append((" 0. Sata & extend hdd test",self.satetestIndex))
 347                         self.usbtestIndex=1
 348                         tlist.append((" 1. USB test",self.usbtestIndex))
 349                         self.fronttestIndex=2
 350                         tlist.append((" 2. Front test",self.fronttestIndex))
 351                         self.smarttestIndex=3
 352                         tlist.append((" 3. Smartcard test",self.smarttestIndex))
 353                         self.tuner1_1testIndex=4
 354                         tlist.append((" 4. T1 H 22K x 4:3 CVBS",self.tuner1_1testIndex))
 355                         self.tuner1_2testIndex=5
 356                         tlist.append((" 5. T1 V 22k o 16:9 RGB",self.tuner1_2testIndex))
 357                         self.tuner2_1testIndex = -1
 358                         self.tuner2_2testIndex=6
 359                         tlist.append((" 6. T2 DVB-C 4:3 YC CAM",self.tuner2_2testIndex))
 360                         self.rs232testIndex=7
 361                         tlist.append((" 7. RS232 test",self.rs232testIndex))
 362                         self.ethernettestIndex=8
 363                         tlist.append(("8. Ethernet & mac test",self.ethernettestIndex))
 364                         self.fdefaultIndex=9
 365                         tlist.append(("9. Factory default",self.fdefaultIndex))
 366                         self.shutdownIndex=10
 367                         tlist.append(("10. Shutdown",self.shutdownIndex))
 368                         self.tuner_test_first_index = 4
 369                         self.tuner_test_last_index = 6
 370
 371                 elif self.model == 3 or self.model == 4:
 372                         self.satetestIndex=0
 373                         tlist.append((" 0. Sata & extend hdd test",self.satetestIndex))
 374                         self.usbtestIndex=1
 375                         tlist.append((" 1. USB test",self.usbtestIndex))
 376                         self.fronttestIndex=2
 377                         tlist.append((" 2. Front test",self.fronttestIndex))
 378                         self.smarttestIndex=3
 379                         tlist.append((" 3. Smartcard test",self.smarttestIndex))
 380                         if self.model == 3:
 381                                 self.tuner_test_first_index = current_index = 4
 382                         elif self.model == 4:
 383                                 self.tuner_test_first_index = 4
 384                                 current_index = 0
 385                         AspectRatio=["4:3", "16:9"]
 386                         ColorFormat=["CVBS","RGB","YC","CVBS","CVBS","CVBS","CVBS","CVBS"]
 387                         self.tuneInfo={}
 388                         tunelist = []
 389                         for (key, val) in self.NimType.items():
 390                                 if val["type"].startswith("DVB-S"):
 391 # Chang : DVB -S setting diseqc A
 392                                         getRatio = AspectRatio.pop(0) # ratio
 393                                         AspectRatio.append(getRatio)
 394                                         getColorFormat=ColorFormat.pop(0) # colorFormat
 395                                         menuname=" %d. T%d/%s/H/22k x/%s/%s" % (current_index, key+1, val["type"], getRatio, getColorFormat)    #menuname
 396                                         print current_index
 397 #                                               current_index=4
 398                                         self.setTuneInfo(index=current_index, slot=key, type=val["type"], sat=val["sat1"], pol="H", tone=False, ratio=getRatio, color=getColorFormat, cam=False) # setTuneInfo
 399 #                                               self.setTuneInfo(current_index, key, val["type"], val["sat1"], "H", True, getRatio, getColorFormat, False) # setTuneInfo
 400                                         tunelist.append((menuname,current_index))
 401                                         current_index+=1
 402 # Chang : DVB -S setting diseqc B
 403                                         getRatio = AspectRatio.pop(0)
 404                                         AspectRatio.append(getRatio)
 405                                         getColorFormat=ColorFormat.pop(0)
 406                                         menuname=" %d. T%d/%s/V/22k o/%s/%s" % (current_index, key+1, val["type"], getRatio, getColorFormat)
 407                                         if len(self.NimType) == key+1: # CAM test on/off
 408                                                 menuname+="/CAM"
 409                                                 camtest = True
 410                                         else:
 411                                                 camtest = False
 412                                         self.setTuneInfo( index=current_index, slot=key, type=val["type"], sat=val["sat2"], pol="V", tone=True, ratio=getRatio, color=getColorFormat, cam=camtest)
 413                                         tunelist.append((menuname,current_index))
 414                                         current_index+=1
 415 # Chang : DVB -T or DVB-C
 416                                 elif val["type"].startswith("DVB-T") or val["type"].startswith("DVB-C"):
 417                                         additionalMenu = None
 418                                         menulen = 1
 419                                         if len(self.NimType) == 1:
 420                                                 additionalMenu = True
 421                                                 menulen +=1
 422                                         for x in range(menulen):
 423                                                 getRatio = AspectRatio.pop(0)
 424                                                 AspectRatio.append(getRatio)
 425                                                 getColorFormat=ColorFormat.pop(0)
 426                                                 menuname=" %d. T%d/%s/%s/%s" % (current_index, key+1, val["type"], getRatio, getColorFormat)
 427                                                 if len(self.NimType) == key+1 and (additionalMenu is None or x != 0): # CAM test on/off
 428                                                         menuname+=" CAM"
 429                                                         camtest = True
 430                                                 else:
 431                                                         camtest = False
 432                                                 self.setTuneInfo( index=current_index, slot=key, type=val["type"], sat=None, pol=None, tone=None, ratio=getRatio, color=getColorFormat, cam=camtest)
 433                                                 tunelist.append((menuname,current_index))
 434                                                 current_index+=1
 435                         if self.model == 3:
 436                                 tlist.extend(tunelist)
 437                                 self.tuner_test_last_index = current_index-1
 438                         elif self.model == 4:
 439                                 self.tunelist = tunelist
 440                                 self.tuner_test_last_index = 4
 441                                 current_index = self.tuner_test_last_index
 442                                 tlist.append((" %d. Tuning test" % current_index,self.tuner_test_last_index))
 443                                 current_index+=1
 444                         self.rs232testIndex=current_index
 445                         tlist.append((" %d. RS232 test" % current_index,self.rs232testIndex))
 446                         current_index+=1
 447                         self.ethernettestIndex=current_index
 448                         tlist.append((" %d. Ethernet & mac test" % current_index,self.ethernettestIndex))
 449                         current_index+=1
 450                         self.fdefaultIndex=current_index
 451                         tlist.append((" %d. Factory default" % current_index,self.fdefaultIndex))
 452                         current_index+=1
 453                         self.shutdownIndex=current_index
 454                         tlist.append((" %d. Shutdown(Deep Standby)" % current_index,self.shutdownIndex))
 455
 456                 self.menulength= len(tlist)
 457                 self["testlist"] = MenuList(tlist)
 458
 459         def setTuneInfo(self,index=0,slot=0,type="DVB-S2",sat="160",pol="H",tone=True,ratio="4:3",color="CVBS",cam=False):
 460                 self.tuneInfo[index]={}
 461                 self.tuneInfo[index]["slot"]=slot
 462                 self.tuneInfo[index]["type"]=type
 463                 self.tuneInfo[index]["sat"]=sat
 464                 self.tuneInfo[index]["pol"]=pol
 465                 self.tuneInfo[index]["22k"]=tone
 466                 self.tuneInfo[index]["ratio"]=ratio
 467                 self.tuneInfo[index]["color"]=color
 468                 self.tuneInfo[index]["cam"]=cam
 469
 470         def getModelInfo(self):
 471                 getmodel = 0
 472                 if fileExists("/proc/stb/info/vumodel"):
 473                         vumodel = open("/proc/stb/info/vumodel")
 474                         info=vumodel.read().strip()
 475                         vumodel.close()
 476                         if info == "duo":
 477                                 self.model = 0
 478                                 getmodel = 1
 479                                 print "getModelInfo : duo"
 480                         if info == "solo":
 481                                 self.model = 1
 482                                 getmodel = 1
 483                                 print "getModelInfo : solo"
 484                         if info == "combo":
 485                                 self.model = 2
 486                                 getmodel = 1
 487                                 print "getModelInfo : combo"
 488                         if info == "uno":
 489                                 self.model = 3
 490                                 getmodel = 1
 491                                 print "getModelInfo : uno"
 492                         if info == "ultimo":
 493                                 self.model = 4
 494                                 getmodel = 1
 495                                 print "getModelInfo : ultimo"
 496
 497                 if getmodel == 0 and fileExists("/proc/stb/info/version"):
 498                         vesion = open("/proc/stb/info/version")
 499                         info=version.read()
 500                         version.close()
 501                         if info[:2] == "14":
 502                                 self.model = 1
 503                                 print "getModelInfo : solo_"
 504                         elif info[:2] == "12":
 505                                 self.model = 0
 506                                 print "getModelInfo : duo_"
 507
 508         def nothing(self):
 509                 print "nothing"
 510
 511         def keyup(self):
 512                 print "self.menulength = ",self.menulength
 513                 print "self[\"testlist\"].getCurrent()[1] = ",self["testlist"].getCurrent()[1]
 514                 if self.testing==1:
 515                         return
 516                 if self["testlist"].getCurrent()[1]==0:
 517                         self["testlist"].moveToIndex(self.menulength-1)
 518                         self["resultlist"].moveToIndex(self.menulength-1)
 519                 else:
 520                         self["testlist"].up()
 521                         self["resultlist"].up()
 522
 523
 524         def keydown(self):
 525                 print "self.menulength = ",self.menulength
 526                 print "self[\"testlist\"].getCurrent()[1] = ",self["testlist"].getCurrent()[1]
 527                 if self.testing==1:
 528                         return
 529                 if self["testlist"].getCurrent()[1]==(self.menulength-1):
 530                         self["testlist"].moveToIndex(0)
 531                         self["resultlist"].moveToIndex(0)
 532                 else:
 533                         self["testlist"].down()
 534                         self["resultlist"].down()
 535
 536         def numberaction(self, number):
 537                 if self.testing==1:
 538                         return
 539                 if number >= self.menulength:
 540                         return
 541                 index = int(number)
 542                 self["testlist"].moveToIndex(index)
 543                 self["resultlist"].moveToIndex(index)
 544
 545         def getImageVersion(self):
 546                 date = 'xxxx-xx-xx'
 547                 file = open(resolveFilename(SCOPE_SYSETC, 'image-version'), 'r')
 548                 lines = file.readlines()
 549                 for x in lines:
 550                         splitted = x.split('=')
 551                         if splitted[0] == "version":
 552                         #     YYYY MM DD hh mm
 553                                 #0120 2005 11 29 01 16
 554                                 #0123 4567 89 01 23 45
 555                                 version = splitted[1]
 556                                 year = version[4:8]
 557                                 month = version[8:10]
 558                                 day = version[10:12]
 559                                 date = '-'.join((year, month, day))
 560                                 break;
 561                 file.close()
 562                 return date
 563
 564         def getversion(self):
 565                 try:
 566                         fd = open("/proc/stb/info/version","r")
 567                         version = fd.read()
 568                         fd.close()
 569                         self["testversion"].setText(("Version %s"%version))
 570                 except:
 571                         self["testversion"].setText(("Version no load"))
 572
 573
 574         def getmacaddr(self):
 575                 try:
 576                         if self.model == 2 or self.model == 3 or self.model == 4:
 577                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd5"
 578                         elif self.model == 0 or self.model == 1:
 579                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd4"
 580                         self.macConsole = Console()
 581                         self.macConsole.ePopen(cmd, self.readmac,self.checkReadmac)
 582                 except:
 583                         return
 584
 585         def readmac(self, result, retval,extra_args=None):
 586                 (callback) = extra_args
 587                 if self.macConsole is not None:
 588                         if retval == 0:
 589                                 self.macConsole = None
 590                                 macline = None
 591                                 content =result.splitlines()
 592                                 for x in content:
 593                                         if x.startswith('0x000'+str((self.mactry-1)*2)+'0010:'):
 594                                                 macline = x.split()
 595                                 if macline == None:
 596                                         callback(0)
 597                                 elif len(macline) < 10:
 598                                         callback(1)
 599                                 else:
 600                                         mac = macline[5]+":"+macline[6]+":"+macline[7]+":"+macline[8]+":"+macline[9]+":"+macline[10]
 601                                         self["mactext"].setText(("MAC : "+mac))
 602                                         callback(2)
 603
 604         def checkReadmac(self,data):
 605                 if data == 0:
 606                         print "block %d is bad block" % self.mactry
 607                         self.mactry = self.mactry + 1
 608                         if self.mactry > 4:
 609                                 self.session.open(MessageBox, _("FLASH IS BROKEN"), type = MessageBox.TYPE_INFO, enable_input = False)
 610                                 return
 611                         else:
 612                                 self.getmacaddr()
 613                 elif data == 1:
 614                         print 'mac dump read error'
 615                         return
 616                 elif data == 2:
 617                         print 'mac address read ok'
 618                         return
 619
 620         def TestAction(self):
 621                 if self.testing==1:
 622                         return
 623                 print "line - ",self["testlist"].getCurrent()[1]
 624                 self.currentindex = index = self["testlist"].getCurrent()[1]
 625                 result = 0
 626                 if index==self.satetestIndex:
 627                         self.Test0()
 628                 elif index==self.fronttestIndex:
 629                         self.Test1()
 630                 elif index>=self.tuner_test_first_index and index<=self.tuner_test_last_index:
 631                         if self.model == 0 or self.model == 1 or self.model == 2 or self.model == 3:
 632                                 self.TestTune(index)
 633                         elif self.model == 4:
 634                                 self.openTestTuneMenu()
 635                 elif index==self.scarttestIndex:
 636                         self.Test6()
 637                 elif index==self.rs232testIndex:
 638                         self.Test7()
 639                 elif index==self.usbtestIndex:
 640                         self.Test8()
 641                 elif index==self.ethernettestIndex:
 642                         self.Test9()
 643                 elif index == self.smarttestIndex:
 644                         self.Test10()
 645 #               elif index == 11:
 646 #                       self.Test11()
 647 #               elif index ==12:
 648 #                       self.Test12()
 649 #               elif index==13:
 650 #                       self.Test13()
 651                 elif index==self.fdefaultIndex:
 652                         self.Test14()
 653 #               elif index==self.shutdownIndex:
 654 #                       self.Test15()
 655                 else:
 656                         pass
 657
 658         def shutdownaction(self):
 659                 if self["testlist"].getCurrent()[1] == self.shutdownIndex:
 660                         self.Test15()
 661
 662
 663         def Test0(self):
 664                 self.satatry = 8
 665                 self.satatimer.start(100,True)
 666
 667         def sataCheck(self):
 668 #               print "try", self.satatry
 669                 if self.satatry == 0:
 670                         displayerror = 1
 671                 else:
 672                         self.rlist[self["testlist"].getCurrent()[1]]="try %d"%self.satatry
 673                         self["resultlist"].updateList(self.rlist)
 674                         self.satatry -= 1
 675                         displayerror = 0
 676                 result =0
 677                 try:
 678                         if fileExists("/autofs/sdb1"):
 679                                 if access("/autofs/sdb1",F_OK|R_OK|W_OK):
 680                                         dummy=open("/autofs/sdb1/dummy03","w")
 681                                         dummy.write("complete")
 682                                         dummy.close()
 683                                         dummy=open("/autofs/sdb1/dummy03","r")
 684                                         if dummy.readline()=="complete":
 685                                                 print "/autofs/sdb1 - complete"
 686                                         else:
 687                                                 print "/autofs/sdb1 - readline error"
 688                                                 result = 1
 689                                                 displayerror = 1
 690                                         dummy.close()
 691                                         system("rm /autofs/sdb1/dummy03")
 692                                 else:
 693                                         print "/autofs/sdb1 - rw access error"
 694                                         result = 1
 695                                         displayerror = 1
 696                         else:
 697                                 print "/autofs/sdb1 - file not exist"
 698                                 result = 1
 699                 except:
 700                         print "/autofs/sdb1 - exceptional error"
 701                         result = 1
 702                         displayerror = 1
 703                 try:
 704                         if fileExists("/autofs/sda1"):
 705                                 if access("/autofs/sda1",F_OK|R_OK|W_OK):
 706                                         dummy=open("/autofs/sda1/dummy03","w")
 707                                         dummy.write("complete")
 708                                         dummy.close()
 709                                         dummy=open("/autofs/sda1/dummy03","r")
 710                                         if dummy.readline()=="complete":
 711                                                 print "/autofs/sda1 - complete"
 712                                         else:
 713                                                 print "/autofs/sda1 - readline error"
 714                                                 result += 1
 715                                                 displayerror = 1
 716                                         dummy.close()
 717                                         system("rm /autofs/sda1/dummy03")
 718                                 else:
 719                                         print "/autofs/sda1 - rw access error"
 720                                         result += 1
 721                                         displayerror = 1
 722                         else:
 723                                 print "/autofs/sda1 - file not exist"
 724                                 result += 1
 725                 except:
 726                         print "/autofs/sda1 - exceptional error"
 727                         result += 1
 728                         displayerror = 1
 729
 730                 if result == 0:
 731                         self.session.open( MessageBox, _("Sata & extend hdd test pass\nPress 'OK' button!"), MessageBox.TYPE_INFO)
 732                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
 733                 elif result == 1:
 734                         if displayerror==1:
 735                                 self.session.open( MessageBox, _("One hdd test error\nPress 'EXIT' button!"), MessageBox.TYPE_ERROR)
 736                                 self.rlist[self["testlist"].getCurrent()[1]]="fail"
 737                         else:
 738                                 self.satatimer.start(1100,True)
 739                 else:
 740                         if displayerror==1:
 741                                 self.session.open( MessageBox, _("Sata & extend hdd test error\nPress 'EXIT' button!"), MessageBox.TYPE_ERROR)
 742                                 self.rlist[self["testlist"].getCurrent()[1]]="fail"
 743                         else:
 744                                 self.satatimer.start(1100,True)
 745
 746         def Test1(self):
 747                 if self.model== 0:
 748                         self.session.openWithCallback(self.displayresult ,FrontTest)
 749                 elif self.model == 1:
 750                         self.session.openWithCallback(self.displayresult ,FrontTest_solo)
 751                 elif self.model == 2 or self.model == 3:
 752                         self.session.openWithCallback(self.displayresult ,FrontTest_uno)
 753                 elif  self.model == 4:
 754                         self.session.openWithCallback(self.displayresult ,FrontTest_ultimo)
 755
 756         def displayresult(self):
 757                 global fronttest
 758                 if fronttest == 1:
 759                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
 760                 else:
 761                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
 762
 763         def openTestTuneMenu(self):
 764                 self.session.openWithCallback(self.TestTuneMenuResult ,TestTuneMenu, self.tuneInfo, self.tunelist, self.NimType)
 765
 766         def TestTuneMenuResult(self,result):
 767                 if result :
 768                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
 769                 else:
 770                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
 771                 self["resultlist"].updateList(self.rlist)
 772
 773         def TestTune(self,index):
 774                 if self.oldref is None:
 775                         eref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0")
 776                         serviceHandler = eServiceCenter.getInstance()
 777                         servicelist = serviceHandler.list(eref)
 778                         if not servicelist is None:
 779                                 ref = servicelist.getNext()
 780                         else:
 781                                 ref = self.getCurrentSelection() # raise error
 782                                 print "servicelist none"
 783                 else:
 784                         ref = self.oldref
 785                 self.session.nav.stopService() # try to disable foreground service
 786                 if self.model == 0 or self.model == 1:
 787                         if index==self.tuner1_1testIndex:
 788                                 ref.setData(0,1)
 789                                 ref.setData(1,0x6D3)
 790                                 ref.setData(2,0x3)
 791                                 ref.setData(3,0xA4)
 792                                 ref.setData(4,0xA00000)
 793                                 self.session.nav.playService(ref)
 794                                 self.avswitch.setColorFormat(0)
 795                                 self.avswitch.setAspectRatio(0)
 796                         elif index==self.tuner1_2testIndex:
 797                                 if self.model == 1:
 798                                         self.camstep = 1
 799                                         self.camtimer.start(100,True)
 800                                 ref.setData(0,0x19)
 801                                 ref.setData(1,0x1325)
 802                                 ref.setData(2,0x3ef)
 803                                 ref.setData(3,0x1)
 804                                 ref.setData(4,0x64af79)
 805                                 self.session.nav.playService(ref)
 806                                 self.avswitch.setColorFormat(1)
 807                                 self.avswitch.setAspectRatio(6)
 808                         elif index==self.tuner2_1testIndex:
 809                                 ref.setData(0,1)
 810                                 ref.setData(1,0x6D3)
 811                                 ref.setData(2,0x3)
 812                                 ref.setData(3,0xA4)
 813                                 ref.setData(4,0x820000)
 814                                 self.session.nav.playService(ref)
 815                                 self.avswitch.setColorFormat(2)
 816                                 self.avswitch.setAspectRatio(0)
 817                         elif index==self.tuner2_2testIndex:
 818                                 self.camstep = 1
 819                                 self.camtimer.start(100,True)
 820                                 ref.setData(0,0x19)
 821                                 ref.setData(1,0x1325)
 822                                 ref.setData(2,0x3ef)
 823                                 ref.setData(3,0x1)
 824                                 ref.setData(4,0xC00000)
 825                                 self.session.nav.playService(ref)
 826                                 self.avswitch.setColorFormat(0)
 827                                 self.avswitch.setAspectRatio(6)
 828                         self.tuningtimer.start(2000,True)
 829                         self.tunemsgtimer.start(3000, True)
 830                 elif self.model == 3 or self.model == 4:
 831                         getTuneInfo=self.tuneInfo[index]
 832                         if getTuneInfo["cam"] is True:
 833                                 self.camstep = 1
 834                                 self.camtimer.start(100,True)
 835                         if getTuneInfo["type"].startswith("DVB-S"):
 836                                 if getTuneInfo["pol"] == "H":
 837                                         ref.setData(0,1)
 838                                         ref.setData(1,0x6D3)
 839                                         ref.setData(2,0x3)
 840                                         ref.setData(3,0xA4)
 841                                 else:
 842                                         ref.setData(0,0x19)
 843                                         ref.setData(1,0x1325)
 844                                         ref.setData(2,0x3ef)
 845                                         ref.setData(3,0x1)
 846                                 if getTuneInfo["sat"] == "160": # Eutelsat W2
 847                                         ref.setData(4,0xA00000)
 848                                 elif getTuneInfo["sat"] == "100": # Eutelsat
 849                                         ref.setData(4,0x64af79)
 850                                 elif getTuneInfo["sat"] == "130": # Hotbird
 851                                         ref.setData(4,0x820000)
 852                                 elif getTuneInfo["sat"] == "192": # Astra
 853                                         ref.setData(4,0xC00000)
 854                                 elif getTuneInfo["sat"] == "620": # Intelsat 902
 855                                         ref.setData(4,0x26c0000)
 856                                 elif getTuneInfo["sat"] == "642": # Intelsat 906
 857                                         ref.setData(4,0x282AF79)
 858                                 elif getTuneInfo["sat"] == "685": # Panamsat 7,10 (68.5E)
 859                                         ref.setData(4,0x02ad0000)
 860                                 elif getTuneInfo["sat"] == "720": # Panamsat 4 (72.0E)
 861                                         ref.setData(4,0x02d0af79)
 862                         elif getTuneInfo["type"].startswith("DVB-C"):
 863                                 ref.setData(0,0x19)
 864                                 ref.setData(1,0x1325)
 865                                 ref.setData(2,0x3ef)
 866                                 ref.setData(3,0x1)
 867                                 ref.setData(4,-64870) # ffff029a
 868                         elif getTuneInfo["type"].startswith("DVB-T"):
 869                                 ref.setData(0,0x19)
 870                                 ref.setData(1,0x1325)
 871                                 ref.setData(2,0x3ef)
 872                                 ref.setData(3,0x1)
 873                                 ref.setData(4,-286391716) # eeee025c
 874                         self.session.nav.playService(ref)
 875                         if getTuneInfo["color"]=="CVBS":
 876                                 self.avswitch.setColorFormat(0)
 877                         elif getTuneInfo["color"]=="RGB":
 878                                 self.avswitch.setColorFormat(1)
 879                         elif getTuneInfo["color"]=="YC":
 880                                 self.avswitch.setColorFormat(2)
 881                         if getTuneInfo["ratio"] == "4:3":
 882                                 self.avswitch.setAspectRatio(0)
 883                         elif getTuneInfo["ratio"] == "16:9":
 884                                 self.avswitch.setAspectRatio(6)
 885                         self.tuningtimer.start(2000,True)
 886                         self.tunemsgtimer.start(3000, True)
 887
 888         def cam_state(self):
 889                 current_index = self.currentindex
 890                 if self.camstep == 1:
 891                         slot = 0
 892                         state = eDVBCI_UI.getInstance().getState(slot)
 893                         print '-1-stat',state
 894                         if state > 0:
 895                                 self.camstep=2
 896                                 self.camtimer.start(100,True)
 897                         else:
 898                                 self.session.nav.stopService()
 899                                 self.session.open( MessageBox, _("CAM1_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
 900                                 self.rlist[current_index]="fail"
 901                                 self.tunemsgtimer.stop()
 902                 elif self.camstep == 2:
 903                         slot = 0
 904                         appname = eDVBCI_UI.getInstance().getAppName(slot)
 905                         print 'appname',appname
 906                         if appname is None:
 907                                 self.session.nav.stopService()
 908                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
 909                                 self.rlist[current_index]="fail"
 910                                 self.tunemsgtimer.stop()
 911                         else:
 912                                 self.camstep=3
 913                                 self.camtimer.start(100,True)
 914                 elif self.camstep==3:
 915                         slot = 1
 916                         state = eDVBCI_UI.getInstance().getState(slot)
 917                         print '-2-stat',state
 918                         if state > 0:
 919                                 self.camstep=4
 920                                 self.camtimer.start(100,True)
 921                         else:
 922                                 self.session.nav.stopService()
 923                                 self.session.open( MessageBox, _("CAM2_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
 924                                 self.rlist[current_index]="fail"
 925                                 self.tunemsgtimer.stop()
 926                 elif self.camstep == 4:
 927                         slot = 1
 928                         appname = eDVBCI_UI.getInstance().getAppName(slot)
 929                         print 'appname',appname
 930                         if appname is None:
 931                                 self.session.nav.stopService()
 932                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
 933                                 self.rlist[current_index]="fail"
 934                                 self.tunemsgtimer.stop()
 935                         else:
 936                                 self.setSource()
 937                                 self.camstep = 5
 938
 939         def updateStatus(self):
 940                 current_index = self.currentindex
 941                 if self.model == 0 or self.model == 1:
 942                         if current_index ==self.tuner1_1testIndex or current_index==self.tuner1_2testIndex:
 943                                 tunno = 1
 944                                 result = eSctest.getInstance().getFrontendstatus(0)
 945                         else:
 946                                 tunno = 2
 947                                 result = eSctest.getInstance().getFrontendstatus(1)
 948                         if current_index == self.tuner1_2testIndex or current_index==self.tuner2_2testIndex:
 949                                 hv = "Ver"
 950                         else:
 951                                 hv = "Hor"
 952
 953                 elif self.model == 3 or self.model == 4:
 954                         getTuneInfo=self.tuneInfo[current_index]
 955                         result = eSctest.getInstance().getFrontendstatus(getTuneInfo["slot"])
 956                         tunno = getTuneInfo["slot"]+1
 957                         hv = getTuneInfo["pol"]
 958                         if hv == "H":
 959                                 hv = "Hor"
 960                         elif hv == "V":
 961                                 hv = "Ver"
 962                         else :
 963                                 hv == ""
 964
 965                 print "eSctest.getInstance().getFrontendstatus - %d"%result
 966                 if result == 0 or result == -1:
 967                         self.tunerlock = 0
 968                         self.tunemsgtimer.stop()
 969                         self.session.nav.stopService()
 970                         self.avswitch.setColorFormat(0)
 971                         self.session.open( MessageBox, _("Tune%d %s Locking Fail..."%(tunno,hv)), MessageBox.TYPE_ERROR)
 972                         self.rlist[current_index]="fail"
 973                 else :
 974                         self.tunerlock = 1
 975
 976         def tuneback(self,yesno):
 977                 current_index=self.currentindex
 978                 self.session.nav.stopService() # try to disable foreground service
 979                 if yesno and self.tunerlock == 1:
 980                         if current_index == self.tuner_test_last_index and self.camstep < 5: # need fix to depending about CAM exist
 981                                 self.rlist[current_index]="fail"
 982                         else :
 983                                 self.rlist[current_index]="pass"
 984                 else:
 985                         self.rlist[current_index]="fail"
 986                 if self.model == 0 and current_index == 6: # YC
 987                         self.avswitch.setColorFormat(0)
 988                 elif ( self.model == 3 or self.model == 4 ) and self.tuneInfo[current_index]["color"] == "YC":
 989                         self.avswitch.setColorFormat(0)
 990                 self.resetSource()
 991                 self["resultlist"].updateList(self.rlist)
 992
 993         def tunemsg(self):
 994                 self.tuningtimer.stop()
 995                 self.session.openWithCallback(self.tuneback, TuneMessageBox, _("%s ok?" %(self["testlist"].getCurrent()[0])), MessageBox.TYPE_YESNO)
 996
 997         def setSourceVar(self):
 998                 if self.model == 0:
 999                         self.input_pad_num=1
1000                         self.setTuner = 'B'
1001                 elif self.model == 1:
1002                         self.input_pad_num=0
1003                         self.setTuner = 'A'
1004                 else:
1005                         self.input_pad_num=len(self.NimType)-1
1006                         if self.input_pad_num == 0:
1007                                 self.setTuner = 'A'
1008                         elif self.input_pad_num == 1:
1009                                 self.setTuner = 'B'
1010                         elif self.input_pad_num == 2:
1011                                 self.setTuner = 'C'
1012
1013 #       ikseong - for 22000 tp
1014         def setSource(self):
1015 # fix input source
1016                 inputname = ("/proc/stb/tsmux/input%d" % self.input_pad_num)
1017                 print "<setsource> inputname : ",inputname
1018                 fd=open(inputname,"w")
1019                 fd.write("CI0")
1020                 fd.close()
1021 # fix ci_input Tuner
1022                 filename = ("/proc/stb/tsmux/ci0_input")
1023                 fd = open(filename,'w')
1024                 fd.write(self.setTuner)
1025                 print "setTuner(CI0) : ",self.setTuner
1026                 fd.close()
1027                 print "CI loop test!!!!!!!!!!!!!!"
1028
1029         def resetSource(self):
1030                 inputname = ("/proc/stb/tsmux/input%d" % self.input_pad_num)
1031                 print "<resetsource> inputname : ",inputname
1032                 fd=open(inputname,"w")
1033                 fd.write(self.setTuner)
1034                 fd.close()
1035                 print "CI loop test end!!!!!!!!!!!!!!"
1036
1037         def Test6(self):
1038                 self.avswitch.setInput("SCART")
1039                 sleep(2)
1040                 self.session.openWithCallback(self.check6, MessageBox, _("Scart loop ok?"), MessageBox.TYPE_YESNO)
1041
1042         def check6(self,yesno):
1043                 if yesno:
1044                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1045                 else:
1046                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1047                 self.avswitch.setInput("ENCODER")
1048
1049         def check7(self):
1050                 global rstest
1051                 if rstest == 1:
1052                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1053                 else:
1054                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1055
1056         def Test7(self):
1057                 self.session.openWithCallback(self.check7,RS232Test)
1058
1059         def Agingmode(self):
1060                 self.session.openWithCallback(self.AgingmodeCallback,AgingTest, self.model)
1061
1062         def AgingmodeCallback(self,ret):
1063                 if ret == 1:
1064                         self["testlist"].moveToIndex(self.fdefaultIndex)
1065                         self.Test14()
1066                         self["testlist"].moveToIndex(self.shutdownIndex)
1067
1068         def Agingmode2(self):
1069                 self.session.openWithCallback(self.Agingmode2Callback,AgingTest_mode2, self.model)
1070
1071         def Agingmode2Callback(self):
1072                 self["testlist"].moveToIndex(self.fdefaultIndex)
1073                 self.Test14()
1074                 self["testlist"].moveToIndex(self.shutdownIndex)
1075
1076         def Test8(self):
1077                 self.usbtry = 9
1078                 self.usbtimer.start(100,True)
1079
1080         def usbCheck(self):
1081                 if self.usbtry == 0:
1082                         displayerror = 1
1083                 else:
1084                         self.rlist[self["testlist"].getCurrent()[1]]="try %d"%self.usbtry
1085                         self["resultlist"].updateList(self.rlist)
1086                         self.usbtry -= 1
1087                         displayerror = 0
1088
1089                 if self.model==0 or self.model==3 or self.model==4:
1090                         devices = [ "/autofs/sdc1", "/autofs/sdd1", "/autofs/sde1" ]
1091                 elif self.model==1:
1092                         devices = [ "/autofs/sda1", "/autofs/sdb1" ]
1093                 elif self.model==2:
1094                         devices = [ "/autofs/sdc1", "/autofs/sdd1" ]
1095                 else :
1096                         self.session.open( MessageBox, _("invalid model"), MessageBox.TYPE_ERROR)
1097                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1098                         return
1099
1100                 result=len(devices)
1101
1102                 for dev in devices:
1103                         try:
1104                                 if fileExists(dev):
1105                                         if access(dev,F_OK|R_OK|W_OK):
1106                                                 dummy=open(dev+"/dummy03","w")
1107                                                 dummy.write("complete")
1108                                                 dummy.close()
1109                                                 dummy=open(dev+"/dummy03","r")
1110                                                 if dummy.readline()=="complete":
1111                                                         print dev," - complete"
1112                                                 else:
1113                                                         print dev," - readline error"
1114                                                         result=result -1
1115                                                         displayerror = 1
1116                                                 dummy.close()
1117                                                 system("rm "+dev+"/dummy03")
1118                                         else:
1119                                                 print dev," - rw access error"
1120                                                 result=result -1
1121                                                 displayerror = 1
1122                                 else:
1123                                         print dev," - file not exist"
1124                                         result=result-1
1125                         except:
1126                                 print dev," - exceptional error"
1127                                 result=result -1
1128                                 displayerror = 1
1129
1130                 if result < 0 :
1131                         result = 0
1132                 elif result == len(devices):
1133                         self.session.open( MessageBox, _("USB test pass %d devices\nPress 'OK' button!"%result), MessageBox.TYPE_INFO)
1134                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1135                 else:
1136                         if displayerror == 1:
1137                                 self.session.open( MessageBox, _("USB test error : Success-%d"%result+" Fail-%d\nPress 'EXIT' button!"%(len(devices)-result)), MessageBox.TYPE_ERROR)
1138                                 self.rlist[self["testlist"].getCurrent()[1]]="fail"
1139                         else:
1140                                 self.usbtimer.start(1100,True)
1141
1142         def pingtest(self):
1143                 self.testing = 1
1144 #               system("/etc/init.d/networking stop")
1145                 system("ifconfig eth0 192.168.0.10")
1146 #               system("/etc/init.d/networking start")
1147                 cmd1 = "ping -c 1 192.168.0.100"
1148                 self.PingConsole = Console()
1149                 self.PingConsole.ePopen(cmd1, self.checkNetworkStateFinished,self.NetworkStatedataAvail)
1150
1151         def checkNetworkStateFinished(self, result, retval,extra_args):
1152                 (statecallback) = extra_args
1153                 if self.PingConsole is not None:
1154                         if retval == 0:
1155                                 self.PingConsole = None
1156                                 content = result.splitlines()
1157 #                               print 'content',content
1158                                 x = content[4].split()
1159 #                               print 'x',x
1160                                 if x[0]==x[3]:
1161                                         statecallback(1)
1162                                 else:
1163                                         statecallback(0)
1164                         else:
1165                                 statecallback(0)
1166
1167
1168         def NetworkStatedataAvail(self,data):
1169                 global ethtest
1170                 if data == 1:
1171                         ethtest = 1
1172                         print "success"
1173                         self.session.openWithCallback(self.openMacConfig ,MessageBox, _("Ping test pass"), MessageBox.TYPE_INFO,2)
1174
1175                 else:
1176                         ethtest = 0
1177                         print "fail"
1178                         self.session.open( MessageBox, _("Ping test fail\nPress exit"), MessageBox.TYPE_ERROR)
1179                         self.macresult()
1180
1181         def Test9(self):
1182                 self.pingtest()
1183
1184         def openMacConfig(self, ret=False):
1185                 self.session.openWithCallback(self.macresult ,MacConfig,mactry=self.mactry)
1186
1187         def macresult(self):
1188                 global ethtest
1189                 if ethtest == 1:
1190                         self.rlist[self.ethernettestIndex]="pass"
1191                 else:
1192                         self.rlist[self.ethernettestIndex]="fail"
1193                 self.getmacaddr()
1194                 self.testing = 0
1195
1196 #       def MemTest(self, which):
1197 #               index = which
1198 #               result = 0
1199 #               if index==0:
1200 #                       result = eMemtest.getInstance().dramtest()
1201 #               elif index==1:
1202 #                       result = eMemtest.getInstance().flashtest()
1203 #                       result = 0      #       temp
1204 #               else:
1205 #                       result = eMemtest.getInstance().dramtest()
1206 #                       result = eMemtest.getInstance().flashtest()
1207 #                       result = 0      #       temp
1208
1209 #               index = index+10
1210
1211 #               if result == 0:
1212 #                       print index,self.rlist[index]
1213 #                       self.rlist[index]="pass"
1214 #               else:
1215 #                       print index,self.rlist[index]
1216 #                       self.rlist[index]="fail"
1217 #               self["resultlist"].updateList(self.rlist)
1218
1219         def scciresult(self):
1220                 global smartcardtest
1221                 if smartcardtest == 1:
1222                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1223                 else:
1224                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1225
1226         def Test10(self):
1227                 self.session.openWithCallback(self.scciresult ,SmartCardTest,stbmodel=self.model)
1228
1229 #       def Test11(self):
1230 #               self.MemTest(1)
1231
1232 #       def Test12(self):
1233 #               self.MemTest(2)
1234
1235 #       def Test13(self):
1236 #               self.MemTest(3)
1237
1238         def Test14(self):
1239                 try:
1240                         print "test14"
1241                         system("rm -R /etc/enigma2")
1242                         system("ls /")
1243                         system("cp -R /usr/share/enigma2/defaults /etc/enigma2")
1244                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1245                         self["resultlist"].updateList(self.rlist)
1246                 except:
1247                         print "test14 except"
1248                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1249                         self["resultlist"].updateList(self.rlist)
1250                         self.session.open( MessageBox, _("Factory reset fail"), MessageBox.TYPE_ERROR)
1251
1252         def Test15(self):
1253                 self.session.openWithCallback(self.shutdown ,MessageBox, _("Do you want to shut down?"), MessageBox.TYPE_YESNO)
1254
1255         def shutdown(self, yesno):
1256                 if yesno :
1257                         from os import _exit
1258                         system("/usr/bin/showiframe /boot/backdrop.mvi")
1259                         _exit(1)
1260                 else:
1261                         return
1262
1263         def keyCancel(self):
1264                 if self.testing==1:
1265                         return
1266                 print "exit"
1267                 self.close()
1268 #               if self.oldref is not None:
1269 #                       self.session.nav.playService(self.oldref)
1270
1271 ethtest = 0
1272 class MacConfig(Screen):
1273         skin = """
1274                 <screen name="MacConfig" position="center,center" size="520,100" title="Mac Config" >
1275                         <eLabel text="Mac Address " position="10,15" size="200,40" font="Regular;30" />
1276                         <widget name="text" position="230,15" size="230,40" font="Regular;30" halign="right"/>
1277                         <widget name="text1" position="470,15" size="40,40" font="Regular;30" />
1278                         <eLabel text=" " position="5,55" zPosition="-1" size="510,5" backgroundColor="#02e1e8e6" />
1279                         <widget name="stattext" position="30,75" size="450,35" font="Regular;30" />
1280                 </screen>"""
1281
1282         def __init__(self, session, mactry = 1):
1283                 self["actions"] = ActionMap(["DirectionActions","OkCancelActions"],
1284                 {
1285                         "ok": self.keyOk,
1286                         "left": self.keyleft,
1287                         "right": self.keyright,
1288                         "cancel": self.keyCancel,
1289                 }, -2)
1290
1291                 Screen.__init__(self, session)
1292
1293                 self.mactry = mactry
1294                 self.model = 0
1295                 self.getModelInfo()
1296                 self.macfd = 0
1297                 self.macaddr = "000000000000"
1298                 self.ReadMacinfo = 0
1299                 self["text"]=Label((self.macaddr))
1300                 self["text1"]= Label(("< >"))
1301                 self["stattext"]= Label((""))
1302                 self.displaymac()
1303                 self.loadmacaddr()
1304                 self.getmacaddr()
1305                 global ethtest
1306                 ethtest = 1
1307
1308         def getModelInfo(self):
1309                 getmodel = 0
1310                 if fileExists("/proc/stb/info/vumodel"):
1311                         vumodel = open("/proc/stb/info/vumodel")
1312                         info=vumodel.read().strip()
1313                         vumodel.close()
1314                         if info == "combo":
1315                                 self.model = 2
1316                                 getmodel = 1
1317                                 print "MacConfig, model : combo"
1318                         elif info == "solo":
1319                                 self.model = 1
1320                                 getmodel = 1
1321                                 print "MacConfig, model : solo"
1322                         elif info == "duo":
1323                                 self.model = 0
1324                                 getmodel = 1
1325                                 print "MacConfig, model : duo"
1326                         elif info == "uno":
1327                                 self.model = 3
1328                                 getmodel = 1
1329                                 print "getModelInfo : uno"
1330                         elif info == "ultimo":
1331                                 self.model = 4
1332                                 getmodel = 1
1333                                 print "getModelInfo : ultimo"
1334
1335                 if getmodel == 0 and fileExists("/proc/stb/info/version"):
1336                         version = open("/proc/stb/info/version")
1337                         info=version.read()
1338                         version.close()
1339 #                       print info,info[:2]
1340                         if info[:2] == "14":
1341                                 self.model = 1
1342                                 print "MacConfig, model : solo_"
1343                         elif info[:2] == "12":
1344                                 self.model = 0
1345                                 print "MacConfig, model: duo_"
1346
1347         def loadmacaddr(self):
1348                 try:
1349                         self.macfd = 0
1350
1351                         if self.model==0 or self.model==3 or self.model==4 :
1352                                 devices = ["/autofs/sdb1", "/autofs/sdc1", "/autofs/sdd1", "/autofs/sde1" ]
1353                         elif self.model==1:
1354                                 devices = [ "/autofs/sda1", "/autofs/sdb1" ]
1355                         elif self.model==2:
1356                                 devices = [ "/autofs/sdb1", "/autofs/sdc1", "/autofs/sdd1" ]
1357
1358                         for dev in devices:
1359                                 print 'try..',dev
1360                                 if  fileExists(dev+"/macinfo.txt"):
1361                                         print "<open>"+dev+"/macinfo.txt"
1362                                         self.macfd = open(dev+"/macinfo.txt","r+")
1363                                         break
1364
1365                         if self.macfd == 0:
1366                                 self["text"].setText(("cannot read usb!!"))
1367                                 self["text1"].setText((" "))
1368                                 self["stattext"].setText((" Press Exit Key."))
1369                                 self.ReadMacinfo=0
1370                                 return
1371
1372                         macaddr=self.macfd.readline().split(":")
1373                         self.macaddr=macaddr[1]+macaddr[2]+macaddr[3]+macaddr[4]+macaddr[5]+macaddr[6]
1374                         self.displaymac()
1375                         self.ReadMacinfo = 1
1376                 except:
1377                         self["text"].setText(("cannot read usb!!"))
1378                         self["text1"].setText((" "))
1379                         self["stattext"].setText((" Press Exit Key."))
1380                         self.ReadMacinfo=0
1381
1382         def getmacaddr(self):
1383                 if self.ReadMacinfo==0:
1384                         return
1385                 try:
1386                         if self.model == 2 or self.model == 3 or self.model == 4:
1387                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd5"
1388                         elif self.model == 0 or self.model == 1:
1389                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd4"
1390                         self.macConsole = Console()
1391                         self.macConsole.ePopen(cmd, self.readmac,self.checkReadmac)
1392                 except:
1393                         return
1394
1395         def readmac(self, result, retval,extra_args=None):
1396                 (callback) = extra_args
1397                 if self.macConsole is not None:
1398                         if retval == 0:
1399                                 self.macConsole = None
1400                                 macline = None
1401                                 content =result.splitlines()
1402                                 for x in content:
1403                                         if x.startswith('0x000'+str((self.mactry-1)*2)+'0010:'):
1404                                                 macline = x.split()
1405                                 if macline == None:
1406                                         callback(0)
1407                                 elif len(macline) < 10:
1408                                         callback(1)
1409                                 else:
1410                                         mac = macline[5]+":"+macline[6]+":"+macline[7]+":"+macline[8]+":"+macline[9]+":"+macline[10]
1411                                         self["stattext"].setText(("now : "+mac))
1412                                         callback(2)
1413
1414         def checkReadmac(self,data):
1415                 if data == 0:
1416                         print "block %d is bad block" % self.mactry
1417                         self.mactry = self.mactry + 1
1418                         if self.mactry > 4:
1419                                 self.session.open(MessageBox, _("FLASH IS BROKEN"), type = MessageBox.TYPE_INFO, enable_input = False)
1420                                 return
1421                         else:
1422                                 self.getmacaddr()
1423                 elif data == 1:
1424                         print 'mac dump read error'
1425                         return
1426                 elif data == 2:
1427                         print 'mac address read ok'
1428                         return
1429
1430
1431         def keyleft(self):
1432                 if self.ReadMacinfo==0 :
1433                         return
1434                 macaddress = long(self.macaddr,16)-1
1435                 if macaddress < 0 :
1436                         macaddress = 0xffffffffffff
1437                 self.macaddr = "%012x"%macaddress
1438                 self.displaymac()
1439
1440         def keyright(self):
1441                 if self.ReadMacinfo==0 :
1442                         return
1443                 macaddress = long(self.macaddr,16)+1
1444                 if macaddress > 0xffffffffffff:
1445                         macaddress = 0
1446                 self.macaddr = "%012x"%macaddress
1447                 self.displaymac()
1448
1449         def displaymac(self):
1450                 macaddr= self.macaddr
1451                 self["text"].setText(("%02x:%02x:%02x:%02x:%02x:%02x"%(int(macaddr[0:2],16),int(macaddr[2:4],16),int(macaddr[4:6],16),int(macaddr[6:8],16),int(macaddr[8:10],16),int(macaddr[10:12],16))))
1452
1453         def keyOk(self):
1454                 if self.ReadMacinfo==0 :
1455                         return
1456                 try:
1457                         macaddr = self.macaddr
1458 #make_mac_sector 00-99-99-99-00-00 > /tmp/mac.sector
1459 #flash_eraseall /dev/mtd4
1460 #nandwrite /dev/mtd4 /tmp/mac.sector -p
1461                         cmd = "make_mac_sector %02x-%02x-%02x-%02x-%02x-%02x > /tmp/mac.sector"%(int(macaddr[0:2],16),int(macaddr[2:4],16),int(macaddr[4:6],16),int(macaddr[6:8],16),int(macaddr[8:10],16),int(macaddr[10:12],16))
1462                         system(cmd)
1463                         if self.model == 2 or self.model == 3 or self.model == 4:
1464                                 system("flash_eraseall /dev/mtd5")
1465                                 system("nandwrite /dev/mtd5 /tmp/mac.sector -p")
1466                         elif self.model == 0 or self.model ==1 :
1467                                 system("flash_eraseall /dev/mtd4")
1468                                 system("nandwrite /dev/mtd4 /tmp/mac.sector -p")
1469                         macaddress = long(macaddr,16)+1
1470                         if macaddress > 0xffffffffffff:
1471                                 macaddress = 0
1472                         macaddr = "%012x"%macaddress
1473                         macwritetext = "MAC:%02x:%02x:%02x:%02x:%02x:%02x"%(int(macaddr[0:2],16),int(macaddr[2:4],16),int(macaddr[4:6],16),int(macaddr[6:8],16),int(macaddr[8:10],16),int(macaddr[10:12],16))
1474                         self.macfd.seek(0)
1475                         self.macfd.write(macwritetext)
1476                         self.macfd.close()
1477                         system("sync")
1478                         self.macaddr = macaddr
1479                         self.close()
1480                 except:
1481                         self.session.open( MessageBox, _("Mac address fail"), MessageBox.TYPE_ERROR)
1482                         global ethtest
1483                         ethtest = 0
1484                         self.close()
1485
1486         def keyCancel(self):
1487                 if self.macfd != 0:
1488                         self.macfd.close()
1489                 global ethtest
1490                 ethtest = 0
1491                 self.close()
1492
1493 smartcardtest = 0
1494 class SmartCardTest(Screen):
1495         skin = """
1496                 <screen name="SmartCardTest" position="center,center" size="300,120" title="SmartCard Test" >
1497                         <widget name="text" position="10,10" size="280,100" font="Regular;30" />
1498                 </screen>"""
1499
1500         def __init__(self, session, stbmodel = 0):
1501                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions"],
1502                 {
1503                         "cancel": self.keyCancel,
1504                         "ok" : self.keyOk
1505                 }, -2)
1506
1507                 Screen.__init__(self, session)
1508                 self["text"]=Label(("Testing Smartcard 1..."))
1509                 self.testok = 0
1510                 self.smartcardtimer = eTimer()
1511                 self.smartcardtimer.callback.append(self.check_smart_card)
1512                 self.closetimer = eTimer()
1513                 self.closetimer.callback.append(self.close)
1514                 self.smartcard=0
1515                 global smartcardtest
1516                 smartcardtest = 0
1517                 self.model = stbmodel
1518                 self.smartcardtimer.start(100,True)
1519
1520         def check_smart_card(self):
1521                 global smartcardtest
1522                 index = self.smartcard
1523                 result  = 0
1524                 if index==0:
1525                         result = eSctest.getInstance().check_smart_card("/dev/sci0")
1526                 elif index ==1:
1527                         result = eSctest.getInstance().check_smart_card("/dev/sci1")
1528                 else:
1529                         result = -1
1530
1531                 print "check smartcard : ", result
1532
1533                 if result == 0:
1534                         print 'pass'
1535                         if(index== 0 and ( self.model== 0 or self.model==2 or self.model == 3 or self.model == 4) ):
1536                                 self.smartcard = 1
1537                                 self["text"].setText(_("Testing Smartcard 2..."))
1538                                 self.smartcardtimer.start(100,True)
1539                                 return
1540                         elif (index==1 or self.model==1):
1541                                 smartcardtest = 1
1542                                 self.testok = 1
1543                                 self["text"].setText(_("Smart Card OK!!"))
1544                                 self.closetimer.start(2000,True)
1545                                 self.smartcardtimer.stop()
1546                         else :
1547
1548                                 self["text"].setText(_("Smart Card model type error"))
1549                                 self.closetimer.start(2000,True)
1550                                 self.smartcardtimer.stop()
1551                 else:
1552 #                       if result ==-1:
1553 #                               self.session.open( MessageBox, _("%d:NO_DEV_FOUND"%(index+1)), MessageBox.TYPE_ERROR)
1554 #                       elif result == -2:
1555 #                               self.session.open( MessageBox, _("%d:SC_NOT_INSERTED"%(index+1)), MessageBox.TYPE_ERROR)
1556 #                       elif result == -3:
1557 #                               self.session.open( MessageBox, _("%d:SC_NOT_VALID_ATR"%(index+1)), MessageBox.TYPE_ERROR)
1558 #                       elif result == -5:
1559 #                               self.session.open( MessageBox, _("%d:SC_READ_TIMEOUT"%(index+1)), MessageBox.TYPE_ERROR)
1560                         if(index==0):
1561                                 self["text"].setText(_("Smart Card 1 Error!\nerrorcode=%d"%result))
1562                         elif (index==1):
1563                                 self["text"].setText(_("Smart Card 2 Error!\nerrorcode=%d"%result))
1564                         self.closetimer.start(2000,True)
1565                         self.smartcardtimer.stop()
1566
1567
1568         def keyCancel(self):
1569                 self.close()
1570
1571         def keyOk(self):
1572                 if self.testok == 1:
1573                         self.close()
1574
1575
1576
1577 fronttest = 0
1578
1579 class FrontTest(Screen):
1580         skin = """
1581                 <screen name="FrontTest" position="center,center" size="300,180" title="Front Test" >
1582                         <widget name="text" position="10,10" size="280,160" font="Regular;30" />
1583                 </screen>"""
1584
1585         def __init__(self, session):
1586                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions"],
1587                 {
1588                         "ok": self.keyOk,
1589                         "up":self.keyUp,
1590                         "down":self.keyDown,
1591                         "cancel": self.keyCancel,
1592                 }, -2)
1593
1594                 Screen.__init__(self, session)
1595                 self["text"]=Label(("Wheel LEFT"))
1596                 self.step = 1
1597
1598                 self.fronttimer= eTimer()
1599                 self.fronttimer.callback.append(self.FrontAnimate)
1600                 self.frontturnonoff = 0
1601                 eSctest.getInstance().VFD_Open()
1602                 self.keytimeout = eTimer()
1603                 self.keytimeout.callback.append(self.KeyTimeOut)
1604                 self.keytimeout.start(5000,True)
1605
1606         def KeyTimeOut(self):
1607                 if self.step == 1:
1608                         self["text"].setText(("Wheel LEFT ERROR"))
1609                 elif self.step ==2 :
1610                         self["text"].setText(("Wheel RIGHT ERROR"))
1611                 elif self.step == 3:
1612                         self["text"].setText(("Wheel BUTTON ERROR"))
1613                 self.step = 0
1614 #               self.keyCancel()
1615
1616         def keyCancel(self):
1617                 global fronttest
1618                 self.fronttimer.stop()
1619                 eSctest.getInstance().VFD_Close()
1620                 if self.step==4:
1621                         fronttest = 1
1622                 else:
1623                         fronttest = 0
1624                 self.close()
1625
1626         def keyDown(self):
1627                 if self.step==2:
1628                         self.keytimeout.stop()
1629                         self.keytimeout.start(5000,True)
1630                         self.step = 3
1631                         self["text"].setText(_("Press Front Wheel"))
1632
1633         def keyUp(self):
1634                 if self.step==1:
1635                         self.keytimeout.stop()
1636                         self.keytimeout.start(5000,True)
1637                         self.step=2
1638                         self["text"].setText(_("Wheel RIGHT"))
1639
1640         def keyOk(self):
1641                 if self.step == 3:
1642                         self.keytimeout.stop()
1643                         self.step =4
1644                         self.fronttimer.start(1000,True)
1645                         self["text"].setText(("Front Test OK!\nPress Exit Key"))
1646 #               elif self.step==4:
1647 #                       global fronttest
1648 #                       self.fronttimer.stop()
1649 #                       eSctest.getInstance().VFD_Close()
1650 #                       fronttest = 1
1651 #                       self.close()
1652
1653         def FrontAnimate(self):
1654                 if (self.frontturnonoff==0):
1655                         eSctest.getInstance().turnon_VFD()
1656                         self.frontturnonoff = 1
1657                 else:
1658                         self.frontturnonoff = 0
1659                         eSctest.getInstance().turnoff_VFD()
1660                 self.fronttimer.start(1000,True)
1661
1662
1663 class FrontTest_solo(Screen):
1664         skin = """
1665                 <screen name="FrontTest_solo" position="center,center" size="300,180" title="Front Test" >
1666                         <widget name="text" position="10,10" size="280,160" font="Regular;30" />
1667                 </screen>"""
1668
1669         def __init__(self, session):
1670                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","GlobalActions"],
1671                 {
1672                         "ok": self.keyOk,
1673                         "cancel": self.keyCancel,
1674                         "left": self.keyleft,
1675                         "right": self.keyright,
1676                         "power_down": self.keypower,
1677                         "volumeUp": self.keyvolup,
1678                         "volumeDown": self.keyvoldown,
1679                 }, -2)
1680
1681                 Screen.__init__(self, session)
1682                 self["text"]=Label(("Press Front STANDBY"))
1683                 self.step = 1
1684
1685                 self.fronttimer= eTimer()
1686                 self.fronttimer.callback.append(self.FrontAnimate)
1687                 self.frontturnonoff = 0
1688                 eSctest.getInstance().VFD_Open()
1689                 self.keytimeout = eTimer()
1690                 self.keytimeout.callback.append(self.KeyTimeOut)
1691                 self.keytimeout.start(5000,True)
1692
1693         def KeyTimeOut(self):
1694                 if self.step == 1:
1695                         self["text"].setText(("Front STANDBY ERROR\nPress exit!"))
1696                 elif self.step == 2 :
1697                         self["text"].setText(("Front CH - ERROR\nPress exit!"))
1698                 elif self.step == 3:
1699                         self["text"].setText(("Front CH + ERROR\nPress exit!"))
1700                 elif self.step == 4 :
1701                         self["text"].setText(("Front VOL - ERROR\nPress exit!"))
1702                 elif self.step == 5:
1703                         self["text"].setText(("Front VOL + ERROR\nPress exit!"))
1704
1705                 self.step = 0
1706 #               self.keyCancel()
1707
1708         def keypower(self):
1709                 if self.step== 1:
1710                         self.keytimeout.stop()
1711                         self.keytimeout.start(5000,True)
1712                         self.step = 2
1713                         self["text"].setText(_("Press Front CH -"))
1714
1715         def keyright(self):
1716                 if self.step== 3:
1717                         self.keytimeout.stop()
1718                         self.keytimeout.start(5000,True)
1719                         self.step = 4
1720                         self["text"].setText(_("Press Front VOL -"))
1721
1722         def keyleft(self):
1723                 if self.step== 2:
1724                         self.keytimeout.stop()
1725                         self.keytimeout.start(5000,True)
1726                         self.step = 3
1727                         self["text"].setText(_("Press Front CH +"))
1728
1729         def keyvolup(self):
1730                 if self.step== 5:
1731                         self.keytimeout.stop()
1732                         self.step = 6
1733                         self.fronttimer.start(1000,True)
1734                         self["text"].setText(_("Front LED OK?\n\nyes-ok\nno-exit"))
1735 #                       self["text"].setText(("Front Test OK!\nPress Exit Key"))
1736
1737         def keyvoldown(self):
1738                 if self.step== 4:
1739                         self.keytimeout.stop()
1740                         self.keytimeout.start(5000,True)
1741                         self.step = 5
1742                         self["text"].setText(_("Press Front VOL +"))
1743
1744         def checkled(self, yesno):
1745                 if yesno :
1746                         self.step=6
1747                 else:
1748                         self.step=0
1749                 self.keyCancel()
1750
1751         def keyCancel(self):
1752                 global fronttest
1753                 self.fronttimer.stop()
1754                 eSctest.getInstance().VFD_Close()
1755                 fronttest = 0
1756                 self.close()
1757
1758         def keyOk(self):
1759                 global fronttest
1760                 if self.step == 6:
1761                         fronttest = 1
1762                         self.fronttimer.stop()
1763                         eSctest.getInstance().VFD_Close()
1764                         self.close()
1765
1766         def FrontAnimate(self):
1767                 if (self.frontturnonoff==0):
1768                         eSctest.getInstance().turnon_VFD()
1769                         self.frontturnonoff = 1
1770                 else:
1771                         self.frontturnonoff = 0
1772                         eSctest.getInstance().turnoff_VFD()
1773                 self.fronttimer.start(1000,True)
1774
1775 class FrontTest_uno(Screen):
1776         skin = """
1777                 <screen name="FrontTest_uno" position="center,center" size="300,180" title="Front Test" >
1778                         <widget name="text" position="10,10" size="280,160" font="Regular;30" />
1779                 </screen>"""
1780
1781         def __init__(self, session):
1782                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","GlobalActions"],
1783                 {
1784                         "ok": self.keyOk,
1785                         "cancel": self.keyCancel,
1786                         "left": self.keyleft,
1787                         "right": self.keyright,
1788                         "volumeUp": self.keyvolup,
1789                         "volumeDown": self.keyvoldown,
1790                         "power_down": self.keypower,
1791                 }, -2)
1792
1793                 Screen.__init__(self, session)
1794                 self["text"]=Label(("Press Front CH -"))
1795                 self.step = 1
1796                 self.fronttimer= eTimer()
1797                 self.fronttimer.callback.append(self.FrontAnimate)
1798                 self.frontturnonoff = 0
1799                 eSctest.getInstance().VFD_Open()
1800                 self.keytimeout = eTimer()
1801                 self.keytimeout.callback.append(self.KeyTimeOut)
1802                 self.keytimeout.start(5000,True)
1803
1804         def KeyTimeOut(self):
1805                 if self.step == 1:
1806                         self["text"].setText(("Front CH - ERROR\nPress exit!"))
1807                 elif self.step == 2:
1808                         self["text"].setText(("Front CH + ERROR\nPress exit!"))
1809                 elif self.step == 3 :
1810                         self["text"].setText(("Front VOL - ERROR\nPress exit!"))
1811                 elif self.step == 4:
1812                         self["text"].setText(("Front VOL + ERROR\nPress exit!"))
1813                 elif self.step == 5:
1814                         self["text"].setText(("Front STANDBY ERROR\nPress exit!"))
1815                 self.step = 0
1816
1817         def keyleft(self):
1818                 if self.step== 1:
1819                         self.keytimeout.stop()
1820                         self.keytimeout.start(5000,True)
1821                         self.step = 2
1822                         self["text"].setText(_("Press Front CH +"))
1823         def keyright(self):
1824                 if self.step== 2:
1825                         self.keytimeout.stop()
1826                         self.keytimeout.start(5000,True)
1827                         self.step = 3
1828                         self["text"].setText(_("Press Front VOL -"))
1829
1830         def keyvoldown(self):
1831                 if self.step== 3:
1832                         self.keytimeout.stop()
1833                         self.keytimeout.start(5000,True)
1834                         self.step = 4
1835                         self["text"].setText(_("Press Front VOL +"))
1836
1837         def keyvolup(self):
1838                 if self.step== 4:
1839                         self.keytimeout.stop()
1840                         self.keytimeout.start(5000,True)
1841                         self.step = 5
1842                         self["text"].setText(_("Press Front STANDBY"))
1843
1844         def keypower(self):
1845                 if self.step== 5:
1846                         self.keytimeout.stop()
1847                         self.step = 6
1848                         self.fronttimer.start(1000,True)
1849                         self["text"].setText(_("Front LED OK?\n\nyes-ok\nno-exit"))
1850
1851         def keyCancel(self):
1852                 global fronttest
1853                 self.fronttimer.stop()
1854                 eSctest.getInstance().VFD_Close()
1855                 fronttest = 0
1856                 self.close()
1857
1858         def keyOk(self):
1859                 global fronttest
1860                 if self.step == 6:
1861                         fronttest = 1
1862                         self.fronttimer.stop()
1863                         eSctest.getInstance().VFD_Close()
1864                         self.close()
1865
1866         def FrontAnimate(self):
1867                 if (self.frontturnonoff==0):
1868                         eSctest.getInstance().turnon_VFD()
1869                         self.frontturnonoff = 1
1870                 else:
1871                         self.frontturnonoff = 0
1872                         eSctest.getInstance().turnoff_VFD()
1873                 self.fronttimer.start(1000,True)
1874
1875 class FrontTest_ultimo_Summary(Screen):
1876         skin = """
1877         <screen name="FactoryTestSummary" position="0,0" size="256,64" id="1">
1878                 <widget source="parent.Title" render="Label" position="0,0" size="256,24" font="Regular;18" halign="center" valign="center"/>
1879                 <widget name="text" position="0,24" size="256,40" font="VFD;20" halign="center" valign="center"/>
1880         </screen>"""
1881
1882         def __init__(self, session, parent):
1883                 Screen.__init__(self, session, parent = parent)
1884                 self["text"] = Label("Press Front STANDBY")
1885
1886         def setText(self, text = ""):
1887                 if not isinstance(text, str):
1888                         text = str(text)
1889                 self["text"].setText(text)
1890
1891 class FrontTest_ultimo(FrontTest_solo):
1892         skin = """
1893                 <screen position="center,center" size="300,180" title="Front Test" >
1894                 <widget name="text" position="10,10" size="280,160" font="Regular;30" />
1895                 </screen>"""
1896
1897         def createSummary(self):
1898                 return FrontTest_ultimo_Summary
1899
1900         def KeyTimeOut(self):
1901                 if self.step == 1:
1902                         self["text"].setText(("Front STANDBY ERROR\nPress exit!"))
1903                         self.summaries.setText("Front STANDBY ERROR\nPress exit!")
1904                 elif self.step == 2 :
1905                         self["text"].setText(("Front CH - ERROR\nPress exit!"))
1906                         self.summaries.setText("Front CH - ERROR\nPress exit!")
1907                 elif self.step == 3:
1908                         self["text"].setText(("Front CH + ERROR\nPress exit!"))
1909                         self.summaries.setText("Front CH + ERROR\nPress exit!")
1910                 elif self.step == 4 :
1911                         self["text"].setText(("Front VOL - ERROR\nPress exit!"))
1912                         self.summaries.setText("Front VOL - ERROR\nPress exit!")
1913                 elif self.step == 5:
1914                         self["text"].setText(("Front VOL + ERROR\nPress exit!"))
1915                         self.summaries.setText("Front VOL + ERROR\nPress exit!")
1916                 self.step = 0
1917
1918         def keypower(self):
1919                 if self.step== 1:
1920                         self.keytimeout.stop()
1921                         self.keytimeout.start(5000,True)
1922                         self.step = 2
1923                         self["text"].setText(_("Press Front CH -"))
1924                         self.summaries.setText(_("Press Front CH -"))
1925
1926         def keyright(self):
1927                 if self.step== 3:
1928                         self.keytimeout.stop()
1929                         self.keytimeout.start(5000,True)
1930                         self.step = 4
1931                         self["text"].setText(_("Press Front VOL -"))
1932                         self.summaries.setText(_("Press Front VOL -"))
1933
1934         def keyleft(self):
1935                 if self.step== 2:
1936                         self.keytimeout.stop()
1937                         self.keytimeout.start(5000,True)
1938                         self.step = 3
1939                         self["text"].setText(_("Press Front CH +"))
1940                         self.summaries.setText(_("Press Front CH +"))
1941
1942         def keyvolup(self):
1943                 if self.step== 5:
1944                         self.keytimeout.stop()
1945                         self.step = 6
1946                         self.fronttimer.start(1000,True)
1947                         self["text"].setText(_("Front LED OK?\n\nyes-ok\nno-exit"))
1948                         self.summaries.setText(_("Front LED OK?"))
1949
1950         def keyvoldown(self):
1951                 if self.step== 4:
1952                         self.keytimeout.stop()
1953                         self.keytimeout.start(5000,True)
1954                         self.step = 5
1955                         self["text"].setText(_("Press Front VOL +"))
1956                         self.summaries.setText(_("Press Front VOL +"))
1957
1958         def FrontAnimate(self):
1959                 if (self.frontturnonoff==0):
1960                         eSctest.getInstance().turnon_VFD()
1961                         self.frontturnonoff = 1
1962                         self.fronttimer.start(1500,True)
1963                 else:
1964                         self.frontturnonoff = 0
1965                         eSctest.getInstance().turnoff_VFD()
1966                         self.fronttimer.start(500,True)
1967
1968 rstest = 0
1969
1970 import select
1971
1972 class RS232Test(Screen):
1973         skin = """
1974                 <screen name="RS232Test" position="center,center" size="260,100" title="RS232 Test" >
1975                         <widget name="text" position="10,10" size="240,80" font="Regular;30" />
1976                 </screen>"""
1977         step=1
1978         def __init__(self, session):
1979                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions"],
1980                 {
1981                         "cancel": self.keyCancel,
1982                 }, -2)
1983
1984                 Screen.__init__(self, session)
1985                 self["text"]=Label(("Press \"Enter\" Key"))
1986                 self.timer = eTimer()
1987                 self.timer.callback.append(self.checkrs232)
1988                 self.timer.start(100, True)
1989
1990         def checkrs232(self):
1991                 global rstest
1992                 try:
1993                         rs=open('/dev/ttyS0','r')
1994                         rd = [rs]
1995                         r,w,e = select.select(rd, [], [], 10)
1996                         if r:
1997                                 input = rs.read(1)
1998                                 if input == "\n":
1999                                         rstest = 1
2000                                 else:
2001                                         rstest = 0
2002                         else:
2003                                 rstest = 0
2004                         rs.close()
2005                 except:
2006                         try:
2007                                 if rs:
2008                                         rs.close()
2009                         except:
2010                                 pass
2011                         print 'except error'
2012                         rstest = 0
2013                 if rstest == 0:
2014                         self.session.open( MessageBox, _("RS232 Test Failed!\nPress 'EXIT' button!"), MessageBox.TYPE_ERROR)
2015                 self.close()
2016
2017         def keyCancel(self):
2018                 self.close()
2019
2020 class AgingTestSummary(Screen):
2021         skin = """
2022                 <screen name="AgingTestSummary" position="0,0" size="132,64" id="1">
2023                         <widget source="parent.Title" render="Label" position="6,0" size="132,64" font="Regular;18" halign="center" valign="center"/>
2024                 </screen>"""
2025
2026 class AgingTestSummaryVFD(Screen):
2027         skin = """
2028                 <screen name="AgingTestSummaryVFD" position="0,0" size="256,64" id="1">
2029                         <eLabel text="MODE: " position="0,0" size="50,16" font="VFD;14" />
2030                         <widget name="zapmode" position="51,0" size="70,16" font="VFD;14" halign="left" valign="center"/>
2031                         <widget name="timer" position="152,0" size="124,16" font="VFD;14" halign="left" valign="center"/>
2032                         <eLabel text="TUNER: " position="0,16" size="50,16" font="VFD;14" />
2033                         <widget name="curtuner" position="51,16" size="200,16" font="VFD;14" halign="left" valign="center"/>
2034                         <!-- Signal Quality -->
2035                         <eLabel text="SNR: " position="0,32" size="45,16" font="VFD;14" transparent="1" halign="left" valign="center"/>
2036                         <widget source="session.FrontendStatus" render="Label" position="46,32" size="40,16" font="VFD;14"  transparent="1">
2037                                 <convert type="FrontendInfo">SNRdB</convert>
2038                         </widget>
2039                         <!-- AGC -->
2040                         <eLabel text="AGC: " position="0,48" size="45,16" font="VFD;14"  transparent="1" noWrap="1" />
2041                         <widget source="session.FrontendStatus" render="Label" position="46,48" size="40,16" font="VFD;14"  transparent="1" noWrap="1">
2042                                 <convert type="FrontendInfo">AGC</convert>
2043                         </widget>
2044                         <widget name="error" position="90,32" size="166,32" font="VFD;18" halign="center" valign="center"/>
2045                 </screen>"""
2046
2047         def __init__(self, session, parent):
2048                 Screen.__init__(self, session)
2049                 self["zapmode"] = Label("")
2050                 self["timer"] = Label("")
2051                 self["curtuner"] = Label("")
2052                 self["error"] = Label("")
2053
2054         def setText(self, label = "zapmode",text = ""):
2055                 if not isinstance(text,str):
2056                         text = str(text)
2057                 self[label].setText(text)
2058
2059 class AgingTest(Screen):
2060         skin = """
2061                 <screen position="center,center" size="350,220" title="Aging Test" >
2062                         <widget name="text1" position="10,10" size="340,40" font="Regular;30" halign = "center" valign = "center"/>
2063                         <widget name="text2" position="10,60" size="340,40" font="Regular;30" halign = "center" valign = "center"/>
2064                         <!-- Signal Quality -->
2065                         <eLabel text="SNR : " position="40,120" size="60,25" font="Regular;25" transparent="1" />
2066                         <widget source="session.FrontendStatus" render="Label" position="100,120" size="60,25" font="Regular;25"  transparent="1">
2067                                 <convert type="FrontendInfo">SNRdB</convert>
2068                         </widget>
2069                         <!-- AGC -->
2070                         <eLabel text="AGC : " position="180,120" size="60,25" font="Regular;25"  transparent="1" noWrap="1" />
2071                         <widget source="session.FrontendStatus" render="Label" position="240,120" size="60,25" font="Regular;25"  transparent="1" noWrap="1">
2072                                 <convert type="FrontendInfo">AGC</convert>
2073                         </widget>
2074                         <widget name="text3" position="10,150" size="330,35" font="Regular;28" halign = "center" valign = "center"/>
2075                         <widget name="text4" position="10,185" size="330,35" font="Regular;20" halign = "center" valign = "center"/>
2076                 </screen>"""
2077         step=1
2078         def __init__(self, session, model):
2079                 Screen.__init__(self, session)
2080                 self["actions"] = ActionMap(["MediaPlayerActions","GlobalActions", "MediaPlayerSeekActions", "ChannelSelectBaseActions"],
2081                 {
2082                         "pause": self.keyEnd,
2083                         "stop": self.keyFinish,
2084                         "volumeUp": self.keyVolumeup,
2085                         "volumeDown": self.keyVolumedown,
2086                         "volumeMute": self.nothing,
2087                         "seekFwd" : self.keyFFW,
2088                 }, -2)
2089                 self.model = model
2090                 self["text1"]=Label(("Exit - Press Pause Key"))
2091                 self["text2"]=Label(("Reset - Press Stop Key"))
2092                 self["text3"]=Label(("Manual zapping"))
2093                 self["text4"]=Label((" "))
2094                 self.avswitch = AVSwitch()
2095                 self.curzappingmode = 'manual'
2096                 self.zapping_interval = 300
2097                 self.error = 0
2098                 self.timeout = self.zapping_interval
2099                 self.tunelist = []
2100                 self.zappinglist = {
2101                                         'DVB-S2' : [
2102                                                                 ('S-1','1:0:19:1325:3EF:1:0x64af79:0:0:0:'), # astra hd
2103                                                                 ('S-2','1:0:19:1324:3EF:1:0x64af79:0:0:0:'), # anixe hd
2104                                                                 ('S-3','1:0:19:1331:3EF:1:0x64af79:0:0:0:') # servus hd
2105                                                         ],
2106                                         'DVB-C': [
2107                                                                 ('C-1','1:0:19:1325:3EF:1:FFFF029A:0:0:0:'), # astra hd (DVB-C)
2108                                                                 ('C-2','1:0:19:1324:3EF:1:FFFF029A:0:0:0:') # anixe hd (DVB-C)
2109                                                         ]
2110                 }
2111                 self.LockCheckTimer = eTimer()
2112                 self.LockCheckTimer.callback.append(self.LockCheck)
2113                 self.nextzappingtimer = eTimer()
2114                 self.nextzappingtimer.callback.append(self.checktimeout)
2115                 self.checkTunerType()
2116                 self.makeTunelList()
2117                 self.playservice(service = self.tunelist[0][1])
2118 #               self.logmessage("AGING TEST START")
2119
2120         def createSummary(self):
2121                 if self.model == 4:
2122                         self.onShown.append(self.VFDinit)
2123                         return AgingTestSummaryVFD
2124                 else:
2125                         return AgingTestSummary
2126
2127         def setTextVFD(self, name ,text):
2128                 if self.model == 4:
2129                         self.summaries.setText(name ,text)
2130
2131         def VFDinit(self):
2132                 if self.curzappingmode == 'manual' :
2133                         self.summaries.setText("zapmode", 'MANUAL')
2134                 else:
2135                         self.summaries.setText("zapmode", 'AUTO')
2136                         self.summaries.setText("timer", "Timer %d sec"%self.timeout)
2137                 self.summaries.setText("curtuner", "%s,  CHANNEL - %s)"%(self.NimType[0], self.tunelist[0][0]))
2138
2139         def checkTunerType(self):
2140                 self.NimType={}
2141                 nimfile = open("/proc/bus/nim_sockets")
2142                 for line in nimfile.readlines():
2143                         print line
2144                         if line == "":
2145                                 break
2146                         if line.strip().startswith("NIM Socket"):
2147                                 parts = line.strip().split(" ")
2148                                 current_slot = int(parts[2][:-1])
2149                         elif line.strip().startswith("Type:"):
2150                                 self.NimType[current_slot]= str(line.strip()[6:])
2151                         elif line.strip().startswith("empty"):
2152                                 self.NimType.pop(current_slot)
2153                 nimfile.close()
2154
2155         def makeTunelList(self):
2156                 if self.NimType[0].startswith("DVB-S"):
2157                         tunetype = "DVB-S2"
2158                 elif self.NimType[0].startswith("DVB-C"):
2159                         tunetype = "DVB-C"
2160                 elif self.NimType[0].startswith("DVB-T"):
2161 #                       tunetype = "DVB-T"
2162                         pass # fix later..
2163                 try :
2164                         self.tunelist = self.zappinglist[tunetype]
2165                 except:
2166                         print "[FactoryTest] ERROR, index error (%s)"%tunetype
2167
2168         def nextZapping(self, zap_rev = False):
2169                 if zap_rev:
2170                         tunelistlen = len(self.tunelist)
2171                         nextservice = self.tunelist.pop(tunelistlen-1)
2172                         self.tunelist.insert(0,nextservice)
2173                 else:
2174                         currentservice = self.tunelist.pop(0)
2175                         self.tunelist.append(currentservice)
2176                 self.playservice(service=self.tunelist[0][1])
2177                 if self.curzappingmode == 'auto':
2178                         self.timeout = self.zapping_interval
2179                 self.setTextVFD("curtuner", "%s,  CHANNEL - %s)"%(self.NimType[0], self.tunelist[0][0]))
2180
2181         def checktimeout(self):
2182                 if self.timeout == 0:
2183                         self.nextZapping()
2184                 else:
2185                         self.timeout -=1
2186                 self["text4"].setText("remain %d sec for next tuning" %self.timeout)
2187                 self.setTextVFD("timer", "Timer %d sec"%self.timeout)
2188
2189         def playservice(self,service = '1:0:19:1325:3EF:1:0x64af79:0:0:0:'):
2190                 ref = eServiceReference(service)
2191                 self.session.nav.playService(ref)
2192                 self.avswitch.setAspectRatio(6)
2193                 self.avswitch.setColorFormat(0)
2194                 self.LockCheckTimer.start(2000,True)
2195
2196         def LockCheck(self):
2197                 result = eSctest.getInstance().getFrontendstatus(0)
2198                 if result == 0 or result == -1:
2199                         if self.model == 4:
2200                                 self.error +=1
2201                                 print "AGINGTEST - LOCK FAIL(%d)"%self.error
2202                                 self.setTextVFD("error", "LOCK FAIL(%d)"%self.error)
2203         #                       logmsg = "[LOCKFAIL][%d] TYPE : %s, CH : %s, ZAPMODE: %s"%(self.error,self.NimType[0],self.tunelist[0][0],self.curzappingmode)
2204         #                       self.logmessage(logmsg)
2205                         else:
2206                                 self.session.open( MessageBox, _("Locking Fail Error"), MessageBox.TYPE_ERROR)
2207
2208         def logmessage(self,msg):
2209                 pass
2210
2211         def nothing(self):
2212                 print "nothing"
2213
2214         def keyFFW(self):
2215                 if self.curzappingmode == 'auto':
2216                         self.curzappingmode = 'manual'
2217                         self.nextzappingtimer.stop()
2218                         self.timeout = self.zapping_interval
2219                         self["text3"].setText("Manual zapping")
2220                         self["text4"].setText("")
2221                         self.setTextVFD("zapmode", 'MANUAL')
2222                         self.setTextVFD("timer", "")
2223
2224                 elif self.curzappingmode == 'manual':
2225                         self.curzappingmode = 'auto'
2226                         self["text3"].setText("Auto zapping")
2227                         self["text4"].setText("remain %d sec for next tuning" %self.timeout)
2228                         self.setTextVFD("zapmode", 'AUTO')
2229                         self.setTextVFD("timer", "Timer %d sec"%self.timeout)
2230 #                       self.timeout = self.zapping_interval
2231                         self.nextzappingtimer.start(1000)
2232
2233         def keyVolumeup(self):
2234                 self.nextZapping(zap_rev = False)
2235
2236         def keyVolumedown(self):
2237                 self.nextZapping(zap_rev = True)
2238
2239         def nothing(self):
2240                 print "nothing"
2241
2242         def keyEnd(self):
2243                 self.session.nav.stopService()
2244                 self.close(0) # exit
2245
2246         def keyFinish(self):
2247                 self.session.nav.stopService()
2248                 self.close(1) # exit and reset
2249
2250 class AgingTest_mode2_Summary(Screen):
2251         skin = """
2252                 <screen name="AgingTest_mode2_Summary" position="0,0" size="132,64" id="1">
2253                         <widget source="parent.Title" render="Label" position="6,0" size="132,64" font="Regular;18" halign="center" valign="center"/>
2254                 </screen>"""
2255
2256 class AgingTest_mode2_Summary_VFD(Screen):
2257         skin = """
2258                 <screen name="AgingTest_mode2_Summary_VFD" position="0,0" size="256,64" id="1">
2259                         <eLabel text="MODE: " position="0,0" size="50,16" font="VFD;14" />
2260                         <widget name="zapmode" position="51,0" size="70,16" font="VFD;14" halign="left" valign="center"/>
2261                         <widget name="timer" position="152,0" size="124,16" font="VFD;14" halign="left" valign="center"/>
2262                         <eLabel text="TUNER: " position="0,16" size="50,16" font="VFD;14" />
2263                         <widget name="curtuner" position="51,16" size="200,16" font="VFD;14" halign="left" valign="center"/>
2264                         <!-- Signal Quality -->
2265                         <eLabel text="SNR: " position="0,32" size="45,16" font="VFD;14" transparent="1" halign="left" valign="center"/>
2266                         <widget source="session.FrontendStatus" render="Label" position="46,32" size="40,16" font="VFD;14"  transparent="1">
2267                                 <convert type="FrontendInfo">SNRdB</convert>
2268                         </widget>
2269                         <!-- AGC -->
2270                         <eLabel text="AGC: " position="0,48" size="45,16" font="VFD;14"  transparent="1" noWrap="1" />
2271                         <widget source="session.FrontendStatus" render="Label" position="46,48" size="40,16" font="VFD;14"  transparent="1" noWrap="1">
2272                                 <convert type="FrontendInfo">AGC</convert>
2273                         </widget>
2274                         <widget name="error" position="90,32" size="166,32" font="VFD;18" halign="center" valign="center"/>
2275                 </screen>"""
2276
2277         def __init__(self, session, parent):
2278                 Screen.__init__(self, session)
2279                 self["zapmode"] = Label("")
2280                 self["timer"] = Label("")
2281                 self["curtuner"] = Label("")
2282                 self["error"] = Label("")
2283
2284         def setText(self, label = "zapmode",text = ""):
2285                 if not isinstance(text,str):
2286                         text = str(text)
2287                 self[label].setText(text)
2288
2289 from Components.Input import Input
2290 from Screens.InputBox import InputBox
2291 class AgingTest_mode2(Screen):
2292         skin = """
2293                 <screen position="center,center" size="370,190" title="Aging Test 2" >
2294                         <widget name="text1" position="10,10" size="350,40" font="Regular;30" halign="center" valign="center"/>
2295                         <widget name="text2" position="10,60" size="350,30" font="Regular;25" halign="center" valign="center"/>
2296                         <!-- Signal Quality -->
2297                         <eLabel text="SNR : " position="50,100" size="60,25" font="Regular;25" transparent="1" />
2298                         <widget source="session.FrontendStatus" render="Label" position="110,100" size="60,25" font="Regular;25"  transparent="1">
2299                                 <convert type="FrontendInfo">SNRdB</convert>
2300                         </widget>
2301                         <!-- AGC -->
2302                         <eLabel text="AGC : " position="190,100" size="60,25" font="Regular;25"  transparent="1" noWrap="1" />
2303                         <widget source="session.FrontendStatus" render="Label" position="250,100" size="60,25" font="Regular;25"  transparent="1" noWrap="1">
2304                                 <convert type="FrontendInfo">AGC</convert>
2305                         </widget>
2306                         <widget name="text3" position="10,130" size="350,25" font="Regular;18" halign="center" valign="center"/>
2307                         <widget name="text4" position="10,155" size="350,25" font="Regular;18" halign="center" valign="center"/>
2308                 </screen>"""
2309         step=1
2310         def __init__(self, session,model = 4):
2311                 self["actions"] = ActionMap(["MediaPlayerActions","GlobalActions","InfobarMenuActions","ChannelSelectBaseActions"],
2312                 {
2313                         "pause": self.keyEnd,
2314                         "stop": self.keyFinish,
2315                         "volumeUp": self.keyVolumeup,
2316                         "volumeDown": self.keyVolumedown,
2317                         "volumeMute": self.nothing,
2318                         "mainMenu" : self.keyMenu,
2319                         "nextBouquet" : self.keyChannelup,
2320                         "prevBouquet" : self.keyChannelDown,
2321                         "showFavourites" : self.keyBlue,
2322                 }, -2)
2323
2324                 Screen.__init__(self, session)
2325                 self.model = model
2326                 self.slotindex = { 0 : 'A', 1 : 'B', 2 : 'C', 3: 'D'}
2327                 self.curtuner = 0
2328                 self.isChangeTuner = True
2329                 self.isChangeChannel = False
2330                 self.zapping_interval = 300
2331                 self.timeout = self.zapping_interval
2332                 self.avswitch = AVSwitch()
2333                 self.error = 0
2334                 self.LockCheckTimer = eTimer()
2335                 self.LockCheckTimer.callback.append(self.LockCheck)
2336                 self.nextzappingtimer = eTimer()
2337                 self.nextzappingtimer.callback.append(self.checktimeout)
2338                 self.tunelist_db = {
2339                                         'DVB-S2' : [
2340                                                                 [
2341                                                                         ('1-1','1:0:19:1325:3EF:1:0x64af79:0:0:0:'), # astra hd
2342                                                                         ('1-2','1:0:19:1324:3EF:1:0x64af79:0:0:0:'), # anixe hd
2343                                                                         ('1-3','1:0:19:1331:3EF:1:0x64af79:0:0:0:') # servus hd
2344                                                                 ],
2345                                                                 [
2346                                                                         ('2-1','1:0:19:1325:3EF:1:0xC00000:0:0:0:'), # astra hd
2347                                                                         ('2-2','1:0:19:1324:3EF:1:0xC00000:0:0:0:'), # anixe hd
2348                                                                         ('2-3','1:0:19:1331:3EF:1:0xC00000:0:0:0:') # servus hd
2349                                                                 ],
2350                                                                 [
2351                                                                         ('3-1','1:0:19:1325:3EF:1:0x282AF79:0:0:0:'), # astra hd
2352                                                                         ('3-2','1:0:19:1324:3EF:1:0x282AF79:0:0:0:'), # anixe hd
2353                                                                         ('3-3','1:0:19:1331:3EF:1:0x282AF79:0:0:0:') # servus hd
2354                                                                 ],
2355                                                                 [
2356                                                                         ('4-1','1:0:19:1325:3EF:1:0x02d0af79:0:0:0:'), # astra hd, Panamsat 4 (72.0E)
2357                                                                         ('4-2','1:0:19:1324:3EF:1:0x02d0af79:0:0:0:'), # anixe hd
2358                                                                         ('4-3','1:0:19:1331:3EF:1:0x02d0af79:0:0:0:') # servus hd
2359                                                                 ]
2360 #                                                               namespace : 0x02d0af79, 720 # Panamsat 7,10 (68.5E)
2361                                                         ],
2362                                         'DVB-C': [
2363                                                                 [
2364                                                                         ('C-1','1:0:19:1325:3EF:1:FFFF029A:0:0:0:'), # astra hd (DVB-C)
2365                                                                         ('C-2','1:0:19:1324:3EF:1:FFFF029A:0:0:0:') # anixe hd (DVB-C)
2366                                                                 ]
2367                                                         ]
2368                 }
2369                 self.tunelist = {}
2370                 self.NimType={}
2371                 self.checkTunerType()
2372                 self.makeTunelList()
2373                 self.playservice(service = self.tunelist[self.curtuner][0][1])
2374                 self.curzappingmode = 'auto'
2375                 self["text1"]=Label("ZAPPING MODE : AUTO")
2376                 self["text2"]=Label("CURRENT TUNER : %s (%s)"%(self.slotindex[self.curtuner], self.NimType[self.curtuner]))
2377                 self["text3"]=Label("remain %d sec for next tuning" %self.timeout)
2378                 self["text4"]=Label("Press 'stop' key for exit")
2379                 self.nextzappingtimer.start(1000)
2380                 self.logmessage("AGING TEST START")
2381
2382         def createSummary(self):
2383                 if self.model == 4:
2384                         self.onShown.append(self.VFDinit)
2385                         return AgingTest_mode2_Summary_VFD
2386                 else:
2387                         return AgingTest_mode2_Summary
2388
2389         def VFDinit(self):
2390                 if self.curzappingmode == 'manual' :
2391                         self.summaries.setText("zapmode", 'MANUAL')
2392                 else:
2393                         self.summaries.setText("zapmode", 'AUTO')
2394                         self.summaries.setText("timer", "Timer %d sec"%self.timeout)
2395                 self.summaries.setText("curtuner", "%s (%s,  CHANNEL - %s)"%(self.slotindex[self.curtuner], self.NimType[self.curtuner], self.tunelist[self.curtuner][0][0]))
2396
2397         def setTextVFD(self,name ,text):
2398                 if self.model == 4:
2399                         self.summaries.setText(name, text)
2400
2401         def checkTunerType(self):
2402                 nimfile = open("/proc/bus/nim_sockets")
2403                 for line in nimfile.readlines():
2404                         print line
2405                         if line == "":
2406                                 break
2407                         if line.strip().startswith("NIM Socket"):
2408                                 parts = line.strip().split(" ")
2409                                 current_slot = int(parts[2][:-1])
2410                         elif line.strip().startswith("Type:"):
2411                                 self.NimType[current_slot]= str(line.strip()[6:])
2412                         elif line.strip().startswith("empty"):
2413                                 self.NimType.pop(current_slot)
2414                 nimfile.close()
2415
2416         def makeTunelList(self):
2417                 for slot, type in self.NimType.items():
2418                         if type.startswith('DVB-S'):
2419                                 tunelist_type = 'DVB-S2'
2420                         elif type.startswith('DVB-C'):
2421                                 tunelist_type = 'DVB-C'
2422                         elif type.startswith('DVB-T'):
2423                                 tunelist_type = 'DVB-T'
2424                         try :
2425                                 self.tunelist[slot] = self.tunelist_db[tunelist_type].pop(0)
2426                         except:
2427                                 print "[FactoryTest] ERROR, pop from empty list (%s)"%tunelist_type
2428                 print "tunelist : "
2429                 print self.tunelist
2430
2431         def nextZapping(self, mode = 'auto', changeTuner = True, changeService = False, reverse_tuner = False, reverse_service = False):
2432                 if mode == 'manual' and changeTuner or mode == 'auto' and self.isChangeTuner:
2433                         if reverse_tuner:
2434                                 self.curtuner -=1
2435                         else:
2436                                 self.curtuner +=1
2437                         if self.curtuner >= len(self.tunelist):
2438                                 self.curtuner = 0
2439                         if self.curtuner < 0:
2440                                 self.curtuner = len(self.tunelist)-1
2441                 if mode == 'manual' and changeService or mode == 'auto' and self.isChangeChannel:
2442                         if reverse_service:
2443                                 tunelistlen = len(self.tunelist[self.curtuner])
2444                                 nextservice = self.tunelist[self.curtuner].pop(tunelistlen-1)
2445                                 self.tunelist[self.curtuner].insert(0,nextservice)
2446                         else:
2447                                 currentservice = self.tunelist[self.curtuner].pop(0)
2448                                 self.tunelist[self.curtuner].append(currentservice)
2449                 self.playservice(service=self.tunelist[self.curtuner][0][1])
2450                 if self.curzappingmode == 'auto':
2451                         self.timeout = self.zapping_interval
2452                 self["text2"].setText("CURRENT TUNER : %s (%s)"%(self.slotindex[self.curtuner], self.NimType[self.curtuner]))
2453                 self.setTextVFD("curtuner", "%s (%s,  CHANNEL - %s)"%(self.slotindex[self.curtuner], self.NimType[self.curtuner], self.tunelist[self.curtuner][0][0]))
2454
2455
2456         def checktimeout(self):
2457                 if self.timeout == 0:
2458                         self.nextZapping(mode = 'auto')
2459                 else:
2460                         self.timeout -=1
2461                 self["text3"].setText("remain %d sec for next tuning" %self.timeout)
2462                 self.setTextVFD("timer", "Timer %d sec"%self.timeout)
2463
2464         def playservice(self,service = '1:0:19:1325:3EF:1:0x64af79:0:0:0:'):
2465                 ref = eServiceReference(service)
2466                 self.session.nav.playService(ref)
2467                 self.avswitch.setAspectRatio(6)
2468                 self.avswitch.setColorFormat(0)
2469                 self.LockCheckTimer.start(2000,True)
2470
2471         def LockCheck(self):
2472                 result = eSctest.getInstance().getFrontendstatus(self.curtuner)
2473                 if result == 0 or result == -1:
2474                         if self.model == 4:
2475                                 self.error +=1
2476                                 print "AGINGTEST - LOCK FAIL(%d)"%self.error
2477                                 self.summaries.setText("error", "LOCK FAIL(%d)"%self.error)
2478                                 logmsg = "[LOCKFAIL][%d] SLOT : %d, TYPE : %s, CH : %s, ZAPMODE: %s"%(self.error,self.curtuner,self.NimType[self.curtuner],self.tunelist[self.curtuner][0][0],self.curzappingmode)
2479                                 self.logmessage(logmsg)
2480                         else:
2481                                 self.error +=1
2482                                 print "AGINGTEST - LOCK FAIL(%d)"%self.error
2483                                 logmsg = "[LOCKFAIL][%d] SLOT : %d, TYPE : %s, CH : %s, ZAPMODE: %s"%(self.error,self.curtuner,self.NimType[self.curtuner],self.tunelist[self.curtuner][0][0],self.curzappingmode)
2484                                 self.logmessage(logmsg)
2485                                 self.session.open( MessageBox, _("Locking Fail Error"), MessageBox.TYPE_ERROR)
2486
2487         def logmessage(self,msg):
2488                 print "[logmessage]",msg
2489                 devpath = None
2490                 checklist = ["/autofs/sda1", "/autofs/sdb1", "/autofs/sdc1", "/autofs/sdd1", "/autofs/sde1"]
2491                 for dev in checklist:
2492                         try:
2493                                 if fileExists(dev):
2494                                         if access(dev,F_OK|R_OK|W_OK):
2495                                                 dummy=open(dev+"/dummy03","w")
2496                                                 dummy.write("check")
2497                                                 dummy.close()
2498                                                 dummy=open(dev+"/dummy03","r")
2499                                                 if dummy.readline()=="check":
2500                                                         print dev," - rw check ok"
2501                                                         devpath = dev
2502                                                         break
2503                                                 else:
2504                                                         print dev," - read check error"
2505                                                 dummy.close()
2506                                                 system("rm "+dev+"/dummy03")
2507                                         else:
2508                                                 print dev," - rw access error"
2509                                 else:
2510                                         pass
2511                         except:
2512                                 print dev," - exceptional error"
2513                 if devpath:
2514                         cmd = "echo %s >> %s/agingTest.log" % (msg,devpath)
2515                         print "[logmessage] %s(%s)"%(cmd,devpath)
2516                         system(cmd)
2517
2518         def nothing(self):
2519                 print "nothing"
2520
2521         def keyBlue(self):
2522                 if self.curzappingmode == 'auto':
2523                         self.curzappingmode = 'manual'
2524                         self["text1"].setText("ZAPPING MODE : MANUAL")
2525                         self["text3"].setText("Press 'stop' key for exit")
2526                         self["text4"].setText("")
2527                         self.setTextVFD("zapmode", 'MANUAL')
2528                         self.setTextVFD("timer", "")
2529                         self.nextzappingtimer.stop()
2530                         self.timeout = self.zapping_interval
2531                 elif self.curzappingmode == 'manual':
2532                         self.curzappingmode = 'auto'
2533                         self["text1"].setText("ZAPPING MODE : AUTO")
2534                         self["text3"].setText("remain %d sec for next tuning" %self.timeout)
2535                         self["text4"].setText("Press 'stop' key for exit")
2536                         self.setTextVFD("zapmode", 'AUTO')
2537                         self.setTextVFD("timer", "Timer %d sec"%self.timeout)
2538                         self.timeout = self.zapping_interval
2539                         self.nextzappingtimer.start(1000)
2540
2541         def keyVolumeup(self):
2542                 self.nextZapping(mode = 'manual', changeTuner = False, changeService = True)
2543
2544         def keyVolumedown(self):
2545                 self.nextZapping(mode = 'manual', changeTuner = False, changeService = True, reverse_service = True)
2546
2547         def keyChannelup(self):
2548                 self.nextZapping(mode = 'manual', changeTuner = True, changeService = False)
2549
2550         def keyChannelDown(self):
2551                 self.nextZapping(mode = 'manual', changeTuner = True, changeService = False, reverse_tuner = True)
2552
2553         def keyMenu(self):
2554                 self.session.openWithCallback(self.menuCallback, AgingTest_mode2_setmenu, tuner = self.isChangeTuner, channel = self.isChangeChannel, interval = self.zapping_interval)
2555
2556         def menuCallback(self, tuner, channel, interval):
2557                 if tuner is not None:
2558                         self.isChangeTuner = tuner
2559                 if channel is not None:
2560                         self.isChangeChannel = channel
2561                 if interval is not None:
2562                         self.zapping_interval = interval
2563                         self.timeout = self.zapping_interval
2564
2565         def keyEnd(self):
2566                 self.session.nav.stopService()
2567                 self.close()
2568
2569         def keyFinish(self):
2570                 self.session.nav.stopService()
2571                 self.close()
2572
2573 from Components.ConfigList import ConfigListScreen
2574 from Components.config import ConfigInteger, ConfigYesNo, getConfigListEntry, NoSave
2575 class AgingTest_mode2_setmenu(Screen,ConfigListScreen):
2576         skin = """
2577                 <screen position="center,center" size="370,190" title="Aging Test - settings" >
2578                         <widget name="config" zPosition="2" position="10,10" size="360,180" scrollbarMode="showOnDemand" transparent="1" />
2579                         <ePixmap pixmap="Vu_HD/buttons/green.png" position="50,135" size="25,25" alphatest="on" />
2580                         <ePixmap pixmap="Vu_HD/buttons/red.png" position="215,135" size="25,25" alphatest="on" />
2581                         <widget source="key_red" render="Label" position="75,135" zPosition="1" size="90,25" font="Regular;20" halign="center" valign="center" transparent="1" />
2582                         <widget source="key_green" render="Label" position="240,135" zPosition="1" size="90,25" font="Regular;20" halign="center" valign="center" transparent="1" />
2583                 </screen>"""
2584         def __init__(self,session, tuner = True, channel = False, interval = 300):
2585                 Screen.__init__(self,session)
2586                 self.session = session
2587                 self.tuner = tuner
2588                 self.channel = channel
2589                 self.zap_interval = interval
2590                 self["key_red"] = StaticText(_("Save"))
2591                 self["key_green"] = StaticText(_("Cancel"))
2592                 self["shortcuts"] = ActionMap(["ShortcutActions", "SetupActions" ],
2593                 {
2594                         "ok": self.keySave,
2595                         "cancel": self.keyCancel,
2596                         "red": self.keyCancel,
2597                         "green": self.keySave,
2598                 }, -2)
2599                 self.list = []
2600                 ConfigListScreen.__init__(self, self.list,session = self.session)
2601                 self.config_tuner = NoSave(ConfigYesNo(default = self.tuner))
2602                 self.config_channel = NoSave(ConfigYesNo(default = self.channel))
2603                 self.config_zap_interval = NoSave(ConfigInteger(default = self.zap_interval, limits=(5, 9999) ) )
2604                 self.configSetup()
2605
2606         def configSetup(self):
2607                 self.list = []
2608                 self.setupEntryTuner = getConfigListEntry(_("change tuner on timeout"), self.config_tuner )
2609                 self.setupEntryChannel = getConfigListEntry(_("change channel on timeout"), self.config_channel )
2610                 self.setupEntryZapInterval = getConfigListEntry(_("zapping interval (sec) "), self.config_zap_interval )
2611                 self.list.append( self.setupEntryTuner )
2612                 self.list.append( self.setupEntryChannel )
2613                 self.list.append( self.setupEntryZapInterval )
2614                 self["config"].list = self.list
2615                 self["config"].l.setList(self.list)
2616
2617         def keySave(self):
2618                 self.close(self.config_tuner.value, self.config_channel.value, self.config_zap_interval.value)
2619
2620         def keyCancel(self):
2621                 self.close(None, None, None)
2622
2623 class TestTuneMenu(Screen):
2624         skin = """
2625         <screen position="350,230" size="550,300" title="Tuning Test" >
2626                 <widget name="testlist" position="10,0" size="440,250" itemHeight="35"/>
2627                 <widget name="resultlist" position="470,0" size="60,250" itemHeight="35"/>
2628                 <widget source="text" render="Label" position="100,270" size="450,30" font="Regular;22" />
2629         </screen>"""
2630
2631         def __init__(self ,session ,tuneInfo, tunelist,NimType):
2632                 self.session = session
2633                 self.NimType = NimType
2634                 self.tuneInfo = tuneInfo
2635                 self.tunelist = tunelist
2636                 self.model = 4
2637                 self["actions"] = NumberActionMap(["OkCancelActions","WizardActions","NumberActions"],
2638                 {
2639                         "left": self.nothing,
2640                         "right":self.nothing,
2641                         "ok": self.TestAction,
2642                         "cancel": self.keyCancel,
2643                         "up": self.keyup,
2644                         "down": self.keydown,
2645                         "0": self.numberaction,
2646                         "1": self.numberaction,
2647                         "2": self.numberaction,
2648                         "3": self.numberaction,
2649                         "4": self.numberaction,
2650                         "5": self.numberaction,
2651                         "6": self.numberaction,
2652                         "7": self.numberaction,
2653                         "8": self.numberaction,
2654                         "9": self.numberaction,
2655
2656                 }, -2)
2657                 Screen.__init__(self, session)
2658                 self.text = _("Press 'EXIT' key to finish tune test.")
2659                 self["text"] = StaticText(self.text)
2660                 self.createConfig()
2661                 session.nav.stopService() # try to disable foreground service
2662
2663                 self.tunemsgtimer = eTimer()
2664                 self.tunemsgtimer.callback.append(self.tunemsg)
2665
2666                 self.camstep = 1
2667                 self.camtimer = eTimer()
2668                 self.camtimer.callback.append(self.cam_state)
2669
2670                 self.tunerlock = 0
2671                 self.tuningtimer = eTimer()
2672                 self.tuningtimer.callback.append(self.updateStatus)
2673                 self.setSourceVar()
2674                 self.avswitch = AVSwitch()
2675
2676         def createConfig(self):
2677                 self.menulength= len(self.tunelist)
2678                 self["testlist"] = MenuList(self.tunelist)
2679                 self.rlist = []
2680                 for x in range(self.menulength):
2681                         self.rlist.append((".."))
2682                 self["resultlist"] = TestResultList(self.rlist)
2683
2684         def TestAction(self):
2685                 print "line - ",self["testlist"].getCurrent()[1]
2686                 self.currentindex = index = self["testlist"].getCurrent()[1]
2687                 result = 0
2688                 self.TestTune(index)
2689
2690         def nothing(self):
2691                 print "nothing"
2692
2693         def keyup(self):
2694                 print "self.menulength = ",self.menulength
2695                 print "self[\"testlist\"].getCurrent()[1] = ",self["testlist"].getCurrent()[1]
2696                 if self["testlist"].getCurrent()[1]==0:
2697                         self["testlist"].moveToIndex(self.menulength-1)
2698                         self["resultlist"].moveToIndex(self.menulength-1)
2699                 else:
2700                         self["testlist"].up()
2701                         self["resultlist"].up()
2702
2703
2704         def keydown(self):
2705                 print "self.menulength = ",self.menulength
2706                 print "self[\"testlist\"].getCurrent()[1] = ",self["testlist"].getCurrent()[1]
2707                 if self["testlist"].getCurrent()[1]==(self.menulength-1):
2708                         self["testlist"].moveToIndex(0)
2709                         self["resultlist"].moveToIndex(0)
2710                 else:
2711                         self["testlist"].down()
2712                         self["resultlist"].down()
2713
2714         def numberaction(self, number):
2715                 if number >= self.menulength:
2716                         return
2717                 index = int(number)
2718                 self["testlist"].moveToIndex(index)
2719                 self["resultlist"].moveToIndex(index)
2720
2721         def keyCancel(self):
2722                 print "testtunemenu exit"
2723                 if not '..' in self.rlist and not 'fail' in self.rlist:
2724                         self.close(True)
2725                 else:
2726                         self.close(False)
2727 #               if self.oldref is not None:
2728 #                       self.session.nav.playService(self.oldref)
2729
2730         def TestTune(self,index):
2731                 ref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0")
2732                 self.session.nav.stopService() # try to disable foreground service
2733                 getTuneInfo=self.tuneInfo[index]
2734                 if getTuneInfo["cam"] is True:
2735                         self.camstep = 1
2736                         self.camtimer.start(100,True)
2737                 if getTuneInfo["type"].startswith("DVB-S"):
2738                         if getTuneInfo["pol"] == "H":
2739                                 ref.setData(0,1)
2740                                 ref.setData(1,0x6D3)
2741                                 ref.setData(2,0x3)
2742                                 ref.setData(3,0xA4)
2743                         else:
2744                                 ref.setData(0,0x19)
2745                                 ref.setData(1,0x1325)
2746                                 ref.setData(2,0x3ef)
2747                                 ref.setData(3,0x1)
2748                         if getTuneInfo["sat"] == "160": # Eutelsat W2
2749                                 ref.setData(4,0xA00000)
2750                         elif getTuneInfo["sat"] == "100": # Eutelsat
2751                                 ref.setData(4,0x64af79)
2752                         elif getTuneInfo["sat"] == "130": # Hotbird
2753                                 ref.setData(4,0x820000)
2754                         elif getTuneInfo["sat"] == "192": # Astra
2755                                 ref.setData(4,0xC00000)
2756                         elif getTuneInfo["sat"] == "620": # Intelsat 902
2757                                 ref.setData(4,0x26c0000) # need to fix later
2758                         elif getTuneInfo["sat"] == "642": # Intelsat 906
2759                                 ref.setData(4,0x282AF79) # need to fix later
2760                 elif getTuneInfo["type"].startswith("DVB-C"):
2761                         ref.setData(0,0x19)
2762                         ref.setData(1,0x1325)
2763                         ref.setData(2,0x3ef)
2764                         ref.setData(3,0x1)
2765                         ref.setData(4,-64870) # ffff029a
2766                 elif getTuneInfo["type"].startswith("DVB-T"):
2767                         ref.setData(0,0x19)
2768                         ref.setData(1,0x1325)
2769                         ref.setData(2,0x3ef)
2770                         ref.setData(3,0x1)
2771                         ref.setData(4,-286391716) # eeee025c
2772                 self.session.nav.playService(ref)
2773                 if getTuneInfo["color"]=="CVBS":
2774                         self.avswitch.setColorFormat(0)
2775                 elif getTuneInfo["color"]=="RGB":
2776                         self.avswitch.setColorFormat(1)
2777                 elif getTuneInfo["color"]=="YC":
2778                         self.avswitch.setColorFormat(2)
2779                 if getTuneInfo["ratio"] == "4:3":
2780                         self.avswitch.setAspectRatio(0)
2781                 elif getTuneInfo["ratio"] == "16:9":
2782                         self.avswitch.setAspectRatio(6)
2783                 self.tuningtimer.start(2000,True)
2784                 self.tunemsgtimer.start(3000, True)
2785
2786         def cam_state(self):
2787                 current_index = self.currentindex
2788                 if self.camstep == 1:
2789                         slot = 0
2790                         state = eDVBCI_UI.getInstance().getState(slot)
2791                         print '-1-stat',state
2792                         if state > 0:
2793                                 self.camstep=2
2794                                 self.camtimer.start(100,True)
2795                         else:
2796                                 self.session.nav.stopService()
2797                                 self.session.open( MessageBox, _("CAM1_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
2798                                 self.rlist[current_index]="fail"
2799                                 self.tunemsgtimer.stop()
2800                 elif self.camstep == 2:
2801                         slot = 0
2802                         appname = eDVBCI_UI.getInstance().getAppName(slot)
2803                         print 'appname',appname
2804                         if appname is None:
2805                                 self.session.nav.stopService()
2806                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
2807                                 self.rlist[current_index]="fail"
2808                                 self.tunemsgtimer.stop()
2809                         else:
2810                                 self.camstep=3
2811                                 self.camtimer.start(100,True)
2812                 elif self.camstep==3:
2813                         slot = 1
2814                         state = eDVBCI_UI.getInstance().getState(slot)
2815                         print '-2-stat',state
2816                         if state > 0:
2817                                 self.camstep=4
2818                                 self.camtimer.start(100,True)
2819                         else:
2820                                 self.session.nav.stopService()
2821                                 self.session.open( MessageBox, _("CAM2_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
2822                                 self.rlist[current_index]="fail"
2823                                 self.tunemsgtimer.stop()
2824                 elif self.camstep == 4:
2825                         slot = 1
2826                         appname = eDVBCI_UI.getInstance().getAppName(slot)
2827                         print 'appname',appname
2828                         if appname is None:
2829                                 self.session.nav.stopService()
2830                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
2831                                 self.rlist[current_index]="fail"
2832                                 self.tunemsgtimer.stop()
2833                         else:
2834                                 self.setSource()
2835                                 self.camstep = 5
2836
2837         def updateStatus(self):
2838                 current_index = self.currentindex
2839                 getTuneInfo=self.tuneInfo[current_index]
2840                 result = eSctest.getInstance().getFrontendstatus(getTuneInfo["slot"])
2841                 tunno = getTuneInfo["slot"]+1
2842                 hv = getTuneInfo["pol"]
2843                 if hv == "H":
2844                         hv = "Hor"
2845                 elif hv == "V":
2846                         hv = "Ver"
2847                 else :
2848                         hv == ""
2849
2850                 print "eSctest.getInstance().getFrontendstatus - %d"%result
2851                 if result == 0 or result == -1:
2852                         self.tunerlock = 0
2853                         self.tunemsgtimer.stop()
2854                         self.session.nav.stopService()
2855                         self.avswitch.setColorFormat(0)
2856                         self.session.open( MessageBox, _("Tune%d %s Locking Fail..."%(tunno,hv)), MessageBox.TYPE_ERROR)
2857                         self.rlist[current_index]="fail"
2858                 else :
2859                         self.tunerlock = 1
2860
2861         def tuneback(self,yesno):
2862                 current_index=self.currentindex
2863                 self.session.nav.stopService() # try to disable foreground service
2864                 if yesno and self.tunerlock == 1:
2865                         getTuneInfo=self.tuneInfo[current_index]
2866                         if getTuneInfo["cam"] and self.camstep < 5: # need fix to depending about CAM exist
2867                                 self.rlist[current_index]="fail"
2868                         else :
2869                                 self.rlist[current_index]="pass"
2870                 else:
2871                         self.rlist[current_index]="fail"
2872                 if self.tuneInfo[current_index]["color"] == "YC":
2873                         self.avswitch.setColorFormat(0)
2874                 self.resetSource()
2875                 self["resultlist"].updateList(self.rlist)
2876
2877         def tunemsg(self):
2878                 self.tuningtimer.stop()
2879                 self.session.openWithCallback(self.tuneback, TuneMessageBox, _("%s ok?" %(self["testlist"].getCurrent()[0])), MessageBox.TYPE_YESNO)
2880
2881         def setSourceVar(self):
2882                 self.input_pad_num=len(self.NimType)-1
2883                 if self.input_pad_num == 0:
2884                         self.setTuner = 'A'
2885                 elif self.input_pad_num == 1:
2886                         self.setTuner = 'B'
2887                 elif self.input_pad_num == 2:
2888                         self.setTuner = 'C'
2889
2890 #       ikseong - for 22000 tp
2891         def setSource(self):
2892 # fix input source
2893                 inputname = ("/proc/stb/tsmux/input%d" % self.input_pad_num)
2894                 print "<setsource> inputname : ",inputname
2895                 fd=open(inputname,"w")
2896                 fd.write("CI0")
2897                 fd.close()
2898 # fix ci_input Tuner
2899                 filename = ("/proc/stb/tsmux/ci0_input")
2900                 fd = open(filename,'w')
2901                 fd.write(self.setTuner)
2902                 print "setTuner(CI0) : ",self.setTuner
2903                 fd.close()
2904                 print "CI loop test!!!!!!!!!!!!!!"
2905
2906         def resetSource(self):
2907                 inputname = ("/proc/stb/tsmux/input%d" % self.input_pad_num)
2908                 print "<resetsource> inputname : ",inputname
2909                 fd=open(inputname,"w")
2910                 fd.write(self.setTuner)
2911                 fd.close()
2912                 print "CI loop test end!!!!!!!!!!!!!!"
2913
2914 session = None
2915
2916
2917 def cleanup():
2918         global Session
2919         Session = None
2920         global Servicelist
2921         Servicelist = None
2922
2923 def main(session, servicelist, **kwargs):
2924         global Session
2925         Session = session
2926         global Servicelist
2927         Servicelist = servicelist
2928         bouquets = Servicelist.getBouquetList()
2929         global bouquetSel
2930         bouquetSel = Session.openWithCallback(cleanup, FactoryTest)
2931
2932 #def Plugins(**kwargs):
2933 #       return PluginDescriptor(name=_("Factory Test"), description="Test App for Factory", where = PluginDescriptor.WHERE_EXTENSIONSMENU, fnc=main)
2934
2935 def Plugins(**kwargs):
2936         return []