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