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