add color buttons to TempFanControl
[enigma2.git] / RecordTimer.py
1 from enigma import eEPGCache, getBestPlayableServiceReference, \
2         eServiceReference, iRecordableService, quitMainloop
3
4 from Components.config import config
5 from Components.TimerSanityCheck import TimerSanityCheck
6
7 from Screens.MessageBox import MessageBox
8 import Screens.Standby
9 from Tools import Directories, Notifications, ASCIItranslit
10 from Tools.XMLTools import stringToXML
11
12 import timer
13 import xml.etree.cElementTree
14 import NavigationInstance
15 from ServiceReference import ServiceReference
16
17 from time import localtime, strftime, ctime, time
18 from bisect import insort
19
20 # ok, for descriptions etc we have:
21 # service reference  (to get the service name)
22 # name               (title)
23 # description        (description)
24 # event data         (ONLY for time adjustments etc.)
25
26
27 # parses an event, and gives out a (begin, end, name, duration, eit)-tuple.
28 # begin and end will be corrected
29 def parseEvent(ev, description = True):
30         if description:
31                 name = ev.getEventName()
32                 description = ev.getShortDescription()
33         else:
34                 name = ""
35                 description = ""
36         begin = ev.getBeginTime()
37         end = begin + ev.getDuration()
38         eit = ev.getEventId()
39         begin -= config.recording.margin_before.value * 60
40         end += config.recording.margin_after.value * 60
41         return (begin, end, name, description, eit)
42
43 class AFTEREVENT:
44         NONE = 0
45         STANDBY = 1
46         DEEPSTANDBY = 2
47         AUTO = 3
48
49 # please do not translate log messages
50 class RecordTimerEntry(timer.TimerEntry, object):
51 ######### the following static methods and members are only in use when the box is in (soft) standby
52         receiveRecordEvents = False
53
54         @staticmethod
55         def shutdown():
56                 quitMainloop(1)
57
58         @staticmethod
59         def staticGotRecordEvent(recservice, event):
60                 if event == iRecordableService.evEnd:
61                         print "RecordTimer.staticGotRecordEvent(iRecordableService.evEnd)"
62                         recordings = NavigationInstance.instance.getRecordings()
63                         if not recordings: # no more recordings exist
64                                 rec_time = NavigationInstance.instance.RecordTimer.getNextRecordingTime()
65                                 if rec_time > 0 and (rec_time - time()) < 360:
66                                         print "another recording starts in", rec_time - time(), "seconds... do not shutdown yet"
67                                 else:
68                                         print "no starting records in the next 360 seconds... immediate shutdown"
69                                         RecordTimerEntry.shutdown() # immediate shutdown
70                 elif event == iRecordableService.evStart:
71                         print "RecordTimer.staticGotRecordEvent(iRecordableService.evStart)"
72
73         @staticmethod
74         def stopTryQuitMainloop():
75                 print "RecordTimer.stopTryQuitMainloop"
76                 NavigationInstance.instance.record_event.remove(RecordTimerEntry.staticGotRecordEvent)
77                 RecordTimerEntry.receiveRecordEvents = False
78
79         @staticmethod
80         def TryQuitMainloop(default_yes = True):
81                 if not RecordTimerEntry.receiveRecordEvents:
82                         print "RecordTimer.TryQuitMainloop"
83                         NavigationInstance.instance.record_event.append(RecordTimerEntry.staticGotRecordEvent)
84                         RecordTimerEntry.receiveRecordEvents = True
85                         # send fake event.. to check if another recordings are running or
86                         # other timers start in a few seconds
87                         RecordTimerEntry.staticGotRecordEvent(None, iRecordableService.evEnd)
88                         # send normal notification for the case the user leave the standby now..
89                         Notifications.AddNotification(Screens.Standby.TryQuitMainloop, 1, onSessionOpenCallback=RecordTimerEntry.stopTryQuitMainloop, default_yes = default_yes)
90 #################################################################
91
92         def __init__(self, serviceref, begin, end, name, description, eit, disabled = False, justplay = False, afterEvent = AFTEREVENT.AUTO, checkOldTimers = False, dirname = None, tags = None):
93                 timer.TimerEntry.__init__(self, int(begin), int(end))
94
95                 if checkOldTimers == True:
96                         if self.begin < time() - 1209600:
97                                 self.begin = int(time())
98                 
99                 if self.end < self.begin:
100                         self.end = self.begin
101                 
102                 assert isinstance(serviceref, ServiceReference)
103                 
104                 self.service_ref = serviceref
105                 self.eit = eit
106                 self.dontSave = False
107                 self.name = name
108                 self.description = description
109                 self.disabled = disabled
110                 self.timer = None
111                 self.__record_service = None
112                 self.start_prepare = 0
113                 self.justplay = justplay
114                 self.afterEvent = afterEvent
115                 self.dirname = dirname
116                 self.dirnameHadToFallback = False
117                 self.autoincrease = False
118                 self.autoincreasetime = 3600 * 24 # 1 day
119                 self.tags = tags or []
120
121                 self.log_entries = []
122                 self.resetState()
123         
124         def log(self, code, msg):
125                 self.log_entries.append((int(time()), code, msg))
126                 print "[TIMER]", msg
127
128         def calculateFilename(self):
129                 service_name = self.service_ref.getServiceName()
130                 begin_date = strftime("%Y%m%d %H%M", localtime(self.begin))
131                 
132                 print "begin_date: ", begin_date
133                 print "service_name: ", service_name
134                 print "name:", self.name
135                 print "description: ", self.description
136                 
137                 filename = begin_date + " - " + service_name
138                 if self.name:
139                         filename += " - " + self.name
140
141                 if config.recording.ascii_filenames.value:
142                         filename = ASCIItranslit.legacyEncode(filename)
143
144                 if self.dirname and not Directories.fileExists(self.dirname, 'w'):
145                         self.dirnameHadToFallback = True
146                         self.Filename = Directories.getRecordingFilename(filename, None)
147                 else:
148                         self.Filename = Directories.getRecordingFilename(filename, self.dirname)
149                 self.log(0, "Filename calculated as: '%s'" % self.Filename)
150                 #begin_date + " - " + service_name + description)
151
152         def tryPrepare(self):
153                 if self.justplay:
154                         return True
155                 else:
156                         self.calculateFilename()
157                         rec_ref = self.service_ref and self.service_ref.ref
158                         if rec_ref and rec_ref.flags & eServiceReference.isGroup:
159                                 rec_ref = getBestPlayableServiceReference(rec_ref, eServiceReference())
160                                 if not rec_ref:
161                                         self.log(1, "'get best playable service for group... record' failed")
162                                         return False
163                                 
164                         self.record_service = rec_ref and NavigationInstance.instance.recordService(rec_ref)
165
166                         if not self.record_service:
167                                 self.log(1, "'record service' failed")
168                                 return False
169
170                         if self.repeated:
171                                 epgcache = eEPGCache.getInstance()
172                                 queryTime=self.begin+(self.end-self.begin)/2
173                                 evt = epgcache.lookupEventTime(rec_ref, queryTime)
174                                 if evt:
175                                         self.description = evt.getShortDescription()
176                                         event_id = evt.getEventId()
177                                 else:
178                                         event_id = -1
179                         else:
180                                 event_id = self.eit
181                                 if event_id is None:
182                                         event_id = -1
183
184                         prep_res=self.record_service.prepare(self.Filename + ".ts", self.begin, self.end, event_id, self.name.replace("\n", ""), self.description.replace("\n", ""), ' '.join(self.tags))
185                         if prep_res:
186                                 if prep_res == -255:
187                                         self.log(4, "failed to write meta information")
188                                 else:
189                                         self.log(2, "'prepare' failed: error %d" % prep_res)
190
191                                 # we must calc nur start time before stopRecordService call because in Screens/Standby.py TryQuitMainloop tries to get
192                                 # the next start time in evEnd event handler...
193                                 self.do_backoff()
194                                 self.start_prepare = time() + self.backoff
195
196                                 NavigationInstance.instance.stopRecordService(self.record_service)
197                                 self.record_service = None
198                                 return False
199                         return True
200
201         def do_backoff(self):
202                 if self.backoff == 0:
203                         self.backoff = 5
204                 else:
205                         self.backoff *= 2
206                         if self.backoff > 100:
207                                 self.backoff = 100
208                 self.log(10, "backoff: retry in %d seconds" % self.backoff)
209
210         def activate(self):
211                 next_state = self.state + 1
212                 self.log(5, "activating state %d" % next_state)
213
214                 if next_state == self.StatePrepared:
215                         if self.tryPrepare():
216                                 self.log(6, "prepare ok, waiting for begin")
217                                 # create file to "reserve" the filename
218                                 # because another recording at the same time on another service can try to record the same event
219                                 # i.e. cable / sat.. then the second recording needs an own extension... when we create the file
220                                 # here than calculateFilename is happy
221                                 if not self.justplay:
222                                         open(self.Filename + ".ts", "w").close() 
223                                 # fine. it worked, resources are allocated.
224                                 self.next_activation = self.begin
225                                 self.backoff = 0
226                                 return True
227
228                         self.log(7, "prepare failed")
229                         if self.first_try_prepare:
230                                 self.first_try_prepare = False
231                                 cur_ref = NavigationInstance.instance.getCurrentlyPlayingServiceReference()
232                                 if cur_ref and not cur_ref.getPath():
233                                         if not config.recording.asktozap.value:
234                                                 self.log(8, "asking user to zap away")
235                                                 Notifications.AddNotificationWithCallback(self.failureCB, MessageBox, _("A timer failed to record!\nDisable TV and try again?\n"), timeout=20)
236                                         else: # zap without asking
237                                                 self.log(9, "zap without asking")
238                                                 Notifications.AddNotification(MessageBox, _("In order to record a timer, the TV was switched to the recording service!\n"), type=MessageBox.TYPE_INFO, timeout=20)
239                                                 self.failureCB(True)
240                                 elif cur_ref:
241                                         self.log(8, "currently running service is not a live service.. so stop it makes no sense")
242                                 else:
243                                         self.log(8, "currently no service running... so we dont need to stop it")
244                         return False
245                 elif next_state == self.StateRunning:
246                         # if this timer has been cancelled, just go to "end" state.
247                         if self.cancelled:
248                                 return True
249
250                         if self.justplay:
251                                 if Screens.Standby.inStandby:
252                                         self.log(11, "wakeup and zap")
253                                         #set service to zap after standby
254                                         Screens.Standby.inStandby.prev_running_service = self.service_ref.ref
255                                         #wakeup standby
256                                         Screens.Standby.inStandby.Power()
257                                 else:
258                                         self.log(11, "zapping")
259                                         NavigationInstance.instance.playService(self.service_ref.ref)
260                                 return True
261                         else:
262                                 self.log(11, "start recording")
263                                 record_res = self.record_service.start()
264                                 
265                                 if record_res:
266                                         self.log(13, "start record returned %d" % record_res)
267                                         self.do_backoff()
268                                         # retry
269                                         self.begin = time() + self.backoff
270                                         return False
271
272                                 return True
273                 elif next_state == self.StateEnded:
274                         old_end = self.end
275                         if self.setAutoincreaseEnd():
276                                 self.log(12, "autoincrase recording %d minute(s)" % int((self.end - old_end)/60))
277                                 self.state -= 1
278                                 return True
279                         self.log(12, "stop recording")
280                         if not self.justplay:
281                                 NavigationInstance.instance.stopRecordService(self.record_service)
282                                 self.record_service = None
283                         if self.afterEvent == AFTEREVENT.STANDBY:
284                                 if not Screens.Standby.inStandby: # not already in standby
285                                         Notifications.AddNotificationWithCallback(self.sendStandbyNotification, MessageBox, _("A finished record timer wants to set your\nDreambox to standby. Do that now?"), timeout = 20)
286                         elif self.afterEvent == AFTEREVENT.DEEPSTANDBY:
287                                 if not Screens.Standby.inTryQuitMainloop: # not a shutdown messagebox is open
288                                         if Screens.Standby.inStandby: # in standby
289                                                 RecordTimerEntry.TryQuitMainloop() # start shutdown handling without screen
290                                         else:
291                                                 Notifications.AddNotificationWithCallback(self.sendTryQuitMainloopNotification, MessageBox, _("A finished record timer wants to shut down\nyour Dreambox. Shutdown now?"), timeout = 20)
292                         return True
293
294         def setAutoincreaseEnd(self, entry = None):
295                 if not self.autoincrease:
296                         return False
297                 if entry is None:
298                         new_end =  int(time()) + self.autoincreasetime
299                 else:
300                         new_end = entry.begin -30
301
302                 dummyentry = RecordTimerEntry(self.service_ref, self.begin, new_end, self.name, self.description, self.eit, disabled=True, justplay = self.justplay, afterEvent = self.afterEvent, dirname = self.dirname, tags = self.tags)
303                 dummyentry.disabled = self.disabled
304                 timersanitycheck = TimerSanityCheck(NavigationInstance.instance.RecordTimer.timer_list, dummyentry)
305                 if not timersanitycheck.check():
306                         simulTimerList = timersanitycheck.getSimulTimerList()
307                         new_end = simulTimerList[1].begin
308                         del simulTimerList
309                         new_end -= 30                           # 30 Sekunden Prepare-Zeit lassen
310                 del dummyentry
311                 if new_end <= time():
312                         return False
313                 self.end = new_end
314                 return True
315         
316         
317         def sendStandbyNotification(self, answer):
318                 if answer:
319                         Notifications.AddNotification(Screens.Standby.Standby)
320
321         def sendTryQuitMainloopNotification(self, answer):
322                 if answer:
323                         Notifications.AddNotification(Screens.Standby.TryQuitMainloop, 1)
324
325         def getNextActivation(self):
326                 if self.state == self.StateEnded:
327                         return self.end
328                 
329                 next_state = self.state + 1
330                 
331                 return {self.StatePrepared: self.start_prepare, 
332                                 self.StateRunning: self.begin, 
333                                 self.StateEnded: self.end }[next_state]
334
335         def failureCB(self, answer):
336                 if answer == True:
337                         self.log(13, "ok, zapped away")
338                         #NavigationInstance.instance.stopUserServices()
339                         NavigationInstance.instance.playService(self.service_ref.ref)
340                 else:
341                         self.log(14, "user didn't want to zap away, record will probably fail")
342
343         def timeChanged(self):
344                 old_prepare = self.start_prepare
345                 self.start_prepare = self.begin - self.prepare_time
346                 self.backoff = 0
347                 
348                 if int(old_prepare) != int(self.start_prepare):
349                         self.log(15, "record time changed, start prepare is now: %s" % ctime(self.start_prepare))
350
351         def gotRecordEvent(self, record, event):
352                 # TODO: this is not working (never true), please fix. (comparing two swig wrapped ePtrs)
353                 if self.__record_service.__deref__() != record.__deref__():
354                         return
355                 self.log(16, "record event %d" % event)
356                 if event == iRecordableService.evRecordWriteError:
357                         print "WRITE ERROR on recording, disk full?"
358                         # show notification. the 'id' will make sure that it will be
359                         # displayed only once, even if more timers are failing at the
360                         # same time. (which is very likely in case of disk fullness)
361                         Notifications.AddPopup(text = _("Write error while recording. Disk full?\n"), type = MessageBox.TYPE_ERROR, timeout = 0, id = "DiskFullMessage")
362                         # ok, the recording has been stopped. we need to properly note 
363                         # that in our state, with also keeping the possibility to re-try.
364                         # TODO: this has to be done.
365                 elif event == iRecordableService.evStart:
366                         text = _("A record has been started:\n%s") % self.name
367                         if self.dirnameHadToFallback:
368                                 text = '\n'.join((text, _("Please note that the previously selected media could not be accessed and therefore the default directory is being used instead.")))
369
370                         if config.usage.show_message_when_recording_starts.value:
371                                 Notifications.AddPopup(text = text, type = MessageBox.TYPE_INFO, timeout = 3)
372
373         # we have record_service as property to automatically subscribe to record service events
374         def setRecordService(self, service):
375                 if self.__record_service is not None:
376                         print "[remove callback]"
377                         NavigationInstance.instance.record_event.remove(self.gotRecordEvent)
378
379                 self.__record_service = service
380
381                 if self.__record_service is not None:
382                         print "[add callback]"
383                         NavigationInstance.instance.record_event.append(self.gotRecordEvent)
384
385         record_service = property(lambda self: self.__record_service, setRecordService)
386
387 def createTimer(xml):
388         begin = int(xml.get("begin"))
389         end = int(xml.get("end"))
390         serviceref = ServiceReference(xml.get("serviceref").encode("utf-8"))
391         description = xml.get("description").encode("utf-8")
392         repeated = xml.get("repeated").encode("utf-8")
393         disabled = long(xml.get("disabled") or "0")
394         justplay = long(xml.get("justplay") or "0")
395         afterevent = str(xml.get("afterevent") or "nothing")
396         afterevent = {
397                 "nothing": AFTEREVENT.NONE,
398                 "standby": AFTEREVENT.STANDBY,
399                 "deepstandby": AFTEREVENT.DEEPSTANDBY,
400                 "auto": AFTEREVENT.AUTO
401                 }[afterevent]
402         eit = xml.get("eit")
403         if eit and eit != "None":
404                 eit = long(eit);
405         else:
406                 eit = None
407         location = xml.get("location")
408         if location and location != "None":
409                 location = location.encode("utf-8")
410         else:
411                 location = None
412         tags = xml.get("tags")
413         if tags and tags != "None":
414                 tags = tags.encode("utf-8").split(' ')
415         else:
416                 tags = None
417
418         name = xml.get("name").encode("utf-8")
419         #filename = xml.get("filename").encode("utf-8")
420         entry = RecordTimerEntry(serviceref, begin, end, name, description, eit, disabled, justplay, afterevent, dirname = location, tags = tags)
421         entry.repeated = int(repeated)
422         
423         for l in xml.findall("log"):
424                 time = int(l.get("time"))
425                 code = int(l.get("code"))
426                 msg = l.text.strip().encode("utf-8")
427                 entry.log_entries.append((time, code, msg))
428         
429         return entry
430
431 class RecordTimer(timer.Timer):
432         def __init__(self):
433                 timer.Timer.__init__(self)
434                 
435                 self.Filename = Directories.resolveFilename(Directories.SCOPE_CONFIG, "timers.xml")
436                 
437                 try:
438                         self.loadTimer()
439                 except IOError:
440                         print "unable to load timers from file!"
441
442         def doActivate(self, w):
443                 # when activating a timer which has already passed,
444                 # simply abort the timer. don't run trough all the stages.
445                 if w.shouldSkip():
446                         w.state = RecordTimerEntry.StateEnded
447                 else:
448                         # when active returns true, this means "accepted".
449                         # otherwise, the current state is kept.
450                         # the timer entry itself will fix up the delay then.
451                         if w.activate():
452                                 w.state += 1
453
454                 self.timer_list.remove(w)
455
456                 # did this timer reached the last state?
457                 if w.state < RecordTimerEntry.StateEnded:
458                         # no, sort it into active list
459                         insort(self.timer_list, w)
460                 else:
461                         # yes. Process repeated, and re-add.
462                         if w.repeated:
463                                 w.processRepeated()
464                                 w.state = RecordTimerEntry.StateWaiting
465                                 self.addTimerEntry(w)
466                         else:
467                                 insort(self.processed_timers, w)
468                 
469                 self.stateChanged(w)
470
471         def isRecording(self):
472                 isRunning = False
473                 for timer in self.timer_list:
474                         if timer.isRunning() and not timer.justplay:
475                                 isRunning = True
476                 return isRunning
477         
478         def loadTimer(self):
479                 # TODO: PATH!
480                 try:
481                         doc = xml.etree.cElementTree.parse(self.Filename)
482                 except SyntaxError:
483                         from Tools.Notifications import AddPopup
484                         from Screens.MessageBox import MessageBox
485
486                         AddPopup(_("The timer file (timers.xml) is corrupt and could not be loaded."), type = MessageBox.TYPE_ERROR, timeout = 0, id = "TimerLoadFailed")
487
488                         print "timers.xml failed to load!"
489                         try:
490                                 import os
491                                 os.rename(self.Filename, self.Filename + "_old")
492                         except (IOError, OSError):
493                                 print "renaming broken timer failed"
494                         return
495                 except IOError:
496                         print "timers.xml not found!"
497                         return
498
499                 root = doc.getroot()
500
501                 # put out a message when at least one timer overlaps
502                 checkit = True
503                 for timer in root.findall("timer"):
504                         newTimer = createTimer(timer)
505                         if (self.record(newTimer, True, True) is not None) and (checkit == True):
506                                 from Tools.Notifications import AddPopup
507                                 from Screens.MessageBox import MessageBox
508                                 AddPopup(_("Timer overlap in timers.xml detected!\nPlease recheck it!"), type = MessageBox.TYPE_ERROR, timeout = 0, id = "TimerLoadFailed")
509                                 checkit = False # at moment it is enough when the message is displayed one time
510
511         def saveTimer(self):
512                 #root_element = xml.etree.cElementTree.Element('timers')
513                 #root_element.text = "\n"
514
515                 #for timer in self.timer_list + self.processed_timers:
516                         # some timers (instant records) don't want to be saved.
517                         # skip them
518                         #if timer.dontSave:
519                                 #continue
520                         #t = xml.etree.cElementTree.SubElement(root_element, 'timers')
521                         #t.set("begin", str(int(timer.begin)))
522                         #t.set("end", str(int(timer.end)))
523                         #t.set("serviceref", str(timer.service_ref))
524                         #t.set("repeated", str(timer.repeated))                 
525                         #t.set("name", timer.name)
526                         #t.set("description", timer.description)
527                         #t.set("afterevent", str({
528                         #       AFTEREVENT.NONE: "nothing",
529                         #       AFTEREVENT.STANDBY: "standby",
530                         #       AFTEREVENT.DEEPSTANDBY: "deepstandby",
531                         #       AFTEREVENT.AUTO: "auto"}))
532                         #if timer.eit is not None:
533                         #       t.set("eit", str(timer.eit))
534                         #if timer.dirname is not None:
535                         #       t.set("location", str(timer.dirname))
536                         #t.set("disabled", str(int(timer.disabled)))
537                         #t.set("justplay", str(int(timer.justplay)))
538                         #t.text = "\n"
539                         #t.tail = "\n"
540
541                         #for time, code, msg in timer.log_entries:
542                                 #l = xml.etree.cElementTree.SubElement(t, 'log')
543                                 #l.set("time", str(time))
544                                 #l.set("code", str(code))
545                                 #l.text = str(msg)
546                                 #l.tail = "\n"
547
548                 #doc = xml.etree.cElementTree.ElementTree(root_element)
549                 #doc.write(self.Filename)
550
551                 list = []
552
553                 list.append('<?xml version="1.0" ?>\n')
554                 list.append('<timers>\n')
555                 
556                 for timer in self.timer_list + self.processed_timers:
557                         if timer.dontSave:
558                                 continue
559
560                         list.append('<timer')
561                         list.append(' begin="' + str(int(timer.begin)) + '"')
562                         list.append(' end="' + str(int(timer.end)) + '"')
563                         list.append(' serviceref="' + stringToXML(str(timer.service_ref)) + '"')
564                         list.append(' repeated="' + str(int(timer.repeated)) + '"')
565                         list.append(' name="' + str(stringToXML(timer.name)) + '"')
566                         list.append(' description="' + str(stringToXML(timer.description)) + '"')
567                         list.append(' afterevent="' + str(stringToXML({
568                                 AFTEREVENT.NONE: "nothing",
569                                 AFTEREVENT.STANDBY: "standby",
570                                 AFTEREVENT.DEEPSTANDBY: "deepstandby",
571                                 AFTEREVENT.AUTO: "auto"
572                                 }[timer.afterEvent])) + '"')
573                         if timer.eit is not None:
574                                 list.append(' eit="' + str(timer.eit) + '"')
575                         if timer.dirname is not None:
576                                 list.append(' location="' + str(stringToXML(timer.dirname)) + '"')
577                         if timer.tags is not None:
578                                 list.append(' tags="' + str(stringToXML(' '.join(timer.tags))) + '"')
579                         list.append(' disabled="' + str(int(timer.disabled)) + '"')
580                         list.append(' justplay="' + str(int(timer.justplay)) + '"')
581                         list.append('>\n')
582                         
583                         if config.recording.debug.value:
584                                 for time, code, msg in timer.log_entries:
585                                         list.append('<log')
586                                         list.append(' code="' + str(code) + '"')
587                                         list.append(' time="' + str(time) + '"')
588                                         list.append('>')
589                                         list.append(str(stringToXML(msg)))
590                                         list.append('</log>\n')
591                         
592                         list.append('</timer>\n')
593
594                 list.append('</timers>\n')
595
596                 file = open(self.Filename, "w")
597                 for x in list:
598                         file.write(x)
599                 file.close()
600
601         def getNextZapTime(self):
602                 now = time()
603                 for timer in self.timer_list:
604                         if not timer.justplay or timer.begin < now:
605                                 continue
606                         return timer.begin
607                 return -1
608
609         def getNextRecordingTime(self):
610                 now = time()
611                 for timer in self.timer_list:
612                         next_act = timer.getNextActivation()
613                         if timer.justplay or next_act < now:
614                                 continue
615                         return next_act
616                 return -1
617
618         def isNextRecordAfterEventActionAuto(self):
619                 now = time()
620                 t = None
621                 for timer in self.timer_list:
622                         if timer.justplay or timer.begin < now:
623                                 continue
624                         if t is None or t.begin == timer.begin:
625                                 t = timer
626                                 if t.afterEvent == AFTEREVENT.AUTO:
627                                         return True
628                 return False
629
630         def record(self, entry, ignoreTSC=False, dosave=True):          #wird von loadTimer mit dosave=False aufgerufen
631                 timersanitycheck = TimerSanityCheck(self.timer_list,entry)
632                 if not timersanitycheck.check():
633                         if ignoreTSC != True:
634                                 print "timer conflict detected!"
635                                 print timersanitycheck.getSimulTimerList()
636                                 return timersanitycheck.getSimulTimerList()
637                         else:
638                                 print "ignore timer conflict"
639                 elif timersanitycheck.doubleCheck():
640                         print "ignore double timer"
641                         return None
642                 entry.timeChanged()
643                 print "[Timer] Record " + str(entry)
644                 entry.Timer = self
645                 self.addTimerEntry(entry)
646                 if dosave:
647                         self.saveTimer()
648                 return None
649
650         def isInTimer(self, eventid, begin, duration, service):
651                 time_match = 0
652                 chktime = None
653                 chktimecmp = None
654                 chktimecmp_end = None
655                 end = begin + duration
656                 refstr = str(service)
657                 for x in self.timer_list:
658                         check = x.service_ref.ref.toString() == refstr
659                         if not check:
660                                 sref = x.service_ref.ref
661                                 parent_sid = sref.getUnsignedData(5)
662                                 parent_tsid = sref.getUnsignedData(6)
663                                 if parent_sid and parent_tsid: # check for subservice
664                                         sid = sref.getUnsignedData(1)
665                                         tsid = sref.getUnsignedData(2)
666                                         sref.setUnsignedData(1, parent_sid)
667                                         sref.setUnsignedData(2, parent_tsid)
668                                         sref.setUnsignedData(5, 0)
669                                         sref.setUnsignedData(6, 0)
670                                         check = sref.toCompareString() == refstr
671                                         num = 0
672                                         if check:
673                                                 check = False
674                                                 event = eEPGCache.getInstance().lookupEventId(sref, eventid)
675                                                 num = event and event.getNumOfLinkageServices() or 0
676                                         sref.setUnsignedData(1, sid)
677                                         sref.setUnsignedData(2, tsid)
678                                         sref.setUnsignedData(5, parent_sid)
679                                         sref.setUnsignedData(6, parent_tsid)
680                                         for cnt in range(num):
681                                                 subservice = event.getLinkageService(sref, cnt)
682                                                 if sref.toCompareString() == subservice.toCompareString():
683                                                         check = True
684                                                         break
685                         if check:
686                                 if x.repeated != 0:
687                                         if chktime is None:
688                                                 chktime = localtime(begin)
689                                                 chktimecmp = chktime.tm_wday * 1440 + chktime.tm_hour * 60 + chktime.tm_min
690                                                 chktimecmp_end = chktimecmp + (duration / 60)
691                                         time = localtime(x.begin)
692                                         for y in (0, 1, 2, 3, 4, 5, 6):
693                                                 if x.repeated & (1 << y) and (x.begin <= begin or begin <= x.begin <= end):
694                                                         timecmp = y * 1440 + time.tm_hour * 60 + time.tm_min
695                                                         if timecmp <= chktimecmp < (timecmp + ((x.end - x.begin) / 60)):
696                                                                 time_match = ((timecmp + ((x.end - x.begin) / 60)) - chktimecmp) * 60
697                                                         elif chktimecmp <= timecmp < chktimecmp_end:
698                                                                 time_match = (chktimecmp_end - timecmp) * 60
699                                 else: #if x.eit is None:
700                                         if begin <= x.begin <= end:
701                                                 diff = end - x.begin
702                                                 if time_match < diff:
703                                                         time_match = diff
704                                         elif x.begin <= begin <= x.end:
705                                                 diff = x.end - begin
706                                                 if time_match < diff:
707                                                         time_match = diff
708                                 if time_match:
709                                         break
710                 return time_match
711
712         def removeEntry(self, entry):
713                 print "[Timer] Remove " + str(entry)
714                 
715                 # avoid re-enqueuing
716                 entry.repeated = False
717
718                 # abort timer.
719                 # this sets the end time to current time, so timer will be stopped.
720                 entry.autoincrease = False
721                 entry.abort()
722                 
723                 if entry.state != entry.StateEnded:
724                         self.timeChanged(entry)
725                 
726                 print "state: ", entry.state
727                 print "in processed: ", entry in self.processed_timers
728                 print "in running: ", entry in self.timer_list
729                 # autoincrease instanttimer if possible
730                 if not entry.dontSave:
731                         for x in self.timer_list:
732                                 if x.setAutoincreaseEnd():
733                                         self.timeChanged(x)
734                 # now the timer should be in the processed_timers list. remove it from there.
735                 self.processed_timers.remove(entry)
736                 self.saveTimer()
737
738         def shutdown(self):
739                 self.saveTimer()