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 1 == 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["type"].startswith("DVB-S"):
 747                                 if getTuneInfo["pol"] == "H":
 748                                         ref.setData(0,1)
 749                                         ref.setData(1,0x6D3)
 750                                         ref.setData(2,0x3)
 751                                         ref.setData(3,0xA4)
 752                                 else:
 753                                         ref.setData(0,0x19)
 754                                         ref.setData(1,0x1325)
 755                                         ref.setData(2,0x3ef)
 756                                         ref.setData(3,0x1)
 757                                         ref.setData(4,0x64af79)
 758                                 if getTuneInfo["sat"] == "160": # Eutelsat W2
 759                                         ref.setData(4,0xA00000)
 760                                 elif getTuneInfo["sat"] == "100": # Eutelsat
 761                                         ref.setData(4,0x64af79)
 762                                 elif getTuneInfo["sat"] == "130": # Hotbird
 763                                         ref.setData(4,0x820000)
 764                                 elif getTuneInfo["sat"] == "192": # Astra
 765                                         ref.setData(4,0xC00000)
 766                                 elif getTuneInfo["sat"] == "620": # Intelsat 902
 767                                         ref.setData(4,0x26c0000) # need to fix later
 768                                 elif getTuneInfo["sat"] == "642": # Intelsat 906
 769                                         ref.setData(4,0x282AF79) # need to fix later
 770                         elif getTuneInfo["type"].startswith("DVB-C"):
 771                                 ref.setData(0,0x19)
 772                                 ref.setData(1,0x1325)
 773                                 ref.setData(2,0x3ef)
 774                                 ref.setData(3,0x1)
 775                                 ref.setData(4,-64870) # ffff029a
 776                         elif getTuneInfo["type"].startswith("DVB-T"):
 777                                 ref.setData(0,0x19)
 778                                 ref.setData(1,0x1325)
 779                                 ref.setData(2,0x3ef)
 780                                 ref.setData(3,0x1)
 781                                 ref.setData(4,-286391716) # eeee025c
 782
 783                         self.session.nav.playService(ref)
 784                         if getTuneInfo["color"]=="CVBS":
 785                                 self.avswitch.setColorFormat(0)
 786                         elif getTuneInfo["color"]=="RGB":
 787                                 self.avswitch.setColorFormat(1)
 788                         elif getTuneInfo["color"]=="YC":
 789                                 self.avswitch.setColorFormat(2)
 790                         if getTuneInfo["ratio"] == "4:3":
 791                                 self.avswitch.setAspectRatio(0)
 792                         elif getTuneInfo["ratio"] == "16:9":
 793                                 self.avswitch.setAspectRatio(6)
 794                         if getTuneInfo["cam"] is True:
 795                                 self.camstep = 1
 796                                 self.camtimer.start(100,True)
 797                         self.tuningtimer.start(2000,True)
 798                         self.tunemsgtimer.start(3000, True)
 799
 800         def cam_state(self):
 801                 current_index = self.currentindex
 802                 if self.camstep == 1:
 803                         slot = 0
 804                         state = eDVBCI_UI.getInstance().getState(slot)
 805                         print '-1-stat',state
 806                         if state > 0:
 807                                 self.camstep=2
 808                                 self.camtimer.start(100,True)
 809                         else:
 810                                 self.session.nav.stopService()
 811                                 self.session.open( MessageBox, _("CAM1_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
 812                                 self.rlist[current_index]="fail"
 813                                 self.tunemsgtimer.stop()
 814 #                               self.rlist[index]="fail"
 815 #                               self["resultlist"].updateList(self.rlist)
 816                 elif self.camstep == 2:
 817                         slot = 0
 818                         appname = eDVBCI_UI.getInstance().getAppName(slot)
 819                         print 'appname',appname
 820                         if appname is None:
 821                                 self.session.nav.stopService()
 822                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
 823                                 self.rlist[current_index]="fail"
 824                                 self.tunemsgtimer.stop()
 825                         else:
 826                                 self.camstep=3
 827                                 self.camtimer.start(100,True)
 828                 elif self.camstep==3:
 829                         slot = 1
 830                         state = eDVBCI_UI.getInstance().getState(slot)
 831                         print '-2-stat',state
 832                         if state > 0:
 833                                 self.camstep=4
 834                                 self.camtimer.start(100,True)
 835                         else:
 836                                 self.session.nav.stopService()
 837                                 self.session.open( MessageBox, _("CAM2_NOT_INSERTED\nPress exit!"), MessageBox.TYPE_ERROR)
 838                                 self.rlist[current_index]="fail"
 839                                 self.tunemsgtimer.stop()
 840 #                               self.rlist[index]="fail"
 841 #                               self["resultlist"].updateList(self.rlist)
 842                 elif self.camstep == 4:
 843                         slot = 1
 844                         appname = eDVBCI_UI.getInstance().getAppName(slot)
 845                         print 'appname',appname
 846                         if appname is None:
 847                                 self.session.nav.stopService()
 848                                 self.session.open( MessageBox, _("NO_GET_APPNAME\nPress exit!"), MessageBox.TYPE_ERROR)
 849                                 self.rlist[current_index]="fail"
 850                                 self.tunemsgtimer.stop()
 851                         else:
 852                                 self.setSource()
 853                                 self.camstep = 5
 854 #                               self.session.open( MessageBox, _("CAM OK!"), MessageBox.TYPE_INFO,2)
 855
 856         def updateStatus(self):
 857                 current_index = self.currentindex
 858                 if self.model == 0 or self.model == 1:
 859                         if current_index ==self.tuner1_1testIndex or current_index==self.tuner1_2testIndex:
 860                                 tunno = 1
 861                                 result = eSctest.getInstance().getFrontendstatus(0)
 862                         else:
 863                                 tunno = 2
 864                                 result = eSctest.getInstance().getFrontendstatus(1)
 865                         if current_index == self.tuner1_2testIndex or current_index==self.tuner2_2testIndex:
 866                                 hv = "Ver"
 867                         else:
 868                                 hv = "Hor"
 869
 870                 elif self.model == 3 or self.model == 4:
 871                         getTuneInfo=self.tuneInfo[current_index]
 872                         result = eSctest.getInstance().getFrontendstatus(getTuneInfo["slot"])
 873                         tunno = getTuneInfo["slot"]+1
 874                         hv = getTuneInfo["pol"]
 875                         if hv == "H":
 876                                 hv = "Hor"
 877                         elif hv == "V":
 878                                 hv = "Ver"
 879                         else :
 880                                 hv == ""
 881
 882                 print "eSctest.getInstance().getFrontendstatus - %d"%result
 883                 if result == 0:
 884                         self.tunerlock = 0
 885                         self.tunemsgtimer.stop()
 886                         self.session.nav.stopService()
 887                         self.avswitch.setColorFormat(0)
 888                         self.session.open( MessageBox, _("Tune%d %s Locking Fail..."%(tunno,hv)), MessageBox.TYPE_ERROR)
 889                         self.rlist[current_index]="fail"
 890                 else :
 891                         self.tunerlock = 1
 892
 893         def tuneback(self,yesno):
 894                 current_index=self.currentindex
 895                 self.session.nav.stopService() # try to disable foreground service
 896                 if yesno and self.tunerlock == 1:
 897                         if current_index == self.tuner_test_last_index and self.camstep < 5: # need fix to depending about CAM exist
 898                                 self.rlist[current_index]="fail"
 899                         else :
 900                                 self.rlist[current_index]="pass"
 901                 else:
 902                         self.rlist[current_index]="fail"
 903                 if self.model == 0 and current_index == 6: # YC
 904                         self.avswitch.setColorFormat(0)
 905                 elif ( self.model == 3 or self.model == 4 ) and self.tuneInfo[current_index]["color"] == "YC":
 906                         self.avswitch.setColorFormat(0)
 907                 self.resetSource()
 908                 self["resultlist"].updateList(self.rlist)
 909
 910         def tunemsg(self):
 911                 self.tuningtimer.stop()
 912                 self.session.openWithCallback(self.tuneback, MessageBox, _("%s ok?" %(self["testlist"].getCurrent()[0])), MessageBox.TYPE_YESNO)
 913
 914 #       ikseong - for 22000 tp
 915         def setSource(self):
 916                 filename = ("/proc/stb/tsmux/ci0_input")
 917                 fd = open(filename,'w')
 918                 fd.write('B')
 919 #               fd.write('A')
 920                 fd.close()
 921 #               filename = ("/proc/stb/tsmux/ci1_input")
 922 #               fd = open(filename,'w')
 923 #               fd.write('CI0')
 924 #               fd.close()
 925                 fd=open("/proc/stb/tsmux/input1","w")
 926 #               fd=open("/proc/stb/tsmux/input0","w")
 927                 fd.write("CI0")
 928                 fd.close()
 929                 print "CI loop test!!!!!!!!!!!!!!"
 930
 931         def resetSource(self):
 932                 fd=open("/proc/stb/tsmux/input1","w")
 933                 fd.write("B")
 934                 fd.close()
 935                 print "CI loop test end!!!!!!!!!!!!!!"
 936
 937         def Test6(self):
 938                 self.avswitch.setInput("SCART")
 939                 sleep(2)
 940                 self.session.openWithCallback(self.check6, MessageBox, _("Scart loop ok?"), MessageBox.TYPE_YESNO)
 941
 942         def check6(self,yesno):
 943                 if yesno:
 944                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
 945                 else:
 946                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
 947                 self.avswitch.setInput("ENCODER")
 948
 949         def check7(self):
 950                 global rstest
 951                 if rstest == 1:
 952                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
 953                 else:
 954                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
 955
 956         def Test7(self):
 957                 self.session.openWithCallback(self.check7,RS232Test)
 958
 959         def Agingmode(self):
 960                 if self.testing==1:
 961                         return
 962                 if self.oldref is None:
 963                         eref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0")
 964                         serviceHandler = eServiceCenter.getInstance()
 965                         servicelist = serviceHandler.list(eref)
 966                         if not servicelist is None:
 967                                 ref = servicelist.getNext()
 968                         else:
 969                                 ref = self.getCurrentSelection()
 970                                 print "servicelist none"
 971                 else:
 972                         ref = self.oldref
 973                 self.session.nav.stopService() # try to disable foreground service
 974                 ref.setData(0,0x19)
 975                 ref.setData(1,0x1325)
 976                 ref.setData(2,0x3ef)
 977                 ref.setData(3,0x1)
 978                 ref.setData(4,0x64af79)
 979                 self.session.nav.playService(ref)
 980                 self.avswitch.setColorFormat(0)
 981                 self.avswitch.setAspectRatio(0)
 982                 self.agingtimer.start(2000,True)
 983
 984         def agingCheck(self):
 985                 result = eSctest.getInstance().getFrontendstatus(0)
 986                 hv = "Ver"
 987                 print "eSctest.getInstance().getFrontendstatus - %d"%result
 988                 if result == 0:
 989                         self.session.nav.stopService()
 990                         self.session.open( MessageBox, _("Tune 1 Ver Locking Fail..."), MessageBox.TYPE_ERROR)
 991                 elif result == 1 :
 992                         self.session.openWithCallback(self.agingResult,AgingTest)
 993                 else:
 994                         self.session.nav.stopService()
 995                         self.session.open( MessageBox, _("Tune 1 Ver Error %d..."%result), MessageBox.TYPE_ERROR)
 996
 997         def agingResult(self):
 998                 global Agingresult
 999                 if(Agingresult ==1):
1000                         self["testlist"].moveToIndex(self.fdefaultIndex)
1001                         self.Test14()
1002                         self["testlist"].moveToIndex(self.shutdownIndex)
1003
1004         def Test8(self):
1005                 self.usbtry = 9
1006                 self.usbtimer.start(100,True)
1007
1008         def usbCheck(self):
1009                 if self.usbtry == 0:
1010                         displayerror = 1
1011                 else:
1012                         self.rlist[self["testlist"].getCurrent()[1]]="try %d"%self.usbtry
1013                         self["resultlist"].updateList(self.rlist)
1014                         self.usbtry -= 1
1015                         displayerror = 0
1016
1017                 if self.model==0 or self.model==3 or self.model==4:
1018                         devices = [ "/autofs/sdc1", "/autofs/sdd1", "/autofs/sde1" ]
1019                 elif self.model==1:
1020                         devices = [ "/autofs/sda1", "/autofs/sdb1" ]
1021                 elif self.model==2:
1022                         devices = [ "/autofs/sdc1", "/autofs/sdd1" ]
1023                 else :
1024                         self.session.open( MessageBox, _("invalid model"), MessageBox.TYPE_ERROR)
1025                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1026                         return
1027
1028                 result=len(devices)
1029
1030                 for dev in devices:
1031                         try:
1032                                 if fileExists(dev):
1033                                         if access(dev,F_OK|R_OK|W_OK):
1034                                                 dummy=open(dev+"/dummy03","w")
1035                                                 dummy.write("complete")
1036                                                 dummy.close()
1037                                                 dummy=open(dev+"/dummy03","r")
1038                                                 if dummy.readline()=="complete":
1039                                                         print dev," - complete"
1040                                                 else:
1041                                                         print dev," - readline error"
1042                                                         result=result -1
1043                                                         displayerror = 1
1044                                                 dummy.close()
1045                                                 system("rm "+dev+"/dummy03")
1046                                         else:
1047                                                 print dev," - rw access error"
1048                                                 result=result -1
1049                                                 displayerror = 1
1050                                 else:
1051                                         print dev," - file not exist"
1052                                         result=result-1
1053                         except:
1054                                 print dev," - exceptional error"
1055                                 result=result -1
1056                                 displayerror = 1
1057
1058                 if result < 0 :
1059                         result = 0
1060                 elif result == len(devices):
1061                         self.session.open( MessageBox, _("USB test pass %d devices\nPress OK!"%result), MessageBox.TYPE_INFO)
1062                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1063                 else:
1064                         if displayerror == 1:
1065                                 self.session.open( MessageBox, _("USB test error : Success-%d"%result+" Fail-%d\nPress EXIT!"%(len(devices)-result)), MessageBox.TYPE_ERROR)
1066                                 self.rlist[self["testlist"].getCurrent()[1]]="fail"
1067                         else:
1068                                 self.usbtimer.start(1100,True)
1069
1070         def pingtest(self):
1071                 self.testing = 1
1072 #               system("/etc/init.d/networking stop")
1073                 system("ifconfig eth0 192.168.0.10")
1074 #               system("/etc/init.d/networking start")
1075                 cmd1 = "ping -c 1 192.168.0.100"
1076                 self.PingConsole = Console()
1077                 self.PingConsole.ePopen(cmd1, self.checkNetworkStateFinished,self.NetworkStatedataAvail)
1078
1079         def checkNetworkStateFinished(self, result, retval,extra_args):
1080                 (statecallback) = extra_args
1081                 if self.PingConsole is not None:
1082                         if retval == 0:
1083                                 self.PingConsole = None
1084                                 content = result.splitlines()
1085 #                               print 'content',content
1086                                 x = content[4].split()
1087 #                               print 'x',x
1088                                 if x[0]==x[3]:
1089                                         statecallback(1)
1090                                 else:
1091                                         statecallback(0)
1092                         else:
1093                                 statecallback(0)
1094
1095
1096         def NetworkStatedataAvail(self,data):
1097                 global ethtest
1098                 if data == 1:
1099                         ethtest = 1
1100                         print "success"
1101 #                       self.session.open( MessageBox, _("Ping test pass"), MessageBox.TYPE_INFO,2)
1102                         self.session.openWithCallback(self.openMacConfig ,MessageBox, _("Ping test pass"), MessageBox.TYPE_INFO,2)
1103
1104                 else:
1105                         ethtest = 0
1106                         print "fail"
1107                         self.session.open( MessageBox, _("Ping test fail\nPress exit"), MessageBox.TYPE_ERROR)
1108                         self.macresult()
1109
1110         def Test9(self):
1111                 self.pingtest()
1112
1113         def openMacConfig(self, ret=False):
1114                 self.session.openWithCallback(self.macresult ,MacConfig,mactry=self.mactry)
1115
1116         def macresult(self):
1117                 global ethtest
1118                 if ethtest == 1:
1119                         self.rlist[self.ethernettestIndex]="pass"
1120 #                       self.rlist[self["testlist"].getCurrent()[1]]="pass"
1121                 else:
1122                         self.rlist[self.ethernettestIndex]="fail"
1123 #                       self.rlist[self["testlist"].getCurrent()[1]]="fail"
1124                 self.getmacaddr()
1125                 self.testing = 0
1126
1127         def MemTest(self, which):
1128                 index = which
1129                 result = 0
1130                 if index==0:
1131                         result = eMemtest.getInstance().dramtest()
1132                 elif index==1:
1133                         result = eMemtest.getInstance().flashtest()
1134                         result = 0      #       temp
1135                 else:
1136                         result = eMemtest.getInstance().dramtest()
1137                         result = eMemtest.getInstance().flashtest()
1138                         result = 0      #       temp
1139
1140                 index = index+10
1141
1142                 if result == 0:
1143                         print index,self.rlist[index]
1144                         self.rlist[index]="pass"
1145                 else:
1146                         print index,self.rlist[index]
1147                         self.rlist[index]="fail"
1148                 self["resultlist"].updateList(self.rlist)
1149
1150         def scciresult(self):
1151                 global smartcardtest
1152                 if smartcardtest == 1:
1153                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1154                 else:
1155                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1156
1157         def Test10(self):
1158                 self.session.openWithCallback(self.scciresult ,SmartCardTest,stbmodel=self.model)
1159
1160         def Test11(self):
1161                 self.MemTest(1)
1162
1163         def Test12(self):
1164                 self.MemTest(2)
1165
1166         def Test13(self):
1167                 self.MemTest(3)
1168
1169
1170         def Test14(self):
1171                 try:
1172                         print "test14"
1173                         system("rm -R /etc/enigma2")
1174                         system("ls /")
1175                         system("cp -R /usr/share/enigma2/defaults /etc/enigma2")
1176                         self.rlist[self["testlist"].getCurrent()[1]]="pass"
1177                         self["resultlist"].updateList(self.rlist)
1178                 except:
1179                         print "test14 except"
1180                         self.rlist[self["testlist"].getCurrent()[1]]="fail"
1181                         self["resultlist"].updateList(self.rlist)
1182                         self.session.open( MessageBox, _("Factory reset fail"), MessageBox.TYPE_ERROR)
1183
1184         def Test15(self):
1185                 self.session.openWithCallback(self.shutdown ,MessageBox, _("Do you want to shut down?"), MessageBox.TYPE_YESNO)
1186
1187         def shutdown(self, yesno):
1188                 if yesno :
1189                         from os import _exit
1190                         system("/usr/bin/showiframe /boot/backdrop.mvi")
1191                         _exit(1)
1192                 else:
1193                         return
1194
1195         def keyCancel(self):
1196                 if self.testing==1:
1197                         return
1198                 print "exit"
1199                 self.close()
1200 #               if self.oldref is not None:
1201 #                       self.session.nav.playService(self.oldref)
1202
1203 ethtest = 0
1204 class MacConfig(Screen):
1205         skin = """
1206                 <screen position="100,250" size="520,100" title="Mac Config" >
1207                         <eLabel text="Mac Address " position="10,15" size="200,40" font="Regular;30" />
1208                         <widget name="text" position="230,15" size="230,40" font="Regular;30" />
1209                         <widget name="text1" position="470,15" size="40,40" font="Regular;30" />
1210                         <eLabel text=" " position="5,55" zPosition="-1" size="510,5" backgroundColor="#02e1e8e6" />
1211                         <widget name="stattext" position="30,75" size="400,25" font="Regular;20" />
1212                 </screen>"""
1213
1214         def __init__(self, session, mactry = 1):
1215                 self["actions"] = ActionMap(["DirectionActions","OkCancelActions"],
1216                 {
1217                         "ok": self.keyOk,
1218                         "left": self.keyleft,
1219                         "right": self.keyright,
1220                         "cancel": self.keyCancel,
1221                 }, -2)
1222
1223                 Screen.__init__(self, session)
1224
1225                 self.mactry = mactry
1226                 self.model = 0
1227                 self.getModelInfo()
1228 #               self.result = 0
1229                 self.macfd = 0
1230                 self.macaddr = "000000000000"
1231                 self.ReadMacinfo = 0
1232                 self["text"]=Label((self.macaddr))
1233                 self["text1"]= Label(("< >"))
1234                 self["stattext"]= Label((""))
1235                 self.displaymac()
1236                 self.loadmacaddr()
1237                 self.getmacaddr()
1238                 global ethtest
1239                 ethtest = 1
1240
1241         def getModelInfo(self):
1242                 getmodel = 0
1243                 if fileExists("/proc/stb/info/vumodel"):
1244                         info = open("/proc/stb/info/vumodel").read().strip()
1245                         if info == "combo":
1246                                 self.model = 2
1247                                 getmodel = 1
1248                                 print "MacConfig, model : combo"
1249                         elif info == "solo":
1250                                 self.model = 1
1251                                 getmodel = 1
1252                                 print "MacConfig, model : solo"
1253                         elif info == "duo":
1254                                 self.model = 0
1255                                 getmodel = 1
1256                                 print "MacConfig, model : duo"
1257                         elif info == "uno":
1258                                 self.model = 3
1259                                 getmodel = 1
1260                                 print "getModelInfo : uno"
1261                         elif info == "ultimo":
1262                                 self.model = 4
1263                                 getmodel = 1
1264                                 print "getModelInfo : ultimo"
1265
1266
1267                 if getmodel == 0 and fileExists("/proc/stb/info/version"):
1268                         info = open("/proc/stb/info/version").read()
1269 #                       print info,info[:2]
1270                         if info[:2] == "14":
1271                                 self.model = 1
1272                                 print "MacConfig, model : solo_"
1273                         elif info[:2] == "12":
1274                                 self.model = 0
1275                                 print "MacConfig, model: duo_"
1276
1277         def loadmacaddr(self):
1278                 try:
1279                         self.macfd = 0
1280
1281                         if self.model==0 or self.model==3 or self.model==4 :
1282                                 devices = ["/autofs/sdb1", "/autofs/sdc1", "/autofs/sdd1", "/autofs/sde1" ]
1283                         elif self.model==1:
1284                                 devices = [ "/autofs/sda1", "/autofs/sdb1" ]
1285                         elif self.model==2:
1286                                 devices = [ "/autofs/sdb1", "/autofs/sdc1", "/autofs/sdd1" ]
1287
1288                         for dev in devices:
1289                                 print 'try..',dev
1290                                 if  fileExists(dev+"/macinfo.txt"):
1291                                         print "<open>"+dev+"/macinfo.txt"
1292                                         self.macfd = open(dev+"/macinfo.txt","r+")
1293                                         break
1294
1295                         if self.macfd == 0:
1296                                 self["text"].setText(("cannot read usb!!"))
1297                                 self["text1"].setText((" "))
1298                                 self["stattext"].setText((" Press Exit Key."))
1299                                 self.ReadMacinfo=0
1300                                 return
1301
1302                         macaddr=self.macfd.readline().split(":")
1303                         self.macaddr=macaddr[1]+macaddr[2]+macaddr[3]+macaddr[4]+macaddr[5]+macaddr[6]
1304                         self.displaymac()
1305                         self.ReadMacinfo = 1
1306                 except:
1307                         self["text"].setText(("cannot read usb!!"))
1308                         self["text1"].setText((" "))
1309                         self["stattext"].setText((" Press Exit Key."))
1310                         self.ReadMacinfo=0
1311
1312         def getmacaddr(self):
1313                 if self.ReadMacinfo==0:
1314                         return
1315                 try:
1316                         if self.model == 2 or self.model == 3 or self.model == 4:
1317                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd5"
1318                         elif self.model == 0 or self.model == 1:
1319                                 cmd = "nanddump -s 0x" + str((self.mactry-1)*2) + "0000 -b -o -l 64 -p /dev/mtd4"
1320                         self.macConsole = Console()
1321                         self.macConsole.ePopen(cmd, self.readmac,self.checkReadmac)
1322                 except:
1323                         return
1324
1325         def readmac(self, result, retval,extra_args=None):
1326                 (callback) = extra_args
1327                 if self.macConsole is not None:
1328                         if retval == 0:
1329                                 self.macConsole = None
1330                                 macline = None
1331                                 content =result.splitlines()
1332                                 for x in content:
1333                                         if x.startswith('0x000'+str((self.mactry-1)*2)+'0010:'):
1334                                                 macline = x.split()
1335                                 if macline == None:
1336                                         callback(0)
1337                                 elif len(macline) < 10:
1338                                         callback(1)
1339                                 else:
1340                                         mac = macline[5]+":"+macline[6]+":"+macline[7]+":"+macline[8]+":"+macline[9]+":"+macline[10]
1341                                         self["stattext"].setText(("now : "+mac))
1342                                         callback(2)
1343
1344         def checkReadmac(self,data):
1345                 if data == 0:
1346                         print "block %d is bad block" % self.mactry
1347                         self.mactry = self.mactry + 1
1348                         if self.mactry > 4:
1349                                 self.session.open(MessageBox, _("FLASH IS BROKEN"), type = MessageBox.TYPE_INFO, enable_input = False)
1350                                 return
1351                         else:
1352                                 self.getmacaddr()
1353                 elif data == 1:
1354                         print 'mac dump read error'
1355                         return
1356                 elif data == 2:
1357                         print 'mac address read ok'
1358                         return
1359
1360
1361         def keyleft(self):
1362                 if self.ReadMacinfo==0 :
1363                         return
1364                 macaddress = long(self.macaddr,16)-1
1365                 if macaddress < 0 :
1366                         macaddress = 0xffffffffffff
1367                 self.macaddr = "%012x"%macaddress
1368                 self.displaymac()
1369
1370         def keyright(self):
1371                 if self.ReadMacinfo==0 :
1372                         return
1373                 macaddress = long(self.macaddr,16)+1
1374                 if macaddress > 0xffffffffffff:
1375                         macaddress = 0
1376                 self.macaddr = "%012x"%macaddress
1377                 self.displaymac()
1378
1379         def displaymac(self):
1380                 macaddr= self.macaddr
1381                 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))))
1382
1383         def keyOk(self):
1384                 if self.ReadMacinfo==0 :
1385                         return
1386                 try:
1387                         macaddr = self.macaddr
1388 #make_mac_sector 00-99-99-99-00-00 > /tmp/mac.sector
1389 #flash_eraseall /dev/mtd4
1390 #nandwrite /dev/mtd4 /tmp/mac.sector -p
1391                         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))
1392                         system(cmd)
1393                         if self.model == 2 or self.model == 3 or self.model == 4:
1394                                 system("flash_eraseall /dev/mtd5")
1395                                 system("nandwrite /dev/mtd5 /tmp/mac.sector -p")
1396                         elif self.model == 0 or self.model ==1 :
1397                                 system("flash_eraseall /dev/mtd4")
1398                                 system("nandwrite /dev/mtd4 /tmp/mac.sector -p")
1399                         macaddress = long(macaddr,16)+1
1400                         if macaddress > 0xffffffffffff:
1401                                 macaddress = 0
1402                         macaddr = "%012x"%macaddress
1403                         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))
1404                         self.macfd.seek(0)
1405                         self.macfd.write(macwritetext)
1406                         self.macfd.close()
1407                         system("sync")
1408                         self.macaddr = macaddr
1409                         self.close()
1410                 except:
1411                         self.session.open( MessageBox, _("Mac address fail"), MessageBox.TYPE_ERROR)
1412                         global ethtest
1413                         ethtest = 0
1414                         self.close()
1415
1416         def keyCancel(self):
1417                 if self.macfd != 0:
1418                         self.macfd.close()
1419                 global ethtest
1420                 ethtest = 0
1421                 self.close()
1422
1423
1424 sccitest = 0
1425
1426 class ScCiTest(Screen):
1427         skin = """
1428                 <screen position="120,225" size="440,200" title="CI Smartcard Test" >
1429                         <widget name="testlist" position="10,0" size="340,120" />
1430                         <widget name="resultlist" position="370,0" size="60,120" />
1431                         <eLabel text=" " position="5,125" zPosition="-1" size="430,5" backgroundColor="#02e1e8e6" />
1432                         <widget name="text" position="10,140" size="420,50" font="Regular;25" />
1433                 </screen>"""
1434         step=1
1435         def __init__(self, session):
1436                 self["actions"] = ActionMap(["DirectionActions","OkCancelActions"],
1437                 {
1438                         "ok": self.keyOk,
1439                         "up": self.up,
1440                         "down":self.down,
1441                         "cancel": self.keyCancel,
1442                 }, -2)
1443
1444                 Screen.__init__(self, session)
1445                 tlist = []
1446                 tlist.append(("Smartcard 1 Test",0))
1447                 tlist.append(("Smartcard 2 Test",1))
1448                 tlist.append(("CI 1 Test",2))
1449                 tlist.append(("CI 2 Test",3))
1450                 self["testlist"] = MenuList(tlist)
1451                 self.rlist = []
1452                 for x in range(4):
1453                         self.rlist.append((".."))
1454                 self["resultlist"] = TestResultList(self.rlist)
1455                 self.result = 0
1456                 self.removecard = eTimer()
1457                 self.removecard.callback.append(self.remove_card)
1458                 self["text"]=Label(("Press OK Key"))
1459                 self.camstate= eTimer()
1460                 self.camstate.callback.append(self.cam_state)
1461                 self.camtry = 5
1462                 self.camstep = 0
1463
1464         def keyCancel(self):
1465                 global sccitest
1466                 print "result ", self.result
1467                 if self.result==15:
1468                         sccitest=1
1469                 self.resetSource()
1470                 self.close()
1471
1472         def up(self):
1473                 self["text"].setText(_("Press OK Key"))
1474                 self["testlist"].instance.moveSelection(self["testlist"].instance.moveUp)
1475
1476         def down(self):
1477                 self["text"].setText(_("Press OK Key"))
1478                 self["testlist"].instance.moveSelection(self["testlist"].instance.moveDown)
1479
1480         def keyOk(self):
1481                 print "line - ",self["testlist"].getCurrent()[1]
1482                 index = self["testlist"].getCurrent()[1]
1483                 result = 0
1484                 if index==0 or index==1:
1485                         self["text"].setText(_("Insert Card?"))
1486                         self.ScTest(True)
1487                 elif index ==2 or index==3:
1488                         self["text"].setText(_("Insert Cam"))
1489                         self.CamTest()
1490
1491         def CamTest(self):
1492                 self.camtry = 10
1493                 self.camstep = 1
1494                 self.camstate.start(1000,True)
1495
1496         def setSource(self, cislot):
1497                 filename = ("/proc/stb/tsmux/ci%d_input"%cislot)
1498                 fd = open(filename,'w')
1499                 fd.write('A')
1500                 fd.close()
1501
1502         def setInputSource(self, cislot):
1503                 fd=open("/proc/stb/tsmux/input0","w")
1504                 if cislot==0:
1505                         fd.write("CI0")
1506                 else:
1507                         fd.write("CI1")
1508                 fd.close()
1509
1510         def resetSource(self):
1511                 fd=open("/proc/stb/tsmux/input0","w")
1512                 fd.write("A")
1513                 fd.close()
1514 #               fd = open("/proc/stb/tsmux/ci0_input","w")
1515 #               fd.write("CI0")
1516 #               fd.close()
1517 #               fd = open("/proc/stb/tsmux/ci1_input","w")
1518 #               fd.write("CI1")
1519 #               fd.close()
1520
1521         def channelstart(self):
1522                 ref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0")
1523                 ref.setData(0,0x19)
1524                 ref.setData(1,0x83)
1525                 ref.setData(2,0x6)
1526                 ref.setData(3,0x85)
1527                 ref.setData(4,0x640000)
1528                 self.session.nav.playService(ref)
1529
1530         def channelstop(self):
1531                 self.session.nav.stopService() # try to disable foreground service
1532
1533         def cam_state(self):
1534                 index = self["testlist"].getCurrent()[1]
1535                 if (index-2)==0:
1536                         slot = 1
1537                 else:
1538                         slot = 0
1539                 print 'cam_state', self.camstep,self.camtry
1540                 if self.camstep == 1:
1541                         state = eDVBCI_UI.getInstance().getState(slot)
1542                         print 'stat',state
1543                         if state == 1:
1544                                 self.camstep=2
1545                                 self.camtry=10
1546                                 self["text"].setText(_("Getting Cam name...."))
1547                                 self.camstate.start(5000,True)
1548                         else:
1549                                 self.camtry-=1
1550                                 if self.camtry>0:
1551                                         self.camstate.start(1000,True)
1552                                 else:
1553                                         self.session.open( MessageBox, _("NO_NOT_INSERTED"), MessageBox.TYPE_ERROR)
1554                                         self.rlist[index]="fail"
1555                                         self["resultlist"].updateList(self.rlist)
1556
1557                 elif self.camstep == 2:
1558                         appname = eDVBCI_UI.getInstance().getAppName(slot)
1559                         print 'appname',appname
1560                         if appname is None:
1561                                 self.camtry-=1
1562                                 if self.camtry>0:
1563                                         self.camstate.start(1000,True)
1564                                 else:
1565                                         self.session.open( MessageBox, _("NO_GET_APPNAME"), MessageBox.TYPE_ERROR)
1566                                         self.rlist[index]="fail"
1567                                         self["resultlist"].updateList(self.rlist)
1568                         else:
1569                                 self["text"].setText(_("Get Cam name : %s"%appname+". \n Remove Cam!"))
1570                                 self.channelstart()
1571                                 self.setInputSource(slot)
1572                                 self.setSource(slot)
1573                                 self.camstep=3
1574                                 self.camtry=30
1575                                 self.camstate.start(1000,True)
1576                 elif self.camstep==3:
1577                         state = eDVBCI_UI.getInstance().getState(slot)
1578                         print 'stat', state
1579                         if state == 0:
1580                                 self.channelstop()
1581                                 self.result += (1<<index)
1582                                 print self.result
1583                                 self.rlist[index]="pass"
1584                                 self["text"].setText(_("Press OK Key"))
1585                                 self["resultlist"].updateList(self.rlist)
1586                                 if index==2:
1587                                         self.down()
1588                                 elif index == 3:
1589                                         self.keyCancel()
1590                         else:
1591                                 self.camtry-=1
1592                                 if self.camtry>0:
1593                                         self.camstate.start(1000,True)
1594                                 else:
1595                                         self.channelstop()
1596                                         self.session.open( MessageBox, _("NO_REMOVE_CAM"), MessageBox.TYPE_ERROR)
1597                                         self.rlist[index]="fail"
1598                                         self["resultlist"].updateList(self.rlist)
1599
1600         def check_smart_card(self,which):
1601                 index = which
1602                 result  = 0
1603                 if which==0:
1604                         result = eSctest.getInstance().check_smart_card("/dev/sci0")
1605                 elif which ==1:
1606                         result = eSctest.getInstance().check_smart_card("/dev/sci1")
1607                 else:
1608                         result = -1
1609
1610                 print result
1611
1612                 if result == 0:
1613                         print 'pass'
1614                 else:
1615                         if result ==-1:
1616                                 self.session.open( MessageBox, _("1:NO_DEV_FOUND"), MessageBox.TYPE_ERROR)
1617                         elif result == -2:
1618                                 self.session.open( MessageBox, _("1:SC_NOT_INSERTED"), MessageBox.TYPE_ERROR)
1619                         elif result == -3:
1620                                 self.session.open( MessageBox, _("1:SC_NOT_VALID_ATR"), MessageBox.TYPE_ERROR)
1621                         elif result == -5:
1622                                 self.session.open( MessageBox, _("1:SC_READ_TIMEOUT"), MessageBox.TYPE_ERROR)
1623                         self.rlist[which]="fail"
1624                         self["resultlist"].updateList(self.rlist)
1625                 return result
1626
1627         def remove_card(self):
1628                 index = self["testlist"].getCurrent()[1]
1629                 if index==0:
1630                         result = eSctest.getInstance().eject_smart_card("/dev/sci0")
1631                 elif index==1:
1632                         result = eSctest.getInstance().eject_smart_card("/dev/sci1")
1633                 print 'remove result' ,result
1634                 if result == 0:
1635                         self.rlist[index]="pass"
1636                         self.result += (1<<index)
1637                 else:
1638                         if result ==-1:
1639                                 self.session.open( MessageBox, _("2:NO_DEV_FOUND"), MessageBox.TYPE_ERROR)
1640                         elif result == -2:
1641                                 self.session.open( MessageBox, _("2:SC_NOT_INSERTED"), MessageBox.TYPE_ERROR)
1642                         elif result == -3:
1643                                 self.session.open( MessageBox, _("2:SC_NOT_VALID_ATR"), MessageBox.TYPE_ERROR)
1644                         elif result == -4:
1645                                 self.session.open( MessageBox, _("2:SC_NOT_REMOVED"), MessageBox.TYPE_ERROR)
1646                         self.rlist[index]="fail"
1647                 self["resultlist"].updateList(self.rlist)
1648                 self["text"].setText(_("Press OK Key"))
1649                 self.down()
1650                 return result
1651
1652
1653         def ScTest(self, yesno):
1654                 if yesno==False:
1655                         return
1656                 index = self["testlist"].getCurrent()[1]
1657                 result = self.check_smart_card(index)
1658                 if result==0:
1659                         self.removecard.start(100,True)
1660                         self["text"].setText(_("Read Ok. Remove Card!"))
1661                 else:
1662                         return
1663
1664 smartcardtest = 0
1665
1666 class SmartCardTest(Screen):
1667         skin = """
1668                 <screen position="300,240" size="160,120" title="SmartCard Test" >
1669                         <widget name="text" position="10,10" size="140,100" font="Regular;22" />
1670                 </screen>"""
1671
1672         def __init__(self, session, stbmodel = 0):
1673                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions"],
1674                 {
1675                         "cancel": self.keyCancel,
1676                         "ok" : self.keyCancel
1677                 }, -2)
1678
1679                 Screen.__init__(self, session)
1680 #               self["text"]=Label(("Press Key LEFT"))
1681                 self["text"]=Label(("Testing Smartcard 1..."))
1682                 self.step = 0
1683                 self.smartcardtimer = eTimer()
1684                 self.smartcardtimer.callback.append(self.check_smart_card)
1685                 self.closetimer = eTimer()
1686                 self.closetimer.callback.append(self.close)
1687                 self.smartcard=0
1688                 global smartcardtest
1689                 smartcardtest = 0
1690                 self.model = stbmodel
1691                 self.Testmode = 1
1692                 self.smartcardtimer.start(100,True)
1693
1694         def check_smart_card(self):
1695                 global smartcardtest
1696                 index = self.smartcard
1697                 result  = 0
1698                 if index==0:
1699                         if self.Testmode==0:
1700                                 result = eSctest.getInstance().check_smart_card("/dev/sci0")
1701                         else:
1702                                 result = eSctest.getInstance().n_check_smart_card("/dev/sci0")
1703                 elif index ==1:
1704                         if self.Testmode==0:
1705                                 result = eSctest.getInstance().check_smart_card("/dev/sci1")
1706                         else:
1707                                 result = eSctest.getInstance().n_check_smart_card("/dev/sci1")
1708                 else:
1709                         result = -1
1710
1711                 print result
1712
1713                 if result == 0:
1714                         print 'pass'
1715                         if(index== 0 and ( self.model== 0 or self.model==2 or self.model == 3 or self.model == 4) ):
1716                                 self.smartcard = 1
1717                                 self["text"].setText(_("Testing Smartcard 2..."))
1718                                 self.smartcardtimer.start(100,True)
1719                                 return
1720                         elif (index==1 or self.model==1):
1721                                 smartcardtest = 1
1722 #                               self.session.open( MessageBox, _("Smart Card OK!!"), MessageBox.TYPE_INFO,2)
1723                                 self.step = 1
1724                                 self["text"].setText(_("Smart Card OK!!"))
1725                                 self.closetimer.start(2000,True)
1726                                 self.smartcardtimer.stop()
1727                         else :
1728
1729                                 self["text"].setText(_("Smart Card model type error"))
1730                                 self.closetimer.start(2000,True)
1731                                 self.smartcardtimer.stop()
1732 #                       self.session.openWithCallback(self.check6, MessageBox, _("Scart loop ok?"), MessageBox.TYPE_INFO)
1733                 else:
1734 #                       if result ==-1:
1735 #                               self.session.open( MessageBox, _("%d:NO_DEV_FOUND"%(index+1)), MessageBox.TYPE_ERROR)
1736 #                       elif result == -2:
1737 #                               self.session.open( MessageBox, _("%d:SC_NOT_INSERTED"%(index+1)), MessageBox.TYPE_ERROR)
1738 #                       elif result == -3:
1739 #                               self.session.open( MessageBox, _("%d:SC_NOT_VALID_ATR"%(index+1)), MessageBox.TYPE_ERROR)
1740 #                       elif result == -5:
1741 #                               self.session.open( MessageBox, _("%d:SC_READ_TIMEOUT"%(index+1)), MessageBox.TYPE_ERROR)
1742                         if(index==0):
1743                                 self["text"].setText(_("Smart Card 1 Error!\nerrorcode=%d"%result))
1744                         elif (index==1):
1745                                 self["text"].setText(_("Smart Card 2 Error!\nerrorcode=%d"%result))
1746                         self.closetimer.start(2000,True)
1747                         self.smartcardtimer.stop()
1748
1749
1750         def keyCancel(self):
1751                 self.close()
1752
1753
1754
1755 fronttest = 0
1756
1757 class FrontTest(Screen):
1758         skin = """
1759                 <screen position="260,240" size="200,180" title="Front Test" >
1760                         <widget name="text" position="10,10" size="180,160" font="Regular;22" />
1761                 </screen>"""
1762
1763         def __init__(self, session):
1764                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions"],
1765                 {
1766                         "ok": self.keyOk,
1767                         "up":self.keyUp,
1768                         "down":self.keyDown,
1769                         "cancel": self.keyCancel,
1770                 }, -2)
1771
1772                 Screen.__init__(self, session)
1773                 self["text"]=Label(("Wheel LEFT"))
1774                 self.step = 1
1775
1776                 self.fronttimer= eTimer()
1777                 self.fronttimer.callback.append(self.FrontAnimate)
1778                 self.frontturnonoff = 0
1779                 eSctest.getInstance().VFD_Open()
1780                 self.keytimeout = eTimer()
1781                 self.keytimeout.callback.append(self.KeyTimeOut)
1782                 self.keytimeout.start(5000,True)
1783
1784         def KeyTimeOut(self):
1785                 if self.step == 1:
1786                         self["text"].setText(("Wheel LEFT ERROR"))
1787                 elif self.step ==2 :
1788                         self["text"].setText(("Wheel RIGHT ERROR"))
1789                 elif self.step == 3:
1790                         self["text"].setText(("Wheel BUTTON ERROR"))
1791                 self.step = 0
1792 #               self.keyCancel()
1793
1794         def keyCancel(self):
1795                 global fronttest
1796                 self.fronttimer.stop()
1797                 eSctest.getInstance().VFD_Close()
1798                 if self.step==4:
1799                         fronttest = 1
1800                 else:
1801                         fronttest = 0
1802                 self.close()
1803
1804         def keyDown(self):
1805                 if self.step==2:
1806                         self.keytimeout.stop()
1807                         self.keytimeout.start(5000,True)
1808                         self.step = 3
1809                         self["text"].setText(_("Press Front Wheel"))
1810
1811         def keyUp(self):
1812                 if self.step==1:
1813                         self.keytimeout.stop()
1814                         self.keytimeout.start(5000,True)
1815                         self.step=2
1816                         self["text"].setText(_("Wheel RIGHT"))
1817 #               else:
1818 #                       print ""
1819
1820         def keyOk(self):
1821                 if self.step == 3:
1822                         self.keytimeout.stop()
1823                         self.step =4
1824                         self.fronttimer.start(1000,True)
1825                         self["text"].setText(("Front Test OK!\nPress Exit Key"))
1826 #               elif self.step==4:
1827 #                       global fronttest
1828 #                       self.fronttimer.stop()
1829 #                       eSctest.getInstance().VFD_Close()
1830 #                       fronttest = 1
1831 #                       self.close()
1832
1833         def FrontAnimate(self):
1834                 if (self.frontturnonoff==0):
1835                         eSctest.getInstance().turnon_VFD()
1836                         self.frontturnonoff = 1
1837                 else:
1838                         self.frontturnonoff = 0
1839                         eSctest.getInstance().turnoff_VFD()
1840                 self.fronttimer.start(1000,True)
1841
1842
1843 class FrontTest_solo(Screen):
1844         skin = """
1845                 <screen position="260,240" size="200,180" title="Front Test" >
1846                         <widget name="text" position="10,10" size="180,160" font="Regular;22" />
1847                 </screen>"""
1848
1849         def __init__(self, session):
1850                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","GlobalActions"],
1851                 {
1852                         "ok": self.keyOk,
1853                         "cancel": self.keyCancel,
1854                         "left": self.keyleft,
1855                         "right": self.keyright,
1856                         "power_down": self.keypower,
1857                         "volumeUp": self.keyvolup,
1858                         "volumeDown": self.keyvoldown,
1859                 }, -2)
1860
1861                 Screen.__init__(self, session)
1862                 self["text"]=Label(("Press Front STANDBY"))
1863                 self.step = 1
1864
1865                 self.fronttimer= eTimer()
1866                 self.fronttimer.callback.append(self.FrontAnimate)
1867                 self.frontturnonoff = 0
1868                 eSctest.getInstance().VFD_Open()
1869                 self.keytimeout = eTimer()
1870                 self.keytimeout.callback.append(self.KeyTimeOut)
1871                 self.keytimeout.start(5000,True)
1872
1873         def KeyTimeOut(self):
1874                 if self.step == 1:
1875                         self["text"].setText(("Front STANDBY ERROR\nPress exit!"))
1876                 elif self.step == 2 :
1877                         self["text"].setText(("Front CH - ERROR\nPress exit!"))
1878                 elif self.step == 3:
1879                         self["text"].setText(("Front CH + ERROR\nPress exit!"))
1880                 elif self.step == 4 :
1881                         self["text"].setText(("Front VOL - ERROR\nPress exit!"))
1882                 elif self.step == 5:
1883                         self["text"].setText(("Front VOL + ERROR\nPress exit!"))
1884
1885                 self.step = 0
1886 #               self.keyCancel()
1887
1888         def keypower(self):
1889                 if self.step== 1:
1890                         self.keytimeout.stop()
1891                         self.keytimeout.start(5000,True)
1892                         self.step = 2
1893                         self["text"].setText(_("Press Front CH -"))
1894
1895         def keyright(self):
1896                 if self.step== 3:
1897                         self.keytimeout.stop()
1898                         self.keytimeout.start(5000,True)
1899                         self.step = 4
1900                         self["text"].setText(_("Press Front VOL -"))
1901
1902         def keyleft(self):
1903                 if self.step== 2:
1904                         self.keytimeout.stop()
1905                         self.keytimeout.start(5000,True)
1906                         self.step = 3
1907                         self["text"].setText(_("Press Front CH +"))
1908
1909         def keyvolup(self):
1910                 if self.step== 5:
1911                         self.keytimeout.stop()
1912                         self.step = 6
1913                         self.fronttimer.start(1000,True)
1914                         self["text"].setText(_("Front LED OK?\n\nyes-ok\nno-exit"))
1915 #                       self["text"].setText(("Front Test OK!\nPress Exit Key"))
1916
1917         def keyvoldown(self):
1918                 if self.step== 4:
1919                         self.keytimeout.stop()
1920                         self.keytimeout.start(5000,True)
1921                         self.step = 5
1922                         self["text"].setText(_("Press Front VOL +"))
1923
1924         def checkled(self, yesno):
1925                 if yesno :
1926                         self.step=6
1927                 else:
1928                         self.step=0
1929                 self.keyCancel()
1930
1931         def keyCancel(self):
1932                 global fronttest
1933                 self.fronttimer.stop()
1934                 eSctest.getInstance().VFD_Close()
1935                 fronttest = 0
1936                 self.close()
1937
1938         def keyOk(self):
1939                 global fronttest
1940                 self.fronttimer.stop()
1941                 eSctest.getInstance().VFD_Close()
1942                 if self.step == 6:
1943                         fronttest = 1
1944                 self.close()
1945
1946         def FrontAnimate(self):
1947                 if (self.frontturnonoff==0):
1948                         eSctest.getInstance().turnon_VFD()
1949                         self.frontturnonoff = 1
1950                 else:
1951                         self.frontturnonoff = 0
1952                         eSctest.getInstance().turnoff_VFD()
1953                 self.fronttimer.start(1000,True)
1954
1955
1956
1957
1958 rstest = 0
1959
1960 import select
1961
1962 class RS232Test(Screen):
1963         skin = """
1964                 <screen position="300,240" size="160,100" title="RS232 Test" >
1965                         <widget name="text" position="10,10" size="140,80" font="Regular;22" />
1966                 </screen>"""
1967         step=1
1968         def __init__(self, session):
1969                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions"],
1970                 {
1971                         "cancel": self.keyCancel,
1972                 }, -2)
1973
1974                 Screen.__init__(self, session)
1975                 self["text"]=Label(("Press \"Enter\" Key"))
1976                 self.timer = eTimer()
1977                 self.timer.callback.append(self.checkrs232)
1978                 self.timer.start(100, True)
1979
1980         def checkrs232(self):
1981                 global rstest
1982                 try:
1983                         rs=open('/dev/ttyS0','r')
1984                         rd = [rs]
1985                         r,w,e = select.select(rd, [], [], 10)
1986                         if r:
1987                                 input = rs.read(1)
1988                                 if input == "\n":
1989 #                               if input == "m":
1990                                         rstest = 1
1991                                 else:
1992                                         rstest = 0
1993                         else:
1994                                 rstest = 0
1995                 except:
1996                         print 'error'
1997                         rstest = 0
1998                 self.close()
1999
2000         def keyCancel(self):
2001                 self.close()
2002
2003 Agingresult = 0
2004
2005 class AgingTest(Screen):
2006         skin = """
2007                 <screen position="200,240" size="250,100" title="Aging Test" >
2008                         <widget name="text1" position="10,10" size="230,40" font="Regular;22" />
2009                         <widget name="text2" position="10,50" size="230,40" font="Regular;22" />
2010                 </screen>"""
2011         step=1
2012         def __init__(self, session):
2013                 self["actions"] = ActionMap(["WizardActions","GlobalActions"],
2014                 {
2015                         "agingend": self.keyEnd,
2016                         "agingfinish": self.keyFinish,
2017                         "volumeUp": self.nothing,
2018                         "volumeDown": self.nothing,
2019                         "volumeMute": self.nothing,
2020                 }, -2)
2021
2022                 Screen.__init__(self, session)
2023                 self["text1"]=Label(("Exit - Press Pause Key"))
2024                 self["text2"]=Label(("Reset - Press Stop Key"))
2025 #               self.servicelist = ServiceList()
2026 #               self.oldref = session.nav.getCurrentlyPlayingServiceReference()
2027 #               print "oldref",self.oldref
2028 #               session.nav.stopService() # try to disable foreground service
2029 #               self.chstart()
2030                 self.tunerlock = 0
2031                 self.tuningtimer = eTimer()
2032                 self.tuningtimer.callback.append(self.updateStatus)
2033 #               self.tuningtimer.start(200,True)
2034
2035
2036         def updateStatus(self):
2037                 result = eSctest.getInstance().getFrontendstatus(0)
2038                 hv = "Ver"
2039
2040                 print "eSctest.getInstance().getFrontendstatus - %d"%result
2041                 if result == 0:
2042                         self.tunerlock = 0
2043                         self.session.nav.stopService()
2044                         self.session.open( MessageBox, _("Tune 1 Ver Locking Fail..."), MessageBox.TYPE_ERROR)
2045                 elif result==1 :
2046                         self.tunerlock = 1
2047                 else:
2048                         self.tunerlock = 0
2049                         self.session.nav.stopService()
2050                         self.session.open( MessageBox, _("Tune 1 Ver Error %d..."%result), MessageBox.TYPE_ERROR)
2051
2052
2053         def nothing(self):
2054                 print "nothing"
2055
2056         def chstart(self):
2057                 if self.oldref is None:
2058                         eref = eServiceReference("1:0:19:1324:3EF:1:C00000:0:0:0")
2059                         serviceHandler = eServiceCenter.getInstance()
2060                         servicelist = serviceHandler.list(eref)
2061                         if not servicelist is None:
2062                                 ref = servicelist.getNext()
2063                         else:
2064                                 ref = self.getCurrentSelection()
2065                                 print "servicelist none"
2066                 else:
2067                         ref = self.oldref
2068                 self.session.nav.stopService() # try to disable foreground service
2069                 ref.setData(0,0x19)
2070                 ref.setData(1,0x83)
2071                 ref.setData(2,0x6)
2072                 ref.setData(3,0x85)
2073                 ref.setData(4,0x640000)
2074                 self.session.nav.playService(ref)
2075
2076         def keyEnd(self):
2077                 global Agingresult
2078                 Agingresult = 0
2079                 self.session.nav.stopService() # try to disable foreground service
2080                 self.close()
2081
2082         def keyFinish(self):
2083                 global Agingresult
2084                 Agingresult = 1
2085                 self.session.nav.stopService() # try to disable foreground service
2086                 self.close()
2087
2088 session = None
2089
2090
2091 def cleanup():
2092         global Session
2093         Session = None
2094         global Servicelist
2095         Servicelist = None
2096
2097 def main(session, servicelist, **kwargs):
2098         global Session
2099         Session = session
2100         global Servicelist
2101         Servicelist = servicelist
2102         bouquets = Servicelist.getBouquetList()
2103         global bouquetSel
2104         bouquetSel = Session.openWithCallback(cleanup, FactoryTest)
2105
2106 #def Plugins(**kwargs):
2107 #       return PluginDescriptor(name=_("Factory Test"), description="Test App for Factory", where = PluginDescriptor.WHERE_EXTENSIONSMENU, fnc=main)