code.vuplus.com Git - vuplus_dvbapp/blob - RecordTimer.py

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