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