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 FactoryTest(Screen):
  97         skin = """
  98                 <screen name="FactoryTest" position="300,100" size="660,550" title="Test Menu" >
  99                         <widget name="testlist" position="10,0" size="440,455" itemHeight="35" />
 100                         <widget name="resultlist" position="470,0" size="60,455" itemHeight="35" />
 101                         <widget name="testdate" position="20,470" size="250,35" font="Regular;30" />
 102                         <widget name="testversion" position="20,505" size="250,35" font="Regular;30" />
 103                         <widget name="mactext" position="320,470" size="340,35" font="Regular;30" />
 104                 </screen>"""
 105
 106         def __init__(self, session):
 107
 108                 self["actions"] = NumberActionMap(["OkCancelActions","WizardActions","NumberActions","ColorActions",],
 109                 {
 110                         "left": self.nothing,
 111                         "right":self.nothing,
 112                         "ok": self.TestAction,
 113                         "testexit": self.keyCancel,
 114                         "agingstart": self.Agingmode,
 115                         "up": self.keyup,
 116                         "down": self.keydown,
 117                         "0": self.numberaction,
 118                         "1": self.numberaction,
 119                         "2": self.numberaction,
 120                         "3": self.numberaction,
 121                         "4": self.numberaction,
 122                         "5": self.numberaction,
 123                         "6": self.numberaction,
 124                         "7": self.numberaction,
 125                         "8": self.numberaction,
 126                         "9": self.numberaction,
 127                         "red": self.shutdownaction,
 128                 }, -2)
 129
 130                 Screen.__init__(self, session)
 131                 TESTPROGRAM_DATE = self.getImageVersion() +" (v1.10)"
 132                 TESTPROGRAM_VERSION = "Version 01.10"
 133
 134                 self.model = 0
 135                 self.getModelInfo()
 136
 137                 self["testdate"]=Label((TESTPROGRAM_DATE))
 138                 self["testversion"]=Label(("Loading version..."))
 139                 self["mactext"]=Label(("Loading mac address..."))
 140                 if self.model == 0 or self.model == 1:
 141                         nimConfig = nimmanager.getNimConfig(0)
 142                         nimConfig.configMode.slot_id=0
 143                         nimConfig.configMode.value= "simple"
 144                         nimConfig.diseqcMode.value="diseqc_a_b"
 145                         nimConfig.diseqcA.value="160"
 146                         nimConfig.diseqcB.value="100"
 147                 if self.model == 0:
 148                         nimConfig = nimmanager.getNimConfig(1)
 149                         nimConfig.configMode.slot_id=1
 150                         nimConfig.configMode.value= "simple"
 151                         nimConfig.diseqcMode.value="diseqc_a_b"
 152                         nimConfig.diseqcA.value="130"
 153                         nimConfig.diseqcB.value="192"
 154                 if self.model == 2:
 155                         pass
 156                 if self.model == 3 or self.model == 4:
 157                         self.NimType = {}
 158                         sat_list = ["160","100","130","192","620","642"]
 159                         try:
 160                                 nimfile = open("/proc/bus/nim_sockets")
 161                         except IOError:
 162                                 nimfile = None
 163                         if nimfile is None:
 164                                 self.session.openWithCallback(self.close, MessageBox, _("File not Found!\n/proc/bus/nim_sockets"), MessageBox.TYPE_ERROR)
 165                         for line in nimfile.readlines():
 166                                 print line
 167                                 if line == "":
 168                                         break
 169                                 if line.strip().startswith("NIM Socket"):
 170                                         parts = line.strip().split(" ")
 171                                         current_slot = int(parts[2][:-1])
 172                                         self.NimType[current_slot]={}
 173                                         self.NimType[current_slot]["slot"] = current_slot
 174                                 elif line.strip().startswith("Type:"):
 175                                         print str(line.strip())
 176                                         self.NimType[current_slot]["type"] = str(line.strip()[6:])
 177                                         if self.NimType[current_slot]["type"].startswith("DVB-S"):
 178                                                 self.NimType[current_slot]["sat1"] = sat_list.pop(0)
 179                                                 self.NimType[current_slot]["sat2"] = sat_list.pop(0)
 180                                         else:
 181                                                 self.NimType[current_slot]["sat1"] = None
 182                                                 self.NimType[current_slot]["sat2"] = None
 183                                 elif line.strip().startswith("empty"):
 184                                         self.NimType.pop(current_slot)
 185                         nimfile.close()
 186                         if True:
 187                                 for (key, val) in self.NimType.items():
 188                                         print key
 189                                         print val
 190                                         if val["type"].startswith("DVB-S"):
 191                                                 print "nimConfig (dvb-s): ",key
 192                                                 nimConfig = nimmanager.getNimConfig(key)
 193                                                 nimConfig.configMode.slot_id=key
 194                                                 nimConfig.configMode.value= "simple"
 195                                                 nimConfig.diseqcMode.value="diseqc_a_b"
 196                                                 nimConfig.diseqcA.value = val["sat1"]
 197                                                 nimConfig.diseqcB.value = val["sat2"]
 198                                         else :
 199                                                 nimConfig = nimmanager.getNimConfig(key)
 200                                                 print "configMode check : ",nimConfig.configMode.value
 201
 202                 nimmanager.sec.update()
 203
 204                 system("cp /usr/lib/enigma2/python/Plugins/SystemPlugins/FactoryTest/testdb /etc/enigma2/lamedb")
 205                 db = eDVBDB.getInstance()
 206                 db.reloadServicelist()
 207                 self.createConfig()
 208
 209                 self.rlist = []
 210                 for x in range(self.menulength-1):
 211                         self.rlist.append((".."))
 212                 self.rlist.append((" "))
 213                 self["resultlist"] = TestResultList(self.rlist)
 214
 215                 self.avswitch = AVSwitch()
 216                 self.scTest= eSctest()
 217
 218                 self.testing = 0
 219
 220                 self.servicelist = ServiceList()
 221                 self.oldref = session.nav.getCurrentlyPlayingServiceReference()
 222                 print "oldref",self.oldref
 223                 session.nav.stopService() # try to disable foreground service
 224
 225                 self.tunemsgtimer = eTimer()
 226                 self.tunemsgtimer.callback.append(self.tunemsg)
 227
 228                 self.camstep = 1
 229                 self.camtimer = eTimer()
 230                 self.camtimer.callback.append(self.cam_state)
 231                 self.mactry = 1
 232                 self.getmacaddr()
 233                 self.getversion()
 234
 235                 self.tunerlock = 0
 236                 self.tuningtimer = eTimer()
 237                 self.tuningtimer.callback.append(self.updateStatus)
 238
 239                 self.satatry = 8
 240                 self.satatimer = eTimer()
 241                 self.satatimer.callback.append(self.sataCheck)
 242
 243                 self.usbtimer = eTimer()
 244                 self.usbtimer.callback.append(self.usbCheck)
 245
 246                 self.agingtimer = eTimer()
 247                 self.agingtimer.callback.append(self.agingCheck)
 248                 self.setSourceVar()
 249
 250         def createConfig(self):
 251                 tlist = []
 252                 self.satetestIndex = -1
 253                 self.scarttestIndex = -1
 254                 if self.model == 0:
 255                         self.satetestIndex=0
 256                         tlist.append((" 0. Sata & extend hdd test",self.satetestIndex))
 257                         self.usbtestIndex=1
 258                         tlist.append((" 1. USB test",self.usbtestIndex))
 259                         self.fronttestIndex=2
 260                         tlist.append((" 2. Front test",self.fronttestIndex))
 261                         self.smarttestIndex=3
 262                         tlist.append((" 3. Smartcard test",self.smarttestIndex))
 263                         self.tuner1_1testIndex=4
 264                         tlist.append((" 4. T1/H/22K x /4:3/CVBS",self.tuner1_1testIndex))
 265                         self.tuner1_2testIndex=5
 266                         tlist.append((" 5. T1/V/22k o/16:9/RGB",self.tuner1_2testIndex))
 267                         self.tuner2_1testIndex=6
 268                         tlist.append((" 6. T2/H/22k x/4:3/YC",self.tuner2_1testIndex))
 269                         self.tuner2_2testIndex=7
 270                         tlist.append((" 7. T2/V/22k o/16:9/CVBS/CAM",self.tuner2_2testIndex))
 271                         self.scarttestIndex=8
 272                         tlist.append((" 8. VCR Scart loop",self.scarttestIndex))
 273                         self.rs232testIndex=9
 274                         tlist.append((" 9. RS232 test",self.rs232testIndex))
 275                         self.ethernettestIndex=10
 276                         tlist.append(("10. Ethernet & mac test",self.ethernettestIndex))
 277                         self.fdefaultIndex=11
 278                         tlist.append(("11. Factory default",self.fdefaultIndex))
 279                         self.shutdownIndex=12
 280                         tlist.append(("12. Shutdown(Deep Standby)",self.shutdownIndex))
 281                         self.tuner_test_first_index = 4
 282                         self.tuner_test_last_index = 7
 283
 284                 elif self.model == 1:
 285                         self.usbtestIndex=0
 286                         tlist.append((" 0. USB test",self.usbtestIndex))
 287                         self.fronttestIndex=1
 288                         tlist.append((" 1. Front test",self.fronttestIndex))
 289                         self.smarttestIndex=2
 290                         tlist.append((" 2. Smartcard test",self.smarttestIndex))
 291                         self.tuner1_1testIndex=3
 292                         tlist.append((" 3. T1/H/22K x/4:3/CVBS",self.tuner1_1testIndex))
 293                         self.tuner2_2testIndex = self.tuner1_2testIndex=4
 294                         tlist.append((" 4. T1/V/22k o/16:9/RGB/CAM",self.tuner1_2testIndex))
 295                         self.rs232testIndex=5
 296                         tlist.append((" 5. RS232 test",self.rs232testIndex))
 297                         self.ethernettestIndex=6
 298                         tlist.append((" 6. Ethernet & mac test",self.ethernettestIndex))
 299                         self.fdefaultIndex=7
 300                         tlist.append((" 7. Factory default",self.fdefaultIndex))
 301                         self.shutdownIndex=8
 302                         tlist.append((" 8. Shutdown(Deep Standby)",self.shutdownIndex))
 303                         self.tuner_test_first_index = 3
 304                         self.tuner_test_last_index = 4
 305
 306                 elif self.model == 2:
 307                         self.satetestIndex=0
 308                         tlist.append((" 0. Sata & extend hdd test",self.satetestIndex))
 309                         self.usbtestIndex=1
 310                         tlist.append((" 1. USB test",self.usbtestIndex))
 311                         self.fronttestIndex=2
 312                         tlist.append((" 2. Front test",self.fronttestIndex))
 313                         self.smarttestIndex=3
 314                         tlist.append((" 3. Smartcard test",self.smarttestIndex))
 315                         self.tuner1_1testIndex=4
 316                         tlist.append((" 4. T1 H 22K x 4:3 CVBS",self.tuner1_1testIndex))
 317                         self.tuner1_2testIndex=5
 318                         tlist.append((" 5. T1 V 22k o 16:9 RGB",self.tuner1_2testIndex))
 319                         self.tuner2_1testIndex = -1
 320                         self.tuner2_2testIndex=6
 321                         tlist.append((" 6. T2 DVB-C 4:3 YC CAM",self.tuner2_2testIndex))
 322                         self.rs232testIndex=7
 323                         tlist.append((" 7. RS232 test",self.rs232testIndex))
 324                         self.ethernettestIndex=8
 325                         tlist.append(("8. Ethernet & mac test",self.ethernettestIndex))
 326                         self.fdefaultIndex=9
 327                         tlist.append(("9. Factory default",self.fdefaultIndex))
 328                         self.shutdownIndex=10
 329                         tlist.append(("10. Shutdown",self.shutdownIndex))
 330                         self.tuner_test_first_index = 4
 331                         self.tuner_test_last_index = 6
 332
 333                 elif self.model == 3 or self.model == 4:
 334                         self.satetestIndex=0
 335                         tlist.append((" 0. Sata & extend hdd test",self.satetestIndex))
 336                         self.usbtestIndex=1
 337                         tlist.append((" 1. USB test",self.usbtestIndex))
 338                         self.fronttestIndex=2
 339                         tlist.append((" 2. Front test",self.fronttestIndex))
 340                         self.smarttestIndex=3
 341                         tlist.append((" 3. Smartcard test",self.smarttestIndex))
 342                         if self.model == 3:
 343                                 self.tuner_test_first_index = current_index = 4
 344                         elif self.model == 4:
 345                                 self.tuner_test_first_index = 4
 346                                 current_index = 0
 347                         AspectRatio=["4:3", "16:9"]
 348                         ColorFormat=["CVBS","RGB","YC","CVBS","CVBS","CVBS","CVBS","CVBS"]
 349                         self.tuneInfo={}
 350                         tunelist = []
 351                         for (key, val) in self.NimType.items():
 352                                 if val["type"].startswith("DVB-S"):
 353 # Chang : DVB -S setting diseqc A
 354                                         getRatio = AspectRatio.pop(0) # ratio
 355                                         AspectRatio.append(getRatio)
 356                                         getColorFormat=ColorFormat.pop(0) # colorFormat
 357                                         menuname=" %d. T%d/%s/H/22k x/%s/%s" % (current_index, key+1, val["type"], getRatio, getColorFormat)    #menuname
 358                                         print current_index
 359 #                                               current_index=4
 360                                         self.setTuneInfo(index=current_index, slot=key, type=val["type"], sat=val["sat1"], pol="H", tone=False, ratio=getRatio, color=getColorFormat, cam=False) # setTuneInfo
 361 #                                               self.setTuneInfo(current_index, key, val["type"], val["sat1"], "H", True, getRatio, getColorFormat, False) # setTuneInfo
 362                                         tunelist.append((menuname,current_index))
 363                                         current_index+=1
 364 # Chang : DVB -S setting diseqc B
 365                                         getRatio = AspectRatio.pop(0)
 366                                         AspectRatio.append(getRatio)
 367                                         getColorFormat=ColorFormat.pop(0)
 368                                         menuname=" %d. T%d/%s/V/22k o/%s/%s" % (current_index, key+1, val["type"], getRatio, getColorFormat)
 369                                         if len(self.NimType) == key+1: # CAM test on/off
 370                                                 menuname+="/CAM"
 371                                                 camtest = True
 372                                         else:
 373                                                 camtest = False
 374                                         self.setTuneInfo( index=current_index, slot=key, type=val["type"], sat=val["sat2"], pol="V", tone=True, ratio=getRatio, color=getColorFormat, cam=camtest)
 375                                         tunelist.append((menuname,current_index))
 376                                         current_index+=1
 377 # Chang : DVB -T or DVB-C
 378                                 elif val["type"].startswith("DVB-T") or val["type"].startswith("DVB-C"):
 379                                         additionalMenu = None
 380                                         menulen = 1
 381                                         if len(self.NimType) == 1:
 382                                                 additionalMenu = True
 383                                                 menulen +=1
 384                                         for x in range(menulen):
 385                                                 getRatio = AspectRatio.pop(0)
 386                                                 AspectRatio.append(getRatio)
 387                                                 getColorFormat=ColorFormat.pop(0)
 388                                                 menuname=" %d. T%d/%s/%s/%s" % (current_index, key+1, val["type"], getRatio, getColorFormat)
 389                                                 if len(self.NimType) == key+1 and (additionalMenu is None or x != 0): # CAM test on/off
 390                                                         menuname+=" CAM"
 391                                                         camtest = True
 392                                                 else:
 393                                                         camtest = False
 394                                                 self.setTuneInfo( index=current_index, slot=key, type=val["type"], sat=None, pol=None, tone=None, ratio=getRatio, color=getColorFormat, cam=camtest)
 395                                                 tunelist.append((menuname,current_index))
 396                                                 current_index+=1
 397                         if self.model == 3:
 398                                 tlist.extend(tunelist)
 399                                 self.tuner_test_last_index = current_index-1
 400                         elif self.model == 4:
 401                                 self.tunelist = tunelist
 402                                 self.tuner_test_last_index = 4
 403                                 current_index = self.tuner_test_last_index
 404                                 tlist.append((" %d. Tuning test" % current_index,self.tuner_test_last_index))
 405                                 current_index+=1
 406                         self.rs232testIndex=current_index
 407                         tlist.append((" %d. RS232 test" % current_index,self.rs232testIndex))
 408                         current_index+=1
 409                         self.ethernettestIndex=current_index
 410                         tlist.append((" %d. Ethernet & mac test" % current_index,self.ethernettestIndex))
 411                         current_index+=1
 412                         self.fdefaultIndex=current_index
 413                         tlist.append((" %d. Factory default" % current_index,self.fdefaultIndex))
 414                         current_index+=1
 415                         self.shutdownIndex=current_index
 416                         tlist.append((" %d. Shutdown(Deep Standby)" % current_index,self.shutdownIndex))
 417
 418                 self.menulength= len(tlist)
 419                 self["testlist"] = MenuList(tlist)
 420
 421         def setTuneInfo(self,index=0,slot=0,type="DVB-S2",sat="160",pol="H",tone=True,ratio="4:3",color="CVBS",cam=False):
 422                 self.tuneInfo[index]={}
 423                 self.tuneInfo[index]["slot"]=slot
 424                 self.tuneInfo[index]["type"]=type
 425                 self.tuneInfo[index]["sat"]=sat
 426                 self.tuneInfo[index]["pol"]=pol
 427                 self.tuneInfo[index]["22k"]=tone
 428                 self.tuneInfo[index]["ratio"]=ratio
 429                 self.tuneInfo[index]["color"]=color
 430                 self.tuneInfo[index]["cam"]=cam
 431
 432         def getModelInfo(self):
 433                 getmodel = 0
 434                 if fileExists("/proc/stb/info/vumodel"):
 435                         vumodel = open("/proc/stb/info/vumodel")
 436                         info=vumodel.read().strip()
 437                         vumodel.close()
 438                         if info == "duo":
 439                                 self.model = 0
 440                                 getmodel = 1
 441                                 print "getModelInfo : duo"
 442                         if info == "solo":
 443                                 self.model = 1
 444                                 getmodel = 1
 445                                 print "getModelInfo : solo"
 446                         if info == "combo":
 447                                 self.model = 2
 448                                 getmodel = 1
 449                                 print "getModelInfo : combo"
 450                         if info == "uno":
 451                                 self.model = 3
 452                                 getmodel = 1
 453                                 print "getModelInfo : uno"
 454                         if info == "ultimo":
 455                                 self.model = 4
 456                                 getmodel = 1
 457                                 print "getModelInfo : ultimo"
 458
 459                 if getmodel == 0 and fileExists("/proc/stb/info/version"):
 460                         vesion = open("/proc/stb/info/version")
 461                         info=version.read()
 462                         version.close()
 463                         if info[:2] == "14":
 464                                 self.model = 1
 465                                 print "getModelInfo : solo_"
 466                         elif info[:2] == "12":
 467                                 self.model = 0
 468                                 print "getModelInfo : duo_"
 469
 470         def nothing(self):
 471                 print "nothing"
 472
 473         def keyup(self):
 474                 print "self.menulength = ",self.menulength
 475                 print "self[\"testlist\"].getCurrent()[1] = ",self["testlist"].getCurrent()[1]
 476                 if self.testing==1:
 477                         return
 478                 if self["testlist"].getCurrent()[1]==0:
 479                         self["testlist"].moveToIndex(self.menulength-1)
 480                         self["resultlist"].moveToIndex(self.menulength-1)
 481                 else:
 482                         self["testlist"].up()
 483                         self["resultlist"].up()
 484
 485
 486         def keydown(self):
 487                 print "self.menulength = ",self.menulength
 488                 print "self[\"testlist\"].getCurrent()[1] = ",self["testlist"].getCurrent()[1]
 489                 if self.testing==1:
 490                         return
 491                 if self["testlist"].getCurrent()[1]==(self.menulength-1):
 492                         self["testlist"].moveToIndex(0)
 493                         self["resultlist"].moveToIndex(0)
 494                 else:
 495                         self["testlist"].down()
 496                         self["resultlist"].down()
 497
 498         def numberaction(self, number):
 499                 if self.testing==1:
 500                         return
 501                 if number >= self.menulength:
 502                         return
 503                 index = int(number)
 504                 self["testlist"].moveToIndex(index)
 505                 self["resultlist"].moveToIndex(index)
 506
 507         def getImageVersion(self):
 508                 date = 'xxxx-xx-xx'
 509                 file = open(resolveFilename(SCOPE_SYSETC, 'image-version'), 'r')
 510                 lines = file.readlines()
 511                 for x in lines:
 512                         splitted = x.split('=')
 513                         if splitted[0] == "version":
 514                         #     YYYY MM DD hh mm
 515                                 #0120 2005 11 29 01 16
 516                                 #0123 4567 89 01 23 45
 517                                 version = splitted[1]
 518                                 year = version[4:8]
 519                                 month = version[8:10]
 520                                 day = version[10:12]
 521                                 date = '-'.join((year, month, day))
 522                                 break;
 523                 file.close()
 524                 return date
 525
 526         def getversion(self):
 527                 try:
 528                         fd = open("/proc/stb/info/version","r")
 529                         version = fd.read()
 530                         fd.close()
 531                         self["testversion"].setText(("Version %s"%version))
 532                 except:
 533                         self["testversion"].setText(("Version no load"))
 534
 535
 536         def getmacaddr(self):
 537                 try:
 538                         if self.model == 2 or self.model == 3 or self.model == 4:
 539                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd5"
 540                         elif self.model == 0 or self.model == 1:
 541                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd4"
 542                         self.macConsole = Console()
 543                         self.macConsole.ePopen(cmd, self.readmac,self.checkReadmac)
 544                 except:
 545                         return
 546
 547         def readmac(self, result, retval,extra_args=None):
 548                 (callback) = extra_args
 549                 if self.macConsole is not None:
 550                         if retval == 0:
 551                                 self.macConsole = None
 552                                 macline = None
 553                                 content =result.splitlines()
 554                                 for x in content:
 555                                         if x.startswith('0x000'+str((self.mactry-1)*2)+'0010:'):
 556                                                 macline = x.split()
 557                                 if macline == None:
 558                                         callback(0)
 559                                 elif len(macline) < 10:
 560                                         callback(1)
 561                                 else:
 562                                         mac = macline[5]+":"+macline[6]+":"+macline[7]+":"+macline[8]+":"+macline[9]+":"+macline[10]
 563                                         self["mactext"].setText(("MAC : "+mac))
 564                                         callback(2)
 565
 566         def checkReadmac(self,data):
 567                 if data == 0:
 568                         print "block %d is bad block" % self.mactry
 569                         self.mactry = self.mactry + 1
 570                         if self.mactry > 4:
 571                                 self.session.open(MessageBox, _("FLASH IS BROKEN"), type = MessageBox.TYPE_INFO, enable_input = False)
 572                                 return
 573                         else:
 574                                 self.getmacaddr()
 575                 elif data == 1:
 576                         print 'mac dump read error'
 577                         return
 578                 elif data == 2:
 579                         print 'mac address read ok'
 580                         return
 581
 582         def TestAction(self):
 583                 if self.testing==1:
 584                         return
 585                 print "line - ",self["testlist"].getCurrent()[1]
 586                 self.currentindex = index = self["testlist"].getCurrent()[1]
 587                 result = 0
 588                 if index==self.satetestIndex:
 589                         self.Test0()
 590                 elif index==self.fronttestIndex:
 591                         self.Test1()
 592                 elif index>=self.tuner_test_first_index and index<=self.tuner_test_last_index:
 593                         if self.model == 0 or self.model == 1 or self.model == 2 or self.model == 3:
 594                                 self.TestTune(index)
 595                         elif self.model == 4:
 596                                 self.openTestTuneMenu()
 597                 elif index==self.scarttestIndex:
 598                         self.Test6()
 599                 elif index==self.rs232testIndex:
 600                         self.Test7()
 601                 elif index==self.usbtestIndex:
 602                         self.Test8()
 603                 elif index==self.ethernettestIndex:
 604                         self.Test9()
 605                 elif index == self.smarttestIndex:
 606                         self.Test10()
 607 #               elif index == 11:
 608 #                       self.Test11()
 609 #               elif index ==12:
 610 #                       self.Test12()
 611 #               elif index==13:
 612 #                       self.Test13()
 613                 elif index==self.fdefaultIndex:
 614                         self.Test14()
 615 #               elif index==self.shutdownIndex:
 616 #                       self.Test15()
 617                 else:
 618                         pass
 619
 620         def shutdownaction(self):
 621                 if self["testlist"].getCurrent()[1] == self.shutdownIndex:
 622                         self.Test15()
 623
 624
 625         def Test0(self):
 626                 self.satatry = 8
 627                 self.satatimer.start(100,True)
 628
 629         def sataCheck(self):
 630 #               print "try", self.satatry
 631                 if self.satatry == 0:
 632                         displayerror = 1
 633                 else:
 634                         self.rlist[self["testlist"].getCurrent()[1]]="try %d"%self.satatry
 635                         self["resultlist"].updateList(self.rlist)
 636                         self.satatry -= 1
 637                         displayerror = 0
 638                 result =0
 639                 try:
 640                         if fileExists("/autofs/sdb1"):
 641                                 if access("/autofs/sdb1",F_OK|R_OK|W_OK):
 642                                         dummy=open("/autofs/sdb1/dummy03","w")
 643                                         dummy.write("complete")
 644                                         dummy.close()
 645                                         dummy=open("/autofs/sdb1/dummy03","r")
 646                                         if dummy.readline()=="complete":
 647                                                 print "/autofs/sdb1 - complete"
 648                                         else:
 649                                                 print "/autofs/sdb1 - readline error"
 650                                                 result = 1
 651                                                 displayerror = 1
 652                                         dummy.close()
 653                                         system("rm /autofs/sdb1/dummy03")
 654                                 else:
 655                                         print "/autofs/sdb1 - rw access error"
 656                                         result = 1
 657                                         displayerror = 1
 658                         else:
 659                                 print "/autofs/sdb1 - file not exist"
 660                                 result = 1
 661                 except:
 662                         print "/autofs/sdb1 - exceptional error"
 663                         result = 1
 664                         displayerror = 1
 665                 try:
 666                         if fileExists("/autofs/sda1"):
 667                                 if access("/autofs/sda1",F_OK|R_OK|W_OK):
 668                                         dummy=open("/autofs/sda1/dummy03","w")
 669                                         dummy.write("complete")
 670                                         dummy.close()
 671                                         dummy=open("/autofs/sda1/dummy03","r")
 672                                         if dummy.readline()=="complete":
 673                                                 print "/autofs/sda1 - complete"
 674                                         else:
 675                                                 print "/autofs/sda1 - readline error"
 676                                                 result += 1
 677                                                 displayerror = 1
 678                                         dummy.close()
 679                                         system("rm /autofs/sda1/dummy03")
 680                                 else:
 681                                         print "/autofs/sda1 - rw access error"
 682                                         result += 1
 683                                         displayerror = 1
 684                         else:
 685                                 print "/autofs/sda1 - file not exist"
 686                                 result += 1
 687                 except:
 688                         print "/autofs/sda1 - exceptional error"
 689                         result += 1
 690                         displayerror = 1
 691
 692                 if result == 0:
 693                         self.session.open( MessageBox, _("Sata & extend hdd test pass\nPress 'OK' button!"), MessageBox.TYPE_INFO)
 694                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
 695                 elif result == 1:
 696                         if displayerror==1:
 697                                 self.session.open( MessageBox, _("One hdd test error\nPress 'EXIT' button!"), MessageBox.TYPE_ERROR)
 698                                 self.rlist[self["testlist"].getCurrent()[1]]="fail"
 699                         else:
 700                                 self.satatimer.start(1100,True)
 701                 else:
 702                         if displayerror==1:
 703                                 self.session.open( MessageBox, _("Sata & extend hdd test error\nPress 'EXIT' button!"), MessageBox.TYPE_ERROR)
 704                                 self.rlist[self["testlist"].getCurrent()[1]]="fail"
 705                         else:
 706                                 self.satatimer.start(1100,True)
 707
 708         def Test1(self):
 709                 if self.model== 0:
 710                         self.session.openWithCallback(self.displayresult ,FrontTest)
 711                 elif self.model == 1:
 712                         self.session.openWithCallback(self.displayresult ,FrontTest_solo)
 713                 elif self.model == 2 or self.model == 3:
 714                         self.session.openWithCallback(self.displayresult ,FrontTest_uno)
 715                 elif  self.model == 4:
 716                         self.session.openWithCallback(self.displayresult ,FrontTest_ultimo)
 717
 718         def displayresult(self):
 719                 global fronttest
 720                 if fronttest == 1:
 721                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
 722                 else:
 723                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
 724
 725         def openTestTuneMenu(self):
 726                 self.session.openWithCallback(self.TestTuneMenuResult ,TestTuneMenu, self.tuneInfo, self.tunelist, self.NimType)
 727
 728         def TestTuneMenuResult(self,result):
 729                 if result :
 730                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
 731                 else:
 732                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
 733                 self["resultlist"].updateList(self.rlist)
 734
 735         def TestTune(self,index):
 736                 if self.oldref is None:
 737                         eref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0")
 738                         serviceHandler = eServiceCenter.getInstance()
 739                         servicelist = serviceHandler.list(eref)
 740                         if not servicelist is None:
 741                                 ref = servicelist.getNext()
 742                         else:
 743                                 ref = self.getCurrentSelection() # raise error
 744                                 print "servicelist none"
 745                 else:
 746                         ref = self.oldref
 747                 self.session.nav.stopService() # try to disable foreground service
 748                 if self.model == 0 or self.model == 1:
 749                         if index==self.tuner1_1testIndex:
 750                                 ref.setData(0,1)
 751                                 ref.setData(1,0x6D3)
 752                                 ref.setData(2,0x3)
 753                                 ref.setData(3,0xA4)
 754                                 ref.setData(4,0xA00000)
 755                                 self.session.nav.playService(ref)
 756                                 self.avswitch.setColorFormat(0)
 757                                 self.avswitch.setAspectRatio(0)
 758                         elif index==self.tuner1_2testIndex:
 759                                 if self.model == 1:
 760                                         self.camstep = 1
 761                                         self.camtimer.start(100,True)
 762                                 ref.setData(0,0x19)
 763                                 ref.setData(1,0x1325)
 764                                 ref.setData(2,0x3ef)
 765                                 ref.setData(3,0x1)
 766                                 ref.setData(4,0x64af79)
 767                                 self.session.nav.playService(ref)
 768                                 self.avswitch.setColorFormat(1)
 769                                 self.avswitch.setAspectRatio(6)
 770                         elif index==self.tuner2_1testIndex:
 771                                 ref.setData(0,1)
 772                                 ref.setData(1,0x6D3)
 773                                 ref.setData(2,0x3)
 774                                 ref.setData(3,0xA4)
 775                                 ref.setData(4,0x820000)
 776                                 self.session.nav.playService(ref)
 777                                 self.avswitch.setColorFormat(2)
 778                                 self.avswitch.setAspectRatio(0)
 779                         elif index==self.tuner2_2testIndex:
 780                                 self.camstep = 1
 781                                 self.camtimer.start(100,True)
 782                                 ref.setData(0,0x19)
 783                                 ref.setData(1,0x1325)
 784                                 ref.setData(2,0x3ef)
 785                                 ref.setData(3,0x1)
 786                                 ref.setData(4,0xC00000)
 787                                 self.session.nav.playService(ref)
 788                                 self.avswitch.setColorFormat(0)
 789                                 self.avswitch.setAspectRatio(6)
 790                         self.tuningtimer.start(2000,True)
 791                         self.tunemsgtimer.start(3000, True)
 792                 elif self.model == 3 or self.model == 4:
 793                         getTuneInfo=self.tuneInfo[index]
 794                         if getTuneInfo["cam"] is True:
 795                                 self.camstep = 1
 796                                 self.camtimer.start(100,True)
 797                         if getTuneInfo["type"].startswith("DVB-S"):
 798                                 if getTuneInfo["pol"] == "H":
 799                                         ref.setData(0,1)
 800                                         ref.setData(1,0x6D3)
 801                                         ref.setData(2,0x3)
 802                                         ref.setData(3,0xA4)
 803                                 else:
 804                                         ref.setData(0,0x19)
 805                                         ref.setData(1,0x1325)
 806                                         ref.setData(2,0x3ef)
 807                                         ref.setData(3,0x1)
 808                                 if getTuneInfo["sat"] == "160": # Eutelsat W2
 809                                         ref.setData(4,0xA00000)
 810                                 elif getTuneInfo["sat"] == "100": # Eutelsat
 811                                         ref.setData(4,0x64af79)
 812                                 elif getTuneInfo["sat"] == "130": # Hotbird
 813                                         ref.setData(4,0x820000)
 814                                 elif getTuneInfo["sat"] == "192": # Astra
 815                                         ref.setData(4,0xC00000)
 816                                 elif getTuneInfo["sat"] == "620": # Intelsat 902
 817                                         ref.setData(4,0x26c0000) # need to fix later
 818                                 elif getTuneInfo["sat"] == "642": # Intelsat 906
 819                                         ref.setData(4,0x282AF79) # need to fix later
 820                         elif getTuneInfo["type"].startswith("DVB-C"):
 821                                 ref.setData(0,0x19)
 822                                 ref.setData(1,0x1325)
 823                                 ref.setData(2,0x3ef)
 824                                 ref.setData(3,0x1)
 825                                 ref.setData(4,-64870) # ffff029a
 826                         elif getTuneInfo["type"].startswith("DVB-T"):
 827                                 ref.setData(0,0x19)
 828                                 ref.setData(1,0x1325)
 829                                 ref.setData(2,0x3ef)
 830                                 ref.setData(3,0x1)
 831                                 ref.setData(4,-286391716) # eeee025c
 832                         self.session.nav.playService(ref)
 833                         if getTuneInfo["color"]=="CVBS":
 834                                 self.avswitch.setColorFormat(0)
 835                         elif getTuneInfo["color"]=="RGB":
 836                                 self.avswitch.setColorFormat(1)
 837                         elif getTuneInfo["color"]=="YC":
 838                                 self.avswitch.setColorFormat(2)
 839                         if getTuneInfo["ratio"] == "4:3":
 840                                 self.avswitch.setAspectRatio(0)
 841                         elif getTuneInfo["ratio"] == "16:9":
 842                                 self.avswitch.setAspectRatio(6)
 843                         self.tuningtimer.start(2000,True)
 844                         self.tunemsgtimer.start(3000, True)
 845
 846         def cam_state(self):
 847                 current_index = self.currentindex
 848                 if self.camstep == 1:
 849                         slot = 0
 850                         state = eDVBCI_UI.getInstance().getState(slot)
 851                         print '-1-stat',state
 852                         if state > 0:
 853                                 self.camstep=2
 854                                 self.camtimer.start(100,True)
 855                         else:
 856                                 self.session.nav.stopService()
 857                                 self.session.open( MessageBox, _("CAM1_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
 858                                 self.rlist[current_index]="fail"
 859                                 self.tunemsgtimer.stop()
 860                 elif self.camstep == 2:
 861                         slot = 0
 862                         appname = eDVBCI_UI.getInstance().getAppName(slot)
 863                         print 'appname',appname
 864                         if appname is None:
 865                                 self.session.nav.stopService()
 866                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
 867                                 self.rlist[current_index]="fail"
 868                                 self.tunemsgtimer.stop()
 869                         else:
 870                                 self.camstep=3
 871                                 self.camtimer.start(100,True)
 872                 elif self.camstep==3:
 873                         slot = 1
 874                         state = eDVBCI_UI.getInstance().getState(slot)
 875                         print '-2-stat',state
 876                         if state > 0:
 877                                 self.camstep=4
 878                                 self.camtimer.start(100,True)
 879                         else:
 880                                 self.session.nav.stopService()
 881                                 self.session.open( MessageBox, _("CAM2_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
 882                                 self.rlist[current_index]="fail"
 883                                 self.tunemsgtimer.stop()
 884                 elif self.camstep == 4:
 885                         slot = 1
 886                         appname = eDVBCI_UI.getInstance().getAppName(slot)
 887                         print 'appname',appname
 888                         if appname is None:
 889                                 self.session.nav.stopService()
 890                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
 891                                 self.rlist[current_index]="fail"
 892                                 self.tunemsgtimer.stop()
 893                         else:
 894                                 self.setSource()
 895                                 self.camstep = 5
 896
 897         def updateStatus(self):
 898                 current_index = self.currentindex
 899                 if self.model == 0 or self.model == 1:
 900                         if current_index ==self.tuner1_1testIndex or current_index==self.tuner1_2testIndex:
 901                                 tunno = 1
 902                                 result = eSctest.getInstance().getFrontendstatus(0)
 903                         else:
 904                                 tunno = 2
 905                                 result = eSctest.getInstance().getFrontendstatus(1)
 906                         if current_index == self.tuner1_2testIndex or current_index==self.tuner2_2testIndex:
 907                                 hv = "Ver"
 908                         else:
 909                                 hv = "Hor"
 910
 911                 elif self.model == 3 or self.model == 4:
 912                         getTuneInfo=self.tuneInfo[current_index]
 913                         result = eSctest.getInstance().getFrontendstatus(getTuneInfo["slot"])
 914                         tunno = getTuneInfo["slot"]+1
 915                         hv = getTuneInfo["pol"]
 916                         if hv == "H":
 917                                 hv = "Hor"
 918                         elif hv == "V":
 919                                 hv = "Ver"
 920                         else :
 921                                 hv == ""
 922
 923                 print "eSctest.getInstance().getFrontendstatus - %d"%result
 924                 if result == 0 or result == -1:
 925                         self.tunerlock = 0
 926                         self.tunemsgtimer.stop()
 927                         self.session.nav.stopService()
 928                         self.avswitch.setColorFormat(0)
 929                         self.session.open( MessageBox, _("Tune%d %s Locking Fail..."%(tunno,hv)), MessageBox.TYPE_ERROR)
 930                         self.rlist[current_index]="fail"
 931                 else :
 932                         self.tunerlock = 1
 933
 934         def tuneback(self,yesno):
 935                 current_index=self.currentindex
 936                 self.session.nav.stopService() # try to disable foreground service
 937                 if yesno and self.tunerlock == 1:
 938                         if current_index == self.tuner_test_last_index and self.camstep < 5: # need fix to depending about CAM exist
 939                                 self.rlist[current_index]="fail"
 940                         else :
 941                                 self.rlist[current_index]="pass"
 942                 else:
 943                         self.rlist[current_index]="fail"
 944                 if self.model == 0 and current_index == 6: # YC
 945                         self.avswitch.setColorFormat(0)
 946                 elif ( self.model == 3 or self.model == 4 ) and self.tuneInfo[current_index]["color"] == "YC":
 947                         self.avswitch.setColorFormat(0)
 948                 self.resetSource()
 949                 self["resultlist"].updateList(self.rlist)
 950
 951         def tunemsg(self):
 952                 self.tuningtimer.stop()
 953                 self.session.openWithCallback(self.tuneback, TuneMessageBox, _("%s ok?" %(self["testlist"].getCurrent()[0])), MessageBox.TYPE_YESNO)
 954
 955         def setSourceVar(self):
 956                 if self.model == 0:
 957                         self.input_pad_num=1
 958                         self.setTuner = 'B'
 959                 elif self.model == 1:
 960                         self.input_pad_num=0
 961                         self.setTuner = 'A'
 962                 else:
 963                         self.input_pad_num=len(self.NimType)-1
 964                         if self.input_pad_num == 0:
 965                                 self.setTuner = 'A'
 966                         elif self.input_pad_num == 1:
 967                                 self.setTuner = 'B'
 968                         elif self.input_pad_num == 2:
 969                                 self.setTuner = 'C'
 970
 971 #       ikseong - for 22000 tp
 972         def setSource(self):
 973 # fix input source
 974                 inputname = ("/proc/stb/tsmux/input%d" % self.input_pad_num)
 975                 print "<setsource> inputname : ",inputname
 976                 fd=open(inputname,"w")
 977                 fd.write("CI0")
 978                 fd.close()
 979 # fix ci_input Tuner
 980                 filename = ("/proc/stb/tsmux/ci0_input")
 981                 fd = open(filename,'w')
 982                 fd.write(self.setTuner)
 983                 print "setTuner(CI0) : ",self.setTuner
 984                 fd.close()
 985                 print "CI loop test!!!!!!!!!!!!!!"
 986
 987         def resetSource(self):
 988                 inputname = ("/proc/stb/tsmux/input%d" % self.input_pad_num)
 989                 print "<resetsource> inputname : ",inputname
 990                 fd=open(inputname,"w")
 991                 fd.write(self.setTuner)
 992                 fd.close()
 993                 print "CI loop test end!!!!!!!!!!!!!!"
 994
 995         def Test6(self):
 996                 self.avswitch.setInput("SCART")
 997                 sleep(2)
 998                 self.session.openWithCallback(self.check6, MessageBox, _("Scart loop ok?"), MessageBox.TYPE_YESNO)
 999
1000         def check6(self,yesno):
1001                 if yesno:
1002                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1003                 else:
1004                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1005                 self.avswitch.setInput("ENCODER")
1006
1007         def check7(self):
1008                 global rstest
1009                 if rstest == 1:
1010                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1011                 else:
1012                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1013
1014         def Test7(self):
1015                 self.session.openWithCallback(self.check7,RS232Test)
1016
1017         def Agingmode(self):
1018                 if self.testing==1:
1019                         return
1020                 if self.oldref is None:
1021                         eref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0")
1022                         serviceHandler = eServiceCenter.getInstance()
1023                         servicelist = serviceHandler.list(eref)
1024                         if not servicelist is None:
1025                                 ref = servicelist.getNext()
1026                         else:
1027                                 ref = self.getCurrentSelection()
1028                                 print "servicelist none"
1029                 else:
1030                         ref = self.oldref
1031                 self.session.nav.stopService() # try to disable foreground service
1032                 if self.model == 0 or self.model == 1 or self.NimType[0]["type"].startswith("DVB-S"):
1033                         ref.setData(0,0x19)
1034                         ref.setData(1,0x1325)
1035                         ref.setData(2,0x3ef)
1036                         ref.setData(3,0x1)
1037                         ref.setData(4,0x64af79)
1038                 elif self.NimType[0]["type"].startswith("DVB-C"):
1039                         ref.setData(0,0x19)
1040                         ref.setData(1,0x1325)
1041                         ref.setData(2,0x3ef)
1042                         ref.setData(3,0x1)
1043                         ref.setData(4,-64870) # ffff029a
1044                 elif self.NimType[0]["type"].startswith("DVB-T"):
1045                         ref.setData(0,0x19)
1046                         ref.setData(1,0x1325)
1047                         ref.setData(2,0x3ef)
1048                         ref.setData(3,0x1)
1049                         ref.setData(4,-286391716) # eeee025c
1050                 self.session.nav.playService(ref)
1051                 self.avswitch.setColorFormat(0)
1052                 self.avswitch.setAspectRatio(0)
1053                 self.agingtimer.start(2000,True)
1054
1055         def agingCheck(self):
1056                 result = eSctest.getInstance().getFrontendstatus(0)
1057                 hv = "Ver"
1058                 print "eSctest.getInstance().getFrontendstatus - %d"%result
1059                 if result == 0:
1060                         self.session.nav.stopService()
1061                         self.session.open( MessageBox, _("Tune 1 Ver Locking Fail..."), MessageBox.TYPE_ERROR)
1062                 elif result == 1 :
1063                         self.session.openWithCallback(self.agingResult,AgingTest)
1064                 else:
1065                         self.session.nav.stopService()
1066                         self.session.open( MessageBox, _("Tune 1 Ver Error %d..."%result), MessageBox.TYPE_ERROR)
1067
1068         def agingResult(self):
1069                 global Agingresult
1070                 if(Agingresult ==1):
1071                         self["testlist"].moveToIndex(self.fdefaultIndex)
1072                         self.Test14()
1073                         self["testlist"].moveToIndex(self.shutdownIndex)
1074
1075         def Test8(self):
1076                 self.usbtry = 9
1077                 self.usbtimer.start(100,True)
1078
1079         def usbCheck(self):
1080                 if self.usbtry == 0:
1081                         displayerror = 1
1082                 else:
1083                         self.rlist[self["testlist"].getCurrent()[1]]="try %d"%self.usbtry
1084                         self["resultlist"].updateList(self.rlist)
1085                         self.usbtry -= 1
1086                         displayerror = 0
1087
1088                 if self.model==0 or self.model==3 or self.model==4:
1089                         devices = [ "/autofs/sdc1", "/autofs/sdd1", "/autofs/sde1" ]
1090                 elif self.model==1:
1091                         devices = [ "/autofs/sda1", "/autofs/sdb1" ]
1092                 elif self.model==2:
1093                         devices = [ "/autofs/sdc1", "/autofs/sdd1" ]
1094                 else :
1095                         self.session.open( MessageBox, _("invalid model"), MessageBox.TYPE_ERROR)
1096                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1097                         return
1098
1099                 result=len(devices)
1100
1101                 for dev in devices:
1102                         try:
1103                                 if fileExists(dev):
1104                                         if access(dev,F_OK|R_OK|W_OK):
1105                                                 dummy=open(dev+"/dummy03","w")
1106                                                 dummy.write("complete")
1107                                                 dummy.close()
1108                                                 dummy=open(dev+"/dummy03","r")
1109                                                 if dummy.readline()=="complete":
1110                                                         print dev," - complete"
1111                                                 else:
1112                                                         print dev," - readline error"
1113                                                         result=result -1
1114                                                         displayerror = 1
1115                                                 dummy.close()
1116                                                 system("rm "+dev+"/dummy03")
1117                                         else:
1118                                                 print dev," - rw access error"
1119                                                 result=result -1
1120                                                 displayerror = 1
1121                                 else:
1122                                         print dev," - file not exist"
1123                                         result=result-1
1124                         except:
1125                                 print dev," - exceptional error"
1126                                 result=result -1
1127                                 displayerror = 1
1128
1129                 if result < 0 :
1130                         result = 0
1131                 elif result == len(devices):
1132                         self.session.open( MessageBox, _("USB test pass %d devices\nPress 'OK' button!"%result), MessageBox.TYPE_INFO)
1133                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1134                 else:
1135                         if displayerror == 1:
1136                                 self.session.open( MessageBox, _("USB test error : Success-%d"%result+" Fail-%d\nPress 'EXIT' button!"%(len(devices)-result)), MessageBox.TYPE_ERROR)
1137                                 self.rlist[self["testlist"].getCurrent()[1]]="fail"
1138                         else:
1139                                 self.usbtimer.start(1100,True)
1140
1141         def pingtest(self):
1142                 self.testing = 1
1143 #               system("/etc/init.d/networking stop")
1144                 system("ifconfig eth0 192.168.0.10")
1145 #               system("/etc/init.d/networking start")
1146                 cmd1 = "ping -c 1 192.168.0.100"
1147                 self.PingConsole = Console()
1148                 self.PingConsole.ePopen(cmd1, self.checkNetworkStateFinished,self.NetworkStatedataAvail)
1149
1150         def checkNetworkStateFinished(self, result, retval,extra_args):
1151                 (statecallback) = extra_args
1152                 if self.PingConsole is not None:
1153                         if retval == 0:
1154                                 self.PingConsole = None
1155                                 content = result.splitlines()
1156 #                               print 'content',content
1157                                 x = content[4].split()
1158 #                               print 'x',x
1159                                 if x[0]==x[3]:
1160                                         statecallback(1)
1161                                 else:
1162                                         statecallback(0)
1163                         else:
1164                                 statecallback(0)
1165
1166
1167         def NetworkStatedataAvail(self,data):
1168                 global ethtest
1169                 if data == 1:
1170                         ethtest = 1
1171                         print "success"
1172                         self.session.openWithCallback(self.openMacConfig ,MessageBox, _("Ping test pass"), MessageBox.TYPE_INFO,2)
1173
1174                 else:
1175                         ethtest = 0
1176                         print "fail"
1177                         self.session.open( MessageBox, _("Ping test fail\nPress exit"), MessageBox.TYPE_ERROR)
1178                         self.macresult()
1179
1180         def Test9(self):
1181                 self.pingtest()
1182
1183         def openMacConfig(self, ret=False):
1184                 self.session.openWithCallback(self.macresult ,MacConfig,mactry=self.mactry)
1185
1186         def macresult(self):
1187                 global ethtest
1188                 if ethtest == 1:
1189                         self.rlist[self.ethernettestIndex]="pass"
1190                 else:
1191                         self.rlist[self.ethernettestIndex]="fail"
1192                 self.getmacaddr()
1193                 self.testing = 0
1194
1195 #       def MemTest(self, which):
1196 #               index = which
1197 #               result = 0
1198 #               if index==0:
1199 #                       result = eMemtest.getInstance().dramtest()
1200 #               elif index==1:
1201 #                       result = eMemtest.getInstance().flashtest()
1202 #                       result = 0      #       temp
1203 #               else:
1204 #                       result = eMemtest.getInstance().dramtest()
1205 #                       result = eMemtest.getInstance().flashtest()
1206 #                       result = 0      #       temp
1207
1208 #               index = index+10
1209
1210 #               if result == 0:
1211 #                       print index,self.rlist[index]
1212 #                       self.rlist[index]="pass"
1213 #               else:
1214 #                       print index,self.rlist[index]
1215 #                       self.rlist[index]="fail"
1216 #               self["resultlist"].updateList(self.rlist)
1217
1218         def scciresult(self):
1219                 global smartcardtest
1220                 if smartcardtest == 1:
1221                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1222                 else:
1223                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1224
1225         def Test10(self):
1226                 self.session.openWithCallback(self.scciresult ,SmartCardTest,stbmodel=self.model)
1227
1228 #       def Test11(self):
1229 #               self.MemTest(1)
1230
1231 #       def Test12(self):
1232 #               self.MemTest(2)
1233
1234 #       def Test13(self):
1235 #               self.MemTest(3)
1236
1237         def Test14(self):
1238                 try:
1239                         print "test14"
1240                         system("rm -R /etc/enigma2")
1241                         system("ls /")
1242                         system("cp -R /usr/share/enigma2/defaults /etc/enigma2")
1243                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1244                         self["resultlist"].updateList(self.rlist)
1245                 except:
1246                         print "test14 except"
1247                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1248                         self["resultlist"].updateList(self.rlist)
1249                         self.session.open( MessageBox, _("Factory reset fail"), MessageBox.TYPE_ERROR)
1250
1251         def Test15(self):
1252                 self.session.openWithCallback(self.shutdown ,MessageBox, _("Do you want to shut down?"), MessageBox.TYPE_YESNO)
1253
1254         def shutdown(self, yesno):
1255                 if yesno :
1256                         from os import _exit
1257                         system("/usr/bin/showiframe /boot/backdrop.mvi")
1258                         _exit(1)
1259                 else:
1260                         return
1261
1262         def keyCancel(self):
1263                 if self.testing==1:
1264                         return
1265                 print "exit"
1266                 self.close()
1267 #               if self.oldref is not None:
1268 #                       self.session.nav.playService(self.oldref)
1269
1270 ethtest = 0
1271 class MacConfig(Screen):
1272         skin = """
1273                 <screen name="MacConfig" position="center,center" size="520,100" title="Mac Config" >
1274                         <eLabel text="Mac Address " position="10,15" size="200,40" font="Regular;30" />
1275                         <widget name="text" position="230,15" size="230,40" font="Regular;30" halign="right"/>
1276                         <widget name="text1" position="470,15" size="40,40" font="Regular;30" />
1277                         <eLabel text=" " position="5,55" zPosition="-1" size="510,5" backgroundColor="#02e1e8e6" />
1278                         <widget name="stattext" position="30,75" size="450,35" font="Regular;30" />
1279                 </screen>"""
1280
1281         def __init__(self, session, mactry = 1):
1282                 self["actions"] = ActionMap(["DirectionActions","OkCancelActions"],
1283                 {
1284                         "ok": self.keyOk,
1285                         "left": self.keyleft,
1286                         "right": self.keyright,
1287                         "cancel": self.keyCancel,
1288                 }, -2)
1289
1290                 Screen.__init__(self, session)
1291
1292                 self.mactry = mactry
1293                 self.model = 0
1294                 self.getModelInfo()
1295                 self.macfd = 0
1296                 self.macaddr = "000000000000"
1297                 self.ReadMacinfo = 0
1298                 self["text"]=Label((self.macaddr))
1299                 self["text1"]= Label(("< >"))
1300                 self["stattext"]= Label((""))
1301                 self.displaymac()
1302                 self.loadmacaddr()
1303                 self.getmacaddr()
1304                 global ethtest
1305                 ethtest = 1
1306
1307         def getModelInfo(self):
1308                 getmodel = 0
1309                 if fileExists("/proc/stb/info/vumodel"):
1310                         vumodel = open("/proc/stb/info/vumodel")
1311                         info=vumodel.read().strip()
1312                         vumodel.close()
1313                         if info == "combo":
1314                                 self.model = 2
1315                                 getmodel = 1
1316                                 print "MacConfig, model : combo"
1317                         elif info == "solo":
1318                                 self.model = 1
1319                                 getmodel = 1
1320                                 print "MacConfig, model : solo"
1321                         elif info == "duo":
1322                                 self.model = 0
1323                                 getmodel = 1
1324                                 print "MacConfig, model : duo"
1325                         elif info == "uno":
1326                                 self.model = 3
1327                                 getmodel = 1
1328                                 print "getModelInfo : uno"
1329                         elif info == "ultimo":
1330                                 self.model = 4
1331                                 getmodel = 1
1332                                 print "getModelInfo : ultimo"
1333
1334                 if getmodel == 0 and fileExists("/proc/stb/info/version"):
1335                         version = open("/proc/stb/info/version")
1336                         info=version.read()
1337                         version.close()
1338 #                       print info,info[:2]
1339                         if info[:2] == "14":
1340                                 self.model = 1
1341                                 print "MacConfig, model : solo_"
1342                         elif info[:2] == "12":
1343                                 self.model = 0
1344                                 print "MacConfig, model: duo_"
1345
1346         def loadmacaddr(self):
1347                 try:
1348                         self.macfd = 0
1349
1350                         if self.model==0 or self.model==3 or self.model==4 :
1351                                 devices = ["/autofs/sdb1", "/autofs/sdc1", "/autofs/sdd1", "/autofs/sde1" ]
1352                         elif self.model==1:
1353                                 devices = [ "/autofs/sda1", "/autofs/sdb1" ]
1354                         elif self.model==2:
1355                                 devices = [ "/autofs/sdb1", "/autofs/sdc1", "/autofs/sdd1" ]
1356
1357                         for dev in devices:
1358                                 print 'try..',dev
1359                                 if  fileExists(dev+"/macinfo.txt"):
1360                                         print "<open>"+dev+"/macinfo.txt"
1361                                         self.macfd = open(dev+"/macinfo.txt","r+")
1362                                         break
1363
1364                         if self.macfd == 0:
1365                                 self["text"].setText(("cannot read usb!!"))
1366                                 self["text1"].setText((" "))
1367                                 self["stattext"].setText((" Press Exit Key."))
1368                                 self.ReadMacinfo=0
1369                                 return
1370
1371                         macaddr=self.macfd.readline().split(":")
1372                         self.macaddr=macaddr[1]+macaddr[2]+macaddr[3]+macaddr[4]+macaddr[5]+macaddr[6]
1373                         self.displaymac()
1374                         self.ReadMacinfo = 1
1375                 except:
1376                         self["text"].setText(("cannot read usb!!"))
1377                         self["text1"].setText((" "))
1378                         self["stattext"].setText((" Press Exit Key."))
1379                         self.ReadMacinfo=0
1380
1381         def getmacaddr(self):
1382                 if self.ReadMacinfo==0:
1383                         return
1384                 try:
1385                         if self.model == 2 or self.model == 3 or self.model == 4:
1386                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd5"
1387                         elif self.model == 0 or self.model == 1:
1388                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd4"
1389                         self.macConsole = Console()
1390                         self.macConsole.ePopen(cmd, self.readmac,self.checkReadmac)
1391                 except:
1392                         return
1393
1394         def readmac(self, result, retval,extra_args=None):
1395                 (callback) = extra_args
1396                 if self.macConsole is not None:
1397                         if retval == 0:
1398                                 self.macConsole = None
1399                                 macline = None
1400                                 content =result.splitlines()
1401                                 for x in content:
1402                                         if x.startswith('0x000'+str((self.mactry-1)*2)+'0010:'):
1403                                                 macline = x.split()
1404                                 if macline == None:
1405                                         callback(0)
1406                                 elif len(macline) < 10:
1407                                         callback(1)
1408                                 else:
1409                                         mac = macline[5]+":"+macline[6]+":"+macline[7]+":"+macline[8]+":"+macline[9]+":"+macline[10]
1410                                         self["stattext"].setText(("now : "+mac))
1411                                         callback(2)
1412
1413         def checkReadmac(self,data):
1414                 if data == 0:
1415                         print "block %d is bad block" % self.mactry
1416                         self.mactry = self.mactry + 1
1417                         if self.mactry > 4:
1418                                 self.session.open(MessageBox, _("FLASH IS BROKEN"), type = MessageBox.TYPE_INFO, enable_input = False)
1419                                 return
1420                         else:
1421                                 self.getmacaddr()
1422                 elif data == 1:
1423                         print 'mac dump read error'
1424                         return
1425                 elif data == 2:
1426                         print 'mac address read ok'
1427                         return
1428
1429
1430         def keyleft(self):
1431                 if self.ReadMacinfo==0 :
1432                         return
1433                 macaddress = long(self.macaddr,16)-1
1434                 if macaddress < 0 :
1435                         macaddress = 0xffffffffffff
1436                 self.macaddr = "%012x"%macaddress
1437                 self.displaymac()
1438
1439         def keyright(self):
1440                 if self.ReadMacinfo==0 :
1441                         return
1442                 macaddress = long(self.macaddr,16)+1
1443                 if macaddress > 0xffffffffffff:
1444                         macaddress = 0
1445                 self.macaddr = "%012x"%macaddress
1446                 self.displaymac()
1447
1448         def displaymac(self):
1449                 macaddr= self.macaddr
1450                 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))))
1451
1452         def keyOk(self):
1453                 if self.ReadMacinfo==0 :
1454                         return
1455                 try:
1456                         macaddr = self.macaddr
1457 #make_mac_sector 00-99-99-99-00-00 > /tmp/mac.sector
1458 #flash_eraseall /dev/mtd4
1459 #nandwrite /dev/mtd4 /tmp/mac.sector -p
1460                         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))
1461                         system(cmd)
1462                         if self.model == 2 or self.model == 3 or self.model == 4:
1463                                 system("flash_eraseall /dev/mtd5")
1464                                 system("nandwrite /dev/mtd5 /tmp/mac.sector -p")
1465                         elif self.model == 0 or self.model ==1 :
1466                                 system("flash_eraseall /dev/mtd4")
1467                                 system("nandwrite /dev/mtd4 /tmp/mac.sector -p")
1468                         macaddress = long(macaddr,16)+1
1469                         if macaddress > 0xffffffffffff:
1470                                 macaddress = 0
1471                         macaddr = "%012x"%macaddress
1472                         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))
1473                         self.macfd.seek(0)
1474                         self.macfd.write(macwritetext)
1475                         self.macfd.close()
1476                         system("sync")
1477                         self.macaddr = macaddr
1478                         self.close()
1479                 except:
1480                         self.session.open( MessageBox, _("Mac address fail"), MessageBox.TYPE_ERROR)
1481                         global ethtest
1482                         ethtest = 0
1483                         self.close()
1484
1485         def keyCancel(self):
1486                 if self.macfd != 0:
1487                         self.macfd.close()
1488                 global ethtest
1489                 ethtest = 0
1490                 self.close()
1491
1492 smartcardtest = 0
1493 class SmartCardTest(Screen):
1494         skin = """
1495                 <screen name="SmartCardTest" position="center,center" size="300,120" title="SmartCard Test" >
1496                         <widget name="text" position="10,10" size="280,100" font="Regular;30" />
1497                 </screen>"""
1498
1499         def __init__(self, session, stbmodel = 0):
1500                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions"],
1501                 {
1502                         "cancel": self.keyCancel,
1503                         "ok" : self.keyOk
1504                 }, -2)
1505
1506                 Screen.__init__(self, session)
1507                 self["text"]=Label(("Testing Smartcard 1..."))
1508                 self.testok = 0
1509                 self.smartcardtimer = eTimer()
1510                 self.smartcardtimer.callback.append(self.check_smart_card)
1511                 self.closetimer = eTimer()
1512                 self.closetimer.callback.append(self.close)
1513                 self.smartcard=0
1514                 global smartcardtest
1515                 smartcardtest = 0
1516                 self.model = stbmodel
1517                 self.smartcardtimer.start(100,True)
1518
1519         def check_smart_card(self):
1520                 global smartcardtest
1521                 index = self.smartcard
1522                 result  = 0
1523                 if index==0:
1524                         result = eSctest.getInstance().check_smart_card("/dev/sci0")
1525                 elif index ==1:
1526                         result = eSctest.getInstance().check_smart_card("/dev/sci1")
1527                 else:
1528                         result = -1
1529
1530                 print "check smartcard : ", result
1531
1532                 if result == 0:
1533                         print 'pass'
1534                         if(index== 0 and ( self.model== 0 or self.model==2 or self.model == 3 or self.model == 4) ):
1535                                 self.smartcard = 1
1536                                 self["text"].setText(_("Testing Smartcard 2..."))
1537                                 self.smartcardtimer.start(100,True)
1538                                 return
1539                         elif (index==1 or self.model==1):
1540                                 smartcardtest = 1
1541                                 self.testok = 1
1542                                 self["text"].setText(_("Smart Card OK!!"))
1543                                 self.closetimer.start(2000,True)
1544                                 self.smartcardtimer.stop()
1545                         else :
1546
1547                                 self["text"].setText(_("Smart Card model type error"))
1548                                 self.closetimer.start(2000,True)
1549                                 self.smartcardtimer.stop()
1550                 else:
1551 #                       if result ==-1:
1552 #                               self.session.open( MessageBox, _("%d:NO_DEV_FOUND"%(index+1)), MessageBox.TYPE_ERROR)
1553 #                       elif result == -2:
1554 #                               self.session.open( MessageBox, _("%d:SC_NOT_INSERTED"%(index+1)), MessageBox.TYPE_ERROR)
1555 #                       elif result == -3:
1556 #                               self.session.open( MessageBox, _("%d:SC_NOT_VALID_ATR"%(index+1)), MessageBox.TYPE_ERROR)
1557 #                       elif result == -5:
1558 #                               self.session.open( MessageBox, _("%d:SC_READ_TIMEOUT"%(index+1)), MessageBox.TYPE_ERROR)
1559                         if(index==0):
1560                                 self["text"].setText(_("Smart Card 1 Error!\nerrorcode=%d"%result))
1561                         elif (index==1):
1562                                 self["text"].setText(_("Smart Card 2 Error!\nerrorcode=%d"%result))
1563                         self.closetimer.start(2000,True)
1564                         self.smartcardtimer.stop()
1565
1566
1567         def keyCancel(self):
1568                 self.close()
1569
1570         def keyOk(self):
1571                 if self.testok == 1:
1572                         self.close()
1573
1574
1575
1576 fronttest = 0
1577
1578 class FrontTest(Screen):
1579         skin = """
1580                 <screen name="FrontTest" position="center,center" size="300,180" title="Front Test" >
1581                         <widget name="text" position="10,10" size="280,160" font="Regular;30" />
1582                 </screen>"""
1583
1584         def __init__(self, session):
1585                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions"],
1586                 {
1587                         "ok": self.keyOk,
1588                         "up":self.keyUp,
1589                         "down":self.keyDown,
1590                         "cancel": self.keyCancel,
1591                 }, -2)
1592
1593                 Screen.__init__(self, session)
1594                 self["text"]=Label(("Wheel LEFT"))
1595                 self.step = 1
1596
1597                 self.fronttimer= eTimer()
1598                 self.fronttimer.callback.append(self.FrontAnimate)
1599                 self.frontturnonoff = 0
1600                 eSctest.getInstance().VFD_Open()
1601                 self.keytimeout = eTimer()
1602                 self.keytimeout.callback.append(self.KeyTimeOut)
1603                 self.keytimeout.start(5000,True)
1604
1605         def KeyTimeOut(self):
1606                 if self.step == 1:
1607                         self["text"].setText(("Wheel LEFT ERROR"))
1608                 elif self.step ==2 :
1609                         self["text"].setText(("Wheel RIGHT ERROR"))
1610                 elif self.step == 3:
1611                         self["text"].setText(("Wheel BUTTON ERROR"))
1612                 self.step = 0
1613 #               self.keyCancel()
1614
1615         def keyCancel(self):
1616                 global fronttest
1617                 self.fronttimer.stop()
1618                 eSctest.getInstance().VFD_Close()
1619                 if self.step==4:
1620                         fronttest = 1
1621                 else:
1622                         fronttest = 0
1623                 self.close()
1624
1625         def keyDown(self):
1626                 if self.step==2:
1627                         self.keytimeout.stop()
1628                         self.keytimeout.start(5000,True)
1629                         self.step = 3
1630                         self["text"].setText(_("Press Front Wheel"))
1631
1632         def keyUp(self):
1633                 if self.step==1:
1634                         self.keytimeout.stop()
1635                         self.keytimeout.start(5000,True)
1636                         self.step=2
1637                         self["text"].setText(_("Wheel RIGHT"))
1638
1639         def keyOk(self):
1640                 if self.step == 3:
1641                         self.keytimeout.stop()
1642                         self.step =4
1643                         self.fronttimer.start(1000,True)
1644                         self["text"].setText(("Front Test OK!\nPress Exit Key"))
1645 #               elif self.step==4:
1646 #                       global fronttest
1647 #                       self.fronttimer.stop()
1648 #                       eSctest.getInstance().VFD_Close()
1649 #                       fronttest = 1
1650 #                       self.close()
1651
1652         def FrontAnimate(self):
1653                 if (self.frontturnonoff==0):
1654                         eSctest.getInstance().turnon_VFD()
1655                         self.frontturnonoff = 1
1656                 else:
1657                         self.frontturnonoff = 0
1658                         eSctest.getInstance().turnoff_VFD()
1659                 self.fronttimer.start(1000,True)
1660
1661
1662 class FrontTest_solo(Screen):
1663         skin = """
1664                 <screen name="FrontTest_solo" position="center,center" size="300,180" title="Front Test" >
1665                         <widget name="text" position="10,10" size="280,160" font="Regular;30" />
1666                 </screen>"""
1667
1668         def __init__(self, session):
1669                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","GlobalActions"],
1670                 {
1671                         "ok": self.keyOk,
1672                         "cancel": self.keyCancel,
1673                         "left": self.keyleft,
1674                         "right": self.keyright,
1675                         "power_down": self.keypower,
1676                         "volumeUp": self.keyvolup,
1677                         "volumeDown": self.keyvoldown,
1678                 }, -2)
1679
1680                 Screen.__init__(self, session)
1681                 self["text"]=Label(("Press Front STANDBY"))
1682                 self.step = 1
1683
1684                 self.fronttimer= eTimer()
1685                 self.fronttimer.callback.append(self.FrontAnimate)
1686                 self.frontturnonoff = 0
1687                 eSctest.getInstance().VFD_Open()
1688                 self.keytimeout = eTimer()
1689                 self.keytimeout.callback.append(self.KeyTimeOut)
1690                 self.keytimeout.start(5000,True)
1691
1692         def KeyTimeOut(self):
1693                 if self.step == 1:
1694                         self["text"].setText(("Front STANDBY ERROR\nPress exit!"))
1695                 elif self.step == 2 :
1696                         self["text"].setText(("Front CH - ERROR\nPress exit!"))
1697                 elif self.step == 3:
1698                         self["text"].setText(("Front CH + ERROR\nPress exit!"))
1699                 elif self.step == 4 :
1700                         self["text"].setText(("Front VOL - ERROR\nPress exit!"))
1701                 elif self.step == 5:
1702                         self["text"].setText(("Front VOL + ERROR\nPress exit!"))
1703
1704                 self.step = 0
1705 #               self.keyCancel()
1706
1707         def keypower(self):
1708                 if self.step== 1:
1709                         self.keytimeout.stop()
1710                         self.keytimeout.start(5000,True)
1711                         self.step = 2
1712                         self["text"].setText(_("Press Front CH -"))
1713
1714         def keyright(self):
1715                 if self.step== 3:
1716                         self.keytimeout.stop()
1717                         self.keytimeout.start(5000,True)
1718                         self.step = 4
1719                         self["text"].setText(_("Press Front VOL -"))
1720
1721         def keyleft(self):
1722                 if self.step== 2:
1723                         self.keytimeout.stop()
1724                         self.keytimeout.start(5000,True)
1725                         self.step = 3
1726                         self["text"].setText(_("Press Front CH +"))
1727
1728         def keyvolup(self):
1729                 if self.step== 5:
1730                         self.keytimeout.stop()
1731                         self.step = 6
1732                         self.fronttimer.start(1000,True)
1733                         self["text"].setText(_("Front LED OK?\n\nyes-ok\nno-exit"))
1734 #                       self["text"].setText(("Front Test OK!\nPress Exit Key"))
1735
1736         def keyvoldown(self):
1737                 if self.step== 4:
1738                         self.keytimeout.stop()
1739                         self.keytimeout.start(5000,True)
1740                         self.step = 5
1741                         self["text"].setText(_("Press Front VOL +"))
1742
1743         def checkled(self, yesno):
1744                 if yesno :
1745                         self.step=6
1746                 else:
1747                         self.step=0
1748                 self.keyCancel()
1749
1750         def keyCancel(self):
1751                 global fronttest
1752                 self.fronttimer.stop()
1753                 eSctest.getInstance().VFD_Close()
1754                 fronttest = 0
1755                 self.close()
1756
1757         def keyOk(self):
1758                 global fronttest
1759                 if self.step == 6:
1760                         fronttest = 1
1761                         self.fronttimer.stop()
1762                         eSctest.getInstance().VFD_Close()
1763                         self.close()
1764
1765         def FrontAnimate(self):
1766                 if (self.frontturnonoff==0):
1767                         eSctest.getInstance().turnon_VFD()
1768                         self.frontturnonoff = 1
1769                 else:
1770                         self.frontturnonoff = 0
1771                         eSctest.getInstance().turnoff_VFD()
1772                 self.fronttimer.start(1000,True)
1773
1774 class FrontTest_uno(Screen):
1775         skin = """
1776                 <screen name="FrontTest_uno" position="center,center" size="300,180" title="Front Test" >
1777                         <widget name="text" position="10,10" size="280,160" font="Regular;30" />
1778                 </screen>"""
1779
1780         def __init__(self, session):
1781                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","GlobalActions"],
1782                 {
1783                         "ok": self.keyOk,
1784                         "cancel": self.keyCancel,
1785                         "left": self.keyleft,
1786                         "right": self.keyright,
1787                         "volumeUp": self.keyvolup,
1788                         "volumeDown": self.keyvoldown,
1789                         "power_down": self.keypower,
1790                 }, -2)
1791
1792                 Screen.__init__(self, session)
1793                 self["text"]=Label(("Press Front CH -"))
1794                 self.step = 1
1795                 self.fronttimer= eTimer()
1796                 self.fronttimer.callback.append(self.FrontAnimate)
1797                 self.frontturnonoff = 0
1798                 eSctest.getInstance().VFD_Open()
1799                 self.keytimeout = eTimer()
1800                 self.keytimeout.callback.append(self.KeyTimeOut)
1801                 self.keytimeout.start(5000,True)
1802
1803         def KeyTimeOut(self):
1804                 if self.step == 1:
1805                         self["text"].setText(("Front CH - ERROR\nPress exit!"))
1806                 elif self.step == 2:
1807                         self["text"].setText(("Front CH + ERROR\nPress exit!"))
1808                 elif self.step == 3 :
1809                         self["text"].setText(("Front VOL - ERROR\nPress exit!"))
1810                 elif self.step == 4:
1811                         self["text"].setText(("Front VOL + ERROR\nPress exit!"))
1812                 elif self.step == 5:
1813                         self["text"].setText(("Front STANDBY ERROR\nPress exit!"))
1814                 self.step = 0
1815
1816         def keyleft(self):
1817                 if self.step== 1:
1818                         self.keytimeout.stop()
1819                         self.keytimeout.start(5000,True)
1820                         self.step = 2
1821                         self["text"].setText(_("Press Front CH +"))
1822         def keyright(self):
1823                 if self.step== 2:
1824                         self.keytimeout.stop()
1825                         self.keytimeout.start(5000,True)
1826                         self.step = 3
1827                         self["text"].setText(_("Press Front VOL -"))
1828
1829         def keyvoldown(self):
1830                 if self.step== 3:
1831                         self.keytimeout.stop()
1832                         self.keytimeout.start(5000,True)
1833                         self.step = 4
1834                         self["text"].setText(_("Press Front VOL +"))
1835
1836         def keyvolup(self):
1837                 if self.step== 4:
1838                         self.keytimeout.stop()
1839                         self.keytimeout.start(5000,True)
1840                         self.step = 5
1841                         self["text"].setText(_("Press Front STANDBY"))
1842
1843         def keypower(self):
1844                 if self.step== 5:
1845                         self.keytimeout.stop()
1846                         self.step = 6
1847                         self.fronttimer.start(1000,True)
1848                         self["text"].setText(_("Front LED OK?\n\nyes-ok\nno-exit"))
1849
1850         def keyCancel(self):
1851                 global fronttest
1852                 self.fronttimer.stop()
1853                 eSctest.getInstance().VFD_Close()
1854                 fronttest = 0
1855                 self.close()
1856
1857         def keyOk(self):
1858                 global fronttest
1859                 if self.step == 6:
1860                         fronttest = 1
1861                         self.fronttimer.stop()
1862                         eSctest.getInstance().VFD_Close()
1863                         self.close()
1864
1865         def FrontAnimate(self):
1866                 if (self.frontturnonoff==0):
1867                         eSctest.getInstance().turnon_VFD()
1868                         self.frontturnonoff = 1
1869                 else:
1870                         self.frontturnonoff = 0
1871                         eSctest.getInstance().turnoff_VFD()
1872                 self.fronttimer.start(1000,True)
1873
1874 class FrontTest_ultimo(FrontTest_solo):
1875         skin = """
1876                 <screen position="center,center" size="300,180" title="Front Test" >
1877                 <widget name="text" position="10,10" size="280,160" font="Regular;30" />
1878                 </screen>"""
1879
1880 rstest = 0
1881
1882 import select
1883
1884 class RS232Test(Screen):
1885         skin = """
1886                 <screen name="RS232Test" position="center,center" size="260,100" title="RS232 Test" >
1887                         <widget name="text" position="10,10" size="240,80" font="Regular;30" />
1888                 </screen>"""
1889         step=1
1890         def __init__(self, session):
1891                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions"],
1892                 {
1893                         "cancel": self.keyCancel,
1894                 }, -2)
1895
1896                 Screen.__init__(self, session)
1897                 self["text"]=Label(("Press \"Enter\" Key"))
1898                 self.timer = eTimer()
1899                 self.timer.callback.append(self.checkrs232)
1900                 self.timer.start(100, True)
1901
1902         def checkrs232(self):
1903                 global rstest
1904                 try:
1905                         rs=open('/dev/ttyS0','r')
1906                         rd = [rs]
1907                         r,w,e = select.select(rd, [], [], 10)
1908                         if r:
1909                                 input = rs.read(1)
1910                                 if input == "\n":
1911                                         rstest = 1
1912                                 else:
1913                                         rstest = 0
1914                         else:
1915                                 rstest = 0
1916                         rs.close()
1917                 except:
1918                         try:
1919                                 if rs:
1920                                         rs.close()
1921                         except:
1922                                 pass
1923                         print 'except error'
1924                         rstest = 0
1925                 if rstest == 0:
1926                         self.session.open( MessageBox, _("RS232 Test Failed!\nPress 'EXIT' button!"), MessageBox.TYPE_ERROR)
1927                 self.close()
1928
1929         def keyCancel(self):
1930                 self.close()
1931
1932 Agingresult = 0
1933
1934 class AgingTest(Screen):
1935         skin = """
1936                 <screen position="center,center" size="350,150" title="Aging Test" >
1937                         <widget name="text1" position="10,10" size="330,40" font="Regular;30" />
1938                         <widget name="text2" position="10,60" size="330,40" font="Regular;30" />
1939                         <!-- Signal Quality -->
1940                         <eLabel text="SNR : " position="40,120" size="60,25" font="Regular;25" transparent="1" />
1941                         <widget source="session.FrontendStatus" render="Label" position="100,120" size="60,25" font="Regular;25"  transparent="1">
1942                                 <convert type="FrontendInfo">SNRdB</convert>
1943                         </widget>
1944                         <!-- AGC -->
1945                         <eLabel text="AGC : " position="180,120" size="60,25" font="Regular;25"  transparent="1" noWrap="1" />
1946                         <widget source="session.FrontendStatus" render="Label" position="240,120" size="60,25" font="Regular;25"  transparent="1" noWrap="1">
1947                                 <convert type="FrontendInfo">AGC</convert>
1948                         </widget>
1949                 </screen>"""
1950         step=1
1951         def __init__(self, session):
1952                 self["actions"] = ActionMap(["MediaPlayerActions","GlobalActions"],
1953                 {
1954                         "pause": self.keyEnd,
1955                         "stop": self.keyFinish,
1956                         "volumeUp": self.nothing,
1957                         "volumeDown": self.nothing,
1958                         "volumeMute": self.nothing,
1959                 }, -2)
1960
1961                 Screen.__init__(self, session)
1962                 self["text1"]=Label(("Exit - Press Pause Key"))
1963                 self["text2"]=Label(("Reset - Press Stop Key"))
1964 #               self.servicelist = ServiceList()
1965 #               self.oldref = session.nav.getCurrentlyPlayingServiceReference()
1966 #               print "oldref",self.oldref
1967 #               session.nav.stopService() # try to disable foreground service
1968 #               self.chstart()
1969                 self.tunerlock = 0
1970                 self.tuningtimer = eTimer()
1971                 self.tuningtimer.callback.append(self.updateStatus)
1972 #               self.tuningtimer.start(200,True)
1973
1974
1975         def updateStatus(self):
1976                 result = eSctest.getInstance().getFrontendstatus(0)
1977                 hv = "Ver"
1978
1979                 print "eSctest.getInstance().getFrontendstatus - %d"%result
1980                 if result == 0:
1981                         self.tunerlock = 0
1982                         self.session.nav.stopService()
1983                         self.session.open( MessageBox, _("Tune 1 Ver Locking Fail..."), MessageBox.TYPE_ERROR)
1984                 elif result==1 :
1985                         self.tunerlock = 1
1986                 else:
1987                         self.tunerlock = 0
1988                         self.session.nav.stopService()
1989                         self.session.open( MessageBox, _("Tune 1 Ver Error %d..."%result), MessageBox.TYPE_ERROR)
1990
1991
1992         def nothing(self):
1993                 print "nothing"
1994
1995         def chstart(self):
1996                 if self.oldref is None:
1997                         eref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0")
1998                         serviceHandler = eServiceCenter.getInstance()
1999                         servicelist = serviceHandler.list(eref)
2000                         if not servicelist is None:
2001                                 ref = servicelist.getNext()
2002                         else:
2003                                 ref = self.getCurrentSelection()
2004                                 print "servicelist none"
2005                 else:
2006                         ref = self.oldref
2007                 self.session.nav.stopService() # try to disable foreground service
2008                 ref.setData(0,0x19)
2009                 ref.setData(1,0x83)
2010                 ref.setData(2,0x6)
2011                 ref.setData(3,0x85)
2012                 ref.setData(4,0x640000)
2013                 self.session.nav.playService(ref)
2014
2015         def keyEnd(self):
2016                 global Agingresult
2017                 Agingresult = 0
2018                 self.session.nav.stopService() # try to disable foreground service
2019                 self.close()
2020
2021         def keyFinish(self):
2022                 global Agingresult
2023                 Agingresult = 1
2024                 self.session.nav.stopService() # try to disable foreground service
2025                 self.close()
2026
2027 class TestTuneMenu(Screen):
2028         skin = """
2029         <screen position="350,230" size="550,300" title="Tuning Test" >
2030                 <widget name="testlist" position="10,0" size="440,250" itemHeight="35"/>
2031                 <widget name="resultlist" position="470,0" size="60,250" itemHeight="35"/>
2032                 <widget source="text" render="Label" position="100,270" size="450,30" font="Regular;22" />
2033         </screen>"""
2034
2035         def __init__(self ,session ,tuneInfo, tunelist,NimType):
2036                 self.session = session
2037                 self.NimType = NimType
2038                 self.tuneInfo = tuneInfo
2039                 self.tunelist = tunelist
2040                 self.model = 4
2041                 self["actions"] = NumberActionMap(["OkCancelActions","WizardActions","NumberActions"],
2042                 {
2043                         "left": self.nothing,
2044                         "right":self.nothing,
2045                         "ok": self.TestAction,
2046                         "cancel": self.keyCancel,
2047                         "up": self.keyup,
2048                         "down": self.keydown,
2049                         "0": self.numberaction,
2050                         "1": self.numberaction,
2051                         "2": self.numberaction,
2052                         "3": self.numberaction,
2053                         "4": self.numberaction,
2054                         "5": self.numberaction,
2055                         "6": self.numberaction,
2056                         "7": self.numberaction,
2057                         "8": self.numberaction,
2058                         "9": self.numberaction,
2059
2060                 }, -2)
2061                 Screen.__init__(self, session)
2062                 self.text = _("Press 'EXIT' key to finish tune test.")
2063                 self["text"] = StaticText(self.text)
2064                 self.createConfig()
2065                 session.nav.stopService() # try to disable foreground service
2066
2067                 self.tunemsgtimer = eTimer()
2068                 self.tunemsgtimer.callback.append(self.tunemsg)
2069
2070                 self.camstep = 1
2071                 self.camtimer = eTimer()
2072                 self.camtimer.callback.append(self.cam_state)
2073
2074                 self.tunerlock = 0
2075                 self.tuningtimer = eTimer()
2076                 self.tuningtimer.callback.append(self.updateStatus)
2077                 self.setSourceVar()
2078                 self.avswitch = AVSwitch()
2079
2080         def createConfig(self):
2081                 self.menulength= len(self.tunelist)
2082                 self["testlist"] = MenuList(self.tunelist)
2083                 self.rlist = []
2084                 for x in range(self.menulength):
2085                         self.rlist.append((".."))
2086                 self["resultlist"] = TestResultList(self.rlist)
2087
2088         def TestAction(self):
2089                 print "line - ",self["testlist"].getCurrent()[1]
2090                 self.currentindex = index = self["testlist"].getCurrent()[1]
2091                 result = 0
2092                 self.TestTune(index)
2093
2094         def nothing(self):
2095                 print "nothing"
2096
2097         def keyup(self):
2098                 print "self.menulength = ",self.menulength
2099                 print "self[\"testlist\"].getCurrent()[1] = ",self["testlist"].getCurrent()[1]
2100                 if self["testlist"].getCurrent()[1]==0:
2101                         self["testlist"].moveToIndex(self.menulength-1)
2102                         self["resultlist"].moveToIndex(self.menulength-1)
2103                 else:
2104                         self["testlist"].up()
2105                         self["resultlist"].up()
2106
2107
2108         def keydown(self):
2109                 print "self.menulength = ",self.menulength
2110                 print "self[\"testlist\"].getCurrent()[1] = ",self["testlist"].getCurrent()[1]
2111                 if self["testlist"].getCurrent()[1]==(self.menulength-1):
2112                         self["testlist"].moveToIndex(0)
2113                         self["resultlist"].moveToIndex(0)
2114                 else:
2115                         self["testlist"].down()
2116                         self["resultlist"].down()
2117
2118         def numberaction(self, number):
2119                 if number >= self.menulength:
2120                         return
2121                 index = int(number)
2122                 self["testlist"].moveToIndex(index)
2123                 self["resultlist"].moveToIndex(index)
2124
2125         def keyCancel(self):
2126                 print "testtunemenu exit"
2127                 if not '..' in self.rlist and not 'fail' in self.rlist:
2128                         self.close(True)
2129                 else:
2130                         self.close(False)
2131 #               if self.oldref is not None:
2132 #                       self.session.nav.playService(self.oldref)
2133
2134         def TestTune(self,index):
2135                 ref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0")
2136                 self.session.nav.stopService() # try to disable foreground service
2137                 getTuneInfo=self.tuneInfo[index]
2138                 if getTuneInfo["cam"] is True:
2139                         self.camstep = 1
2140                         self.camtimer.start(100,True)
2141                 if getTuneInfo["type"].startswith("DVB-S"):
2142                         if getTuneInfo["pol"] == "H":
2143                                 ref.setData(0,1)
2144                                 ref.setData(1,0x6D3)
2145                                 ref.setData(2,0x3)
2146                                 ref.setData(3,0xA4)
2147                         else:
2148                                 ref.setData(0,0x19)
2149                                 ref.setData(1,0x1325)
2150                                 ref.setData(2,0x3ef)
2151                                 ref.setData(3,0x1)
2152                         if getTuneInfo["sat"] == "160": # Eutelsat W2
2153                                 ref.setData(4,0xA00000)
2154                         elif getTuneInfo["sat"] == "100": # Eutelsat
2155                                 ref.setData(4,0x64af79)
2156                         elif getTuneInfo["sat"] == "130": # Hotbird
2157                                 ref.setData(4,0x820000)
2158                         elif getTuneInfo["sat"] == "192": # Astra
2159                                 ref.setData(4,0xC00000)
2160                         elif getTuneInfo["sat"] == "620": # Intelsat 902
2161                                 ref.setData(4,0x26c0000) # need to fix later
2162                         elif getTuneInfo["sat"] == "642": # Intelsat 906
2163                                 ref.setData(4,0x282AF79) # need to fix later
2164                 elif getTuneInfo["type"].startswith("DVB-C"):
2165                         ref.setData(0,0x19)
2166                         ref.setData(1,0x1325)
2167                         ref.setData(2,0x3ef)
2168                         ref.setData(3,0x1)
2169                         ref.setData(4,-64870) # ffff029a
2170                 elif getTuneInfo["type"].startswith("DVB-T"):
2171                         ref.setData(0,0x19)
2172                         ref.setData(1,0x1325)
2173                         ref.setData(2,0x3ef)
2174                         ref.setData(3,0x1)
2175                         ref.setData(4,-286391716) # eeee025c
2176                 self.session.nav.playService(ref)
2177                 if getTuneInfo["color"]=="CVBS":
2178                         self.avswitch.setColorFormat(0)
2179                 elif getTuneInfo["color"]=="RGB":
2180                         self.avswitch.setColorFormat(1)
2181                 elif getTuneInfo["color"]=="YC":
2182                         self.avswitch.setColorFormat(2)
2183                 if getTuneInfo["ratio"] == "4:3":
2184                         self.avswitch.setAspectRatio(0)
2185                 elif getTuneInfo["ratio"] == "16:9":
2186                         self.avswitch.setAspectRatio(6)
2187                 self.tuningtimer.start(2000,True)
2188                 self.tunemsgtimer.start(3000, True)
2189
2190         def cam_state(self):
2191                 current_index = self.currentindex
2192                 if self.camstep == 1:
2193                         slot = 0
2194                         state = eDVBCI_UI.getInstance().getState(slot)
2195                         print '-1-stat',state
2196                         if state > 0:
2197                                 self.camstep=2
2198                                 self.camtimer.start(100,True)
2199                         else:
2200                                 self.session.nav.stopService()
2201                                 self.session.open( MessageBox, _("CAM1_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
2202                                 self.rlist[current_index]="fail"
2203                                 self.tunemsgtimer.stop()
2204                 elif self.camstep == 2:
2205                         slot = 0
2206                         appname = eDVBCI_UI.getInstance().getAppName(slot)
2207                         print 'appname',appname
2208                         if appname is None:
2209                                 self.session.nav.stopService()
2210                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
2211                                 self.rlist[current_index]="fail"
2212                                 self.tunemsgtimer.stop()
2213                         else:
2214                                 self.camstep=3
2215                                 self.camtimer.start(100,True)
2216                 elif self.camstep==3:
2217                         slot = 1
2218                         state = eDVBCI_UI.getInstance().getState(slot)
2219                         print '-2-stat',state
2220                         if state > 0:
2221                                 self.camstep=4
2222                                 self.camtimer.start(100,True)
2223                         else:
2224                                 self.session.nav.stopService()
2225                                 self.session.open( MessageBox, _("CAM2_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
2226                                 self.rlist[current_index]="fail"
2227                                 self.tunemsgtimer.stop()
2228                 elif self.camstep == 4:
2229                         slot = 1
2230                         appname = eDVBCI_UI.getInstance().getAppName(slot)
2231                         print 'appname',appname
2232                         if appname is None:
2233                                 self.session.nav.stopService()
2234                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
2235                                 self.rlist[current_index]="fail"
2236                                 self.tunemsgtimer.stop()
2237                         else:
2238                                 self.setSource()
2239                                 self.camstep = 5
2240
2241         def updateStatus(self):
2242                 current_index = self.currentindex
2243                 getTuneInfo=self.tuneInfo[current_index]
2244                 result = eSctest.getInstance().getFrontendstatus(getTuneInfo["slot"])
2245                 tunno = getTuneInfo["slot"]+1
2246                 hv = getTuneInfo["pol"]
2247                 if hv == "H":
2248                         hv = "Hor"
2249                 elif hv == "V":
2250                         hv = "Ver"
2251                 else :
2252                         hv == ""
2253
2254                 print "eSctest.getInstance().getFrontendstatus - %d"%result
2255                 if result == 0 or result == -1:
2256                         self.tunerlock = 0
2257                         self.tunemsgtimer.stop()
2258                         self.session.nav.stopService()
2259                         self.avswitch.setColorFormat(0)
2260                         self.session.open( MessageBox, _("Tune%d %s Locking Fail..."%(tunno,hv)), MessageBox.TYPE_ERROR)
2261                         self.rlist[current_index]="fail"
2262                 else :
2263                         self.tunerlock = 1
2264
2265         def tuneback(self,yesno):
2266                 current_index=self.currentindex
2267                 self.session.nav.stopService() # try to disable foreground service
2268                 if yesno and self.tunerlock == 1:
2269                         getTuneInfo=self.tuneInfo[current_index]
2270                         if getTuneInfo["cam"] and self.camstep < 5: # need fix to depending about CAM exist
2271                                 self.rlist[current_index]="fail"
2272                         else :
2273                                 self.rlist[current_index]="pass"
2274                 else:
2275                         self.rlist[current_index]="fail"
2276                 if self.tuneInfo[current_index]["color"] == "YC":
2277                         self.avswitch.setColorFormat(0)
2278                 self.resetSource()
2279                 self["resultlist"].updateList(self.rlist)
2280
2281         def tunemsg(self):
2282                 self.tuningtimer.stop()
2283                 self.session.openWithCallback(self.tuneback, TuneMessageBox, _("%s ok?" %(self["testlist"].getCurrent()[0])), MessageBox.TYPE_YESNO)
2284
2285         def setSourceVar(self):
2286                 self.input_pad_num=len(self.NimType)-1
2287                 if self.input_pad_num == 0:
2288                         self.setTuner = 'A'
2289                 elif self.input_pad_num == 1:
2290                         self.setTuner = 'B'
2291                 elif self.input_pad_num == 2:
2292                         self.setTuner = 'C'
2293
2294 #       ikseong - for 22000 tp
2295         def setSource(self):
2296 # fix input source
2297                 inputname = ("/proc/stb/tsmux/input%d" % self.input_pad_num)
2298                 print "<setsource> inputname : ",inputname
2299                 fd=open(inputname,"w")
2300                 fd.write("CI0")
2301                 fd.close()
2302 # fix ci_input Tuner
2303                 filename = ("/proc/stb/tsmux/ci0_input")
2304                 fd = open(filename,'w')
2305                 fd.write(self.setTuner)
2306                 print "setTuner(CI0) : ",self.setTuner
2307                 fd.close()
2308                 print "CI loop test!!!!!!!!!!!!!!"
2309
2310         def resetSource(self):
2311                 inputname = ("/proc/stb/tsmux/input%d" % self.input_pad_num)
2312                 print "<resetsource> inputname : ",inputname
2313                 fd=open(inputname,"w")
2314                 fd.write(self.setTuner)
2315                 fd.close()
2316                 print "CI loop test end!!!!!!!!!!!!!!"
2317
2318 session = None
2319
2320
2321 def cleanup():
2322         global Session
2323         Session = None
2324         global Servicelist
2325         Servicelist = None
2326
2327 def main(session, servicelist, **kwargs):
2328         global Session
2329         Session = session
2330         global Servicelist
2331         Servicelist = servicelist
2332         bouquets = Servicelist.getBouquetList()
2333         global bouquetSel
2334         bouquetSel = Session.openWithCallback(cleanup, FactoryTest)
2335
2336 #def Plugins(**kwargs):
2337 #       return PluginDescriptor(name=_("Factory Test"), description="Test App for Factory", where = PluginDescriptor.WHERE_EXTENSIONSMENU, fnc=main)
2338
2339 def Plugins(**kwargs):
2340         return []