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