timerfix by adenin
[enigma2.git] / lib / python / Components / TimerSanityCheck.py
1 import NavigationInstance
2 from time import localtime, mktime, gmtime
3 from ServiceReference import ServiceReference
4 from enigma import iServiceInformation, eServiceCenter, eServiceReference
5
6 class TimerSanityCheck:
7         def __init__(self, timerlist, newtimer=None):
8                 print "sanitycheck"
9                 self.localtimediff = 25*3600 - mktime(gmtime(25*3600))
10                 self.timerlist = timerlist
11                 self.newtimer = newtimer
12                 self.simultimer = []
13                 self.rep_eventlist = []
14                 self.nrep_eventlist = []
15                 self.bflag = 1
16                 self.eflag = -1
17
18         def check(self, ext_timer=1):
19                 print "check"
20                 if ext_timer != 1:
21                         self.newtimer = ext_timer
22                 if self.newtimer is None:
23                         self.simultimer = []
24                 else:
25                         self.simultimer = [ self.newtimer ]
26                 return self.checkTimerlist()
27
28         def getSimulTimerList(self):
29                 return self.simultimer
30
31         def doubleCheck(self):
32                 if self.newtimer is not None and self.newtimer.service_ref.ref.valid():
33                         self.simultimer = [ self.newtimer ]
34                         for timer in self.timerlist:
35                                 if (timer == self.newtimer):
36                                         return True
37                                 else:
38                                         if timer.begin == self.newtimer.begin:
39                                                 getUnsignedDataRef1 = timer.service_ref.ref.getUnsignedData
40                                                 getUnsignedDataRef2 = self.newtimer.service_ref.ref.getUnsignedData
41                                                 for x in (1, 2, 3, 4):
42                                                         if getUnsignedDataRef1(x) != getUnsignedDataRef2(x):
43                                                                 break;
44                                                 else:
45                                                         return True
46                 return False
47
48         def checkTimerlist(self, ext_timer=1):
49                 #with special service for external plugins
50                 # Entries in eventlist
51                 # timeindex
52                 # BeginEndFlag 1 for begin, -1 for end
53                 # index -1 for the new Timer, 0..n index of the existing timers
54                 # count of running timers
55
56                 serviceHandler = eServiceCenter.getInstance()
57                 print "checkTimerlist"
58 # create a list with all start and end times
59 # split it into recurring and singleshot timers
60
61 ##################################################################################
62 # process the new timer
63                 self.rep_eventlist = []
64                 self.nrep_eventlist = []
65                 if ext_timer != 1:
66                         self.newtimer = ext_timer
67                 if (self.newtimer is not None) and (not self.newtimer.disabled):
68                         if not self.newtimer.service_ref.ref.valid():
69                                 return False
70                         rflags = self.newtimer.repeated
71                         rflags = ((rflags & 0x7F)>> 3)|((rflags & 0x07)<<4)
72                         if rflags:
73                                 begin = self.newtimer.begin % 86400 # map to first day
74                                 if (self.localtimediff > 0) and ((begin + self.localtimediff) > 86400):
75                                         rflags = ((rflags >> 1)& 0x3F)|((rflags << 6)& 0x40)
76                                 elif (self.localtimediff < 0) and (begin < self.localtimediff):
77                                         rflags = ((rflags << 1)& 0x7E)|((rflags >> 6)& 0x01)
78                                 while rflags: # then arrange on the week
79                                         if rflags & 1:
80                                                 self.rep_eventlist.append((begin, -1))
81                                         begin += 86400
82                                         rflags >>= 1
83                         else:
84                                 self.nrep_eventlist.extend([(self.newtimer.begin,self.bflag,-1),(self.newtimer.end,self.eflag,-1)])
85
86 ##################################################################################
87 # now process existing timers
88                 idx = 0
89                 for timer in self.timerlist:
90                         if (timer != self.newtimer) and (not timer.disabled):
91                                 if timer.repeated:
92                                         rflags = timer.repeated
93                                         rflags = ((rflags & 0x7F)>> 3)|((rflags & 0x07)<<4)
94                                         begin = timer.begin % 86400 # map all to first day
95                                         if (self.localtimediff > 0) and ((begin + self.localtimediff) > 86400):
96                                                 rflags = ((rflags >> 1)& 0x3F)|((rflags << 6)& 0x40)
97                                         elif (self.localtimediff < 0) and (begin < self.localtimediff):
98                                                 rflags = ((rflags << 1)& 0x7E)|((rflags >> 6)& 0x01)
99                                         while rflags:
100                                                 if rflags & 1:
101                                                         self.rep_eventlist.append((begin, idx))
102                                                 begin += 86400
103                                                 rflags >>= 1
104                                 else:
105                                         self.nrep_eventlist.extend([(timer.begin,self.bflag,idx),(timer.end,self.eflag,idx)])
106                         idx += 1
107
108 ################################################################################
109 # journalize timer repeations
110                 if self.nrep_eventlist:
111                         interval_begin = min(self.nrep_eventlist)[0]
112                         interval_end = max(self.nrep_eventlist)[0]
113                         offset_0 = interval_begin - (interval_begin % 604800)
114                         weeks = (interval_end - offset_0) / 604800
115                         if ((interval_end - offset_0) % 604800):
116                                 weeks += 1
117                         for cnt in range(weeks):
118                                 for event in self.rep_eventlist:
119                                         if event[1] == -1: # -1 is the identifier of the changed timer
120                                                 event_begin = self.newtimer.begin
121                                                 event_end = self.newtimer.end
122                                         else:
123                                                 event_begin = self.timerlist[event[1]].begin
124                                                 event_end = self.timerlist[event[1]].end
125                                         new_event_begin = event[0] + offset_0 + (cnt * 604800)
126                                         # summertime correction
127                                         new_lth = localtime(new_event_begin).tm_hour
128                                         new_event_begin += 3600 * (localtime(event_begin).tm_hour - new_lth)
129                                         new_event_end = new_event_begin + (event_end - event_begin)
130                                         if event[1] == -1:
131                                                 if new_event_begin >= self.newtimer.begin: # is the soap already running?
132                                                         self.nrep_eventlist.extend([(new_event_begin, self.bflag, event[1]),(new_event_end, self.eflag, event[1])])
133                                         else:
134                                                 if new_event_begin >= self.timerlist[event[1]].begin: # is the soap already running?
135                                                         self.nrep_eventlist.extend([(new_event_begin, self.bflag, event[1]),(new_event_end, self.eflag, event[1])])
136                 else:
137                         offset_0 = 345600 # the Epoch begins on Thursday
138                         weeks = 2 # test two weeks to take care of Sunday-Monday transitions
139                         for cnt in range(weeks):
140                                 for event in self.rep_eventlist:
141                                         if event[1] == -1: # -1 is the identifier of the changed timer
142                                                 event_begin = self.newtimer.begin
143                                                 event_end = self.newtimer.end
144                                         else:
145                                                 event_begin = self.timerlist[event[1]].begin
146                                                 event_end = self.timerlist[event[1]].end
147                                         new_event_begin = event[0] + offset_0 + (cnt * 604800)
148                                         new_event_end = new_event_begin + (event_end - event_begin)
149                                         self.nrep_eventlist.extend([(new_event_begin, self.bflag, event[1]),(new_event_end, self.eflag, event[1])])
150
151 ################################################################################
152 # order list chronological
153                 self.nrep_eventlist.sort()
154
155 ##################################################################################
156 # detect overlapping timers and overlapping times
157                 fakeRecList = []
158                 ConflictTimer = None
159                 ConflictTunerType = None
160                 newTimerTunerType = None
161                 cnt = 0
162                 idx = 0
163                 overlaplist = []
164                 for event in self.nrep_eventlist:
165                         cnt += event[1]
166                         if event[2] == -1: # new timer
167                                 timer = self.newtimer
168                         else:
169                                 timer = self.timerlist[event[2]]
170                         if event[1] == self.bflag:
171                                 tunerType = [ ]
172                                 fakeRecService = NavigationInstance.instance.recordService(timer.service_ref, True)
173                                 if fakeRecService:
174                                         fakeRecResult = fakeRecService.start(True)
175                                 else:
176                                         fakeRecResult = -1
177                                 if not fakeRecResult: # tune okay
178                                         feinfo = fakeRecService.frontendInfo().getFrontendData()
179                                         tunerType.append(feinfo.get("tuner_type"))
180                                 else: # tune failed.. so we must go another way to get service type (DVB-S, DVB-T, DVB-C)
181
182                                         def getServiceType(ref): # helper function to get a service type of a service reference
183                                                 serviceInfo = serviceHandler.info(ref)
184                                                 serviceInfo = serviceInfo and serviceInfo.getInfoObject(ref, iServiceInformation.sTransponderData)
185                                                 return serviceInfo and serviceInfo["tuner_type"] or ""
186
187                                         ref = timer.service_ref.ref
188                                         if ref.flags & eServiceReference.isGroup: # service group ?
189                                                 serviceList = serviceHandler.list(ref) # get all alternative services
190                                                 if serviceList:
191                                                         for ref in serviceList.getContent("R"): # iterate over all group service references
192                                                                 type = getServiceType(ref)
193                                                                 if not type in tunerType: # just add single time
194                                                                         tunerType.append(type) 
195                                         else:
196                                                 tunerType.append(getServiceType(ref))
197
198                                 if event[2] == -1: # new timer
199                                         newTimerTunerType = tunerType
200                                 overlaplist.append((fakeRecResult, timer, tunerType))
201                                 fakeRecList.append((timer, fakeRecService))
202                                 if fakeRecResult:
203                                         if ConflictTimer is None: # just take care of the first conflict
204                                                 ConflictTimer = timer
205                                                 ConflictTunerType = tunerType
206                         elif event[1] == self.eflag:
207                                 for fakeRec in fakeRecList:
208                                         if timer == fakeRec[0] and fakeRec[1]:
209                                                 NavigationInstance.instance.stopRecordService(fakeRec[1])
210                                                 fakeRecList.remove(fakeRec)
211                                 fakeRec = None
212                                 for entry in overlaplist:
213                                         if entry[1] == timer:
214                                                 overlaplist.remove(entry)
215                         else:
216                                 print "Bug: unknown flag!"
217                         self.nrep_eventlist[idx] = (event[0],event[1],event[2],cnt,overlaplist[:]) # insert a duplicate into current overlaplist
218                         idx += 1
219
220                 if ConflictTimer is None: # no conflict found :)
221                         return True
222
223 ##################################################################################
224 # we have detected a conflict, now we must figure out the involved timers
225
226                 if self.newtimer is not None: # new timer?
227                         if self.newtimer is not ConflictTimer: # the new timer is not the conflicting timer?
228                                 for event in self.nrep_eventlist:
229                                         if len(event[4]) > 1: # entry in overlaplist of this event??
230                                                 kt = False
231                                                 nt = False
232                                                 for entry in event[4]:
233                                                         if entry[1] is ConflictTimer:
234                                                                 kt = True
235                                                         if entry[1] is self.newtimer:
236                                                                 nt = True
237                                                 if nt and kt:
238                                                         ConflictTimer = self.newtimer
239                                                         ConflictTunerType = newTimerTunerType
240                                                         break
241
242                 self.simultimer = [ ConflictTimer ]
243                 for event in self.nrep_eventlist:
244                         if len(event[4]) > 1: # entry in overlaplist of this event??
245                                 for entry in event[4]:
246                                         if entry[1] is ConflictTimer:
247                                                 break
248                                 else:
249                                         continue
250                                 for entry in event[4]:
251                                         if not entry[1] in self.simultimer:
252                                                 for x in entry[2]:
253                                                         if x in ConflictTunerType:
254                                                                 self.simultimer.append(entry[1])
255                                                                 break
256
257                 if len(self.simultimer) < 2:
258                         print "Bug: unknown Conflict!"
259
260                 return False # conflict detected!