Merge branch 'master' of acidburn@git.opendreambox.org:/git/enigma2 into bug_218_simp...

[enigma2.git] / lib / python / Components / TimerSanityCheck.py

diff --git a/lib/python/Components/TimerSanityCheck.py b/lib/python/Components/TimerSanityCheck.py
index d3857039cce00f03c6ce5ef082e24310177317a6..8f48d1ecb0f3588125b4eae4ff1798da33788bc9 100644 (file)
--- a/lib/python/Components/TimerSanityCheck.py
+++ b/lib/python/Components/TimerSanityCheck.py
@@ -1,20 +1,19 @@
-import string

 import NavigationInstance
 import NavigationInstance

-from time import localtime
-from Components.NimManager import nimmanager
+from time import localtime, mktime, gmtime

 from ServiceReference import ServiceReference
 from ServiceReference import ServiceReference

-from enigma import iServiceInformation, eServiceCenter
+from enigma import iServiceInformation, eServiceCenter, eServiceReference

 
 class TimerSanityCheck:
        def __init__(self, timerlist, newtimer=None):
                print "sanitycheck"
 
 class TimerSanityCheck:
        def __init__(self, timerlist, newtimer=None):
                print "sanitycheck"

+               self.localtimediff = 25*3600 - mktime(gmtime(25*3600))

                self.timerlist = timerlist
                self.newtimer = newtimer
                self.simultimer = []
                self.rep_eventlist = []
                self.nrep_eventlist = []
                self.timerlist = timerlist
                self.newtimer = newtimer
                self.simultimer = []
                self.rep_eventlist = []
                self.nrep_eventlist = []

-               self.bflag = -1
-               self.eflag = 1
+               self.bflag = 1
+               self.eflag = -1

 
        def check(self, ext_timer=1):
                print "check"
 
        def check(self, ext_timer=1):
                print "check"


@@ -25,7 +24,6 @@ class TimerSanityCheck:
                else:
                        self.simultimer = [ self.newtimer ]
                return self.checkTimerlist()
                else:
                        self.simultimer = [ self.newtimer ]
                return self.checkTimerlist()

-               

 
        def getSimulTimerList(self):
                return self.simultimer
 
        def getSimulTimerList(self):
                return self.simultimer


@@ -38,9 +36,15 @@ class TimerSanityCheck:
                                        return True
                                else:
                                        if timer.begin == self.newtimer.begin:
                                        return True
                                else:
                                        if timer.begin == self.newtimer.begin:

+                                               fl1 = timer.service_ref.ref.flags & eServiceReference.isGroup
+                                               fl2 = self.newtimer.service_ref.ref.flags & eServiceReference.isGroup
+                                               if fl1 != fl2:
+                                                       return False
+                                               if fl1: #is group
+                                                       return timer.service_ref.ref.getPath() == self.newtimer.service_ref.ref.getPath()

                                                getUnsignedDataRef1 = timer.service_ref.ref.getUnsignedData
                                                getUnsignedDataRef2 = self.newtimer.service_ref.ref.getUnsignedData
                                                getUnsignedDataRef1 = timer.service_ref.ref.getUnsignedData
                                                getUnsignedDataRef2 = self.newtimer.service_ref.ref.getUnsignedData

-                                               for x in range(1,5):
+                                               for x in (1, 2, 3, 4):

                                                        if getUnsignedDataRef1(x) != getUnsignedDataRef2(x):
                                                                break;
                                                else:
                                                        if getUnsignedDataRef1(x) != getUnsignedDataRef2(x):
                                                                break;
                                                else:


@@ -51,10 +55,11 @@ class TimerSanityCheck:
                #with special service for external plugins
                # Entries in eventlist
                # timeindex
                #with special service for external plugins
                # Entries in eventlist
                # timeindex

+               # BeginEndFlag 1 for begin, -1 for end

                # index -1 for the new Timer, 0..n index of the existing timers
                # index -1 for the new Timer, 0..n index of the existing timers

-               # BeginEndFlag -1 for begin, +1 for end

                # count of running timers
 
                # count of running timers
 

+               serviceHandler = eServiceCenter.getInstance()

                print "checkTimerlist"
 # create a list with all start and end times
 # split it into recurring and singleshot timers
                print "checkTimerlist"
 # create a list with all start and end times
 # split it into recurring and singleshot timers


