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