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