@@ -72,13 +77,17 @@ class TimerSanityCheck:
                        rflags = ((rflags & 0x7F)>> 3)|((rflags & 0x07)<<4)
                        if rflags:
                                begin = self.newtimer.begin % 86400 # map to first day
                        rflags = ((rflags & 0x7F)>> 3)|((rflags & 0x07)<<4)
                        if rflags:
                                begin = self.newtimer.begin % 86400 # map to first day

+                               if (self.localtimediff > 0) and ((begin + self.localtimediff) > 86400):
+                                       rflags = ((rflags >> 1)& 0x3F)|((rflags << 6)& 0x40)
+                               elif (self.localtimediff < 0) and (begin < self.localtimediff):
+                                       rflags = ((rflags << 1)& 0x7E)|((rflags >> 6)& 0x01)

                                while rflags: # then arrange on the week
                                        if rflags & 1:
                                                self.rep_eventlist.append((begin, -1))
                                        begin += 86400
                                        rflags >>= 1
                        else:
                                while rflags: # then arrange on the week
                                        if rflags & 1:
                                                self.rep_eventlist.append((begin, -1))
                                        begin += 86400
                                        rflags >>= 1
                        else:

-                               self.nrep_eventlist.extend([(self.newtimer.begin,-1,self.bflag),(self.newtimer.end,-1,self.eflag)])
+                               self.nrep_eventlist.extend([(self.newtimer.begin,self.bflag,-1),(self.newtimer.end,self.eflag,-1)])

 
 ##################################################################################
 # now process existing timers
 
 ##################################################################################
 # now process existing timers


@@ -89,18 +98,22 @@ class TimerSanityCheck:
                                        rflags = timer.repeated
                                        rflags = ((rflags & 0x7F)>> 3)|((rflags & 0x07)<<4)
                                        begin = timer.begin % 86400 # map all to first day
                                        rflags = timer.repeated
                                        rflags = ((rflags & 0x7F)>> 3)|((rflags & 0x07)<<4)
                                        begin = timer.begin % 86400 # map all to first day

+                                       if (self.localtimediff > 0) and ((begin + self.localtimediff) > 86400):
+                                               rflags = ((rflags >> 1)& 0x3F)|((rflags << 6)& 0x40)
+                                       elif (self.localtimediff < 0) and (begin < self.localtimediff):
+                                               rflags = ((rflags << 1)& 0x7E)|((rflags >> 6)& 0x01)

                                        while rflags:
                                                if rflags & 1:
                                                        self.rep_eventlist.append((begin, idx))
                                                begin += 86400
                                                rflags >>= 1
                                else:
                                        while rflags:
                                                if rflags & 1:
                                                        self.rep_eventlist.append((begin, idx))
                                                begin += 86400
                                                rflags >>= 1
                                else:

-                                       self.nrep_eventlist.extend([(timer.begin,idx,self.bflag),(timer.end,idx,self.eflag)])
+                                       self.nrep_eventlist.extend([(timer.begin,self.bflag,idx),(timer.end,self.eflag,idx)])

                        idx += 1
 
 ################################################################################
 # journalize timer repeations
                        idx += 1
 
 ################################################################################
 # journalize timer repeations

-               if len(self.nrep_eventlist):
+               if self.nrep_eventlist:

                        interval_begin = min(self.nrep_eventlist)[0]
                        interval_end = max(self.nrep_eventlist)[0]
                        offset_0 = interval_begin - (interval_begin % 604800)
                        interval_begin = min(self.nrep_eventlist)[0]
                        interval_end = max(self.nrep_eventlist)[0]
                        offset_0 = interval_begin - (interval_begin % 604800)


@@ -122,14 +135,13 @@ class TimerSanityCheck:
                                        new_event_end = new_event_begin + (event_end - event_begin)
                                        if event[1] == -1:
                                                if new_event_begin >= self.newtimer.begin: # is the soap already running?
                                        new_event_end = new_event_begin + (event_end - event_begin)
                                        if event[1] == -1:
                                                if new_event_begin >= self.newtimer.begin: # is the soap already running?

