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