X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/dc093daa0b0c4b12e33c30fb1b0b48c18ab8f8b5..334e49f88bb558bb2f07d47c77c7900074d5b7b8:/timer.py

diff --git a/timer.py b/timer.py
index 42bafe35..a98481c0 100644
--- a/timer.py
+++ b/timer.py
@@ -3,26 +3,24 @@ import time
 from enigma import *
 
 class TimerEntry:
-	EventPrepare = 0
-	EventStart   = 1
-	EventEnd     = 2
-	EventAbort   = 3
-	
-	StateWait    = 0
-	StatePrepare = 1
-	StateRunning = 2
-	StateEnded   = 3
+	StateWaiting  = 0
+	StatePrepared = 1
+	StateRunning  = 2
+	StateEnded    = 3
 	
 	def __init__(self, begin, end):
 		self.begin = begin
-		self.prepare_time = 10
+		self.prepare_time = 20
 		self.end = end
 		self.state = 0
 		self.resetRepeated()
+		self.backoff = 0
+		
+		self.disabled = False
 		
 	def resetRepeated(self):
 		self.repeated = int(0)
-		
+
 	def setRepeated(self, day):
 		self.repeated |= (2 ** day)
 		print "Repeated: " + str(self.repeated)
@@ -57,23 +55,38 @@ class TimerEntry:
 				print time.strftime("%c", time.localtime(self.end))
 				self.begin += 86400
 				self.end += 86400
+			
+			self.timeChanged()
+			
 
-	def getTime(self):
-		if self.state == self.StateWait:
-			return self.begin - self.prepare_time
-		elif self.state == self.StatePrepare:
-			return self.begin
-		else:
-			return self.end 
-	
 	def __lt__(self, o):
-		return self.getTime() < o.getTime()
+		return self.getNextActivation() < o.getNextActivation()
 	
-	def activate(self, event):
-		print "[timer.py] timer %s got activated (%d)!" % (self.description, event)
+	# must be overridden
+	def activate(self):
+		pass
+		
+	# can be overridden
+	def timeChanged(self):
+		pass
 
-class Timer:
+	# check if a timer entry must be skipped
+	def shouldSkip(self):
+		return self.end <= time.time() and self.state == TimerEntry.StateWaiting
 
+	def abort(self):
+		self.end = time.time()
+		
+		# in case timer has not yet started, but gets aborted (so it's preparing),
+		# set begin to now.
+		if self.begin > self.end:
+			self.begin = self.end
+	
+	# must be overridden!
+	def getNextActivation():
+		pass
+
+class Timer:
 	# the time between "polls". We do this because
 	# we want to account for time jumps etc.
 	# of course if they occur <100s before starting,
@@ -94,19 +107,34 @@ class Timer:
 		self.lastActivation = time.time()
 		
 		self.calcNextActivation()
+		self.on_state_change = [ ]
+	
+	def stateChanged(self, entry):
+		for f in self.on_state_change:
+			f(entry)
+			
+	def getNextRecordingTime(self):
+		if len(self.timer_list) > 0:
+			return self.timer_list[0].begin
+		return -1
+			
+	def cleanup(self):
+		self.processed_timers = [entry for entry in self.processed_timers if entry.disabled]
 	
 	def addTimerEntry(self, entry, noRecalc=0):
 		entry.processRepeated()
 
-		# we either go trough Prepare/Start/End-state if the timer is still running,
-		# or skip it when it's alrady past the end.
-		
-		if entry.end > time.time():
+		# when the timer has not yet started, and is already passed,
+		# don't go trough waiting/running/end-states, but sort it
+		# right into the processedTimers.
+		if entry.shouldSkip() or entry.state == TimerEntry.StateEnded or (entry.state == TimerEntry.StateWaiting and entry.disabled):
+			print "already passed, skipping"
+			bisect.insort(self.processed_timers, entry)
+			entry.state = TimerEntry.StateEnded
+		else:
 			bisect.insort(self.timer_list, entry)
 			if not noRecalc:
 				self.calcNextActivation()
-		else:
-			bisect.insort(self.processed_timers, entry)
 	
 	def setNextActivation(self, when):
 		delay = int((when - time.time()) * 1000)
@@ -121,6 +149,8 @@ class Timer:
 			tl = self.processed_timers
 			self.processed_timers = [ ]
 			for x in tl:
+				# simulate a "waiting" state to give them a chance to re-occure
+				x.resetState()
 				self.addTimerEntry(x, noRecalc=1)
 		
 		self.processActivation()
@@ -130,36 +160,54 @@ class Timer:
 		
 		# calculate next activation point
 		if len(self.timer_list):
-			w = self.timer_list[0].getTime()
+			w = self.timer_list[0].getNextActivation()
 			if w < min:
 				min = w
 		
 		self.setNextActivation(min)
 	
 	def timeChanged(self, timer):
-		self.timer_list.remove(timer)
+		timer.timeChanged()
+		if timer.state == TimerEntry.StateEnded:
+			self.processed_timers.remove(timer)
+		else:
+			self.timer_list.remove(timer)
 
 		self.addTimerEntry(timer)
 	
 	def doActivate(self, w):
-		w.activate(w.state)
 		self.timer_list.remove(w)
+		
+		# when activating a timer which has already passed,
+		# simply abort the timer. don't run trough all the stages.
+		if w.shouldSkip():
+			w.state = TimerEntry.StateEnded
+		else:
+			# when active returns true, this means "accepted".
+			# otherwise, the current state is kept.
+			# the timer entry itself will fix up the delay then.
+			if w.activate():
+				w.state += 1
 
-		w.state += 1
+		# did this timer reached the last state?
 		if w.state < TimerEntry.StateEnded:
+			# no, sort it into active list
 			bisect.insort(self.timer_list, w)
 		else:
-			if (w.repeated != 0):
+			# yes. Process repeated, and re-add.
+			if w.repeated:
 				w.processRepeated()
-				w.state = TimerEntry.StateWait
+				w.state = TimerEntry.StateWaiting
 				self.addTimerEntry(w)
 			else:
 				bisect.insort(self.processed_timers, w)
+		
+		self.stateChanged(w)
 
-	
 	def processActivation(self):
+		print "It's now ", time.strftime("%c", time.localtime(time.time()))
 		t = int(time.time()) + 1
 		
 		# we keep on processing the first entry until it goes into the future.
-		while len(self.timer_list) and self.timer_list[0].getTime() < t:
+		while len(self.timer_list) and self.timer_list[0].getNextActivation() < t:
 			self.doActivate(self.timer_list[0])