def loader(self): if self.osd: print "[CrossEPG_Auto] calling CrossEPG_Loader with callback" self.session.openWithCallback(self.loaderCallback, CrossEPG_Loader) else: print "[CrossEPG_Auto] calling CrossEPG_Loader directly" self.ploader = CrossEPG_Loader(self.session, self.loaderCallback, True)
class CrossEPG_Auto(Screen):
POLL_TIMER = 1800000 # poll every 30 minutes
#POLL_TIMER = 18000
POLL_TIMER_FAST = 10000 # poll every 10 seconds
POLL_TIMER_BOOT = 60000 # poll every 1 minute
def __init__(self):
self.session = None
self.timer = eTimer()
self.standbyTimer = eTimer()
self.delayedInitTimer = eTimer()
self.timer.callback.append(self.poll)
self.standbyTimer.callback.append(self.backToStandby)
self.delayedInitTimer.callback.append(self.init)
self.config = CrossEPG_Config()
self.patchtype = getEPGPatchType()
self.pdownloader = None
self.pimporter = None
self.pconverter = None
self.ploader = None
self.osd = False
self.ontune = False
self.lock = False
self.callLoader = False
if fileExists("/tmp/crossepg.standby"):
# Modded by IAmATeaf 13/04/2012
# os.system("rm -f /tmp/crossepg.standby")
os.unlink("/tmp/crossepg.standby")
print "[CrossEPG_Auto] coming back in standby in 30 seconds"
self.standbyTimer.start(30000, 1)
self.config.load()
def init(self, session = None):
if session != None:
self.session = session
if time() < 1262325600: # if before 2010 probably the clock isn't yet updated
self.delayedInitTimer.start(60000, 1) #initialization delayed of 1 minute
return
if self.config.force_load_on_boot:
self.callLoader = True
print"[CrossEPG_Auto] force_load_on_boot enabled"
if self.config.isQBOXHD():
# on qboxhd, delay initialization. this patch may be helpful for other decoders aswell....
self.config.force_load_on_boot = 0
print"[CrossEPG_Auto] running on qboxhd"
self.delayedInitTimer.start(10000, 1)
return
if self.callLoader == True:
self.loader()
self.resetDailyDownloadDateCache()
self.timer.start(self.POLL_TIMER_BOOT, 1)
def forcePoll(self):
self.timer.stop()
self.resetDailyDownloadDateCache()
self.timer.start(self.POLL_TIMER_FAST, 1)
def resetDailyDownloadDateCache(self):
self.config.load()
now = time()
ttime = localtime(now)
ltime = (ttime[0], ttime[1], ttime[2], self.config.download_daily_hours, self.config.download_daily_minutes, 0, ttime[6], ttime[7], ttime[8])
stime = mktime(ltime)
if stime < now:
ttime = localtime(stime+86400) # 24 hours in future
# to avoid problems with internal clock (big changes on date/time)
# we step forward of 24 hours until the new time is greater than now
while ttime < now:
ttime = ttime+86400 # 24 hours in future
self.cacheYear = ttime[0]
self.cacheMonth = ttime[1]
self.cacheDay = ttime[2]
def poll(self):
from Screens.Standby import inStandby
try:
self.config.load()
if self.lock:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER_FAST, 1)
elif self.session.nav.RecordTimer.isRecording() or abs(self.session.nav.RecordTimer.getNextRecordingTime() - time()) <= 900 or abs(self.session.nav.RecordTimer.getNextZapTime() - time()) <= 900:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
elif self.config.download_standby_enabled and inStandby:
self.providers = []
now = time()
if self.config.last_full_download_timestamp <= now - (24*60*60):
self.config.last_full_download_timestamp = now
self.config.last_partial_download_timestamp = now
self.config.save()
self.providers = self.config.providers
elif self.config.last_partial_download_timestamp <= now - (60*60): # skip xmltv... we download it only one time a day
self.config.last_partial_download_timestamp = now
self.config.save()
providers = self.config.getAllProviders()
i = 0
for provider in providers[0]:
if self.config.providers.count(provider) > 0:
if providers[2][i] == "opentv":
self.providers.append(provider)
else:
print "[CrossEPG_Auto] is not OpenTV : skip provider %s (we download it only one time a day)" % provider
i += 1
if len(self.providers) == 0:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
else:
print "[CrossEPG_Auto] automatic download in standby"
self.osd = False
self.ontune = False
self.config.deleteLog()
self.download(self.providers)
elif self.config.download_daily_enabled:
now = time()
ttime = localtime(now)
ltime = (self.cacheYear, self.cacheMonth, self.cacheDay, self.config.download_daily_hours, self.config.download_daily_minutes, 0, ttime[6], ttime[7], ttime[8])
stime = mktime(ltime)
if stime < now and self.config.last_full_download_timestamp != stime:
from Screens.Standby import inStandby
self.osd = (inStandby == None)
self.ontune = False
self.config.last_full_download_timestamp = stime
self.config.last_partial_download_timestamp = stime
self.config.save()
ttime = localtime(stime+86400) # 24 hours in future
# to avoid problems with internal clock (big changes on date/time)
# we step forward of 24 hours until the new time is greater than now
while ttime < now:
ttime = ttime+86400 # 24 hours in future
self.cacheYear = ttime[0]
self.cacheMonth = ttime[1]
self.cacheDay = ttime[2]
self.config.deleteLog()
self.download(self.config.providers)
elif stime < now + (self.POLL_TIMER / 1000) and self.config.last_full_download_timestamp != stime:
print "[CrossEPG_Auto] poll"
delta = int(stime - now);
self.timer.start((delta + 5)*1000, 1) # 5 seconds offset
else:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
elif self.config.download_tune_enabled:
now = time()
if self.config.last_partial_download_timestamp <= now - (60*60):
providerok = None
sservice = self.session.nav.getCurrentlyPlayingServiceReference()
if sservice:
service = sservice.toString()
providers = self.config.getAllProviders()
i = 0
for provider in providers[0]:
if providers[2][i] == "opentv":
if self.config.getChannelID(provider) == service:
providerok = provider
break;
i += 1
if providerok:
print "[CrossEPG_Auto] automatic download on tune"
self.osd = False
self.ontune = True
self.config.last_partial_download_timestamp = now
self.config.save()
self.config.deleteLog()
self.download([provider,])
else:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
else:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
else:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
except:
self.timer.start(self.POLL_TIMER,1)
pass
def download(self, providers):
print "[CrossEPG_Auto] providers selected for download:"
for provider in providers:
print "[CrossEPG_Auto] %s" % provider
if self.osd:
self.session.openWithCallback(self.downloadCallback, CrossEPG_Downloader, providers)
else:
self.pdownloader = CrossEPG_Downloader(self.session, providers, self.downloadCallback, True)
def downloadCallback(self, ret):
self.pdownloader = None
from Screens.Standby import inStandby
if inStandby: # if in standby force service stop
self.session.nav.stopService()
if ret:
if self.config.csv_import_enabled == 1 and not self.ontune:
self.importer()
else:
if self.patchtype != 3:
self.converter()
else:
self.loader()
else:
self.timer.start(self.POLL_TIMER, 1)
def importer(self):
print "[CrossEPG_Auto] start csv import"
if self.osd:
self.session.openWithCallback(self.importerCallback, CrossEPG_Importer)
else:
self.pimporter = CrossEPG_Importer(self.session, self.importerCallback, True)
def importerCallback(self, ret):
self.pimporter = None
if ret:
if self.patchtype != 3:
self.converter()
else:
self.loader()
else:
self.timer.start(self.POLL_TIMER, 1)
def converter(self):
print "[CrossEPG_Auto] start epg.dat conversion"
if self.osd:
self.session.openWithCallback(self.converterCallback, CrossEPG_Converter)
else:
self.pconverter = CrossEPG_Converter(self.session, self.converterCallback, True)
def converterCallback(self, ret):
self.pconverter = None
if ret:
if self.patchtype != -1:
self.loader()
else:
if self.config.download_daily_reboot:
from Screens.Standby import inStandby
if inStandby:
# Modded by IAmATeaf 13/04/2012
# os.system("touch /tmp/crossepg.standby")
open("/tmp/crossepg.standby", "wb").close()
else:
# Modded by IAmATeaf 13/04/2012
# os.system("rm /tmp/crossepg.standby")
os.unlink("/tmp/crossepg.standby")
print "[CrossEPG_Auto] rebooting"
from Screens.Standby import TryQuitMainloop
self.session.open(TryQuitMainloop, 3)
else:
self.timer.start(self.POLL_TIMER, 1)
else:
self.timer.start(self.POLL_TIMER, 1)
def loader(self):
if self.osd:
print "[CrossEPG_Auto] calling CrossEPG_Loader with callback"
self.session.openWithCallback(self.loaderCallback, CrossEPG_Loader)
else:
print "[CrossEPG_Auto] calling CrossEPG_Loader directly"
self.ploader = CrossEPG_Loader(self.session, self.loaderCallback, True)
def loaderCallback(self, ret):
self.ploader = None
self.timer.start(self.POLL_TIMER, 1)
def stop(self):
if self.pdownloader:
self.pdownloader.quit()
self.pdownloader = None
if self.pimporter:
self.pimporter.quit()
self.pimporter = None
if self.pconverter:
self.pconverter.quit()
self.pconverter = None
if self.ploader:
self.ploader.quit()
self.ploader = None
def backToStandby(self):
from Screens.Standby import inStandby
if inStandby == None:
print "[CrossEPG_Auto] coming back in standby"
from Screens.Standby import Standby
self.session.open(Standby)
def loader(self): if self.osd: self.session.openWithCallback(self.loaderCallback, CrossEPG_Loader) else: self.ploader = CrossEPG_Loader(self.session, self.loaderCallback, True)
class CrossEPG_Auto(Screen):
POLL_TIMER = 1800000 # poll every 30 minutes
#POLL_TIMER = 18000
POLL_TIMER_FAST = 10000 # poll every 10 seconds
POLL_TIMER_BOOT = 60000 # poll every 1 minute
def __init__(self):
self.session = None
self.timer = eTimer()
self.standbyTimer = eTimer()
self.delayedInitTimer = eTimer()
self.timer.callback.append(self.poll)
self.standbyTimer.callback.append(self.backToStandby)
self.delayedInitTimer.callback.append(self.init)
self.config = CrossEPG_Config()
self.patchtype = getEPGPatchType()
self.pdownloader = None
self.pimporter = None
self.pconverter = None
self.ploader = None
self.osd = False
self.ontune = False
self.lock = False
if fileExists("/tmp/crossepg.standby"):
# Modded by IAmATeaf 13/04/2012
# os.system("rm -f /tmp/crossepg.standby")
os.unlink("/tmp/crossepg.standby")
print "[CrossEPG_Auto] coming back in standby in 30 seconds"
self.standbyTimer.start(30000, 1)
self.config.load()
if self.config.force_load_on_boot:
self.loader()
def init(self, session = None):
if session != None:
self.session = session
if time() < 1262325600: # if before 2010 probably the clock isn't yet updated
self.delayedInitTimer.start(60000, 1) #initialization delayed of 1 minute
return
self.resetDailyDownloadDateCache()
self.timer.start(self.POLL_TIMER_BOOT, 1)
def forcePoll(self):
self.timer.stop()
self.resetDailyDownloadDateCache()
self.timer.start(self.POLL_TIMER_FAST, 1)
def resetDailyDownloadDateCache(self):
self.config.load()
now = time()
ttime = localtime(now)
ltime = (ttime[0], ttime[1], ttime[2], self.config.download_daily_hours, self.config.download_daily_minutes, 0, ttime[6], ttime[7], ttime[8])
stime = mktime(ltime)
if stime < now:
ttime = localtime(stime+86400) # 24 hours in future
# to avoid problems with internal clock (big changes on date/time)
# we step forward of 24 hours until the new time is greater than now
while ttime < now:
ttime = ttime+86400 # 24 hours in future
self.cacheYear = ttime[0]
self.cacheMonth = ttime[1]
self.cacheDay = ttime[2]
def poll(self):
from Screens.Standby import inStandby
self.config.load()
if self.lock:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER_FAST, 1)
elif self.session.nav.RecordTimer.isRecording() or abs(self.session.nav.RecordTimer.getNextRecordingTime() - time()) <= 900 or abs(self.session.nav.RecordTimer.getNextZapTime() - time()) <= 900:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
elif self.config.download_standby_enabled and inStandby:
self.providers = []
now = time()
if self.config.last_full_download_timestamp <= now - (24*60*60):
self.config.last_full_download_timestamp = now
self.config.last_partial_download_timestamp = now
self.config.save()
self.providers = self.config.providers
elif self.config.last_partial_download_timestamp <= now - (60*60): # skip xmltv... we download it only one time a day
self.config.last_partial_download_timestamp = now
self.config.save()
providers = self.config.getAllProviders()
i = 0
for provider in providers[0]:
if self.config.providers.count(provider) > 0:
if providers[2][i] == "opentv":
self.providers.append(provider)
else:
print "[CrossEPG_Auto] is not OpenTV : skip provider %s (we download it only one time a day)" % provider
i += 1
if len(self.providers) == 0:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
else:
print "[CrossEPG_Auto] automatic download in standby"
self.osd = False
self.ontune = False
self.config.deleteLog()
self.download(self.providers)
elif self.config.download_daily_enabled:
now = time()
ttime = localtime(now)
ltime = (self.cacheYear, self.cacheMonth, self.cacheDay, self.config.download_daily_hours, self.config.download_daily_minutes, 0, ttime[6], ttime[7], ttime[8])
stime = mktime(ltime)
if stime < now and self.config.last_full_download_timestamp != stime:
from Screens.Standby import inStandby
self.osd = (inStandby == None)
self.ontune = False
self.config.last_full_download_timestamp = stime
self.config.last_partial_download_timestamp = stime
self.config.save()
ttime = localtime(stime+86400) # 24 hours in future
# to avoid problems with internal clock (big changes on date/time)
# we step forward of 24 hours until the new time is greater than now
while ttime < now:
ttime = ttime+86400 # 24 hours in future
self.cacheYear = ttime[0]
self.cacheMonth = ttime[1]
self.cacheDay = ttime[2]
self.config.deleteLog()
self.download(self.config.providers)
elif stime < now + (self.POLL_TIMER / 1000) and self.config.last_full_download_timestamp != stime:
print "[CrossEPG_Auto] poll"
delta = int(stime - now);
self.timer.start((delta + 5)*1000, 1) # 5 seconds offset
else:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
elif self.config.download_tune_enabled:
now = time()
if self.config.last_partial_download_timestamp <= now - (60*60):
providerok = None
sservice = self.session.nav.getCurrentlyPlayingServiceReference()
if sservice:
service = sservice.toString()
providers = self.config.getAllProviders()
i = 0
for provider in providers[0]:
if providers[2][i] == "opentv":
if self.config.getChannelID(provider) == service:
providerok = provider
break;
i += 1
if providerok:
print "[CrossEPG_Auto] automatic download on tune"
self.osd = False
self.ontune = True
self.config.last_partial_download_timestamp = now
self.config.save()
self.config.deleteLog()
self.download([provider,])
else:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
else:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
else:
print "[CrossEPG_Auto] poll"
self.timer.start(self.POLL_TIMER, 1)
def download(self, providers):
print "[CrossEPG_Auto] providers selected for download:"
for provider in providers:
print "[CrossEPG_Auto] %s" % provider
if self.osd:
self.session.openWithCallback(self.downloadCallback, CrossEPG_Downloader, providers)
else:
self.pdownloader = CrossEPG_Downloader(self.session, providers, self.downloadCallback, True)
def downloadCallback(self, ret):
self.pdownloader = None
from Screens.Standby import inStandby
if inStandby: # if in standby force service stop
self.session.nav.stopService()
if ret:
if self.config.csv_import_enabled == 1 and not self.ontune:
self.importer()
else:
if self.patchtype != 3:
self.converter()
else:
self.loader()
else:
self.timer.start(self.POLL_TIMER, 1)
def importer(self):
print "[CrossEPG_Auto] start csv import"
if self.osd:
self.session.openWithCallback(self.importerCallback, CrossEPG_Importer)
else:
self.pimporter = CrossEPG_Importer(self.session, self.importerCallback, True)
def importerCallback(self, ret):
self.pimporter = None
if ret:
if self.patchtype != 3:
self.converter()
else:
self.loader()
else:
self.timer.start(self.POLL_TIMER, 1)
def converter(self):
print "[CrossEPG_Auto] start epg.dat conversion"
if self.osd:
self.session.openWithCallback(self.converterCallback, CrossEPG_Converter)
else:
self.pconverter = CrossEPG_Converter(self.session, self.converterCallback, True)
def converterCallback(self, ret):
self.pconverter = None
if ret:
if self.patchtype != -1:
self.loader()
else:
if self.config.download_daily_reboot:
from Screens.Standby import inStandby
if inStandby:
# Modded by IAmATeaf 13/04/2012
# os.system("touch /tmp/crossepg.standby")
open("/tmp/crossepg.standby", "wb").close()
else:
# Modded by IAmATeaf 13/04/2012
# os.system("rm /tmp/crossepg.standby")
os.unlink("/tmp/crossepg.standby")
print "[CrossEPG_Auto] rebooting"
from Screens.Standby import TryQuitMainloop
self.session.open(TryQuitMainloop, 3)
else:
self.timer.start(self.POLL_TIMER, 1)
else:
self.timer.start(self.POLL_TIMER, 1)
def loader(self):
if self.osd:
self.session.openWithCallback(self.loaderCallback, CrossEPG_Loader)
else:
self.ploader = CrossEPG_Loader(self.session, self.loaderCallback, True)
def loaderCallback(self, ret):
self.ploader = None
self.timer.start(self.POLL_TIMER, 1)
def stop(self):
if self.pdownloader:
self.pdownloader.quit()
self.pdownloader = None
if self.pimporter:
self.pimporter.quit()
self.pimporter = None
if self.pconverter:
self.pconverter.quit()
self.pconverter = None
if self.ploader:
self.ploader.quit()
self.ploader = None
def backToStandby(self):
from Screens.Standby import inStandby
if inStandby == None:
print "[CrossEPG_Auto] coming back in standby"
from Screens.Standby import Standby
self.session.open(Standby)
class CrossEPG_Auto:
instance = None
def __init__(self, session):
self.session = session
self.crossepgtimer = eTimer()
self.crossepgtimer.callback.append(self.CrossEPGonTimer)
self.crossepgactivityTimer = eTimer()
self.crossepgactivityTimer.timeout.get().append(self.crossepgdatedelay)
self.config = CrossEPG_Config()
self.patchtype = getEPGPatchType()
self.pdownloader = None
self.pimporter = None
self.pconverter = None
self.ploader = None
self.pdefrag = None
self.osd = False
self.lock = False
if fileExists("/tmp/crossepg.standby"):
# Modded by IAmATeaf 13/04/2012
# os.system("rm -f /tmp/crossepg.standby")
os.unlink("/tmp/crossepg.standby")
print "[CrossEPG_Auto] coming back in standby in 30 seconds"
self.standbyTimer.start(30000, 1)
self.config.load()
if self.config.force_load_on_boot:
self.loader()
now = int(time())
global CrossEPGTime
if self.config.download_standby_enabled or self.config.download_daily_enabled:
print "[CrossEPG_Auto] Schedule Enabled at ", strftime(
"%c", localtime(now))
if now > 1262304000:
self.crossepgdate()
else:
print "[CrossEPG_Auto] Time not yet set."
CrossEPGTime = 0
self.crossepgactivityTimer.start(36000)
else:
CrossEPGTime = 0
print "[CrossEPG_Auto] Schedule Disabled at", strftime(
"%c", localtime(now))
self.crossepgactivityTimer.stop()
assert CrossEPG_Auto.instance is None, "class CrossEPG_Auto is a singleton class and just one instance of this class is allowed!"
CrossEPG_Auto.instance = self
def __onClose(self):
CrossEPG_Auto.instance = None
def forcePoll(self):
self.crossepgtimer.start(10)
def crossepgdatedelay(self):
self.crossepgactivityTimer.stop()
self.crossepgdate()
def getCrossEPGTime(self):
self.config.load()
nowt = time()
now = localtime(nowt)
return int(
mktime((now.tm_year, now.tm_mon, now.tm_mday,
self.config.download_daily_hours,
self.config.download_daily_minutes, 0, now.tm_wday,
now.tm_yday, now.tm_isdst)))
def crossepgdate(self, atLeast=0):
self.crossepgtimer.stop()
global CrossEPGTime
CrossEPGTime = self.getCrossEPGTime()
now = int(time())
if CrossEPGTime > 0:
if CrossEPGTime < now + atLeast:
if self.config.download_daily_enabled:
CrossEPGTime += 24 * 3600
while (int(CrossEPGTime) - 30) < now:
CrossEPGTime += 24 * 3600
elif self.config.download_standby_enabled:
CrossEPGTime += 3600
while (int(CrossEPGTime) - 30) < now:
CrossEPGTime += 3600
next = CrossEPGTime - now
self.crossepgtimer.startLongTimer(next)
else:
CrossEPGTime = -1
print "[CrossEPG_Auto] Time set to", strftime(
"%c", localtime(CrossEPGTime)), strftime("(now=%c)",
localtime(now))
return CrossEPGTime
def backupstop(self):
self.crossepgtimer.stop()
def CrossEPGonTimer(self):
self.crossepgtimer.stop()
now = int(time())
wake = self.getCrossEPGTime()
# If we're close enough, we're okay...
atLeast = 0
if wake - now < 60:
atLeast = 60
print "[CrossEPG_Auto] onTimer occured at", strftime(
"%c", localtime(now))
from Screens.Standby import inStandby
self.config.load()
if (self.config.download_standby_enabled
and inStandby) or self.config.download_daily_enabled:
if self.lock or self.session.nav.RecordTimer.isRecording(
) or abs(self.session.nav.RecordTimer.getNextRecordingTime() -
time()) <= 900 or abs(
self.session.nav.RecordTimer.getNextZapTime() -
time()) <= 900:
print "[CrossEPG_Auto] poll delaying as recording."
self.doCrossEPG(False)
elif not inStandby:
message = _(
"Your epg about to update,\nDo you want to allow this?"
)
ybox = self.session.openWithCallback(self.doCrossEPG,
MessageBox,
message,
MessageBox.TYPE_YESNO,
timeout=30)
ybox.setTitle('Scheduled CrossEPG.')
else:
self.doCrossEPG(True)
self.crossepgdate(atLeast)
def doCrossEPG(self, answer):
global retrycount
now = int(time())
if answer is False:
if retrycount < 2:
print '[CrossEPG_Auto] Number of retries', retrycount
print "[CrossEPG_Auto] delayed."
repeat = retrycount
repeat += 1
retrycount = repeat
CrossEPGTime = now + (30 * 60)
print "[CrossEPG_Auto] Time now set to", strftime(
"%c",
localtime(CrossEPGTime)), strftime("(now=%c)",
localtime(now))
self.crossepgtimer.startLongTimer(30 * 60)
else:
atLeast = 60
print "[CrossEPG_Auto] Enough Retries, delaying till next schedule.", strftime(
"%c", localtime(now))
self.session.open(
MessageBox,
_("Enough Retries, delaying till next schedule."),
MessageBox.TYPE_INFO,
timeout=10)
retrycount = 0
self.crossepgdate(atLeast)
else:
self.timer = eTimer()
self.timer.callback.append(self.doautostartdownload)
print "[CrossEPG_Auto] Running CrossEPG", strftime(
"%c", localtime(now))
self.timer.start(100, 1)
def doautostartdownload(self):
self.config.load()
from Screens.Standby import inStandby
if self.config.download_standby_enabled and inStandby:
self.osd = False
elif self.config.download_daily_enabled:
self.osd = (inStandby == None)
self.config.deleteLog()
self.download(self.config.providers)
def download(self, providers):
print "[CrossEPG_Auto] providers selected for download:"
for provider in providers:
print "[CrossEPG_Auto] %s" % provider
if self.osd:
self.session.openWithCallback(self.downloadCallback,
CrossEPG_Downloader, providers)
else:
self.pdownloader = CrossEPG_Downloader(self.session, providers,
self.downloadCallback, True)
def downloadCallback(self, ret):
self.pdownloader = None
if ret:
if self.config.csv_import_enabled == 1:
self.importer()
else:
if self.patchtype != 3:
self.converter()
else:
self.loader()
def defrag(self):
if self.config.last_defrag_timestamp < time(
) - 7 * 24 * 60 * 60: # 1 week
print "[CrossEPG_Auto] start defragmentation"
if self.osd:
self.session.openWithCallback(self.defragCallback,
CrossEPG_Defragmenter)
else:
self.pdefrag = CrossEPG_Defragmenter(self.session,
self.defragCallback, True)
self.config.last_defrag_timestamp = time()
self.config.save()
def defragCallback(self, ret):
self.pdefrag = None
def importer(self):
print "[CrossEPG_Auto] start csv import"
if self.osd:
self.session.openWithCallback(self.importerCallback,
CrossEPG_Importer)
else:
self.pimporter = CrossEPG_Importer(self.session,
self.importerCallback, True)
def importerCallback(self, ret):
self.pimporter = None
if ret:
if self.patchtype != 3:
self.converter()
else:
self.loader()
def converter(self):
print "[CrossEPG_Auto] start epg.dat conversion"
if self.osd:
self.session.openWithCallback(self.converterCallback,
CrossEPG_Converter)
else:
self.pconverter = CrossEPG_Converter(self.session,
self.converterCallback, True)
def converterCallback(self, ret):
self.pconverter = None
if ret:
if self.patchtype != -1:
self.loader()
else:
if self.config.download_daily_reboot:
from Screens.Standby import inStandby
if inStandby:
# Modded by IAmATeaf 13/04/2012
# os.system("touch /tmp/crossepg.standby")
open("/tmp/crossepg.standby", "wb").close()
else:
# Modded by IAmATeaf 13/04/2012
# os.system("rm /tmp/crossepg.standby")
os.unlink("/tmp/crossepg.standby")
print "[CrossEPG_Auto] rebooting"
from Screens.Standby import TryQuitMainloop
self.session.open(TryQuitMainloop, 3)
def loader(self):
if self.osd:
self.session.openWithCallback(self.loaderCallback, CrossEPG_Loader)
else:
self.ploader = CrossEPG_Loader(self.session, self.loaderCallback,
True)
def loaderCallback(self, ret):
self.ploader = None
self.defrag()
def stop(self):
if self.pdownloader:
self.pdownloader.quit()
self.pdownloader = None
if self.pimporter:
self.pimporter.quit()
self.pimporter = None
if self.pconverter:
self.pconverter.quit()
self.pconverter = None
if self.ploader:
self.ploader.quit()
self.ploader = None
if self.pdefrag:
self.pdefrag.quit()
self.pdefrag = None
def backToStandby(self):
from Screens.Standby import inStandby
if inStandby == None:
print "[CrossEPG_Auto] coming back in standby"
from Screens.Standby import Standby
self.session.open(Standby)
def doneConfiguring(self):
now = int(time())
if self.config.download_standby_enabled or self.config.download_daily_enabled:
if autoCrossEPGTimer is not None:
print "[CrossEPG_Auto] Schedule Enabled at", strftime(
"%c", localtime(now))
autoCrossEPGTimer.crossepgdate()
else:
if autoCrossEPGTimer is not None:
global CrossEPGTime
CrossEPGTime = 0
print "[CrossEPG_Auto] Schedule Disabled at", strftime(
"%c", localtime(now))
autoCrossEPGTimer.backupstop()
if CrossEPGTime > 0:
t = localtime(CrossEPGTime)
crossepgtext = strftime(_("%a %e %b %-H:%M"), t)
else:
crossepgtext = ""
class CrossEPG_Auto:
instance = None
def __init__(self, session):
self.session = session
self.crossepgtimer = eTimer()
self.crossepgtimer.callback.append(self.CrossEPGonTimer)
self.crossepgactivityTimer = eTimer()
self.crossepgactivityTimer.timeout.get().append(self.crossepgdatedelay)
self.config = CrossEPG_Config()
self.patchtype = getEPGPatchType()
self.pdownloader = None
self.pimporter = None
self.pconverter = None
self.ploader = None
self.pdefrag = None
self.osd = False
self.lock = False
if fileExists("/tmp/crossepg.standby"):
# Modded by IAmATeaf 13/04/2012
# os.system("rm -f /tmp/crossepg.standby")
os.unlink("/tmp/crossepg.standby")
print "[CrossEPG_Auto] coming back in standby in 30 seconds"
self.standbyTimer.start(30000, 1)
self.config.load()
if self.config.force_load_on_boot:
self.loader()
now = int(time())
global CrossEPGTime
if self.config.download_standby_enabled or self.config.download_daily_enabled:
print "[CrossEPG_Auto] Schedule Enabled at ", strftime("%c", localtime(now))
if now > 1262304000:
self.crossepgdate()
else:
print "[CrossEPG_Auto] Time not yet set."
CrossEPGTime = 0
self.crossepgactivityTimer.start(36000)
else:
CrossEPGTime = 0
print "[CrossEPG_Auto] Schedule Disabled at", strftime("%c", localtime(now))
self.crossepgactivityTimer.stop()
assert CrossEPG_Auto.instance is None, "class CrossEPG_Auto is a singleton class and just one instance of this class is allowed!"
CrossEPG_Auto.instance = self
def __onClose(self):
CrossEPG_Auto.instance = None
def forcePoll(self):
self.crossepgtimer.start(10)
def crossepgdatedelay(self):
self.crossepgactivityTimer.stop()
self.crossepgdate()
def getCrossEPGTime(self):
self.config.load()
nowt = time()
now = localtime(nowt)
return int(mktime((now.tm_year, now.tm_mon, now.tm_mday, self.config.download_daily_hours, self.config.download_daily_minutes, 0, now.tm_wday, now.tm_yday, now.tm_isdst)))
def crossepgdate(self, atLeast = 0):
self.crossepgtimer.stop()
global CrossEPGTime
CrossEPGTime = self.getCrossEPGTime()
now = int(time())
if CrossEPGTime > 0:
if CrossEPGTime < now + atLeast:
if self.config.download_daily_enabled:
CrossEPGTime += 24*3600
while (int(CrossEPGTime)-30) < now:
CrossEPGTime += 24*3600
elif self.config.download_standby_enabled:
CrossEPGTime += 3600
while (int(CrossEPGTime)-30) < now:
CrossEPGTime += 3600
next = CrossEPGTime - now
self.crossepgtimer.startLongTimer(next)
else:
CrossEPGTime = -1
print "[CrossEPG_Auto] Time set to", strftime("%c", localtime(CrossEPGTime)), strftime("(now=%c)", localtime(now))
return CrossEPGTime
def backupstop(self):
self.crossepgtimer.stop()
def CrossEPGonTimer(self):
self.crossepgtimer.stop()
now = int(time())
wake = self.getCrossEPGTime()
# If we're close enough, we're okay...
atLeast = 0
if wake - now < 60:
atLeast = 60
print "[CrossEPG_Auto] onTimer occured at", strftime("%c", localtime(now))
from Screens.Standby import inStandby
self.config.load()
if (self.config.download_standby_enabled and inStandby) or self.config.download_daily_enabled:
if self.lock or self.session.nav.RecordTimer.isRecording() or abs(self.session.nav.RecordTimer.getNextRecordingTime() - time()) <= 900 or abs(self.session.nav.RecordTimer.getNextZapTime() - time()) <= 900:
print "[CrossEPG_Auto] poll delaying as recording."
self.doCrossEPG(False)
elif not inStandby:
message = _("Your epg about to update,\nDo you want to allow this?")
ybox = self.session.openWithCallback(self.doCrossEPG, MessageBox, message, MessageBox.TYPE_YESNO, timeout = 30)
ybox.setTitle('Scheduled CrossEPG.')
else:
self.doCrossEPG(True)
self.crossepgdate(atLeast)
def doCrossEPG(self, answer):
global retrycount
now = int(time())
if answer is False:
if retrycount < 2:
print '[CrossEPG_Auto] Number of retries',retrycount
print "[CrossEPG_Auto] delayed."
repeat = retrycount
repeat += 1
retrycount = repeat
CrossEPGTime = now + (30 * 60)
print "[CrossEPG_Auto] Time now set to", strftime("%c", localtime(CrossEPGTime)), strftime("(now=%c)", localtime(now))
self.crossepgtimer.startLongTimer(30 * 60)
else:
atLeast = 60
print "[CrossEPG_Auto] Enough Retries, delaying till next schedule.", strftime("%c", localtime(now))
self.session.open(MessageBox, _("Enough Retries, delaying till next schedule."), MessageBox.TYPE_INFO, timeout = 10)
retrycount = 0
self.crossepgdate(atLeast)
else:
self.timer = eTimer()
self.timer.callback.append(self.doautostartdownload)
print "[CrossEPG_Auto] Running CrossEPG", strftime("%c", localtime(now))
self.timer.start(100, 1)
def doautostartdownload(self):
self.config.load()
from Screens.Standby import inStandby
if self.config.download_standby_enabled and inStandby:
self.osd = False
elif self.config.download_daily_enabled:
self.osd = (inStandby == None)
self.config.deleteLog()
self.download(self.config.providers)
def download(self, providers):
print "[CrossEPG_Auto] providers selected for download:"
for provider in providers:
print "[CrossEPG_Auto] %s" % provider
if self.osd:
self.session.openWithCallback(self.downloadCallback, CrossEPG_Downloader, providers)
else:
self.pdownloader = CrossEPG_Downloader(self.session, providers, self.downloadCallback, True)
def downloadCallback(self, ret):
self.pdownloader = None
if ret:
if self.config.csv_import_enabled == 1:
self.importer()
else:
if self.patchtype != 3:
self.converter()
else:
self.loader()
def defrag(self):
if self.config.last_defrag_timestamp < time() - 7 * 24 * 60 * 60: # 1 week
print "[CrossEPG_Auto] start defragmentation"
if self.osd:
self.session.openWithCallback(self.defragCallback, CrossEPG_Defragmenter)
else:
self.pdefrag = CrossEPG_Defragmenter(self.session, self.defragCallback, True)
self.config.last_defrag_timestamp = time()
self.config.save()
def defragCallback(self, ret):
self.pdefrag = None
def importer(self):
print "[CrossEPG_Auto] start csv import"
if self.osd:
self.session.openWithCallback(self.importerCallback, CrossEPG_Importer)
else:
self.pimporter = CrossEPG_Importer(self.session, self.importerCallback, True)
def importerCallback(self, ret):
self.pimporter = None
if ret:
if self.patchtype != 3:
self.converter()
else:
self.loader()
def converter(self):
print "[CrossEPG_Auto] start epg.dat conversion"
if self.osd:
self.session.openWithCallback(self.converterCallback, CrossEPG_Converter)
else:
self.pconverter = CrossEPG_Converter(self.session, self.converterCallback, True)
def converterCallback(self, ret):
self.pconverter = None
if ret:
if self.patchtype != -1:
self.loader()
else:
if self.config.download_daily_reboot:
from Screens.Standby import inStandby
if inStandby:
# Modded by IAmATeaf 13/04/2012
# os.system("touch /tmp/crossepg.standby")
open("/tmp/crossepg.standby", "wb").close()
else:
# Modded by IAmATeaf 13/04/2012
# os.system("rm /tmp/crossepg.standby")
os.unlink("/tmp/crossepg.standby")
print "[CrossEPG_Auto] rebooting"
from Screens.Standby import TryQuitMainloop
self.session.open(TryQuitMainloop, 3)
def loader(self):
if self.osd:
self.session.openWithCallback(self.loaderCallback, CrossEPG_Loader)
else:
self.ploader = CrossEPG_Loader(self.session, self.loaderCallback, True)
def loaderCallback(self, ret):
self.ploader = None
self.defrag()
def stop(self):
if self.pdownloader:
self.pdownloader.quit()
self.pdownloader = None
if self.pimporter:
self.pimporter.quit()
self.pimporter = None
if self.pconverter:
self.pconverter.quit()
self.pconverter = None
if self.ploader:
self.ploader.quit()
self.ploader = None
if self.pdefrag:
self.pdefrag.quit()
self.pdefrag = None
def backToStandby(self):
from Screens.Standby import inStandby
if inStandby == None:
print "[CrossEPG_Auto] coming back in standby"
from Screens.Standby import Standby
self.session.open(Standby)
def doneConfiguring(self):
now = int(time())
if self.config.download_standby_enabled or self.config.download_daily_enabled:
if autoCrossEPGTimer is not None:
print "[CrossEPG_Auto] Schedule Enabled at", strftime("%c", localtime(now))
autoCrossEPGTimer.crossepgdate()
else:
if autoCrossEPGTimer is not None:
global CrossEPGTime
CrossEPGTime = 0
print "[CrossEPG_Auto] Schedule Disabled at", strftime("%c", localtime(now))
autoCrossEPGTimer.backupstop()
if CrossEPGTime > 0:
t = localtime(CrossEPGTime)
crossepgtext = strftime(_("%a %e %b %-H:%M"), t)
else:
crossepgtext = ""