-                                                       self.nrep_eventlist.extend([(new_event_begin, event[1], self.bflag),(new_event_end, event[1], self.eflag)])
+                                                       self.nrep_eventlist.extend([(new_event_begin, self.bflag, event[1]),(new_event_end, self.eflag, event[1])])

                                        else:
                                                if new_event_begin >= self.timerlist[event[1]].begin: # is the soap already running?
                                        else:
                                                if new_event_begin >= self.timerlist[event[1]].begin: # is the soap already running?

-                                                       self.nrep_eventlist.extend([(new_event_begin, event[1], self.bflag),(new_event_end, event[1], self.eflag)])
+                                                       self.nrep_eventlist.extend([(new_event_begin, self.bflag, event[1]),(new_event_end, self.eflag, event[1])])

                else:
                        offset_0 = 345600 # the Epoch begins on Thursday
                else:
                        offset_0 = 345600 # the Epoch begins on Thursday

-                       weeks = 2 # test two weeks to take care of Sunday-Monday transitions
-                       for cnt in range(weeks):
+                       for cnt in (0, 1): # test two weeks to take care of Sunday-Monday transitions

                                for event in self.rep_eventlist:
                                        if event[1] == -1: # -1 is the identifier of the changed timer
                                                event_begin = self.newtimer.begin
                                for event in self.rep_eventlist:
                                        if event[1] == -1: # -1 is the identifier of the changed timer
                                                event_begin = self.newtimer.begin


@@ -139,7 +151,7 @@ class TimerSanityCheck:
                                                event_end = self.timerlist[event[1]].end
                                        new_event_begin = event[0] + offset_0 + (cnt * 604800)
                                        new_event_end = new_event_begin + (event_end - event_begin)
                                                event_end = self.timerlist[event[1]].end
                                        new_event_begin = event[0] + offset_0 + (cnt * 604800)
                                        new_event_end = new_event_begin + (event_end - event_begin)

-                                       self.nrep_eventlist.extend([(new_event_begin, event[1], self.bflag),(new_event_end, event[1], self.eflag)])
+                                       self.nrep_eventlist.extend([(new_event_begin, self.bflag, event[1]),(new_event_end, self.eflag, event[1])])

 
 ################################################################################
 # order list chronological
 
 ################################################################################
 # order list chronological


@@ -150,49 +162,66 @@ class TimerSanityCheck:
                fakeRecList = []
                ConflictTimer = None
                ConflictTunerType = None
                fakeRecList = []
                ConflictTimer = None
                ConflictTunerType = None

-               ConflictSlot = None

                newTimerTunerType = None
                newTimerTunerType = None

-               newTimerTunerSlot = None

                cnt = 0
                idx = 0
                overlaplist = []
                for event in self.nrep_eventlist:
                cnt = 0
                idx = 0
                overlaplist = []
                for event in self.nrep_eventlist:

-                       cnt -= event[2]
-                       if event[1] == -1: # new timer
+                       cnt += event[1]
+                       if event[2] == -1: # new timer

                                timer = self.newtimer
                        else:
                                timer = self.newtimer
                        else:

-                               timer = self.timerlist[event[1]]
-                       if event[2] == self.bflag:
-                               fakeRecService = NavigationInstance.instance.recordService(timer.service_ref)
-                               feinfo = fakeRecService.frontendInfo().getFrontendData()
-                               tunerType = feinfo.get("tuner_type")
-                               tunerSlot = feinfo.get("tuner_number")
-                               if event[1] == -1: # new timer
+                               timer = self.timerlist[event[2]]
+                       if event[1] == self.bflag:
+                               tunerType = [ ]
+                               fakeRecService = NavigationInstance.instance.recordService(timer.service_ref, True)
+                               if fakeRecService:
+                                       fakeRecResult = fakeRecService.start(True)
+                               else:
+                                       fakeRecResult = -1
+                               if not fakeRecResult: # tune okay
+                                       feinfo = fakeRecService.frontendInfo().getFrontendData()
+                                       tunerType.append(feinfo.get("tuner_type"))
+                               else: # tune failed.. so we must go another way to get service type (DVB-S, DVB-T, DVB-C)
+
+                                       def getServiceType(ref): # helper function to get a service type of a service reference
+                                               serviceInfo = serviceHandler.info(ref)
+                                               serviceInfo = serviceInfo and serviceInfo.getInfoObject(ref, iServiceInformation.sTransponderData)
+                                               return serviceInfo and serviceInfo["tuner_type"] or ""
+
+                                       ref = timer.service_ref.ref
+                                       if ref.flags & eServiceReference.isGroup: # service group ?
+                                               serviceList = serviceHandler.list(ref) # get all alternative services
+                                               if serviceList:
+                                                       for ref in serviceList.getContent("R"): # iterate over all group service references
+                                                               type = getServiceType(ref)
+                                                               if not type in tunerType: # just add single time
+                                                                       tunerType.append(type) 
+                                       else:
+                                               tunerType.append(getServiceType(ref))
+
+                               if event[2] == -1: # new timer

                                        newTimerTunerType = tunerType
                                        newTimerTunerType = tunerType

