71ae50b673377edc1bccb31632232d1b58ac376f
[enigma2.git] / lib / python / Plugins / SystemPlugins / DiseqcTester / plugin.py
1 from Screens.Satconfig import NimSelection
2 from Screens.Screen import Screen
3 from Screens.TextBox import TextBox
4 from Screens.MessageBox import MessageBox
5
6 from Plugins.Plugin import PluginDescriptor
7
8 from Components.ActionMap import ActionMap, NumberActionMap
9 from Components.NimManager import nimmanager
10 from Components.ResourceManager import resourcemanager
11 from Components.Sources.FrontendStatus import FrontendStatus
12 from Components.TuneTest import TuneTest
13 from Components.Sources.List import List
14 from Components.Sources.Progress import Progress
15 from Components.Sources.StaticText import StaticText
16 from Components.ConfigList import ConfigListScreen
17 from Components.config import getConfigListEntry, ConfigSelection, ConfigYesNo
18 from Components.Harddisk import harddiskmanager
19
20 import random
21
22 # always use:
23 # setResultType(type)
24 # setResultParameter(parameter)
25 # getTextualResult()
26 class ResultParser:
27         def __init__(self):
28                 pass
29         
30         TYPE_BYORBPOS = 0
31         TYPE_BYINDEX = 1
32         TYPE_ALL = 2
33         def setResultType(self, type):
34                 self.type = type
35                 
36         def setResultParameter(self, parameter):
37                 if self.type == self.TYPE_BYORBPOS:
38                         self.orbpos = parameter
39                 elif self.type == self.TYPE_BYINDEX:
40                         self.index = parameter
41                         
42         def getTextualResultForIndex(self, index, logfulltransponders = False):
43                 text = ""
44                 text += "%s:\n" % self.getTextualIndexRepresentation(index)
45                 
46                 failed, successful = self.results[index]["failed"], self.results[index]["successful"]
47                 countfailed = len(failed)
48                 countsuccessful = len(successful)
49                 countall = countfailed + countsuccessful
50                 percentfailed = round(countfailed / float(countall + 0.0001) * 100)
51                 percentsuccessful = round(countsuccessful / float(countall + 0.0001) * 100)
52                 text += "Tested %d transponders\n%d (%d %%) transponders succeeded\n%d (%d %%) transponders failed\n" % (countall, countsuccessful, percentsuccessful, countfailed, percentfailed)
53                 reasons = {}
54                 completelist = []
55                 if countfailed > 0:
56                         for transponder in failed:
57                                 completelist.append({"transponder": transponder[0], "fedata": transponder[-1]})
58                                 reasons[transponder[2]] = reasons.get(transponder[2], [])
59                                 reasons[transponder[2]].append(transponder)
60                                 if transponder[2] == "pids_failed":
61                                         print transponder[2], "-", transponder[3]
62                                 
63                         text += "The %d unsuccessful tuning attempts failed for the following reasons:\n" % countfailed
64                         
65                         for reason in reasons.keys():
66                                 text += "%s: %d transponders failed\n" % (reason, len(reasons[reason]))
67                         
68                         for reason in reasons.keys():
69                                 text += "\n"
70                                 text += "%s previous planes:\n" % reason
71                                 for transponder in reasons[reason]:
72                                         if transponder[1] is not None:
73                                                 text += self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[1]))
74                                         else:
75                                                 text += "No transponder tuned"
76                                         text += " ==> " + self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[0]))
77                                         text += "\n"
78                                         if logfulltransponders:
79                                                 text += str(transponder[1])
80                                                 text += " ==> "
81                                                 text += str(transponder[0])
82                                                 text += "\n"
83                                         if reason == "pids_failed":
84                                                 text += "(tsid, onid): "
85                                                 text += str(transponder[3]['real'])
86                                                 text += "(read from sat) != "
87                                                 text += str(transponder[3]['expected'])
88                                                 text += "(read from file)"
89                                                 text += "\n"
90                                         text += "\n"
91                 if countsuccessful > 0:
92                         text += "\n"
93                         text += "Successfully tuned transponders' previous planes:\n" 
94                         for transponder in successful:
95                                 completelist.append({"transponder": transponder[0], "fedata": transponder[-1]})
96                                 if transponder[1] is not None:
97                                         text += self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[1]))
98                                 else:
99                                         text += "No transponder tuned"
100                                 text += " ==> " + self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[0]))
101                                 text += "\n"
102                 
103                 text += "------------------------------------------------\n"
104                 text += "complete transponderlist:\n"
105                 for entry in completelist:
106                         text += str(entry["transponder"]) + " -- " + str(entry["fedata"]) + "\n"
107                 return text
108
109         def getTextualResult(self):
110                 text = ""
111                 if self.type == self.TYPE_BYINDEX:
112                         text += self.getTextualResultForIndex(self.index)
113                 elif self.type == self.TYPE_BYORBPOS:
114                         for index in self.results.keys():
115                                 if index[2] == self.orbpos:
116                                         text += self.getTextualResultForIndex(index)
117                                         text += "\n-----------------------------------------------------\n"
118                 elif self.type == self.TYPE_ALL:
119                         orderedResults = {}
120                         for index in self.results.keys():
121                                 orbpos = index[2]
122                                 orderedResults[orbpos] = orderedResults.get(orbpos, [])
123                                 orderedResults[orbpos].append(index)
124                         ordered_orbpos = orderedResults.keys()
125                         ordered_orbpos.sort()
126                         for orbpos in ordered_orbpos:
127                                 text += "\n*****************************************\n"
128                                 text += "Orbital position %s:" % str(orbpos)
129                                 text += "\n*****************************************\n"
130                                 for index in orderedResults[orbpos]:
131                                         text += self.getTextualResultForIndex(index, logfulltransponders = True)
132                                         text += "\n-----------------------------------------------------\n"
133                         
134                                 
135                 return text
136
137 class DiseqcTester(Screen, TuneTest, ResultParser):
138         skin = """
139                 <screen position="90,100" size="520,400" title="DiSEqC Tester" >
140                 <!--ePixmap pixmap="skin_default/icons/dish_scan.png" position="5,25" zPosition="0" size="119,110" transparent="1" alphatest="on" />
141                 <widget source="Frontend" render="Label" position="190,10" zPosition="2" size="260,20" font="Regular;19" halign="center" valign="center" transparent="1">
142                         <convert type="FrontendInfo">SNRdB</convert>
143                 </widget>
144                 <eLabel name="snr" text="SNR:" position="120,35" size="60,22" font="Regular;21" halign="right" transparent="1" />
145                 <widget source="Frontend" render="Progress" position="190,35" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc">
146                         <convert type="FrontendInfo">SNR</convert>
147                 </widget>
148                 <widget source="Frontend" render="Label" position="460,35" size="60,22" font="Regular;21">
149                         <convert type="FrontendInfo">SNR</convert>
150                 </widget>
151                 <eLabel name="agc" text="AGC:" position="120,60" size="60,22" font="Regular;21" halign="right" transparent="1" />
152                 <widget source="Frontend" render="Progress" position="190,60" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc">
153                         <convert type="FrontendInfo">AGC</convert>
154                 </widget>
155                 <widget source="Frontend" render="Label" position="460,60" size="60,22" font="Regular;21">
156                         <convert type="FrontendInfo">AGC</convert>
157                 </widget>
158                 <eLabel name="ber" text="BER:" position="120,85" size="60,22" font="Regular;21" halign="right" transparent="1" />
159                 <widget source="Frontend" render="Progress" position="190,85" size="260,20" pixmap="skin_default/bar_ber.png" borderWidth="2" borderColor="#cccccc">
160                         <convert type="FrontendInfo">BER</convert>
161                 </widget>
162                 <widget source="Frontend" render="Label" position="460,85" size="60,22" font="Regular;21">
163                         <convert type="FrontendInfo">BER</convert>
164                 </widget>
165                 <eLabel name="lock" text="Lock:" position="120,115" size="60,22" font="Regular;21" halign="right" />
166                 <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_on.png" position="190,110" zPosition="1" size="38,31" alphatest="on">
167                         <convert type="FrontendInfo">LOCK</convert>
168                         <convert type="ConditionalShowHide" />
169                 </widget>
170                 <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_off.png" position="190,110" zPosition="1" size="38,31" alphatest="on">
171                         <convert type="FrontendInfo">LOCK</convert>
172                         <convert type="ConditionalShowHide">Invert</convert>
173                 </widget-->
174                 <widget source="progress_list" render="Listbox" position="0,0" size="510,150" scrollbarMode="showOnDemand">
175                         <convert type="TemplatedMultiContent">
176                                 {"template": [
177                                                 MultiContentEntryText(pos = (10, 0), size = (330, 25), flags = RT_HALIGN_LEFT, text = 1), # index 1 is the index name,
178                                                 MultiContentEntryText(pos = (330, 0), size = (150, 25), flags = RT_HALIGN_RIGHT, text = 2) # index 2 is the status,
179                                         ],
180                                  "fonts": [gFont("Regular", 20)],
181                                  "itemHeight": 25
182                                 }
183                         </convert>
184                 </widget>
185                 <eLabel name="overall_progress" text="Overall progress:" position="20,162" size="480,22" font="Regular;21" halign="center" transparent="1" />
186                 <widget source="overall_progress" render="Progress" position="20,192" size="480,20" borderWidth="2" backgroundColor="#254f7497" />
187                 <eLabel name="overall_progress" text="Progress:" position="20,222" size="480,22" font="Regular;21" halign="center" transparent="1" />
188                 <widget source="sub_progress" render="Progress" position="20,252" size="480,20" borderWidth="2" backgroundColor="#254f7497" />
189                 
190                 <eLabel name="" text="Failed:" position="20,282" size="140,22" font="Regular;21" halign="left" transparent="1" />
191                 <widget source="failed_counter" render="Label" position="160,282" size="100,20" font="Regular;21" />
192                 
193                 <eLabel name="" text="Succeeded:" position="20,312" size="140,22" font="Regular;21" halign="left" transparent="1" />
194                 <widget source="succeeded_counter" render="Label" position="160,312" size="100,20" font="Regular;21" />
195                 
196                 <eLabel name="" text="With errors:" position="20,342" size="140,22" font="Regular;21" halign="left" transparent="1" />
197                 <widget source="witherrors_counter" render="Label" position="160,342" size="100,20" font="Regular;21" />
198                 
199                 <eLabel name="" text="Not tested:" position="20,372" size="140,22" font="Regular;21" halign="left" transparent="1" />
200                 <widget source="untestable_counter" render="Label" position="160,372" size="100,20" font="Regular;21" />
201                 
202                 <widget source="CmdText" render="Label" position="300,282" size="180,200" font="Regular;21" />
203                 </screen>"""
204                 
205         TEST_TYPE_QUICK = 0
206         TEST_TYPE_RANDOM = 1
207         TEST_TYPE_COMPLETE = 2
208         def __init__(self, session, feid, test_type = TEST_TYPE_QUICK, loopsfailed = 3, loopssuccessful = 1, log = False):
209                 Screen.__init__(self, session)
210                 self.feid = feid
211                 self.test_type = test_type
212                 self.loopsfailed = loopsfailed
213                 self.loopssuccessful = loopssuccessful
214                 self.log = log
215                 
216                 self["actions"] = NumberActionMap(["SetupActions"],
217                 {
218                         "ok": self.select,
219                         "cancel": self.keyCancel,
220                 }, -2)
221                 
222                 TuneTest.__init__(self, feid, stopOnSuccess = self.loopssuccessful, stopOnError = self.loopsfailed)
223                 #self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
224                 self["overall_progress"] = Progress()
225                 self["sub_progress"] = Progress()
226                 
227                 self["failed_counter"] = StaticText("0")
228                 self["succeeded_counter"] = StaticText("0")
229                 self["witherrors_counter"] = StaticText("0")
230                 self["untestable_counter"] = StaticText("0")
231                 
232                 self.list = []
233                 self["progress_list"] = List(self.list)
234                 self["progress_list"].onSelectionChanged.append(self.selectionChanged)
235                 
236                 self["CmdText"] = StaticText(_("Please wait while scanning is in progress..."))
237                                 
238                 self.indexlist = {}
239                 self.readTransponderList()
240                 
241                 self.running = False
242                 
243                 self.results = {}
244                 self.resultsstatus = {}
245                 
246                 self.onLayoutFinish.append(self.go)
247                 
248         def getProgressListComponent(self, index, status):
249                 return (index, self.getTextualIndexRepresentation(index), status)
250         
251         def clearProgressList(self):
252                 self.list = []
253                 self["progress_list"].list = self.list
254         
255         def addProgressListItem(self, index):
256                 if index in self.indexlist:
257                         for entry in self.list:
258                                 if entry[0] == index:
259                                         self.changeProgressListStatus(index, "working")
260                                         return
261                         self.list.append(self.getProgressListComponent(index, _("working")))
262                         self["progress_list"].list = self.list
263                         self["progress_list"].setIndex(len(self.list) - 1)
264
265         def changeProgressListStatus(self, index, status):
266                 self.newlist = []
267                 count = 0
268                 indexpos = 0
269                 for entry in self.list:
270                         if entry[0] == index:
271                                 self.newlist.append(self.getProgressListComponent(index, status))
272                                 indexpos = count
273                         else:
274                                 self.newlist.append(entry)
275                         count += 1
276                 self.list = self.newlist
277                 self["progress_list"].list = self.list
278                 self["progress_list"].setIndex(indexpos)
279
280         def readTransponderList(self):
281                 for sat in nimmanager.getSatListForNim(self.feid):
282                         for transponder in nimmanager.getTransponders(sat[0]):
283                                 #print transponder
284                                 mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11])
285                                 self.analyseTransponder(mytransponder)
286
287         def getIndexForTransponder(self, transponder):
288                 
289                 if transponder[0] < 11700:
290                         band = 1 # low
291                 else:
292                         band = 0 # high
293                 
294                 polarisation = transponder[2]
295                 
296                 sat = transponder[5]
297                 
298                 index = (band, polarisation, sat)
299                 return index
300
301         # sort the transponder into self.transponderlist
302         def analyseTransponder(self, transponder):
303                 index = self.getIndexForTransponder(transponder)
304                 if index not in self.indexlist:
305                         self.indexlist[index] = []
306                 self.indexlist[index].append(transponder)
307                 #print "self.indexlist:", self.indexlist
308         
309         # returns a string for the user representing a human readable output for index 
310         def getTextualIndexRepresentation(self, index):
311                 print "getTextualIndexRepresentation:", index
312                 text = ""
313                 
314                 text += nimmanager.getSatDescription(index[2]) + ", "
315                 
316                 if index[0] == 1:
317                         text += "Low Band, "
318                 else:
319                         text += "High Band, "
320                         
321                 if index[1] == 0:
322                         text += "H"
323                 else:
324                         text += "V"
325                 return text
326         
327         def fillTransponderList(self):
328                 self.clearTransponder()
329                 print "----------- fillTransponderList"
330                 print "index:", self.currentlyTestedIndex
331                 keys = self.indexlist.keys()
332                 if self.getContinueScanning():
333                         print "index:", self.getTextualIndexRepresentation(self.currentlyTestedIndex)
334                         for transponder in self.indexlist[self.currentlyTestedIndex]:
335                                 self.addTransponder(transponder)
336                         print "transponderList:", self.transponderlist
337                         return True
338                 else:
339                         return False
340                 
341         def progressCallback(self, progress):
342                 if progress[0] != self["sub_progress"].getRange():
343                         self["sub_progress"].setRange(progress[0])
344                 self["sub_progress"].setValue(progress[1])
345
346         # logic for scanning order of transponders
347         # on go getFirstIndex is called
348         def getFirstIndex(self):
349                 # TODO use other function to scan more randomly
350                 if self.test_type == self.TEST_TYPE_QUICK:
351                         self.myindex = 0
352                         keys = self.indexlist.keys()
353                         keys.sort(key = lambda a: a[2]) # sort by orbpos
354                         self["overall_progress"].setRange(len(keys))
355                         self["overall_progress"].setValue(self.myindex)
356                         return keys[0]
357                 elif self.test_type == self.TEST_TYPE_RANDOM:
358                         self.randomkeys = self.indexlist.keys()
359                         random.shuffle(self.randomkeys)
360                         self.myindex = 0
361                         self["overall_progress"].setRange(len(self.randomkeys))
362                         self["overall_progress"].setValue(self.myindex)
363                         return self.randomkeys[0]
364                 elif self.test_type == self.TEST_TYPE_COMPLETE:
365                         keys = self.indexlist.keys()
366                         print "keys:", keys
367                         successorindex = {}
368                         for index in keys:
369                                 successorindex[index] = []
370                                 for otherindex in keys:
371                                         if otherindex != index:
372                                                 successorindex[index].append(otherindex)
373                                 random.shuffle(successorindex[index])
374                         self.keylist = []
375                         stop = False
376                         currindex = None
377                         while not stop:
378                                 if currindex is None or len(successorindex[currindex]) == 0:
379                                         oldindex = currindex
380                                         for index in successorindex.keys():
381                                                 if len(successorindex[index]) > 0:
382                                                         currindex = index
383                                                         self.keylist.append(currindex)
384                                                         break
385                                         if currindex == oldindex:
386                                                 stop = True
387                                 else:
388                                         currindex = successorindex[currindex].pop()
389                                         self.keylist.append(currindex)
390                         print "self.keylist:", self.keylist
391                         self.myindex = 0
392                         self["overall_progress"].setRange(len(self.keylist))
393                         self["overall_progress"].setValue(self.myindex)
394                         return self.keylist[0]
395
396                                         
397         # after each index is finished, getNextIndex is called to get the next index to scan 
398         def getNextIndex(self):
399                 # TODO use other function to scan more randomly
400                 if self.test_type == self.TEST_TYPE_QUICK:
401                         self.myindex += 1
402                         keys = self.indexlist.keys()
403                         keys.sort(key = lambda a: a[2]) # sort by orbpos
404                         
405                         self["overall_progress"].setValue(self.myindex)
406                         if self.myindex < len(keys):
407                                 return keys[self.myindex]
408                         else:
409                                 return None
410                 elif self.test_type == self.TEST_TYPE_RANDOM:
411                         self.myindex += 1
412                         keys = self.randomkeys
413                         
414                         self["overall_progress"].setValue(self.myindex)
415                         if self.myindex < len(keys):
416                                 return keys[self.myindex]
417                         else:
418                                 return None
419                 elif self.test_type == self.TEST_TYPE_COMPLETE:
420                         self.myindex += 1
421                         keys = self.keylist
422                         
423                         self["overall_progress"].setValue(self.myindex)
424                         if self.myindex < len(keys):
425                                 return keys[self.myindex]
426                         else:
427                                 return None
428                                 
429         # after each index is finished and the next index is returned by getNextIndex
430         # the algorithm checks, if we should continue scanning
431         def getContinueScanning(self):
432                 if self.test_type == self.TEST_TYPE_QUICK or self.test_type == self.TEST_TYPE_RANDOM:
433                         return (self.myindex < len(self.indexlist.keys()))
434                 elif self.test_type == self.TEST_TYPE_COMPLETE:
435                         return (self.myindex < len(self.keylist))
436                 
437         def addResult(self, index, status, failedTune, successfullyTune):
438                 self.results[index] = self.results.get(index, {"failed": [], "successful": [], "status": None, "internalstatus": None})
439                 self.resultsstatus[status] = self.resultsstatus.get(status, [])
440
441                 oldstatus = self.results[index]["internalstatus"]
442                 if oldstatus is None:
443                         self.results[index]["status"] = status
444                 elif oldstatus == "successful":
445                         if status == "failed":
446                                 self.results[index]["status"] = "with_errors"
447                         elif status == "successful":
448                                 self.results[index]["status"] = oldstatus
449                         elif status == "with_errors":
450                                 self.results[index]["status"] = "with_errors"
451                         elif status == "not_tested":
452                                 self.results[index]["status"] = oldstatus
453                 elif oldstatus == "failed":
454                         if status == "failed":
455                                 self.results[index]["status"] = oldstatus
456                         elif status == "successful":
457                                 self.results[index]["status"] = "with_errors"
458                         elif status == "with_errors":
459                                 self.results[index]["status"] = "with_errors"
460                         elif status == "not_tested":
461                                 self.results[index]["status"] = oldstatus
462                 elif oldstatus == "with_errors":
463                         if status == "failed":
464                                 self.results[index]["status"] = oldstatus
465                         elif status == "successful":
466                                 self.results[index]["status"] = oldstatus
467                         elif status == "with_errors":
468                                 self.results[index]["status"] = oldstatus
469                         elif status == "not_tested":
470                                 self.results[index]["status"] = oldstatus
471                 elif oldstatus == "not_tested":
472                         self.results[index]["status"] = status
473                         
474                 if self.results[index]["status"] != "working":
475                         self.results[index]["internalstatus"] = self.results[index]["status"] 
476                 self.results[index]["failed"] = failedTune + self.results[index]["failed"]
477                 self.results[index]["successful"] = successfullyTune + self.results[index]["successful"]
478                 
479                 self.resultsstatus[status].append(index)
480         
481         def finishedChecking(self):
482                 print "finishedChecking"
483                 TuneTest.finishedChecking(self)
484
485                 if not self.results.has_key(self.currentlyTestedIndex):
486                         self.results[self.currentlyTestedIndex] = {"failed": [], "successful": [], "status": None, "internalstatus": None}
487                 
488                 if len(self.failedTune) > 0 and len(self.successfullyTune) > 0:
489                         self.changeProgressListStatus(self.currentlyTestedIndex, "with errors")
490                         self["witherrors_counter"].setText(str(int(self["witherrors_counter"].getText()) + 1))
491                         self.addResult(self.currentlyTestedIndex, "with_errors", self.failedTune, self.successfullyTune)
492                 elif len(self.failedTune) == 0 and len(self.successfullyTune) == 0:
493                         self.changeProgressListStatus(self.currentlyTestedIndex, "not tested")
494                         self["untestable_counter"].setText(str(int(self["untestable_counter"].getText()) + 1))
495                         self.addResult(self.currentlyTestedIndex, "untestable", self.failedTune, self.successfullyTune)
496                 elif len(self.failedTune) > 0:
497                         self.changeProgressListStatus(self.currentlyTestedIndex, "failed")
498                         #self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + len(self.failedTune)))
499                         self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + 1))
500                         self.addResult(self.currentlyTestedIndex, "failed", self.failedTune, self.successfullyTune)
501                 else:
502                         self.changeProgressListStatus(self.currentlyTestedIndex, "successful")
503                         #self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + len(self.successfullyTune)))
504                         self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + 1))
505                         self.addResult(self.currentlyTestedIndex, "successful", self.failedTune, self.successfullyTune)
506                         
507                         
508                 #self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + len(self.failedTune)))
509                 #self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + len(self.successfullyTune)))
510                 #if len(self.failedTune) == 0 and len(self.successfullyTune) == 0:
511                         #self["untestable_counter"].setText(str(int(self["untestable_counter"].getText()) + 1))
512                         
513                 self.currentlyTestedIndex = self.getNextIndex()
514                 self.addProgressListItem(self.currentlyTestedIndex)
515                 
516                 if self.fillTransponderList():
517                         self.run(checkPIDs = True)
518                 else:
519                         self.running = False
520                         self["progress_list"].setIndex(0)
521                         print "results:", self.results
522                         print "resultsstatus:", self.resultsstatus
523                         if self.log:
524                                 file = open("/media/hdd/diseqctester.log", "w")
525                                 self.setResultType(ResultParser.TYPE_ALL)
526                                 file.write(self.getTextualResult())
527                                 file.close()
528                                 self.session.open(MessageBox, text=_("The results have been written to %s.") % "/media/hdd/diseqctester.log", type = MessageBox.TYPE_INFO)
529
530         def go(self):
531                 self.running = True
532                 self["failed_counter"].setText("0")
533                 self["succeeded_counter"].setText("0")
534                 self["untestable_counter"].setText("0")
535                 self.currentlyTestedIndex = self.getFirstIndex()
536                 
537                 self.clearProgressList()
538                 self.addProgressListItem(self.currentlyTestedIndex)
539                 
540                 if self.fillTransponderList():
541                         self.run(True)
542
543         def keyCancel(self):
544                 self.close()
545                 
546         def select(self):
547                 print "selectedIndex:", self["progress_list"].getCurrent()[0]
548                 if not self.running:
549                         index = self["progress_list"].getCurrent()[0]
550                         #self.setResultType(ResultParser.TYPE_BYORBPOS)
551                         #self.setResultParameter(index[2])
552                         self.setResultType(ResultParser.TYPE_BYINDEX)
553                         self.setResultParameter(index)
554                         #self.setResultType(ResultParser.TYPE_ALL)
555                         self.session.open(TextBox, self.getTextualResult())
556         
557         def selectionChanged(self):
558                 print "selection changed"
559                 if len(self.list) > 0 and not self.running:
560                         self["CmdText"].setText(_("Press OK to get further details for %s") % str(self["progress_list"].getCurrent()[1]))
561
562 class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen):
563         skin = """<screen position="80,95" size="560,412" title="DiSEqC Tester Test Settings">
564                 <widget name="config" position="10,10" size="540,402" scrollbarMode="showOnDemand" />
565         </screen>
566         """
567         def __init__(self, session, feid):
568                 Screen.__init__(self, session)
569                 self.feid = feid
570                 
571                 self.list = []
572                 ConfigListScreen.__init__(self, self.list)
573                 
574                 self["actions"] = ActionMap(["SetupActions"],
575                 {
576                         "cancel": self.keyCancel
577                 }, -2)
578                 
579                 self.createSetup()
580                 
581         def createSetup(self):
582                 self.testtype = ConfigSelection(choices={"quick": _("Quick"), "random": _("Random"), "complete": _("Complete")}, default = "quick")
583                 self.testtypeEntry = getConfigListEntry(_("Test Type"), self.testtype)
584                 self.list.append(self.testtypeEntry)
585                 
586                 self.loopsfailed = ConfigSelection(choices={"-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "3")
587                 self.loopsfailedEntry = getConfigListEntry(_("Stop testing plane after # failed transponders"), self.loopsfailed)
588                 self.list.append(self.loopsfailedEntry)
589                 
590                 self.loopssuccessful = ConfigSelection(choices={"-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "1")
591                 self.loopssuccessfulEntry = getConfigListEntry(_("Stop testing plane after # successful transponders"), self.loopssuccessful)
592                 self.list.append(self.loopssuccessfulEntry)
593                 
594                 self.log = ConfigYesNo(False)
595                 if harddiskmanager.HDDCount() > 0:
596                         self.logEntry = getConfigListEntry(_("Log results to harddisk"), self.log)
597                         self.list.append(self.logEntry)
598                                         
599                 self["config"].list = self.list
600                 self["config"].l.setList(self.list)
601                 
602         def keyOK(self):
603                 print self.testtype.getValue()
604                 testtype = DiseqcTester.TEST_TYPE_QUICK
605                 if self.testtype.getValue() == "quick":
606                         testtype = DiseqcTester.TEST_TYPE_QUICK
607                 elif self.testtype.getValue() == "random":
608                         testtype = DiseqcTester.TEST_TYPE_RANDOM
609                 elif self.testtype.getValue() == "complete":
610                         testtype = DiseqcTester.TEST_TYPE_COMPLETE
611                 self.session.open(DiseqcTester, feid = self.feid, test_type = testtype, loopsfailed = int(self.loopsfailed.value), loopssuccessful = int(self.loopssuccessful.value), log = self.log.value)
612         
613         def keyCancel(self):
614                 self.close()
615
616 class DiseqcTesterNimSelection(NimSelection):
617         skin = """
618                 <screen position="160,123" size="400,330" title="Choose Tuner">
619                 <widget source="nimlist" render="Listbox" position="0,0" size="380,300" scrollbarMode="showOnDemand">
620                         <convert type="TemplatedMultiContent">
621                                 {"template": [
622                                                 MultiContentEntryText(pos = (10, 5), size = (360, 30), flags = RT_HALIGN_LEFT, text = 1), # index 1 is the nim name,
623                                                 MultiContentEntryText(pos = (50, 30), size = (320, 30), font = 1, flags = RT_HALIGN_LEFT, text = 2), # index 2 is a description of the nim settings,
624                                         ],
625                                  "fonts": [gFont("Regular", 20), gFont("Regular", 15)],
626                                  "itemHeight": 70
627                                 }
628                         </convert>
629                 </widget>
630         </screen>"""
631                 
632         def __init__(self, session, args = None):
633                 NimSelection.__init__(self, session)
634
635         def setResultClass(self):
636                 #self.resultclass = DiseqcTester
637                 self.resultclass = DiseqcTesterTestTypeSelection
638                 
639         def showNim(self, nim):
640                 nimConfig = nimmanager.getNimConfig(nim.slot)
641                 if nim.isCompatible("DVB-S"):
642                         if nimConfig.configMode.value in ("loopthrough", "equal", "satposdepends", "nothing"):
643                                 return False
644                         if nimConfig.configMode.value == "simple":
645                                 if nimConfig.diseqcMode.value == "positioner":
646                                         return True
647                         return True
648                 return False
649
650 def DiseqcTesterMain(session, **kwargs):
651         session.open(DiseqcTesterNimSelection)
652         
653 def autostart(reason, **kwargs):
654         resourcemanager.addResource("DiseqcTester", DiseqcTesterMain)
655
656 def Plugins(**kwargs):
657         return [ PluginDescriptor(name="DiSEqC Tester", description=_("Test DiSEqC settings"), where = PluginDescriptor.WHERE_PLUGINMENU, fnc=DiseqcTesterMain),
658                         PluginDescriptor(where = PluginDescriptor.WHERE_AUTOSTART, fnc = autostart)]