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