-                                       newTimerTunerSlot = tunerSlot
-                               fakeRecResult = fakeRecService.start(True)
-                               overlaplist.append((fakeRecResult, timer, tunerType, tunerSlot))
+                               overlaplist.append((fakeRecResult, timer, tunerType))

                                fakeRecList.append((timer, fakeRecService))
                                if fakeRecResult:
                                        if ConflictTimer is None: # just take care of the first conflict
                                                ConflictTimer = timer
                                                ConflictTunerType = tunerType
                                fakeRecList.append((timer, fakeRecService))
                                if fakeRecResult:
                                        if ConflictTimer is None: # just take care of the first conflict
                                                ConflictTimer = timer
                                                ConflictTunerType = tunerType

-                                               ConflictSlot = tunerSlot
-                       elif event[2] == self.eflag:
+                       elif event[1] == self.eflag:

                                for fakeRec in fakeRecList:
                                for fakeRec in fakeRecList:

-                                       if timer == fakeRec[0]:
+                                       if timer == fakeRec[0] and fakeRec[1]:

                                                NavigationInstance.instance.stopRecordService(fakeRec[1])
                                                fakeRecList.remove(fakeRec)
                                                NavigationInstance.instance.stopRecordService(fakeRec[1])
                                                fakeRecList.remove(fakeRec)

-                               if overlaplist.count(timer):
-                                       overlaplist.remove(timer)
+                               fakeRec = None
+                               for entry in overlaplist:
+                                       if entry[1] == timer:
+                                               overlaplist.remove(entry)

                        else:
                                print "Bug: unknown flag!"
                        self.nrep_eventlist[idx] = (event[0],event[1],event[2],cnt,overlaplist[:]) # insert a duplicate into current overlaplist
                        idx += 1
 
                        else:
                                print "Bug: unknown flag!"
                        self.nrep_eventlist[idx] = (event[0],event[1],event[2],cnt,overlaplist[:]) # insert a duplicate into current overlaplist
                        idx += 1
 

-               for fakeRec in fakeRecList:
-                       NavigationInstance.instance.stopRecordService(fakeRec[1])
-

                if ConflictTimer is None: # no conflict found :)
                        return True
 
                if ConflictTimer is None: # no conflict found :)
                        return True
 


@@ -213,7 +242,6 @@ class TimerSanityCheck:
                                                if nt and kt:
                                                        ConflictTimer = self.newtimer
                                                        ConflictTunerType = newTimerTunerType
                                                if nt and kt:
                                                        ConflictTimer = self.newtimer
                                                        ConflictTunerType = newTimerTunerType

-                                                       ConflictSlot = newTimerTunerSlot

                                                        break
 
                self.simultimer = [ ConflictTimer ]
                                                        break
 
                self.simultimer = [ ConflictTimer ]


@@ -225,8 +253,11 @@ class TimerSanityCheck:
                                else:
                                        continue
                                for entry in event[4]:
                                else:
                                        continue
                                for entry in event[4]:

-                                       if not self.simultimer.count(entry[1]) and (entry[2] == ConflictTunerType or entry[3] == ConflictTunerSlot):
-                                               self.simultimer.append(entry[1])
+                                       if not entry[1] in self.simultimer:
+                                               for x in entry[2]:
+                                                       if x in ConflictTunerType:
+                                                               self.simultimer.append(entry[1])
+                                                               break

 
                if len(self.simultimer) < 2:
                        print "Bug: unknown Conflict!"
 
                if len(self.simultimer) < 2:
                        print "Bug: unknown Conflict!"